browser-debugger-cli 0.7.2 → 0.9.0

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

@@ -4,7 +4,8 @@
  * Types for handshake, start session, and stop session operations.
  */
 import type { IPCErrorCode } from './errors.js';
-import type { TelemetryType } from '../../types.js';
+import type { PageLoadingState } from '../protocol/commands.js';
+import type { ColorScheme, TelemetryType, ViewportSize } from '../../types.js';
 /**
  * Base message interface with type and session ID.
  */
@@ -27,7 +28,12 @@ export interface HandshakeResponse extends IPCMessage {
     message?: string;
 }
 /**
- * Session start options.
+ * Canonical session options — single source of truth for session knobs.
+ *
+ * The CLI and the daemon IPC request (`StartSessionRequest`) both reference
+ * this shape. Adding a new
+ * session option means editing this interface + the Commander flag — nothing
+ * else.
  */
 export interface SessionOptions {
     /** CDP port to use. */
@@ -48,39 +54,28 @@ export interface SessionOptions {
     chromeWsUrl?: string;
     /** Custom Chrome flags (e.g., ['--ignore-certificate-errors']). */
     chromeFlags?: string[];
+    /** Viewport size the page is emulated at (`--viewport`). */
+    viewport?: ViewportSize;
+    /** `prefers-color-scheme` the page is emulated with (`--color-scheme`). */
+    colorScheme?: ColorScheme;
 }
 /**
  * Start session request (client → daemon).
+ *
+ * Derived from `SessionOptions` so a new option flows end-to-end without
+ * redeclaring fields here.
  */
-export interface StartSessionRequest extends IPCMessage {
+export interface StartSessionRequest extends IPCMessage, SessionOptions {
     type: 'start_session_request';
     /** Target URL to navigate to. */
     url: string;
-    /** CDP port to use. */
-    port?: number;
-    /** Auto-stop timeout in seconds. */
-    timeout?: number;
-    /** Telemetry collectors to enable. */
-    telemetry?: TelemetryType[];
-    /** Include all data (disable filtering). */
-    includeAll?: boolean;
-    /** Custom Chrome user data directory. */
-    userDataDir?: string;
-    /** Max response body size in MB. */
-    maxBodySize?: number;
-    /** Launch Chrome in headless mode. */
-    headless?: boolean;
-    /** Connect to existing Chrome instance. */
-    chromeWsUrl?: string;
-    /** Custom Chrome flags (e.g., ['--ignore-certificate-errors']). */
-    chromeFlags?: string[];
 }
 /**
  * Start session response data.
  */
 export interface StartSessionResponseData {
-    /** Worker process ID. */
-    workerPid: number;
+    /** Daemon process ID (the daemon hosts the session). */
+    daemonPid: number;
     /** Chrome process ID. */
     chromePid: number;
     /** CDP port. */
@@ -89,6 +84,14 @@ export interface StartSessionResponseData {
     targetUrl: string;
     /** Target page title. */
     targetTitle?: string;
+    /** HTTP status of the page's main document, when known. */
+    documentStatus?: number;
+    /** The page had not finished loading when the start returned. */
+    loading?: PageLoadingState;
+    /** True if a stale session was auto-recovered before this one started. */
+    recovered?: boolean;
+    /** Target URL or ws URL of the stale session that was recovered, if recorded. */
+    previousTarget?: string;
 }
 /**
  * Start session response (daemon → client).
@@ -99,6 +102,8 @@ export interface StartSessionResponse extends IPCMessage {
     data?: StartSessionResponseData;
     message?: string;
     errorCode?: IPCErrorCode;
+    /** Exit code when the failure has a more specific one than its error code */
+    exitCode?: number;
     existingSession?: {
         pid: number;
         targetUrl?: string;

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

@@ -5,7 +5,7 @@
  */
 import type { IPCMessage } from './lifecycle.js';
 import type { PageState, SessionActivity } from './types.js';
-import type { NetworkRequest, TelemetryType } from '../../types.js';
+import type { ColorScheme, NetworkRequest, TelemetryType, ViewportSize } from '../../types.js';
 /**
  * Status request (client → daemon).
  */
@@ -22,7 +22,7 @@ export interface StatusResponseData {
     daemonStartTime: number;
     /** Unix socket path. */
     socketPath: string;
-    /** Worker process ID (if session active). */
+    /** Session process ID, i.e. the daemon (if session active). */
     sessionPid?: number;
     /** Session metadata (if session active). */
     sessionMetadata?: {
@@ -33,6 +33,12 @@ export interface StatusResponseData {
         targetId?: string;
         webSocketDebuggerUrl?: string;
         activeTelemetry?: TelemetryType[];
+        /** When `--timeout` stops the session (epoch ms) */
+        autoStopAt?: number;
+        /** Viewport the page is emulated at (`--viewport`) */
+        viewport?: ViewportSize;
+        /** `prefers-color-scheme` the page is emulated with (`--color-scheme`) */
+        colorScheme?: ColorScheme;
     };
     /** Session activity metrics. */
     activity?: SessionActivity;
@@ -40,6 +46,13 @@ export interface StatusResponseData {
     pageState?: PageState;
     /** Current navigation counter (increments on each page navigation). */
     navigationId?: number;
+    /** Set while the session is shutting down */
+    ending?: boolean;
+    /** Set while `bdg <url>` is starting the session */
+    starting?: {
+        url: string;
+        since: number;
+    };
 }
 /**
  * Status response (daemon → client).
@@ -57,12 +70,16 @@ export interface PeekRequest extends IPCMessage {
     type: 'peek_request';
     /** Number of recent items to return. 0 = all. */
     lastN?: number;
+    /** Return items of one kind only. */
+    only?: 'network' | 'console';
+    /** Include request/response headers in network items. */
+    withHeaders?: boolean;
 }
 /**
  * Peek response data.
  */
 export interface PeekResponseData {
-    /** Worker process ID. */
+    /** Session process ID (the daemon). */
     sessionPid: number;
     /** Preview of collected data. */
     preview: {
@@ -75,10 +92,14 @@ export interface PeekResponseData {
             title: string;
         };
         data: {
-            dom?: unknown;
             network?: unknown[];
             console?: unknown[];
         };
+        totals: {
+            network: number;
+            console: number;
+        };
+        currentNavigationId?: number;
         partial?: boolean;
     };
 }
@@ -101,7 +122,7 @@ export interface HARDataRequest extends IPCMessage {
  * HAR data response data.
  */
 export interface HARDataResponseData {
-    /** Worker process ID. */
+    /** Session process ID (the daemon). */
     sessionPid: number;
     /** Network requests for HAR export. */
     requests: NetworkRequest[];

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

@@ -1,8 +1,9 @@
 /**
  * Shared Session Types
  *
- * Common types used across session messages and worker commands.
+ * Common types used across session messages and session commands.
  */
+import type { ColorScheme, ViewportSize } from '../../types.js';
 /**
  * Session activity metrics.
  */
@@ -24,5 +25,9 @@ export interface PageState {
     url: string;
     /** Current page title. */
     title: string;
+    /** Layout viewport without scrollbars (left out when the page did not answer in time). */
+    viewport?: ViewportSize;
+    /** `prefers-color-scheme` the page sees (left out when the page did not answer in time). */
+    colorScheme?: ColorScheme;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/ipc/session/types.js

@@ -1,7 +1,7 @@
 /**
  * Shared Session Types
  *
- * Common types used across session messages and worker commands.
+ * Common types used across session messages and session commands.
  */
 export {};
 //# sourceMappingURL=types.js.map

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

@@ -39,7 +39,7 @@ export declare class IPCConnectionError extends IPCError {
  *
  * @example
  * ```typescript
- * throw new IPCTimeoutError('worker_status', 5000);
+ * throw new IPCTimeoutError('session_status', 5000);
  * ```
  */
 export declare class IPCTimeoutError extends IPCError {
@@ -55,7 +55,7 @@ export declare class IPCTimeoutError extends IPCError {
  *
  * @example
  * ```typescript
- * throw new IPCParseError('worker_peek', 'Unexpected token in JSON');
+ * throw new IPCParseError('session_peek', 'Unexpected token in JSON');
  * ```
  */
 export declare class IPCParseError extends IPCError {
@@ -71,7 +71,7 @@ export declare class IPCParseError extends IPCError {
  *
  * @example
  * ```typescript
- * throw new IPCEarlyCloseError('worker_peek');
+ * throw new IPCEarlyCloseError('session_peek');
  * ```
  */
 export declare class IPCEarlyCloseError extends IPCError {

package/dist/ipc/transport/IPCError.js

@@ -53,7 +53,7 @@ export class IPCConnectionError extends IPCError {
  *
  * @example
  * ```typescript
- * throw new IPCTimeoutError('worker_status', 5000);
+ * throw new IPCTimeoutError('session_status', 5000);
  * ```
  */
 export class IPCTimeoutError extends IPCError {
@@ -73,7 +73,7 @@ export class IPCTimeoutError extends IPCError {
  *
  * @example
  * ```typescript
- * throw new IPCParseError('worker_peek', 'Unexpected token in JSON');
+ * throw new IPCParseError('session_peek', 'Unexpected token in JSON');
  * ```
  */
 export class IPCParseError extends IPCError {
@@ -95,7 +95,7 @@ export class IPCParseError extends IPCError {
  *
  * @example
  * ```typescript
- * throw new IPCEarlyCloseError('worker_peek');
+ * throw new IPCEarlyCloseError('session_peek');
  * ```
  */
 export class IPCEarlyCloseError extends IPCError {

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

@@ -11,6 +11,13 @@ type WithTypeAndSession = {
 /**
  * Send IPC request and wait for response.
  * Handles connection, JSONL protocol, validation, timeout, and cleanup.
+ *
+ * @param request - Request to send
+ * @param requestName - Name used in errors and logs
+ * @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)
+ * @returns The daemon's response
  */
-export declare function sendRequest<TRequest extends WithTypeAndSession, TResponse extends WithTypeAndSession>(request: TRequest, requestName: string, expectedType?: string): Promise<TResponse>;
+export declare function sendRequest<TRequest extends WithTypeAndSession, TResponse extends WithTypeAndSession>(request: TRequest, requestName: string, expectedType?: string, timeoutMs?: number, socketPath?: string): Promise<TResponse>;
 //# sourceMappingURL=index.d.ts.map

package/dist/ipc/transport/index.js

@@ -15,10 +15,15 @@ const log = createLogger('client');
 /**
  * Send IPC request and wait for response.
  * Handles connection, JSONL protocol, validation, timeout, and cleanup.
+ *
+ * @param request - Request to send
+ * @param requestName - Name used in errors and logs
+ * @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)
+ * @returns The daemon's response
  */
-export async function sendRequest(request, requestName, expectedType) {
-    const socketPath = getDaemonSocketPath();
-    const timeoutMs = getIPCRequestTimeout();
+export async function sendRequest(request, requestName, expectedType, timeoutMs = getIPCRequestTimeout(), socketPath = getDaemonSocketPath()) {
     return new Promise((resolve, reject) => {
         const buffer = new JSONLBuffer();
         let resolved = false;

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

@@ -16,20 +16,46 @@ export declare class JSONLBufferOverflowError extends Error {
  * that send unbounded data without newlines.
  */
 export declare class JSONLBuffer {
-    private buffer;
+    private readonly maxSize;
+    /**
+     * @param maxSize - Longest unfinished line accepted (default {@link MAX_JSONL_BUFFER_SIZE})
+     */
+    constructor(maxSize?: number);
+    /** Chunks of the line still being received (joined once it is complete) */
+    private parts;
+    private partsLength;
     /**
      * Process incoming chunk and extract complete JSONL frames.
      *
+     * Only the new chunk is searched for line ends, and an unfinished line is
+     * kept as a list of chunks, so a large response costs linear time (joining
+     * and re-splitting the whole buffer on every chunk made multi-megabyte
+     * responses, like a big HAR, quadratic).
+     *
      * @param chunk - Incoming data chunk
      * @returns Array of complete JSONL frames (lines)
-     * @throws JSONLBufferOverflowError if buffer exceeds MAX_JSONL_BUFFER_SIZE
+     * @throws JSONLBufferOverflowError if an unfinished line exceeds the maximum size
      */
     process(chunk: string): string[];
+    /**
+     * Reject a message longer than the limit.
+     *
+     * @param length - Length of the message (so far)
+     * @throws JSONLBufferOverflowError above the maximum size
+     */
+    private assertWithinLimit;
     clear(): void;
     getBuffer(): string;
 }
 /**
  * Parse JSONL frame into typed object.
+ *
+ * Strings with a lone UTF-16 surrogate (page text cut inside an emoji, or a
+ * page logging `"\\ud83d"`) get U+FFFD in its place: printed back as JSON
+ * they would be an escape sequence that strict parsers such as jq reject.
+ *
+ * @param line - One JSON document
+ * @returns Parsed value
  */
 export declare function parseJSONLFrame<T>(line: string): T;
 /**

package/dist/ipc/transport/jsonl.js

@@ -21,36 +21,83 @@ export class JSONLBufferOverflowError extends Error {
  * that send unbounded data without newlines.
  */
 export class JSONLBuffer {
-    buffer = '';
+    maxSize;
+    /**
+     * @param maxSize - Longest unfinished line accepted (default {@link MAX_JSONL_BUFFER_SIZE})
+     */
+    constructor(maxSize = MAX_JSONL_BUFFER_SIZE) {
+        this.maxSize = maxSize;
+    }
+    /** Chunks of the line still being received (joined once it is complete) */
+    parts = [];
+    partsLength = 0;
     /**
      * Process incoming chunk and extract complete JSONL frames.
      *
+     * Only the new chunk is searched for line ends, and an unfinished line is
+     * kept as a list of chunks, so a large response costs linear time (joining
+     * and re-splitting the whole buffer on every chunk made multi-megabyte
+     * responses, like a big HAR, quadratic).
+     *
      * @param chunk - Incoming data chunk
      * @returns Array of complete JSONL frames (lines)
-     * @throws JSONLBufferOverflowError if buffer exceeds MAX_JSONL_BUFFER_SIZE
+     * @throws JSONLBufferOverflowError if an unfinished line exceeds the maximum size
      */
     process(chunk) {
-        this.buffer += chunk;
-        if (this.buffer.length > MAX_JSONL_BUFFER_SIZE) {
-            throw new JSONLBufferOverflowError(this.buffer.length, MAX_JSONL_BUFFER_SIZE);
+        const lines = [];
+        let start = 0;
+        for (let end = chunk.indexOf('\n'); end !== -1; end = chunk.indexOf('\n', start)) {
+            this.assertWithinLimit(this.partsLength + end - start);
+            this.parts.push(chunk.slice(start, end));
+            lines.push(this.parts.join(''));
+            this.parts = [];
+            this.partsLength = 0;
+            start = end + 1;
+        }
+        if (start < chunk.length) {
+            this.parts.push(chunk.slice(start));
+            this.partsLength += chunk.length - start;
         }
-        const lines = this.buffer.split('\n');
-        this.buffer = lines.pop() ?? '';
+        this.assertWithinLimit(this.partsLength);
         return lines.filter((line) => line.trim());
     }
+    /**
+     * Reject a message longer than the limit.
+     *
+     * @param length - Length of the message (so far)
+     * @throws JSONLBufferOverflowError above the maximum size
+     */
+    assertWithinLimit(length) {
+        if (length > this.maxSize)
+            throw new JSONLBufferOverflowError(length, this.maxSize);
+    }
     clear() {
-        this.buffer = '';
+        this.parts = [];
+        this.partsLength = 0;
     }
     getBuffer() {
-        return this.buffer;
+        return this.parts.join('');
     }
 }
 /**
  * Parse JSONL frame into typed object.
+ *
+ * Strings with a lone UTF-16 surrogate (page text cut inside an emoji, or a
+ * page logging `"\\ud83d"`) get U+FFFD in its place: printed back as JSON
+ * they would be an escape sequence that strict parsers such as jq reject.
+ *
+ * @param line - One JSON document
+ * @returns Parsed value
  */
 export function parseJSONLFrame(line) {
-    return JSON.parse(line);
+    if (!SURROGATE_ESCAPE.test(line))
+        return JSON.parse(line);
+    return JSON.parse(line, (_key, value) => typeof value === 'string' ? value.replace(LONE_SURROGATE, '\uFFFD') : value);
 }
+/** A surrogate escape in JSON text (only then can a string hold a lone surrogate) */
+const SURROGATE_ESCAPE = /\\u[dD][89a-fA-F]/;
+/** A high surrogate not followed by a low one, or a low one not preceded by a high one */
+const LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
 /**
  * Serialize object to JSONL frame (JSON + newline).
  */

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

@@ -4,8 +4,10 @@
  * Utilities for detecting IPC transport-level errors.
  */
 /**
- * Detect whether an error indicates the daemon socket is unavailable.
- * Checks for ENOENT (socket file doesn't exist) and ECONNREFUSED (daemon not listening).
+ * Detect whether an error indicates the daemon socket is unavailable:
+ * the socket file doesn't exist (ENOENT) or nobody listens (ECONNREFUSED).
+ * Errors of other files (e.g. a screenshot path in a missing directory) are
+ * not connection errors, even though they also say ENOENT.
  *
  * @param error - Error from IPC transport layer
  * @returns True if error indicates daemon connection failure

package/dist/ipc/utils/errors.js

@@ -3,10 +3,15 @@
  *
  * Utilities for detecting IPC transport-level errors.
  */
+import { IPCConnectionError } from '../transport/IPCError.js';
 import { getErrorMessage } from '../../utils/errors.js';
+/** A failed socket connection or an IPC connection error (not a file error) */
+const DAEMON_CONNECTION_PATTERN = /IPC .+ connection error|\bconnect (ENOENT|ECONNREFUSED)\b/;
 /**
- * Detect whether an error indicates the daemon socket is unavailable.
- * Checks for ENOENT (socket file doesn't exist) and ECONNREFUSED (daemon not listening).
+ * Detect whether an error indicates the daemon socket is unavailable:
+ * the socket file doesn't exist (ENOENT) or nobody listens (ECONNREFUSED).
+ * Errors of other files (e.g. a screenshot path in a missing directory) are
+ * not connection errors, even though they also say ENOENT.
  *
  * @param error - Error from IPC transport layer
  * @returns True if error indicates daemon connection failure
@@ -23,7 +28,8 @@ import { getErrorMessage } from '../../utils/errors.js';
  * ```
  */
 export function isConnectionError(error) {
-    const message = getErrorMessage(error);
-    return message.includes('ENOENT') || message.includes('ECONNREFUSED');
+    if (error instanceof IPCConnectionError)
+        return true;
+    return DAEMON_CONNECTION_PATTERN.test(getErrorMessage(error));
 }
 //# sourceMappingURL=errors.js.map

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

@@ -6,7 +6,6 @@
  */
 export * from './session.js';
 export type * from './types.js';
-export * from './requestId.js';
 export * from './errors.js';
 export * from './responseValidator.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/ipc/utils/index.js

@@ -5,7 +5,6 @@
  * and response validation.
  */
 export * from './session.js';
-export * from './requestId.js';
 export * from './errors.js';
 export * from './responseValidator.js';
 //# sourceMappingURL=index.js.map

package/dist/ipc/utils/responseValidator.d.ts

@@ -11,6 +11,10 @@ interface BaseResponse {
     status: 'ok' | 'error';
     error?: string;
     data?: object;
+    /** Semantic exit code forwarded by the daemon */
+    exitCode?: number;
+    /** Recovery suggestion forwarded by the daemon */
+    suggestion?: string;
 }
 /**
  * Response type with success status.
@@ -31,7 +35,7 @@ type SuccessResponse<T extends BaseResponse> = T & {
  * Works with both IPCResponse (legacy) and ClientResponse (new) types.
  *
  * @param response - IPC or CDP response from daemon
- * @throws IPCError if response.status === 'error'
+ * @throws CommandError (carrying the daemon's exitCode and suggestion) if response.status === 'error'
  *
  * @example
  * ```typescript

package/dist/ipc/utils/responseValidator.js

@@ -3,7 +3,8 @@
  *
  * Provides standardized error handling for IPC/CDP calls with type narrowing.
  */
-import { IPCError } from '../../ipc/transport/IPCError.js';
+import { CommandError } from '../../errors/index.js';
+import { EXIT_CODES } from '../../utils/exitCodes.js';
 /**
  * Validate IPC response and throw on error.
  * Standardizes error handling for all IPC/CDP calls.
@@ -16,7 +17,7 @@ import { IPCError } from '../../ipc/transport/IPCError.js';
  * Works with both IPCResponse (legacy) and ClientResponse (new) types.
  *
  * @param response - IPC or CDP response from daemon
- * @throws IPCError if response.status === 'error'
+ * @throws CommandError (carrying the daemon's exitCode and suggestion) if response.status === 'error'
  *
  * @example
  * ```typescript
@@ -28,7 +29,10 @@ import { IPCError } from '../../ipc/transport/IPCError.js';
  */
 export function validateIPCResponse(response) {
     if (response.status === 'error') {
-        throw new IPCError(response.error ?? 'Unknown IPC error');
+        const message = response.error ?? 'Unknown IPC error';
+        const exitCode = response.exitCode ??
+            (/no active session/i.test(message) ? EXIT_CODES.RESOURCE_NOT_FOUND : undefined);
+        throw new CommandError(message, response.suggestion ? { suggestion: response.suggestion } : {}, exitCode ?? EXIT_CODES.SOFTWARE_ERROR);
     }
 }
 //# sourceMappingURL=responseValidator.js.map

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

@@ -0,0 +1,106 @@
+/**
+ * What a DOM action changed on the page: whether it navigated (to a new
+ * document or within the same one), which messages appeared, and whether it
+ * had no visible effect at all. 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.
+ * Worst case, when the page does not answer (a navigation is pending), the
+ * snapshot is given up after {@link START_TIMEOUT_MS} and each read after
+ * {@link READ_TIMEOUT_MS}.
+ */
+import type { CDPConnection } from '../../connection/cdp.js';
+import type { ActionEffects, NewMessage, PageNavigation } from '../../ipc/protocol/domTypes.js';
+import { type NavigationEvents } from './pageActivity.js';
+/** A message element as a page snapshot lists it */
+export interface SeenMessage {
+    /** Number of the element, stable within its document */
+    id: number;
+    text: string;
+    element: string;
+}
+export type { NavigationEvents };
+/** The page after the action */
+export interface ReadSnapshot {
+    href: string;
+    /** The snapshot was gone: a new document */
+    fresh: boolean;
+    /** DOM changes counted since the start (same document only) */
+    changes?: number;
+    /** Why "no effect" can't be claimed even without changes */
+    uncertain?: string;
+    messages: SeenMessage[];
+}
+/** What the action did besides changing the page, for the "no effect" decision */
+export interface OtherActivity {
+    /** Requests started during the action */
+    requests: number;
+    /** Dialogs opened during the action */
+    dialogs: number;
+    /** A window, tab or download was opened */
+    opened: boolean;
+}
+/**
+ * Messages that are new after the action: all of them after a new document
+ * loaded; otherwise those whose text is shown more often than before (a
+ * re-rendered message with the same text is not new) and those whose
+ * element changed its text. Texts that tick on their own
+ * ({@link TICKING_TEXT}: clocks, counters) are left out; other elements
+ * that change on their own (a rotating banner) are not recognised. Each text
+ * is reported once, at most {@link MAX_NEW_MESSAGES}, cut to
+ * {@link MAX_MESSAGE_LENGTH} characters.
+ *
+ * @param before - Messages before the action
+ * @param after - Messages after the action
+ * @param newDocument - Whether a new document loaded
+ * @returns New messages
+ */
+export declare function newMessages(before: SeenMessage[], after: SeenMessage[], newDocument: boolean): NewMessage[];
+/**
+ * How the page's location changed: a new document committed in the main
+ * frame (also when it has the URL it had, as after a form POST that
+ * redirects back), or a same-document URL change (history API, hash).
+ *
+ * Without the URL before the action, a same-document change is reported
+ * only when Chrome announced one.
+ *
+ * @param startHref - URL before the action (undefined when not read)
+ * @param read - Page read after the action (undefined when not read)
+ * @param events - Main-frame navigation events
+ * @returns Navigation, or undefined when the location did not change
+ */
+export declare function pageNavigation(startHref: string | undefined, read: ReadSnapshot | undefined, events: NavigationEvents): PageNavigation | undefined;
+/**
+ * Whether an action had no visible effect: the page was read before and
+ * after in the same document, it counted no DOM change, nothing made the
+ * check uncertain, and no navigation, message, request, dialog or new window
+ * happened.
+ *
+ * @param read - Page read after the action
+ * @param effects - Navigation and messages found
+ * @param activity - Requests, dialogs and windows during the action
+ * @returns True to report `effect: "none"`
+ */
+export declare function hadNoEffect(read: ReadSnapshot | undefined, effects: ActionEffects, activity: OtherActivity): boolean;
+/** Collects what changed, once the action and its wait are done */
+export interface ActionEffectsWatch {
+    /**
+     * @param options - Dialogs the action opened, and whether to decide "no effect"
+     * @returns What changed
+     */
+    collect(options: {
+        dialogs: number;
+        detectNoEffect: boolean;
+    }): Promise<ActionEffects>;
+    /** Stop listening and stop the page's watch (always call) */
+    dispose(): void;
+}
+/**
+ * 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.
+ *
+ * @param cdp - CDP connection
+ * @returns Watch to collect from after the action
+ */
+export declare function watchActionEffects(cdp: CDPConnection): ActionEffectsWatch;
+//# sourceMappingURL=actionEffects.d.ts.map