@ultimat3/cli 20.2.1 → 22.0.0

package/src/cdp-browser.ts

@@ -1,100 +0,0 @@
-// One responsibility: compose the three halves — find a browser, connect to it, attach a page —
-// into the one object `installE2eDriver({ page })` takes, plus the way to shut it down.
-//
-// **Absent is a SKIP, never a failure, and that is a requirement rather than a state.** A CI box
-// with no Chrome must not turn the `e2e` step red for a reason unrelated to the change, which is
-// the rule `packages/cli/CLAUDE.md` already states about `x shot`, `x pr` and `x ci`.
-// `openE2eBrowserIfAvailable` is that door; `openE2eBrowser` refuses by name for a caller that has
-// already decided a browser is required.
-
-import { finiteCount } from '@ultimat3/core';
-import type { CdpConnection } from './cdp-connection';
-import { cdpConnect } from './cdp-connection';
-import { cdpE2ePage } from './cdp-e2e-page';
-import { CdpBrowserMissingError } from './cdp-errors';
-import type { LaunchedBrowser } from './cdp-launch';
-import { CHROME_CANDIDATES, findChrome, launchChrome } from './cdp-launch';
-import type { E2eBrowserPage } from './e2e-page';
-
-/** How long a launch, a connect or a single CDP call may take. One number, three deadlines. */
-export const DEFAULT_CDP_TIMEOUT_MS = 30_000;
-
-export interface E2eBrowser {
-  readonly page: E2eBrowserPage;
-  /** Idempotent, and it closes both halves: the CDP socket, then the process and its profile. */
-  close(): void;
-}
-
-export interface OpenE2eBrowserOptions {
-  readonly env?: Readonly<Record<string, string | undefined>> | undefined;
-  readonly timeoutMs?: number | undefined;
-}
-
-/**
- * Screened HERE, before a browser exists, and not where it lands. It becomes three deadlines — the
- * launch, the handshake and every CDP call — and `Number(process.env.E2E_TIMEOUT ?? '')` is `NaN`
- * for an unset variable and is not nullish, so `??` keeps it: a `setTimeout` given `NaN` fires at
- * 1ms in this Bun, which makes every call report `X_CDP_TIMEOUT` against a browser that was
- * answering. A misdiagnosis reported as a test failure is worse than the failure.
- */
-const budget = (options: OpenE2eBrowserOptions): number =>
-  finiteCount('openE2eBrowser', 'timeoutMs', options.timeoutMs ?? DEFAULT_CDP_TIMEOUT_MS);
-
-const compose = (
-  launched: LaunchedBrowser,
-  connection: CdpConnection,
-  page: E2eBrowserPage,
-): E2eBrowser => ({
-  page,
-  close(): void {
-    // The socket first: closing the process out from under an open connection makes every
-    // in-flight call report "the browser closed the CDP connection", which is true and useless.
-    connection.close();
-    launched.close();
-  },
-});
-
-/**
- * Launch a browser and attach one page to it. Refuses with `X_CDP_BROWSER_MISSING` when there is
- * nothing to launch — the caller that wants a skip asks `openE2eBrowserIfAvailable` instead.
- */
-export async function openE2eBrowser(options: OpenE2eBrowserOptions = {}): Promise<E2eBrowser> {
-  const timeoutMs = budget(options);
-  const executable = await findChrome(options.env ?? process.env);
-  if (executable === undefined) throw new CdpBrowserMissingError({ tried: CHROME_CANDIDATES });
-  return openLaunched(executable, timeoutMs);
-}
-
-/** `undefined` when this machine has no browser. Every other failure still throws. */
-export async function openE2eBrowserIfAvailable(
-  options: OpenE2eBrowserOptions = {},
-): Promise<E2eBrowser | undefined> {
-  const timeoutMs = budget(options);
-  const executable = await findChrome(options.env ?? process.env);
-  if (executable === undefined) return undefined;
-  return openLaunched(executable, timeoutMs);
-}
-
-/**
- * The half both doors share. Each step undoes the ones before it on the way out: a Chrome that
- * launched and then refused the CDP handshake would otherwise be left running, holding its profile
- * directory, for the rest of the test process — one leaked browser per failing suite.
- */
-async function openLaunched(executable: string, timeoutMs: number): Promise<E2eBrowser> {
-  const launched = await launchChrome({ executable, timeoutMs });
-  let connection: CdpConnection;
-  try {
-    connection = await cdpConnect({ endpoint: launched.endpoint, timeoutMs });
-  } catch (error) {
-    launched.close();
-    throw error;
-  }
-  try {
-    const page = await cdpE2ePage({ connection, loadTimeoutMs: timeoutMs });
-    return compose(launched, connection, page);
-  } catch (error) {
-    connection.close();
-    launched.close();
-    throw error;
-  }
-}

package/src/cdp-connection.ts

