browser-debugger-cli 0.15.0 → 0.16.0

package/dist/ipc/client.d.ts

@@ -92,8 +92,11 @@ export declare function getHARData(): Promise<HARDataResponse>;
  *
  * @param url - Target URL to navigate to
  * @param options - Session configuration options
+ * @param signal - Cancels the start: closes the connection, so the daemon
+ *   abandons the session it is starting
  * @returns Start session response with daemon and Chrome PIDs
  * @throws Error if connection fails, session already running, or Chrome launch fails
+ * @throws IPCCancelledError if `signal` aborts first
  *
  * @example
  * ```typescript
@@ -107,7 +110,7 @@ export declare function getHARData(): Promise<HARDataResponse>;
  * }
  * ```
  */
-export declare function startSession(url: string, options?: SessionOptions): Promise<StartSessionResponse>;
+export declare function startSession(url: string, options?: SessionOptions, signal?: AbortSignal): Promise<StartSessionResponse>;
 /**
  * Request session stop from the daemon.
  * Stops telemetry collection and closes Chrome.
@@ -258,6 +261,16 @@ export declare function domAudit(params: NoType<(typeof COMMANDS)['dom_audit']['
 export declare function cssSearch(params: NoType<(typeof COMMANDS)['css_search']['requestSchema']>): Promise<ClientResponse<'css_search'>>;
 /** What one element looks like: styles, box, layout and child tree. */
 export declare function domInspect(params: NoType<(typeof COMMANDS)['dom_inspect']['requestSchema']>): Promise<ClientResponse<'dom_inspect'>>;
+/**
+ * Capture the page or one element; the daemon puts back the emulation the
+ * capture changed before it answers.
+ *
+ * @param params - What to capture and how
+ * @param signal - Cancels the capture (the daemon skips it and only restores)
+ * @returns The image and what was captured
+ * @throws IPCCancelledError if `signal` aborts first
+ */
+export declare function domScreenshot(params: NoType<(typeof COMMANDS)['dom_screenshot']['requestSchema']>, signal?: AbortSignal): Promise<ClientResponse<'dom_screenshot'>>;
 /**
  * Wait until elements appear, become visible, contain a text or are gone,
  * and/or the page has loaded.

package/dist/ipc/client.js

@@ -117,8 +117,11 @@ export async function getHARData() {
  *
  * @param url - Target URL to navigate to
  * @param options - Session configuration options
+ * @param signal - Cancels the start: closes the connection, so the daemon
+ *   abandons the session it is starting
  * @returns Start session response with daemon and Chrome PIDs
  * @throws Error if connection fails, session already running, or Chrome launch fails
+ * @throws IPCCancelledError if `signal` aborts first
  *
  * @example
  * ```typescript
@@ -132,7 +135,7 @@ export async function getHARData() {
  * }
  * ```
  */
-export async function startSession(url, options) {
+export async function startSession(url, options, signal) {
     const request = withSession({
         type: 'start_session_request',
         url,
@@ -151,7 +154,7 @@ export async function startSession(url, options) {
         }),
     });
     await assertResponsive();
-    return sendRequest(request, 'start session', 'start_session_response');
+    return sendRequest(request, 'start session', 'start_session_response', undefined, undefined, signal);
 }
 /**
  * Request session stop from the daemon.
@@ -180,10 +183,12 @@ export async function stopSession() {
  * @param commandName - Name of the command to send
  * @param params - Command parameters (without type field)
  * @param timeoutMs - How long to wait (default: IPC timeout; page work can take long)
+ * @param signal - Cancels the command: closes the connection, which the daemon notices
  * @returns Command response from the session
  * @throws Error if connection fails or command execution fails
+ * @throws IPCCancelledError if `signal` aborts first
  */
