browser-debugger-cli 0.8.0 → 0.10.0

package/dist/daemon/session/commandRegistry.js

@@ -1,16 +1,25 @@
-import { CDPConnectionError } from '../../connection/errors.js';
+import { CDPConnectionError, CDPProtocolError } from '../../connection/errors.js';
 import { PatternDetector } from '../patternDetector.js';
 import { createInteractionRunner } from './interactions.js';
+import { withTriggeredRequestCount } from './triggeredRequests.js';
 import { CommandError } from '../../errors/index.js';
+import { cdpCallError, formDiscoveryFailedError } from '../../errors/messages.js';
 import { evaluateScript, withBusyPageRecovery } from '../../runtime/dom/evalHelpers.js';
 import { inspectEventListeners } from '../../runtime/dom/eventListeners.js';
 import { FORM_DISCOVERY_SCRIPT, isRawFormData } from '../../runtime/dom/formDiscovery.js';
-import { fillElement, clickElement, pressKeyElement, scrollPage, waitForActionStability, } from '../../runtime/dom/formFillHelpers/index.js';
+import { fillElement, clickElement, pressKeyElement, scrollPage, withActionStability, } from '../../runtime/dom/formFillHelpers/index.js';
+import { exceptionSummary } from '../../runtime/dom/formFillHelpers/shared.js';
 import { submitForm } from '../../runtime/dom/formSubmitHelpers.js';
 import { evaluateInFrame, listFrames } from '../../runtime/dom/frames.js';
-import { resolveScriptTarget, withUserSelector } from '../../runtime/dom/targetNode.js';
+import { inspectElement } from '../../runtime/dom/inspect.js';
+import { inspectLayout } from '../../runtime/dom/layout.js';
+import { onScriptTarget } from '../../runtime/dom/targetNode.js';
+import { waitForCondition } from '../../runtime/dom/wait.js';
+import { emulatePage, pageAppearance } from '../../runtime/page/emulation.js';
+import { readDocumentReadyState } from '../../runtime/page/loadingState.js';
 import { navigatePage } from '../../runtime/page/navigation.js';
 import { skippedBodyReason } from '../../telemetry/network.js';
+import { sessionCommand } from '../../ui/messages/sessionCommand.js';
 import { EXIT_CODES } from '../../utils/exitCodes.js';
 import { filterDefined } from '../../utils/objects.js';
 import { VERSION } from '../../utils/version.js';
