pi-ast-sgrep 2.0.2 → 2.2.0

package/dist/codemode/runner.js

@@ -1,207 +1,434 @@
 import { Worker } from "node:worker_threads";
+import { coerceHostArgs, normalizeCode, packGuestCall, resolveHostMethod, timeoutHint, unknownMethodError } from "./guest-api.js";
+import { CODEMODE_HOST_METHODS } from "./types.js";
+export { normalizeCode };
 const DEFAULT_TIMEOUT_MS = 30_000;
 const MAX_CODE_CHARS = 32_000;
 const MAX_BRIDGE_CALLS = 256;
 const MAX_BRIDGE_REQUEST_CHARS = 64_000;
-const MAX_BRIDGE_RESPONSE_CHARS = 4 * 1024 * 1024;
 const MAX_ERROR_CHARS = 8_192;
 const MAX_LOG_LINES = 100;
 const MAX_LOG_CHARS = 64_000;
-const MAX_LOG_LINE_CHARS = 4_096;
 const MAX_RESULT_JSON_CHARS = 1_000_000;
-const RESULT_SERIALIZE_TIMEOUT_MS = 1_000;
 const MAX_TIMER_MS = 2_147_483_647;
-/** Strip markdown fences and normalize to an async IIFE expression. */
-export function normalizeCode(raw) {
-    let code = raw.trim();
-    if (code.startsWith("```")) {
-        code = code.replace(/^```(?:javascript|js|typescript|ts)?\s*/i, "").replace(/\s*```$/, "").trim();
-    }
-    if (/^async\s*\(/.test(code) || /^async\s+function\b/.test(code)) {
-        return `(${code.endsWith(";") ? code.slice(0, -1) : code})()`;
-    }
-    return `(async () => {\n${code}\n})()`;
+/** Hard ceiling on guest heap; an OOM guest kills its isolate, never the host. */
+const WORKER_MAX_OLD_SPACE_MB = 512;
+const WORKER_MAX_YOUNG_SPACE_MB = 64;
+/** Parent-side RSS guard: a run may grow process RSS by this multiple of the heap cap. */
+const MEMORY_SLACK = 1.5;
+const MEMORY_POLL_MS = 50;
+/** Grace for in-flight host calls after the guest reports done. */
+const DRAIN_PENDING_MS = 250;
+const WORKER_URL = new URL("./guest-worker.mjs", import.meta.url);
+const ABORT_MESSAGE = "codemode timed out or aborted: pass timeoutMs to allow longer runs";
+let idle = null;
+let runSeq = 0;
+const activeWorkers = new Set();
+function spawnWorker() {
+    // Inline eval'd bootstrap: imports the real guest-worker file. execArgv is
+    // emptied so --import tsx / --test flags cannot leak in and crash the isolate.
+    const worker = new Worker("import(" + JSON.stringify(WORKER_URL.href) + ")", {
+        eval: true,
+        execArgv: [],
+        resourceLimits: {
+            maxOldGenerationSizeMb: WORKER_MAX_OLD_SPACE_MB,
+            maxYoungGenerationSizeMb: WORKER_MAX_YOUNG_SPACE_MB,
+        },
+    });
+    const handle = { worker, ready: Promise.resolve(), dead: false };
+    worker.on("error", () => { handle.dead = true; });
+    worker.on("exit", () => {
+        handle.dead = true;
+        if (idle === handle)
+            idle = null;
+    });
+    handle.ready = new Promise((resolve, reject) => {
+        const cleanup = () => {
+            worker.off("message", onMessage);
+            worker.off("error", onFail);
+            worker.off("exit", onFail);
+        };
+        const onMessage = (msg) => {
+            if (msg?.op !== "ready")
+                return;
+            cleanup();
+            resolve();
+        };
+        const onFail = (err) => {
+            cleanup();
+            reject(err instanceof Error ? err : new Error("codemode worker exited before ready (code " + err + ")"));
+        };
+        worker.on("message", onMessage);
+        worker.on("error", onFail);
+        worker.on("exit", onFail);
+    });
+    handle.ready.catch(() => undefined);
+    return handle;
 }
-/**
- * Run model-generated JavaScript against the typed `asgrep` connector.
- *
- * Model-generated code is not trusted with the extension host's ambient Node
- * authority. A dedicated worker contains CPU/microtask denial of service; its
- * VM hides `process`, module loading, and host constructors, with a JSON bridge
- * as the only exposed capability. This is not an OS sandbox, so deployments
- * requiring adversarial-code isolation should still restrict the Pi process.
- */
-export async function runCodemode(rawCode, asgrep, options = {}) {
-    const requestedTimeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const timeoutMs = Number.isFinite(requestedTimeout)
-        ? Math.min(MAX_TIMER_MS, Math.max(1, Math.trunc(requestedTimeout)))
-        : DEFAULT_TIMEOUT_MS;
-    const wall0 = Date.now();
-    if (rawCode.length > MAX_CODE_CHARS) {
-        return resultErr(`code exceeds ${MAX_CODE_CHARS} characters`, [], rawCode.slice(0, 200), wall0, options.stats);
-    }
-    if (options.signal?.aborted) {
-        return resultErr("codemode aborted", [], rawCode.slice(0, 200), wall0, options.stats);
-    }
-    const code = normalizeCode(rawCode);
-    const runController = new AbortController();
-    const hostMethods = {
-        search: asgrep.search.bind(asgrep),
-        semantic: asgrep.semantic.bind(asgrep),
-        chain: asgrep.chain.bind(asgrep),
-        defs: asgrep.defs.bind(asgrep),
-        callers: asgrep.callers.bind(asgrep),
-        imports: asgrep.imports.bind(asgrep),
-        indexStatus: asgrep.indexStatus.bind(asgrep),
-        indexRepo: asgrep.indexRepo.bind(asgrep),
-        catalogSearch: asgrep.catalogSearch.bind(asgrep),
-        catalogDescribe: asgrep.catalogDescribe.bind(asgrep),
-    };
-    const workerUrl = new URL(import.meta.url.endsWith(".ts") ? "./sandbox-worker.ts" : "./sandbox-worker.js", import.meta.url);
-    let worker;
-    try {
-        worker = new Worker(workerUrl, {
-            workerData: {
-                code,
-                timeoutMs,
-                limits: {
-                    bridgeCalls: MAX_BRIDGE_CALLS,
-                    bridgeRequestChars: MAX_BRIDGE_REQUEST_CHARS,
-                    errorChars: MAX_ERROR_CHARS,
-                    logLines: MAX_LOG_LINES,
-                    logChars: MAX_LOG_CHARS,
-                    logLineChars: MAX_LOG_LINE_CHARS,
-                    resultJsonChars: MAX_RESULT_JSON_CHARS,
-                    serializeTimeoutMs: RESULT_SERIALIZE_TIMEOUT_MS,
-                },
-            },
-            resourceLimits: {
-                maxOldGenerationSizeMb: 64,
-                maxYoungGenerationSizeMb: 16,
-                stackSizeMb: 4,
-            },
-        });
+function killWorker(handle) {
+    if (!handle)
+        return undefined;
+    if (idle === handle)
+        idle = null;
+    handle.dead = true;
+    return handle.worker.terminate().then(() => undefined, () => undefined);
+}
+function acquireWorker() {
+    const candidate = idle;
+    idle = null;
+    const handle = candidate && !candidate.dead ? candidate : spawnWorker();
+    if (candidate && candidate.dead)
+        void killWorker(candidate);
+    handle.worker.ref?.();
+    // Pipeline the replacement while this run executes.
+    warmCodemodeSandbox().catch(() => undefined);
+    return handle;
+}
+/** Spawn the warm standby isolate (session_start / pre-call). */
+export function warmCodemodeSandbox() {
+    if (idle && !idle.dead)
+        return idle.ready;
+    const handle = spawnWorker();
+    idle = handle;
+    void handle.ready.then(() => {
+        if (idle === handle)
+            handle.worker.unref?.();
+    }, () => undefined);
+    return handle.ready;
+}
+/** Drop the standby isolate and any in-flight runs (tests / session shutdown). */
+export async function resetCodemodeSandboxForTests() {
+    await killWorker(idle);
+    await Promise.all([...activeWorkers].map((worker) => worker.terminate().catch(() => undefined)));
+}
+// ---------------------------------------------------------------------------
+// Admission funnel: validate everything before any worker work happens.
+// ---------------------------------------------------------------------------
+function admitTimeout(requested) {
+    if (requested === undefined)
+        return { timeoutMs: DEFAULT_TIMEOUT_MS };
+    if (!Number.isFinite(requested) || requested <= 0)
+        return { error: "timeoutMs must be a positive finite number" };
+    return { timeoutMs: Math.min(MAX_TIMER_MS, Math.max(1, Math.trunc(requested))) };
+}
+function admitRun(code, timeoutMs, signal) {
+    if (code.length > MAX_CODE_CHARS)
+        return { error: "code exceeds " + MAX_CODE_CHARS + " characters; split into multiple asgrep calls" };
+    if (signal?.aborted)
+        return { error: "codemode aborted" };
+    const timeout = admitTimeout(timeoutMs);
+    if ("error" in timeout)
+        return timeout;
+    return { code: normalizeCode(code), timeoutMs: timeout.timeoutMs };
+}
+// ---------------------------------------------------------------------------
+// GuestRun: one run = one worker = one class instance. Explicit lifecycle
+// states replace the closure flag soup: finished → terminal, accepting →
+// messages still honored, completing → draining, aborting → user/timeout path.
+// ---------------------------------------------------------------------------
+class GuestRun {
+    code;
+    timeoutMs;
+    hostMethods;
+    signal;
+    statsFn;
+    runId;
+    finished = false;
+    accepting = true;
+    completing = false;
+    aborting = false;
+    handle;
+    pending = new Set();
+    logs = [];
+    logChars = 0;
+    callCount = 0;
+    lastMethod = null;
+    timer;
+    memTimer;
+    hostError;
+    wall0 = performance.now();
+    runController = new AbortController();
+    rssStart;
+    rssLimit;
+    resolve;
+    constructor(code, timeoutMs, hostMethods, signal, statsFn, runId) {
+        this.code = code;
+        this.timeoutMs = timeoutMs;
+        this.hostMethods = hostMethods;
+        this.signal = signal;
+        this.statsFn = statsFn;
+        this.runId = runId;
+        this.rssStart = process.memoryUsage().rss;
+        this.rssLimit = this.rssStart + WORKER_MAX_OLD_SPACE_MB * MEMORY_SLACK * 1_048_576;
     }
-    catch (cause) {
-        return resultErr(cause instanceof Error ? cause.message : String(cause), [], code, wall0, options.stats);
+    wall() {
+        return performance.now() - this.wall0;
     }
-    return new Promise((resolve) => {
-        let active = true;
-        const receivedCallIds = new Set();
-        const finish = (outcome) => {
-            if (!active)
-                return;
-            active = false;
-            clearTimeout(timer);
-            options.signal?.removeEventListener("abort", onAbort);
-            // Cancel host work that the disposable worker was awaiting or abandoned.
-            runController.abort();
-            void worker.terminate().catch(() => undefined).then(() => {
-                outcome.wallMs = Date.now() - wall0;
-                resolve(outcome);
-            });
-        };
-        const fail = (error, logs = []) => {
-            finish(resultErr(error, logs, code, wall0, options.stats));
+    ok(result) {
+        const out = { ok: true, result, logs: this.logs, code: this.code, wallMs: this.wall() };
+        const stats = this.statsFn?.();
+        if (stats)
+            out.stats = stats;
+        return out;
+    }
+    err(error) {
+        const out = {
+            ok: false,
+            result: null,
+            logs: this.logs,
+            error: timeoutHint(error).slice(0, MAX_ERROR_CHARS),
+            code: this.code,
+            wallMs: this.wall(),
         };
-        const onAbort = () => fail("codemode aborted");
-        const timer = setTimeout(() => fail(`codemode timeout after ${timeoutMs}ms`), timeoutMs);
-        worker.on("message", (message) => {
-            if (!active)
-                return;
-            if (!isSandboxMessage(message)) {
-                fail("codemode worker sent an invalid message");
-                return;
-            }
-            if (message.type === "done") {
-                if (message.ok) {
-                    finish(resultOk(message.result, message.logs, code, wall0, options.stats));
-                }
-                else {
-                    fail(message.error ?? "codemode worker failed", message.logs);
-                }
-                return;
+        const stats = this.statsFn?.();
+        if (stats)
+            out.stats = stats;
+        return out;
+    }
+    cleanup() {
+        clearTimeout(this.timer);
+        clearInterval(this.memTimer);
+        this.signal?.removeEventListener("abort", this.onAbort);
+        if (this.handle) {
+            this.handle.worker.off("message", this.onMessage);
+            this.handle.worker.off("error", this.onError);
+            this.handle.worker.off("exit", this.onExit);
+        }
+    }
+    finish(outcome) {
+        if (this.finished)
+            return;
+        this.finished = true;
+        this.accepting = false;
+        this.cleanup();
+        this.runController.abort();
+        if (this.handle) {
+            activeWorkers.delete(this.handle.worker);
+            void killWorker(this.handle);
+        }
+        this.resolve(outcome);
+    }
+    fail(message) {
+        this.finish(this.err(message));
+    }
+    abort() {
+        if (this.finished || this.aborting)
+            return;
+        this.aborting = true;
+        this.fail(ABORT_MESSAGE);
+        this.aborting = false;
+    }
+    onAbort = () => this.abort();
+    hostLog(line) {
+        if (this.logs.length >= MAX_LOG_LINES || this.logChars >= MAX_LOG_CHARS)
+            return;
+        const remaining = MAX_LOG_CHARS - this.logChars;
+        const bounded = line.length <= remaining ? line : line.slice(0, Math.max(0, remaining - 1)) + "…";
+        this.logs.push(bounded);
+        this.logChars += bounded.length;
+    }
+    async hostCall(method, payload) {
+        try {
+            if (this.runController.signal.aborted) {
+                throw Object.assign(new Error("codemode aborted"), { name: "AbortError" });
             }
-            for (const call of message.calls) {
-                if (call.id >= MAX_BRIDGE_CALLS || receivedCallIds.has(call.id)) {
-                    fail("codemode worker exceeded its bridge call allowance");
-                    return;
-                }
-                receivedCallIds.add(call.id);
+            if (this.callCount >= MAX_BRIDGE_CALLS) {
+                throw new Error("codemode exceeds " + MAX_BRIDGE_CALLS + " host calls");
             }
-            for (const call of message.calls)
-                void handleSandboxCall(call);
-        });
-        worker.once("error", (error) => fail(error.message));
-        worker.once("exit", (code) => {
-            if (active)
-                fail(`codemode worker exited ${code}`);
-        });
-        const handleSandboxCall = async (call) => {
-            if (!active)
-                return;
-            let payload;
-            try {
-                if (call.payload.length > MAX_BRIDGE_REQUEST_CHARS) {
-                    throw new Error(`codemode call arguments exceed ${MAX_BRIDGE_REQUEST_CHARS} characters`);
-                }
-                if (!Object.hasOwn(hostMethods, call.method)) {
-                    throw new Error(`unknown asgrep method: ${call.method}`);
-                }
-                const input = JSON.parse(call.payload);
-                const methodCall = hostMethods[call.method];
-                const value = await methodCall(input, { signal: runController.signal });
-                payload = stringifyBounded({ ok: true, value }, MAX_BRIDGE_RESPONSE_CHARS, "codemode call result");
+            this.callCount += 1;
+            this.lastMethod = method;
+            if (payload.length > MAX_BRIDGE_REQUEST_CHARS) {
+                throw new Error("codemode call arguments exceed " + MAX_BRIDGE_REQUEST_CHARS + " characters");
             }
-            catch (cause) {
-                payload = JSON.stringify({
-                    ok: false,
-                    error: safeErrorMessage(cause).slice(0, MAX_ERROR_CHARS),
-                });
+            const resolved = resolveHostMethod(method);
+            if (!resolved || !Object.hasOwn(this.hostMethods, resolved)) {
+                throw new Error(unknownMethodError(method));
             }
-            if (active)
-                worker.postMessage({ type: "callResult", id: call.id, payload });
-        };
-        options.signal?.addEventListener("abort", onAbort, { once: true });
-        if (options.signal?.aborted)
-            onAbort();
-    });
+            const parsed = JSON.parse(payload);
+            const packed = Array.isArray(parsed.__guestArgs)
+                ? packGuestCall(resolved, parsed.__guestArgs)
+                : parsed;
+            const input = coerceHostArgs(resolved, packed);
+            const invokeHost = this.hostMethods[resolved];
+            if (!invokeHost)
+                throw new Error(unknownMethodError(method));
+            const value = await invokeHost(input, { signal: this.runController.signal });
+            return JSON.stringify({ ok: true, value }, jsonSafe);
+        }
+        catch (cause) {
+            return JSON.stringify({ ok: false, error: safeErrorMessage(cause).slice(0, MAX_ERROR_CHARS) });
+        }
+    }
+    respond(id, body) {
+        if (!this.handle || this.finished)
+            return;
+        try {
+            this.handle.worker.postMessage({ op: "call-result", runId: this.runId, id, body });
+        }
+        catch {
+            // Worker already terminated; the run is settled.
+        }
+    }
+    onCallBatch(calls) {
+        for (const call of calls) {
+            const work = this.hostCall(call.method, call.payload)
+                .then((body) => this.respond(call.id, body))
+                .catch(() => this.respond(call.id, JSON.stringify({ ok: false, error: "codemode call failed" })));
+            this.pending.add(work);
+            void work.finally(() => this.pending.delete(work));
+        }
+    }
+    onResult(msg) {
+        try {
+            const serialized = msg.serialized;
+            const result = serialized === undefined ? undefined : JSON.parse(serialized);
+            void this.complete(this.ok(result));
+        }
+        catch (cause) {
+            this.fail("codemode result decode failed: " + safeErrorMessage(cause));
+        }
+    }
+    onMessage = (msg) => {
+        if (this.finished || !this.accepting || !msg || typeof msg !== "object")
+            return;
+        if (typeof msg.runId === "number" && msg.runId !== this.runId)
+            return;
+        if (msg.op === "log") {
+            this.hostLog(msg.line);
+            return;
+        }
+        if (msg.op === "call-batch") {
+            this.onCallBatch(Array.isArray(msg.calls) ? msg.calls : []);
+            return;
+        }
+        if (msg.op === "result") {
+            this.onResult(msg);
+            return;
+        }
+        if (msg.op === "error") {
+            this.fail(msg.error);
+        }
+    };
+    onError = (cause) => {
+        void this.complete(this.err("codemode worker error: " + cause.message));
+    };
+    onExit = (exitCode) => {
+        void this.complete(this.err("codemode worker exited code=" + exitCode));
+    };
+    /** Give in-flight host calls a bounded settle window, then surface leaks. */
+    async drainPending(outcome) {
+        if (this.pending.size === 0)
+            return;
+        await Promise.race([
+            Promise.allSettled(this.pending),
+            new Promise((resolve) => setTimeout(resolve, DRAIN_PENDING_MS)),
+        ]);
+        if (this.pending.size && outcome.ok) {
+            this.hostError ??= "program completed with a host call still running";
+        }
+    }
+    async complete(outcome) {
+        if (this.finished || this.completing)
+            return;
+        this.completing = true;
+        this.accepting = false;
+        await this.drainPending(outcome);
+        if (this.finished)
+            return;
+        this.finish(outcome.ok && this.hostError ? this.err(this.hostError) : outcome);
+    }
+    memoryLimitError() {
+        const now = process.memoryUsage().rss;
+        const deltaMb = Math.max(0, (now - this.rssStart) / 1_048_576);
+        const where = this.lastMethod ? " during " + this.lastMethod : "";
+        return ("codemode exceeded memory limit: process RSS +" + deltaMb.toFixed(1) + "MB in " +
+            Math.round(this.wall()) + "ms" + where + " (" + this.callCount + " host calls); " +
+            "worker heap cap is " + WORKER_MAX_OLD_SPACE_MB + "MB — split the program or stream less data");
+    }
+    async boot() {
+        try {
+            this.handle = acquireWorker();
+            activeWorkers.add(this.handle.worker);
+            await this.handle.ready;
+            if (this.finished || this.signal?.aborted)
+                return this.abort();
+            this.handle.worker.on("message", this.onMessage);
+            this.handle.worker.on("error", this.onError);
+            this.handle.worker.on("exit", this.onExit);
+            if (this.wall() >= this.timeoutMs)
+                return this.abort();
+            this.handle.worker.postMessage({ op: "run", runId: this.runId, code: this.code, timeoutMs: this.timeoutMs });
+        }
+        catch (cause) {
+            if (this.finished)
+                return;
+            this.fail("codemode worker unavailable: " + safeErrorMessage(cause));
+        }
+    }
+    start() {
+        return new Promise((resolve) => {
+            this.resolve = resolve;
+            this.timer = setTimeout(() => this.abort(), this.timeoutMs);
+            this.timer.unref?.();
+            this.memTimer = setInterval(() => {
+                if (process.memoryUsage().rss <= this.rssLimit)
+                    return;
+                this.fail(this.memoryLimitError());
+            }, MEMORY_POLL_MS);
+            this.memTimer.unref?.();
+            this.signal?.addEventListener("abort", this.onAbort, { once: true });
+            void this.boot();
+        });
+    }
 }
-function isSandboxMessage(message) {
-    if (typeof message !== "object" || message === null || !("type" in message))
-        return false;
-    if (message.type === "calls") {
-        return "calls" in message
-            && Array.isArray(message.calls)
-            && message.calls.length > 0
-            && message.calls.length <= MAX_BRIDGE_CALLS
-            && message.calls.every((call) => isSandboxCall(call));
-    }
-    if (message.type !== "done"
-        || !("ok" in message)
-        || typeof message.ok !== "boolean"
-        || !("logs" in message)
-        || !Array.isArray(message.logs)
-        || message.logs.length > MAX_LOG_LINES
-        || !message.logs.every((line) => typeof line === "string" && line.length <= MAX_LOG_LINE_CHARS)
-        || message.logs.reduce((total, line) => total + line.length, 0) > MAX_LOG_CHARS) {
-        return false;
-    }
-    return !("error" in message)
-        || message.error === undefined
-        || (typeof message.error === "string" && message.error.length <= MAX_ERROR_CHARS);
+function bindHostMethods(asgrep) {
+    const wrap = (fn) => (args, options) => fn(args, options);
+    return {
+        search: wrap(asgrep.search.bind(asgrep)),
+        find: wrap(asgrep.find.bind(asgrep)),
+        read: wrap(asgrep.read.bind(asgrep)),
+        edit: wrap(asgrep.edit.bind(asgrep)),
+        semantic: wrap(asgrep.semantic.bind(asgrep)),
+        chain: wrap(asgrep.chain.bind(asgrep)),
+        defs: wrap(asgrep.defs.bind(asgrep)),
+        callers: wrap(asgrep.callers.bind(asgrep)),
+        imports: wrap(asgrep.imports.bind(asgrep)),
+        indexStatus: (_args, options) => asgrep.indexStatus(options),
+        indexRepo: wrap(asgrep.indexRepo.bind(asgrep)),
+        doctor: (_args, options) => asgrep.doctor(options),
+        catalogSearch: wrap(asgrep.catalogSearch.bind(asgrep)),
+        catalogDescribe: wrap(asgrep.catalogDescribe.bind(asgrep)),
+    };
 }
-function isSandboxCall(call) {
-    return typeof call === "object"
-        && call !== null
-        && "id" in call
-        && typeof call.id === "number"
-        && Number.isSafeInteger(call.id)
-        && call.id >= 0
-        && "method" in call
-        && typeof call.method === "string"
-        && "payload" in call
-        && typeof call.payload === "string";
+/** NAPI u64/i64 fields cross as BigInt; keep safe ints numeric, exact-string the rest. */
+const jsonSafe = (_key, item) => typeof item === "bigint"
+    ? item >= -9007199254740991n && item <= 9007199254740991n
+        ? Number(item)
+        : item.toString()
+    : item;
+/**
+ * Run model-generated JavaScript against the typed asgrep connector.
+ *
+ * Execution happens in a single-use worker_threads isolate: the guest gets a
+ * node:vm context inside the worker; asgrep/console are built there; the only
+ * host channel is a JSON postMessage bridge carrying runId envelopes. Timeout
+ * and abort call worker.terminate(), which is the only mechanism that actually
+ * stops a detached guest microtask or a runaway heap.
+ */
+export function runCodemode(rawCode, asgrep, options = {}) {
+    const admitted = admitRun(rawCode, options.timeoutMs, options.signal);
+    const wall0 = performance.now();
+    if ("error" in admitted) {
+        const out = {
+            ok: false, result: null, logs: [], error: admitted.error,
+            code: rawCode.slice(0, 200), wallMs: performance.now() - wall0,
+        };
+        const stats = options.stats?.();
+        if (stats)
+            out.stats = stats;
+        return Promise.resolve(out);
+    }
+    return new GuestRun(admitted.code, admitted.timeoutMs, bindHostMethods(asgrep), options.signal, options.stats, ++runSeq).start();
 }
 function safeErrorMessage(cause) {
     try {
@@ -211,32 +438,3 @@ function safeErrorMessage(cause) {
         return "codemode call failed";
     }
 }
-function stringifyBounded(value, maxBytes, label) {
-    let remaining = maxBytes;
-    const payload = JSON.stringify(value, (key, item) => {
-        remaining -= Buffer.byteLength(key) + 8;
-        if (typeof item === "string")
-            remaining -= Buffer.byteLength(item);
-        if (remaining < 0)
-            throw new Error(`${label} exceeds ${maxBytes} bytes`);
-        return item;
-    });
-    if (payload === undefined || Buffer.byteLength(payload) > maxBytes) {
-        throw new Error(`${label} exceeds ${maxBytes} bytes`);
-    }
-    return payload;
-}
-function resultOk(result, logs, code, wall0, statsFn) {
-    const out = { ok: true, result, logs, code, wallMs: Date.now() - wall0 };
-    const stats = statsFn?.();
-    if (stats)
-        out.stats = stats;
-    return out;
-}
-function resultErr(error, logs, code, wall0, statsFn) {
-    const out = { ok: false, result: null, logs, error, code, wallMs: Date.now() - wall0 };
-    const stats = statsFn?.();
-    if (stats)
-        out.stats = stats;
-    return out;
-}