rea-agents 3.1.0 → 3.2.1

package/dist/reference/ReferenceSourceReaderEntries.js

@@ -1,7 +1,9 @@
 import { readdir, readlink, realpath } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 import { entryFailure, safeSize } from "./ReferenceSourceReaderErrors.js";
-import { compareNames, pathFromRoot, withinRoot, } from "./ReferenceSourceReaderPaths.js";
+import { isPathWithinRoot } from "../domain/localPath.js";
+import { pathFromRoot } from "./ReferenceSourceReaderPaths.js";
 import { readStableFile } from "./ReferenceSourceReaderFile.js";
 import { isAborted, sameFile, validateDirectory, bigLstat, } from "./ReferenceSourceReaderValidate.js";
 import {} from "./ReferenceSourceReaderTypes.js";
@@ -35,8 +37,6 @@ export const traverseDirectory = async (state, current) => {
         const result = await processEntry(state, current, name, directories);
         if (!result.ok)
             return result;
-        if (state.stopReason !== undefined)
-            break;
     }
     directories.reverse();
     state.pending.push(...directories);
@@ -44,7 +44,10 @@ export const traverseDirectory = async (state, current) => {
 };
 const readDirectoryNames = async (path) => {
     try {
-        return { ok: true, value: (await readdir(path)).sort(compareNames) };
+        return {
+            ok: true,
+            value: (await readdir(path)).sort(compareUnicodeCodePoints),
+        };
     }
     catch {
         return { ok: false, message: "Directory could not be read" };
@@ -82,13 +85,6 @@ const processEntry = async (state, current, name, directories) => {
         };
     if (excluded.value)
         return { ok: true, value: undefined };
-    if (!reserveEntry(state))
-        return { ok: true, value: undefined };
-    if (Buffer.byteLength(path) > state.limits.maxPathBytes) {
-        state.entries.push(entryFailure(path, "unknown", "limit", "Path exceeds maxPathBytes"));
-        state.truncated = true;
-        return { ok: true, value: undefined };
-    }
     const metadata = await readMetadata(absolute);
     if (!metadata.ok) {
         state.entries.push(entryFailure(path, "unknown", "io", metadata.message));
@@ -106,14 +102,8 @@ const processEntry = async (state, current, name, directories) => {
     if (metadata.value.isSymbolicLink())
         state.entries.push(await describeSymlink(state.root, absolute, path));
     else if (metadata.value.isDirectory()) {
-        if (current.depth < state.limits.maxDepth) {
-            state.entries.push({ status: "read", kind: "directory", path });
-            directories.push({ path: absolute, depth: current.depth + 1 });
-        }
-        else {
-            state.entries.push(entryFailure(path, "directory", "limit", "Directory exceeds maxDepth"));
-            state.truncated = true;
-        }
+        state.entries.push({ status: "read", kind: "directory", path });
+        directories.push({ path: absolute });
     }
     else if (!metadata.value.isFile())
         state.entries.push(entryFailure(path, "other", "unsupported", "Entry is not a regular file", safeSize(metadata.value.size)));
@@ -122,32 +112,23 @@ const processEntry = async (state, current, name, directories) => {
     return { ok: true, value: undefined };
 };
 const processFileEntry = async (state, absolute, path, metadata) => {
-    const remaining = state.limits.maxBytes - state.bytesRead;
-    if (metadata.size > BigInt(remaining)) {
-        state.entries.push(entryFailure(path, "file", "limit", "File exceeds remaining maxBytes", safeSize(metadata.size)));
-        state.truncated = true;
-        return;
-    }
     const result = await readStableFile({
         root: state.root,
         rootIdentity: state.rootIdentity,
         absolute,
         path,
         expected: metadata,
-        remaining,
         ...(state.signal === undefined ? {} : { signal: state.signal }),
     });
     if (result.status === "read" && result.kind === "file")
         state.bytesRead += result.bytes.byteLength;
-    else if (result.status === "failed" && result.code === "limit")
-        state.truncated = true;
     state.entries.push(result);
 };
 const describeSymlink = async (root, absolute, path) => {
     try {
         const rawTarget = await readlink(absolute);
         const lexicalTarget = resolve(dirname(absolute), rawTarget);
-        if (!withinRoot(root, lexicalTarget))
+        if (!isPathWithinRoot(root, lexicalTarget))
             return {
                 status: "read",
                 kind: "symlink",
@@ -157,7 +138,7 @@ const describeSymlink = async (root, absolute, path) => {
             };
         try {
             const canonicalTarget = await realpath(lexicalTarget);
-            return withinRoot(root, canonicalTarget)
+            return isPathWithinRoot(root, canonicalTarget)
                 ? {
                     status: "read",
                     kind: "symlink",
@@ -195,12 +176,3 @@ const applyExclusion = (shouldExclude, path) => {
         return { ok: false };
     }
 };
-const reserveEntry = (state) => {
-    if (state.filesSeen < state.limits.maxEntries) {
-        state.filesSeen += 1;
-        return true;
-    }
-    state.truncated = true;
-    state.stopReason = "entry-limit";
-    return false;
-};

package/dist/reference/ReferenceSourceReaderFile.js

@@ -5,17 +5,9 @@ import { entryFailure, safeSize } from "./ReferenceSourceReaderErrors.js";
 import { isAborted, sameFile, validateDirectory, } from "./ReferenceSourceReaderValidate.js";
 import {} from "./ReferenceSourceReaderTypes.js";
 const READ_CHUNK_BYTES = 64 * 1024;
-const prepareFileRead = async (request) => {
-    const { root, rootIdentity, absolute, path, expected, signal } = request;
-    const parentBefore = await validateDirectory(root, rootIdentity, dirname(absolute));
-    if (!parentBefore.ok)
-        return {
-            status: "failed",
-            entry: entryFailure(path, "file", parentBefore.code, parentBefore.message, safeSize(expected.size)),
-        };
-    const handle = await open(absolute, constants.O_RDONLY | constants.O_NOFOLLOW);
+const prepareFileRead = async (request, handle) => {
+    const { path, expected, signal } = request;
     if (isAborted(signal)) {
-        await handle.close().catch(() => undefined);
         return {
             status: "failed",
             entry: entryFailure(path, "file", "cancelled", "File read cancelled", safeSize(expected.size)),
@@ -23,16 +15,15 @@ const prepareFileRead = async (request) => {
     }
     const before = await handle.stat({ bigint: true });
     if (!sameFile(expected, before)) {
-        await handle.close().catch(() => undefined);
         return {
             status: "failed",
             entry: entryFailure(path, "file", "changed", "File changed before it was read", safeSize(before.size)),
         };
     }
-    return { status: "ready", handle, before, parentBefore };
+    return { status: "ready", before };
 };
 const readFileContents = async (request) => {
-    const { handle, path, remaining, signal } = request;
+    const { handle, path, signal } = request;
     const chunks = [];
     let total = 0;
     for (;;) {
@@ -41,14 +32,8 @@ const readFileContents = async (request) => {
                 status: "failed",
                 entry: entryFailure(path, "file", "cancelled", "File read cancelled", total),
             };
-        const capacity = Math.min(READ_CHUNK_BYTES, remaining + 1 - total);
-        if (capacity <= 0)
-            return {
-                status: "failed",
-                entry: entryFailure(path, "file", "limit", "File exceeds remaining maxBytes", total),
-            };
-        const chunk = Buffer.allocUnsafe(capacity);
-        const read = await handle.read(chunk, 0, capacity, null);
+        const chunk = Buffer.allocUnsafe(READ_CHUNK_BYTES);
+        const read = await handle.read(chunk, 0, chunk.byteLength, null);
         if (isAborted(signal))
             return {
                 status: "failed",
@@ -57,11 +42,6 @@ const readFileContents = async (request) => {
         if (read.bytesRead === 0)
             break;
         total += read.bytesRead;
-        if (total > remaining)
-            return {
-                status: "failed",
-                entry: entryFailure(path, "file", "limit", "File exceeds remaining maxBytes", total),
-            };
         chunks.push(chunk.subarray(0, read.bytesRead));
     }
     return { status: "ok", chunks, total };
@@ -83,17 +63,19 @@ const finalizeFileRead = async (request) => {
     };
 };
 export const readStableFile = async (request) => {
-    const { root, rootIdentity, absolute, path, expected, remaining, signal } = request;
+    const { root, rootIdentity, absolute, path, expected, signal } = request;
     let handle;
     try {
-        const prepared = await prepareFileRead(request);
+        const parentBefore = await validateDirectory(root, rootIdentity, dirname(absolute));
+        if (!parentBefore.ok)
+            return entryFailure(path, "file", parentBefore.code, parentBefore.message, safeSize(expected.size));
+        handle = await open(absolute, constants.O_RDONLY | constants.O_NOFOLLOW);
+        const prepared = await prepareFileRead(request, handle);
         if (prepared.status === "failed")
             return prepared.entry;
-        handle = prepared.handle;
         const contents = await readFileContents({
             handle,
             path,
-            remaining,
             ...(signal === undefined ? {} : { signal }),
         });
         if (contents.status === "failed")
@@ -105,7 +87,7 @@ export const readStableFile = async (request) => {
             path,
             handle,
             before: prepared.before,
-            parentBefore: prepared.parentBefore,
+            parentBefore,
             chunks: contents.chunks,
             total: contents.total,
         });

package/dist/reference/ReferenceSourceReaderPaths.js

@@ -1,23 +1,8 @@
-import { isAbsolute, relative, sep } from "node:path";
-export const withinRoot = (root, path) => {
-    const value = relative(root, path);
-    return (value === "" ||
-        (value !== ".." && !value.startsWith(`..${sep}`) && !isAbsolute(value)));
-};
+import { relative, sep } from "node:path";
+import { isPathWithinRoot } from "../domain/localPath.js";
 export const pathFromRoot = (root, path) => {
     const value = relative(root, path);
-    return withinRoot(root, path)
+    return isPathWithinRoot(root, path)
         ? value.split(sep).join("/") || "."
         : "<outside-root>";
 };
-export const compareNames = (left, right) => {
-    const leftPoints = [...left].map((value) => value.codePointAt(0) ?? 0);
-    const rightPoints = [...right].map((value) => value.codePointAt(0) ?? 0);
-    const length = Math.min(leftPoints.length, rightPoints.length);
-    for (let index = 0; index < length; index += 1) {
-        const difference = (leftPoints[index] ?? 0) - (rightPoints[index] ?? 0);
-        if (difference !== 0)
-            return difference;
-    }
-    return leftPoints.length - rightPoints.length;
-};

package/dist/reference/ReferenceSourceReaderValidate.js

@@ -2,7 +2,7 @@ import { constants } from "node:fs";
 import { lstat, realpath } from "node:fs/promises";
 import { err, ok } from "../domain/result.js";
 import { cancelled, failure } from "./ReferenceSourceReaderErrors.js";
-import { withinRoot } from "./ReferenceSourceReaderPaths.js";
+import { isPathWithinRoot } from "../domain/localPath.js";
 import {} from "./ReferenceSourceReaderTypes.js";
 export const bigLstat = (path) => lstat(path, { bigint: true });
 export const sameFile = (left, right) => left.dev === right.dev &&
@@ -11,7 +11,6 @@ export const sameFile = (left, right) => left.dev === right.dev &&
     left.mtimeNs === right.mtimeNs &&
     left.ctimeNs === right.ctimeNs;
 export const isAborted = (signal) => signal?.aborted === true;
-const validLimits = (limits) => Object.values(limits).every((value) => Number.isSafeInteger(value) && value > 0);
 export const noFollowOpenSupported = () => Number.isSafeInteger(constants.O_NOFOLLOW) && constants.O_NOFOLLOW !== 0;
 export const validateDirectory = async (root, rootIdentity, path) => {
     try {
@@ -32,7 +31,7 @@ export const validateDirectory = async (root, rootIdentity, path) => {
                 message: "Directory identity changed",
             };
         const canonical = await realpath(path);
-        if (canonical !== path || !withinRoot(root, canonical))
+        if (canonical !== path || !isPathWithinRoot(root, canonical))
             return {
                 ok: false,
                 code: "changed",
@@ -48,9 +47,7 @@ export const validateDirectory = async (root, rootIdentity, path) => {
         };
     }
 };
-export const prepareRoot = async (root, limits, signal) => {
-    if (!validLimits(limits))
-        return err(failure("invalid-limits", "Reader limits must be positive integers"));
+export const prepareRoot = async (root, signal) => {
     if (isAborted(signal))
         return err(cancelled());
     try {

package/dist/replay/JavaScriptReplayWorker.js

@@ -46,12 +46,11 @@ const parseWorkerSide = (value) => {
 };
 const parseWorkerRequest = (value) => {
     const request = record(value, "request");
-    if (request.schemaVersion !== 1 || !Array.isArray(request.cases))
-        throw new TypeError("Unsupported replay worker protocol");
+    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 {
-        schemaVersion: 1,
         left: parseWorkerSide(request.left),
         ...(request.right === undefined
             ? {}
@@ -97,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 }),
     }));
@@ -379,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/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,38 +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,
-                termination: replayProcess.termination,
+                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();
         }
     }
@@ -194,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) => ({
@@ -81,7 +80,6 @@ export const terminationResult = (options) => {
         }));
     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

@@ -26,13 +26,11 @@ const workerOutcomeSchema = z.discriminatedUnion("outcome", [
 ]);
 const singleWorkerResponseSchema = z
     .object({
-    schema_version: z.literal(1),
     left: z.array(workerOutcomeSchema),
 })
     .strict();
 const differentialWorkerResponseSchema = z
     .object({
-    schema_version: z.literal(1),
     left: z.array(workerOutcomeSchema),
     right: z.array(workerOutcomeSchema),
 })