@@ -54,6 +63,8 @@ function mapNetworkRequestToPreview(req, withHeaders = false) {
     return filterDefined({
         requestId: req.requestId,
         timestamp: req.timestamp,
+        sentTime: req.sentTime,
+        navigationId: req.navigationId,
         method: req.method,
         url: req.url,
         status: req.status,
@@ -169,7 +180,7 @@ function findNetworkRequestOrThrow(store, id) {
         store.pendingNetworkRequests.get(id)?.request ??
         (webSocket && webSocketAsRequest(webSocket));
     if (!request) {
-        throw new CommandError(`Network request not found: ${id}`, { suggestion: 'List request ids with: bdg network list' }, EXIT_CODES.RESOURCE_NOT_FOUND);
+        throw new CommandError(`Network request not found: ${id}`, { suggestion: `List request ids with: ${sessionCommand('bdg network list')}` }, EXIT_CODES.RESOURCE_NOT_FOUND);
     }
     return request;
 }
@@ -183,13 +194,13 @@ function findNetworkRequestOrThrow(store, id) {
  */
 function findConsoleMessageOrThrow(messages, indexStr) {
     if (!/^\d+$/.test(indexStr)) {
-        throw new CommandError(`Invalid console message index: ${indexStr}`, { suggestion: 'Use a 0-based index from: bdg console --list' }, EXIT_CODES.INVALID_ARGUMENTS);
+        throw new CommandError(`Invalid console message index: ${indexStr}`, { suggestion: `Use a 0-based index from: ${sessionCommand('bdg console --list')}` }, EXIT_CODES.INVALID_ARGUMENTS);
     }
     const index = parseInt(indexStr, 10);
     if (index >= messages.length) {
         throw new CommandError(messages.length === 0
             ? `Console message not found at index: ${indexStr} (no messages captured yet)`
-            : `Console message not found at index: ${indexStr} (available: 0-${messages.length - 1})`, { suggestion: 'List messages with: bdg console --list' }, EXIT_CODES.RESOURCE_NOT_FOUND);
+            : `Console message not found at index: ${indexStr} (available: 0-${messages.length - 1})`, { suggestion: `List messages with: ${sessionCommand('bdg console --list')}` }, EXIT_CODES.RESOURCE_NOT_FOUND);
     }
     const message = messages[index];
     if (!message) {
@@ -252,9 +263,45 @@ function pageWebSocketUrl(store) {
         throw new CDPConnectionError('No page target');
     return url;
 }
-export function createCommandRegistry(store) {
+/** Chrome's "server error" code, used for failures on the page's state (a missing node, a bad id…) */
+const CDP_SERVER_ERROR = -32000;
+/**
+ * A `bdg cdp` failure that is the caller's: wrong parameters (81), or an
+ * id of a node, target or frame that does not exist (83). Other failures
+ * (internal errors, a detached page) stay software errors.
+ *
+ * @param method - CDP method
+ * @param error - What the call threw
+ * @returns The error to report, or undefined to keep the original
+ */
+function callerError(method, error) {
+    if (!(error instanceof CDPProtocolError))
+        return undefined;
+    const err = cdpCallError(method, error.message);
+    if (error.isRequestError()) {
+        return new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    if (error.code === CDP_SERVER_ERROR && err.notFound) {
+        return new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.RESOURCE_NOT_FOUND);
+    }
+    if (error.code === CDP_SERVER_ERROR &&
+        /must be specified|invalid|expected|missing/i.test(error.message)) {
+        return new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    return undefined;
+}
+/**
+ * The handlers of the session commands.
+ *
+ * @param store - Telemetry of the session
+ * @param emulation - The session's page emulation
+ * @returns Command registry
+ */
+export function createCommandRegistry(store, emulation) {
     const patternDetector = new PatternDetector();
     const interact = createInteractionRunner(store);
+    /** Frame id behind each index of the last `dom frames` listing */
+    let listedFrameIds;
     return {
         session_peek: async (_cdp, params) => {
             const lastN = calculateLastN(params.lastN);
@@ -304,7 +351,7 @@ export function createCommandRegistry(store) {
             }
             return Promise.reject(new Error(`Unknown itemType: ${String(params.itemType)}. Expected 'network' or 'console'.`));
         },
-        session_status: async (_cdp, _params) => {
+        session_status: async (cdp, _params) => {
             const duration = Date.now() - store.sessionStartTime;
             const lastNetworkRequest = store.networkRequests[store.networkRequests.length - 1];
             const lastConsoleMessage = store.consoleMessages[store.consoleMessages.length - 1];
@@ -314,6 +361,7 @@ export function createCommandRegistry(store) {
                 target: {
                     url: store.targetInfo?.url ?? '',
                     title: store.targetInfo?.title ?? '',
+                    ...(await pageAppearance(cdp)),
                 },
                 activeTelemetry: store.activeTelemetry,
                 activity: filterDefined({
@@ -324,7 +372,7 @@ export function createCommandRegistry(store) {
                 }),
                 navigationId: store.getCurrentNavigationId?.() ?? 0,
             };
-            return Promise.resolve(result);
+            return result;
         },
         session_har_data: async (_cdp, _params) => {
             return Promise.resolve({
@@ -342,12 +390,18 @@ export function createCommandRegistry(store) {
             return Promise.resolve({
                 url: targetRequest.url,
                 requestId: targetRequest.requestId,
+                method: targetRequest.method,
+                ...(targetRequest.status !== undefined && { status: targetRequest.status }),
+                ...(targetRequest.statusText && { statusText: targetRequest.statusText }),
+                ...(targetRequest.errorText && { errorText: targetRequest.errorText }),
                 requestHeaders,
                 responseHeaders,
             });
         },
         cdp_call: async (cdp, params) => {
-            const result = await withBusyPageRecovery(cdp, cdp.send(params.method, params.params ?? {}));
+            const result = await withBusyPageRecovery(cdp, cdp.send(params.method, params.params ?? {}).catch((error) => {
+                throw callerError(params.method, error) ?? error;
+            }));
             const detectionResult = patternDetector.trackCommand(params.method);
             let hint;
             if (detectionResult.shouldShow && detectionResult.pattern) {
@@ -363,68 +417,57 @@ export function createCommandRegistry(store) {
         },
         dom_eval: async (cdp, params) => params.frame === undefined
             ? evaluateScript(cdp, params.script)
-            : evaluateInFrame(cdp, pageWebSocketUrl(store), params.script, params.frame),
-        dom_frames: async (cdp) => ({ frames: await listFrames(cdp, pageWebSocketUrl(store)) }),
-        dom_fill: async (cdp, params) => interact(cdp, async () => {
-            const target = await resolveScriptTarget(cdp, params);
-            const fillOptions = filterDefined({
-                index: target.index,
-                blur: params.blur,
-                cwd: params.cwd,
-            });
-            const result = withUserSelector(await fillElement(cdp, target.selector, params.value, fillOptions), params.selector);
-            if (result.success && params.wait !== false)
-                await waitForActionStability(cdp);
-            return result;
-        }),
-        dom_click: async (cdp, params) => interact(cdp, async () => {
-            const target = await resolveScriptTarget(cdp, params);
-            const clickOptions = filterDefined({ index: target.index, action: params.action });
-            const result = withUserSelector(await clickElement(cdp, target.selector, clickOptions), params.selector);
-            if (result.success && params.wait !== false)
-                await waitForActionStability(cdp);
-            return result;
+            : evaluateInFrame(cdp, pageWebSocketUrl(store), params.script, params.frame, listedFrameIds),
+        dom_frames: async (cdp) => {
+            const { frames, frameIds } = await listFrames(cdp, pageWebSocketUrl(store));
+            listedFrameIds = frameIds;
+            return { frames };
+        },
+        dom_fill: async (cdp, params) => interact(cdp, async () => onScriptTarget(cdp, params, (target) => withActionStability(cdp, () => fillElement(target.cdp, target.selector, params.value, filterDefined({ index: target.index, blur: params.blur, cwd: params.cwd })), params.wait !== false))),
+        dom_click: async (cdp, params) => interact(cdp, async () => onScriptTarget(cdp, params, (target) => withActionStability(cdp, () => clickElement(target.cdp, target.selector, filterDefined({
+            index: target.index,
+            action: params.action,
+            strict: params.strict,
+        })), params.wait !== false)), {
+            detectNoEffect: params.wait !== false && params.action !== 'hover' && params.action !== 'right',
+            reportShown: params.action === 'hover',
+            detectUnsettled: params.wait !== false && params.action !== 'hover',
         }),
-        dom_submit: async (cdp, params) => interact(cdp, async () => {
-            const target = await resolveScriptTarget(cdp, params);
-            const submitOptions = filterDefined({
+        dom_submit: async (cdp, params) => withTriggeredRequestCount(await interact(cdp, async () => onScriptTarget(cdp, params, (target) => submitForm(target.cdp, target.selector, {
+            ...filterDefined({
                 index: target.index,
                 waitNavigation: params.waitNavigation,
                 waitNetwork: params.waitNetwork,
                 timeout: params.timeout,
-            });
-            return withUserSelector(await submitForm(cdp, target.selector, submitOptions), params.selector);
-        }),
-        dom_press_key: async (cdp, params) => interact(cdp, async () => {
-            const target = await resolveScriptTarget(cdp, params);
-            const pressKeyOptions = filterDefined({
-                index: target.index,
-                times: params.times,
-                modifiers: params.modifiers,
-            });
-            const result = withUserSelector(await pressKeyElement(cdp, target.selector, params.key, pressKeyOptions), params.selector);
-            if (result.success && params.wait !== false)
-                await waitForActionStability(cdp);
-            return result;
-        }),
-        dom_scroll: async (cdp, params) => interact(cdp, async () => {
-            const target = await resolveScriptTarget(cdp, params);
-            const scrollOptions = filterDefined({
-                index: target.index,
-                down: params.down,
-                up: params.up,
-                left: params.left,
-                right: params.right,
-                top: params.top,
-                bottom: params.bottom,
-            });
-            const result = withUserSelector(await scrollPage(cdp, target.selector || undefined, scrollOptions), params.selector);
-            if (result.success && params.wait !== false)
-                await waitForActionStability(cdp);
-            return result;
-        }),
+            }),
+            pendingRequests: () => store.pendingNetworkRequests.values(),
+        })), { detectNoEffect: params.waitNetwork !== 0 || params.waitNavigation === true })),
+        dom_press_key: async (cdp, params) => interact(cdp, async () => onScriptTarget(cdp, params, (target) => withActionStability(cdp, () => pressKeyElement(target.cdp, target.selector, params.key, filterDefined({
+            index: target.index,
+            times: params.times,
+            modifiers: params.modifiers,
+        })), params.wait !== false)), { reportShown: true, detectUnsettled: params.wait !== false }),
+        dom_scroll: async (cdp, params) => interact(cdp, async () => onScriptTarget(cdp, params, (target) => withActionStability(cdp, () => scrollPage(target.cdp, target.selector || undefined, filterDefined({
+            index: target.index,
+            down: params.down,
+            up: params.up,
+            left: params.left,
+            right: params.right,
+            top: params.top,
+            bottom: params.bottom,
+        })), params.wait !== false))),
         dom_listeners: async (cdp, params) => withBusyPageRecovery(cdp, inspectEventListeners(cdp, params)),
-        page_navigate: async (cdp, params) => interact(cdp, () => navigatePage(cdp, params.action, filterDefined({ url: params.url, wait: params.wait }))),
+        dom_layout: async (cdp, params) => withBusyPageRecovery(cdp, inspectLayout(cdp, params)),
+        dom_inspect: async (cdp, params) => withBusyPageRecovery(cdp, inspectElement(cdp, params)),
+        dom_wait: async (cdp, params) => waitForCondition(cdp, params),
+        page_navigate: async (cdp, params) => interact(cdp, () => navigatePage(cdp, params.action, {
+            ...filterDefined({ url: params.url, wait: params.wait }),
+            pendingRequests: () => store.pendingNetworkRequests.values(),
+        }), { reportRequests: false, reportEffects: false }),
+        page_emulate: async (cdp, params) => {
+            const emulated = await emulatePage(cdp, emulation.get(), params, emulation.set);
+            return { emulated, ...(await pageAppearance(cdp)) };
+        },
         dom_form_discover: async (cdp) => {
             const response = await withBusyPageRecovery(cdp, cdp.send('Runtime.evaluate', {
                 expression: FORM_DISCOVERY_SCRIPT,
@@ -432,7 +475,10 @@ export function createCommandRegistry(store) {
             }));
             const cdpResponse = response;
             if (cdpResponse.exceptionDetails) {
-                throw new Error(`Form discovery failed: ${cdpResponse.exceptionDetails.text}`);
+                const readyState = await readDocumentReadyState(cdp);
+                const loading = readyState !== undefined && readyState !== 'complete';
+                const err = formDiscoveryFailedError(exceptionSummary(cdpResponse.exceptionDetails), readyState);
+                throw new CommandError(err.message, { suggestion: err.suggestion }, loading ? EXIT_CODES.RESOURCE_NOT_FOUND : EXIT_CODES.SOFTWARE_ERROR);
             }
             const rawData = cdpResponse.result?.value;
             if (!isRawFormData(rawData)) {

package/dist/daemon/session/interactions.d.ts

@@ -1,14 +1,48 @@
 /**
  * Running page interactions (fill, click, submit, pressKey, scroll) one at a
- * time, reporting the dialogs they caused.
+ * time, reporting the dialogs, network requests and page changes they caused,
+ * and whether the page was still changing when they returned.
  */
 import type { TelemetryStore } from './TelemetryStore.js';
 import type { CDPConnection } from '../../connection/cdp.js';
-import type { DialogInfo } from '../../ipc/protocol/domTypes.js';
-/** Runs one interaction after the previous one finished */
-export type InteractionRunner = <T extends object>(cdp: CDPConnection, action: () => Promise<T>) => Promise<T & {
+import type { ActionEffects, DialogInfo, TriggeredRequest } from '../../ipc/protocol/domTypes.js';
+/** What an interaction caused besides its own result */
+interface InteractionReport extends ActionEffects {
     dialogs?: DialogInfo[];
-}>;
+    triggeredRequests?: TriggeredRequest[];
+    triggeredRequestsOmitted?: number;
+}
+/** How an interaction is reported */
+export interface InteractionOptions {
+    /**
+     * List the network requests it triggered (default true; off for page
+     * navigation, whose requests are the whole page load)
+     */
+    reportRequests?: boolean;
+    /**
+     * Report navigation and new messages (default true; off for page
+     * navigation, which reports its own page)
+     */
+    reportEffects?: boolean;
+    /**
+     * Say when it had no visible effect (`effect: "none"`): only for actions
+     * whose effect shows in the DOM (click, submit) and that waited for it
+     */
+    detectNoEffect?: boolean;
+    /**
+     * List the elements it showed (`shown`): for hover and key presses, whose
+     * effect is often a menu, tooltip or new item rather than a message
+     */
+    reportShown?: boolean;
+    /**
+     * Say when the page was still changing as it returned (`settled: false`
+     * with `pending`): for actions that start app transitions (click, key
+     * press) and waited for the network
+     */
+    detectUnsettled?: boolean;
+}
+/** Runs one interaction after the previous one finished */
+export type InteractionRunner = <T extends object>(cdp: CDPConnection, action: () => Promise<T>, options?: InteractionOptions) => Promise<T & InteractionReport>;
 /**
  * Create the runner for a session's interactions.
  *
@@ -16,12 +50,17 @@ export type InteractionRunner = <T extends object>(cdp: CDPConnection, action: (
  * commands would interleave keystrokes into each other's field, so they are
  * queued. After each one, the bound target (`window.__bdgTarget`) is removed
  * from the page (without waiting: during a pending navigation that takes until
- * the new page commits), and the dialogs it opened are added to its result.
- * Dialogs are attributed by time: one opened by a page timer or a navigation
- * started earlier is reported by whichever interaction is running then.
+ * the new page commits), and the dialogs it opened, what it changed on the
+ * page (see {@link watchActionEffects}) and the network requests it
+ * triggered (see {@link watchTriggeredRequests}) are added to its result,
+ * and, when asked, what the page was still working on (see
+ * {@link pendingChanges}). They are attributed by time: a dialog or request
+ * started by a page timer or a navigation started earlier is reported by
+ * whichever interaction is running then.
  *
- * @param store - Session store recording accepted dialogs
+ * @param store - Session store recording accepted dialogs and network requests
  * @returns Interaction runner
  */
 export declare function createInteractionRunner(store: TelemetryStore): InteractionRunner;
+export {};
 //# sourceMappingURL=interactions.d.ts.map

package/dist/daemon/session/interactions.js

@@ -1,12 +1,23 @@
 /**
  * Running page interactions (fill, click, submit, pressKey, scroll) one at a
- * time, reporting the dialogs they caused.
+ * time, reporting the dialogs, network requests and page changes they caused,
+ * and whether the page was still changing when they returned.
  */
+import { pendingChanges, watchActionEffects } from '../../runtime/dom/actionEffects.js';
+import { UNBIND_TARGET_SCRIPT } from '../../runtime/dom/targetNode.js';
 import { createLogger } from '../../ui/logging/index.js';
 import { getErrorMessage } from '../../utils/errors.js';
+import { watchTriggeredRequests } from './triggeredRequests.js';
 const log = createLogger('dom');
-/** Removes the node bound for index-based commands from the page */
-const UNBIND_TARGET_SCRIPT = 'delete window.__bdgTarget';
+/**
+ * Whether an action result is a success (results without a `success` flag are).
+ *
+ * @param result - Action result
+ * @returns False for `{ success: false }`
+ */
+function succeeded(result) {
+    return !('success' in result) || result.success !== false;
+}
 /**
  * Create the runner for a session's interactions.
  *
@@ -14,24 +25,50 @@ const UNBIND_TARGET_SCRIPT = 'delete window.__bdgTarget';
  * commands would interleave keystrokes into each other's field, so they are
  * queued. After each one, the bound target (`window.__bdgTarget`) is removed
  * from the page (without waiting: during a pending navigation that takes until
- * the new page commits), and the dialogs it opened are added to its result.
- * Dialogs are attributed by time: one opened by a page timer or a navigation
- * started earlier is reported by whichever interaction is running then.
+ * the new page commits), and the dialogs it opened, what it changed on the
+ * page (see {@link watchActionEffects}) and the network requests it
+ * triggered (see {@link watchTriggeredRequests}) are added to its result,
+ * and, when asked, what the page was still working on (see
+ * {@link pendingChanges}). They are attributed by time: a dialog or request
+ * started by a page timer or a navigation started earlier is reported by
+ * whichever interaction is running then.
  *
- * @param store - Session store recording accepted dialogs
+ * @param store - Session store recording accepted dialogs and network requests
  * @returns Interaction runner
  */
 export function createInteractionRunner(store) {
     let queue = Promise.resolve();
-    return (cdp, action) => {
+    return (cdp, action, options = {}) => {
         const run = queue.then(async () => {
             const firstDialog = store.dialogs.length;
+            const collectRequests = options.reportRequests === false ? undefined : watchTriggeredRequests(store);
+            const effects = options.reportEffects === false ? undefined : watchActionEffects(cdp);
             try {
                 const result = await action();
                 const dialogs = store.dialogs.slice(firstDialog);
-                return dialogs.length > 0 ? { ...result, dialogs } : result;
+                if (!succeeded(result))
+                    return { ...result, ...(dialogs.length > 0 && { dialogs }) };
+                const collected = await effects?.collect({
+                    dialogs: dialogs.length,
+                    detectNoEffect: options.detectNoEffect === true,
+                    reportShown: options.reportShown === true,
+                    detectUnsettled: options.detectUnsettled === true,
+                });
+                const { work, ...changes } = collected ?? {};
+                const requests = collectRequests?.();
+                const pending = options.detectUnsettled && work
+                    ? pendingChanges(work, requests?.triggeredRequests)
+                    : undefined;
+                return {
+                    ...result,
+                    ...(dialogs.length > 0 && { dialogs }),
+                    ...changes,
+                    ...(pending && { settled: false, pending }),
+                    ...requests,
+                };
             }
             finally {
+                effects?.dispose();
                 void cdp
                     .send('Runtime.evaluate', { expression: UNBIND_TARGET_SCRIPT })
                     .catch((error) => log.debug(`Target not unbound: ${getErrorMessage(error)}`));

package/dist/daemon/session/triggeredRequests.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Network requests an interaction triggered, read from the session's network
+ * telemetry (no CDP listeners of its own).
+ */
+import type { TelemetryStore } from './TelemetryStore.js';
+import type { TriggeredRequest } from '../../ipc/protocol/domTypes.js';
+import type { NetworkRequest } from '../../types.js';
+/**
+ * Requests listed in a result (a click that loads a page triggers its whole
+ * load); notable ones ({@link isNotableRequest}) are kept before assets
+ */
+export declare const MAX_TRIGGERED_REQUESTS = 50;
+/** Requests started since the watch began: the first ones, and how many more there were */
+export interface CollectedRequests {
+    triggeredRequests: TriggeredRequest[];
+    triggeredRequestsOmitted?: number;
+}
+/** Lists the requests started since the watch began */
+export type TriggeredRequestsCollector = () => CollectedRequests | undefined;
+/**
+ * Start attributing requests to an interaction.
+ *
+ * Requests are attributed by time: every request (and WebSocket connection)
+ * bdg saw start between this call and the collector's call belongs to the
+ * interaction, including one a page timer or poller happened to start
+ * meanwhile. Collecting adds no wait: requests
+ * still running then are reported as pending.
+ *
+ * @param store - Session store holding the network telemetry
+ * @returns Collector (at most {@link MAX_TRIGGERED_REQUESTS} requests, plus how
+ *   many more there were); it returns undefined when network telemetry is off
+ */
+export declare function watchTriggeredRequests(store: TelemetryStore): TriggeredRequestsCollector;
+/**
+ * At most `limit` requests, notable ones first (pages, API calls, sockets,
+ * failures), then assets, still in start order.
+ *
+ * @param requests - Requests in start order
+ * @param limit - How many to keep
+ * @returns Kept requests, in start order
+ */
+export declare function keepNotableFirst(requests: TriggeredRequest[], limit: number): TriggeredRequest[];
+/**
+ * Count a submission's network requests as its request list does (the
+ * submit watcher counts every request id CDP reported until the wait ended:
+ * `data:` URLs and preflights included, a redirect chain once), so
+ * `networkRequests`, the listed requests and JSON agree. Without network
+ * telemetry the watcher's count stays.
+ *
+ * @param result - Submit result with the requests it triggered
+ * @returns The result, `networkRequests` matching `triggeredRequests`
+ */
+export declare function withTriggeredRequestCount<T extends {
+    networkRequests?: number | undefined;
+    triggeredRequests?: TriggeredRequest[] | undefined;
+    triggeredRequestsOmitted?: number | undefined;
+}>(result: T): T;
+/**
+ * Summarize a captured request.
+ *
+ * @param request - Captured request
+ * @param inFlight - Whether it was still in flight (a request with a response
+ *   is then still loading its body: a stream, a slow download)
+ * @returns Triggered request entry
+ */
+export declare function toTriggeredRequest(request: NetworkRequest, inFlight?: boolean): TriggeredRequest;
+//# sourceMappingURL=triggeredRequests.d.ts.map