@openpond/evals 0.7.2 → 0.7.3

package/JAVASCRIPT_ENVIRONMENTS.md

@@ -0,0 +1,58 @@
+# JavaScript tool environments
+
+These entrypoints execute authored tool modules over owner-held JSON state:
+
+- `@openpond/evals/javascript-environment` validates immutable definitions and creates an episode with `step`, `collect`, `snapshot` and `destroy`.
+- `@openpond/evals/javascript-environment/node` executes each operation in a terminable worker around the isolated interpreter.
+- `@openpond/evals/javascript-environment/attempt` runs a policy adapter through the declared tools and returns its messages, output and independently recorded state.
+
+The interpreter exposes no host functions, filesystem, network, timers or module loader. Environment code receives an explicit seed and supplied inputs; ambient `Date` and `Math.random` are unavailable. A module cannot call a production connector or launch a process. Tools that require those capabilities need a separate host adapter and its permissions.
+
+## Module contract
+
+Publish the module as a `LearningTextAsset` with `host_private` visibility. Its exact asset reference belongs in a sealed `JavaScriptEnvironmentDefinition`. The definition lists each tool's schema, schema hash, side effect and timeout, plus episode step and byte limits.
+
+The module exports five functions: `create`, `reset`, `step`, `collect` and `destroy`. Each receives one JSON object with `input`, `initialState`, `seed`, `state`, `sequence` and `action`. Every operation returns `{ state, observation }`, both JSON objects. `action` is null except during `step`, when it contains `{ name, arguments }`.
+
+For example, a scoped record environment can implement:
+
+```js
+export function create({ initialState }) {
+  return { state: initialState, observation: {} };
+}
+export const reset = create;
+export function step({ input, state, action }) {
+  if (action.name === "read_record") {
+    return { state, observation: { record: state[action.arguments.id] ?? null } };
+  }
+  if (action.arguments.id !== input.allowedId) {
+    return { state, observation: { error: "outside_scope" } };
+  }
+  return {
+    state: { ...state, [action.arguments.id]: action.arguments.value },
+    observation: { updated: true },
+  };
+}
+export function collect({ state }) {
+  return { state, observation: {} };
+}
+export function destroy() {
+  return { state: {}, observation: {} };
+}
+```
+
+Declare `read_record` as read-only and the update tool as a write. The owner verifies arguments before execution and rejects any state change from a read-only tool or collection. A failed operation leaves state unchanged. Invalid calls consume the step budget. The module can return an error observation for a simulated service failure while retaining an intentional transition, such as an idempotency record.
+
+## Policy and evidence boundary
+
+`runJavaScriptEnvironmentAttempt` supplies the policy adapter with copied messages and tool declarations. Initial state, module source and evaluator targets are not policy inputs. Initial and subsequent observations come from the module; the owner retains state and records every executed operation with its arguments, observation and before/after hashes.
+
+A policy response contains `text` and `toolCalls`. Each call has a unique `id`, a declared `name` and JSON-object `arguments`. The loop executes calls sequentially, returns validation errors as tool observations and stops at the step, transcript or time limit. It collects state only after a final response with no tool calls. A model's claim about final state never replaces the recorded state.
+
+Hosts persist the returned attempt under their task/model/release identity and grade the captured state with private checks. The attempt's content hash covers its task identity, status, output, state snapshot and messages. Completion of execution is not a passing grade, training qualification or promotion approval.
+
+## Lifecycle ownership
+
+Server hosts should pass `executeJavaScriptEnvironmentInWorker` as the session or attempt runner. Each worker runs a fresh interpreter. A promise settles only after the worker is terminated, including timeout and cancellation. The session rejects overlapping operations and waits for an active operation to stop before cleanup. Call `destroy` in `finally` when using the session API directly; the attempt runner does this automatically.
+
+The policy adapter must honor its supplied abort signal and settle after cancelling its own request. `environmentCleanupComplete` describes environment cleanup only; it is not a provider billing or infrastructure-cleanup receipt. Failed creation, collection, cancellation and cleanup remain explicit states, without fabricated scores.

package/README.md

@@ -2,6 +2,8 @@
 
 See [task evidence and learning](./LEARNING.md) for reusable Rewards, task-format publication, SDK/HTTP intake, grading, review and approved batches.
 
+See [JavaScript tool environments](./JAVASCRIPT_ENVIRONMENTS.md) for isolated state transitions, policy tool loops and owner-recorded execution evidence.
+
 Portable evaluation and benchmark contracts plus pure helpers for Tasksets,
 graders, run manifests, attempt and evaluation receipts, paired benchmark
 comparisons, execution adapters, conformance fixtures, Work-evidence

