@specific.dev/spectest 0.131.21 → 0.132.2

package/src/browser-clipboard.test.ts

@@ -0,0 +1,177 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { acquirePersistentBrowser, openBrowser, openMobileBackend, prewarmViewPool, type Browser } from "./browser.js";
+import { expect as assert } from "./index.js";
+import { readRaw } from "./inspect.js";
+import { startRecording, stopRecording } from "./recorder.js";
+
+const available = !!(Bun.which("chromium") ?? Bun.which("chromium-browser") ?? Bun.which("google-chrome") ?? Bun.which("chrome"));
+
+describe.skipIf(!available)("native browser clipboard", () => {
+  let server: ReturnType<typeof Bun.serve>;
+  beforeAll(() => {
+    server = Bun.serve({ port: 0, hostname: "127.0.0.1", fetch: () => new Response(`
+      <button id="text">Copy text</button><button id="item">Copy item</button><output></output>
+      <script>
+        window.initialReadPermission = navigator.permissions.query({name: 'clipboard-read'}).then(p => p.state);
+        for (const kind of ['text', 'item']) document.getElementById(kind).onclick = async () => {
+          try {
+            const text = kind === 'text' ? 'Copied native text' : 'Copied native item';
+            if (kind === 'text') await navigator.clipboard.writeText(text);
+            else await navigator.clipboard.write([new ClipboardItem({'text/plain': new Blob([text], {type: 'text/plain'})})]);
+            document.querySelector('output').textContent = text;
+          } catch (e) { document.querySelector('output').textContent = e.message; }
+        };
+      </script>`, { headers: { "content-type": "text/html" } }) });
+  });
+  afterAll(() => server.stop(true));
+  afterEach(() => stopRecording());
+  const state = async (browser: Browser) => readRaw(await browser.evaluate("read clipboard permission", "navigator.permissions.query({name: 'clipboard-read'}).then(p => p.state)"));
+
+  test.each(["browser", "mobile"] as const)("%s: default real clicks copy with both native APIs and reads record assertion provenance", async frame => {
+    const browser = await openBrowser({ frame, url: server.url.href, recorder: { sessionId: "clipboard", recordStep() {} } });
+    try {
+      // Loopback is a secure context, so this exercises native web clipboard APIs.
+      expect(readRaw(await browser.evaluate("secure context", "isSecureContext"))).toBe(true);
+      expect(readRaw(await browser.evaluate("permission at first document", "window.initialReadPermission"))).toBe("prompt");
+      for (const [button, text] of [["Copy text", "Copied native text"], ["Copy item", "Copied native item"]]) {
+        await browser.getByRole("button", { name: button, exact: true }).click();
+        await assert(browser.locator("output")).toHaveText(text);
+        startRecording();
+        assert(await browser.readClipboard()).toBe(text);
+        const events = stopRecording();
+        expect(events).toHaveLength(2);
+        expect(events[0]).toMatchObject({ kind: "browser", action: "readClipboard", sessionId: "clipboard" });
+        expect(events[1]).toMatchObject({ kind: "assertion", passed: true, sourceSeq: events[0]!.seq });
+        expect((await browser.readClipboard()).unwrap()).toBe(text); // same shape without recording
+      }
+    } finally { await browser.close(); }
+  }, 20000);
+
+  test("reads restore native permission defaults and leave other origins unchanged", async () => {
+    const browser = await openBrowser({ url: server.url.href });
+    try {
+      const readStates = () => browser.evaluate("read permission states", async () => {
+        const names = ["clipboard-read", "clipboard-write", "camera", "microphone", "geolocation", "notifications", "background-sync"];
+        return Object.fromEntries(await Promise.all(names.map(async name => [name,
+          (await navigator.permissions.query({ name: name as PermissionName })).state])));
+      });
+      const before = readRaw(await readStates());
+      expect(before).toMatchObject({ "clipboard-read": "prompt", "clipboard-write": "granted" });
+      await browser.readClipboard();
+      expect(readRaw(await readStates())).toEqual(before);
+      await browser.goto(server.url.href.replace("127.0.0.1", "localhost"));
+      expect(readRaw(await readStates())).toEqual(before);
+      await browser.readClipboard();
+      expect(readRaw(await readStates())).toEqual(before);
+      await browser.goto(server.url.href);
+      expect(readRaw(await readStates())).toEqual(before);
+    } finally { await browser.close(); }
+  }, 20000);
+
+  test("native policy failures are recorded without changing permission defaults", async () => {
+    const blocked = Bun.serve({ port: 0, hostname: "127.0.0.1", fetch: () => new Response("<p>Clipboard blocked</p>", {
+      headers: { "content-type": "text/html", "permissions-policy": "clipboard-read=()" },
+    }) });
+    const browser = await openBrowser({ url: blocked.url.href });
+    try {
+      startRecording();
+      await expect(browser.readClipboard()).rejects.toThrow(/permission|policy|denied/i);
+      expect(stopRecording()).toMatchObject([{ kind: "browser", action: "readClipboard", error: expect.any(String) }]);
+      blocked.reload({ fetch: () => new Response("<p>Clipboard allowed</p>", { headers: { "content-type": "text/html" } }) });
+      await browser.reload();
+      expect(await state(browser)).toBe("prompt");
+      await browser.goto("about:blank");
+      await expect(browser.readClipboard()).rejects.toThrow("secure HTTP(S) page");
+    } finally { await browser.close(); blocked.stop(true); }
+  }, 20000);
+
+  test("reads leave pooled, named and inherited sessions at their defaults", async () => {
+    await prewarmViewPool();
+    const a = await acquirePersistentBrowser("clipboard-reader", { url: server.url.href });
+    const b = await acquirePersistentBrowser("clipboard-other", { url: server.url.href });
+    const pooled = await openBrowser({ url: server.url.href });
+    try {
+      await a.browser.getByRole("button", { name: "Copy text", exact: true }).click();
+      await assert(a.browser.locator("output")).toHaveText("Copied native text");
+      expect((await a.browser.readClipboard()).unwrap()).toBe("Copied native text");
+      expect(await state(a.browser)).toBe("prompt");
+      expect(await state(b.browser)).toBe("prompt");
+      expect(await state(pooled)).toBe("prompt");
+      await a.detach();
+      const attached = await acquirePersistentBrowser("clipboard-reader");
+      expect(attached.attached).toBe(true);
+      await attached.browser.reload();
+      expect(await state(attached.browser)).toBe("prompt");
+      await attached.detach();
+    } finally { await a.browser.close(); await b.browser.close(); await pooled.close(); }
+  }, 20000);
+
+  test("observation leaves native prompt decisions, page focus and context lifetime unchanged", async () => {
+    const browser = await openMobileBackend({ url: server.url.href });
+    const page = await browser.silentRead(async page => page);
+    const owner = page.context().browser()!;
+    try {
+      await browser.getByRole("button", { name: "Copy text", exact: true }).click();
+      await assert(browser.locator("output")).toHaveText("Copied native text");
+      const contexts = owner.contexts().length;
+      const focused = await page.evaluate(() => document.hasFocus());
+      expect(await state(browser)).toBe("prompt");
+      expect((await browser.readClipboard()).unwrap()).toBe("Copied native text");
+      expect(owner.contexts().length).toBe(contexts);
+      expect(await page.evaluate(() => document.hasFocus())).toBe(focused);
+      expect(await state(browser)).toBe("prompt");
+      // A persistent CDP 'prompt' override looks correct immediately after a
+      // helper read but prevents this normal prompt -> denied transition.
+      await expect(page.evaluate(() => navigator.clipboard.readText())).rejects.toThrow(/denied/i);
+      expect(await state(browser)).toBe("denied");
+      expect((await browser.readClipboard()).unwrap()).toBe("Copied native text");
+      expect(await state(browser)).toBe("denied");
+      expect(owner.contexts().length).toBe(contexts);
+    } finally { await browser.close(); }
+  }, 20000);
+
+  test("observation preserves denied overrides owned by another DevTools session", async () => {
+    const browser = await openMobileBackend({ url: server.url.href });
+    const page = await browser.silentRead(async page => page);
+    const session = await page.context().browser()!.newBrowserCDPSession();
+    const target = await page.context().newCDPSession(page);
+    try {
+      await browser.getByRole("button", { name: "Copy item", exact: true }).click();
+      await assert(browser.locator("output")).toHaveText("Copied native item");
+      const { targetInfo } = await target.send("Target.getTargetInfo");
+      await session.send("Browser.setPermission", {
+        permission: { name: "clipboard-read", allowWithoutSanitization: true },
+        origin: server.url.origin, browserContextId: targetInfo.browserContextId, setting: "denied",
+      });
+      expect(await state(browser)).toBe("denied");
+      expect((await browser.readClipboard()).unwrap()).toBe("Copied native item");
+      expect(await state(browser)).toBe("denied");
+    } finally { await target.detach(); await session.detach(); await browser.close(); }
+  }, 20000);
+
+  test("navigation during observation rejects and closes the observer without changing app permissions", async () => {
+    const browser = await openMobileBackend({ url: server.url.href });
+    const page = await browser.silentRead(async page => page);
+    const owner = page.context().browser()!;
+    const createContext = owner.newContext.bind(owner);
+    const count = owner.contexts().length;
+    // Place a native navigation precisely after observer permission setup,
+    // without timing assumptions or replacing any Clipboard API.
+    owner.newContext = async options => {
+      const observer = await createContext(options);
+      const grant = observer.grantPermissions.bind(observer);
+      observer.grantPermissions = async (...args) => {
+        await grant(...args);
+        await page.goto(server.url.href.replace("127.0.0.1", "localhost"));
+      };
+      return observer;
+    };
+    try {
+      await expect(browser.readClipboard()).rejects.toThrow("Page navigated during clipboard read");
+      expect(owner.contexts().length).toBe(count);
+      expect(await state(browser)).toBe("prompt");
+      await page.goto(server.url.href);
+      expect(await state(browser)).toBe("prompt");
+    } finally { owner.newContext = createContext; await browser.close(); }
+  }, 20000);
+});

