rea-agents 3.0.0 → 3.2.0

package/dist/replay/JavaScriptReplayWorker.js

@@ -1,5 +1,81 @@
 import { Script, SourceTextModule, SyntheticModule, createContext, } from "node:vm";
 import { types } from "node:util";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const record = (value, label) => {
+    if (!isRecord(value))
+        throw new TypeError(`Invalid replay worker ${label}`);
+    return value;
+};
+const string = (value, label) => {
+    if (typeof value !== "string")
+        throw new TypeError(`Invalid replay worker ${label}`);
+    return value;
+};
+const integer = (value, label) => {
+    if (!Number.isSafeInteger(value) || Number(value) < 0)
+        throw new TypeError(`Invalid replay worker ${label}`);
+    return Number(value);
+};
+const parseWorkerModule = (value) => {
+    const module = record(value, "module");
+    const format = module.format;
+    if (format !== "esm" && format !== "commonjs-factory")
+        throw new TypeError("Invalid replay worker module format");
+    const dependencies = record(module.dependencies, "module dependencies");
+    if (Object.values(dependencies).some((dependency) => typeof dependency !== "string"))
+        throw new TypeError("Invalid replay worker module dependency");
+    return {
+        alias: string(module.alias, "module alias"),
+        format,
+        dependencies: Object.fromEntries(Object.entries(dependencies).map(([key, dependency]) => [
+            key,
+            string(dependency, "module dependency"),
+        ])),
+        source: string(module.source, "module source"),
+    };
+};
+const parseWorkerSide = (value) => {
+    const side = record(value, "side");
+    if (!Array.isArray(side.modules))
+        throw new TypeError("Invalid replay worker modules");
+    return {
+        modules: side.modules.map(parseWorkerModule),
+        entryAlias: string(side.entryAlias, "entry alias"),
+        entryExport: string(side.entryExport, "entry export"),
+    };
+};
+const parseWorkerRequest = (value) => {
+    const request = record(value, "request");
+    if (!Array.isArray(request.cases))
+        throw new TypeError("Invalid replay worker cases");
+    const determinism = record(request.determinism, "determinism");
+    const limits = record(request.limits, "limits");
+    return {
+        left: parseWorkerSide(request.left),
+        ...(request.right === undefined
+            ? {}
+            : { right: parseWorkerSide(request.right) }),
+        cases: request.cases.map((value) => {
+            const replayCase = record(value, "case");
+            if (!Array.isArray(replayCase.arguments))
+                throw new TypeError("Invalid replay worker case arguments");
+            return {
+                caseId: string(replayCase.caseId, "case ID"),
+                arguments: replayCase.arguments,
+                inputSha256: string(replayCase.inputSha256, "case digest"),
+            };
+        }),
+        determinism: {
+            clockIso: string(determinism.clockIso, "clock"),
+            randomSeed: integer(determinism.randomSeed, "random seed"),
+        },
+        limits: {
+            resultDepth: integer(limits.resultDepth, "result depth"),
+            resultNodes: integer(limits.resultNodes, "result nodes"),
+            exceptionBytes: integer(limits.exceptionBytes, "exception bytes"),
+        },
+    };
+};
 class ReplayDeniedError extends Error {
     name = "ReplayDeniedError";
 }