package/dist/javascript-environment-attempt.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import { contentHash } from "@openpond/harness";
+import { assertBoundedTaskJson } from "./task-schema.js";
+import { createJavaScriptEnvironmentSession, JavaScriptEnvironmentActionError } from "./javascript-environment.js";
+const ToolCallSchema = z.object({ id: z.string().min(1).max(200), name: z.string().min(1).max(64), arguments: z.record(z.string(), z.unknown()) }).strict();
+const PolicyTurnSchema = z.object({ text: z.string().max(262_144), toolCalls: z.array(ToolCallSchema).max(200) }).strict();
+/** The policy receives observations, never source, initial state or evaluator
+ * targets. Its final text cannot replace state recorded by the environment.
+ * The policy adapter must honor signal and settle after its own cancellation. */
+export async function runJavaScriptEnvironmentAttempt(input) {
+    if (!input.taskId || input.taskId.length > 500)
+        throw new Error("environment_task_identity_invalid");
+    if (!Number.isInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 3_600_000)
+        throw new Error("environment_attempt_timeout_invalid");
+    assertBoundedTaskJson(input.instructions, 262_144);
+    const taskId = input.taskId, instructions = input.instructions;
+    const taskInput = structuredClone(input.input), policy = input.policy;
+    const controller = new AbortController();
+    const signal = input.signal ? AbortSignal.any([controller.signal, input.signal]) : controller.signal;
+    let timedOut = false;
+    const timer = setTimeout(() => { timedOut = true; controller.abort(new Error("environment_attempt_timeout")); }, input.timeoutMs);
+    timer.unref?.();
+    let session = null;
+    let snapshot = null;
+    let status = "environment_failure";
+    let output = null, error = null;
+    let collected = false, environmentCleanupComplete = false;
+    const messages = [];
+    let transcriptBytes = 0;
+    const append = (message) => {
+        transcriptBytes += new TextEncoder().encode(JSON.stringify(message)).byteLength;
+        if (transcriptBytes > 4_194_304) {
+            status = "budget_exhausted";
+            throw new Error("environment_transcript_budget_exhausted");
+        }
+        messages.push(message);
+    };
+    const callIds = new Set();
+    try {
+        session = await createJavaScriptEnvironmentSession({ ...input, input: taskInput, signal });
+        append({ role: "system", text: instructions });
+        append({ role: "user", text: JSON.stringify({ input: taskInput, observation: session.observation }) });
+        for (let turn = 0; turn <= session.definition.maxSteps; turn++) {
+            signal.throwIfAborted();
+            let response;
+            try {
+                const value = await policy({ messages: structuredClone(messages), tools: structuredClone(session.definition.tools), signal });
+                assertBoundedTaskJson(value, 1_048_576);
+                response = structuredClone(PolicyTurnSchema.parse(value));
+                for (const call of response.toolCalls) {
+                    if (callIds.has(call.id))
+                        throw new Error("environment_duplicate_tool_call_identity");
+                    callIds.add(call.id);
+                }
+            }
+            catch (cause) {
+                if (signal.aborted)
+                    throw cause;
+                status = "policy_failure";
+                throw cause;
+            }
+            signal.throwIfAborted();
+            append({ role: "assistant", ...response });
+            if (!response.toolCalls.length) {
+                output = response.text;
+                await session.collect();
+                snapshot = session.snapshot();
+                collected = true;
+                status = "completed";
+                break;
+            }
+            for (const call of response.toolCalls) {
+                let observation;
+                try {
+                    observation = await session.step({ name: call.name, arguments: call.arguments });
+                }
+                catch (cause) {
+                    if (!(cause instanceof JavaScriptEnvironmentActionError))
+                        throw cause;
+                    if (cause.code === "step_budget_exhausted") {
+                        status = "budget_exhausted";
+                        break;
+                    }
+                    observation = { error: cause.code };
+                }
+                append({ role: "tool", callId: call.id, name: call.name, observation });
+            }
+            if (status === "budget_exhausted")
+                break;
+            if (turn === session.definition.maxSteps)
+                status = "budget_exhausted";
+        }
+        snapshot ??= session.snapshot();
+    }
+    catch (cause) {
+        if (signal.aborted)
+            status = timedOut ? "timed_out" : "cancelled";
+        error = cause instanceof Error ? cause.message : "environment_attempt_failed";
+        snapshot ??= session?.snapshot() ?? null;
+    }
+    finally {
+        clearTimeout(timer);
+        if (session) {
+            try {
+                await session.destroy();
+                environmentCleanupComplete = true;
+            }
+            catch (cause) {
+                status = "environment_failure";
+                error = cause instanceof Error ? cause.message : "environment_cleanup_failed";
+            }
+        }
+    }
+    const result = { schemaVersion: "openpond.javascriptEnvironmentAttempt.v1", taskId, status, output, snapshot, collected, environmentCleanupComplete, messages, error };
+    return { ...result, contentHash: contentHash(result) };
+}

