@openpond/evals 0.12.4 → 0.12.6

package/dist/javascript-isolate-process.js

@@ -1,6 +1,18 @@
 import { spawn } from "node:child_process";
 import { JavaScriptIsolateExecutionError, validateJavaScriptIsolateInput } from "./javascript-isolate.js";
 import { assertBoundedTaskJson } from "./task-schema.js";
+/** Created only by the trusted parent wall timer, never from guest error text.
+ * The process executor rejects with this error only after child exit. */
+export class JavaScriptVerifierHostTimeoutError extends Error {
+    timeoutMs;
+    elapsedMs;
+    constructor(timeoutMs, elapsedMs) {
+        super("verifier_timeout");
+        this.timeoutMs = timeoutMs;
+        this.elapsedMs = elapsedMs;
+        this.name = "JavaScriptVerifierHostTimeoutError";
+    }
+}
 /** A Node subprocess owns the interpreter; completion always waits for its exit. */
 export async function executeJavaScriptIsolateInProcess(input) {
     input.signal?.throwIfAborted();
@@ -12,8 +24,9 @@ export async function executeJavaScriptIsolateInProcess(input) {
     // The authored source remains JSON data passed to QuickJS, never host code.
     const program = `globalThis.__openpondIsolateInput = JSON.parse(${JSON.stringify(JSON.stringify(data))});\n${stripTypeScript ? 'globalThis.__openpondIsolateInput.source = require("node:module").stripTypeScriptTypes(globalThis.__openpondIsolateInput.source, { mode: "strip" });\n' : ""}${javascriptIsolateProcessSource}`;
     return new Promise((resolve, reject) => {
+        const startedAt = performance.now();
         const child = spawn("node", ["--max-old-space-size=64", "--input-type=commonjs", "-"], {
-            stdio: ["pipe", "pipe", "pipe"],
+            stdio: ["pipe", "pipe", "pipe", "ipc"],
             env: { PATH: process.env.PATH },
             windowsHide: true,
         });
@@ -26,7 +39,26 @@ export async function executeJavaScriptIsolateInProcess(input) {
             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);
+        const verifier = input.errorPrefix === "verifier";
+        let executionReady = !verifier;
+        const timedOut = () => stop(input.errorPrefix === "candidate"
+            ? new JavaScriptIsolateExecutionError("candidate_timeout")
+            : input.errorPrefix === "verifier"
+                ? new JavaScriptVerifierHostTimeoutError(input.timeoutMs, performance.now() - startedAt)
+                : error("timeout"));
+        // Cold Node/WASM initialization has its own finite bound. It must not
+        // consume the authored verifier budget, and cancellation covers both phases.
+        let timer = setTimeout(timedOut, verifier ? 30_000 : input.timeoutMs);
+        child.on("message", (message) => {
+            if (!verifier || executionReady || !message || typeof message !== "object" ||
+                !("type" in message) || message.type !== "execution_ready") {
+                stop(error("process_invalid_startup_message"));
+                return;
+            }
+            executionReady = true;
+            clearTimeout(timer);
+            timer = setTimeout(timedOut, input.timeoutMs);
+        });
         signal?.addEventListener("abort", cancel, { once: true });
         child.stdout.setEncoding("utf8");
         child.stdout.on("data", (chunk) => {
@@ -53,6 +85,8 @@ export async function executeJavaScriptIsolateInProcess(input) {
             try {
                 if (code !== 0)
                     throw error("process_exited_without_result");
+                if (!executionReady)
+                    throw error("process_exited_before_ready");
                 const message = JSON.parse(response);
                 if (!message || typeof message !== "object" || !("ok" in message))
                     throw error("process_invalid_response");

package/dist/javascript-isolate.js

@@ -4,11 +4,11 @@ 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) {
+export async function executeJavaScriptIsolate(input, host) {
     validateJavaScriptIsolateInput(input);
     input.signal?.throwIfAborted();
     const error = (suffix) => new Error(`${input.errorPrefix}_${suffix}`);
-    const deadline = Date.now() + input.timeoutMs;
+    let deadline = Date.now() + input.timeoutMs;
     const { default: variant } = await import("@jitl/quickjs-singlefile-cjs-release-sync");
     input.signal?.throwIfAborted();
     const module = await newQuickJSWASMModuleFromVariant(variant);
@@ -20,6 +20,12 @@ export async function executeJavaScriptIsolate(input) {
             runtime.setMaxStackSize(262_144);
             runtime.setInterruptHandler(() => Date.now() >= deadline || input.signal?.aborted === true);
             const context = scope.manage(runtime.newContext());
+            // Only a trusted process owner supplies this hook. Interpreter startup is
+            // bounded by that owner; authored source gets its pinned execution budget.
+            if (host) {
+                deadline = Date.now() + input.timeoutMs;
+                host.onExecutionReady();
+            }
             if (input.deterministic) {
                 scope.manage(context.unwrapResult(context.evalCode("globalThis.Date = undefined; Math.random = () => { throw new Error('environment_random_requires_explicit_seed'); };")));
             }

package/dist/javascript-verifier-node.js

@@ -1,6 +1,7 @@
 import { assertIsolatedVerifierRuntime, JavaScriptVerifierResultSchema } from "./javascript-verifier-contract.js";
 import { executeJavaScriptIsolateInWorker } from "./javascript-isolate-node.js";
 import { executeJavaScriptIsolateInProcess } from "./javascript-isolate-process.js";
+export { JavaScriptVerifierHostTimeoutError } from "./javascript-isolate-process.js";
 /** Resolves/rejects only after the execution owner has stopped the worker. */
 export async function executeJavaScriptVerifierInWorker(input) {
     assertIsolatedVerifierRuntime(input.runtime);