@@ -7,9 +83,8 @@ const main = async () => {
     const chunks = [];
     for await (const chunk of process.stdin)
         chunks.push(Buffer.from(chunk));
-    const request = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-    if (request.schemaVersion !== 1)
-        throw new TypeError("Unsupported replay worker protocol");
+    const rawRequest = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    const request = parseWorkerRequest(rawRequest);
     const left = [];
     const right = [];
     for (let index = 0; index < request.cases.length; index += 1) {
@@ -21,7 +96,6 @@ const main = async () => {
             right.push(await runCase(request.right, replayCase, request, index));
     }
     process.stdout.write(JSON.stringify({
-        schema_version: 1,
         left,
         ...(request.right === undefined ? {} : { right }),
     }));
@@ -66,18 +140,20 @@ const loadEntry = async (side, request, caseIndex) => {
             throw new TypeError(`Synchronous require cannot load ESM module: ${alias}`);
         const module = { exports: {} };
         commonJsCache.set(alias, module.exports);
-        const requireModule = ((specifier) => {
+        const requireModule = (specifier) => {
             const dependency = descriptor.dependencies[specifier];
             if (dependency === undefined)
                 throw new ReplayDeniedError(`Undeclared require: ${specifier}`);
             return loadCommonJs(dependency);
-        });
+        };
         installRspackHelpers(requireModule);
         const source = normalizeFactorySource(descriptor.source);
         const factory = new Script(`(${source})`, {
             filename: `/modules/${alias}.js`,
         }).runInContext(context);
-        factory(module, module.exports, requireModule);
+        if (typeof factory !== "function")
+            throw new TypeError(`CommonJS factory is not callable: ${alias}`);
+        Reflect.apply(factory, undefined, [module, module.exports, requireModule]);
         commonJsCache.set(alias, module.exports);
         return module.exports;
     };
@@ -126,7 +202,7 @@ const loadEntry = async (side, request, caseIndex) => {
             : exported[side.entryExport];
     }
     const namespace = (await loadEsm(side.entryAlias)).namespace;
-    return namespace[side.entryExport];
+    return Reflect.get(namespace, side.entryExport);
 };
 const deterministicContext = (request, caseIndex) => {
     let state = (request.determinism.randomSeed + caseIndex) >>> 0;
@@ -153,21 +229,27 @@ const deterministicContext = (request, caseIndex) => {
     });
 };
 const installRspackHelpers = (require_) => {
-    require_.d = (exports, definitions) => {
+    const defineExports = (exports, definitions) => {
         for (const [name, getter] of Object.entries(definitions))
             if (!Object.prototype.hasOwnProperty.call(exports, name))
                 Object.defineProperty(exports, name, { enumerable: true, get: getter });
     };
-    require_.r = (exports) => {
+    const markModule = (exports) => {
         Object.defineProperty(exports, "__esModule", { value: true });
         Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     };
-    require_.n = (module) => {
+    const normalizeModule = (module) => {
         const getter = () => (module.__esModule === true ? module.default : module);
         Object.defineProperty(getter, "a", { get: getter });
         return getter;
     };
-    require_.nmd = (module) => module;
+    const passModule = (module) => module;
+    Object.defineProperties(require_, {
+        d: { value: defineExports },
+        r: { value: markModule },
+        n: { value: normalizeModule },
+        nmd: { value: passModule },
+    });
 };
 const requiredModule = (modules, alias) => {
     const module = modules.get(alias);
@@ -295,6 +377,6 @@ const bounded = (value, maximumBytes) => {
 };
 void main().catch((error) => {
     const message = error instanceof Error ? error.message : "Replay worker failed";
-    process.stderr.write(message.slice(0, 4096));
+    process.stderr.write(message);
     process.exitCode = 70;
 });

package/dist/replay/JavaScriptReplayWorkerTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/replay/LinuxJavaScriptReplayRunner.js

@@ -1,10 +1,11 @@
+import { temporaryFilterHandle } from "./ReplaySeccompFile.js";
 import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { digestBytes, } from "../application/JavaScriptReplayPlanning.js";
 import { linuxX64ReplaySeccompDigest } from "./LinuxSeccompPolicy.js";
 import { resolveLinuxRuntimeClosure } from "./LinuxRuntimeClosure.js";
-import { assertRuntimeCommitment, systemdArguments, temporaryFilterHandle, } from "./LinuxJavaScriptReplaySandbox.js";
+import { assertRuntimeCommitment, systemdArguments, } from "./LinuxJavaScriptReplaySandbox.js";
 import { boundedCollector, killUnit, observeCleanup, observeUnitResult, } from "./ReplayProcessLifecycle.js";
 import { commitOutcomes, compareOutcomes, terminationResult, workerRequest, } from "./ReplayOutcome.js";
 import { parseReplayWorkerResponse, } from "./ReplayWorkerProtocol.js";
@@ -23,39 +24,42 @@ export class LinuxJavaScriptReplayRunner {
         const closure = await validateReplayCommitments(prepared, policy);
         const encoded = buildWorkerPayload(prepared);
         const filter = await temporaryFilterHandle();
-        const replayProcess = launchReplayProcess({
-            prepared,
-            policy,
-            encoded,
-            closure,
-            filterPath: filter.path,
-            unit,
-            signal,
-        });
         try {
-            const collected = await replayProcess.completion;
-            if (replayProcess.terminationRequest !== undefined)
-                await replayProcess.terminationRequest;
-            const unitResult = await observeUnitResult(policy.systemctlPath, unit);
-            const cleanup = await observeCleanup(policy.systemctlPath, unit);
-            return resolveReplayResult({
+            const replayProcess = launchReplayProcess({
                 prepared,
-                collected,
-                unitResult,
-                cleanup,
-                cancelled: replayProcess.cancelled,
-                timedOut: replayProcess.timedOut,
+                policy,
+                encoded,
+                closure,
+                filterPath: filter.path,
+                unit,
+                signal,
             });
+            try {
+                const collected = await replayProcess.completion;
+                if (replayProcess.terminationRequest !== undefined)
+                    await replayProcess.terminationRequest;
+                const unitResult = await observeUnitResult(policy.systemctlPath, unit);
+                const cleanup = await observeCleanup(policy.systemctlPath, unit);
+                return resolveReplayResult({
+                    prepared,
+                    collected,
+                    unitResult,
+                    cleanup,
+                    termination: replayProcess.termination,
+                });
+            }
+            finally {
+                signal?.removeEventListener("abort", replayProcess.terminate);
+                if (replayProcess.timeout !== undefined)
+                    clearTimeout(replayProcess.timeout);
+                if (replayProcess.child !== undefined &&
+                    replayProcess.child.exitCode === null) {
+                    replayProcess.requestTermination();
+                    await replayProcess.terminationRequest;
+                }
+            }
         }
         finally {
-            signal?.removeEventListener("abort", replayProcess.terminate);
-            if (replayProcess.timeout !== undefined)
-                clearTimeout(replayProcess.timeout);
-            if (replayProcess.child !== undefined &&
-                replayProcess.child.exitCode === null) {
-                replayProcess.requestTermination();
-                await replayProcess.terminationRequest;
-            }
             await filter.close();
         }
     }
@@ -90,15 +94,14 @@ const launchReplayProcess = (options) => {
     });
     let child;
     let timeout;
-    let cancelled = false;
-    let timedOut = false;
+    let termination;
     let terminationRequest;
     const requestTermination = () => {
         terminationRequest ??= killUnit(policy.systemctlPath, unit);
         child?.kill("SIGKILL");
     };
     const terminate = () => {
-        cancelled = true;
+        termination ??= "cancelled";
         requestTermination();
     };
     const completion = new Promise((resolve, reject) => {
@@ -124,7 +127,7 @@ const launchReplayProcess = (options) => {
     if (isAborted(signal))
         terminate();
     timeout = setTimeout(() => {
-        timedOut = true;
+        termination ??= "timeout";
         requestTermination();
     }, prepared.publicPlan.limits.wall_time_ms);
     timeout.unref();
@@ -139,11 +142,8 @@ const launchReplayProcess = (options) => {
         get terminationRequest() {
             return terminationRequest;
         },
-        get cancelled() {
-            return cancelled;
-        },
-        get timedOut() {
-            return timedOut;
+        get termination() {
+            return termination;
         },
     };
 };
@@ -160,12 +160,12 @@ const replayProcessEnvironment = () => ({
         : { DBUS_SESSION_BUS_ADDRESS: process.env.DBUS_SESSION_BUS_ADDRESS }),
 });
 const resolveReplayResult = (options) => {
-    const { prepared, collected, unitResult, cleanup, cancelled, timedOut } = options;
-    if (cancelled || timedOut)
+    const { prepared, collected, unitResult, cleanup, termination } = options;
+    if (termination !== undefined)
         return terminationResult({
             prepared,
             stderr: collected.stderr,
-            termination: cancelled ? "cancelled" : "timeout",
+            termination,
             cleanup,
         });
     if (collected.outputExceeded)
@@ -186,7 +186,7 @@ const resolveReplayResult = (options) => {
     let response;
     try {
         const rawResponse = JSON.parse(collected.stdout);
-        response = parseReplayWorkerResponse(rawResponse, prepared.publicPlan.cases, prepared.publicPlan.right !== undefined);
+        response = parseReplayWorkerResponse(rawResponse, prepared.publicPlan.cases, prepared.publicPlan.right === undefined ? "single" : "differential");
     }
     catch {
         return terminationResult({
@@ -199,7 +199,6 @@ const resolveReplayResult = (options) => {
     const outcomes = commitOutcomes(response.left);
     const right = response.right === undefined ? undefined : commitOutcomes(response.right);
     return {
-        schema_version: 1,
         plan_digest: prepared.publicPlan.plan_digest,
         outcomes: [...outcomes, ...(right ?? [])],
         ...(right === undefined

package/dist/replay/LinuxJavaScriptReplaySandbox.js

@@ -1,7 +1,5 @@
-import { open } from "node:fs/promises";
 import { dirname } from "node:path";
 import { digestJson, } from "../application/JavaScriptReplayPlanning.js";
-import { buildLinuxX64ReplaySeccomp } from "./LinuxSeccompPolicy.js";
 import { resolveLinuxRuntimeClosure } from "./LinuxRuntimeClosure.js";
 export const assertRuntimeCommitment = (prepared, closure) => {
     const observed = closure.map((item) => ({
@@ -13,23 +11,6 @@ export const assertRuntimeCommitment = (prepared, closure) => {
         digestJson(prepared.publicPlan.runtime.read_only_files))
         throw new TypeError("Replay runtime closure changed after approval");
 };
-export const temporaryFilterHandle = async () => {
-    const { mkdtemp, writeFile, rm } = await import("node:fs/promises");
-    const { tmpdir } = await import("node:os");
-    const { join } = await import("node:path");
-    const directory = await mkdtemp(join(tmpdir(), "rea-replay-filter-"));
-    const path = join(directory, "seccomp.bpf");
-    await writeFile(path, buildLinuxX64ReplaySeccomp(), { mode: 0o600 });
-    const handle = await open(path, "r");
-    return {
-        path,
-        handle,
-        close: async () => {
-            await handle.close();
-            await rm(directory, { recursive: true, force: true });
-        },
-    };
-};
 export const systemdArguments = (options) => {
     const { unit, policy, prepared, workerPath, closure, filterPath } = options;
     const limits = prepared.publicPlan.limits;

package/dist/replay/LinuxRuntimeClosure.js

@@ -1,7 +1,6 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { readFile, realpath } from "node:fs/promises";
-const LDD_OUTPUT_LIMIT = 64 * 1024;
 /** Resolve and content-address the exact ELF closure mounted into a replay. */
 export const resolveLinuxRuntimeClosure = async (nodePath) => {
     const canonicalNode = await realpath(nodePath);
@@ -32,8 +31,7 @@ const collectLdd = async (path) => new Promise((resolve, reject) => {
     timeout.unref();
     let stdout = "";
     child.stdout.on("data", (chunk) => {
-        const remaining = Math.max(0, LDD_OUTPUT_LIMIT - Buffer.byteLength(stdout));
-        stdout += chunk.subarray(0, remaining).toString("utf8");
+        stdout += chunk.toString("utf8");
     });
     child.once("error", (error) => {
         clearTimeout(timeout);

package/dist/replay/ReplayOutcome.js

@@ -1,7 +1,6 @@
 import { digestJson, } from "../application/JavaScriptReplayPlanning.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 export const workerRequest = (prepared) => ({
-    schemaVersion: 1,
     left: workerSide(prepared.publicPlan.left, prepared.leftSources),
     ...(prepared.publicPlan.right === undefined ||
         prepared.rightSources === undefined
@@ -19,7 +18,7 @@ export const workerRequest = (prepared) => ({
     limits: {
         resultDepth: prepared.publicPlan.limits.result_depth,
         resultNodes: prepared.publicPlan.limits.result_nodes,
-        exceptionBytes: Math.min(64 * 1024, prepared.publicPlan.limits.output_bytes),
+        exceptionBytes: prepared.publicPlan.limits.output_bytes,
     },
 });
 const workerSide = (side, sources) => ({
@@ -33,18 +32,21 @@ const workerSide = (side, sources) => ({
     entryExport: side.entry_export,
 });
 export const commitOutcomes = (outcomes) => outcomes.map((outcome) => {
-    const semantic = outcome.value === undefined ? (outcome.exception ?? null) : outcome.value;
+    if (outcome.outcome === "return")
+        return {
+            case_id: outcome.case_id,
+            outcome: outcome.outcome,
+            value: jsonValueSchema.parse(outcome.value),
+            input_sha256: outcome.input_sha256,
+            output_sha256: digestJson(outcome.value),
+            truncated: false,
+        };
     return {
         case_id: outcome.case_id,
         outcome: outcome.outcome,
-        ...(outcome.value === undefined
-            ? {}
-            : { value: jsonValueSchema.parse(outcome.value) }),
-        ...(outcome.exception === undefined
-            ? {}
-            : { exception: outcome.exception }),
+        exception: outcome.exception,
         input_sha256: outcome.input_sha256,
-        output_sha256: digestJson(semantic),
+        output_sha256: digestJson(outcome.exception),
         truncated: false,
     };
 });
@@ -61,16 +63,23 @@ export const compareOutcomes = (left, right) => left.map((item, index) => ({
 }));
 export const terminationResult = (options) => {
     const { prepared, stderr, termination, cleanup, limitation } = options;
-    const outcomes = prepared.publicPlan.cases.map((item) => ({
-        case_id: item.case_id,
-        outcome: termination,
-        input_sha256: item.sha256,
-        output_sha256: null,
-        truncated: termination === "protocol_error",
-    }));
+    const outcomes = termination === "protocol_error"
+        ? prepared.publicPlan.cases.map((item) => ({
+            case_id: item.case_id,
+            outcome: termination,
+            input_sha256: item.sha256,
+            output_sha256: null,
+            truncated: true,
+        }))
+        : prepared.publicPlan.cases.map((item) => ({
+            case_id: item.case_id,
+            outcome: termination,
+            input_sha256: item.sha256,
+            output_sha256: null,
+            truncated: false,
+        }));
     const differential = prepared.publicPlan.right !== undefined;
     return {
-        schema_version: 1,
         plan_digest: prepared.publicPlan.plan_digest,
         outcomes: [...outcomes, ...(differential ? outcomes : [])],
         ...(differential

package/dist/replay/ReplayProcessLifecycle.js

@@ -16,12 +16,12 @@ export const boundedCollector = (maximum) => {
         exceeded: () => overflow,
     };
 };
-const collect = async (executable, arguments_, maximum) => new Promise((resolve, reject) => {
+const collect = async (executable, arguments_) => new Promise((resolve, reject) => {
     const child = spawn(executable, [...arguments_], {
         stdio: ["ignore", "pipe", "pipe"],
     });
-    const stdout = boundedCollector(maximum);
-    const stderr = boundedCollector(maximum);
+    const stdout = unboundedCollector();
+    const stderr = unboundedCollector();
     const timeout = setTimeout(() => child.kill("SIGKILL"), 5_000);
     timeout.unref();
     child.stdout?.on("data", stdout.append);
@@ -37,7 +37,13 @@ const collect = async (executable, arguments_, maximum) => new Promise((resolve,
 });
 export const killUnit = async (systemctl, unit) => {
     try {
-        await collect(systemctl, ["--user", "kill", "--kill-whom=all", "--signal=SIGKILL", unit], 4096);
+        await collect(systemctl, [
+            "--user",
+            "kill",
+            "--kill-whom=all",
+            "--signal=SIGKILL",
+            unit,
+        ]);
     }
     catch {
         /* cleanup continues */
@@ -45,13 +51,19 @@ export const killUnit = async (systemctl, unit) => {
 };
 export const observeCleanup = async (systemctl, unit) => {
     try {
-        const state = await collect(systemctl, ["--user", "show", "--property=ActiveState", "--value", unit], 4096);
+        const state = await collect(systemctl, [
+            "--user",
+            "show",
+            "--property=ActiveState",
+            "--value",
+            unit,
+        ]);
         const activeState = state.stdout.trim();
         if (state.code !== 0 ||
             activeState === "inactive" ||
             activeState === "failed" ||
             activeState.length === 0) {
-            await collect(systemctl, ["--user", "reset-failed", unit], 4096);
+            await collect(systemctl, ["--user", "reset-failed", unit]);
             return { state: "complete", residual_resources: [] };
         }
         return { state: "incomplete", residual_resources: [unit] };
@@ -62,10 +74,23 @@ export const observeCleanup = async (systemctl, unit) => {
 };
 export const observeUnitResult = async (systemctl, unit) => {
     try {
-        const result = await collect(systemctl, ["--user", "show", "--property=Result", "--value", unit], 4096);
+        const result = await collect(systemctl, [
+            "--user",
+            "show",
+            "--property=Result",
+            "--value",
+            unit,
+        ]);
         return result.stdout.trim();
     }
     catch {
         return "unknown";
     }
 };
+const unboundedCollector = () => {
+    const chunks = [];
+    return {
+        append: (chunk) => chunks.push(chunk),
+        value: () => Buffer.concat(chunks).toString("utf8"),
+    };
+};

package/dist/replay/ReplaySeccompFile.js

@@ -0,0 +1,29 @@
+import { mkdtemp, open, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { buildLinuxX64ReplaySeccomp } from "./LinuxSeccompPolicy.js";
+/** Own a private seccomp file and descriptor until probe or execution cleanup. */
+export const temporaryFilterHandle = async () => {
+    const directory = await mkdtemp(join(tmpdir(), "rea-replay-filter-"));
+    const path = join(directory, "seccomp.bpf");
+    try {
+        await writeFile(path, buildLinuxX64ReplaySeccomp(), { mode: 0o600 });
+        const handle = await open(path, "r");
+        return {
+            path,
+            handle,
+            close: async () => {
+                try {
+                    await handle.close();
+                }
+                finally {
+                    await rm(directory, { recursive: true, force: true });
+                }
+            },
+        };
+    }
+    catch (cause) {
+        await rm(directory, { recursive: true, force: true });
+        throw cause;
+    }
+};

package/dist/replay/ReplayWorkerProtocol.js

@@ -1,45 +1,48 @@
 import { z } from "zod";
-const workerOutcomeSchema = z
-    .object({
+const workerOutcomeFacts = {
     case_id: z.string(),
-    outcome: z.enum(["return", "exception", "serialization_error", "denied"]),
-    value: z.json().optional(),
-    exception: z
-        .object({
-        name: z.string(),
-        message: z.string(),
-        stack: z.string().nullable(),
-    })
-        .strict()
-        .optional(),
     input_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     output_sha256: z.null(),
     truncated: z.literal(false),
+};
+const exceptionSchema = z
+    .object({
+    name: z.string(),
+    message: z.string(),
+    stack: z.string().nullable(),
+})
+    .strict();
+const workerOutcomeSchema = z.discriminatedUnion("outcome", [
+    z.strictObject({
+        ...workerOutcomeFacts,
+        outcome: z.literal("return"),
+        value: z.json(),
+    }),
+    z.strictObject({
+        ...workerOutcomeFacts,
+        outcome: z.enum(["exception", "serialization_error", "denied"]),
+        exception: z.object(exceptionSchema.shape).strict(),
+    }),
+]);
+const singleWorkerResponseSchema = z
+    .object({
+    left: z.array(workerOutcomeSchema),
 })
-    .strict()
-    .superRefine((value, context) => {
-    if (value.outcome === "return" && value.value === undefined)
-        context.addIssue({ code: "custom", message: "Return value is missing" });
-    if (value.outcome !== "return" && value.exception === undefined)
-        context.addIssue({ code: "custom", message: "Exception is missing" });
-    if (value.outcome === "return" && value.exception !== undefined)
-        context.addIssue({ code: "custom", message: "Return has an exception" });
-});
-const workerResponseSchema = z
+    .strict();
+const differentialWorkerResponseSchema = z
     .object({
-    schema_version: z.literal(1),
     left: z.array(workerOutcomeSchema),
-    right: z.array(workerOutcomeSchema).optional(),
+    right: z.array(workerOutcomeSchema),
 })
     .strict();
 /** Strictly authenticate case ordering and commitments in worker output. */
-export const parseReplayWorkerResponse = (rawResponse, cases, differential) => {
-    const response = workerResponseSchema.parse(rawResponse);
-    if ((response.right !== undefined) !== differential)
-        throw new TypeError("Replay worker differential response is incomplete");
+export const parseReplayWorkerResponse = (rawResponse, cases, mode) => {
+    const response = mode === "single"
+        ? singleWorkerResponseSchema.parse(rawResponse)
+        : differentialWorkerResponseSchema.parse(rawResponse);
     validateOutcomeSequence(response.left, cases);
-    if (response.right !== undefined)
-        validateOutcomeSequence(response.right, cases);
+    if (mode === "differential")
+        validateOutcomeSequence(differentialWorkerResponseSchema.parse(response).right, cases);
     return response;
 };
 const validateOutcomeSequence = (outcomes, cases) => {