package/dist/javascript-environment-contract.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { ImmutableAssetRefSchema, ToolDeclarationSchema, contentHash } from "@openpond/harness";
+import { assertBoundedTaskJson, validateTaskSchema } from "./task-schema-validation.js";
+export const JavaScriptEnvironmentDefinitionContentSchema = z.object({
+    schemaVersion: z.literal("openpond.javascriptEnvironment.v1"),
+    id: z.string().trim().min(1).max(500),
+    revision: z.number().int().positive(),
+    module: ImmutableAssetRefSchema.refine(reference => reference.visibility === "host_private", "Environment code belongs to the execution owner."),
+    tools: z.array(ToolDeclarationSchema).min(1).max(200),
+    maxSteps: z.number().int().min(1).max(1_000),
+    maxStateBytes: z.number().int().min(1).max(1_048_576),
+    maxObservationBytes: z.number().int().min(1).max(262_144),
+    operationTimeoutMs: z.number().int().min(1).max(30_000),
+}).strict().superRefine((value, context) => {
+    if (new Set(value.tools.map(tool => tool.name)).size !== value.tools.length)
+        context.addIssue({ code: "custom", path: ["tools"], message: "Environment tool names must be unique." });
+    value.tools.forEach((tool, index) => {
+        if (!validateTaskSchema(tool.inputSchema).valid)
+            context.addIssue({ code: "custom", path: ["tools", index, "inputSchema"], message: "Environment tools require a supported JSON schema." });
+        if (tool.inputSchemaHash !== contentHash(tool.inputSchema))
+            context.addIssue({ code: "custom", path: ["tools", index, "inputSchemaHash"], message: "Tool schema identity differs from its declared schema." });
+    });
+});
+export const JavaScriptEnvironmentDefinitionSchema = JavaScriptEnvironmentDefinitionContentSchema.safeExtend({ contentHash: z.string().regex(/^[a-f0-9]{64}$/) });
+export const JavaScriptEnvironmentOperationSchema = z.enum(["create", "reset", "step", "collect", "destroy"]);
+export const JavaScriptEnvironmentResultSchema = z.object({
+    state: z.record(z.string(), z.unknown()),
+    observation: z.record(z.string(), z.unknown()),
+}).strict();
+export function assertJavaScriptEnvironmentDefinition(value) {
+    assertBoundedTaskJson(value, 4_194_304);
+    const parsed = JavaScriptEnvironmentDefinitionSchema.parse(value);
+    const { contentHash: hash, ...content } = parsed;
+    if (contentHash(content) !== hash)
+        throw new Error("environment_definition_hash_mismatch");
+    return structuredClone(parsed);
+}

package/dist/javascript-environment-node.js

@@ -0,0 +1,7 @@
+import { JavaScriptEnvironmentOperationSchema, JavaScriptEnvironmentResultSchema } from "./javascript-environment-contract.js";
+import { executeJavaScriptIsolateInWorker } from "./javascript-isolate-node.js";
+/** The execution owner awaits termination before recording a step or cleanup. */
+export async function executeJavaScriptEnvironmentInWorker(input) {
+    const operation = JavaScriptEnvironmentOperationSchema.parse(input.operation);
+    return JavaScriptEnvironmentResultSchema.parse(await executeJavaScriptIsolateInWorker({ ...input, exportName: operation, maxResultBytes: 1_572_864, deterministic: true, errorPrefix: "environment" }));
+}

package/dist/javascript-environment.js

