Class QuickJSRuntime

src/node/services/ptc/quickjsRuntime.ts:32–576

 * Uses Asyncify build for async host function support.
 */
export class QuickJSRuntime implements IJSRuntime {
  private disposed = false;
  private eventHandler?: (event: PTCEvent) => void;
  private abortController?: AbortController;
  private abortRequested = false; // Track abort requests before eval() starts
  private limits: RuntimeLimits = {};
  private consoleSetup = false;

  // Execution state (reset per eval)
  private toolCalls: PTCToolCallRecord[] = [];
  private consoleOutput: PTCConsoleRecord[] = [];

  private constructor(private readonly ctx: QuickJSAsyncContext) {}

  static async create(): Promise<QuickJSRuntime> {
    // Create the async variant manually due to bun's package export resolution issues.
    // The self-referential import in the variant package doesn't resolve correctly.
    const variant = {
      type: "async" as const,
      importFFI: () => Promise.resolve(QuickJSAsyncFFI),
      // eslint-disable-next-line @typescript-eslint/require-await -- sync require wrapped for interface
      importModuleLoader: async () => {
        // Use require() with the named export path since bun's dynamic import()
        // doesn't resolve package exports correctly from within node_modules
        // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment
        const mod = require("@jitl/quickjs-wasmfile-release-asyncify/emscripten-module");
        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return
        return mod.default ?? mod;
      },
    };

    const QuickJS = await newQuickJSAsyncWASMModuleFromVariant(variant);
    const ctx = QuickJS.newContext();
    return new QuickJSRuntime(ctx);
  }

  setLimits(limits: RuntimeLimits): void {
    this.limits = limits;

    // Apply memory limit to the runtime
    const memoryBytes = limits.memoryBytes ?? DEFAULT_MEMORY_BYTES;
    this.ctx.runtime.setMemoryLimit(memoryBytes);
  }

  onEvent(handler: (event: PTCEvent) => void): void {
    this.eventHandler = handler;
  }

  registerFunction(name: string, fn: (...args: unknown[]) => Promise<unknown>): void {
    this.assertNotDisposed("registerFunction");

    const handle = this.ctx.newAsyncifiedFunction(name, async (...argHandles) => {
      if (this.abortController?.signal.aborted) {
        throw new Error("Execution aborted");
      }

      // Convert QuickJS handles to JS values - cast to unknown at the FFI boundary
      const args: unknown[] = argHandles.map((h) => this.ctx.dump(h) as unknown);