@ultimat3/cli 21.0.0 → 22.1.0

package/src/cdp-connection.ts

@@ -1,247 +0,0 @@
-// One responsibility: a Chrome DevTools Protocol connection — request framing, response
-// correlation, and the per-call deadline — over a TRANSPORT that moves whole messages. Two exist:
-// the pipe a launched Chrome is driven over (`cdp-pipe.ts`, what the e2e driver uses) and a remote
-// browser's WebSocket (`cdpConnect` below). Launching is `cdp-launch.ts`; the page surface is
-// `cdp-e2e-page.ts`; this file knows nothing about either.
-//
-// **No library, and that is the point rather than an economy.** `packages/scraping/src/cdp-port.ts`
-// declares a ~25-method port because `ScrapePage` is a full scraping surface, and its intended
-// implementation is `puppeteer-core`. `E2eBrowserPage` is FIVE methods, and CDP's wire format is
-// one JSON object with an `id` — so the whole thing an e2e driver needs is this file plus two
-// small ones, on Bun's native `WebSocket`, with no dependency to add to a repo whose first
-// non-negotiable is that Bun's natives replace most of them.
-
-import { assert } from '@ultimat3/core';
-import { CdpCallFailedError, CdpTimeoutError } from './cdp-errors';
-
-/** One CDP result. `unknown` because every payload here is somebody else's JSON. */
-export interface CdpResult {
-  readonly result?: Record<string, unknown> | undefined;
-}
-
-export interface CdpConnection {
-  /** Send one command. `sessionId` targets an attached page rather than the browser itself. */
-  send(method: string, params?: Record<string, unknown>, sessionId?: string): Promise<CdpResult>;
-  /**
-   * Wait for the next occurrence of one CDP **event**, or for the deadline. Answers `true` when the
-   * event arrived and `false` when it did not — it never throws, because every caller has a better
-   * assertion to fail on than "the event was late".
-   *
-   * It exists because a command's reply is not always the signal. `Page.navigate`'s reply is
-   * DROPPED whenever the navigation swaps the render process — measured on Chrome 150: the page
-   * loads, the server is hit, a later `Runtime.evaluate` answers, and the navigate frame never
-   * comes back at all. A driver that treated the reply as the completion signal waits out its full
-   * deadline on the most ordinary navigation there is.
-   */
-  once(method: string, sessionId: string | undefined, timeoutMs: number): Promise<boolean>;
-  /**
-   * Subscribe to every occurrence of one CDP event, until the returned function is called.
-   *
-   * `once` cannot express what this is for: a target that attaches AFTER the driver stopped
-   * listening is a service worker whose network conditions nobody set, which is an `offline()`
-   * that silently does nothing to the one thing serving the page.
-   */
-  on(method: string, listener: (params: Record<string, unknown>) => void): () => void;
-  close(): void;
-}
-
-interface Pending {
-  readonly resolve: (value: CdpResult) => void;
-  readonly reject: (reason: Error) => void;
-  readonly timer: ReturnType<typeof setTimeout>;
-}
-
-/** A CDP error frame: `{ error: { code, message } }`, both fields somebody else's. */
-const errorText = (frame: Record<string, unknown>): string | undefined => {
-  const error = frame['error'];
-  if (typeof error !== 'object' || error === null) return undefined;
-  const message = (error as Record<string, unknown>)['message'];
-  return typeof message === 'string' ? message : 'the browser refused the call';
-};
-
-/**
- * What a connection needs of the wire: whole messages out, whole messages in, and a close. Framing
- * is the transport's — a WebSocket frames per message, the pipe splits on NUL — so correlation and
- * deadlines are written once, over either.
- */
-export interface CdpTransport {
-  send(text: string): void;
-  close(): void;
-  /** Installed exactly once, by the connection, before the first `send`. */
-  listen(handlers: {
-    readonly message: (text: string) => void;
-    readonly closed: (reason: string) => void;
-  }): void;
-}
-
-export interface CdpConnectionOptions {
-  readonly endpoint: string;
-  /** Per-call deadline. A CDP call that never answers is a suite that never finishes. */
-  readonly timeoutMs: number;
-}
-
-/**
- * A remote browser over its WebSocket url. NOT the e2e driver's wire: measured in the dummy's
- * `offline-feed` suite on Bun 1.4.0, Bun's WebSocket client handed `onmessage` text spliced out of
- * several frames — 64 unparseable frames in one run, one of them the reply to a `Runtime.evaluate`
- * that then waited out its whole deadline. A launched Chrome is driven over `cdp-pipe.ts` instead.
- */
-export async function cdpConnect(options: CdpConnectionOptions): Promise<CdpConnection> {
-  assert(
-    options.endpoint.startsWith('ws://') || options.endpoint.startsWith('wss://'),
-    `the CDP endpoint is ${options.endpoint === '' ? 'empty' : 'not a WebSocket url'}`,
-    'pass the `webSocketDebuggerUrl` Chrome prints on stderr, or the one /json/version answers',
-  );
-  const socket = new WebSocket(options.endpoint);
-  await new Promise<void>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      reject(new CdpTimeoutError({ method: 'connect', timeoutMs: options.timeoutMs }));
-    }, options.timeoutMs);
-    socket.onopen = (): void => {
-      clearTimeout(timer);
-      resolve();
-    };
-    // `onerror` is the handshake's only until `listen` below reassigns it: a failure BEFORE open
-    // has no pending call to abandon, and rejecting is the only way the caller hears about it.
-    socket.onerror = (): void => {
-      clearTimeout(timer);
-      reject(
-        new CdpCallFailedError({ method: 'connect', detail: 'the browser refused the connection' }),
-      );
-    };
-  });
-
-  const transport: CdpTransport = {
-    send: (text) => socket.send(text),
-    close: () => socket.close(),
-    listen(handlers) {
-      socket.onmessage = (event: MessageEvent): void => {
-        handlers.message(typeof event.data === 'string' ? event.data : '');
-      };
-      socket.onclose = (): void => handlers.closed('the browser closed the CDP connection');
-      socket.onerror = (): void => handlers.closed('the CDP connection failed');
-    },
-  };
-  return cdpConnectOver(transport, options.timeoutMs);
-}
-
-/** A connection over any transport — correlation, deadlines and events, written once. */
-export function cdpConnectOver(transport: CdpTransport, timeoutMs: number): CdpConnection {
-  const pending = new Map<number, Pending>();
-  const waiters = new Set<(method: string, sessionId: string | undefined) => void>();
-  const listeners = new Map<string, Set<(params: Record<string, unknown>) => void>>();
-  let nextId = 0;
-  let closed = false;
-
-  // Every in-flight call is settled on close. Without this a suite whose browser died waits out
-  // one full deadline per call and reports a timeout, where the true fault is a dead browser.
-  const abandon = (reason: string): void => {
-    closed = true;
-    for (const [, one] of pending) {
-      clearTimeout(one.timer);
-      one.reject(new CdpCallFailedError({ method: 'the connection', detail: reason }));
-    }
-    pending.clear();
-    // A waiter is a "did this happen" question, and on a dead connection the answer is no. Its
-    // own timer settles it, so nothing is left hanging; clearing the set only stops a late frame
-    // from resolving a waiter whose connection has gone.
-    waiters.clear();
-  };
-
-  const message = (raw: string): void => {
-    let frame: Record<string, unknown>;
-    try {
-      frame = JSON.parse(raw) as Record<string, unknown>;
-    } catch {
-      // An unparseable frame is the browser's, not ours, and there is no call to fail with it:
-      // correlation is by `id`, and a frame we cannot read has none. Events land here too.
-      return;
-    }
-    const id = frame['id'];
-    if (typeof id !== 'number') {
-      const method = frame['method'];
-      if (typeof method !== 'string') return;
-      const on = frame['sessionId'];
-      for (const waiter of [...waiters]) waiter(method, typeof on === 'string' ? on : undefined);
-      const subscribed = listeners.get(method);
-      if (subscribed !== undefined) {
-        const params = frame['params'];
-        const payload: Record<string, unknown> =
-          typeof params === 'object' && params !== null ? (params as Record<string, unknown>) : {};
-        // A copy, because a listener may unsubscribe itself while this loop is running.
-        for (const listener of [...subscribed]) listener(payload);
-      }
-      return;
-    }
-    const one = pending.get(id);
-    if (one === undefined) return;
-    pending.delete(id);
-    clearTimeout(one.timer);
-    const failed = errorText(frame);
-    if (failed !== undefined) {
-      one.reject(new CdpCallFailedError({ method: `call ${String(id)}`, detail: failed }));
-      return;
-    }
-    const result = frame['result'];
-    one.resolve({
-      result:
-        typeof result === 'object' && result !== null
-          ? (result as Record<string, unknown>)
-          : undefined,
-    });
-  };
-  transport.listen({ message, closed: abandon });
-
-  return {
-    send(method, params = {}, sessionId): Promise<CdpResult> {
-      if (closed) {
-        return Promise.reject(
-          new CdpCallFailedError({ method, detail: 'the CDP connection is already closed' }),
-        );
-      }
-      nextId += 1;
-      const id = nextId;
-      return new Promise<CdpResult>((resolve, reject) => {
-        const timer = setTimeout(() => {
-          pending.delete(id);
-          reject(new CdpTimeoutError({ method, timeoutMs: timeoutMs }));
-        }, timeoutMs);
-        pending.set(id, { resolve, reject, timer });
-        transport.send(
-          JSON.stringify({ id, method, params, ...(sessionId === undefined ? {} : { sessionId }) }),
-        );
-      });
-    },
-    once(method, sessionId, timeoutMs): Promise<boolean> {
-      if (closed) return Promise.resolve(false);
-      return new Promise<boolean>((resolve) => {
-        const waiter = (seen: string, on: string | undefined): void => {
-          if (seen !== method) return;
-          if (sessionId !== undefined && on !== sessionId) return;
-          clearTimeout(timer);
-          waiters.delete(waiter);
-          resolve(true);
-        };
-        const timer = setTimeout(() => {
-          waiters.delete(waiter);
-          resolve(false);
-        }, timeoutMs);
-        waiters.add(waiter);
-      });
-    },
-    on(method, listener): () => void {
-      const subscribed = listeners.get(method) ?? new Set();
-      subscribed.add(listener);
-      listeners.set(method, subscribed);
-      return () => {
-        subscribed.delete(listener);
-        if (subscribed.size === 0) listeners.delete(method);
-      };
-    },
-    close(): void {
-      listeners.clear();
-      abandon('the driver closed the CDP connection');
-      transport.close();
-    },
-  };
-}