@@ -0,0 +1,132 @@
+import { contentHash } from "@openpond/harness";
+import { verifyLearningTextAsset } from "./learning/assets.js";
+import { assertBoundedTaskJson, validateTaskValue } from "./task-schema.js";
+import { executeJavaScriptIsolate } from "./javascript-isolate.js";
+import { assertJavaScriptEnvironmentDefinition, JavaScriptEnvironmentOperationSchema, JavaScriptEnvironmentResultSchema } from "./javascript-environment-contract.js";
+export * from "./javascript-environment-contract.js";
+/** Pure, bounded module execution. Server hosts should provide the worker runner. */
+export async function executeJavaScriptEnvironment(input) {
+    const operation = JavaScriptEnvironmentOperationSchema.parse(input.operation);
+    return JavaScriptEnvironmentResultSchema.parse(await executeJavaScriptIsolate({ ...input, exportName: operation, maxResultBytes: 1_572_864, deterministic: true, errorPrefix: "environment" }));
+}
+export class JavaScriptEnvironmentActionError extends Error {
+    code;
+    constructor(code) {
+        super(`environment_${code}`);
+        this.code = code;
+        this.name = "JavaScriptEnvironmentActionError";
+    }
+}
+/** One episode, with owner-held state that is never accepted from model output.
+ * Read-only tools and collection cannot change it. Call destroy in a finally block. */
+export async function createJavaScriptEnvironmentSession(input) {
+    const definition = assertJavaScriptEnvironmentDefinition(input.definition);
+    const source = verifyLearningTextAsset(input.asset, definition.module);
+    if (!Number.isSafeInteger(input.seed))
+        throw new Error("environment_seed_invalid");
+    const seed = input.seed;
+    assertBoundedTaskJson(input.input, 1_048_576);
+    assertBoundedTaskJson(input.initialState, definition.maxStateBytes);
+    const taskInput = structuredClone(input.input), initialState = structuredClone(input.initialState);
+    const execute = input.execute ?? executeJavaScriptEnvironment;
+    const controller = new AbortController();
+    const signal = input.signal ? AbortSignal.any([input.signal, controller.signal]) : controller.signal;
+    let state = {};
+    let steps = 0, closed = false, closing = false;
+    let active = null;
+    const events = [];
+    let closePromise = null;
+    async function invoke(operation, action) {
+        if (closed || closing)
+            throw new Error("environment_closed");
+        if (active)
+            throw new Error("environment_operation_in_progress");
+        signal.throwIfAborted();
+        if (action) {
+            assertBoundedTaskJson(action, 262_144);
+            action = structuredClone(action);
+        }
+        const beforeStateHash = contentHash(state);
+        const tool = action ? definition.tools.find(tool => tool.name === action.name) : null;
+        if (operation === "step") {
+            if (steps >= definition.maxSteps)
+                throw new JavaScriptEnvironmentActionError("step_budget_exhausted");
+            steps++;
+        }
+        const record = (observation, error) => events.push({ sequence: events.length, operation, toolName: action?.name ?? null, arguments: action ? structuredClone(action.arguments) : null, observation, beforeStateHash, afterStateHash: contentHash(state), error });
+        try {
+            if (action && !tool)
+                throw new JavaScriptEnvironmentActionError("unknown_tool");
+            if (action && tool && !validateTaskValue(tool.inputSchema, action.arguments).valid)
+                throw new JavaScriptEnvironmentActionError("invalid_arguments");
+            const promise = execute({ source, operation, value: { input: taskInput, initialState, seed, state: structuredClone(state), sequence: steps, action: action ? structuredClone(action) : null }, timeoutMs: Math.min(definition.operationTimeoutMs, tool?.timeoutMs ?? definition.operationTimeoutMs), signal });
+            active = promise;
+            const result = JavaScriptEnvironmentResultSchema.parse(await promise);
+            signal.throwIfAborted();
+            assertBoundedTaskJson(result.state, definition.maxStateBytes);
+            assertBoundedTaskJson(result.observation, definition.maxObservationBytes);
+            if ((operation === "collect" || tool?.sideEffect === "read") && contentHash(result.state) !== beforeStateHash)
+                throw new Error("environment_read_changed_state");
+            state = structuredClone(result.state);
+            const observation = structuredClone(result.observation);
+            record(observation, null);
+            return { state: structuredClone(state), observation };
+        }
+        catch (error) {
+            record(null, error instanceof Error ? error.message : "environment_execution_failed");
+            throw error;
+        }
+        finally {
+            active = null;
+        }
+    }
+    async function destroy() {
+        if (closePromise)
+            return closePromise;
+        closing = true;
+        controller.abort(new Error("environment_destroyed"));
+        closePromise = (async () => {
+            try {
+                // A worker runner settles only after termination; cleanup cannot race it.
+                try {
+                    await active;
+                }
+                catch { /* The operation failure is retained by its caller. */ }
+                await execute({ source, operation: "destroy", value: { input: taskInput, initialState, seed, state: structuredClone(state), sequence: steps, action: null }, timeoutMs: Math.min(definition.operationTimeoutMs, 1_000) });
+            }
+            finally {
+                state = {};
+                closed = true;
+            }
+        })();
+        return closePromise;
+    }
+    try {
+        await invoke("create");
+        const reset = await invoke("reset");
+        const initialStateHash = contentHash(state);
+        const snapshot = () => {
+            if (closed)
+                throw new Error("environment_closed");
+            return { definition: { id: definition.id, revision: definition.revision, contentHash: definition.contentHash }, inputHash: contentHash(taskInput), seed, initialStateHash, finalStateHash: contentHash(state), state: structuredClone(state), events: structuredClone(events) };
+        };
+        return {
+            definition: structuredClone(definition),
+            observation: reset.observation,
+            async step(action) { return (await invoke("step", action)).observation; },
+            async collect() {
+                const result = await invoke("collect");
+                return { ...snapshot(), observation: result.observation };
+            },
+            snapshot,
+            destroy,
+        };
+    }
+    catch (error) {
+        try {
+            await destroy();
+        }
+        catch { /* Preserve the original creation failure after owner cleanup. */ }
+        throw error;
+    }
+}

