@specific.dev/spectest 0.101.0 → 0.103.0

package/dist/harness/ingress-server.d.ts

@@ -0,0 +1,30 @@
+import { type WsBridgeData } from "./ws-bridge.js";
+import type { FakeWebSocketHandlers } from "../fake-websocket.js";
+export interface IngressServer {
+    port: number;
+    stop(force?: boolean): void;
+    requestIP(req: Request): {
+        address: string;
+        port: number;
+    } | undefined;
+    upgrade(req: Request, options: ({
+        data: WsBridgeData;
+    } | {
+        handlers: FakeWebSocketHandlers;
+    }) & {
+        headers?: Record<string, string>;
+    }): boolean;
+}
+/**
+ * Serve the ingress's Fetch handlers through node:http. Bun.serve discards
+ * Content-Length on a still-streaming Response, even when its bytes are
+ * unchanged. ServerResponse preserves the declared length while pipeline
+ * propagates backpressure and cancellation without buffering the whole body.
+ * This is also the HTTP/1 listener behind the TLS terminator.
+ */
+export declare function startIngressServer(options: {
+    port: number;
+    hostname?: string;
+    reusePort?: boolean;
+    fetch(req: Request, server: IngressServer): Response | undefined | Promise<Response | undefined>;
+}): Promise<IngressServer>;

package/dist/harness/ingress-server.js