package/src/cdp-e2e-page.ts

@@ -1,180 +0,0 @@
-// One responsibility: one TAB over a raw CDP session — navigate, reload, evaluate, click, wait. The
-// session (`cdp-e2e-session.ts`) attaches it and owns everything browser-wide: the network
-// condition, the init scripts, the socket and request log. Launching is `cdp-launch.ts` and the
-// wire is `cdp-connection.ts`.
-//
-// FIVE methods, which is the whole reason this exists next to `@ultimat3/scraping` rather than
-// through it: `ScrapePage` is a full scraping surface whose intended implementation is
-// `puppeteer-core`, and an e2e driver needs none of it.
-
-import type { CdpConnection } from './cdp-connection';
-import { CdpCallFailedError, CdpTimeoutError } from './cdp-errors';
-import type { E2eBrowserPage } from './e2e-page';
-
-/** What the page threw, when `Runtime.evaluate` answered with an exception rather than a value. */
-const thrownIn = (result: Record<string, unknown> | undefined): string | undefined => {
-  const thrown = result?.['exceptionDetails'];
-  if (typeof thrown !== 'object' || thrown === null) return undefined;
-  const text = (thrown as Record<string, unknown>)['text'];
-  return typeof text === 'string' ? text : 'the expression threw in the page';
-};
-
-/** `Runtime.evaluate`'s answer, unwrapped. Every field here is somebody else's JSON. */
-const evaluated = (result: Record<string, unknown> | undefined): unknown => {
-  const threw = thrownIn(result);
-  if (threw !== undefined) {
-    throw new CdpCallFailedError({ method: 'Runtime.evaluate', detail: threw });
-  }
-  const remote = result?.['result'];
-  if (typeof remote !== 'object' || remote === null) return undefined;
-  return (remote as Record<string, unknown>)['value'];
-};
-
-/** One tab: the port the driver drives, plus what a multi-tab acceptance suite asks of one. */
-export interface E2eTab extends E2eBrowserPage {
-  readonly targetId: string;
-  /** Browser-wide, like the switch it models: every tab AND every worker goes with it. */
-  offline(enabled: boolean): Promise<void>;
-  /** Reload and wait for the load, at the url the tab already had. */
-  reload(): Promise<void>;
-  /** Poll `expression` in the page until it is truthy, or refuse naming `what`. */
-  waitFor(expression: string, what: string, timeoutMs?: number): Promise<void>;
-  /** The IndexedDB databases this tab's origin holds, by name, sorted. */
-  indexedDbNames(): Promise<readonly string[]>;
-  close(): Promise<void>;
-}
-
-export interface CdpE2eTabOptions {
-  readonly connection: CdpConnection;
-  /** The attached tab's flattened session — every page call carries it. */
-  readonly sessionId: string;
-  readonly targetId: string;
-  /**
-   * How long a navigation's load event may take. Distinct from the connection's per-call deadline:
-   * `Page.navigate` ANSWERS as soon as the navigation is committed, so the wait for the load event
-   * is a second budget and is the one an app makes long.
-   */
-  readonly loadTimeoutMs: number;
-  /** The session's browser-wide switch, which `offline()` forwards to. */
-  readonly offline: (enabled: boolean) => Promise<void>;
-}
-
-const POLL_MS = 100;
-
-/** A tab over a session the caller has already attached and enabled (`cdp-e2e-session.ts`). */
-export function cdpE2eTab(options: CdpE2eTabOptions): E2eTab {
-  const send = options.connection.send.bind(options.connection);
-  const { sessionId } = options;
-
-  // `url()` is SYNCHRONOUS on the port, and CDP has no synchronous read — so the last committed
-  // url is tracked here. Seeded with the tab's own starting url rather than '' so a `reload()`
-  // before any `goto()` navigates somewhere real.
-  let current = 'about:blank';
-
-  const evaluateRaw = (expression: string) =>
-    send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true }, sessionId);
-  const evaluate = async (expression: string): Promise<unknown> =>
-    evaluated((await evaluateRaw(expression)).result);
-
-  // A poll that THROWS is a poll that does not hold yet, not a refusal: a click that navigates
-  // leaves the next poll reading a document whose `<body>` is not parsed, and
-  // `document.body.textContent` throws there once and holds a poll later. The last throw is kept
-  // and named at the deadline, so an expression that can never evaluate still says why.
-  const waitFor = async (expression: string, what: string, timeoutMs = options.loadTimeoutMs) => {
-    // Only the PAGE's throw is swallowed: a connection that died still refuses at once.
-    let threw: string | undefined;
-    for (let waited = 0; waited < timeoutMs; waited += POLL_MS) {
-      const answer = (await evaluateRaw(`Boolean(${expression})`)).result;
-      threw = thrownIn(answer);
-      if (threw === undefined && evaluated(answer) === true) return;
-      await Bun.sleep(POLL_MS);
-    }
-    const last = threw === undefined ? '' : `, and its last poll threw: ${threw}`;
-    throw new CdpTimeoutError({ method: `waitFor(${what})${last}`, timeoutMs });
-  };
-
-  const tab: E2eTab = {
-    targetId: options.targetId,
-    url: () => current,
-    async goto(url: string): Promise<unknown> {
-      // **The load EVENT is the signal, not the reply.** Chrome drops `Page.navigate`'s own reply
-      // whenever the navigation swaps the render process — measured on Chrome 150 against a local
-      // server: the page loads, the server is hit, a later `Runtime.evaluate` answers `document
-      // .title` from the new document, and the navigate frame never comes back at all. Awaiting
-      // the reply therefore waited out the full deadline on the most ordinary navigation there is,
-      // `about:blank` → `http://localhost:<port>/`. So the waiter is registered BEFORE the send,
-      // and the reply is raced against it rather than depended on.
-      const loaded = options.connection.once(
-        'Page.loadEventFired',
-        sessionId,
-        options.loadTimeoutMs,
-      );
-      // A dropped reply is expected, so its rejection is answered rather than thrown: what the
-      // reply is still worth reading for is `errorText`, which is the ONLY place a refused
-      // navigation is named — an unreachable host loads no page and fires no load event.
-      const answered = send('Page.navigate', { url }, sessionId).then(
-        (answer) => {
-          const failed = answer.result?.['errorText'];
-          return typeof failed === 'string' && failed !== '' ? failed : undefined;
-        },
-        () => undefined,
-      );
-      const failed = await Promise.race([loaded.then(() => undefined), answered]);
-      if (failed !== undefined) {
-        throw new CdpCallFailedError({ method: `Page.navigate to ${url}`, detail: failed });
-      }
-      current = url;
-      // The load event may already have fired before the waiter was registered on a same-process
-      // navigation, and `answered` can win the race on one too. So the document is asked directly:
-      // a `readyState` that is already `complete` resolves at once, and the deadline resolves
-      // rather than throwing — a slow page is the app's business, and the assertion after this is
-      // what should fail. HALF the budget, because the budget is also the connection's per-call
-      // deadline: a page timer of the full budget raced that deadline and lost, reporting a page
-      // that never fired `load` as "Runtime.evaluate did not answer" instead.
-      await evaluate(`(() => new Promise((resolve) => {
-        if (document.readyState === 'complete') { resolve(true); return; }
-        const done = () => resolve(true);
-        addEventListener('load', done, { once: true });
-        setTimeout(done, ${String(Math.floor(options.loadTimeoutMs / 2))});
-      }))()`);
-      // The app may have redirected, so the committed url is re-read rather than assumed.
-      const settled = await evaluate('location.href');
-      if (typeof settled === 'string' && settled !== '') current = settled;
-      return undefined;
-    },
-    evaluate,
-    async click(selector: string): Promise<void> {
-      // In-page rather than a synthesised `Input.dispatchMouseEvent`: the port takes a SELECTOR,
-      // and turning one into coordinates means a box model read, a scroll and a hit test — three
-      // more CDP calls, each with its own way to be wrong about an element the page can click.
-      const clicked = await evaluate(
-        `(() => { const el = document.querySelector(${JSON.stringify(selector)}); if (!el) return false; el.click(); return true; })()`,
-      );
-      if (clicked !== true) {
-        throw new CdpCallFailedError({
-          method: `click(${selector})`,
-          detail: 'no element in the page matches that selector',
-        });
-      }
-    },
-    offline: (enabled: boolean) => options.offline(enabled),
-    async reload(): Promise<void> {
-      const at = current;
-      // Reload is a navigation to the url the tab already has — the one wait the port proves.
-      await tab.goto(at);
-    },
-    waitFor,
-    async indexedDbNames(): Promise<readonly string[]> {
-      const names = await evaluate(
-        '(async () => (await indexedDB.databases()).map((db) => db.name ?? "").sort())()',
-      );
-      return Array.isArray(names)
-        ? names.filter((name): name is string => typeof name === 'string')
-        : [];
-    },
-    async close(): Promise<void> {
-      await send('Target.closeTarget', { targetId: options.targetId });
-    },
-  };
-  return tab;
-}

