@alisio/core 0.5.2 → 0.6.0

package/dist/forge/javascript/engine.js

@@ -0,0 +1,229 @@
+/**
+ * `JavaScriptEngine` (spec §6, D1-D5): the `ExecutionEngine` strategy that runs a script in a
+ * QuickJS-WASM VM inside an isolate host. It owns the transport and the lifecycle of the isolate;
+ * what the guest's messages MEAN (tool calls, state, output, budget) is the kernel's broker.
+ *
+ * Host-side checks, whatever the guest says: every message passes `GuestMessageValidator`
+ * (schema, sequence, correlation, size, depth, forbidden keys, capability gate); a violation or a
+ * handler error terminates the isolate and fails the execution with the matching code.
+ */
+import { access } from "node:fs/promises";
+import { isForgeError } from "../errors.js";
+import { GuestMessageValidator } from "../protocol.js";
+import { resolveIsolateCommand } from "./hosts/process-host.js";
+import { workerEntryUrl } from "./hosts/worker-host.js";
+import { PRELUDE_HASH } from "./prelude.js";
+import { FORGE_PROTOCOL_VERSION, JAVASCRIPT_ENGINE_VERSION } from "./runtime-manifest.js";
+import { loadQuickJsModule } from "./wasm.js";
+const GUEST_LIMIT_KEYS = [
+    "timeoutMs",
+    "memoryBytes",
+    "stackBytes",
+    "maxToolCalls",
+    "maxConcurrency",
+    "maxCallInputBytes",
+    "maxCallResponseBytes",
+    "maxRetainedOutputBytes",
+];
+const guestLimits = (limits) => Object.fromEntries(GUEST_LIMIT_KEYS.map((key) => [key, limits[key]]));
+export class JavaScriptEngine {
+    id = "javascript-quickjs";
+    #options;
+    constructor(options) {
+        this.#options = options;
+    }
+    #module() {
+        return (this.#options.loadModule ?? loadQuickJsModule)();
+    }
+    /**
+     * Cheap self-check (runs at startup): the WASM matches its pinned hash and compiles, and the
+     * files the chosen host starts exist. The full spin-up of an isolate is `probe()`.
+     */
+    async describe() {
+        const base = {
+            id: this.id,
+            language: "javascript",
+            version: JAVASCRIPT_ENGINE_VERSION,
+            isolation: "wasm-isolate",
+            ready: true,
+            capabilities: {
+                cooperativeInterrupt: true,
+                hardTermination: true,
+                hardMemoryLimit: false,
+                networkDeniedByOS: false,
+                toolCalls: true,
+            },
+        };
+        const unavailable = (reason) => ({ ...base, ready: false, reason });
+        try {
+            await this.#module();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return unavailable(`the QuickJS runtime failed verification (${message}); reinstall @alisio/core`);
+        }
+        try {
+            if (this.#options.hosts.kind === "worker")
+                await access(workerEntryUrl());
+            else {
+                const command = resolveIsolateCommand();
+                await access(command.execPath);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return unavailable(`the ${this.#options.hosts.kind} isolate host cannot start (${message})`);
+        }
+        return base;
+    }
+    /** The kind of host that runs the isolates (`forge status`). */
+    get hostKind() {
+        return this.#options.hosts.kind;
+    }
+    async prepare(request, ctx) {
+        await this.#module();
+        const payload = request.payload ?? {};
+        return {
+            executionId: ctx.executionId,
+            engine: this.id,
+            limits: ctx.limits,
+            source: request.source,
+            state: payload.state ?? {},
+            catalogSize: typeof payload.catalogSize === "number" ? payload.catalogSize : 0,
+            host: await this.#options.hosts.create(),
+        };
+    }
+    async run(prepared, channel) {
+        const job = prepared;
+        const session = job.host.start();
+        job.session = session;
+        const validator = new GuestMessageValidator({ toolCalls: true });
+        let hostSeq = 0;
+        let settled = false;
+        return new Promise((resolve) => {
+            const send = (reply) => {
+                if (settled)
+                    return;
+                // Answering a call or a lookup closes its correlation (a second answer is a bug).
+                if (reply.type === "result")
+                    validator.resolveCall(reply.payload.callId);
+                else if (reply.type === "catalog.result")
+                    validator.resolveCatalog(reply.payload.requestId);
+                session.send({ protocol: FORGE_PROTOCOL_VERSION, seq: hostSeq++, ...reply });
+            };
+            const finish = (outcome, stop) => {
+                if (settled)
+                    return;
+                settled = true;
+                validator.close();
+                // The guest ends itself after its terminal message; a failure stops it from here.
+                if (stop)
+                    void session.stop(stop);
+                resolve(outcome);
+            };
+            const fail = (code, message, stop) => finish({ kind: "failed", code, message }, stop);
+            // The kernel stopped the run (deadline or cancellation) and the isolate never confirmed it
+            // is gone: no terminal message and no exit will come, so the host ends the run itself. The
+            // kernel's own verdict decides the status; the unconfirmed report is journaled from there.
+            job.forceEnd = () => finish({
+                kind: "failed",
+                code: "ISOLATE_FAILURE",
+                message: "the isolate did not confirm that it stopped",
+            });
+            session.onStreamError((reason) => fail("PROTOCOL_VIOLATION", reason, "protocol_violation"));
+            session.exited.then((exit) => {
+                if (settled)
+                    return;
+                const detail = exit.error ?? `code ${String(exit.code)}${exit.signal ? `, signal ${exit.signal}` : ""}`;
+                finish({
+                    kind: "failed",
+                    code: "ISOLATE_FAILURE",
+                    message: `the isolate exited unexpectedly (${detail})`,
+                });
+            });
+            session.onMessage((raw) => {
+                if (settled)
+                    return;
+                const checked = validator.accept(raw);
+                if (!checked.ok)
+                    return fail("PROTOCOL_VIOLATION", checked.error.message, "protocol_violation");
+                const message = checked.message;
+                if (message.type === "complete") {
+                    const value = message.payload.value;
+                    return finish({ kind: "completed", ...(value !== undefined ? { value } : {}) });
+                }
+                if (message.type === "fatal") {
+                    return finish({
+                        kind: "failed",
+                        code: message.payload.code,
+                        message: message.payload.message,
+                    });
+                }
+                if (message.type === "ready") {
+                    if (message.payload.engine !== this.id || message.payload.preludeHash !== PRELUDE_HASH)
+                        return fail("PROTOCOL_VIOLATION", "the isolate runs an unexpected prelude", "protocol_violation");
+                    send({
+                        type: "start",
+                        payload: {
+                            source: job.source,
+                            state: job.state,
+                            limits: guestLimits(job.limits),
+                            catalogSize: job.catalogSize,
+                        },
+                    });
+                }
+                Promise.resolve()
+                    .then(() => channel.receive(message))
+                    .then((reply) => {
+                    if (reply)
+                        send(reply);
+                })
+                    .catch((error) => {
+                    if (isForgeError(error))
+                        return fail(error.code, error.message, "limit_exceeded");
+                    fail("ISOLATE_FAILURE", error instanceof Error ? error.message : String(error), "limit_exceeded");
+                });
+            });
+            channel.bind(send);
+        });
+    }
+    async terminate(prepared, reason) {
+        const job = prepared;
+        const session = job.session;
+        if (!session)
+            return { confirmed: true, method: "interrupt", elapsedMs: 0 };
+        const report = await session.stop(reason);
+        if (!report.confirmed)
+            job.forceEnd?.();
+        return report;
+    }
+    async dispose(prepared) {
+        const session = prepared.session;
+        if (!session)
+            return;
+        // A normal run ends with the guest leaving by itself; anything still alive is stopped now.
+        const gone = await Promise.race([
+            session.exited.then(() => true),
+            new Promise((resolve) => setTimeout(() => resolve(false), 250).unref?.()),
+        ]);
+        if (!gone)
+            await session.stop("limit_exceeded");
+    }
+    /**
+     * Full self-test (`alisio forge status`): starts a real isolate, runs `return 1` and reports how
+     * long it took. Nothing here is on the hot path of a normal execution.
+     */
+    async probe() {
+        const host = this.#options.hosts.kind;
+        const started = performance.now();
+        try {
+            const { probeIsolate } = await import("./probe.js");
+            const module = await this.#module();
+            await probeIsolate(await this.#options.hosts.create(), module);
+            return { ok: true, host, bootMs: Math.round(performance.now() - started) };
+        }
+        catch (error) {
+            return { ok: false, host, reason: error instanceof Error ? error.message : String(error) };
+        }
+    }
+}

package/dist/forge/javascript/hosts/factory.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Chooses the isolate host (spec §6.3, D-20). Node always gets the worker; Bun (directly or as a
+ * compiled binary) gets the child process, because `worker.terminate()` does not reliably stop a
+ * WASM loop there. `forge.javascript.host` can force either one for diagnosis. The only runtime
+ * detection in Forja lives here and reads `process.versions.bun`, not a Bun global.
+ */
+import type { IsolateHost } from "../../ports.ts";
+import { type ProcessHostOptions } from "./process-host.ts";
+import { type WorkerHostOptions } from "./worker-host.ts";
+export type HostChoice = "auto" | "worker" | "process";
+export declare function chooseHostKind(choice: HostChoice, bun?: boolean): "worker" | "process";
+export interface IsolateHostFactoryOptions {
+    choice: HostChoice;
+    /** The verified, compiled module (the worker receives it; the child compiles its own copy). */
+    module: () => Promise<WebAssembly.Module>;
+    worker?: Omit<WorkerHostOptions, "module">;
+    process?: ProcessHostOptions;
+    bun?: boolean;
+}
+export declare class IsolateHostFactory {
+    #private;
+    constructor(options: IsolateHostFactoryOptions);
+    get kind(): "worker" | "process";
+    create(): Promise<IsolateHost>;
+}

package/dist/forge/javascript/hosts/factory.js

@@ -0,0 +1,21 @@
+import { ProcessIsolateHost } from "./process-host.js";
+import { WorkerIsolateHost } from "./worker-host.js";
+export function chooseHostKind(choice, bun = !!process.versions.bun) {
+    if (choice !== "auto")
+        return choice;
+    return bun ? "process" : "worker";
+}
+export class IsolateHostFactory {
+    #options;
+    constructor(options) {
+        this.#options = options;
+    }
+    get kind() {
+        return chooseHostKind(this.#options.choice, this.#options.bun);
+    }
+    async create() {
+        if (this.kind === "process")
+            return new ProcessIsolateHost(this.#options.process);
+        return new WorkerIsolateHost({ ...this.#options.worker, module: await this.#options.module() });
+    }
+}

package/dist/forge/javascript/hosts/framing.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Length-prefixed JSON framing of the process host (spec §6.3, D10): a big-endian u32 byte count
+ * followed by that many bytes of UTF-8 JSON. Pure. A frame over the limit or a body that is not
+ * JSON breaks the stream: the caller treats it as a protocol violation and kills the child.
+ *
+ * Erasable TypeScript only (D-33): the isolate process loads this file under type stripping.
+ */
+export declare function encodeFrame(message: unknown): Buffer;
+export declare class FrameStreamError extends Error {
+    constructor(message: string);
+}
+export declare class FrameDecoder {
+    #private;
+    constructor(maxFrameBytes: number);
+    /** Adds bytes and returns every message completed by them. Throws `FrameStreamError`. */
+    push(chunk: Uint8Array): unknown[];
+}

package/dist/forge/javascript/hosts/framing.js

@@ -0,0 +1,49 @@
+/**
+ * Length-prefixed JSON framing of the process host (spec §6.3, D10): a big-endian u32 byte count
+ * followed by that many bytes of UTF-8 JSON. Pure. A frame over the limit or a body that is not
+ * JSON breaks the stream: the caller treats it as a protocol violation and kills the child.
+ *
+ * Erasable TypeScript only (D-33): the isolate process loads this file under type stripping.
+ */
+export function encodeFrame(message) {
+    const body = Buffer.from(JSON.stringify(message), "utf8");
+    const header = Buffer.allocUnsafe(4);
+    header.writeUInt32BE(body.length, 0);
+    return Buffer.concat([header, body]);
+}
+export class FrameStreamError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "FrameStreamError";
+    }
+}
+export class FrameDecoder {
+    #buffer = Buffer.alloc(0);
+    #maxFrameBytes;
+    constructor(maxFrameBytes) {
+        this.#maxFrameBytes = maxFrameBytes;
+    }
+    /** Adds bytes and returns every message completed by them. Throws `FrameStreamError`. */
+    push(chunk) {
+        this.#buffer =
+            this.#buffer.length === 0 ? Buffer.from(chunk) : Buffer.concat([this.#buffer, chunk]);
+        const messages = [];
+        while (this.#buffer.length >= 4) {
+            const size = this.#buffer.readUInt32BE(0);
+            // The size is checked before the body is buffered: a hostile length never allocates.
+            if (size > this.#maxFrameBytes)
+                throw new FrameStreamError(`frame of ${size} bytes exceeds the ${this.#maxFrameBytes} limit`);
+            if (this.#buffer.length < 4 + size)
+                break;
+            const body = this.#buffer.subarray(4, 4 + size).toString("utf8");
+            this.#buffer = this.#buffer.subarray(4 + size);
+            try {
+                messages.push(JSON.parse(body));
+            }
+            catch {
+                throw new FrameStreamError("frame is not valid JSON");
+            }
+        }
+        return messages;
+    }
+}

package/dist/forge/javascript/hosts/isolate-main.d.ts

@@ -0,0 +1,9 @@
+export interface WorkerIsolateData {
+    forgeIsolate: 1;
+    module: WebAssembly.Module;
+    flag: SharedArrayBuffer;
+}
+/** Body of a worker thread started by `WorkerIsolateHost`. */
+export declare function runWorkerIsolate(): Promise<void>;
+/** Body of the child process started by `ProcessIsolateHost` (or by `alisio __forge-isolate`). */
+export declare function runProcessIsolate(env?: Record<string, string | undefined>): Promise<void>;

package/dist/forge/javascript/hosts/isolate-main.js

@@ -0,0 +1,63 @@
+/**
+ * What runs inside an isolate (spec §6.3, D-20, D-21): the worker thread body and the child
+ * process body. Both build a `GuestTransport` over their channel and hand it to `runGuest`.
+ *
+ * The process variant refuses to run unless `ALISIO_FORGE_ISOLATE=1` is set (the host sets it
+ * with an otherwise empty environment), so the hidden `__forge-isolate` command cannot be
+ * mistaken for something a user runs. It talks only through stdin/stdout frames and exits when
+ * the execution reaches its terminal message.
+ *
+ * Erasable TypeScript only (D-33).
+ */
+import { isMainThread, parentPort, workerData } from "node:worker_threads";
+import { runGuest } from "../vm-runner.js";
+import { loadQuickJsModule } from "../wasm.js";
+import { encodeFrame, FrameDecoder } from "./framing.js";
+/** Body of a worker thread started by `WorkerIsolateHost`. */
+export async function runWorkerIsolate() {
+    const data = workerData;
+    if (isMainThread || !parentPort || data?.forgeIsolate !== 1)
+        return;
+    const port = parentPort;
+    await runGuest({
+        module: data.module,
+        flag: new Int32Array(data.flag),
+        transport: {
+            send: (message) => port.postMessage(message),
+            onMessage: (handler) => port.on("message", handler),
+        },
+    });
+    // The terminal message is posted; leaving the thread lets the parent observe a clean `exit`.
+    process.exit(0);
+}
+/** Body of the child process started by `ProcessIsolateHost` (or by `alisio __forge-isolate`). */
+export async function runProcessIsolate(env = process.env) {
+    if (env.ALISIO_FORGE_ISOLATE !== "1") {
+        process.stderr.write("__forge-isolate is internal and is started by the Forja process host\n");
+        process.exit(2);
+    }
+    const module = await loadQuickJsModule();
+    const decoder = new FrameDecoder(8 * 1024 * 1024);
+    let handler = () => { };
+    process.stdin.on("data", (chunk) => {
+        try {
+            for (const message of decoder.push(chunk))
+                handler(message);
+        }
+        catch {
+            process.exit(3);
+        }
+    });
+    process.stdin.on("end", () => process.exit(0));
+    await runGuest({
+        module,
+        transport: {
+            send: (message) => process.stdout.write(encodeFrame(message)),
+            onMessage: (next) => {
+                handler = next;
+            },
+        },
+    });
+    // Exit once the last frame is flushed.
+    process.stdout.write("", () => process.exit(0));
+}

package/dist/forge/javascript/hosts/process-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/forge/javascript/hosts/process-entry.js

@@ -0,0 +1,3 @@
+/** Entry file of the isolate child process when run from a file (spec D-33: erasable TypeScript only). */
+import { runProcessIsolate } from "./isolate-main.js";
+await runProcessIsolate();

package/dist/forge/javascript/hosts/process-host.d.ts

@@ -0,0 +1,33 @@
+import type { IsolateHost, IsolateSession } from "../../ports.ts";
+export declare const PROCESS_KILL_BACKSTOP_MS = 500;
+/**
+ * The isolate's whole environment: the marker, and on Windows `SystemRoot` and nothing else (the
+ * runtime cannot start without it). No other variable of the parent ever reaches the guest process.
+ */
+export declare function isolateEnv(platform?: NodeJS.Platform, parent?: NodeJS.ProcessEnv): Record<string, string>;
+export interface IsolateCommand {
+    execPath: string;
+    args: string[];
+}
+/** Whether this process is a binary compiled by `bun build --compile`. */
+export declare function isBunCompiled(argv1?: string | undefined): boolean;
+/**
+ * How to start an isolate process. A compiled binary re-runs itself with the hidden
+ * `__forge-isolate` command (its virtual files cannot be spawned); otherwise the process entry file
+ * next to this one runs directly (`.ts` through type stripping, `.js` from `dist`).
+ */
+export declare function resolveIsolateCommand(options?: {
+    compiled?: boolean;
+    base?: string;
+    execPath?: string;
+}): IsolateCommand;
+export interface ProcessHostOptions {
+    command?: IsolateCommand;
+    backstopMs?: number;
+}
+export declare class ProcessIsolateHost implements IsolateHost {
+    #private;
+    readonly kind: "process";
+    constructor(options?: ProcessHostOptions);
+    start(): IsolateSession;
+}

package/dist/forge/javascript/hosts/process-host.js

@@ -0,0 +1,160 @@
+/**
+ * `ProcessIsolateHost` (spec §6.3, D-20, D-21): the VM runs in a child process of the same
+ * executable (Bun, where `worker.terminate()` cannot be trusted to stop WASM).
+ *
+ * The child gets an EMPTY environment but `ALISIO_FORGE_ISOLATE=1` (see `isolateEnv`), no inherited descriptors
+ * (stdin and stdout are the frame channel, stderr is dropped) and a private working directory.
+ * There is no shared memory with it, so:
+ *  - a user cancellation is `SIGKILL` at once;
+ *  - a deadline relies on the guest's own interrupt handler, with `SIGKILL` as a backstop 500 ms
+ *    after the deadline passed.
+ * The stop is only "confirmed" when the child's `exit` is seen.
+ */
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { MAX_MESSAGE_BYTES } from "../../protocol.js";
+import { encodeFrame, FrameDecoder, FrameStreamError } from "./framing.js";
+export const PROCESS_KILL_BACKSTOP_MS = 500;
+const EXIT_CONFIRM_MS = 2_000;
+/**
+ * The isolate's whole environment: the marker, and on Windows `SystemRoot` and nothing else (the
+ * runtime cannot start without it). No other variable of the parent ever reaches the guest process.
+ */
+export function isolateEnv(platform = process.platform, parent = process.env) {
+    const env = { ALISIO_FORGE_ISOLATE: "1" };
+    if (platform === "win32" && parent.SystemRoot)
+        env.SystemRoot = parent.SystemRoot;
+    return env;
+}
+/** Whether this process is a binary compiled by `bun build --compile`. */
+export function isBunCompiled(argv1 = process.argv[1]) {
+    return !!process.versions.bun && /^(\/\$bunfs\/|[A-Za-z]:[\\/]+~BUN[\\/])/.test(argv1 ?? "");
+}
+/**
+ * How to start an isolate process. A compiled binary re-runs itself with the hidden
+ * `__forge-isolate` command (its virtual files cannot be spawned); otherwise the process entry file
+ * next to this one runs directly (`.ts` through type stripping, `.js` from `dist`).
+ */
+export function resolveIsolateCommand(options = {}) {
+    const execPath = options.execPath ?? process.execPath;
+    if (options.compiled ?? isBunCompiled())
+        return { execPath, args: ["__forge-isolate"] };
+    const base = options.base ?? import.meta.url;
+    const typescript = base.endsWith(".ts");
+    const entry = fileURLToPath(new URL(`./process-entry.${typescript ? "ts" : "js"}`, base));
+    const stripFlags = typescript && !process.versions.bun
+        ? ["--experimental-strip-types", "--disable-warning=ExperimentalWarning"]
+        : [];
+    return { execPath, args: [...stripFlags, entry] };
+}
+export class ProcessIsolateHost {
+    kind = "process";
+    #options;
+    constructor(options = {}) {
+        this.#options = options;
+    }
+    start() {
+        const command = this.#options.command ?? resolveIsolateCommand();
+        const backstopMs = this.#options.backstopMs ?? PROCESS_KILL_BACKSTOP_MS;
+        const cwd = mkdtempSync(join(tmpdir(), "alisio-forge-"));
+        const child = spawn(command.execPath, command.args, {
+            cwd,
+            env: isolateEnv(),
+            stdio: ["pipe", "pipe", "ignore"],
+            windowsHide: true,
+        });
+        let messageHandler = () => { };
+        let streamErrorHandler = () => { };
+        let exitState;
+        let spawnError;
+        const exited = new Promise((resolve) => {
+            let settled = false;
+            const finish = (exit) => {
+                if (settled)
+                    return;
+                settled = true;
+                exitState = exit;
+                try {
+                    rmSync(cwd, { recursive: true, force: true });
+                }
+                catch {
+                    /* A leftover empty directory in the temporary folder is harmless. */
+                }
+                resolve(exit);
+            };
+            child.once("error", (error) => {
+                spawnError = error.message;
+                finish({ code: null, signal: null, error: error.message });
+            });
+            child.once("exit", (code, signal) => finish({ code, signal, ...(spawnError ? { error: spawnError } : {}) }));
+        });
+        const decoder = new FrameDecoder(MAX_MESSAGE_BYTES + 4096);
+        child.stdout?.on("data", (chunk) => {
+            try {
+                for (const message of decoder.push(chunk))
+                    messageHandler(message);
+            }
+            catch (error) {
+                if (error instanceof FrameStreamError) {
+                    streamErrorHandler(error.message);
+                    child.kill("SIGKILL");
+                    return;
+                }
+                throw error;
+            }
+        });
+        // The child may be killed while a frame is being written.
+        child.stdin?.on("error", () => { });
+        child.stdout?.on("error", () => { });
+        const waitExit = async () => {
+            let timer;
+            const confirmed = await Promise.race([
+                exited.then(() => true),
+                new Promise((resolve) => {
+                    timer = setTimeout(() => resolve(false), EXIT_CONFIRM_MS);
+                }),
+            ]);
+            clearTimeout(timer);
+            return confirmed;
+        };
+        return {
+            kind: "process",
+            onMessage(handler) {
+                messageHandler = handler;
+            },
+            onStreamError(handler) {
+                streamErrorHandler = handler;
+            },
+            send(message) {
+                if (!exitState && child.stdin?.writable)
+                    child.stdin.write(encodeFrame(message));
+            },
+            exited,
+            async stop(reason) {
+                const started = performance.now();
+                if (exitState)
+                    return { confirmed: true, method: "kill", elapsedMs: 0 };
+                let backstop;
+                if (reason === "timeout") {
+                    // The guest's own deadline should end it first; this is the backstop.
+                    backstop = setTimeout(() => child.kill("SIGKILL"), backstopMs);
+                }
+                else
+                    child.kill("SIGKILL");
+                const confirmed = await waitExit();
+                clearTimeout(backstop);
+                if (!confirmed)
+                    child.kill("SIGKILL");
+                return {
+                    confirmed,
+                    method: "kill",
+                    elapsedMs: Math.round(performance.now() - started),
+                    ...(confirmed ? {} : { settled: exited.then(() => undefined) }),
+                };
+            },
+        };
+    }
+}

package/dist/forge/javascript/hosts/worker-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/forge/javascript/hosts/worker-entry.js

@@ -0,0 +1,3 @@
+/** Entry file of the worker thread (spec D-33: erasable TypeScript only). */
+import { runWorkerIsolate } from "./isolate-main.js";
+await runWorkerIsolate();

package/dist/forge/javascript/hosts/worker-host.d.ts

@@ -0,0 +1,18 @@
+import type { IsolateHost, IsolateSession } from "../../ports.ts";
+export declare const WORKER_TERMINATE_AFTER_MS = 50;
+/** The worker entry next to this file: `.ts` when running from sources, `.js` from `dist`. */
+export declare function workerEntryUrl(base?: string): URL;
+export interface WorkerHostOptions {
+    module: WebAssembly.Module;
+    /** Overrides the entry (tests of failure paths). */
+    entry?: URL;
+    terminateAfterMs?: number;
+}
+export declare class WorkerIsolateHost implements IsolateHost {
+    #private;
+    readonly kind: "worker";
+    constructor(options: WorkerHostOptions);
+    start(): IsolateSession;
+}
+/** Path of the worker entry, for diagnostics. */
+export declare const workerEntryPath: () => string;