@noodleseed/one 0.139.4 → 0.141.0

package/node_modules/@noodle-borg/compute/dist/quickjs-engine.js

@@ -1,5 +1,6 @@
-import { getQuickJS, newAsyncContext, shouldInterruptAfterDeadline, } from 'quickjs-emscripten';
 import { ComputeError, digestSource, } from './engine.js';
+import { hostErrorEnvelope } from './sandbox-eval.js';
+import { ComputeWorkerPool, sharedComputeWorkerPool, } from './worker-pool.js';
 /**
  * The first {@link ComputeEngine} backend: a QuickJS interpreter compiled to WebAssembly
  * (`quickjs-emscripten`). It runs tenant-authored JavaScript with **no ambient authority** — a fresh
@@ -7,6 +8,11 @@ import { ComputeError, digestSource, } from './engine.js';
  * `require`, or other host bindings), nondeterministic globals removed (`Date`, `Math.random`), and hard,
  * fail-closed bounds (wall-clock timeout, memory cap, output-size cap).
  *
+ * Execution happens on a bounded {@link ComputeWorkerPool} of worker threads rather than the main
+ * event loop, so one slow invocation cannot serialize independent invocations behind it or starve
+ * unrelated requests on the instance (issue #1307). The `timeoutMs` budget covers queue wait plus
+ * execution, and both durations are reported independently through the invoke `onTimings` callback.
+ *
  * The unit of code is **a JavaScript expression that evaluates to a function** `fn(input) -> output`
  * (e.g. `(input) => { ... }`). Input is JSON-marshaled in, output JSON-marshaled out — the boundary never
  * shares object references. When a host is provided, `callOperation` is the only injected capability and
@@ -19,7 +25,23 @@ import { ComputeError, digestSource, } from './engine.js';
 export class QuickJsComputeEngine {
     kind = 'interpreter';
     #sources = new Map();
-    #wasm;
+    #pool;
+    #ownsPool;
+    /**
+     * With no options the engine shares the process-wide worker pool, so many per-deployment engines
+     * stay within one bounded worker set. Passing options creates a private pool owned (and closed)
+     * by this engine.
+     */
+    constructor(options) {
+        if (options === undefined) {
+            this.#pool = sharedComputeWorkerPool();
+            this.#ownsPool = false;
+        }
+        else {
+            this.#pool = new ComputeWorkerPool(options);
+            this.#ownsPool = true;
+        }
+    }
     /** Hash and retain the source. (An AOT backend would emit and store a WASM module here instead.) */
     async compile(source) {
         return this.registerSource(source);
@@ -39,289 +61,83 @@ export class QuickJsComputeEngine {
         if (source === undefined) {
             throw new ComputeError('unknown_module', `no source registered for module ${module.digest}`);
         }
-        this.#wasm ??= await getQuickJS();
-        return new QuickJsComputeInstance(this.#wasm, source);
+        return new QuickJsComputeInstance(this.#pool, source);
+    }
+    /** Terminate a private pool's workers; a shared-pool engine has nothing to close. */
+    async close() {
+        if (this.#ownsPool)
+            await this.#pool.close();
     }
 }
-/** A runnable instance: each {@link invoke} spins a fresh, disposable QuickJS runtime for isolation. */
+/** A runnable instance: each {@link invoke} runs on a fresh QuickJS runtime in a pool worker. */
 class QuickJsComputeInstance {
-    #wasm;
+    #pool;
     #source;
-    constructor(wasm, source) {
-        this.#wasm = wasm;
+    constructor(pool, source) {
+        this.#pool = pool;
         this.#source = source;
     }
-    async invoke(input, limits, host) {
-        if (host)
-            return this.invokeWithHost(input, limits, host);
-        const runtime = this.#wasm.newRuntime();
-        runtime.setMemoryLimit(limits.memoryBytes);
-        runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + limits.timeoutMs));
-        const context = runtime.newContext();
+    invoke(input, limits, host, onTimings) {
+        // Serialize before submission: only JSON strings cross the thread boundary, and a hostile
+        // input must fail as a typed error here — never strand a worker slot or crash the queue pump.
+        // JSON.stringify returns undefined (not a string) for a top-level function or symbol.
+        let inputJson;
         try {
-            const wrapper = buildWrapper(this.#source, input);
-            const result = context.evalCode(wrapper, 'module.js');
-            if (result.error) {
-                const described = describeError(context, result.error);
-                result.error.dispose();
-                throw classifyError(described);
-            }
-            const out = readResult(context, result.value, limits.maxOutputBytes);
-            result.value.dispose();
-            return out;
-        }
-        finally {
-            context.dispose();
-            runtime.dispose();
+            inputJson = JSON.stringify(input ?? null);
         }
-    }
-    dispose() {
-        // No retained per-instance resources; runtimes are created and disposed per invoke.
-    }
-    async invokeWithHost(input, limits, host) {
-        const context = await newAsyncContext();
-        const runtime = context.runtime;
-        runtime.setMemoryLimit(limits.memoryBytes);
-        runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + limits.timeoutMs));
-        try {
-            installHostCall(context, host, limits);
-            if (host.log !== undefined)
-                installConsole(context, host);
-            const result = await context.evalCodeAsync(buildWrapper(this.#source, input, true, host.log !== undefined), 'module.js');
-            if (result.error) {
-                const described = describeError(context, result.error);
-                result.error.dispose();
-                throw classifyError(described);
-            }
-            const pendingResult = context.resolvePromise(result.value);
-            await drainPendingJobs(runtime, context);
-            const resolved = await pendingResult;
-            result.value.dispose();
-            if (resolved.error) {
-                const described = describeError(context, resolved.error);
-                resolved.error.dispose();
-                throw classifyError(described);
-            }
-            const out = readResult(context, resolved.value, limits.maxOutputBytes);
-            resolved.value.dispose();
-            return out;
+        catch {
+            return Promise.reject(new ComputeError('runtime_error', 'compute input is not JSON-serializable'));
         }
-        finally {
-            context.setProp(context.global, '__hostCallOperation', context.undefined);
-            context.setProp(context.global, '__hostLog', context.undefined);
-            context.setProp(context.global, 'console', context.undefined);
-            context.dispose();
-            runtime.dispose();
+        if (typeof inputJson !== 'string') {
+            return Promise.reject(new ComputeError('runtime_error', 'compute input is not JSON-serializable'));
         }
+        return this.#pool.execute({
+            source: this.#source,
+            inputJson,
+            limits,
+            ...(host === undefined ? {} : { host: envelopeBridge(host) }),
+            consoleEnabled: host?.log !== undefined,
+            ...(onTimings === undefined ? {} : { onTimings }),
+        });
     }
-}
-async function drainPendingJobs(runtime, context) {
-    while (runtime.hasPendingJob()) {
-        const jobs = await runtime.executePendingJobs();
-        if (jobs.error) {
-            const described = describeError(context, jobs.error);
-            jobs.error.dispose();
-            throw classifyError(described);
-        }
+    dispose() {
+        // No retained per-instance resources; runtimes live and die inside the pool workers.
     }
 }
 /**
- * Build the script run inside the sandbox. The handler source is wrapped as an expression, called with
- * the JSON-marshaled input, and its result re-serialized to a string. A prelude removes nondeterministic
- * globals so "deterministic by default" holds for the future resume/idempotency model
- * ([ADR 0004](../../../docs/decisions/0004-code-as-sandboxed-connector.md)).
+ * Adapt a {@link ComputeHost} to the pool's JSON-string bridge: parse the sandbox's argument JSON,
+ * run the host capability, and serialize the result (or a bounded, truncated failure) as the
+ * envelope the sandbox prelude understands. Host state never crosses in object form.
  */
-function buildWrapper(source, input, hostEnabled = false, consoleEnabled = false) {
-    const callOperationPrelude = hostEnabled
-        ? `
-var callOperation = function(name, args) {
-  var __hostEnvelope = JSON.parse(globalThis.__hostCallOperation(String(name), JSON.stringify(args ?? {})));
-  if (!__hostEnvelope.ok) {
-    var __err = new Error(__hostEnvelope.error.message || "host call failed");
-    __err.name = __hostEnvelope.error.code || "host_call_failed";
-    __err.code = __hostEnvelope.error.code;
-    __err.path = __hostEnvelope.error.path;
-    throw __err;
-  }
-  return __hostEnvelope.output;
-};
-`
-        : '';
-    const handlerArgs = hostEnabled
-        ? `${jsLiteral(input ?? null)}, { callOperation: callOperation }`
-        : jsLiteral(input ?? null);
-    const consolePrelude = consoleEnabled
-        ? `
-var console = Object.freeze({
-  debug: function() { return globalThis.__hostLog("debug", JSON.stringify(Array.prototype.slice.call(arguments))); },
-  info: function() { return globalThis.__hostLog("info", JSON.stringify(Array.prototype.slice.call(arguments))); },
-  log: function() { return globalThis.__hostLog("info", JSON.stringify(Array.prototype.slice.call(arguments))); },
-  warn: function() { return globalThis.__hostLog("warn", JSON.stringify(Array.prototype.slice.call(arguments))); },
-  error: function() { return globalThis.__hostLog("error", JSON.stringify(Array.prototype.slice.call(arguments))); }
-});
-`
-        : '';
-    const bodyPrefix = `"use strict";
-delete globalThis.Date;
-delete Math.random;
-${callOperationPrelude}
-${consolePrelude}
-var __handler = (${source});
-if (typeof __handler !== "function") { throw new TypeError("compute module must evaluate to a function"); }`;
-    if (hostEnabled) {
-        return `${bodyPrefix}
-Promise.resolve(__handler(${handlerArgs})).then(function(__value) {
-  var __out = JSON.stringify(__value);
-  return (typeof __out === "string") ? __out : "null";
-});`;
-    }
-    return `${bodyPrefix}
-var __out = JSON.stringify(__handler(${handlerArgs}));
-(typeof __out === "string") ? __out : "null";`;
-}
-function installHostCall(context, host, limits) {
-    let calls = 0;
-    const fn = context.newAsyncifiedFunction('__hostCallOperation', async (nameHandle, argsJsonHandle) => {
-        const envelope = async () => {
-            if (calls >= limits.maxHostCalls) {
-                return {
-                    ok: false,
-                    error: {
-                        code: 'host_call_denied',
-                        message: 'host call budget exceeded',
-                    },
-                };
-            }
-            calls += 1;
-            const name = context.getString(nameHandle);
-            let args;
+function envelopeBridge(host) {
+    return {
+        async callOperation(name, argsJson) {
+            const envelope = await (async () => {
+                try {
+                    const args = JSON.parse(argsJson);
+                    return { ok: true, output: await host.callOperation(name, args) };
+                }
+                catch (error) {
+                    return hostErrorEnvelope(error);
+                }
+            })();
             try {
-                args = JSON.parse(context.getString(argsJsonHandle));
+                return JSON.stringify(envelope);
             }
             catch {
-                return {
-                    ok: false,
-                    error: { code: 'host_call_denied', message: 'host call arguments must be JSON' },
-                };
-            }
-            if (args === null || typeof args !== 'object' || Array.isArray(args)) {
-                return {
+                return JSON.stringify({
                     ok: false,
-                    error: { code: 'host_call_denied', message: 'host call arguments must be an object' },
-                };
+                    error: { code: 'host_call_failed', message: 'host call output is not serializable' },
+                });
             }
-            try {
-                return {
-                    ok: true,
-                    output: await host.callOperation(name, args),
-                };
-            }
-            catch (error) {
-                const err = error;
-                return {
-                    ok: false,
-                    error: {
-                        code: typeof err.code === 'string' ? err.code : 'host_call_failed',
-                        message: typeof err.message === 'string' && err.message !== ''
-                            ? err.message.slice(0, 256)
-                            : 'host call failed',
-                        ...(typeof err.path === 'string' ? { path: err.path } : {}),
-                    },
-                };
-            }
-        };
-        return context.newString(JSON.stringify(await envelope()));
-    });
-    context.setProp(context.global, '__hostCallOperation', fn);
-    fn.dispose();
-}
-function installConsole(context, host) {
-    const fn = context.newAsyncifiedFunction('__hostLog', async (levelHandle, argsJsonHandle) => {
-        const level = normalizeLogLevel(context.getString(levelHandle));
-        const args = parseLogArgs(context.getString(argsJsonHandle));
-        const entry = formatLogEntry(level, args);
-        await host.log?.(entry);
-        return context.undefined;
-    });
-    context.setProp(context.global, '__hostLog', fn);
-    fn.dispose();
-}
-function normalizeLogLevel(level) {
-    return level === 'debug' || level === 'warn' || level === 'error' ? level : 'info';
-}
-function parseLogArgs(json) {
-    try {
-        const parsed = JSON.parse(json);
-        return Array.isArray(parsed) ? parsed : [];
-    }
-    catch {
-        return [];
-    }
-}
-const MAX_LOG_MESSAGE_CHARS = 1024;
-function formatLogEntry(level, args) {
-    const message = args.map(formatLogArg).join(' ');
-    if (message.length <= MAX_LOG_MESSAGE_CHARS)
-        return { level, message };
-    return { level, message: message.slice(0, MAX_LOG_MESSAGE_CHARS), truncated: true };
-}
-function formatLogArg(value) {
-    if (value === null || value === undefined)
-        return '';
-    const type = typeof value;
-    if (type === 'string')
-        return value;
-    if (type === 'number' || type === 'boolean')
-        return String(value);
-    return '[unloggable]';
-}
-/** Read the string completion value, enforcing the output-size cap, and parse it as JSON. */
-function readResult(context, value, maxOutputBytes) {
-    const text = context.getString(value);
-    if (Buffer.byteLength(text, 'utf8') > maxOutputBytes) {
-        throw new ComputeError('output_too_large', 'compute output exceeds the size limit');
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        throw new ComputeError('invalid_output', 'compute output is not valid JSON');
-    }
-}
-/** Extract a bounded `{ name, message }` from a sandbox error handle without leaking host state. */
-function describeError(context, handle) {
-    let dumped;
-    try {
-        dumped = context.dump(handle);
-    }
-    catch {
-        return { name: 'Error', message: 'sandbox error' };
-    }
-    if (dumped !== null && typeof dumped === 'object') {
-        const o = dumped;
-        const name = typeof o.name === 'string' ? o.name : 'Error';
-        const message = typeof o.message === 'string' ? o.message : '';
-        return { name, message };
-    }
-    return { name: 'Error', message: String(dumped) };
-}
-/** Map a sandbox error to a stable {@link ComputeError} code; truncate the relayed message. */
-function classifyError(described) {
-    const lower = described.message.toLowerCase();
-    if (lower.includes('interrupted')) {
-        return new ComputeError('timeout', 'compute exceeded its time budget');
-    }
-    if (lower.includes('out of memory')) {
-        return new ComputeError('memory', 'compute exceeded its memory limit');
-    }
-    if (described.name === 'host_call_denied' || described.name === 'host_call_failed') {
-        return new ComputeError(described.name, described.message.slice(0, 256) || 'host call failed');
-    }
-    const detail = `${described.name}: ${described.message}`.slice(0, 256);
-    return new ComputeError('runtime_error', detail);
-}
-/** Embed a JSON-safe value as a JavaScript literal, escaping the line/paragraph separators. */
-function jsLiteral(value) {
-    return JSON.stringify(value).replace(/[\u2028\u2029]/g, (c) => c === '\u2028' ? '\\u2028' : '\\u2029');
+        },
+        ...(host.log === undefined
+            ? {}
+            : {
+                log: async (entry) => {
+                    await host.log?.(entry);
+                },
+            }),
+    };
 }
 //# sourceMappingURL=quickjs-engine.js.map

package/node_modules/@noodle-borg/compute/dist/sandbox-eval.js

@@ -0,0 +1,276 @@
+import { shouldInterruptAfterDeadline } from 'quickjs-emscripten';
+import { ComputeError, } from './engine.js';
+/**
+ * Normalize a host-call failure into a bounded error envelope. The code/path pass through only as
+ * strings and the message is truncated, so backend internals never re-enter sandbox code.
+ */
+export function hostErrorEnvelope(error) {
+    const err = error;
+    return {
+        ok: false,
+        error: {
+            code: typeof err.code === 'string' ? err.code : 'host_call_failed',
+            message: typeof err.message === 'string' && err.message !== ''
+                ? err.message.slice(0, 256)
+                : 'host call failed',
+            ...(typeof err.path === 'string' ? { path: err.path } : {}),
+        },
+    };
+}
+/** Run a pure (no-host) invocation synchronously on a fresh, disposable QuickJS runtime. */
+export function runPure(wasm, source, input, limits) {
+    const runtime = wasm.newRuntime();
+    runtime.setMemoryLimit(limits.memoryBytes);
+    runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + limits.timeoutMs));
+    const context = runtime.newContext();
+    try {
+        const wrapper = buildWrapper(source, input);
+        const result = context.evalCode(wrapper, 'module.js');
+        if (result.error) {
+            const described = describeError(context, result.error);
+            result.error.dispose();
+            throw classifyError(described);
+        }
+        const out = readResultString(context, result.value, limits.maxOutputBytes);
+        result.value.dispose();
+        return out;
+    }
+    finally {
+        context.dispose();
+        runtime.dispose();
+    }
+}
+/** Run a host-mediated invocation on a fresh asyncified context from the worker's shared module. */
+export async function runHosted(wasm, source, input, limits, bridge) {
+    const context = wasm.newContext();
+    const runtime = context.runtime;
+    runtime.setMemoryLimit(limits.memoryBytes);
+    runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + limits.timeoutMs));
+    try {
+        installHostCall(context, bridge, limits);
+        if (bridge.log !== undefined)
+            installConsole(context, bridge);
+        const result = await context.evalCodeAsync(buildWrapper(source, input, true, bridge.log !== undefined), 'module.js');
+        if (result.error) {
+            const described = describeError(context, result.error);
+            result.error.dispose();
+            throw classifyError(described);
+        }
+        const pendingResult = context.resolvePromise(result.value);
+        await drainPendingJobs(runtime, context);
+        const resolved = await pendingResult;
+        result.value.dispose();
+        if (resolved.error) {
+            const described = describeError(context, resolved.error);
+            resolved.error.dispose();
+            throw classifyError(described);
+        }
+        const out = readResultString(context, resolved.value, limits.maxOutputBytes);
+        resolved.value.dispose();
+        return out;
+    }
+    finally {
+        // The module-created context owns its runtime: disposing the context frees the runtime and
+        // every global, so no per-global cleanup or separate runtime.dispose() belongs here.
+        context.dispose();
+    }
+}
+async function drainPendingJobs(runtime, context) {
+    while (runtime.hasPendingJob()) {
+        const jobs = await runtime.executePendingJobs();
+        if (jobs.error) {
+            const described = describeError(context, jobs.error);
+            jobs.error.dispose();
+            throw classifyError(described);
+        }
+    }
+}
+/**
+ * Build the script run inside the sandbox. The handler source is wrapped as an expression, called
+ * with the JSON-marshaled input, and its result re-serialized to a string. A prelude removes
+ * nondeterministic globals so "deterministic by default" holds for the future resume/idempotency
+ * model ([ADR 0004](../../../docs/decisions/0004-code-as-sandboxed-connector.md)).
+ */
+function buildWrapper(source, input, hostEnabled = false, consoleEnabled = false) {
+    const callOperationPrelude = hostEnabled
+        ? `
+var callOperation = function(name, args) {
+  var __hostEnvelope = JSON.parse(globalThis.__hostCallOperation(String(name), JSON.stringify(args ?? {})));
+  if (!__hostEnvelope.ok) {
+    var __err = new Error(__hostEnvelope.error.message || "host call failed");
+    __err.name = __hostEnvelope.error.code || "host_call_failed";
+    __err.code = __hostEnvelope.error.code;
+    __err.path = __hostEnvelope.error.path;
+    throw __err;
+  }
+  return __hostEnvelope.output;
+};
+`
+        : '';
+    const handlerArgs = hostEnabled
+        ? `${jsLiteral(input ?? null)}, { callOperation: callOperation }`
+        : jsLiteral(input ?? null);
+    const consolePrelude = consoleEnabled
+        ? `
+var console = Object.freeze({
+  debug: function() { return globalThis.__hostLog("debug", JSON.stringify(Array.prototype.slice.call(arguments))); },
+  info: function() { return globalThis.__hostLog("info", JSON.stringify(Array.prototype.slice.call(arguments))); },
+  log: function() { return globalThis.__hostLog("info", JSON.stringify(Array.prototype.slice.call(arguments))); },
+  warn: function() { return globalThis.__hostLog("warn", JSON.stringify(Array.prototype.slice.call(arguments))); },
+  error: function() { return globalThis.__hostLog("error", JSON.stringify(Array.prototype.slice.call(arguments))); }
+});
+`
+        : '';
+    const bodyPrefix = `"use strict";
+delete globalThis.Date;
+delete Math.random;
+${callOperationPrelude}
+${consolePrelude}
+var __handler = (${source});
+if (typeof __handler !== "function") { throw new TypeError("compute module must evaluate to a function"); }`;
+    if (hostEnabled) {
+        return `${bodyPrefix}
+Promise.resolve(__handler(${handlerArgs})).then(function(__value) {
+  var __out = JSON.stringify(__value);
+  return (typeof __out === "string") ? __out : "null";
+});`;
+    }
+    return `${bodyPrefix}
+var __out = JSON.stringify(__handler(${handlerArgs}));
+(typeof __out === "string") ? __out : "null";`;
+}
+function installHostCall(context, bridge, limits) {
+    let calls = 0;
+    const fn = context.newAsyncifiedFunction('__hostCallOperation', async (nameHandle, argsJsonHandle) => {
+        const envelopeJson = await (async () => {
+            if (calls >= limits.maxHostCalls) {
+                return JSON.stringify({
+                    ok: false,
+                    error: { code: 'host_call_denied', message: 'host call budget exceeded' },
+                });
+            }
+            calls += 1;
+            const name = context.getString(nameHandle);
+            const argsJson = context.getString(argsJsonHandle);
+            let args;
+            try {
+                args = JSON.parse(argsJson);
+            }
+            catch {
+                return JSON.stringify({
+                    ok: false,
+                    error: { code: 'host_call_denied', message: 'host call arguments must be JSON' },
+                });
+            }
+            if (args === null || typeof args !== 'object' || Array.isArray(args)) {
+                return JSON.stringify({
+                    ok: false,
+                    error: { code: 'host_call_denied', message: 'host call arguments must be an object' },
+                });
+            }
+            try {
+                return await bridge.callOperation(name, argsJson);
+            }
+            catch {
+                return JSON.stringify({
+                    ok: false,
+                    error: { code: 'host_call_failed', message: 'host call failed' },
+                });
+            }
+        })();
+        return context.newString(envelopeJson);
+    });
+    context.setProp(context.global, '__hostCallOperation', fn);
+    fn.dispose();
+}
+function installConsole(context, bridge) {
+    const fn = context.newAsyncifiedFunction('__hostLog', async (levelHandle, argsJsonHandle) => {
+        const level = normalizeLogLevel(context.getString(levelHandle));
+        const args = parseLogArgs(context.getString(argsJsonHandle));
+        const entry = formatLogEntry(level, args);
+        await bridge.log?.(entry);
+        return context.undefined;
+    });
+    context.setProp(context.global, '__hostLog', fn);
+    fn.dispose();
+}
+function normalizeLogLevel(level) {
+    return level === 'debug' || level === 'warn' || level === 'error' ? level : 'info';
+}
+function parseLogArgs(json) {
+    try {
+        const parsed = JSON.parse(json);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+const MAX_LOG_MESSAGE_CHARS = 1024;
+function formatLogEntry(level, args) {
+    const message = args.map(formatLogArg).join(' ');
+    if (message.length <= MAX_LOG_MESSAGE_CHARS)
+        return { level, message };
+    return { level, message: message.slice(0, MAX_LOG_MESSAGE_CHARS), truncated: true };
+}
+function formatLogArg(value) {
+    if (value === null || value === undefined)
+        return '';
+    const type = typeof value;
+    if (type === 'string')
+        return value;
+    if (type === 'number' || type === 'boolean')
+        return String(value);
+    return '[unloggable]';
+}
+/** Read the string completion value, enforcing the output-size cap and JSON validity. */
+function readResultString(context, value, maxOutputBytes) {
+    const text = context.getString(value);
+    if (Buffer.byteLength(text, 'utf8') > maxOutputBytes) {
+        throw new ComputeError('output_too_large', 'compute output exceeds the size limit');
+    }
+    try {
+        JSON.parse(text);
+    }
+    catch {
+        throw new ComputeError('invalid_output', 'compute output is not valid JSON');
+    }
+    return text;
+}
+/** Extract a bounded `{ name, message }` from a sandbox error handle without leaking host state. */
+function describeError(context, handle) {
+    let dumped;
+    try {
+        dumped = context.dump(handle);
+    }
+    catch {
+        return { name: 'Error', message: 'sandbox error' };
+    }
+    if (dumped !== null && typeof dumped === 'object') {
+        const o = dumped;
+        const name = typeof o.name === 'string' ? o.name : 'Error';
+        const message = typeof o.message === 'string' ? o.message : '';
+        return { name, message };
+    }
+    return { name: 'Error', message: String(dumped) };
+}
+/** Map a sandbox error to a stable {@link ComputeError} code; truncate the relayed message. */
+function classifyError(described) {
+    const lower = described.message.toLowerCase();
+    if (lower.includes('interrupted')) {
+        return new ComputeError('timeout', 'compute exceeded its time budget');
+    }
+    if (lower.includes('out of memory')) {
+        return new ComputeError('memory', 'compute exceeded its memory limit');
+    }
+    if (described.name === 'host_call_denied' || described.name === 'host_call_failed') {
+        return new ComputeError(described.name, described.message.slice(0, 256) || 'host call failed');
+    }
+    const detail = `${described.name}: ${described.message}`.slice(0, 256);
+    return new ComputeError('runtime_error', detail);
+}
+/** Embed a JSON-safe value as a JavaScript literal, escaping the line/paragraph separators. */
+function jsLiteral(value) {
+    return JSON.stringify(value).replace(/[\u2028\u2029]/g, (c) => c === '\u2028' ? '\\u2028' : '\\u2029');
+}
+//# sourceMappingURL=sandbox-eval.js.map