package/dist/javascript-isolate-node.js

@@ -0,0 +1,55 @@
+import { Worker } from "node:worker_threads";
+import { javascriptVerifierWorkerSource } from "./javascript-verifier-worker-source.js";
+import { validateJavaScriptIsolateInput } from "./javascript-isolate.js";
+import { assertBoundedTaskJson } from "./task-schema.js";
+/** Both environment steps and graders settle only after their worker stops. */
+export async function executeJavaScriptIsolateInWorker(input) {
+    input.signal?.throwIfAborted();
+    validateJavaScriptIsolateInput(input);
+    const signal = input.signal;
+    const workerData = { source: input.source, exportName: input.exportName, value: input.value, timeoutMs: input.timeoutMs, maxResultBytes: input.maxResultBytes, deterministic: input.deterministic === true, errorPrefix: input.errorPrefix };
+    const error = (suffix) => new Error(`${input.errorPrefix}_${suffix}`);
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(javascriptVerifierWorkerSource, {
+            eval: true, workerData, execArgv: [], env: {},
+            resourceLimits: { maxOldGenerationSizeMb: 64, maxYoungGenerationSizeMb: 16, stackSizeMb: 4 },
+        });
+        let settling = false;
+        const finish = (outcome) => {
+            if (settling)
+                return;
+            settling = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", cancel);
+            void worker.terminate().then(() => {
+                if ("error" in outcome)
+                    reject(outcome.error);
+                else
+                    resolve(outcome.result);
+            }, reject);
+        };
+        const cancel = () => finish({ error: signal?.reason instanceof Error ? signal.reason : error("cancelled") });
+        const timer = setTimeout(() => finish({ error: error("timeout") }), input.timeoutMs);
+        signal?.addEventListener("abort", cancel, { once: true });
+        worker.once("error", (error) => finish({ error }));
+        worker.once("exit", () => { if (!settling)
+            finish({ error: error("worker_exited_without_result") }); });
+        worker.once("message", (message) => {
+            try {
+                if (!message || typeof message !== "object" || !("ok" in message))
+                    throw error("worker_invalid_response");
+                if (message.ok !== true)
+                    throw new Error("error" in message && typeof message.error === "string" ? message.error : `${input.errorPrefix}_execution_failed`);
+                if (!("result" in message))
+                    throw error("worker_invalid_response");
+                assertBoundedTaskJson(message.result, input.maxResultBytes);
+                finish({ result: message.result });
+            }
+            catch (cause) {
+                finish({ error: cause instanceof Error ? cause : error("worker_invalid_response") });
+            }
+        });
+        if (signal?.aborted)
+            cancel();
+    });
+}

package/dist/javascript-isolate.js

