@openpond/evals 0.7.4 → 0.7.6

package/dist/javascript-isolate-process.js

@@ -0,0 +1,75 @@
+import { spawn } from "node:child_process";
+import { javascriptIsolateProcessSource } from "./javascript-isolate-process-source.js";
+import { JavaScriptIsolateExecutionError, validateJavaScriptIsolateInput } from "./javascript-isolate.js";
+import { assertBoundedTaskJson } from "./task-schema.js";
+/** A Node subprocess owns the interpreter; completion always waits for its exit. */
+export async function executeJavaScriptIsolateInProcess(input) {
+    input.signal?.throwIfAborted();
+    validateJavaScriptIsolateInput(input);
+    const { signal, ...data } = input;
+    const error = (suffix) => new Error(`${input.errorPrefix}_${suffix}`);
+    // The authored source remains JSON data passed to QuickJS, never host code.
+    const program = `globalThis.__openpondIsolateInput = JSON.parse(${JSON.stringify(JSON.stringify(data))});\n${javascriptIsolateProcessSource}`;
+    return new Promise((resolve, reject) => {
+        const child = spawn("node", ["--max-old-space-size=64", "--input-type=commonjs", "-"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { PATH: process.env.PATH },
+            windowsHide: true,
+        });
+        let failure;
+        let response = "";
+        let responseBytes = 0;
+        let stderrBytes = 0;
+        const stop = (cause) => {
+            failure ??= cause;
+            child.kill("SIGKILL");
+        };
+        const cancel = () => stop(signal?.reason instanceof Error ? signal.reason : error("cancelled"));
+        const timer = setTimeout(() => stop(input.errorPrefix === "candidate" ? new JavaScriptIsolateExecutionError("candidate_timeout") : error("timeout")), input.timeoutMs);
+        signal?.addEventListener("abort", cancel, { once: true });
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            responseBytes += Buffer.byteLength(chunk);
+            if (responseBytes > input.maxResultBytes + 65_536)
+                stop(error("process_response_too_large"));
+            else
+                response += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderrBytes += chunk.byteLength;
+            if (stderrBytes > 65_536)
+                stop(error("process_stderr_too_large"));
+        });
+        child.once("error", (cause) => { failure ??= cause; });
+        child.stdin.on("error", (cause) => stop(cause));
+        child.once("close", (code) => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", cancel);
+            if (failure) {
+                reject(failure);
+                return;
+            }
+            try {
+                if (code !== 0)
+                    throw error("process_exited_without_result");
+                const message = JSON.parse(response);
+                if (!message || typeof message !== "object" || !("ok" in message))
+                    throw error("process_invalid_response");
+                if (message.ok !== true) {
+                    const detail = "error" in message && typeof message.error === "string" ? message.error : `${input.errorPrefix}_execution_failed`;
+                    throw "executionError" in message && message.executionError === true ? new JavaScriptIsolateExecutionError(detail) : new Error(detail);
+                }
+                if (!("result" in message))
+                    throw error("process_invalid_response");
+                assertBoundedTaskJson(message.result, input.maxResultBytes);
+                resolve(message.result);
+            }
+            catch (cause) {
+                reject(cause instanceof Error ? cause : error("process_invalid_response"));
+            }
+        });
+        child.stdin.end(program);
+        if (signal?.aborted)
+            cancel();
+    });
+}

package/dist/javascript-isolate.js

@@ -1,6 +1,9 @@
 import { newQuickJSWASMModuleFromVariant, Scope } from "quickjs-emscripten-core";
 import variant from "@jitl/quickjs-singlefile-cjs-release-sync";
 import { assertBoundedTaskJson } from "./task-schema.js";