@@ -0,0 +1,179 @@
+import http from "node:http";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { WS_BRIDGE_HANDLERS } from "./ws-bridge.js";
+import { attachFakeWebSocket } from "./fake-websocket-connection.js";
+// Load the installed implementation, not Bun's built-in `ws` replacement.
+// On Bun 1.4.0 that replacement cannot upgrade node:http sockets after the
+// asynchronous upstream handshake. The package uses the ordinary socket API.
+const require = createRequire(import.meta.url);
+const { WebSocketServer } = require(join(dirname(require.resolve("ws/package.json")), "index.js"));
+/**
+ * Serve the ingress's Fetch handlers through node:http. Bun.serve discards
+ * Content-Length on a still-streaming Response, even when its bytes are
+ * unchanged. ServerResponse preserves the declared length while pipeline
+ * propagates backpressure and cancellation without buffering the whole body.
+ * This is also the HTTP/1 listener behind the TLS terminator.
+ */
+export async function startIngressServer(options) {
+    const peers = new WeakMap();
+    const upgrades = new WeakMap();
+    const protocols = new WeakMap();
+    const sockets = new Set();
+    const websockets = new WebSocketServer({
+        noServer: true,
+        // The upstream handshake has already selected a protocol. Never select
+        // the client's first offer on its behalf.
+        handleProtocols: (_offered, req) => protocols.get(req) || false,
+    });
+    const fakeWebsockets = new WebSocketServer({
+        noServer: true, maxPayload: 16 * 1024 * 1024,
+        handleProtocols: (_offered, req) => protocols.get(req) || false,
+    });
+    const server = http.createServer({ requestTimeout: 0 }, (req, res) => {
+        void dispatch(req, res);
+    });
+    server.on("connection", socket => {
+        sockets.add(socket);
+        socket.once("close", () => sockets.delete(socket));
+    });
+    server.on("upgrade", (req, socket, head) => {
+        void dispatch(req, undefined, { req, socket: socket, head, upgraded: false });
+    });
+    const facade = {
+        port: 0,
+        stop(force = false) {
+            if (force) {
+                for (const ws of websockets.clients)
+                    ws.terminate();
+                for (const ws of fakeWebsockets.clients)
+                    ws.terminate();
+                for (const socket of sockets)
+                    socket.destroy();
+                server.closeAllConnections();
+            }
+            websockets.close();
+            fakeWebsockets.close();
+            server.close();
+        },
+        requestIP(req) {
+            const socket = peers.get(req);
+            return socket?.remoteAddress && socket.remotePort
+                ? { address: socket.remoteAddress, port: socket.remotePort } : undefined;
+        },
+        upgrade(req, opts) {
+            const pending = upgrades.get(req);
+            if (!pending || pending.upgraded || pending.socket.destroyed)
+                return false;
+            protocols.set(pending.req, opts.headers?.["sec-websocket-protocol"]);
+            const target = "handlers" in opts ? fakeWebsockets : websockets;
+            target.handleUpgrade(pending.req, pending.socket, pending.head, ws => {
+                pending.upgraded = true;
+                if ("handlers" in opts) {
+                    attachFakeWebSocket(ws, opts.handlers);
+                    return;
+                }
+                const client = {
+                    data: opts.data,
+                    send: (data) => ws.send(data),
+                    close: (code, reason) => ws.close(code, reason),
+                };
+                ws.on("message", (data, binary) => WS_BRIDGE_HANDLERS.message(client, binary ? Buffer.from(data) : data.toString()));
+                ws.on("close", (code, reason) => WS_BRIDGE_HANDLERS.close(client, code, reason.toString()));
+                ws.on("error", () => opts.data.upstream.close());
+                WS_BRIDGE_HANDLERS.open(client);
+            });
+            return pending.upgraded;
+        },
+    };
+    async function dispatch(incoming, outgoing, upgrade) {
+        const abort = new AbortController();
+        const onClose = () => {
+            if (!outgoing?.writableFinished && !upgrade?.upgraded)
+                abort.abort();
+        };
+        const connection = outgoing ?? upgrade.socket;
+        connection.once("close", onClose);
+        const responseWriter = () => {
+            if (!outgoing) {
+                // Only attach an HTTP response after a refused upgrade. Attaching
+                // one before handleUpgrade conflicts with Bun's native handshake.
+                outgoing = new http.ServerResponse(incoming);
+                outgoing.assignSocket(upgrade.socket);
+                outgoing.once("finish", () => upgrade.socket.end());
+            }
+            return outgoing;
+        };
+        let response;
+        try {
+            const headers = new Headers();
+            for (let i = 0; i < incoming.rawHeaders.length; i += 2) {
+                headers.append(incoming.rawHeaders[i], incoming.rawHeaders[i + 1]);
+            }
+            const method = incoming.method ?? "GET";
+            const req = new Request(new URL(incoming.url ?? "/", `http://${headers.get("host") ?? "localhost"}`), {
+                method, headers, signal: abort.signal,
+                body: method === "GET" || method === "HEAD" ? undefined : Readable.toWeb(incoming),
+                duplex: "half",
+            });
+            peers.set(req, incoming.socket);
+            if (upgrade)
+                upgrades.set(req, upgrade);
+            response = await options.fetch(req, facade);
+            if (upgrade?.upgraded)
+                return;
+            if (!response)
+                throw new Error("Ingress handler returned no response");
+            if (abort.signal.aborted) {
+                await response.body?.cancel();
+                return;
+            }
+            const writer = responseWriter();
+            writer.statusCode = response.status;
+            writer.statusMessage = response.statusText;
+            response.headers.forEach((value, key) => {
+                if (key !== "set-cookie")
+                    writer.setHeader(key, value);
+            });
+            const cookies = response.headers.getSetCookie();
+            if (cookies.length)
+                writer.setHeader("set-cookie", cookies);
+            // Flush even for a body already buffered by fetch. An upstream with
+            // no length must not acquire an invented Content-Length from end().
+            writer.flushHeaders();
+            if (method === "HEAD" || response.status === 204 || response.status === 304 || !response.body) {
+                await response.body?.cancel();
+                writer.end();
+            }
+            else {
+                await pipeline(Readable.fromWeb(response.body), writer);
+            }
+        }
+        catch (error) {
+            if (upgrade?.upgraded)
+                return;
+            outgoing = responseWriter();
+            if (!outgoing.headersSent && !outgoing.destroyed) {
+                outgoing.writeHead(500, { "content-type": "text/plain" });
+                outgoing.end("spectest-daemon: ingress response failed\n");
+            }
+            else {
+                outgoing.destroy(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+        finally {
+            connection.off("close", onClose);
+        }
+    }
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen({ port: options.port, host: options.hostname ?? "0.0.0.0", reusePort: options.reusePort }, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    facade.port = server.address().port;
+    return facade;
+}

package/dist/harness/microphone-fixture.d.ts

@@ -0,0 +1,13 @@
+export interface MicrophoneFixture {
+    /** WAV file relative to the repository root (absolute paths also work).
+     * Use 16-bit PCM mono or stereo audio. */
+    path: string;
+    /** Repeat the recording. Default false: play once, then supply silence. */
+    loop?: boolean;
+}
+/** Stage immutable bytes under a safe filename: Chromium interprets a `%`
+ * suffix as playback options, so a project filename cannot be passed verbatim. */
+export declare function prepareMicrophoneFixture(fixture: MicrophoneFixture): Promise<{
+    arg: string;
+    cleanup(): Promise<void>;
+}>;

package/dist/harness/microphone-fixture.js

@@ -0,0 +1,67 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { resolveExistingProjectPath } from "../project-files.js";
+/** Stage immutable bytes under a safe filename: Chromium interprets a `%`
+ * suffix as playback options, so a project filename cannot be passed verbatim. */
+export async function prepareMicrophoneFixture(fixture) {
+    if (!fixture || typeof fixture.path !== "string" || !fixture.path.trim()) {
+        throw new Error("microphone.path must name a WAV fixture");
+    }
+    if (fixture.loop !== undefined && typeof fixture.loop !== "boolean")
+        throw new Error("microphone.loop must be a boolean");
+    const source = resolveExistingProjectPath(fixture.path, "microphone fixture");
+    const bytes = await readFile(source);
+    let pcm = false;
+    let audio = false;
+    let dataAt = 0;
+    let dataSize = 0;
+    let bytesPerFrame = 0;
+    let sampleRate = 0;
+    if (bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WAVE") {
+        for (let at = 12; at + 8 <= bytes.length;) {
+            const size = bytes.readUInt32LE(at + 4);
+            const end = at + 8 + size;
+            if (end > bytes.length)
+                break;
+            const chunk = bytes.toString("ascii", at, at + 4);
+            if (chunk === "fmt " && size >= 16) {
+                sampleRate = bytes.readUInt32LE(at + 12);
+                bytesPerFrame = bytes.readUInt16LE(at + 10) * 2;
+                pcm = bytes.readUInt16LE(at + 8) === 1 && [1, 2].includes(bytes.readUInt16LE(at + 10)) &&
+                    sampleRate >= 8000 && sampleRate <= 192000 && bytes.readUInt16LE(at + 22) === 16 &&
+                    bytes.readUInt16LE(at + 20) === bytesPerFrame;
+            }
+            if (chunk === "data" && size > 0) {
+                audio = true;
+                dataAt = at;
+                dataSize = size;
+            }
+            at = end + (size % 2);
+        }
+    }
+    if (!pcm || !audio || dataSize % bytesPerFrame !== 0)
+        throw new Error(`microphone fixture "${fixture.path}" must be a non-empty 16-bit PCM mono or stereo WAV (8–192 kHz)`);
+    // Chromium's FileSource returns zero at EOF without clearing the previous
+    // capture buffer. Finish with silence so single playback cannot repeat the
+    // final speech fragment indefinitely. Leave looping recordings untouched.
+    let staged = bytes;
+    if (!fixture.loop) {
+        const silence = Buffer.alloc(Math.ceil(sampleRate / 4) * bytesPerFrame);
+        const end = dataAt + 8 + dataSize;
+        staged = Buffer.concat([bytes.subarray(0, end), silence, bytes.subarray(end)]);
+        staged.writeUInt32LE(staged.length - 8, 4);
+        staged.writeUInt32LE(dataSize + silence.length, dataAt + 4);
+    }
+    const dir = await mkdtemp(join(tmpdir(), "spectest-microphone-"));
+    const cleanup = () => rm(dir, { recursive: true, force: true });
+    try {
+        const file = join(dir, "audio.wav");
+        await writeFile(file, staged);
+        return { arg: `--use-file-for-fake-audio-capture=${file}${fixture.loop ? "" : "%noloop"}`, cleanup };
+    }
+    catch (err) {
+        await cleanup();
+        throw err;
+    }
+}

package/dist/harness/tls-terminator.js

@@ -33,15 +33,11 @@
  * ## The shape, and why it is a byte pipe
  *
  * The terminator does TLS and *nothing else*: it accepts on :443, picks a
- * leaf by SNI, and pipes the decrypted stream to a plaintext `Bun.serve`
- * bound on loopback. Opted-in HTTP/2 routes select a separate stream router
- * by ALPN; HTTP/1.1 and WebSockets retain the existing listener. Everything downstream — routing, fakes,
- * interceptors, reverse-proxying, and `server.upgrade()` WebSocket
- * bridging — is the same `Bun.serve` code that already serves :80, run
- * unchanged. Terminating HTTP here instead (`node:https`, `(req, res)`)
- * would have meant reimplementing the WebSocket bridge against a
- * different API, which is exactly the kind of trade this change exists to
- * avoid: one flake removed, another introduced somewhere subtler.
+ * leaf by SNI, and pipes the decrypted stream to the plaintext ingress
+ * server bound on loopback. Opted-in HTTP/2 routes select a separate stream
+ * router by ALPN; HTTP/1.1 and WebSockets use the shared ingress listener.
+ * Routing, fakes, interceptors and reverse-proxying stay in that listener;
+ * this layer never parses or rewrites HTTP response framing.
  *
  * Measured cost of the extra hop on this host (Bun 1.4.0, undici client,
  * 50 MB bodies): ~11 % fewer small requests per second, download

package/dist/index.d.ts

@@ -11,6 +11,9 @@ export { SQL, type SqlClient, type SqlOptions } from "./sql.js";
 export { RedisClient, type RedisClientLike, type RedisOptions } from "./redis.js";
 export { S3Client, type S3ClientLike, type S3File, type S3ClientOptions } from "./s3.js";
 export type { Browser, BrowserOptions, Keyboard, Mouse, Touchscreen } from "./browser.js";
+export type { MicrophoneFixture } from "./harness/microphone-fixture.js";
+export type { FakeWebSocket, FakeWebSocketHandlers } from "./fake-websocket.js";
+import type { FakeWebSocketHandlers } from "./fake-websocket.js";
 import type { Browser, BrowserOptions } from "./browser.js";
 export { McpHttpError, McpRpcError, McpAuthDeniedError, type Mcp, type McpOptions, type McpAuthorization, type McpChallenge, type McpIdentity, type McpToolResult, type McpToolInfo, type McpResourceInfo, type McpResourceContents, type McpPromptInfo, type McpPromptResult, type McpContent, type McpNotification, type McpSamplingRequest, type McpSamplingResult, type AuthorizeOptions, type AuthorizationServerInfo, } from "./mcp.js";
 import type { Mcp, McpOptions } from "./mcp.js";
@@ -1483,6 +1486,10 @@ export interface FakeDefinition<S = any, H extends Record<string, unknown> = Rec
      * also applies to state/helper factories and helper implementations.
      */
     handler: (req: Request, state: S, ctx: FakeContext) => Response | Promise<Response>;
+    /** Optional WebSocket handshake on the same hostnames as HTTP. Return a
+     * Response to reject, or connection callbacks to accept. Callbacks share
+     * this fake's state and run uninstrumented, in order per connection. */
+    websocket?: (req: Request, state: S, ctx: FakeContext) => FakeWebSocketHandlers | Response | Promise<FakeWebSocketHandlers | Response>;
     /**
      * Build the helpers exposed at `ctx.fakes.<name>` — a record of
      * **functions** that read or mutate the fake's `state` (received here)

package/dist/index.js

@@ -414,6 +414,9 @@ export function defineFake(opts) {
     if (typeof opts.handler !== "function") {
         throw new Error(`defineFake(${opts.name}): \`handler\` is required`);
     }
+    if (opts.websocket !== undefined && typeof opts.websocket !== "function") {
+        throw new Error(`defineFake(${opts.name}): \`websocket\` must be a function`);
+    }
     return opts;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.101.0",
+  "version": "0.103.0",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",
@@ -56,11 +56,13 @@
     "@kubernetes/client-node": "^1.0.0",
     "@xterm/headless": "^5.5.0",
     "dns-packet": "^5.6.1",
-    "playwright-core": "^1.61.1"
+    "playwright-core": "^1.61.1",
+    "ws": "^8.20.1"
   },
   "devDependencies": {
     "@types/dns-packet": "^5.6.5",
     "@types/bun": "^1.3.0",
+    "@types/ws": "^8",
     "typescript": "^5.6.3"
   },
   "spectestCapabilities": [

package/src/browser.ts

@@ -35,6 +35,8 @@ import { fileURLToPath } from "node:url";
 
 import { generateId } from "./ids.js";
 import { rawFetch } from "./harness/raw-fetch.js";
+import { prepareMicrophoneFixture, type MicrophoneFixture } from "./harness/microphone-fixture.js";
+export type { MicrophoneFixture } from "./harness/microphone-fixture.js";
 import { DESKTOP_INPUT_SYNC_SCRIPT } from "./desktop-recorder.js";
 import type { DesktopChrome } from "./desktop.js";
 import { recordBrowser, reserveBackdated, reserveEvent, truncateUtf8 } from "./recorder.js";
@@ -91,6 +93,10 @@ export interface BrowserOptions {
   frame?: "browser" | "mobile";
   /** Initial URL to navigate to before the constructor returns. */
   url?: string;
+  /** Feed a WAV fixture through Chromium's native microphone capture.
+   * Set on the session's first creation; inherited sessions keep their source.
+   * Fixture sessions use a dedicated Chromium process for audio isolation. */
+  microphone?: MicrophoneFixture;
   /**
    * Script installed (before the session's first navigation) to run in every
    * document loaded from now on, BEFORE the document's own scripts — the
@@ -406,8 +412,8 @@ export interface MobileBackend extends Browser {
 // What the app gets is Chromium's own synthetic devices: the microphone is a
 // generated beep pattern (a live, real MediaStreamTrack — MediaRecorder,
 // WebRTC and AudioContext analysis all work on it), the camera a rolling
-// test pattern at 640x480. There is deliberately NO way to feed a recording
-// in; this is device availability, not audio fixtures.
+// test pattern at 640x480. A microphone fixture adds Chromium's file-capture
+// flag in a dedicated process; getUserMedia and track behavior stay native.
 //
 // --use-fake-device-for-media-stream: the synthetic camera + microphone.
 //   Also what makes `enumerateDevices()` return anything at all.
@@ -442,14 +448,16 @@ const NAVIGATION_TIMEOUT_MS = 30_000;
 // Shared Chromium (playwright-core)
 // ────────────────────────────────────────────────────────────────────────
 
-// One Chromium per daemon, launched lazily on first view creation and kept
-// for the daemon's lifetime. It rides snapshots: the process, playwright's
+// Default sessions share one Chromium per daemon, launched lazily and kept
+// for the daemon's lifetime. Fixture sessions own a process because the audio
+// source is a process-wide flag. Both ride snapshots: the process, playwright's
 // pipe connection to it, and every open page freeze into the VM snapshot
 // and resume in each fork (like dockerd and the daemon itself). Profile
 // state — cookies, localStorage — is per-Chromium, and the in-VM CA trust
 // comes from the HOME-scoped NSS user DB, so neither cares that playwright
 // runs a temp --user-data-dir.
 let PW_BROWSER: PlaywrightBrowser | null = null;
+const VIEW_CLEANUPS = new WeakMap<BrowserContext, () => Promise<void>>();
 // Every view gets its OWN context, desktop included. A context is the cookie
 // jar + storage, so one-context-per-view is what makes `close()` mean what
 // the docs promise: the browsing session is destroyed and the next
@@ -502,20 +510,46 @@ async function newViewContext(
   width: number,
   height: number,
   device: DevicePreset | null,
+  microphone?: MicrophoneFixture,
 ): Promise<BrowserContext> {
-  const browser = await ensurePlaywrightBrowser();
-  const context = await browser.newContext(
-    device
-      ? deviceContextOptions(device)
-      : {
-          viewport: { width, height },
-          // Reduced-motion for replay fidelity — see deviceContextOptions.
-          reducedMotion: "reduce",
-        },
-  );
-  context.setDefaultTimeout(DEFAULT_ACTION_TIMEOUT_MS);
-  context.setDefaultNavigationTimeout(NAVIGATION_TIMEOUT_MS);
-  return context;
+  const fixture = microphone === undefined ? undefined : await prepareMicrophoneFixture(microphone);
+  let browser: PlaywrightBrowser | undefined;
+  try {
+    browser = fixture ? await chromium.launch({
+      executablePath: chromiumPath(), headless: true, args: [...CHROME_ARGV, fixture.arg],
+    }) : await ensurePlaywrightBrowser();
+    const context = await browser.newContext(
+      device
+        ? deviceContextOptions(device)
+        : {
+            viewport: { width, height },
+            // Reduced-motion for replay fidelity — see deviceContextOptions.
+            reducedMotion: "reduce",
+          },
+    );
+    context.setDefaultTimeout(DEFAULT_ACTION_TIMEOUT_MS);
+    context.setDefaultNavigationTimeout(NAVIGATION_TIMEOUT_MS);
+    if (fixture) {
+      const owned = browser;
+      VIEW_CLEANUPS.set(context, async () => {
+        try { await owned.close(); } finally { await fixture.cleanup(); }
+      });
+    }
+    return context;
+  } catch (err) {
+    if (fixture) {
+      try { await browser?.close(); } finally { await fixture.cleanup(); }
+    }
+    throw err;
+  }
+}
+
+async function closeViewContext(context: BrowserContext): Promise<void> {
+  try { await context.close(); } finally {
+    const cleanup = VIEW_CLEANUPS.get(context);
+    VIEW_CLEANUPS.delete(context);
+    await cleanup?.();
+  }
 }
 
 /**
@@ -1315,7 +1349,7 @@ export async function openMobileBackend(
   // views (in the shared desktop context), and a mobile view needs its own
   // emulated context anyway.
   const pooled =
-    !device && wantW === 1280 && wantH === 720 ? VIEW_POOL.pop() : undefined;
+    !device && opts.microphone === undefined && wantW === 1280 && wantH === 720 ? VIEW_POOL.pop() : undefined;
   let holder: ViewHolder;
   if (pooled) {
     holder = {
@@ -1331,7 +1365,7 @@ export async function openMobileBackend(
       initScripts: [],
     };
   } else {
-    holder = await newHolder(wantW, wantH, device);
+    holder = await newHolder(wantW, wantH, device, opts.microphone);
   }
 
   const { backend } = buildBackend(holder, opts.recorder ?? null, {
@@ -1341,11 +1375,14 @@ export async function openMobileBackend(
   // We deliberately don't forward `opts.url` to the constructor — going
   // through our own `navigate()` keeps the recorder log uniform (one
   // event per navigation, with timing) and drains rrweb after the load.
-  if (opts.initScript !== undefined) await installInitScript(holder, opts.initScript);
-  if (opts.url !== undefined) {
-    await backend.goto(opts.url);
+  try {
+    if (opts.initScript !== undefined) await installInitScript(holder, opts.initScript);
+    if (opts.url !== undefined) await backend.goto(opts.url);
+    return backend;
+  } catch (err) {
+    await backend.close();
+    throw err;
   }
-  return backend;
 }
 
 // ────────────────────────────────────────────────────────────────────────
@@ -1400,9 +1437,14 @@ async function newHolder(
   width: number,
   height: number,
   device: DevicePreset | null,
+  microphone?: MicrophoneFixture,
 ): Promise<ViewHolder> {
-  const context = await newViewContext(width, height, device);
-  const spawned = await spawnPage(context);
+  const context = await newViewContext(width, height, device, microphone);
+  let spawned: SpawnedPage;
+  try { spawned = await spawnPage(context); } catch (err) {
+    await closeViewContext(context);
+    throw err;
+  }
   const holder: ViewHolder = {
     context,
     page: spawned.page,
@@ -1497,6 +1539,7 @@ export async function acquirePersistentBrowser(
       device ? device.viewport.width : opts.width ?? 1280,
       device ? device.viewport.height : opts.height ?? 720,
       device,
+      opts.microphone,
     );
     SHARED_BROWSERS.set(name, holder);
   }
@@ -2163,7 +2206,7 @@ function buildBackend(
       // The context, not the page, holds the cookies and storage — closing
       // only the page would leave the next session signed in as this one.
       try {
-        if (buildOpts.ownsContext !== false) await holder.context.close();
+        if (buildOpts.ownsContext !== false) await closeViewContext(holder.context);
       } catch {
         /* context already gone (browser died) */
       }