@@ -0,0 +1,67 @@
+import { newQuickJSWASMModuleFromVariant, Scope } from "quickjs-emscripten-core";
+import variant from "@jitl/quickjs-singlefile-cjs-release-sync";
+import { assertBoundedTaskJson } from "./task-schema.js";
+/** Authored code is interpreter data, with no host functions or module loader. */
+export async function executeJavaScriptIsolate(input) {
+    validateJavaScriptIsolateInput(input);
+    input.signal?.throwIfAborted();
+    const error = (suffix) => new Error(`${input.errorPrefix}_${suffix}`);
+    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");
+        input.signal?.throwIfAborted();
+        if (Date.now() >= deadline)
+            throw error("timeout");
+        const value = JSON.parse(json);
+        assertBoundedTaskJson(value, input.maxResultBytes);
+        return value;
+    });
+}
+export function validateJavaScriptIsolateInput(input) {
+    if (!Number.isInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 300_000)
+        throw new Error(`${input.errorPrefix}_timeout_invalid`);
+    if (!Number.isInteger(input.maxResultBytes) || input.maxResultBytes < 1 || input.maxResultBytes > 4_194_304)
+        throw new Error(`${input.errorPrefix}_result_limit_invalid`);
+    if (new TextEncoder().encode(input.source).byteLength > 524_288)
+        throw new Error(`${input.errorPrefix}_source_too_large`);
+    assertBoundedTaskJson(input.value, 4_194_304);
+}
+function settle(context, handle, deadline, signal, error) {
+    for (;;) {
+        signal?.throwIfAborted();
+        if (Date.now() >= deadline)
+            throw error("timeout");
+        const state = context.getPromiseState(handle);
+        if (state.type === "fulfilled")
+            return state.notAPromise ? state.value.dup() : state.value;
+        if (state.type === "rejected")
+            return context.unwrapResult(state);
+        const jobs = context.runtime.executePendingJobs(1);
+        if (jobs.unwrap() === 0)
+            throw error("unresolved_promise");
+    }
+}

package/dist/javascript-verifier-node.js

@@ -1,56 +1,6 @@
-import { Worker } from "node:worker_threads";
 import { JavaScriptVerifierResultSchema } from "./javascript-verifier-contract.js";
-import { javascriptVerifierWorkerSource } from "./javascript-verifier-worker-source.js";
-import { assertBoundedTaskJson } from "./task-schema.js";
+import { executeJavaScriptIsolateInWorker } from "./javascript-isolate-node.js";
 /** Resolves/rejects only after the execution owner has stopped the worker. */
 export async function executeJavaScriptVerifierInWorker(input) {
-    input.signal?.throwIfAborted();
-    if (!Number.isInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 300_000)
-        throw new Error("verifier_timeout_invalid");
-    assertBoundedTaskJson(input.value, 4_194_304);
-    if (new TextEncoder().encode(input.source).byteLength > 524_288)
-        throw new Error("verifier_source_too_large");
-    const { signal, ...workerData } = input;
-    return new Promise((resolve, reject) => {
-        const worker = new Worker(javascriptVerifierWorkerSource, {
-            eval: true, workerData, execArgv: [], env: {},
-            resourceLimits: { maxOldGenerationSizeMb: 64, maxYoungGenerationSizeMb: 16, stackSizeMb: 4 },
-        });
-        let settling = false;
-        const finish = (outcome) => {
-            if (settling)
-                return;
-            settling = true;
-            clearTimeout(timer);
-            signal?.removeEventListener("abort", cancel);
-            void worker.terminate().then(() => {
-                if ("error" in outcome)
-                    reject(outcome.error);
-                else
-                    resolve(outcome.result);
-            }, reject);
-        };
-        const cancel = () => finish({ error: signal?.reason instanceof Error ? signal.reason : new Error("verifier_cancelled") });
-        const timer = setTimeout(() => finish({ error: new Error("verifier_timeout") }), input.timeoutMs);
-        signal?.addEventListener("abort", cancel, { once: true });
-        worker.once("error", (error) => finish({ error }));
-        worker.once("exit", () => { if (!settling)
-            finish({ error: new Error("verifier_worker_exited_without_result") }); });
-        worker.once("message", (message) => {
-            try {
-                if (!message || typeof message !== "object" || !("ok" in message))
-                    throw new Error("verifier_worker_invalid_response");
-                if (message.ok !== true)
-                    throw new Error("error" in message && typeof message.error === "string" ? message.error : "verifier_execution_failed");
-                if (!("result" in message))
-                    throw new Error("verifier_worker_invalid_response");
-                finish({ result: JavaScriptVerifierResultSchema.parse(message.result) });
-            }
-            catch (error) {
-                finish({ error: error instanceof Error ? error : new Error("verifier_worker_invalid_response") });
-            }
-        });
-        if (signal?.aborted)
-            cancel();
-    });
+    return JavaScriptVerifierResultSchema.parse(await executeJavaScriptIsolateInWorker({ ...input, exportName: input.exportName ?? "verify", maxResultBytes: 65_536, errorPrefix: "verifier" }));
 }