-async function sendCommand(commandName, params, timeoutMs) {
+async function sendCommand(commandName, params, timeoutMs, signal) {
     const request = {
         ...params,
         type: `${commandName}_request`,
@@ -191,7 +196,7 @@ async function sendCommand(commandName, params, timeoutMs) {
     };
     if (timeoutMs === undefined || timeoutMs > getQuickIPCRequestTimeout())
         await assertResponsive();
-    return sendRequest(request, commandName, `${commandName}_response`, timeoutMs);
+    return sendRequest(request, commandName, `${commandName}_response`, timeoutMs, undefined, signal);
 }
 /**
  * Get details for a specific network request or console message.
@@ -376,6 +381,18 @@ export async function cssSearch(params) {
 export async function domInspect(params) {
     return sendCommand('dom_inspect', params);
 }
+/**
+ * Capture the page or one element; the daemon puts back the emulation the
+ * capture changed before it answers.
+ *
+ * @param params - What to capture and how
+ * @param signal - Cancels the capture (the daemon skips it and only restores)
+ * @returns The image and what was captured
+ * @throws IPCCancelledError if `signal` aborts first
+ */
+export async function domScreenshot(params, signal) {
+    return sendCommand('dom_screenshot', params, undefined, signal);
+}
 /** Time the client gives `dom wait` beyond its --timeout (the daemon reports the timeout first) */
 const WAIT_IPC_MARGIN_MS = 10_000;
 /**

package/dist/ipc/protocol/commands.d.ts

@@ -6,10 +6,10 @@
  */
 import type { HintDetails } from '../../errors/notices.js';
 import type { AuditCheck, AuditResult, CssSearchResult } from './auditTypes.js';
-import type { ClickResult, FillResult, LayoutResult, ListenersResult, PressKeyResult, RawFormData, ScrollResult, SubmitResult } from './domTypes.js';
+import type { ClickResult, DownloadInfo, FillResult, LayoutResult, ListenersResult, PressKeyResult, RawFormData, ScrollResult, SubmitResult } from './domTypes.js';
 import type { InspectResult } from './inspectTypes.js';
 import type { PageState, SessionActivity } from '../session/types.js';
-import type { ColorScheme, NetworkRequest, ViewportSize } from '../../types.js';
+import type { ColorScheme, NetworkRequest, ScreenshotResult, ViewportSize } from '../../types.js';
 /**
  * Session peek command request schema.
  */
@@ -78,6 +78,8 @@ export interface SessionPeekData {
     droppedNetwork?: number;
     /** Response bodies evicted at the total body budget (the oldest) */
     evictedNetworkBodies?: number;
+    /** Downloads that began during the session, oldest first (left out when none) */
+    downloads?: DownloadInfo[];
     /** Whether there are more network items available. */
     hasMoreNetwork?: boolean;
     /** Whether there are more console items available. */
@@ -378,6 +380,33 @@ export interface DomInspectCommand {
     why?: string;
 }
 export type DomInspectData = InspectResult;
+/**
+ * dom_screenshot: capture the page, or one element, as an image. The daemon
+ * changes the page's emulation for the capture and puts it back before it
+ * answers, so an interrupted CLI cannot leave it changed.
+ */
+export interface DomScreenshotCommand {
+    format: 'png' | 'jpeg';
+    /** JPEG quality (default 90) */
+    quality?: number;
+    /** Keep the full size instead of scaling down to the token budget */
+    noResize?: boolean;
+    /** Element to capture (the page when absent) */
+    backendNodeId?: number;
+    /** Element capture: CSS px of page added around the captured area */
+    padding?: number;
+    /** Page capture: the whole page (default true) */
+    fullPage?: boolean;
+    /** Page capture: selector scrolled into view first */
+    scroll?: string;
+}
+/** A captured image and what it shows */
+export interface DomScreenshotData {
+    /** The image, base64-encoded */
+    image: string;
+    /** What was captured (all a screenshot reports but the file it is written to) */
+    screenshot: Omit<ScreenshotResult, 'path'>;
+}
 /**
  * dom_form_discover: run the form discovery script and return raw form data.
  */
@@ -413,6 +442,7 @@ export type RegistryShape = {
     dom_audit: CommandDef<DomAuditCommand, DomAuditData>;
     css_search: CommandDef<CssSearchCommand, CssSearchData>;
     dom_inspect: CommandDef<DomInspectCommand, DomInspectData>;
+    dom_screenshot: CommandDef<DomScreenshotCommand, DomScreenshotData>;
     dom_wait: CommandDef<DomWaitCommand, DomWaitData>;
     page_navigate: CommandDef<PageNavigateCommand, PageNavigationResult>;
     page_emulate: CommandDef<PageEmulateCommand, PageEmulationResult>;

package/dist/ipc/protocol/commands.js

@@ -38,6 +38,7 @@ export const COMMANDS = {
     dom_audit: defineCommand(),
     css_search: defineCommand(),
     dom_inspect: defineCommand(),
+    dom_screenshot: defineCommand(),
     dom_wait: defineCommand(),
 };
 //# sourceMappingURL=commands.js.map

package/dist/ipc/protocol/domTypes.d.ts

@@ -67,6 +67,27 @@ export interface ShownElement {
     /** The element, e.g. `div.figcaption` */
     element: string;
 }
+/** State of a download: still running, saved, or stopped before it finished */
+export type DownloadState = 'inProgress' | 'completed' | 'canceled';
+/** A file download a command started */
+export interface DownloadInfo {
+    /** URL of the downloaded resource */
+    url: string;
+    /** File name the page or server suggested */
+    suggestedFilename: string;
+    /**
+     * Absolute path of the file once saved: for a Chrome bdg launched,
+     * `<session dir>/downloads/<name>` (`(1)`, `(2)`… added when the name is
+     * taken), set while it still runs; for an attached Chrome only when Chrome
+     * says where it saved it. Absent for a canceled download
+     */
+    path?: string;
+    state: DownloadState;
+    /** Bytes received so far (all of them once completed) */
+    bytes?: number;
+    /** Why bdg canceled it, e.g. its downloads directory could not be created */
+    reason?: string;
+}
 /** What the page was still working on when an action returned */
 export interface PendingChanges {
     /** Content requests (documents, fetch/XHR, scripts) the action started that were still running */
@@ -75,7 +96,7 @@ export interface PendingChanges {
     navigation?: true;
     /** A loading indicator that appeared during the action and was still shown, e.g. `div#loading` */
     loading?: string;
-    /** The DOM was still changing (several bursts of changes, the last one under 150 ms ago) */
+    /** The DOM was still changing (several bursts of changes, the last one under 150 ms of quiet time ago) */
     domChanging?: true;
     /** The page did not answer within 250 ms (a long-running script) */
     busy?: true;
@@ -98,6 +119,8 @@ export interface ActionEffects {
     pending?: PendingChanges;
     /** All built-ins the page replaced that bdg's action scripts use (when the warning mentions them) */
     replacedBuiltins?: string[];
+    /** Downloads that began during the action (absent when none did) */
+    downloads?: DownloadInfo[];
 }
 /** A filled field's value differing from the one given */
 export interface FillValueMismatch {

package/dist/ipc/session/queries.d.ts

@@ -5,6 +5,7 @@
  */
 import type { IPCMessage } from './lifecycle.js';
 import type { PageState, SessionActivity } from './types.js';
+import type { DownloadInfo } from '../protocol/domTypes.js';
 import type { ColorScheme, NetworkRequest, TelemetryType, ViewportSize } from '../../types.js';
 /**
  * Status request (client → daemon).
@@ -100,6 +101,8 @@ export interface PeekResponseData {
             console: number;
         };
         currentNavigationId?: number;
+        /** Downloads that began during the session, oldest first */
+        downloads?: DownloadInfo[];
         partial?: boolean;
     };
 }

package/dist/ipc/session/types.d.ts

@@ -3,6 +3,7 @@
  *
  * Common types used across session messages and session commands.
  */
+import type { DownloadInfo } from '../protocol/domTypes.js';
 import type { ColorScheme, ViewportSize } from '../../types.js';
 /**
  * Session activity metrics.
@@ -20,6 +21,10 @@ export interface SessionActivity {
     lastNetworkRequestAt?: number;
     /** Timestamp of last console message. */
     lastConsoleMessageAt?: number;
+    /** Downloads that began during the session, oldest first (left out when none). */
+    downloads?: DownloadInfo[];
+    /** Why downloads do not go to the session directory (refused, or not redirected), while they do not */
+    downloadsWarning?: string;
 }
 /**
  * Current page state.

package/dist/ipc/transport/IPCError.d.ts

@@ -79,4 +79,13 @@ export declare class IPCEarlyCloseError extends IPCError {
     readonly requestName: string;
     constructor(requestName: string);
 }
+/**
+ * Error thrown when the client cancels a request (its abort signal fired),
+ * closing the connection before the response arrived.
+ */
+export declare class IPCCancelledError extends IPCError {
+    readonly name = "IPCCancelledError";
+    readonly requestName: string;
+    constructor(requestName: string);
+}
 //# sourceMappingURL=IPCError.d.ts.map

package/dist/ipc/transport/IPCError.js

@@ -106,4 +106,16 @@ export class IPCEarlyCloseError extends IPCError {
         this.requestName = requestName;
     }
 }
+/**
+ * Error thrown when the client cancels a request (its abort signal fired),
+ * closing the connection before the response arrived.
+ */
+export class IPCCancelledError extends IPCError {
+    name = 'IPCCancelledError';
+    requestName;
+    constructor(requestName) {
+        super(`${requestName} request cancelled`, EXIT_CODES.SOFTWARE_ERROR);
+        this.requestName = requestName;
+    }
+}
 //# sourceMappingURL=IPCError.js.map

package/dist/ipc/transport/errors.d.ts

@@ -3,9 +3,10 @@
  *
  * Formats transport-layer errors with context using structured error classes.
  */
-import { IPCConnectionError, IPCParseError, IPCTimeoutError, IPCEarlyCloseError } from './IPCError.js';
+import { IPCCancelledError, IPCConnectionError, IPCParseError, IPCTimeoutError, IPCEarlyCloseError } from './IPCError.js';
 export declare function formatConnectionError(requestName: string, socketPath: string, error: Error): IPCConnectionError;
 export declare function formatParseError(requestName: string, error: unknown): IPCParseError;
 export declare function formatTimeoutError(requestName: string, timeoutMs: number): IPCTimeoutError;
 export declare function formatEarlyCloseError(requestName: string): IPCEarlyCloseError;
+export declare function formatCancelledError(requestName: string): IPCCancelledError;
 //# sourceMappingURL=errors.d.ts.map

package/dist/ipc/transport/errors.js

@@ -4,7 +4,7 @@
  * Formats transport-layer errors with context using structured error classes.
  */
 import { getErrorMessage } from '../../utils/errors.js';
-import { IPCConnectionError, IPCParseError, IPCTimeoutError, IPCEarlyCloseError, } from './IPCError.js';
+import { IPCCancelledError, IPCConnectionError, IPCParseError, IPCTimeoutError, IPCEarlyCloseError, } from './IPCError.js';
 export function formatConnectionError(requestName, socketPath, error) {
     const code = error.code;
     const message = [
@@ -25,4 +25,7 @@ export function formatTimeoutError(requestName, timeoutMs) {
 export function formatEarlyCloseError(requestName) {
     return new IPCEarlyCloseError(requestName);
 }
+export function formatCancelledError(requestName) {
+    return new IPCCancelledError(requestName);
+}
 //# sourceMappingURL=errors.js.map

package/dist/ipc/transport/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Handles Unix domain socket communication with JSONL protocol.
  */
-export { IPCError, IPCConnectionError, IPCTimeoutError, IPCParseError, IPCEarlyCloseError, } from './IPCError.js';
+export { IPCError, IPCCancelledError, IPCConnectionError, IPCTimeoutError, IPCParseError, IPCEarlyCloseError, } from './IPCError.js';
 type WithTypeAndSession = {
     type: string;
     sessionId: string;
@@ -17,6 +17,8 @@ type WithTypeAndSession = {
  * @param expectedType - Response type to validate, if any
  * @param timeoutMs - How long to wait for the response (default: IPC timeout)
  * @param socketPath - Daemon socket (default: the selected session's)
+ * @param signal - Closes the connection and rejects when aborted (the daemon
+ *   sees the client disconnect, e.g. an interrupted start is cancelled)
  * @returns The daemon's response
  * @throws CommandError (103) before connecting when the socket's session
  *   directory cannot be trusted (see {@link secureSessionDir}): a socket
@@ -25,5 +27,5 @@ type WithTypeAndSession = {
  *   needs write access to a directory of the chain, which the check has
  *   just found only the user has
  */
-export declare function sendRequest<TRequest extends WithTypeAndSession, TResponse extends WithTypeAndSession>(request: TRequest, requestName: string, expectedType?: string, timeoutMs?: number, socketPath?: string): Promise<TResponse>;
+export declare function sendRequest<TRequest extends WithTypeAndSession, TResponse extends WithTypeAndSession>(request: TRequest, requestName: string, expectedType?: string, timeoutMs?: number, socketPath?: string, signal?: AbortSignal): Promise<TResponse>;
 //# sourceMappingURL=index.d.ts.map

package/dist/ipc/transport/index.js

@@ -10,11 +10,11 @@ import { untrustedSessionDirError } from '../../errors/messages.js';
 import { getDaemonSocketPath, secureSessionDir } from '../../session/paths.js';
 import { createLogger } from '../../ui/logging/index.js';
 import { EXIT_CODES } from '../../utils/exitCodes.js';
-import { formatConnectionError, formatEarlyCloseError, formatParseError, formatTimeoutError, } from './errors.js';
+import { formatCancelledError, formatConnectionError, formatEarlyCloseError, formatParseError, formatTimeoutError, } from './errors.js';
 import { JSONLBuffer, parseJSONLFrame, toJSONLFrame } from './jsonl.js';
 import { createSocket } from './socket.js';
 import { validateResponseType, validateSessionId } from './validation.js';
-export { IPCError, IPCConnectionError, IPCTimeoutError, IPCParseError, IPCEarlyCloseError, } from './IPCError.js';
+export { IPCError, IPCCancelledError, IPCConnectionError, IPCTimeoutError, IPCParseError, IPCEarlyCloseError, } from './IPCError.js';
 const log = createLogger('client');
 /**
  * Send IPC request and wait for response.
@@ -25,6 +25,8 @@ const log = createLogger('client');
  * @param expectedType - Response type to validate, if any
  * @param timeoutMs - How long to wait for the response (default: IPC timeout)
  * @param socketPath - Daemon socket (default: the selected session's)
+ * @param signal - Closes the connection and rejects when aborted (the daemon
+ *   sees the client disconnect, e.g. an interrupted start is cancelled)
  * @returns The daemon's response
  * @throws CommandError (103) before connecting when the socket's session
  *   directory cannot be trusted (see {@link secureSessionDir}): a socket
@@ -33,19 +35,25 @@ const log = createLogger('client');
  *   needs write access to a directory of the chain, which the check has
  *   just found only the user has
  */
-export async function sendRequest(request, requestName, expectedType, timeoutMs = getIPCRequestTimeout(), socketPath = getDaemonSocketPath()) {
+export async function sendRequest(request, requestName, expectedType, timeoutMs = getIPCRequestTimeout(), socketPath = getDaemonSocketPath(), signal) {
     const untrusted = secureSessionDir(path.dirname(socketPath));
     if (untrusted) {
         const err = untrustedSessionDirError(untrusted);
         throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.SESSION_FILE_ERROR);
     }
     return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(formatCancelledError(requestName));
+            return;
+        }
         const buffer = new JSONLBuffer();
         let resolved = false;
+        let onAbort = () => { };
         const resolveOnce = (cleanup, error, response) => {
             if (resolved)
                 return;
             resolved = true;
+            signal?.removeEventListener('abort', onAbort);
             cleanup();
             if (error) {
                 reject(error);
@@ -91,6 +99,8 @@ export async function sendRequest(request, requestName, expectedType, timeoutMs
                 resolveOnce(cleanup, formatTimeoutError(requestName, timeoutMs));
             },
         });
+        onAbort = () => resolveOnce(cleanup, formatCancelledError(requestName));
+        signal?.addEventListener('abort', onAbort, { once: true });
     });
 }
 //# sourceMappingURL=index.js.map

package/dist/runtime/dom/actionEffects.d.ts

@@ -5,9 +5,13 @@
  * working on the result. Costs one page script sent before the action (not
  * waited for: CDP runs it before the action's own scripts) and one read
  * after it, plus a second look 300 ms later when nothing seemed to happen.
+ * While watching, a timer in bdg's world notes the stalls during which the
+ * page's tasks could not run ({@link STALL_WATCH_START_SCRIPT}); they do not
+ * count as quiet time when deciding whether the DOM kept changing.
  * Worst case, when the page does not answer (a navigation is pending, or a
  * long script runs), the snapshot is given up after {@link START_TIMEOUT_MS}
- * and each read after {@link READ_TIMEOUT_MS}.
+ * and each read after {@link READ_TIMEOUT_MS}, plus as long again, once per
+ * action, to ask whether the page ran a long task ({@link pageAnswer}).
  */
 import type { CDPConnection } from '../../connection/cdp.js';
 import type { ActionEffects, NewMessage, PageNavigation, PendingChanges, ShownElement, TriggeredRequest } from '../../ipc/protocol/domTypes.js';
@@ -20,10 +24,20 @@ export interface SeenMessage {
     element: string;
 }
 export type { NavigationEvents };
+/**
+ * A stall: a stretch during which the page's tasks could not run (a long
+ * task, or a renderer running the page's tasks late), as how long ago it
+ * began and ended at a read (ms, `[began, ended]`)
+ */
+export type StallAges = [number, number];
 /** Signs that the page was still working at a read (same document only) */
 export interface SettleSignals {
+    /** Page time of the read (ms, `performance.now()`) */
+    at?: number;
     /** How long ago each recent burst of structural DOM changes was (ms, newest last) */
     burstAges: number[];
+    /** Stalls up to the read, oldest first (when its bursts made them matter) */
+    stalls?: StallAges[];
     /** A loading indicator shown since the action began, described */
     loading: string | null;
 }
@@ -97,21 +111,43 @@ export declare function newMessages(before: SeenMessage[], after: SeenMessage[],
  * @returns Elements to report
  */
 export declare function shownElements(shown: ShownElement[], messages: NewMessage[]): ShownElement[];
+/**
+ * How long the page was quiet between two moments of a read: the time
+ * between them less the stalls in it, during which the page's tasks could
+ * not run, so it could not change the DOM either.
+ *
+ * @param fromAge - Earlier moment, as an age at the read (ms)
+ * @param toAge - Later moment, as an age at the read (ms)
+ * @param stalls - Stalls of the read (they do not overlap)
+ * @returns Quiet time (ms)
+ */
+export declare function quietMs(fromAge: number, toAge: number, stalls?: StallAges[]): number;
 /**
  * Whether a read's DOM looks busy, worth a second look: at least
  * {@link BUSY_BURSTS} bursts of structural changes within
- * {@link BUSY_WINDOW_MS}, the last within {@link BUSY_RECENT_MS}. Text-only
- * changes (clocks) and style changes (animations) are not bursts.
+ * {@link BUSY_WINDOW_MS}, and quiet for at most {@link BUSY_RECENT_MS} since
+ * the last ({@link quietMs}: stalls do not count). A single burst older than
+ * that counts when the page stalled for most of the time since, quiet for
+ * at most {@link LONE_BURST_QUIET_MS}: on a renderer running the page's
+ * timers late, a page's second step may not have come by the first read.
+ * Text-only changes (clocks) and style changes (animations) are not bursts.
  *
  * @param settle - Signals of the read
  * @returns True when the DOM may still be changing
  */
 export declare function domLooksBusy(settle: SettleSignals | undefined): boolean;
 /**
- * Whether the DOM kept changing during the second look: at least
- * {@link BUSY_BURSTS} new bursts within the time since the first read (a
- * render that ends in two commits, or a poller updating once a second, does
- * not count).
+ * Whether the DOM kept changing during the second look: at least one new
+ * burst since the first read, and no quiet gap longer than
+ * {@link BUSY_RECENT_MS} from the last burst the first read saw, through the
+ * new ones, to the second read. Stalls in a gap, during which the page's
+ * tasks could not run, are not quiet ({@link quietMs}): a page whose steps
+ * come 250 ms apart around a 200 ms long task, or whose timers a starved
+ * renderer runs 150 ms late, keeps changing. A page changing every 140 ms
+ * keeps changing; changes more than 150 ms apart while the page could run,
+ * a render that ended over 150 ms before the second read and a poller
+ * updating every 300 ms do not. A short render whose last commit came within
+ * 150 ms of the second read counts as changing.
  *
  * @param settle - Signals of the second read
  * @param sinceMs - Time since the first read
@@ -182,8 +218,11 @@ export interface ActionEffectsWatch {
 }
 /**
  * Start watching an action's effects: listen for main-frame navigations,
- * document statuses, requests and new windows, and send the page snapshot
- * without waiting for it.
+ * document statuses, requests and new windows, send the page snapshot
+ * without waiting for it, and start the stall watch in bdg's world. That
+ * creates bdg's world for the reads now, while the page is idle (created at
+ * the first read, it would wait for a page busy after the action and could
+ * leave the read no time to answer).
  *
  * @param cdp - CDP connection
  * @returns Watch to collect from after the action