@specific.dev/spectest 0.79.1 → 0.80.0

package/src/daemon.ts

@@ -53,9 +53,6 @@ import {
   coverageAdapters,
   coverageReportsMode,
   validateCoverage,
-  nodeCoverageToolsAvailable,
-  nodeCoverageToolsDir,
-  NODE_COVERAGE_TOOLS_CONTAINER_DIR,
   type CoverageAdapter,
   type CoverageCaptureContext,
 } from "./coverage.js";
@@ -95,12 +92,13 @@ import { runWrapperRules } from "./harness/wrapper-rules.js";
 import type { WrapperDiagnostic } from "./harness/wrapper-rules.js";
 import { cpus } from "node:os";
 import { APP_DIR, WORKSPACE, resolveExistingProjectPath, resolveProjectPath } from "./project-files.js";
+import { installFetchWrapper, isTransportError } from "./harness/fetch.js";
 import {
-  isTextualContentType,
-  looksBinary,
-  omittedBody,
-  parseContentLength,
-} from "./harness/http-body.js";
+  bindInstrumentationScope,
+  createInstrumentationScope,
+  runInstrumented,
+  runUninstrumented,
+} from "./harness/instrumentation-scope.js";
 import { encodeRegistry } from "./harness/names-registry.js";
 import {
   InterceptRegistry,
@@ -169,16 +167,13 @@ import { openTerminal } from "./terminal.js";
 // `ctx.mcp(url)`. One client per call, no registry: an authenticated
 // client is passed to descendants as a test's return value.
 import { openMcp } from "./mcp.js";
-import { setRawFetch } from "./harness/raw-fetch.js";
 import { readAnnotation, type RenderAnnotation } from "./annotate.js";
 import {
   isRecording,
-  pauseRecording,
   recordEmail,
   recordEnv,
   recordExec,
   recordFake,
-  recordHttp,
   recordStep,
   recordTerminal,
   recordWait,
@@ -186,16 +181,14 @@ import {
   recorderEventCount,
   recorderMarkChildren,
   recorderTruncate,
-  resumeRecording,
   startRecording,
   stopRecording,
   truncateUtf8,
   type StepBlock,
   type TestEvent,
-  type OmittedBody,
 } from "./recorder.js";
-import { deepUnwrap, readRaw, wrap, wrapResponse } from "./inspect.js";
-import type { Wrapped, WrappedResponse } from "./inspect.js";
+import { deepUnwrap, readRaw, wrap } from "./inspect.js";
+import type { Wrapped } from "./inspect.js";
 import { clearRecordSecrets, setRecordSecrets } from "./record-secrets.js";
 import { generateId } from "./ids.js";
 import { encodeReplayBundle, replayChunk } from "./replay-bundle.js";
@@ -983,16 +976,9 @@ async function ensureCoverage(svc: NamedService): Promise<string[]> {
   const host = coverageHostDir(WORKSPACE, svc.name);
   await fs.mkdir(host, { recursive: true });
   await fs.chmod(host, 0o777);
-  const flags = [`--volume=${host}:${COVERAGE_CONTAINER_DIR}`];
-  // The conversion tools golden ships (`c8` for `coverage.node()`),
-  // read-only, on the same existence check the adapter makes at capture
-  // — so the VM and the container agree on whether they are there. A
-  // plain `--volume`, never a config `volumes` entry: an absolute-source
-  // volume dir is listed in the delta-restore manifest and wiped.
-  if (await nodeCoverageToolsAvailable()) {
-    flags.push(`--volume=${nodeCoverageToolsDir()}:${NODE_COVERAGE_TOOLS_CONTAINER_DIR}:ro`);
-  }
-  return flags;
+  // Nothing else is mounted: no conversion runs in the container (the
+  // c8 tools mount went with SDK 0.80).
+  return [`--volume=${host}:${COVERAGE_CONTAINER_DIR}`];
 }
 
 /** A `user`/`group` pair resolved to the numeric ids the kernel wants.
@@ -2150,7 +2136,7 @@ async function startIngress(): Promise<void> {
   for (const [name, fake] of FAKES) {
     if (fake.def.state) {
       try {
-        fake.state = await fake.def.state();
+        fake.state = await runUninstrumented(() => fake.def.state!());
       } catch (err) {
         throw new Error(
           `fake ${JSON.stringify(name)} state() factory threw: ${(err as Error).message}`,
@@ -2604,7 +2590,9 @@ async function dispatchIngress(
   const upstream = async (current: Request): Promise<Response> => {
     if (route.kind === "fake") {
       try {
-        return await route.fake.def.handler(current, route.fake.state, FAKE_CTX);
+        return await runUninstrumented(() =>
+          route.fake.def.handler(current, route.fake.state, FAKE_CTX),
+        );
       } catch (err) {
         const e = err as Error;
         return new Response(
@@ -3057,7 +3045,7 @@ function registerInterceptor(
     );
   }
   const resv = reserveEvent();
-  const it = INTERCEPTORS.register(host, path, handler);
+  const it = INTERCEPTORS.register(host, path, bindInstrumentationScope(handler));
   const where = `${host}${it.path === "/" ? "" : it.path}`;
   const seq = recordStep(
     {
@@ -3288,11 +3276,11 @@ async function ensureFakeHelpers(name: string): Promise<Record<string, unknown>>
   if (!fake) throw new Error(`fake ${JSON.stringify(name)} is not loaded`);
   if (fake.trackedHelpers) return fake.trackedHelpers;
   fake.helpers = fake.def.helpers
-    ? ((await fake.def.helpers({
+    ? ((await runUninstrumented(() => fake.def.helpers!({
         name,
         state: fake.state,
         ctx: FAKE_CTX,
-      })) as Record<string, unknown>)
+      }))) as Record<string, unknown>)
     : {};
   fake.trackedHelpers = trackFakeHelpers(name, fake.helpers);
   return fake.trackedHelpers;
@@ -3386,41 +3374,24 @@ function invokeFakeHelper(
     }, resv);
   };
 
-  // A helper call is ONE step. Whatever the fake does inside it — a fetch to
-  // deliver a webhook, a call to its own API — is the fake's plumbing, not
-  // something the test did, and it would otherwise land on the timeline as
-  // an `http` step the test never made. The built-in `email()` helpers
-  // already pause around their internal polls by hand for exactly this
-  // reason (`components/email.ts`); doing it here gives every user-authored
-  // fake the same contract without having to know about it.
-  //
-  // The pause spans the helper's `await`s, so genuinely concurrent test work
-  // (`Promise.all([helper(), ctx.fetch(…)])`) loses its events too. That is
-  // the same trade `email()` has always made, and sequential test code — all
-  // of it, in practice — is unaffected.
-  pauseRecording();
+  // Record the public helper call in the caller's scope, while its body
+  // and async descendants use native fetch and emit no internal events.
   let result: unknown;
   try {
-    result = fn.apply(thisArg, args);
+    result = runUninstrumented(() => fn.apply(thisArg, args));
   } catch (err) {
-    resumeRecording();
     recordError(err);
     throw err;
   }
   if (result instanceof Promise) {
     return result.then(
-      (value) => {
-        resumeRecording();
-        return recordResult(value);
-      },
+      recordResult,
       (err) => {
-        resumeRecording();
         recordError(err);
         throw err;
       },
     );
   }
-  resumeRecording();
   return recordResult(result);
 }
 
@@ -3756,13 +3727,15 @@ async function runProjectSetupInner(): Promise<ProjectSetupResult> {
   // as in a test. No recorder is active here, so it wraps without provenance —
   // but the wrapped type stays honest at runtime (`.unwrap()` works).
   const restoreFetch = installFetchWrapper();
+  const fetchScope = createInstrumentationScope(false);
   // The full context, unscoped: every service is up by project-setup time,
   // so `ctx.svc` is the same map tests see (and shares helper instances with
   // them — a Bun.SQL pool created here is reused later).
   const ctx: ProjectSetupContext = await spectestContext();
   try {
-    await proj.setup(ctx);
+    await runInstrumented(fetchScope, () => proj.setup!(ctx));
   } finally {
+    fetchScope.active = false;
     restoreFetch();
   }
   return { ran: true, durationMs: Date.now() - start };
@@ -4753,173 +4726,6 @@ async function buildServiceHandles(cfg: EnvironmentConfig): Promise<ServiceHandl
 // Instrumentation helpers
 // ────────────────────────────────────────────────────────────────────────
 
-function describeFetchInput(input: Parameters<typeof fetch>[0]): {
-  url: string;
-  methodFromInput?: string;
-} {
-  if (typeof input === "string") return { url: input };
-  if (input instanceof URL) return { url: input.toString() };
-  // Request instance
-  const req = input as Request;
-  return { url: req.url, methodFromInput: req.method };
-}
-
-function describeRequestBody(
-  input: Parameters<typeof fetch>[0],
-  init: Parameters<typeof fetch>[1],
-): { body?: string; truncated?: boolean } {
-  // For Request objects, body has already been consumed into the request;
-  // we can't read it back without cloning, which costs. Skip unless init.body
-  // is provided directly.
-  const body = init?.body;
-  if (body === undefined || body === null) {
-    if (input instanceof Request && input.bodyUsed === false) {
-      // Don't drain the request's body here — leaving it for the actual
-      // fetch. Return a marker.
-      return { body: "[Request body not captured]", truncated: false };
-    }
-    return {};
-  }
-  if (typeof body === "string") {
-    const t = truncateUtf8(body);
-    return { body: t.value, truncated: t.truncated };
-  }
-  if (body instanceof URLSearchParams) {
-    const t = truncateUtf8(body.toString());
-    return { body: t.value, truncated: t.truncated };
-  }
-  return { body: `[non-text body: ${body.constructor?.name ?? typeof body}]` };
-}
-
-/**
- * Marks an error thrown by the instrumented fetch as *transport-level* —
- * the connection itself failed (refused, unresolvable, reset) before any
- * HTTP reply existed. `fetch` never rejects for an HTTP status, so every
- * rejection short of an abort is transport. `Symbol.for` so a duplicated
- * SDK module instance (the bun hardlink landmine) still recognises it.
- *
- * Why it exists: `ctx.poll` waits for convergence, and right after a fork
- * restore the guest can serve a ~10 s window where a connect or a DNS
- * lookup fails once and then heals (measured 2026-08-21: a poll's first
- * fetch hung 12 s in resolution, threw, and killed a 60 s poll on attempt
- * 1 while attempt 2 would have passed). During a poll, a dead connection
- * is just "not ready yet"; outside one it stays a hard error.
- */
-const TRANSPORT_ERROR = Symbol.for("spectest.transportError");
-
-function isTransportError(err: unknown): boolean {
-  return (
-    typeof err === "object" &&
-    err !== null &&
-    (err as Record<symbol, unknown>)[TRANSPORT_ERROR] === true
-  );
-}
-
-/**
- * Install a fetch wrapper on `globalThis` that emits HTTP events into the
- * active recorder. Returns a restore function. Calls outside of a running
- * test still hit the original fetch (the recorder is null then; the
- * wrapper just adds a tiny amount of overhead — but we restore after each
- * test anyway, so this only matters mid-test).
- */
-function installFetchWrapper(): () => void {
-  const original = globalThis.fetch;
-  // SDK internals (the MCP client, its OAuth flow) must not see the
-  // wrapper: a wrapped `res.ok` is an object, and the wrapper reads every
-  // body to the end, which never finishes for an SSE stream.
-  setRawFetch(original);
-  const wrappedFn = async (
-    input: Parameters<typeof fetch>[0],
-    init?: Parameters<typeof fetch>[1],
-  ): Promise<Response | WrappedResponse> => {
-    const start = Date.now();
-    const resv = reserveEvent();
-    const { url, methodFromInput } = describeFetchInput(input);
-    const method = (init?.method ?? methodFromInput ?? "GET").toUpperCase();
-    const reqBody = describeRequestBody(input, init);
-    try {
-      const res = await original(input as RequestInfo, init);
-      let responseBody: string | OmittedBody | undefined;
-      let responseBodyTruncated: boolean | undefined;
-      // The reply the test gets is untouched: everything here reads a clone,
-      // and a body known to be binary is not read at all. See
-      // ./harness/http-body.ts for why a blanket `.text()` was wrong.
-      const contentType = res.headers.get("content-type");
-      const contentLength = () => parseContentLength(res.headers.get("content-length"));
-      const textual = isTextualContentType(contentType);
-      if (textual === false) {
-        responseBody = omittedBody("binary", contentType, contentLength());
-      } else {
-        try {
-          const cloned = res.clone();
-          const text = await cloned.text();
-          if (textual === undefined && looksBinary(text)) {
-            // No content type (or a multipart one), and the bytes say this
-            // was never text.
-            responseBody = omittedBody("binary", contentType, contentLength());
-          } else {
-            const t = truncateUtf8(text);
-            responseBody = t.value;
-            responseBodyTruncated = t.truncated;
-          }
-        } catch {
-          // The stream failed, or something had already consumed the body.
-          responseBody = omittedBody("unreadable", contentType, contentLength());
-        }
-      }
-      const seq = recordHttp({
-        method,
-        url,
-        requestBody: reqBody.body,
-        requestBodyTruncated: reqBody.truncated,
-        status: res.status,
-        responseBody,
-        responseBodyTruncated,
-        durationMs: Date.now() - start,
-      }, resv);
-      return wrapResponse(res, seq);
-    } catch (err) {
-      const e = err as Error;
-      recordHttp({
-        method,
-        url,
-        requestBody: reqBody.body,
-        requestBodyTruncated: reqBody.truncated,
-        durationMs: Date.now() - start,
-        error: e?.message ?? String(err),
-      }, resv);
-      // Tag transport failures for ctx.poll (see TRANSPORT_ERROR). An abort
-      // is the caller's own signal (their AbortController or their
-      // AbortSignal.timeout) — their semantics, never retried for them.
-      if (
-        typeof err === "object" &&
-        err !== null &&
-        e?.name !== "AbortError" &&
-        e?.name !== "TimeoutError"
-      ) {
-        try {
-          (err as Record<symbol, unknown>)[TRANSPORT_ERROR] = true;
-        } catch {
-          /* frozen error object — stays a hard error */
-        }
-      }
-      throw err;
-    }
-  };
-  // Preserve any provider-specific statics on `fetch` (e.g. Bun's
-  // `fetch.preconnect`) so consumers that touch them keep working.
-  const wrapped = wrappedFn as unknown as typeof fetch;
-  for (const key of Object.keys(original) as (keyof typeof original)[]) {
-    (wrapped as unknown as Record<string, unknown>)[key as string] = (
-      original as unknown as Record<string, unknown>
-    )[key as string];
-  }
-  globalThis.fetch = wrapped;
-  return () => {
-    globalThis.fetch = original;
-  };
-}
-
 /** Build the `docker exec` argv for a service command. A string command runs
  *  through `sh -lc`; an array is exact argv with no shell (the
  *  `["psql", "-f", "-"]` shape). An optional `cwd` becomes `-w <cwd>` (the
@@ -5481,6 +5287,7 @@ async function runOne(testCase: TestCase<unknown>): Promise<RunResult> {
 
   startRecording();
   const restoreFetch = installFetchWrapper();
+  const fetchScope = createInstrumentationScope();
 
   // Look up the parent's stored return value (if any). The parent ran in
   // an ancestor fork; its TEST_DATA entry travels with the snapshot.
@@ -5622,7 +5429,7 @@ async function runOne(testCase: TestCase<unknown>): Promise<RunResult> {
   let outcome: { status: "passed" | "failed"; error?: RunResult["error"] };
   try {
     const value = await Promise.race([
-      Promise.resolve(testCase.run(ctx)),
+      Promise.resolve(runInstrumented(fetchScope, () => testCase.run(ctx))),
       timedOut,
     ]);
     // Stash the return value so child cases — which fork from the snapshot
@@ -5639,6 +5446,7 @@ async function runOne(testCase: TestCase<unknown>): Promise<RunResult> {
     if (timer) clearTimeout(timer);
     RECORDING_EXEC = undefined;
     INTERCEPTORS.endScope();
+    fetchScope.active = false;
     restoreFetch();
     restoreConsole();
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -6013,6 +5821,7 @@ async function evalCode(
   // Response just like in a test (no recorder here, so no provenance — but the
   // wrapped type is honest at runtime). Restored in the `finally` below.
   const restoreFetch = installFetchWrapper();
+  const fetchScope = createInstrumentationScope(false);
 
   // Same persistent acquire/detach as a test run (see runOne): the browser
   // survives the eval, so successive `spectest env eval` calls continue one
@@ -6177,7 +5986,8 @@ async function evalCode(
     await fs.mkdir(EVAL_DIR, { recursive: true });
     filePath = path.join(EVAL_DIR, `${randomUUID()}.ts`);
     await fs.writeFile(filePath, prepared.code);
-    const mod = (await import(pathToFileURL(filePath).href)) as { default?: unknown };
+    const moduleUrl = pathToFileURL(filePath).href;
+    const mod = (await runInstrumented(fetchScope, () => import(moduleUrl))) as { default?: unknown };
     outcome = { ok: true, result: safeSerialize(mod.default) };
   } catch (err) {
     const e = err as Error;
@@ -6188,6 +5998,7 @@ async function evalCode(
     };
   } finally {
     clearRecordSecrets();
+    fetchScope.active = false;
     restoreFetch();
     restoreConsole();
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -6255,8 +6066,7 @@ async function evalCode(
 
 /** Where the baked compiler lives. Overridable so the typecheck — and the
  *  blocking rules, which always use THIS copy rather than the project's own —
- *  can be driven outside a VM (same convention as
- *  `SPECTEST_COVERAGE_TOOLS_DIR`). */
+ *  can be driven outside a VM. */
 const TYPECHECK_DIR = process.env.SPECTEST_TYPECHECK_DIR ?? "/opt/spectest/typecheck";
 /** Cap on errors shipped in the report; `totalErrors` carries the true count. */
 const TYPECHECK_ERROR_CAP = 50;

package/src/harness/fetch.test.ts

@@ -0,0 +1,253 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { expect as assertValue } from "../index.js";
+import { type WrappedResponse } from "../inspect.js";
+import { recordFake, startRecording, stopRecording } from "../recorder.js";
+import { installFetchWrapper, isTransportError } from "./fetch.js";
+import {
+  bindInstrumentationScope,
+  createInstrumentationScope,
+  runInstrumented,
+  runUninstrumented,
+  type InstrumentationScope,
+} from "./instrumentation-scope.js";
+
+function deferred<T = void>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((done) => { resolve = done; });
+  return { promise, resolve };
+}
+
+describe("fetch execution scopes", () => {
+  let scope: InstrumentationScope;
+  let restore: () => void;
+  let server: ReturnType<typeof Bun.serve>;
+  let handler: (req: Request) => Response | Promise<Response>;
+  const url = (path: string) => new URL(path, server.url).href;
+
+  beforeEach(() => {
+    handler = () => Response.json({ value: 42 });
+    server = Bun.serve({ port: 0, hostname: "127.0.0.1", fetch: (req) => handler(req) });
+    startRecording();
+    scope = createInstrumentationScope();
+    restore = installFetchWrapper();
+  });
+
+  afterEach(() => {
+    scope.active = false;
+    restore();
+    stopRecording();
+    server.stop(true);
+  });
+
+  test("test helpers retain HTTP and assertion provenance across awaits", async () => {
+    await runInstrumented(scope, async () => {
+      const helper = async () => {
+        await Promise.resolve();
+        return await fetch(url("/test")) as unknown as WrappedResponse;
+      };
+      const res = await helper();
+      expect(res.status.unwrap()).toBe(200);
+      assertValue(res.status).toBe(200);
+      assertValue((await res.json<{ value: number }>()).value).toBe(42);
+    });
+    const events = stopRecording();
+    expect(events.map((e) => e.kind)).toEqual(["http", "assertion", "assertion"]);
+    expect(events[1]).toMatchObject({ sourceSeq: events[0]!.seq, path: ["status"] });
+    expect(events[2]).toMatchObject({ sourceSeq: events[0]!.seq, path: ["body", "value"] });
+  });
+
+  test("background fetch is native even while a test recorder is active", async () => {
+    handler = () => Response.json({ error: "missing" }, { status: 404 });
+    const res = await fetch(url("/background"));
+    expect(res.status).toBe(404);
+    expect(res.ok).toBe(false);
+    expect(await res.json()).toEqual({ error: "missing" });
+    expect(stopRecording()).toEqual([]);
+  });
+
+  test("an HTTP fake records only the test's outer request", async () => {
+    handler = (req) => {
+      if (new URL(req.url).pathname === "/fake") {
+        return runUninstrumented(async () => {
+          await Promise.resolve();
+          const res = await fetch(url("/upstream"));
+          // Ordinary HTTP status/error handling must work inside the fake.
+          if (!res.ok) return new Response(await res.text(), { status: res.status });
+          return new Response("unexpected success");
+        });
+      }
+      return new Response("upstream unavailable", { status: 503 });
+    };
+    await runInstrumented(scope, async () => {
+      const res = await fetch(url("/fake")) as unknown as WrappedResponse;
+      expect(res.status.unwrap()).toBe(503);
+      expect((await res.text()).unwrap()).toBe("upstream unavailable");
+    });
+    expect(stopRecording()).toMatchObject([{ kind: "http", url: url("/fake"), status: 503 }]);
+  });
+
+  test("async fake internals do not suppress concurrent test events", async () => {
+    const entered = deferred();
+    const release = deferred();
+    await runInstrumented(scope, async () => {
+      const fake = runUninstrumented(async () => {
+        entered.resolve();
+        await release.promise;
+        const res = await fetch(url("/fake-internal"));
+        expect(res.status).toBe(200);
+        recordFake({ fake: "nested", member: "internal", args: [], durationMs: 0 });
+        return (await res.json()).value;
+      });
+      // Like invokeFakeHelper, the public call's completion is recorded in
+      // its caller's scope; internal operations stay in the fake scope.
+      const completed = fake.then((value) => {
+        recordFake({ fake: "example", member: "read", args: [], result: value, durationMs: 0 });
+      });
+      await entered.promise;
+      try {
+        await fetch(url("/test-during-fake"));
+      } finally {
+        release.resolve();
+      }
+      await completed;
+      await fetch(url("/test-after-fake"));
+    });
+    expect(stopRecording()).toMatchObject([
+      { kind: "http", url: url("/test-during-fake") },
+      { kind: "fake", fake: "example", member: "read", result: 42 },
+      { kind: "http", url: url("/test-after-fake") },
+    ]);
+  });
+
+  test("fake streams are returned without cloning or waiting for the body to end", async () => {
+    let controller!: ReadableStreamDefaultController<Uint8Array>;
+    handler = () => new Response(new ReadableStream<Uint8Array>({
+      start(c) {
+        controller = c;
+        c.enqueue(new TextEncoder().encode("data: first\n\n"));
+      },
+    }), { headers: { "content-type": "text/event-stream" } });
+    await runInstrumented(scope, () => runUninstrumented(async () => {
+      const res = await fetch(url("/stream"));
+      expect(res.status).toBe(200);
+      expect(res.bodyUsed).toBe(false);
+      const reader = res.body!.getReader();
+      try {
+        expect(new TextDecoder().decode((await reader.read()).value)).toBe("data: first\n\n");
+      } finally {
+        controller.close();
+        await reader.cancel();
+      }
+    }));
+    expect(stopRecording()).toEqual([]);
+  }, 2_000);
+
+  test("test-authored ingress callbacks retain their scope but their fake upstream does not", async () => {
+    const callback = runInstrumented(scope, () => bindInstrumentationScope(async () => {
+      const res = await fetch(url("/interceptor")) as unknown as WrappedResponse;
+      expect(res.status.unwrap()).toBe(200);
+      await runUninstrumented(async () => {
+        const upstream = await fetch(url("/fake-upstream"));
+        expect(upstream.status).toBe(200);
+      });
+    }));
+    // Dispatch from outside the test's async call chain, like ingress does.
+    await callback();
+    expect(stopRecording()).toMatchObject([{ kind: "http", url: url("/interceptor") }]);
+  });
+
+  test("fake errors keep native semantics and throwing restores the test scope", async () => {
+    await runInstrumented(scope, async () => {
+      let rawError: unknown;
+      try {
+        await runUninstrumented(async () => {
+          await Promise.resolve();
+          await fetch("http://[invalid");
+        });
+      } catch (err) {
+        rawError = err;
+      }
+      expect(rawError).toBeInstanceOf(Error);
+      expect(isTransportError(rawError)).toBe(false);
+      let recordedError: unknown;
+      try { await fetch("http://[invalid"); } catch (err) { recordedError = err; }
+      expect(isTransportError(recordedError)).toBe(true);
+      await fetch(url("/test"));
+    });
+    expect(stopRecording().map((e) => e.kind)).toEqual(["http", "http"]);
+  });
+
+  test("late responses and detached callbacks cannot record into the next test", async () => {
+    const entered = deferred();
+    const release = deferred();
+    handler = async (req) => {
+      if (new URL(req.url).pathname === "/late") {
+        entered.resolve();
+        await release.promise;
+      }
+      return Response.json({ value: 42 });
+    };
+    const late = runInstrumented(scope, async () => {
+      const res = await fetch(url("/late"));
+      expect(res.status).toBe(200);
+      await fetch(url("/detached"));
+    });
+    await entered.promise;
+    scope.active = false;
+    restore();
+    expect(stopRecording()).toEqual([]);
+    startRecording();
+    restore = installFetchWrapper();
+    const next = createInstrumentationScope();
+    try {
+      release.resolve();
+      await late;
+      await runInstrumented(next, () => fetch(url("/next-test")));
+      expect(stopRecording()).toMatchObject([{ kind: "http", url: url("/next-test"), seq: 0 }]);
+    } finally {
+      next.active = false;
+    }
+  });
+
+  test("a response body finishing after scope closure cannot record into a new test", async () => {
+    let controller!: ReadableStreamDefaultController<Uint8Array>;
+    const reading = deferred();
+    handler = () => new Response(new ReadableStream<Uint8Array>({
+      start(c) { controller = c; },
+      pull(c) {
+        c.enqueue(new TextEncoder().encode("part"));
+        reading.resolve();
+        // Keep the body open until the test closes the scope.
+        return new Promise(() => {});
+      },
+    }), { headers: { "content-type": "text/plain" } });
+    const pending = runInstrumented(scope, () => fetch(url("/body")));
+    await reading.promise;
+    // Yield so the fetch wrapper can start reading its clone.
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    scope.active = false;
+    stopRecording();
+    startRecording();
+    controller.close();
+    const res = await pending;
+    expect(res.status).toBe(200);
+    expect(await res.text()).toBe("part");
+    expect(stopRecording()).toEqual([]);
+  });
+
+  test("setup/eval keep wrapped responses without recording or wrapping fake internals", async () => {
+    const setup = createInstrumentationScope(false);
+    try {
+      await runInstrumented(setup, async () => {
+        const res = await fetch(url("/setup")) as unknown as WrappedResponse;
+        expect(res.status.unwrap()).toBe(200);
+        await runUninstrumented(async () => {
+          expect((await fetch(url("/setup-fake"))).status).toBe(200);
+        });
+      });
+      expect(stopRecording()).toEqual([]);
+    } finally {
+      setup.active = false;
+    }
+  });
+});