package/src/cdp-e2e-session.ts

@@ -1,199 +0,0 @@
-// One responsibility: the BROWSER half of the e2e driver — every target auto-attached at browser
-// level, so a second tab, a SharedWorker, a dedicated worker and a service worker are all watched
-// from their first byte; the offline switch, the init scripts, and the log of every WebSocket and
-// request the browser made. A tab is `cdp-e2e-page.ts`'s; this file decides what every tab shares.
-
-import type { CdpConnection } from './cdp-connection';
-import type { E2eTab } from './cdp-e2e-page';
-import { cdpE2eTab } from './cdp-e2e-page';
-import { CdpCallFailedError, CdpTimeoutError } from './cdp-errors';
-import { offlineScripts } from './cdp-offline-script';
-
-export interface E2eSession {
-  /** A new tab in the same profile — same cookies, same origin storage, same SharedWorker. */
-  newTab(): Promise<E2eTab>;
-  /** Runs in every page before its own scripts, in tabs open now and tabs opened later. */
-  addInitScript(source: string): Promise<void>;
-  /** Cut or restore the network for every page AND every worker, including ones attached later. */
-  offline(enabled: boolean): Promise<void>;
-  setCookie(url: string, name: string, value: string): Promise<void>;
-  /** Every WebSocket url the browser opened, in any realm — page, dedicated, shared or service worker. */
-  sockets(): readonly string[];
-  /** Every request the browser sent, `METHOD url`, in order. */
-  requests(): readonly string[];
-}
-
-export interface CdpE2eSessionOptions {
-  readonly connection: CdpConnection;
-  /** The load budget every tab's `goto` waits on, and how long a new tab may take to attach. */
-  readonly loadTimeoutMs: number;
-}
-
-const POLL_MS = 50;
-
-const field = (from: unknown, key: string): string | undefined => {
-  const value =
-    typeof from === 'object' && from !== null ? (from as Record<string, unknown>)[key] : undefined;
-  return typeof value === 'string' ? value : undefined;
-};
-
-/**
- * Start watching the browser. Targets are attached PAUSED (`waitForDebuggerOnStart: true`) and
- * released only once their network domain is ENABLED, in dispatch order — a SharedWorker opens its
- * socket at start-up, so a target configured any later than that is a socket nothing ever counted.
- * Released with `Runtime.runIfWaitingForDebugger` whatever happens and without waiting for any
- * answer, or a page that registered a worker never becomes controlled.
- */
-export async function cdpE2eSession(options: CdpE2eSessionOptions): Promise<E2eSession> {
-  const { connection } = options;
-  const send = connection.send.bind(connection);
-  const sessions = new Set<string>();
-  const pages = new Map<string, string>(); // targetId → sessionId
-  const scripts: string[] = [];
-  const sockets: string[] = [];
-  const requests: string[] = [];
-  let cut = false;
-
-  // `-1` is CDP's "no throttling" for both throughputs; 0 would be a browser that can never
-  // transfer a byte, which is a different failure wearing the same name.
-  const pageSessions = new Set<string>();
-  const onLineScripts = offlineScripts(send);
-  const condition = (session: string): Promise<unknown> =>
-    send(
-      'Network.emulateNetworkConditions',
-      { offline: cut, latency: 0, downloadThroughput: -1, uploadThroughput: -1 },
-      session,
-    );
-
-  connection.on('Network.webSocketCreated', (params) => {
-    sockets.push(field(params, 'url') ?? '');
-  });
-  connection.on('Network.requestWillBeSent', (params) => {
-    const request = params['request'];
-    requests.push(`${field(request, 'method') ?? '?'} ${field(request, 'url') ?? ''}`);
-  });
-  connection.on('Target.attachedToTarget', (params) => {
-    const session = field(params, 'sessionId');
-    if (session === undefined) return;
-    const info = params['targetInfo'];
-    const type = field(info, 'type');
-    sessions.add(session);
-    void (async () => {
-      // Every configuration call is SENT before the release and none is AWAITED before it. A
-      // session dispatches in order, so the target is still configured before its first byte runs —
-      // but a paused target may answer nothing until it is released: measured in a full `x verify`,
-      // a SharedWorker's `Network.enable` went unanswered for the whole 30 s deadline, the worker
-      // stayed paused that long, and the shared gate page stalled behind it. Awaiting the answers
-      // before releasing was a deadlock with a timeout for an exit.
-      //
-      // `Network.enable` first: `emulateNetworkConditions` is silently ignored on a session whose
-      // Network domain is off — an `offline()` that does nothing while the assertion after it
-      // reads as proof.
-      const configured: Promise<unknown>[] = [send('Network.enable', {}, session)];
-      if (cut) configured.push(condition(session));
-      if (type === 'page') {
-        configured.push(send('Page.enable', {}, session), send('Runtime.enable', {}, session));
-        pageSessions.add(session);
-        for (const source of scripts) {
-          configured.push(send('Page.addScriptToEvaluateOnNewDocument', { source }, session));
-        }
-        if (cut) configured.push(onLineScripts.add(session));
-        // The page's own workers attach under it UNPAUSED. Measured: paused here, the emitted
-        // service worker never took control of its page (`e2e/service-worker.e2e.test.ts` went
-        // red), because it is also attached at browser level. A dedicated worker's first request
-        // can therefore precede its Network.enable — the SharedWorker, which is what owns the
-        // socket, is a browser-level target and IS paused.
-        configured.push(
-          send(
-            'Target.setAutoAttach',
-            { autoAttach: true, waitForDebuggerOnStart: false, flatten: true },
-            session,
-          ),
-        );
-      }
-      const released = send('Runtime.runIfWaitingForDebugger', {}, session).catch(() => undefined);
-      // Settled, not `all`: a target that went away refuses EVERY call, and `all` would leave the
-      // refusals after the first as unhandled rejections. It has nothing left to watch.
-      const answers = await Promise.allSettled(configured);
-      if (answers.some((answer) => answer.status === 'rejected')) sessions.delete(session);
-      await released;
-      // Published only once RELEASED: a tab handed out while still paused would take its first
-      // `goto` into a page that is waiting for a debugger.
-      const targetId = field(info, 'targetId');
-      if (type === 'page' && targetId !== undefined && sessions.has(session)) {
-        pages.set(targetId, session);
-      }
-    })();
-  });
-  await send('Target.setDiscoverTargets', { discover: true });
-  await send('Target.setAutoAttach', {
-    autoAttach: true,
-    waitForDebuggerOnStart: true,
-    flatten: true,
-  });
-
-  const offline = async (enabled: boolean): Promise<void> => {
-    cut = enabled;
-    // Sequential, and a session that has gone away is dropped rather than taking the rest down.
-    for (const session of [...sessions]) {
-      await condition(session).catch(() => sessions.delete(session));
-    }
-    // And `navigator.onLine` from a new document's first script (`cdp-offline-script.ts`) — the
-    // network condition alone reaches a reloaded page only after its scripts have run.
-    for (const session of [...pageSessions]) {
-      const toggled = enabled ? onLineScripts.add(session) : onLineScripts.remove(session);
-      await toggled.catch(() => pageSessions.delete(session));
-    }
-  };
-
-  const attached = async (targetId: string): Promise<string> => {
-    for (let waited = 0; waited < options.loadTimeoutMs; waited += POLL_MS) {
-      const session = pages.get(targetId);
-      if (session !== undefined) return session;
-      await Bun.sleep(POLL_MS);
-    }
-    throw new CdpTimeoutError({
-      method: `Target.attachedToTarget for tab ${targetId}`,
-      timeoutMs: options.loadTimeoutMs,
-    });
-  };
-
-  return {
-    async newTab(): Promise<E2eTab> {
-      const created = await send('Target.createTarget', { url: 'about:blank' });
-      const targetId = field(created.result, 'targetId');
-      if (targetId === undefined) {
-        throw new CdpCallFailedError({
-          method: 'Target.createTarget',
-          detail: 'the browser created a tab and answered no targetId',
-        });
-      }
-      const sessionId = await attached(targetId);
-      return cdpE2eTab({
-        connection,
-        sessionId,
-        targetId,
-        loadTimeoutMs: options.loadTimeoutMs,
-        offline,
-      });
-    },
-    async addInitScript(source: string): Promise<void> {
-      scripts.push(source);
-      // A closed tab refuses every call; it is dropped rather than taking the open tabs down with
-      // it, exactly as `offline()` drops one.
-      for (const [targetId, session] of [...pages]) {
-        await send('Page.addScriptToEvaluateOnNewDocument', { source }, session).catch(() => {
-          pages.delete(targetId);
-          sessions.delete(session);
-          pageSessions.delete(session);
-        });
-      }
-    },
-    offline,
-    async setCookie(url: string, name: string, value: string): Promise<void> {
-      await send('Storage.setCookies', { cookies: [{ name, value, url, path: '/' }] });
-    },
-    sockets: () => [...sockets],
-    requests: () => [...requests],
-  };
-}