@@ -1,211 +0,0 @@
-// One responsibility: a Chrome DevTools Protocol connection over Bun's own WebSocket — request
-// framing, response correlation, and the per-call deadline. Launching a browser is `cdp-launch.ts`
-// and 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';
-};
-
-export interface CdpConnectionOptions {
-  readonly endpoint: string;
-  /** Per-call deadline. A CDP call that never answers is a suite that never finishes. */
-  readonly timeoutMs: number;
-}
-
-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);
-  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();
-  };
-
-  socket.onmessage = (event: MessageEvent): void => {
-    const raw = typeof event.data === 'string' ? event.data : '';
-    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,
-    });
-  };
-  socket.onclose = (): void => abandon('the browser closed the CDP connection');
-  socket.onerror = (): void => abandon('the CDP connection failed');
-
-  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 replaced for the handshake only, then restored above: 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' }),
-      );
-    };
-  });
-  socket.onerror = (): void => abandon('the CDP connection failed');
-
-  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: options.timeoutMs }));
-        }, options.timeoutMs);
-        pending.set(id, { resolve, reject, timer });
-        socket.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');
-      socket.close();
-    },
-  };
-}

package/src/cdp-e2e-page.ts

@@ -1,209 +0,0 @@
-// One responsibility: `E2eBrowserPage` over a raw CDP connection — attach a tab, navigate,
-// evaluate, click, and set the browser's offline condition. 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 { assert } from '@ultimat3/core';
-import type { CdpConnection } from './cdp-connection';
-import { CdpCallFailedError } from './cdp-errors';
-import type { E2eBrowserPage } from './e2e-page';
-
-/** `Runtime.evaluate`'s answer, unwrapped. Every field here is somebody else's JSON. */
-const evaluated = (result: Record<string, unknown> | undefined): unknown => {
-  const thrown = result?.['exceptionDetails'];
-  if (typeof thrown === 'object' && thrown !== null) {
-    const text = (thrown as Record<string, unknown>)['text'];
-    throw new CdpCallFailedError({
-      method: 'Runtime.evaluate',
-      detail: typeof text === 'string' ? text : 'the expression threw in the page',
-    });
-  }
-  const remote = result?.['result'];
-  if (typeof remote !== 'object' || remote === null) return undefined;
-  return (remote as Record<string, unknown>)['value'];
-};
-
-export interface CdpE2ePageOptions {
-  readonly connection: CdpConnection;
-  /**
-   * 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;
-}
-
-/**
- * Attach a fresh tab and give back the page.
- *
- * `flatten: true` is not optional: without it every page call has to be wrapped in
- * `Target.sendMessageToTarget` and the answers arrive as nested strings. Flattened, a `sessionId`
- * on the frame is the whole of it, which is what keeps `cdp-connection.ts` a single map.
- */
-export async function cdpE2ePage(options: CdpE2ePageOptions): Promise<E2eBrowserPage> {
-  const send = options.connection.send.bind(options.connection);
-  const created = await send('Target.createTarget', { url: 'about:blank' });
-  const targetId = created.result?.['targetId'];
-  assert(
-    typeof targetId === 'string',
-    'the browser created a tab and answered no targetId',
-    'check the Chrome version supports Target.createTarget — every build since 60 does',
-  );
-  const attached = await send('Target.attachToTarget', { targetId, flatten: true });
-  const sessionId = attached.result?.['sessionId'];
-  assert(
-    typeof sessionId === 'string',
-    'the browser attached to the tab and answered no sessionId',
-    'check the Chrome version supports Target.attachToTarget with flatten: true — every build since 79 does',
-  );
-
-  await send('Page.enable', {}, sessionId);
-  await send('Runtime.enable', {}, sessionId);
-  // Enabled at attach rather than inside `offline()`, because `Network.emulateNetworkConditions`
-  // is silently ignored on a session whose Network domain was never enabled — the exact shape of
-  // an `offline()` that does nothing while the assertion after it reads as proof.
-  await send('Network.enable', {}, sessionId);
-
-  // **A SERVICE WORKER FETCHES ON ITS OWN TARGET, and that is what `offline()` used to miss.**
-  // Measured against the framework's own emitted `sw.js`: with the page session offline, a
-  // `networkFirst` route the cache had never seen still answered from the network, because the
-  // worker's fetches never crossed the session the condition was set on. The assertion after
-  // `offline()` then read as proof of an offline fallback that had not run.
-  //
-  // So worker targets are AUTO-ATTACHED and carry the same condition. `waitForDebuggerOnStart:
-  // false`, or every worker starts paused and the page that registered it never becomes
-  // controlled.
-  const workers = new Set<string>();
-  let offline = false;
-  const applyOffline = async (target: string | undefined): Promise<void> => {
-    // `-1` is CDP's "no throttling" for both throughputs. Passing 0 would be a browser that can
-    // never transfer a byte, which is a different failure wearing the same name.
-    await send(
-      'Network.emulateNetworkConditions',
-      { offline, latency: 0, downloadThroughput: -1, uploadThroughput: -1 },
-      target,
-    );
-  };
-  options.connection.on('Target.attachedToTarget', (params) => {
-    const info = params['targetInfo'];
-    const kind =
-      typeof info === 'object' && info !== null
-        ? (info as Record<string, unknown>)['type']
-        : undefined;
-    const attachedTo = params['sessionId'];
-    if (typeof attachedTo !== 'string') return;
-    if (kind !== 'service_worker' && kind !== 'worker' && kind !== 'shared_worker') return;
-    workers.add(attachedTo);
-    // A worker that attaches while the page is offline inherits the condition — it did not exist
-    // when `offline(true)` ran, and a worker registered mid-test is the ordinary case for a PWA.
-    void (async () => {
-      try {
-        await send('Network.enable', {}, attachedTo);
-        if (offline) await applyOffline(attachedTo);
-      } catch {
-        // A worker that died between attaching and being configured is not this driver's problem;
-        // its session is gone and every later call on it would report the same thing.
-        workers.delete(attachedTo);
-      }
-    })();
-  });
-  await send(
-    'Target.setAutoAttach',
-    { autoAttach: true, waitForDebuggerOnStart: false, flatten: true },
-    sessionId,
-  );
-
-  // `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 evaluate = async (expression: string): Promise<unknown> => {
-    const answer = await send(
-      'Runtime.evaluate',
-      { expression, returnByValue: true, awaitPromise: true },
-      sessionId,
-    );
-    return evaluated(answer.result);
-  };
-
-  return {
-    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.
-      await evaluate(`(() => new Promise((resolve) => {
-        if (document.readyState === 'complete') { resolve(true); return; }
-        const done = () => resolve(true);
-        addEventListener('load', done, { once: true });
-        setTimeout(done, ${String(options.loadTimeoutMs)});
-      }))()`);
-      // 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',
-        });
-      }
-    },
-    async offline(enabled: boolean): Promise<void> {
-      offline = enabled;
-      // The page first, then every worker attached to it. Sequential rather than `Promise.all`:
-      // the set is small, and a worker session that has gone away must not take the page's own
-      // condition down with it.
-      await applyOffline(sessionId);
-      for (const worker of [...workers]) {
-        try {
-          await applyOffline(worker);
-        } catch {
-          workers.delete(worker);
-        }
-      }
-    },
-  };
-}

