@modelprofile.com/flexharness 10.12.0 → 10.14.0

package/package.json

@@ -2,7 +2,7 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "name": "@modelprofile.com/flexharness",
-  "version": "10.12.0",
+  "version": "10.14.0",
   "type": "module",
   "description": "Managed agent sessions with tools, MCP, chat, OCR, documents and browser control through focused subpath imports.",
   "main": "./dist_ts/index.js",
@@ -74,8 +74,9 @@
     }
   },
   "dependencies": {
-    "@modelprofile.com/flexharness-agent": "10.12.0",
-    "@modelprofile.com/flexharness-models": "10.12.0",
+    "@cfworker/json-schema": "^4.1.1",
+    "@modelprofile.com/flexharness-agent": "10.14.0",
+    "@modelprofile.com/flexharness-models": "10.14.0",
     "@push.rocks/smartrequest": "^5.5.1",
     "ai": "^7.0.111",
     "zod": "^4.6.5"
@@ -92,7 +93,10 @@
     "lit": "^3.2.0",
     "@types/react": "^19.0.0",
     "@lossless.org/client": "^1.17.0",
-    "@design.estate/dees-catalog": "^17.0.0 || ^19.5.0 || ^20.0.0 || ^21.0.0"
+    "@design.estate/dees-catalog": "^17.0.0 || ^19.5.0 || ^20.0.0 || ^21.0.0",
+    "quickjs-emscripten-core": "^0.32.0",
+    "@jitl/quickjs-ng-wasmfile-release-sync": "^0.32.0",
+    "amaro": "^1.2.1"
   },
   "peerDependenciesMeta": {
     "@modelcontextprotocol/sdk": {
@@ -130,6 +134,15 @@
     },
     "@design.estate/dees-catalog": {
       "optional": true
+    },
+    "quickjs-emscripten-core": {
+      "optional": true
+    },
+    "@jitl/quickjs-ng-wasmfile-release-sync": {
+      "optional": true
+    },
+    "amaro": {
+      "optional": true
     }
   },
   "engines": {

package/readme.md

@@ -1026,7 +1026,7 @@ A `contextCompactor` states which model to compact with from the model the compa
 
 A compactor uses `resolvedModel.model` directly, and resolves `modelHint` the way its model resolver resolves a prompt's `modelHint`. Only when neither member is present, because nothing dispatched states a model, does the host choose the compaction model itself.
 
-A `context-overflow` or `context-budget` compaction also carries `system` and `providerOptions`: the instructions and the provider options (cache options applied, so `store: false` on OpenAI) the run's turns are sent with. `compactMessages()` sends its summary call with them as one streamed call, the shape of every turn, so a compactor that passes its options through reaches the provider the way the run does. Without `system` it sends its own instructions.
+A `context-overflow` or `context-budget` compaction also carries `system` and `providerOptions`: the instructions and the provider options (cache options applied, so `store: false` on OpenAI) the run's turns are sent with. A `context-budget` compaction on a provider that caches the prefix also carries the turns' `tools`. `compactMessages()` sends its summary call with them as one streamed call, the shape of every turn, with the tools' definitions but none of their code, so a compactor that passes its options through repeats the run's prefix and reads it from the provider's prompt cache; definitions that outweigh the history nine times are left out. Without `system` it sends its own instructions.
 
 ```typescript
 agentSessionPolicy: {

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/flexharness',
-  version: '10.12.0',
+  version: '10.14.0',
   description: 'The FlexHarness toolbox source repository and shared dependency catalog.'
 }

package/ts/classes.codesandbox.ts

@@ -0,0 +1,565 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessValidationError } from './errors.js';
+import type { IFlexCodeModeLimits, IFlexCodeRunFailure, TJsonValue } from './interfaces.js';
+
+/** What one catalog call of a program comes to: a JSON value, or the error the program sees. */
+export type TFlexCodeCallOutcome = { ok: true; value: TJsonValue } | { ok: false; error: TJsonValue };
+
+export interface IFlexCodeHost {
+  /**
+   * Runs one catalog call of the program; `signal` aborts when the program stops. A rejection is a
+   * failure of the host, which stops the program and rejects `run()` with it.
+   */
+  call(method: string, params: unknown, signal: AbortSignal): Promise<TFlexCodeCallOutcome>;
+  /** Milliseconds the program has waited for permission decisions; they do not count as wall time. */
+  waitedMs?(): number;
+}
+
+export type TFlexCodeRunResult =
+  | { ok: true; value: TJsonValue; calls: number; logs?: string }
+  | { ok: false; failure: IFlexCodeRunFailure };
+
+type TStop =
+  | { kind: 'limit'; limit: NonNullable<IFlexCodeRunFailure['limit']>; message: string }
+  | { kind: 'aborted'; message: string }
+  | { kind: 'host'; error: unknown };
+
+const programFile = 'program.ts';
+/** How long calls in flight get to settle after their program stopped and their signal aborted. */
+const stopGraceMs = 5_000;
+
+/** Evaluating the prelude, the program's text, or running the program. */
+type TPhase = 'prelude' | 'parse' | 'program';
+const programPrefix = 'globalThis.__flexMain = async function () {\n';
+const programSuffix = '\n};';
+
+/**
+ * Runs in the context before the program: it takes the host functions off the global object and
+ * defines `api`, `ApiError` and `console`. Only strings cross the boundary.
+ */
+const prelude = `'use strict';
+(() => {
+  const call = globalThis.__flexCall;
+  const log = globalThis.__flexLog;
+  const done = globalThis.__flexDone;
+  delete globalThis.__flexCall;
+  delete globalThis.__flexLog;
+  delete globalThis.__flexDone;
+  class ApiError extends Error {
+    constructor(details) {
+      const message = details && typeof details.message === 'string' ? details.message : JSON.stringify(details);
+      super(message);
+      this.name = 'ApiError';
+      this.details = details;
+    }
+  }
+  const invoke = (path, args) => {
+    if (!path) return Promise.reject(new TypeError('Call a method as api.<namespace>.<method>(params).'));
+    let params;
+    try {
+      params = JSON.stringify(args.length === 0 || args[0] === undefined ? {} : args[0]);
+    } catch (error) {
+      return Promise.reject(new TypeError('The params of ' + path + ' are not JSON: ' + error.message));
+    }
+    return call(path, params === undefined ? 'null' : params).then((text) => {
+      const outcome = JSON.parse(text);
+      if (outcome.ok) return outcome.value;
+      throw new ApiError(outcome.error);
+    });
+  };
+  const target = (path) => new Proxy(function () {}, {
+    get: (_target, key) => typeof key === 'string' && key !== 'then' ? target(path ? path + '.' + key : key) : undefined,
+    apply: (_target, _this, args) => invoke(path, args),
+    set: () => false,
+    defineProperty: () => false,
+    deleteProperty: () => false,
+  });
+  const format = (value) => {
+    if (typeof value === 'string') return value;
+    try {
+      const text = JSON.stringify(value);
+      return text === undefined ? String(value) : text;
+    } catch {
+      return String(value);
+    }
+  };
+  const writer = (level) => (...values) => { log(level, values.map(format).join(' ')); };
+  const fixed = (value) => ({ value, enumerable: false, writable: false, configurable: false });
+  Object.defineProperty(globalThis, 'api', fixed(target('')));
+  Object.defineProperty(globalThis, 'ApiError', fixed(ApiError));
+  Object.defineProperty(globalThis, 'console', fixed(Object.freeze({
+    log: writer('log'), info: writer('info'), warn: writer('warn'), error: writer('error'), debug: writer('debug'),
+  })));
+  const settle = (value) => {
+    try {
+      const text = JSON.stringify({ ok: true, value: value === undefined ? null : value });
+      return text === undefined ? JSON.stringify({ ok: true, value: null }) : text;
+    } catch (error) {
+      return JSON.stringify({ ok: false, name: 'TypeError', message: 'The return value is not JSON: ' + error.message });
+    }
+  };
+  const fail = (error) => JSON.stringify({
+    ok: false,
+    name: error && typeof error.name === 'string' ? error.name : 'Error',
+    message: error && typeof error.message === 'string' ? error.message : String(error),
+    stack: error && typeof error.stack === 'string' ? error.stack : '',
+    ...(error instanceof ApiError ? { details: error.details } : {}),
+  });
+  Object.defineProperty(globalThis, '__flexStart', {
+    configurable: true,
+    value: () => {
+      const main = globalThis.__flexMain;
+      delete globalThis.__flexStart;
+      delete globalThis.__flexMain;
+      main().then(settle, fail).then(done);
+    },
+  });
+})();
+`;
+
+let enginePromise: Promise<plugins.ICodeSandboxEngine> | undefined;
+
+/**
+ * Runs `run_code` programs in QuickJS-ng compiled to WebAssembly: every program in a WebAssembly
+ * instance of its own, with no globals beyond the language, `api`, `ApiError` and `console`, and
+ * every limit of `IFlexCodeModeLimits` enforced. Program types are stripped with amaro first.
+ */
+export class FlexCodeSandbox {
+  private constructor(private readonly engine: plugins.ICodeSandboxEngine) {}
+
+  /** Loads QuickJS and amaro, once per process. */
+  public static async load(): Promise<FlexCodeSandbox> {
+    enginePromise ??= plugins.importCodeSandboxEngine().catch((error: unknown) => {
+      enginePromise = undefined;
+      throw new FlexHarnessValidationError(
+        'Code mode needs the optional peers quickjs-emscripten-core, '
+          + '@jitl/quickjs-ng-wasmfile-release-sync and amaro.',
+        { cause: error },
+      );
+    });
+    return new FlexCodeSandbox(await enginePromise);
+  }
+
+  public run(
+    source: string,
+    host: IFlexCodeHost,
+    limits: Readonly<IFlexCodeModeLimits>,
+    signal?: AbortSignal,
+  ): Promise<TFlexCodeRunResult> {
+    return new CodeRun(this.engine, source, host, limits, signal).start();
+  }
+}
+
+class CodeRun {
+  private runtime?: plugins.IQuickJsRuntime;
+  private vm?: plugins.IQuickJsContext;
+  private readonly deferreds = new Set<plugins.IQuickJsDeferredPromise>();
+  private readonly calls = new AbortController();
+  private readonly queue: Array<() => void> = [];
+  /** Host calls in flight; the run settles only after every one of them did. */
+  private readonly inFlight = new Set<Promise<void>>();
+  private running = 0;
+  private callCount = 0;
+  private cpuMs = 0;
+  private enteredAt?: number;
+  private stop?: TStop;
+  private logs = '';
+  private logBytes = 0;
+  private logsCut = false;
+  private settle!: (result: TFlexCodeRunResult) => void;
+  private reject!: (error: unknown) => void;
+  /** The outcome is decided; the run waits for its calls in flight, then settles. */
+  private closing = false;
+  private finished = false;
+  private broken = false;
+  private wallTimer?: ReturnType<typeof setTimeout>;
+  private readonly startedAt = performance.now();
+
+  constructor(
+    private readonly engine: plugins.ICodeSandboxEngine,
+    private readonly source: string,
+    private readonly host: IFlexCodeHost,
+    private readonly limits: Readonly<IFlexCodeModeLimits>,
+    private readonly signal: AbortSignal | undefined,
+  ) {}
+
+  public async start(): Promise<TFlexCodeRunResult> {
+    if (Buffer.byteLength(this.source, 'utf8') > this.limits.maxSourceBytes) {
+      return this.failure({
+        error: 'limit_exceeded',
+        limit: 'source',
+        message: `The program is longer than ${this.limits.maxSourceBytes} bytes.`,
+      });
+    }
+    try {
+      this.program = this.engine.stripTypes(`${programPrefix}${this.source}${programSuffix}`);
+    } catch (error) {
+      const reported = (error ?? {}) as plugins.IAmaroError;
+      return this.failure({
+        error: 'syntax_error',
+        message: typeof reported.message === 'string' ? reported.message : 'The program cannot be parsed.',
+        ...(typeof reported.startLine === 'number' && reported.startLine > 1 ? { line: reported.startLine - 1 } : {}),
+      });
+    }
+    const outcome = new Promise<TFlexCodeRunResult>((resolve, reject) => {
+      this.settle = resolve;
+      this.reject = reject;
+    });
+    const onAbort = () => this.halt({ kind: 'aborted', message: 'The program was stopped.' });
+    this.signal?.addEventListener('abort', onAbort, { once: true });
+    try {
+      const module = await this.engine.newModule();
+      // QuickJS runs on the host's stack too: start it from a fresh, shallow one.
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      if (this.signal?.aborted) onAbort();
+      else {
+        this.armWallTimer();
+        this.boot(module);
+      }
+      return await outcome;
+    } finally {
+      this.signal?.removeEventListener('abort', onAbort);
+      this.dispose();
+    }
+  }
+
+  private program = '';
+
+  private boot(module: plugins.IQuickJsModule): void {
+    const runtime = module.newRuntime();
+    this.runtime = runtime;
+    runtime.setMemoryLimit(this.limits.memoryBytes);
+    runtime.setMaxStackSize(this.limits.stackBytes);
+    runtime.setInterruptHandler(() => this.interrupted());
+    const vm = runtime.newContext();
+    this.vm = vm;
+    this.define('__flexCall', (pathHandle, paramsHandle) => this.bridgeCall(vm.getString(pathHandle), vm.getString(paramsHandle)));
+    this.define('__flexLog', (levelHandle, textHandle) => {
+      this.log(vm.getString(levelHandle), vm.getString(textHandle));
+    });
+    this.define('__flexDone', (textHandle) => {
+      this.complete(vm.getString(textHandle));
+    });
+    if (!this.evaluate(prelude, 'prelude.js', 'prelude')) return;
+    if (!this.evaluate(this.program, programFile, 'parse')) return;
+    if (!this.evaluate('__flexStart();', 'start.js', 'program')) return;
+    this.pump();
+  }
+
+  private define(name: string, implementation: (...args: plugins.IQuickJsHandle[]) => plugins.IQuickJsHandle | void): void {
+    const handle = this.vm!.newFunction(name, implementation);
+    this.vm!.setProp(this.vm!.global, name, handle);
+    handle.dispose();
+  }
+
+  private evaluate(code: string, file: string, phase: TPhase): boolean {
+    if (this.closing) return false;
+    let result: plugins.TQuickJsResult;
+    this.enter();
+    try {
+      result = this.vm!.evalCode(code, file);
+    } catch (error) {
+      this.hostThrow(error);
+      return false;
+    } finally {
+      this.leave();
+    }
+    if (result.error) {
+      this.failWith(result.error, phase);
+      return false;
+    }
+    result.value.dispose();
+    return true;
+  }
+
+  /** Runs the program's pending jobs after a call settled or the program started. */
+  private pump(): void {
+    if (this.closing || !this.runtime?.alive) return;
+    let result: { error?: plugins.IQuickJsHandle };
+    this.enter();
+    try {
+      result = this.runtime.executePendingJobs();
+    } catch (error) {
+      this.hostThrow(error);
+      return;
+    } finally {
+      this.leave();
+    }
+    if (result.error) this.failWith(result.error, 'program');
+  }
+
+  /**
+   * An exception out of the WebAssembly instance: the host's stack ran out under deep recursion, or
+   * the instance failed. Its state is not trusted afterwards; `dispose()` abandons it.
+   */
+  private hostThrow(error: unknown): void {
+    this.broken = true;
+    if (error instanceof RangeError) {
+      this.halt({ kind: 'limit', limit: 'stack', message: 'The program exceeded its stack.' });
+      return;
+    }
+    this.halt({ kind: 'host', error });
+  }
+
+  private enter(): void {
+    this.enteredAt = performance.now();
+  }
+
+  private leave(): void {
+    if (this.enteredAt === undefined) return;
+    this.cpuMs += performance.now() - this.enteredAt;
+    this.enteredAt = undefined;
+  }
+
+  private interrupted(): boolean {
+    if (this.stop) return true;
+    if (this.enteredAt !== undefined && this.cpuMs + performance.now() - this.enteredAt > this.limits.cpuMs) {
+      this.stop = { kind: 'limit', limit: 'cpu', message: `The program computed for more than ${this.limits.cpuMs} ms.` };
+      return true;
+    }
+    return false;
+  }
+
+  private bridgeCall(method: string, paramsText: string): plugins.IQuickJsHandle {
+    const deferred = this.vm!.newPromise();
+    this.deferreds.add(deferred);
+    this.callCount += 1;
+    if (this.callCount > this.limits.maxCalls) {
+      this.halt({
+        kind: 'limit',
+        limit: 'calls',
+        message: `The program made more than ${this.limits.maxCalls} calls.`,
+      });
+      return deferred.handle;
+    }
+    let params: unknown;
+    try {
+      params = JSON.parse(paramsText);
+    } catch {
+      params = undefined;
+    }
+    const run = (): void => {
+      if (this.closing) return;
+      this.running += 1;
+      // A settled call stops counting before the program sees its answer, which may end the program.
+      const settled = (): void => {
+        this.running -= 1;
+        this.inFlight.delete(call);
+      };
+      const call: Promise<void> = this.host.call(method, params, this.calls.signal).then(
+        (outcome) => {
+          settled();
+          this.answer(deferred, outcome);
+        },
+        (error: unknown) => {
+          settled();
+          this.halt({ kind: 'host', error });
+        },
+      ).finally(() => this.queue.shift()?.());
+      this.inFlight.add(call);
+    };
+    if (this.running < this.limits.maxConcurrentCalls) run();
+    else this.queue.push(run);
+    return deferred.handle;
+  }
+
+  private answer(deferred: plugins.IQuickJsDeferredPromise, outcome: TFlexCodeCallOutcome): void {
+    if (this.closing || !deferred.alive) return;
+    let text: string;
+    try {
+      text = JSON.stringify(outcome);
+    } catch {
+      text = JSON.stringify({ ok: false, error: { error: 'failed', message: 'The result is not JSON.' } });
+    }
+    const value = this.vm!.newString(text);
+    deferred.resolve(value);
+    value.dispose();
+    this.deferreds.delete(deferred);
+    this.pump();
+  }
+
+  private log(level: string, text: string): void {
+    if (this.logsCut || this.closing) return;
+    const line = `${level === 'log' ? '' : `[${level}] `}${text}\n`;
+    const bytes = Buffer.byteLength(line, 'utf8');
+    if (this.logBytes + bytes > this.limits.maxLogBytes) {
+      this.logsCut = true;
+      this.logs += '[console output cut off]\n';
+      return;
+    }
+    this.logBytes += bytes;
+    this.logs += line;
+  }
+
+  private complete(text: string): void {
+    if (this.closing) return;
+    let outcome: { ok: boolean; value?: TJsonValue; name?: string; message?: string; stack?: string };
+    try {
+      outcome = JSON.parse(text);
+    } catch {
+      outcome = { ok: false, name: 'Error', message: 'The program ended without a result.' };
+    }
+    if (outcome.ok) {
+      const unawaited = this.running + this.queue.length;
+      if (unawaited > 0) {
+        // Calls the program did not await are not part of its result: it fails, and proposes nothing.
+        this.done(this.failure({
+          error: 'program_error',
+          message: `The program returned with ${unawaited} call${unawaited === 1 ? '' : 's'} it did not await; await every call.`,
+        }));
+        return;
+      }
+      this.done({
+        ok: true,
+        value: outcome.value ?? null,
+        calls: Math.min(this.callCount, this.limits.maxCalls),
+        ...(this.logs ? { logs: this.logs } : {}),
+      });
+      return;
+    }
+    this.done(this.failure(this.classify(outcome, 'program')));
+  }
+
+  private failWith(handle: plugins.IQuickJsHandle, phase: TPhase): void {
+    let dumped: unknown;
+    // Reading the thrown value can run program code, such as a toJSON: it counts as computing.
+    this.enter();
+    try {
+      dumped = this.vm!.dump(handle);
+    } catch (error) {
+      if (!(error instanceof Error) || error instanceof RangeError) this.broken = true;
+      dumped = undefined;
+    } finally {
+      this.leave();
+      if (!this.broken && handle.alive) handle.dispose();
+    }
+    if (phase === 'prelude' && !this.stop) {
+      this.halt({ kind: 'host', error: new Error(`The code mode prelude failed: ${JSON.stringify(dumped)}`) });
+      return;
+    }
+    const error = (dumped && typeof dumped === 'object' ? dumped : { message: String(dumped) }) as {
+      name?: string; message?: string; stack?: string;
+    };
+    this.done(this.failure(this.classify(error, phase)));
+  }
+
+  private classify(
+    error: { name?: string; message?: string; stack?: string },
+    phase: TPhase,
+  ): Omit<IFlexCodeRunFailure, 'calls'> {
+    if (this.stop?.kind === 'limit') return { error: 'limit_exceeded', limit: this.stop.limit, message: this.stop.message };
+    if (this.stop?.kind === 'aborted') return { error: 'aborted', message: this.stop.message };
+    const message = typeof error.message === 'string' ? error.message : 'The program failed.';
+    if (error.name === 'InternalError' && message === 'out of memory') {
+      return { error: 'limit_exceeded', limit: 'memory', message: `The program used more than ${this.limits.memoryBytes} bytes of memory.` };
+    }
+    if (
+      (error.name === 'InternalError' && message === 'stack overflow')
+      || (error.name === 'RangeError' && message === 'Maximum call stack size exceeded')
+    ) {
+      return { error: 'limit_exceeded', limit: 'stack', message: 'The program exceeded its stack.' };
+    }
+    if (error.name === 'InternalError' && message === 'interrupted') {
+      return { error: 'limit_exceeded', limit: 'cpu', message: `The program computed for more than ${this.limits.cpuMs} ms.` };
+    }
+    const line = /program\.ts:(\d+)/.exec(error.stack ?? '')?.[1];
+    return {
+      error: phase === 'parse' && error.name === 'SyntaxError' ? 'syntax_error' : 'program_error',
+      ...(typeof error.name === 'string' ? { name: error.name } : {}),
+      message,
+      ...(line && Number(line) > 1 ? { line: Number(line) - 1 } : {}),
+    };
+  }
+
+  private failure(failure: Omit<IFlexCodeRunFailure, 'calls'>): TFlexCodeRunResult {
+    return {
+      ok: false,
+      failure: {
+        ...failure,
+        calls: Math.min(this.callCount, this.limits.maxCalls),
+        ...(this.logs ? { logs: this.logs } : {}),
+      },
+    };
+  }
+
+  /** Stops the program from outside it: a limit, an abort, or a failure of the host. */
+  private halt(stop: TStop): void {
+    if (this.closing) return;
+    this.stop ??= stop;
+    const reason = this.stop;
+    if (reason.kind === 'host') {
+      this.close(() => this.reject(reason.error));
+      return;
+    }
+    this.done(this.failure(reason.kind === 'limit'
+      ? { error: 'limit_exceeded', limit: reason.limit, message: reason.message }
+      : { error: 'aborted', message: reason.message }));
+  }
+
+  private done(result: TFlexCodeRunResult): void {
+    this.close(() => this.settle(result));
+  }
+
+  /**
+   * Decides the run's outcome. Calls not started yet never start. Calls in flight are told to stop
+   * through their signal, and the outcome is delivered once they settled, so no call runs on after
+   * its program; a host call that ignores its signal gets `stopGraceMs`, and its answer is dropped.
+   */
+  private close(deliver: () => void): void {
+    if (this.closing) return;
+    this.closing = true;
+    this.queue.length = 0;
+    if (this.inFlight.size === 0) {
+      this.finished = true;
+      deliver();
+      return;
+    }
+    this.calls.abort();
+    let grace: ReturnType<typeof setTimeout> | undefined;
+    void Promise.race([
+      Promise.allSettled([...this.inFlight]),
+      new Promise<void>((resolve) => {
+        grace = setTimeout(resolve, stopGraceMs);
+      }),
+    ]).then(() => {
+      clearTimeout(grace);
+      this.finished = true;
+      deliver();
+    });
+  }
+
+  private armWallTimer(): void {
+    const check = (): void => {
+      if (this.closing) return;
+      const elapsed = performance.now() - this.startedAt - (this.host.waitedMs?.() ?? 0);
+      if (elapsed > this.limits.wallMs) {
+        this.halt({ kind: 'limit', limit: 'wall', message: `The program ran for more than ${this.limits.wallMs} ms.` });
+        return;
+      }
+      this.wallTimer = setTimeout(check, Math.max(10, Math.min(250, this.limits.wallMs - elapsed)));
+    };
+    this.wallTimer = setTimeout(check, Math.max(10, Math.min(250, this.limits.wallMs)));
+  }
+
+  /**
+   * Frees the program's runtime. An instance that threw, or whose runtime cannot be freed after a
+   * stack overflow left objects behind, is abandoned instead: it is the program's own, and garbage
+   * collection reclaims its memory.
+   */
+  private dispose(): void {
+    this.closing = true;
+    this.finished = true;
+    if (this.wallTimer) clearTimeout(this.wallTimer);
+    this.queue.length = 0;
+    this.calls.abort();
+    if (this.broken) return;
+    try {
+      for (const deferred of this.deferreds) if (deferred.alive) deferred.dispose();
+      this.deferreds.clear();
+      this.vm?.dispose();
+      if (this.runtime?.alive) this.runtime.dispose();
+    } catch {
+      this.broken = true;
+    }
+  }
+}