@specific.dev/spectest 0.131.11 → 0.131.12

package/dist/components/replay-websocket.js

@@ -176,7 +176,12 @@ export function replayWebSocket(args) {
         const progress = record.inputMode === "anchors"
             ? ` occurrence ${record.inputOccurrences[position]}; observed ${occurrences.get(expected) ?? 0} occurrences; received ${receivedMessages} messages, ${receivedCandidates} candidates; last candidate ${lastCandidate ?? "<none>"}`
             : "";
-        return diagnostic(`required input never arrived; expected ${expected}${progress}`);
+        const reordered = record.inputMode === "anchors"
+            && (occurrences.get(expected) ?? 0) >= record.inputOccurrences[position];
+        const detail = reordered
+            ? "required input arrived before preceding anchors matched"
+            : "required input never arrived";
+        return diagnostic(`${detail}; expected ${expected}${progress}`);
     };
     const armDeadline = () => {
         clearTimeout(deadline);

package/dist/daemon.js

@@ -52,7 +52,7 @@ import { fakeFunctions, fakeFunctionParameters, callFakeFunction } from "./harne
 import { dispatchFake } from "./harness/fake-websocket.js";
 import { casesMetadata as catalogueCases, groupsMetadata as catalogueGroups, } from "./harness/catalogue.js";
 import { summarizeBuildKit } from "./harness/buildkit-progress.js";
-import { LOG_DELTA_MAX_BYTES, capMiddle, streamDelta } from "./harness/log-delta.js";
+import { LOG_DELTA_MAX_BYTES, capMiddle, streamDelta, mergeServiceLogDeltas } from "./harness/log-delta.js";
 import { resolveHostPath as resolveVolumeHostPath, sanitizeSegment, } from "./harness/volume-paths.js";
 import { pollUntilReady } from "./harness/ready-poll.js";
 import { fsUsageDiagnostics } from "./harness/wrapper-rules.js";
@@ -1158,6 +1158,12 @@ async function runContainer(svc, tag, volumeFlags,
 // runtime `startService` (whose service isn't in LOWERED) to give the new
 // container docker-native multi-label resolution for its `hostnames`.
 extraAliases = []) {
+    // Preserve the previous incarnation before the name is reused.
+    if (RUNTIME_SERVICES.has(svc.name))
+        await stopRuntimeService(svc.name);
+    STOPPED_LOG_SERVICES.delete(svc.name);
+    LOG_MARKERS.delete(`${svc.name}\0stdout`);
+    LOG_MARKERS.delete(`${svc.name}\0stderr`);
     // Idempotent: clean up any leftover container with the same name.
     await docker(["rm", "-f", svc.name], 30_000);
     // The argv, and every rule shaping it, lives in `harness/container-run.ts`
@@ -2469,6 +2475,15 @@ async function stopRuntimeService(name) {
     const t0 = Date.now();
     const resv = reserveEvent();
     const svc = RUNTIME_SERVICES.get(name);
+    // Freeze log production before reading, while Docker still owns the logs.
+    // Keep force-stop semantics; removing first destroys the only copy.
+    await docker(["kill", name], 30_000);
+    if (!STOPPED_LOG_SERVICES.has(name)) {
+        const delta = await captureServiceLogDelta(name, true);
+        const previous = STOPPED_LOG_DELTAS.get(name);
+        STOPPED_LOG_DELTAS.set(name, previous ? mergeServiceLogDeltas(previous, delta) : delta);
+        STOPPED_LOG_SERVICES.add(name);
+    }
     await docker(["rm", "-f", name], 30_000);
     RUNTIME_SERVICES.delete(name);
     for (const entry of svc?.tls ?? [])
@@ -2921,6 +2936,10 @@ function parkCoverageBundle(caseId, captures) {
  * so it travels with the snapshot into every fork.
  */
 const LOG_MARKERS = new Map();
+// Fork with the harness, like markers. Deltas drain once per case; names remain
+// excluded from Docker reads until a replacement container starts.
+const STOPPED_LOG_DELTAS = new Map();
+const STOPPED_LOG_SERVICES = new Set();
 /**
  * Inspect a container's run state for {@link ServiceLogDelta}: `{}` while
  * running (or when inspect fails — a removed container has no state left to
@@ -2949,43 +2968,51 @@ async function captureServiceLogDeltas() {
         byName.set(s.name, s);
     for (const [name, s] of RUNTIME_SERVICES)
         byName.set(name, s);
-    const services = [...byName.values()];
-    return Promise.all(services.map(async (svc) => {
-        const [r, stop] = await Promise.all([
-            docker(["logs", "--timestamps", svc.name], 30_000),
-            containerStopState(svc.name),
-        ]);
-        if (r.code !== 0) {
-            // Container gone/renamed — surface the CLI error, leave markers put.
-            const err = capMiddle(r.stderr || r.stdout, LOG_DELTA_MAX_BYTES);
-            return {
-                service: svc.name,
-                stdout: "",
-                stdoutTruncated: false,
-                stdoutReset: false,
-                stderr: err.value,
-                stderrTruncated: err.truncated,
-                stderrReset: false,
-                ...stop,
-            };
-        }
-        const outKey = `${svc.name}stdout`;
-        const errKey = `${svc.name}stderr`;
-        const out = streamDelta(r.stdout, LOG_MARKERS.get(outKey)?.lines ?? 0);
-        const err = streamDelta(r.stderr, LOG_MARKERS.get(errKey)?.lines ?? 0);
-        LOG_MARKERS.set(outKey, { lines: out.total });
-        LOG_MARKERS.set(errKey, { lines: err.total });
+    const deltas = new Map(STOPPED_LOG_DELTAS);
+    for (const delta of await Promise.all([...byName.keys()]
+        .filter(name => !STOPPED_LOG_SERVICES.has(name)).map(name => captureServiceLogDelta(name)))) {
+        const previous = deltas.get(delta.service);
+        deltas.set(delta.service, previous ? mergeServiceLogDeltas(previous, delta) : delta);
+    }
+    STOPPED_LOG_DELTAS.clear();
+    return [...deltas.values()];
+}
+async function captureServiceLogDelta(name, final = false) {
+    const [r, stop] = await Promise.all([
+        docker(["logs", "--timestamps", name], 30_000),
+        containerStopState(name),
+    ]);
+    if (r.code !== 0) {
+        // Container gone/renamed — surface the CLI error, leave markers put.
+        const err = capMiddle(r.stderr || r.stdout, LOG_DELTA_MAX_BYTES);
         return {
-            service: svc.name,
-            stdout: out.delta,
-            stdoutTruncated: out.truncated,
-            stdoutReset: out.reset,
-            stderr: err.delta,
+            service: name,
+            stdout: "",
+            stdoutTruncated: false,
+            stdoutReset: false,
+            stderr: err.value,
             stderrTruncated: err.truncated,
-            stderrReset: err.reset,
+            stderrReset: false,
             ...stop,
         };
-    }));
+    }
+    const outKey = `${name}stdout`;
+    const errKey = `${name}stderr`;
+    const complete = (text) => final && text && !text.endsWith("\n") ? text + "\n" : text;
+    const out = streamDelta(complete(r.stdout), LOG_MARKERS.get(outKey)?.lines ?? 0);
+    const err = streamDelta(complete(r.stderr), LOG_MARKERS.get(errKey)?.lines ?? 0);
+    LOG_MARKERS.set(outKey, { lines: out.total });
+    LOG_MARKERS.set(errKey, { lines: err.total });
+    return {
+        service: name,
+        stdout: out.delta,
+        stdoutTruncated: out.truncated,
+        stdoutReset: out.reset,
+        stderr: err.delta,
+        stderrTruncated: err.truncated,
+        stderrReset: err.reset,
+        ...stop,
+    };
 }
 // ────────────────────────────────────────────────────────────────────────
 // Coverage capture (opt-in per service; see coverage.ts + harness/coverage.ts)

package/dist/harness/log-delta.d.ts

@@ -52,3 +52,12 @@ export interface StreamDelta {
  * capture repeats the other half, since the marker counts lines.
  */
 export declare function streamDelta(full: string, marker: number): StreamDelta;
+/** Join successive container incarnations into one bounded per-service delta. */
+export declare function mergeServiceLogDeltas<T extends {
+    stdout: string;
+    stderr: string;
+    stdoutTruncated: boolean;
+    stderrTruncated: boolean;
+    stdoutReset: boolean;
+    stderrReset: boolean;
+}>(earlier: T, later: T): T;

package/dist/harness/log-delta.js

@@ -81,3 +81,13 @@ export function streamDelta(full, marker) {
     const capped = capMiddle(delta, LOG_DELTA_MAX_BYTES);
     return { delta: capped.value, total, reset, truncated: capped.truncated };
 }
+/** Join successive container incarnations into one bounded per-service delta. */
+export function mergeServiceLogDeltas(earlier, later) {
+    const stdout = capMiddle(earlier.stdout + later.stdout, LOG_DELTA_MAX_BYTES);
+    const stderr = capMiddle(earlier.stderr + later.stderr, LOG_DELTA_MAX_BYTES);
+    return { ...later, stdout: stdout.value, stderr: stderr.value,
+        stdoutTruncated: earlier.stdoutTruncated || later.stdoutTruncated || stdout.truncated,
+        stderrTruncated: earlier.stderrTruncated || later.stderrTruncated || stderr.truncated,
+        stdoutReset: earlier.stdoutReset || later.stdoutReset,
+        stderrReset: earlier.stderrReset || later.stderrReset };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.131.11",
+  "version": "0.131.12",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",

package/src/components/replay-websocket.ts

@@ -218,7 +218,12 @@ export function replayWebSocket(args: {
     const progress = record.inputMode === "anchors"
       ? ` occurrence ${record.inputOccurrences![position]}; observed ${occurrences.get(expected) ?? 0} occurrences; received ${receivedMessages} messages, ${receivedCandidates} candidates; last candidate ${lastCandidate ?? "<none>"}`
       : "";
-    return diagnostic(`required input never arrived; expected ${expected}${progress}`);
+    const reordered = record.inputMode === "anchors"
+      && (occurrences.get(expected) ?? 0) >= record.inputOccurrences![position];
+    const detail = reordered
+      ? "required input arrived before preceding anchors matched"
+      : "required input never arrived";
+    return diagnostic(`${detail}; expected ${expected}${progress}`);
   };
   const armDeadline = () => {
     clearTimeout(deadline);

package/src/components/replayFake-websocket.test.ts

@@ -452,3 +452,26 @@ test("a reached response anchor catches up older output without adding its stale
   expect(c.sent).toEqual([...messages.map(m => m.data), "response"]);
   await c.close(); expect(h.state.websocketErrors).toEqual([]);
 });
+
+
+test("an anchor observed before its predecessor is diagnosed as out of order", async () => {
+  const key: WebSocketKey<null> = { initial: null,
+    input(state, message) { return { state, key: message }; },
+    output(state) { return { state, anchorPreviousInput: true }; },
+  };
+  const hash = (value: string) => websocketMatcher(() => value)("x")!;
+  const h = await harness([{ request, inputMode: "anchors",
+    inputs: [hash("start"), hash("warmup"), hash("question")],
+    inputOccurrences: [1, 1, 1],
+    messages: [{ type: "text", data: "answer", afterInput: 3, delayMs: 0 }],
+  }], key);
+  const c = await h.connect();
+  await c.message("start");
+  await c.message("question");
+  await c.message("warmup");
+  await tick();
+  expect(c.sent).toEqual([]);
+  await c.close();
+  expect(h.state.websocketErrors.join()).toContain("input #3: required input arrived before preceding anchors matched");
+  expect(h.state.websocketErrors.join()).toContain("occurrence 1; observed 1 occurrences");
+});

package/src/daemon.ts

@@ -109,7 +109,7 @@ import {
   type GroupMeta,
 } from "./harness/catalogue.js";
 import { summarizeBuildKit, type BuildStep } from "./harness/buildkit-progress.js";
-import { LOG_DELTA_MAX_BYTES, capMiddle, streamDelta } from "./harness/log-delta.js";
+import { LOG_DELTA_MAX_BYTES, capMiddle, streamDelta, mergeServiceLogDeltas } from "./harness/log-delta.js";
 import {
   resolveHostPath as resolveVolumeHostPath,
   sanitizeSegment,
@@ -1489,6 +1489,11 @@ async function runContainer(
   // container docker-native multi-label resolution for its `hostnames`.
   extraAliases: string[] = [],
 ): Promise<void> {
+  // Preserve the previous incarnation before the name is reused.
+  if (RUNTIME_SERVICES.has(svc.name)) await stopRuntimeService(svc.name);
+  STOPPED_LOG_SERVICES.delete(svc.name);
+  LOG_MARKERS.delete(`${svc.name}\0stdout`);
+  LOG_MARKERS.delete(`${svc.name}\0stderr`);
   // Idempotent: clean up any leftover container with the same name.
   await docker(["rm", "-f", svc.name], 30_000);
 
@@ -2947,6 +2952,15 @@ async function stopRuntimeService(name: string): Promise<void> {
   const t0 = Date.now();
   const resv = reserveEvent();
   const svc = RUNTIME_SERVICES.get(name);
+  // Freeze log production before reading, while Docker still owns the logs.
+  // Keep force-stop semantics; removing first destroys the only copy.
+  await docker(["kill", name], 30_000);
+  if (!STOPPED_LOG_SERVICES.has(name)) {
+    const delta = await captureServiceLogDelta(name, true);
+    const previous = STOPPED_LOG_DELTAS.get(name);
+    STOPPED_LOG_DELTAS.set(name, previous ? mergeServiceLogDeltas(previous, delta) : delta);
+    STOPPED_LOG_SERVICES.add(name);
+  }
   await docker(["rm", "-f", name], 30_000);
   RUNTIME_SERVICES.delete(name);
   for (const entry of svc?.tls ?? []) await unbindRuntimeTls(entry.hostname);
@@ -3482,6 +3496,10 @@ function parkCoverageBundle(
  * so it travels with the snapshot into every fork.
  */
 const LOG_MARKERS = new Map<string, { lines: number }>();
+// Fork with the harness, like markers. Deltas drain once per case; names remain
+// excluded from Docker reads until a replacement container starts.
+const STOPPED_LOG_DELTAS = new Map<string, ServiceLogDelta>();
+const STOPPED_LOG_SERVICES = new Set<string>();
 
 /** Per-(service, stream) delta byte cap. Over this we keep head+tail and
  *  elide the middle — the head preserves the continuation from the parent,
@@ -3537,45 +3555,52 @@ async function captureServiceLogDeltas(): Promise<ServiceLogDelta[]> {
   const byName = new Map<string, NamedService>();
   for (const s of namedServices(l.project.environment)) byName.set(s.name, s);
   for (const [name, s] of RUNTIME_SERVICES) byName.set(name, s);
-  const services = [...byName.values()];
-  return Promise.all(
-    services.map(async (svc): Promise<ServiceLogDelta> => {
-      const [r, stop] = await Promise.all([
-        docker(["logs", "--timestamps", svc.name], 30_000),
-        containerStopState(svc.name),
-      ]);
-      if (r.code !== 0) {
-        // Container gone/renamed — surface the CLI error, leave markers put.
-        const err = capMiddle(r.stderr || r.stdout, LOG_DELTA_MAX_BYTES);
-        return {
-          service: svc.name,
-          stdout: "",
-          stdoutTruncated: false,
-          stdoutReset: false,
-          stderr: err.value,
-          stderrTruncated: err.truncated,
-          stderrReset: false,
-          ...stop,
-        };
-      }
-      const outKey = `${svc.name}stdout`;
-      const errKey = `${svc.name}stderr`;
-      const out = streamDelta(r.stdout, LOG_MARKERS.get(outKey)?.lines ?? 0);
-      const err = streamDelta(r.stderr, LOG_MARKERS.get(errKey)?.lines ?? 0);
-      LOG_MARKERS.set(outKey, { lines: out.total });
-      LOG_MARKERS.set(errKey, { lines: err.total });
-      return {
-        service: svc.name,
-        stdout: out.delta,
-        stdoutTruncated: out.truncated,
-        stdoutReset: out.reset,
-        stderr: err.delta,
-        stderrTruncated: err.truncated,
-        stderrReset: err.reset,
-        ...stop,
-      };
-    }),
-  );
+  const deltas = new Map(STOPPED_LOG_DELTAS);
+  for (const delta of await Promise.all([...byName.keys()]
+    .filter(name => !STOPPED_LOG_SERVICES.has(name)).map(name => captureServiceLogDelta(name)))) {
+    const previous = deltas.get(delta.service);
+    deltas.set(delta.service, previous ? mergeServiceLogDeltas(previous, delta) : delta);
+  }
+  STOPPED_LOG_DELTAS.clear();
+  return [...deltas.values()];
+}
+
+async function captureServiceLogDelta(name: string, final = false): Promise<ServiceLogDelta> {
+  const [r, stop] = await Promise.all([
+    docker(["logs", "--timestamps", name], 30_000),
+    containerStopState(name),
+  ]);
+  if (r.code !== 0) {
+    // Container gone/renamed — surface the CLI error, leave markers put.
+    const err = capMiddle(r.stderr || r.stdout, LOG_DELTA_MAX_BYTES);
+    return {
+      service: name,
+      stdout: "",
+      stdoutTruncated: false,
+      stdoutReset: false,
+      stderr: err.value,
+      stderrTruncated: err.truncated,
+      stderrReset: false,
+      ...stop,
+    };
+  }
+  const outKey = `${name}stdout`;
+  const errKey = `${name}stderr`;
+  const complete = (text: string) => final && text && !text.endsWith("\n") ? text + "\n" : text;
+  const out = streamDelta(complete(r.stdout), LOG_MARKERS.get(outKey)?.lines ?? 0);
+  const err = streamDelta(complete(r.stderr), LOG_MARKERS.get(errKey)?.lines ?? 0);
+  LOG_MARKERS.set(outKey, { lines: out.total });
+  LOG_MARKERS.set(errKey, { lines: err.total });
+  return {
+    service: name,
+    stdout: out.delta,
+    stdoutTruncated: out.truncated,
+    stdoutReset: out.reset,
+    stderr: err.delta,
+    stderrTruncated: err.truncated,
+    stderrReset: err.reset,
+    ...stop,
+  };
 }
 
 // ────────────────────────────────────────────────────────────────────────

package/src/harness/log-delta.test.ts

@@ -123,3 +123,20 @@ describe("streamDelta", () => {
     expect(out.delta.length).toBeLessThan(big.length);
   });
 });
+
+test("repeated service incarnations retain both ends within the log cap", async () => {
+  const { mergeServiceLogDeltas, LOG_DELTA_MAX_BYTES } = await import("./log-delta");
+  const earlier = { stdout: "first\n" + "x".repeat(LOG_DELTA_MAX_BYTES), stderr: "old error\n",
+    stdoutTruncated: false, stderrTruncated: true, stdoutReset: false, stderrReset: false,
+    stopped: true, exitCode: 137 };
+  const later = { ...earlier, stdout: "last\n", stderr: "new error\n", stderrTruncated: false,
+    stopped: false, exitCode: 0 };
+  const result = mergeServiceLogDeltas(earlier, later);
+  expect(result.stdout.startsWith("first\n")).toBe(true);
+  expect(result.stdout.endsWith("last\n")).toBe(true);
+  expect(result.stdout.length).toBeLessThan(LOG_DELTA_MAX_BYTES + 100);
+  expect(result.stdoutTruncated).toBe(true);
+  expect(result.stderr).toBe("old error\nnew error\n");
+  expect(result.stderrTruncated).toBe(true);
+  expect(result.stopped).toBe(false);
+});

package/src/harness/log-delta.ts

@@ -98,3 +98,18 @@ export function streamDelta(full: string, marker: number): StreamDelta {
   const capped = capMiddle(delta, LOG_DELTA_MAX_BYTES);
   return { delta: capped.value, total, reset, truncated: capped.truncated };
 }
+
+/** Join successive container incarnations into one bounded per-service delta. */
+export function mergeServiceLogDeltas<T extends {
+  stdout: string; stderr: string;
+  stdoutTruncated: boolean; stderrTruncated: boolean;
+  stdoutReset: boolean; stderrReset: boolean;
+}>(earlier: T, later: T): T {
+  const stdout = capMiddle(earlier.stdout + later.stdout, LOG_DELTA_MAX_BYTES);
+  const stderr = capMiddle(earlier.stderr + later.stderr, LOG_DELTA_MAX_BYTES);
+  return { ...later, stdout: stdout.value, stderr: stderr.value,
+    stdoutTruncated: earlier.stdoutTruncated || later.stdoutTruncated || stdout.truncated,
+    stderrTruncated: earlier.stderrTruncated || later.stderrTruncated || stderr.truncated,
+    stdoutReset: earlier.stdoutReset || later.stdoutReset,
+    stderrReset: earlier.stderrReset || later.stderrReset };
+}

package/src/runtime-service-logs.test.ts

@@ -0,0 +1,74 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+test("stopped service logs survive removal and are emitted only in their owning case", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spectest-stopped-logs-"));
+  try {
+    await mkdir(join(root, "spectest"));
+    await mkdir(join(root, "bin"));
+    await writeFile(join(root, "bin/docker"), `#!/bin/sh
+case "$1" in
+  kill) touch "$SPECTEST_APP_DIR/stopped" ;;
+  rm) touch "$SPECTEST_APP_DIR/removed" ;;
+  run) rm -f "$SPECTEST_APP_DIR/stopped" "$SPECTEST_APP_DIR/removed" ;;
+  inspect) echo 'exited 137' ;;
+  logs)
+    if [ -f "$SPECTEST_APP_DIR/removed" ]; then echo 'container removed' >&2; exit 1; fi
+    if [ -f "$SPECTEST_APP_DIR/stopped" ]; then
+      printf 'startup\nlast diagnostic\n'
+      printf 'failure detail' >&2
+    else printf 'startup\n'; fi ;;
+esac
+`, { mode: 0o755 });
+    await writeFile(join(root, "spectest/index.ts"), `
+      import { defineEnvironment } from ${JSON.stringify(new URL("./index.ts", import.meta.url).href)};
+      const env = defineEnvironment({ name: "logs", services: {
+        agent: { image: { type: "registry", reference: "busybox" } }
+      }});
+      export default env.project([
+        env.test("parent", async () => {}),
+        env.test("stop", async ctx => { await ctx.stopService("agent"); await ctx.stopService("agent"); }),
+        env.test("child", async () => {}),
+        env.test("reuse", async ctx => {
+          const spec = { name: "runtime", image: { type: "registry", reference: "busybox" } };
+          await ctx.startService(spec);
+          await ctx.stopService("runtime");
+          await ctx.startService(spec);
+          await ctx.stopService("runtime");
+        }),
+      ]);
+    `);
+    const script = `
+      import { strict as assert } from "node:assert";
+      import { METHODS } from ${JSON.stringify(new URL("./daemon.ts", import.meta.url).href)};
+      const loaded = await METHODS.load({});
+      const parent = await METHODS.run({caseId: loaded.cases[0].id});
+      assert.equal(parent.serviceLogDeltas[0].stdout, "startup\\n");
+      const stopped = await METHODS.run({caseId: loaded.cases[1].id});
+      assert.equal(stopped.status, "passed", JSON.stringify(stopped));
+      assert.equal(stopped.serviceLogDeltas.length, 1);
+      assert.equal(stopped.serviceLogDeltas[0].stdout, "last diagnostic\\n");
+      assert.equal(stopped.serviceLogDeltas[0].stderr, "failure detail\\n");
+      assert.equal(stopped.serviceLogDeltas[0].stopped, true);
+      assert.equal(stopped.serviceLogDeltas[0].exitCode, 137);
+      const child = await METHODS.run({caseId: loaded.cases[2].id});
+      assert.deepEqual(child.serviceLogDeltas, []);
+      const reuse = await METHODS.run({caseId: loaded.cases[3].id});
+      assert.equal(reuse.status, "passed", JSON.stringify(reuse));
+      const logs = reuse.serviceLogDeltas.find(d => d.service === "runtime");
+      assert.equal(logs.stdout, "startup\\nlast diagnostic\\nstartup\\nlast diagnostic\\n");
+      assert.equal(logs.stderr, "failure detail\\nfailure detail\\n");
+      process.exit(0);
+    `;
+    const child = Bun.spawn([process.execPath, "--eval", script], {
+      env: { ...process.env, SPECTEST_APP_DIR: root, PATH: `${root}/bin:${process.env.PATH}` },
+      stdout: "pipe", stderr: "pipe",
+    });
+    const [code, stdout, stderr] = await Promise.all([
+      child.exited, new Response(child.stdout).text(), new Response(child.stderr).text(),
+    ]);
+    expect(code, stdout + stderr).toBe(0);
+  } finally { await rm(root, { recursive: true, force: true }); }
+}, 20_000);