package/src/cdp-errors.ts

@@ -1,56 +0,0 @@
-// One constructor per way the raw-CDP e2e browser refuses. Every cause quotes a value that came
-// out of a BROWSER or off a spawned process's stderr, so every one is rendered rather than
-// interpolated — the rule `e2e-errors.ts` already states.
-
-import { renderCauseValue, UltimateError } from '@ultimat3/core';
-
-/**
- * No browser to drive. This is the one an author meets first, so its fix names the two ways out:
- * point the driver at a binary, or accept that this machine cannot run the check.
- */
-export class CdpBrowserMissingError extends UltimateError {
-  constructor(input: { readonly tried: readonly string[] }) {
-    super({
-      code: 'X_CDP_BROWSER_MISSING',
-      cause: `no Chrome or Chromium executable was found — tried ${renderCauseValue(input.tried)}`,
-      fix: 'set CHROME_PATH to a Chrome or Chromium binary (GitHub-hosted ubuntu runners ship one at /usr/bin/google-chrome), or skip the browser-backed e2e suite by leaving it unset',
-    });
-  }
-}
-
-/** The binary ran and never announced an endpoint — a crash, a bad flag, or a sandbox refusal. */
-export class CdpLaunchFailedError extends UltimateError {
-  constructor(input: { readonly executable: string; readonly detail: string }) {
-    super({
-      code: 'X_CDP_LAUNCH_FAILED',
-      cause: `${renderCauseValue(input.executable)} did not announce a DevTools endpoint: ${renderCauseValue(input.detail)}`,
-      fix: 'run the same binary by hand with --headless=new --remote-debugging-port=0 and read its stderr; inside a container add --no-sandbox --disable-dev-shm-usage, which this launcher already passes',
-    });
-  }
-}
-
-/** A CDP call answered with an error frame, or the connection died under it. */
-export class CdpCallFailedError extends UltimateError {
-  constructor(input: { readonly method: string; readonly detail: string }) {
-    super({
-      code: 'X_CDP_CALL_FAILED',
-      cause: `the browser refused ${renderCauseValue(input.method)}: ${renderCauseValue(input.detail)}`,
-      fix: 'print what the page had: await page.evaluate(() => document.body.innerHTML) — a call that refuses the same way means the browser itself is gone, so read the launch above it',
-    });
-  }
-}
-
-/**
- * A call that never answered. Its own code rather than `X_TIMEOUT`, because the actionable half is
- * WHICH call: a hung `Page.navigate` is an app that never finishes responding, and a hung
- * `Runtime.evaluate` is an expression that never settles.
- */
-export class CdpTimeoutError extends UltimateError {
-  constructor(input: { readonly method: string; readonly timeoutMs: number }) {
-    super({
-      code: 'X_CDP_TIMEOUT',
-      cause: `${renderCauseValue(input.method)} did not answer inside ${String(input.timeoutMs)}ms`,
-      fix: 'raise timeoutMs on installE2eDriver({ timeoutMs }), or find the request the page is still waiting on — a navigation that never settles is an app that never finishes its response',
-    });
-  }
-}