+export class JavaScriptIsolateExecutionError extends Error {
+    constructor(message) { super(message); this.name = "JavaScriptIsolateExecutionError"; }
+}
 /** Authored code is interpreter data, with no host functions or module loader. */
 export async function executeJavaScriptIsolate(input) {
     validateJavaScriptIsolateInput(input);
@@ -9,37 +12,43 @@ export async function executeJavaScriptIsolate(input) {
     const deadline = Date.now() + input.timeoutMs;
     const module = await newQuickJSWASMModuleFromVariant(variant);
     input.signal?.throwIfAborted();
-    return Scope.withScope((scope) => {
-        const runtime = scope.manage(module.newRuntime());
-        runtime.setMemoryLimit(33_554_432);
-        runtime.setMaxStackSize(262_144);
-        runtime.setInterruptHandler(() => Date.now() >= deadline || input.signal?.aborted === true);
-        const context = scope.manage(runtime.newContext());
-        if (input.deterministic) {
-            scope.manage(context.unwrapResult(context.evalCode("globalThis.Date = undefined; Math.random = () => { throw new Error('environment_random_requires_explicit_seed'); };")));
-        }
-        const stringify = scope.manage(context.unwrapResult(context.evalCode("JSON.stringify")));
-        const argument = scope.manage(context.unwrapResult(context.evalCode(`JSON.parse(${JSON.stringify(JSON.stringify(input.value))})`)));
-        const exported = scope.manage(context.unwrapResult(context.evalCode(input.source, `${input.errorPrefix}.mjs`, { type: "module" })));
-        const namespace = scope.manage(settle(context, exported, deadline, input.signal, error));
-        const fn = scope.manage(context.getProp(namespace, input.exportName));
-        if (context.typeof(fn) !== "function")
-            throw error("function_export_missing");
-        const returned = scope.manage(context.unwrapResult(context.callFunction(fn, context.undefined, argument)));
-        const result = scope.manage(settle(context, returned, deadline, input.signal, error));
-        const serialized = scope.manage(context.unwrapResult(context.callFunction(stringify, context.undefined, result)));
-        if (context.typeof(serialized) !== "string")
-            throw error("result_not_json");
-        const json = context.getString(serialized);
-        if (new TextEncoder().encode(json).byteLength > input.maxResultBytes)
-            throw error("result_too_large");
+    try {
+        return Scope.withScope((scope) => {
+            const runtime = scope.manage(module.newRuntime());
+            runtime.setMemoryLimit(33_554_432);
+            runtime.setMaxStackSize(262_144);
+            runtime.setInterruptHandler(() => Date.now() >= deadline || input.signal?.aborted === true);
+            const context = scope.manage(runtime.newContext());
+            if (input.deterministic) {
+                scope.manage(context.unwrapResult(context.evalCode("globalThis.Date = undefined; Math.random = () => { throw new Error('environment_random_requires_explicit_seed'); };")));
+            }
+            const stringify = scope.manage(context.unwrapResult(context.evalCode("JSON.stringify")));
+            const argument = scope.manage(context.unwrapResult(context.evalCode(`JSON.parse(${JSON.stringify(JSON.stringify(input.value))})`)));
+            const exported = scope.manage(context.unwrapResult(context.evalCode(input.source, `${input.errorPrefix}.mjs`, { type: "module" })));
+            const namespace = scope.manage(settle(context, exported, deadline, input.signal, error));
+            const fn = scope.manage(context.getProp(namespace, input.exportName));
+            if (context.typeof(fn) !== "function")
+                throw error("function_export_missing");
+            const returned = scope.manage(context.unwrapResult(context.callFunction(fn, context.undefined, argument)));
+            const result = scope.manage(settle(context, returned, deadline, input.signal, error));
+            const serialized = scope.manage(context.unwrapResult(context.callFunction(stringify, context.undefined, result)));
+            if (context.typeof(serialized) !== "string")
+                throw error("result_not_json");
+            const json = context.getString(serialized);
+            if (new TextEncoder().encode(json).byteLength > input.maxResultBytes)
+                throw error("result_too_large");
+            input.signal?.throwIfAborted();
+            if (Date.now() >= deadline)
+                throw error("timeout");
+            const value = JSON.parse(json);
+            assertBoundedTaskJson(value, input.maxResultBytes);
+            return value;
+        });
+    }
+    catch (cause) {
         input.signal?.throwIfAborted();
-        if (Date.now() >= deadline)
-            throw error("timeout");
-        const value = JSON.parse(json);
-        assertBoundedTaskJson(value, input.maxResultBytes);
-        return value;
-    });
+        throw new JavaScriptIsolateExecutionError(cause instanceof Error ? cause.message : "JavaScript execution failed.");
+    }
 }
 export function validateJavaScriptIsolateInput(input) {
     if (!Number.isInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 300_000)

package/dist/javascript-verifier-node.js

@@ -1,6 +1,11 @@
 import { JavaScriptVerifierResultSchema } from "./javascript-verifier-contract.js";
 import { executeJavaScriptIsolateInWorker } from "./javascript-isolate-node.js";
+import { executeJavaScriptIsolateInProcess } from "./javascript-isolate-process.js";
 /** Resolves/rejects only after the execution owner has stopped the worker. */
 export async function executeJavaScriptVerifierInWorker(input) {
     return JavaScriptVerifierResultSchema.parse(await executeJavaScriptIsolateInWorker({ ...input, exportName: input.exportName ?? "verify", maxResultBytes: 65_536, errorPrefix: "verifier" }));
 }
+/** Uses a Node child process and waits for exit on success, failure, or cancellation. */
+export async function executeJavaScriptVerifierInProcess(input) {
+    return JavaScriptVerifierResultSchema.parse(await executeJavaScriptIsolateInProcess({ ...input, exportName: input.exportName ?? "verify", maxResultBytes: 65_536, errorPrefix: "verifier" }));
+}