@specific.dev/spectest 0.132.0 → 0.132.2

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> {

package/src/browser-executable.test.ts

@@ -3,10 +3,12 @@ import { mkdtemp, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-test("SDK refuses a Chromium-only runtime instead of silently falling back", async () => {
-  const dir = await mkdtemp(join(tmpdir(), "spectest-no-shell-"));
+test("SDK refuses a Shell-only runtime instead of silently changing browser behavior", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "spectest-no-chromium-"));
   try {
-    await writeFile(join(dir, "chromium"), "#!/bin/sh\necho UNEXPECTED_CHROMIUM_LAUNCH >&2\nexit 1\n", { mode: 0o755 });
+    for (const name of ["chromium-headless-shell", "chrome-headless-shell"]) {
+      await writeFile(join(dir, name), "#!/bin/sh\necho UNEXPECTED_SHELL_LAUNCH >&2\nexit 1\n", { mode: 0o755 });
+    }
     const browserModule = new URL("./browser.ts", import.meta.url).href;
     const child = Bun.spawn([process.execPath, "-e", `
       import { openBrowser } from ${JSON.stringify(browserModule)};
@@ -15,7 +17,7 @@ test("SDK refuses a Chromium-only runtime instead of silently falling back", asy
     `], { env: { ...process.env, PATH: dir }, stdout: "pipe", stderr: "pipe" });
     const stderr = await new Response(child.stderr).text();
     expect(await child.exited).toBe(1);
-    expect(stderr).toContain("Headless Shell is required");
-    expect(stderr).not.toContain("UNEXPECTED_CHROMIUM_LAUNCH");
+    expect(stderr).toContain("Chromium is required");
+    expect(stderr).not.toContain("UNEXPECTED_SHELL_LAUNCH");
   } finally { await rm(dir, { recursive: true, force: true }); }
 });

package/src/browser-finalization.test.ts

@@ -2,7 +2,7 @@ import { expect, test } from "bun:test";
 import { acquirePersistentBrowser } from "./browser.js";
 import { finalizeBrowserRecordings } from "./harness/deadline.js";
 
-const available = !!(Bun.which("chromium-headless-shell") ?? Bun.which("chrome-headless-shell"));
+const available = !!(Bun.which("chromium") ?? Bun.which("chromium-browser") ?? Bun.which("google-chrome") ?? Bun.which("chrome"));
 
 test.skipIf(!available)("stuck replay drains are bounded warnings and late replies cannot change the recording or clear a later buffer", async () => {
   const chunks: unknown[] = [];

package/src/browser-image-loading.test.ts

@@ -2,7 +2,7 @@ import { expect, test } from "bun:test";
 import { readRaw } from "./inspect.js";
 import { openBrowser } from "./browser.js";
 
-const available = !!(Bun.which("chromium-headless-shell") ?? Bun.which("chrome-headless-shell"));
+const available = !!(Bun.which("chromium") ?? Bun.which("chromium-browser") ?? Bun.which("google-chrome") ?? Bun.which("chrome"));
 const png = Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jRZkAAAAASUVORK5CYII=", "base64");
 
 for (const late of [false, true]) {

package/src/browser-navigation.test.ts

@@ -2,7 +2,7 @@ import { expect, test } from "bun:test";
 import { openBrowser } from "./browser.js";
 import { startRecording, stopRecording } from "./recorder.js";
 
-const available = !!(Bun.which("chromium-headless-shell") ?? Bun.which("chrome-headless-shell"));
+const available = !!(Bun.which("chromium") ?? Bun.which("chromium-browser") ?? Bun.which("google-chrome") ?? Bun.which("chrome"));
 
 test.skipIf(!available)("public navigation options control goto/reload and remain visible in recordings", async () => {
   // The document commits immediately but load waits for an image. This