package/src/browser-coverage-deadline.test.ts

@@ -11,6 +11,7 @@ test("an ambiguous coverage timeout is retained and a late CDP result cannot pub
   const cdp = {
     on() {},
     async send(method: string) {
+      if (method === "Runtime.getIsolateId") return { id: "renderer-1" };
       if (method === "Profiler.takePreciseCoverage") { takes++; return take; }
       if (method === "Debugger.getScriptSource") { sourceReads++; return {scriptSource:"example();"}; }
       return {};
@@ -44,6 +45,7 @@ test("cancelling during script retrieval discards late source and coverage total
   const cdp = {
     on() {},
     async send(method: string) {
+      if (method === "Runtime.getIsolateId") return { id: "renderer-1" };
       if (method === "Profiler.takePreciseCoverage") return {result:[{scriptId:"1",url:"http://app.test/late.js",functions:[{ranges:[{startOffset:0,endOffset:10,count:1}]}]}]};
       if (method === "Debugger.getScriptSource") { sourceStarted(); return source; }
       return {};

package/src/browser-coverage-identity.test.ts

@@ -9,18 +9,23 @@ import {
 function session() {
   const events = new EventEmitter();
   let source = "globalThis.ran = true;";
+  let isolateId = "renderer-1";
   let url = "http://app.test/app.js";
   const cdp = Object.assign(events, {
     async send(method: string): Promise<any> {
+      if (method === "Runtime.getIsolateId") return { id: isolateId };
       if (method === "Profiler.takePreciseCoverage") return { result: [{ scriptId: "4", url,
         functions: [{ ranges: [{ startOffset: 0, endOffset: source.length, count: 1 }] }] }] };
       if (method === "Debugger.getScriptSource") return { scriptSource: source };
       return {};
     },
   }) as unknown as CDPSession;
-  return { cdp, parsed(nextUrl = url, nextSource = source, sourceMapURL?: string) {
+  return { cdp, navigate(id = isolateId) {
+    isolateId = id;
+    events.emit("Runtime.executionContextsCleared");
+  }, parsed(nextUrl = url, nextSource = source, sourceMapURL?: string, hash?: string) {
     url = nextUrl; source = nextSource;
-    events.emit("Debugger.scriptParsed", { scriptId: "4", url, sourceMapURL });
+    events.emit("Debugger.scriptParsed", { scriptId: "4", url, sourceMapURL, hash, executionContextId: 1 });
   } };
 }
 
@@ -85,3 +90,110 @@ for (const phase of ["Profiler.takePreciseCoverage", "Debugger.getScriptSource"]
     } finally { configureBrowserCoverage(null); takeBrowserCoverageReport(service); }
   });
 }
+
+
+test("a new renderer can reuse an ID whose parse event arrives during the take", async () => {
+  const s = session();
+  const service = "identity-renderer";
+  configureBrowserCoverage({ serviceForHost: () => service });
+  try {
+    await attachBrowserCoverage(s.cdp);
+    s.parsed(undefined, undefined, inlineMap("src/old.ts"));
+    await harvestBrowserCoverage(s.cdp);
+    s.navigate("renderer-2");
+    const send = s.cdp.send.bind(s.cdp);
+    s.cdp.send = (async (method: string) => {
+      if (method === "Profiler.takePreciseCoverage") {
+        s.parsed("http://app.test/new.js", "globalThis.newApp = true;", inlineMap("src/new.ts"));
+      }
+      return send(method as any);
+    }) as CDPSession["send"];
+    await harvestBrowserCoverage(s.cdp);
+    const report = takeBrowserCoverageReport(service);
+    expect(report).toContain("SF:src/old.ts\nDA:1,1");
+    expect(report).toContain("SF:src/new.ts\nDA:1,1");
+  } finally { configureBrowserCoverage(null); takeBrowserCoverageReport(service); }
+});
+
+test("same-renderer document changes retain metadata for outgoing script counters", async () => {
+  const s = session();
+  const service = "identity-same-renderer";
+  configureBrowserCoverage({ serviceForHost: () => service });
+  try {
+    await attachBrowserCoverage(s.cdp);
+    s.parsed(undefined, undefined, inlineMap("src/original.ts"));
+    await harvestBrowserCoverage(s.cdp);
+    takeBrowserCoverageReport(service);
+    s.navigate();
+    await harvestBrowserCoverage(s.cdp);
+    expect(takeBrowserCoverageReport(service)).toContain("SF:src/original.ts\nDA:1,1");
+  } finally { configureBrowserCoverage(null); takeBrowserCoverageReport(service); }
+});
+
+for (const phase of ["Profiler.takePreciseCoverage", "Debugger.getScriptSource"]) {
+  test(`a renderer swap during ${phase} retains an incomplete error even with matching script metadata`, async () => {
+    const s = session();
+    const service = `identity-renderer-race-${phase}`;
+    configureBrowserCoverage({ serviceForHost: () => service });
+    try {
+      await attachBrowserCoverage(s.cdp);
+      s.parsed(undefined, undefined, undefined, "same-source-hash");
+      const send = s.cdp.send.bind(s.cdp);
+      s.cdp.send = (async (method: string) => {
+        const result = await send(method as any);
+        if (method === phase) {
+          s.navigate("renderer-2");
+          s.parsed(undefined, undefined, undefined, "same-source-hash");
+        }
+        return result;
+      }) as CDPSession["send"];
+      await expect(harvestBrowserCoverage(s.cdp)).rejects.toThrow("coverage is incomplete");
+      expect(takeBrowserCoverageReport(service)).toBe("TN:\n");
+      await expect(harvestBrowserCoverage(s.cdp)).rejects.toThrow("coverage is incomplete");
+    } finally { configureBrowserCoverage(null); takeBrowserCoverageReport(service); }
+  });
+
+  test(`duplicate parse notifications during ${phase} preserve the same script identity`, async () => {
+    const s = session();
+    const service = `identity-duplicate-${phase}`;
+    configureBrowserCoverage({ serviceForHost: () => service });
+    try {
+      await attachBrowserCoverage(s.cdp);
+      s.parsed(undefined, undefined, inlineMap("src/original.ts"), "same-source-hash");
+      const send = s.cdp.send.bind(s.cdp);
+      s.cdp.send = (async (method: string) => {
+        const result = await send(method as any);
+        if (method === phase) s.parsed(undefined, undefined, inlineMap("src/original.ts"), "same-source-hash");
+        return result;
+      }) as CDPSession["send"];
+      await harvestBrowserCoverage(s.cdp);
+      expect(takeBrowserCoverageReport(service)).toContain("SF:src/original.ts\nDA:1,1");
+    } finally { configureBrowserCoverage(null); takeBrowserCoverageReport(service); }
+  });
+}
+
+for (const failure of ["take", "after take", "source"]) {
+  test(`a protocol error ${failure} retains an incomplete-capture error`, async () => {
+    const s = session();
+    const service = `identity-protocol-error-${failure}`;
+    configureBrowserCoverage({ serviceForHost: () => service });
+    try {
+      await attachBrowserCoverage(s.cdp);
+      s.parsed();
+      const send = s.cdp.send.bind(s.cdp);
+      let taken = false;
+      s.cdp.send = (async (method: string) => {
+        if (method === "Profiler.takePreciseCoverage") {
+          taken = true;
+          if (failure === "take") throw new Error("CDP disconnected");
+        }
+        if ((failure === "after take" && taken && method === "Runtime.getIsolateId") ||
+            (failure === "source" && method === "Debugger.getScriptSource")) throw new Error("CDP disconnected");
+        return send(method as any);
+      }) as CDPSession["send"];
+      await expect(harvestBrowserCoverage(s.cdp)).rejects.toThrow("coverage is incomplete");
+      expect(takeBrowserCoverageReport(service)).toBe("TN:\n");
+      await expect(harvestBrowserCoverage(s.cdp)).rejects.toThrow("coverage is incomplete");
+    } finally { configureBrowserCoverage(null); takeBrowserCoverageReport(service); }
+  });
+}

package/src/browser-coverage-navigation.test.ts

@@ -6,8 +6,7 @@ import {
   takeBrowserCoverageReport,
 } from "./browser-coverage.js";
 
-const executablePath = Bun.which("chromium") ?? Bun.which("chromium-browser") ??
-  Bun.which("google-chrome") ?? chromium.executablePath();
+const executablePath = Bun.which("chromium") ?? Bun.which("chromium-browser") ?? Bun.which("google-chrome") ?? Bun.which("chrome") ?? chromium.executablePath();
 
 test.skipIf(!existsSync(executablePath))("cross-site script ID reuse cannot attribute anonymous code to an earlier empty script", async () => {
   const emptyScript = "/ingest/static/1.438.19/exception-autocapture.js";

package/src/browser-coverage-sdk.test.ts

@@ -0,0 +1,91 @@
+import { expect, test } from "bun:test";
+import { openBrowser } from "./browser.js";
+import { configureBrowserCoverage, takeBrowserCoverageReport } from "./browser-coverage.js";
+
+const available = !!(Bun.which("chromium") ?? Bun.which("chromium-browser") ?? Bun.which("google-chrome") ?? Bun.which("chrome"));
+
+test.skipIf(!available)("SDK navigation collects outgoing counters across about:blank, server restart, and cross-site return", async () => {
+  let version: "before" | "after" = "before";
+  function gate() {
+    let release!: () => void;
+    let ran!: () => void;
+    const released = new Promise<void>(resolve => { release = resolve; });
+    const outgoingRan = new Promise<void>(resolve => { ran = resolve; });
+    return { release, ran, released, outgoingRan };
+  }
+  const gates = { before: gate(), after: gate() };
+  const serve = (port: number) => Bun.serve({ hostname: "0.0.0.0", port, async fetch(request) {
+    const url = new URL(request.url);
+    if (url.pathname === "/release") { await gates[url.searchParams.get("version") as typeof version].released; return new Response("released"); }
+    if (url.pathname === "/ran") { gates[url.searchParams.get("version") as typeof version].ran(); return new Response("ran"); }
+    if (url.pathname === "/app.js.map") return Response.json({ version: 3, sources: [`src/${version}.ts`], names: [], mappings: "AAAA;AACA;AACA;AACA;AACA" });
+    if (url.pathname === "/app.js") {
+      return new Response(`globalThis.ranOnLoad = true;\nfetch("/release?version=${version}").then(() => {\n  globalThis.ranBeforeLeaving = true;\n  fetch("/ran?version=${version}");\n});\n//# sourceMappingURL=/app.js.map`,
+        { headers: { "content-type": "application/javascript", "cache-control": "no-store" } });
+    }
+    return new Response('<script src="/app.js"></script><title>Coverage navigation</title>',
+      { headers: { "content-type": "text/html", "cache-control": "no-store" } });
+  } });
+  let server = serve(0);
+  const port = server.port!;
+  const origin = `http://127.0.0.1:${port}`;
+  const service = "sdk-coverage-navigation";
+  configureBrowserCoverage({ serviceForHost: host => host === "127.0.0.1" ? service : undefined });
+  const browser = await openBrowser({ recorder: { sessionId: "coverage-navigation", recordStep() {} } });
+  try {
+    await browser.goto(origin);
+    const initial = takeBrowserCoverageReport(service);
+    expect(initial).toContain("SF:src/before.ts");
+    expect(initial).toContain("DA:3,0");
+    // App code executes while the SDK is idle. Only the pre-navigation harvest
+    // can preserve it when goto discards this document/renderer.
+    gates.before.release();
+    await gates.before.outgoingRan;
+    await browser.goto("about:blank");
+    const outgoing = takeBrowserCoverageReport(service);
+    expect(outgoing).toContain("SF:src/before.ts");
+    expect(outgoing).toContain("DA:3,1");
+    server.stop(true);
+    version = "after";
+    server = serve(port);
+    await browser.goto(origin);
+    expect(takeBrowserCoverageReport(service)).toContain("DA:3,0");
+    gates.after.release();
+    await gates.after.outgoingRan;
+    // A distinct site forces a renderer transition even in Shell versions
+    // where about:blank retains the original renderer.
+    await browser.goto(`http://127.0.0.2:${port}`);
+    const beforeSwap = takeBrowserCoverageReport(service);
+    expect(beforeSwap).toContain("SF:src/after.ts");
+    expect(beforeSwap).toContain("DA:3,1");
+    await browser.goto(origin);
+    const returned = takeBrowserCoverageReport(service);
+    expect(returned).toContain("SF:src/after.ts");
+    expect(returned).not.toContain("src/before.ts");
+    expect(returned).toContain("DA:1,1");
+  } finally {
+    await browser.close();
+    configureBrowserCoverage(null);
+    takeBrowserCoverageReport(service);
+    server.stop(true);
+  }
+}, 15000);
+
+test.skipIf(!available)("closing an SDK browser releases complete coverage before the next service capture", async () => {
+  // Isolate this global service-capture check from unit tests that deliberately
+  // retain failed collectors for the remainder of their harness lifetime.
+  const browserModule = new URL("./browser.ts", import.meta.url).href;
+  const coverageModule = new URL("./browser-coverage.ts", import.meta.url).href;
+  const child = Bun.spawn([process.execPath, "-e", `
+    import { openBrowser } from ${JSON.stringify(browserModule)};
+    import { configureBrowserCoverage, harvestAllBrowserCoverage } from ${JSON.stringify(coverageModule)};
+    configureBrowserCoverage({ serviceForHost: () => 'close-test' });
+    const browser = await openBrowser();
+    await browser.goto('about:blank');
+    await browser.close();
+    await harvestAllBrowserCoverage();
+    process.exit(0);
+  `], { stdout: "pipe", stderr: "pipe" });
+  const [code, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+  expect({ code, stderr }).toEqual({ code: 0, stderr: "" });
+}, 15000);

package/src/browser-coverage.ts

@@ -55,26 +55,40 @@ const TOTALS = new Map<string, FileCounts>();
 
 interface ScriptInfo {
   url: string;
+  hash?: string;
+  executionContextId?: number;
   sourceMapURL?: string;
   source?: string;
   /** `undefined` = not looked up yet; `null` = none / unusable. */
   map?: DecodedSourceMap | null;
 }
 
+interface Renderer {
+  isolateId: string;
+  scripts: Map<string, ScriptInfo>;
+}
+
+interface DocumentScripts {
+  scripts: Map<string, ScriptInfo>;
+  renderer?: Renderer;
+}
+
 interface Collector {
   cdp: CDPSession;
-  scripts: Map<string, ScriptInfo>;
+  document: DocumentScripts;
+  renderer?: Renderer;
   inFlight: Promise<void> | null;
   incomplete?: Error;
   abort?: AbortController;
 }
 
 const COLLECTORS = new WeakMap<CDPSession, Collector>();
-/** The collectors of every session attached so far, for the harvest at
- *  capture; a closed session's take fails and is dropped there. */
+/** Collectors awaiting service capture. Explicit close releases a completed
+ * collector; unexpected disconnects remain coverage failures. */
 const LIVE_COLLECTORS = new Set<Collector>();
 
-/** Decoded maps by URL (or content hash for inline `data:` maps). */
+/** Inline maps are immutable and cached by content hash. External maps are
+ * cached only on ScriptInfo: a restarted server may reuse their URLs. */
 const SOURCE_MAPS = new Map<string, DecodedSourceMap | null>();
 
 const SOURCE_MAP_FETCH_TIMEOUT_MS = 10_000;
@@ -83,18 +97,26 @@ const SOURCE_MAP_FETCH_TIMEOUT_MS = 10_000;
  *  service opted in. */
 export async function attachBrowserCoverage(cdp: CDPSession): Promise<void> {
   if (!CONFIG || COLLECTORS.has(cdp)) return;
-  const collector: Collector = { cdp, scripts: new Map(), inFlight: null };
+  const collector: Collector = { cdp, document: { scripts: new Map() }, inFlight: null };
   COLLECTORS.set(cdp, collector);
   LIVE_COLLECTORS.add(collector);
-  cdp.on("Debugger.scriptParsed", (ev: { scriptId: string; url: string; sourceMapURL?: string }) => {
-    // IDs belong to a renderer, not the lifetime of this CDP session. A
-    // cross-site navigation can reuse an old named ID for anonymous code.
-    // Replace anonymous entries too, invalidating the previous URL/source/map.
-    collector.scripts.set(ev.scriptId, {
+  cdp.on("Runtime.executionContextsCleared", () => {
+    // A document change may or may not replace the renderer. Buffer its
+    // metadata separately until getIsolateId identifies the new namespace.
+    collector.document = { scripts: new Map() };
+  });
+  cdp.on("Debugger.scriptParsed", (ev: { scriptId: string; url: string; sourceMapURL?: string; hash?: string; executionContextId?: number }) => {
+    const info: ScriptInfo = {
       url: ev.url,
+      hash: ev.hash,
+      executionContextId: ev.executionContextId,
       sourceMapURL: ev.sourceMapURL || undefined,
-    });
+    };
+    const document = collector.document;
+    setScript(document.scripts, ev.scriptId, info);
+    if (document.renderer) setScript(document.renderer.scripts, ev.scriptId, info);
   });
+  await cdp.send("Runtime.enable");
   await cdp.send("Debugger.enable");
   await cdp.send("Profiler.enable");
   await cdp.send("Profiler.startPreciseCoverage", { callCount: true, detailed: true });
@@ -123,9 +145,10 @@ export async function harvestBrowserCoverage(cdp: CDPSession, signal?: AbortSign
         reject(c.incomplete);
       }, { once: true });
     });
-    c.inFlight = Promise.race([harvestInner(c, config, abort.signal), interrupted]).catch(() => {
-      if (c.incomplete) throw c.incomplete;
-      // Preserve the existing handling of closed/navigating pages.
+    c.inFlight = Promise.race([harvestInner(c, config, abort.signal), interrupted]).catch((cause) => {
+      // A failed protocol command can leave reset or unavailable counters.
+      // Expected page closure explicitly releases its collector beforehand.
+      throw c.incomplete ??= new Error("Browser coverage collection failed; coverage is incomplete", { cause });
     }).finally(() => {
       c.inFlight = null;
       c.abort = undefined;
@@ -142,16 +165,55 @@ export async function harvestBrowserCoverage(cdp: CDPSession, signal?: AbortSign
   finally { signal?.removeEventListener("abort", interrupt); }
 }
 
+/** Replayed Debugger events for the same script do not invalidate a source
+ * read. A matching URL alone is insufficient: recompilations may reuse it. */
+function setScript(scripts: Map<string, ScriptInfo>, id: string, info: ScriptInfo): void {
+  const before = scripts.get(id);
+  if (before && info.hash && before.hash === info.hash &&
+      before.executionContextId === info.executionContextId &&
+      before.url === info.url && before.sourceMapURL === info.sourceMapURL) return;
+  scripts.set(id, info);
+}
+
+function identityChanged(c: Collector): Error {
+  return c.incomplete ??= new Error("Browser script identity changed during coverage capture; coverage is incomplete");
+}
+
+/** Resolve the current document's script IDs against V8's renderer identity.
+ * Numeric context IDs and script IDs are both reused across renderer swaps. */
+async function currentRenderer(c: Collector, signal: AbortSignal): Promise<Renderer> {
+  for (;;) {
+    const document = c.document;
+    const { id } = await c.cdp.send("Runtime.getIsolateId");
+    signal.throwIfAborted();
+    // Navigation overlapped this non-destructive query. Retry before taking
+    // counters; no coverage has been reset yet.
+    if (document !== c.document) continue;
+    if (!id) throw identityChanged(c);
+    if (c.renderer?.isolateId !== id) c.renderer = { isolateId: id, scripts: new Map() };
+    const renderer = c.renderer;
+    if (!document.renderer) {
+      for (const [scriptId, info] of document.scripts) setScript(renderer.scripts, scriptId, info);
+      document.renderer = renderer;
+    }
+    return renderer;
+  }
+}
+
 async function harvestInner(c: Collector, config: BrowserCoverageConfig, signal: AbortSignal): Promise<void> {
-  const scriptsAtTake = new Map(c.scripts);
+  const renderer = await currentRenderer(c, signal);
+  const scriptsAtTake = new Map(renderer.scripts);
   let result: { scriptId: string; url: string; functions: V8FunctionCoverage[] }[];
   try {
     ({ result } = (await c.cdp.send("Profiler.takePreciseCoverage")) as { result: typeof result });
     signal.throwIfAborted();
-  } catch (err) {
-    if (!signal.aborted) LIVE_COLLECTORS.delete(c); // the session is gone
-    throw err;
+  } catch (cause) {
+    signal.throwIfAborted();
+    throw c.incomplete ??= new Error("Browser coverage take failed; coverage is incomplete", { cause });
   }
+  // A take is destructive. Once sent, crossing a renderer boundary is
+  // ambiguous and must remain incomplete rather than retrying the take.
+  if (await currentRenderer(c, signal) !== renderer) throw identityChanged(c);
   for (const script of result) {
     // The profiler's URL identifies this execution. Never supply a URL from
     // an earlier renderer to an anonymous result.
@@ -165,16 +227,13 @@ async function harvestInner(c: Collector, config: BrowserCoverageConfig, signal:
     if (url.protocol !== "http:" && url.protocol !== "https:") continue;
     const service = config.serviceForHost(url.hostname);
     if (!service) continue;
-    let info = c.scripts.get(script.scriptId);
+    let info = renderer.scripts.get(script.scriptId);
     const before = scriptsAtTake.get(script.scriptId);
-    const changed = () => {
-      c.incomplete = new Error("Browser script identity changed during coverage capture; coverage is incomplete");
-      return c.incomplete;
-    };
+    const changed = () => identityChanged(c);
     if ((before && before !== info) || (info && info.url !== script.url)) throw changed();
     if (!info) {
       info = { url: script.url };
-      c.scripts.set(script.scriptId, info);
+      renderer.scripts.set(script.scriptId, info);
     }
     if (info.source === undefined) {
       try {
@@ -182,12 +241,14 @@ async function harvestInner(c: Collector, config: BrowserCoverageConfig, signal:
           scriptId: script.scriptId,
         })) as { scriptSource: string };
         signal.throwIfAborted();
-        if (c.scripts.get(script.scriptId) !== info) throw changed();
+        if (await currentRenderer(c, signal) !== renderer || renderer.scripts.get(script.scriptId) !== info) throw changed();
         info.source = r.scriptSource;
-      } catch {
+      } catch (cause) {
         signal.throwIfAborted();
         if (c.incomplete) throw c.incomplete;
-        continue; // script gone with its document
+        // An executed covered script whose source was lost cannot yield a
+        // trustworthy report. Keep the failure for service capture.
+        throw c.incomplete = new Error("Browser script source unavailable; coverage is incomplete", { cause });
       }
     }
     const generated = rangesToLineCounts(info.source, script.functions);
@@ -234,8 +295,6 @@ async function sourceMapFor(info: ScriptInfo, scriptUrl: URL): Promise<DecodedSo
   } catch {
     return null;
   }
-  const cached = SOURCE_MAPS.get(mapUrl);
-  if (cached !== undefined) return cached;
   let map: DecodedSourceMap | null = null;
   try {
     const res = await rawFetch(mapUrl, { signal: AbortSignal.timeout(SOURCE_MAP_FETCH_TIMEOUT_MS) });
@@ -243,7 +302,6 @@ async function sourceMapFor(info: ScriptInfo, scriptUrl: URL): Promise<DecodedSo
   } catch {
     map = null;
   }
-  SOURCE_MAPS.set(mapUrl, map);
   return map;
 }
 
@@ -262,6 +320,13 @@ function parseDataUrl(ref: string): unknown {
   }
 }
 
+/** Called only after harvesting a page that the SDK is about to destroy.
+ * Keep failed collectors visible so closing a page cannot erase a gap. */
+export function releaseBrowserCoverage(cdp: CDPSession): void {
+  const collector = COLLECTORS.get(cdp);
+  if (collector && !collector.incomplete && !collector.inFlight) LIVE_COLLECTORS.delete(collector);
+}
+
 /** Harvest every live session, so a capture sees the counters of code
  *  that ran since the last browser op. */
 export async function harvestAllBrowserCoverage(signal?: AbortSignal): Promise<void> {