browser-debugger-cli 0.8.0 → 0.10.0

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

@@ -0,0 +1,388 @@
+/**
+ * What `bdg dom inspect` returns: one element's look as a designer reads it,
+ * in a schema aligned with Figma's concepts (rect, box, layout with
+ * hug/fill/fixed sizing, text, fills, strokes, radius, effects, children), so
+ * it can be compared key by key with a design. Lengths are CSS px as numbers
+ * (one decimal); other units stay text. Colors are hex (`#rrggbbaa` when
+ * translucent).
+ */
+import type { ContrastLevel } from '../../utils/color.js';
+import type { CssLength } from '../../utils/cssValues.js';
+/** Border box: page coordinates (iframe offsets and page scroll included) and size */
+export interface InspectRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Sides top, right, bottom, left */
+export type Sides = [CssLength, CssLength, CssLength, CssLength];
+/** How a box gets its size along an axis, as Figma's auto layout names it */
+export type SizingMode = 'fixed' | 'hug' | 'fill';
+/** Padding, margin, border widths and the constraints on the box */
+export interface InspectBox {
+    padding: Sides;
+    margin: Sides;
+    border: Sides;
+    sizing: string;
+    min?: {
+        w?: CssLength;
+        h?: CssLength;
+    };
+    max?: {
+        w?: CssLength;
+        h?: CssLength;
+    };
+    /** `overflow` when not visible, e.g. `hidden` or `hidden auto` (x y) */
+    overflow?: string;
+    /** Size of the content when it overflows the box by more than 1px */
+    scroll?: {
+        w: number;
+        h: number;
+    };
+}
+/** Flex or grid container properties */
+export interface InspectContainer {
+    direction?: string;
+    wrap?: string;
+    justify?: string;
+    align?: string;
+    /** Row and column gap (one number when equal) */
+    gap?: CssLength | [CssLength, CssLength];
+    columns?: string;
+    rows?: string;
+}
+/** The parent that lays the element out (display: contents wrappers skipped) */
+export interface InspectParent extends InspectContainer {
+    element: string;
+    display: string;
+    textAlign?: string;
+}
+/** Gaps to the previous and next rendered in-flow siblings, by the side each is on */
+export interface InspectSiblings {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+}
+/** Display, position and the layout the element takes part in */
+export interface InspectLayout extends InspectContainer {
+    display: string;
+    position?: string;
+    inset?: Sides;
+    z?: CssLength;
+    float?: string;
+    valign?: string;
+    /** As a flex item: grow shrink basis */
+    flex?: string;
+    self?: string;
+    order?: number;
+    /** As a grid item: row-start / column-start / row-end / column-end */
+    area?: string;
+    sizing?: {
+        w: SizingMode;
+        h: SizingMode;
+    };
+    parent?: InspectParent;
+    /** Distances from the parent's content box edges */
+    inParent?: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
+    siblings?: InspectSiblings;
+}
+/** Contrast of the text with what is behind it */
+export interface InspectContrast {
+    ratio: number;
+    level: ContrastLevel;
+    /** Effective background (ancestor backgrounds composited) */
+    background: string;
+    /** The background was taken from an ancestor (or the page canvas) */
+    inherited?: boolean;
+    /** A background image or gradient is behind the text: the ratio uses the colors only */
+    overImage?: boolean;
+    /**
+     * Opacity of the element and its ancestors (below 1): the text color is
+     * faded by it before the ratio is taken (backgrounds inside the faded
+     * subtree are not, so the ratio is approximate)
+     */
+    opacity?: number;
+}
+/** Typography (for containers without text of their own: only what differs from the parent) */
+export interface InspectText {
+    family?: string;
+    /** Font Chrome rendered the text with, when it is not the first family */
+    rendered?: string;
+    /** The rendered font is a web font */
+    webfont?: boolean;
+    weight?: number;
+    style?: string;
+    size?: number;
+    lineHeight?: CssLength;
+    color?: string;
+    contrast?: InspectContrast;
+    align?: string;
+    transform?: string;
+    tracking?: CssLength;
+    decoration?: string;
+    whiteSpace?: string;
+    overflow?: string;
+    clamp?: string;
+    shadow?: string;
+    features?: string;
+}
+/** A background layer */
+export type InspectFill = {
+    type: 'solid';
+    color: string;
+} | {
+    type: 'gradient';
+    value: string;
+} | {
+    type: 'image';
+    value: string;
+    size?: string;
+};
+/** A border side (or all four) */
+export interface InspectStroke {
+    side: 'all' | 'top' | 'right' | 'bottom' | 'left';
+    width: number;
+    style: string;
+    color: string;
+}
+/** A shadow layer */
+export interface InspectEffect {
+    type: 'shadow' | 'inner-shadow';
+    x: number;
+    y: number;
+    blur: number;
+    spread: number;
+    color: string;
+}
+/** Visual effects other than shadows */
+export interface InspectFx {
+    transform?: string;
+    filter?: string;
+    backdrop?: string;
+    clip?: string;
+    mask?: string;
+    animation?: string;
+}
+/** Interaction state set by CSS */
+export interface InspectState {
+    cursor?: string;
+    pointerEvents?: string;
+    visibility?: string;
+    userSelect?: string;
+    appearance?: string;
+}
+/** A generated pseudo-element (`::before`, `::after`) or the placeholder */
+export interface InspectPseudo {
+    type: '::before' | '::after' | '::placeholder';
+    content?: string;
+    display?: string;
+    position?: string;
+    size?: {
+        w: number;
+        h: number;
+    };
+    color?: string;
+    fills?: InspectFill[];
+    radius?: string;
+    effects?: InspectEffect[];
+    transform?: string;
+    opacity?: number;
+    /** `::placeholder`: font style and weight, when not the field's */
+    fontStyle?: string;
+    fontWeight?: number;
+    /** `::placeholder`: contrast of the placeholder text with the field's background */
+    contrast?: InspectContrast;
+}
+/** A row of the child tree; identical siblings are one row with a count */
+export interface InspectTreeNode {
+    /** `tag.firstClass` */
+    element: string;
+    /** Position relative to the parent's border box (like Figma's x/y in a frame; a group's first member) */
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    /** `flex` or `grid` container */
+    layout?: 'flex' | 'grid';
+    text?: string;
+    /** Identical siblings this row stands for (2 or more) */
+    count?: number;
+    children?: InspectTreeNode[];
+    /** Rendered element children (at the depth limit, where they are not listed) */
+    childCount?: number;
+    /** Children that are not rendered (not listed) */
+    hiddenChildren?: number;
+}
+/** Why the element cannot be seen, or where it is when it is out of view */
+export interface InspectVisibility {
+    /** No box: `display: none` on it or an ancestor, or not in the page's layout */
+    notRendered?: true;
+    /** Rendered but not seen, e.g. `visibility: hidden`, `zero size` */
+    hidden?: string;
+    /** Out of the viewport: `above`, `below`, `left` or `right` */
+    offscreen?: string;
+    /** Topmost element at the center of its visible part, when another one */
+    coveredBy?: string;
+    /** The cover paints nothing there: the element shows, but clicks land on the cover */
+    coverTransparent?: true;
+}
+/** A property asked for with `--props` */
+export interface InspectProp {
+    /** Computed value as Chrome reports it */
+    computed: string;
+    /** Normalized: px as numbers, colors as hex */
+    value: string;
+}
+/** A declaration that has no effect, and why */
+export interface InspectHint {
+    /** `inactive` (has no effect), `unset-variable` (var() of an unset custom property), `not-inherited` (a form control in the browser's font) */
+    kind: 'inactive' | 'unset-variable' | 'not-inherited';
+    /** Property as written */
+    property: string;
+    value: string;
+    /** e.g. `display is block` */
+    reason: string;
+    /** e.g. `use display: flex or grid on this element` */
+    fix: string;
+    /** e.g. `.hero (app.css:12)` */
+    source: string;
+}
+/** Which declaration sets a property */
+export interface InspectRule {
+    /** Longhand, or the shorthand when one declaration sets all its sides */
+    property: string;
+    /** Value as written (custom properties visible) */
+    value: string;
+    /** Computed value, normalized (px as numbers, colors as hex), when the written one has `var()` */
+    computed?: string;
+    /** e.g. `.btn-primary (bootstrap.min.css:5:52628)`, `style attribute` */
+    source: string;
+    /** Selectors of the declarations it beats */
+    overrides?: string[];
+    /** Set on an ancestor this many levels up (inherited) */
+    inherited?: number;
+    important?: true;
+    layer?: string;
+    /** Media or container condition of the rule */
+    condition?: string;
+}
+/** One declaration in the cascade of a property (`--why`) */
+export interface InspectWhyEntry {
+    /** Value as written (a shorthand's whole value) */
+    value: string;
+    /** Shorthand or logical property it was written as */
+    via?: string;
+    /** The value with its custom properties substituted, when it has `var()` */
+    resolved?: string;
+    /** Custom properties it uses that are not set (the declaration is then invalid) */
+    unset?: string[];
+    source: string;
+    /** Specificity of the rule's selector (ids, classes, types) */
+    specificity?: [number, number, number];
+    /** `applied` (wins), `overridden`, or `inherited` (from an ancestor: the winner, or one it beat there) */
+    status: 'applied' | 'overridden' | 'inherited';
+    important?: true;
+    layer?: string;
+    condition?: string;
+}
+/** `--why`: every declaration of one property, winner first */
+export interface InspectWhy {
+    property: string;
+    /** Computed value, normalized (px as numbers, colors as hex) */
+    computed: string;
+    chain: InspectWhyEntry[];
+    /** Where the custom properties of the winning value are set */
+    variables?: InspectVariable[];
+}
+/** A custom property a winning value uses, and where it is set */
+export interface InspectVariable {
+    name: string;
+    value: string;
+    source: string;
+    /** Set on an ancestor this many levels up */
+    inherited?: number;
+}
+/** `bdg dom inspect` result */
+export interface InspectResult {
+    success: true;
+    /** Selector the element was found with (for an index: the cached query's) */
+    selector: string;
+    /** Elements the selector matched */
+    count: number;
+    /** Which match was inspected (0-based) */
+    index: number;
+    /**
+     * How the match was chosen when no index was given and several matched:
+     * the first rendered one (`first-visible`, when earlier ones are not
+     * rendered) or the first
+     */
+    picked?: 'first-visible' | 'first';
+    /** `tag#id.c1.c2(+N)` */
+    element: string;
+    /** Its text (innerText) or form value, at most 30 characters; not for containers */
+    content?: string;
+    /** Placeholder of an empty field */
+    placeholder?: string;
+    /** Enclosing iframe(s) and shadow root */
+    context?: string;
+    /** Absent when not rendered */
+    rect?: InspectRect;
+    visibility: InspectVisibility;
+    /**
+     * `dark` when the page renders a dark theme (dark canvas or dark page
+     * background) while the session prefers dark; colors are then the dark
+     * theme's
+     */
+    theme?: 'dark';
+    /**
+     * Running CSS transitions (their property) and animations (their name):
+     * the values read are mid-way and will still change
+     */
+    animating?: string[];
+    /** `prefers-color-scheme` the page sees */
+    colorScheme?: 'light' | 'dark';
+    box?: InspectBox;
+    layout?: InspectLayout;
+    text?: InspectText;
+    fills?: InspectFill[];
+    opacity?: number;
+    blend?: string;
+    strokes?: InspectStroke[];
+    /** Corner radii top-left, top-right, bottom-right, bottom-left */
+    radius?: Sides;
+    outline?: {
+        width: number;
+        style: string;
+        color: string;
+        offset?: number;
+    };
+    effects?: InspectEffect[];
+    fx?: InspectFx;
+    state?: InspectState;
+    pseudo?: InspectPseudo[];
+    children?: InspectTreeNode[];
+    /** Children not rendered (not listed) */
+    hiddenChildren?: number;
+    /** Tree rows left out beyond `--tree-limit` */
+    moreRows?: number;
+    /** `--all`: every longhand that is not a no-op default, collapsed into shorthands */
+    all?: Record<string, string>;
+    /** `--props`: the properties asked for */
+    props?: Record<string, InspectProp>;
+    /** Declarations that have no effect (checked by default; empty when none) */
+    hints?: InspectHint[];
+    /** `--rules`: the declaration that sets each shown property */
+    rules?: InspectRule[];
+    /** `--why <property>`: one entry, or one per longhand of a shorthand whose sides differ */
+    why?: InspectWhy[];
+    /** The cascade was not read: Chrome took longer than the time allowed, or failed */
+    cascade?: 'timeout' | 'failed';
+}
+//# sourceMappingURL=inspectTypes.d.ts.map

package/dist/ipc/protocol/inspectTypes.js

@@ -0,0 +1,10 @@
+/**
+ * What `bdg dom inspect` returns: one element's look as a designer reads it,
+ * in a schema aligned with Figma's concepts (rect, box, layout with
+ * hug/fill/fixed sizing, text, fills, strokes, radius, effects, children), so
+ * it can be compared key by key with a design. Lengths are CSS px as numbers
+ * (one decimal); other units stay text. Colors are hex (`#rrggbbaa` when
+ * translucent).
+ */
+export {};
+//# sourceMappingURL=inspectTypes.js.map

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.
  */
@@ -53,6 +54,10 @@ 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).
@@ -81,6 +86,8 @@ export interface StartSessionResponseData {
     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. */

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).
  */
@@ -35,6 +35,10 @@ export interface StatusResponseData {
         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;

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

@@ -3,6 +3,7 @@
  *
  * 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/transport/index.d.ts

@@ -16,7 +16,8 @@ type WithTypeAndSession = {
  * @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, timeoutMs?: number): 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

@@ -20,10 +20,10 @@ const log = createLogger('client');
  * @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, timeoutMs = getIPCRequestTimeout()) {
-    const socketPath = getDaemonSocketPath();
+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/runtime/dom/actionEffects.d.ts

@@ -0,0 +1,185 @@
+/**
+ * What a DOM action changed on the page: whether it navigated (to a new
+ * document or within the same one), which messages and elements appeared,
+ * whether it had no visible effect at all, and whether the page was still
+ * 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.
+ * 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}.
+ */
+import type { CDPConnection } from '../../connection/cdp.js';
+import type { ActionEffects, NewMessage, PageNavigation, PendingChanges, ShownElement, TriggeredRequest } 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 };
+/** Signs that the page was still working at a read (same document only) */
+export interface SettleSignals {
+    /** How long ago each recent burst of structural DOM changes was (ms, newest last) */
+    burstAges: number[];
+    /** A loading indicator shown since the action began, described */
+    loading: string | null;
+}
+/** 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[];
+    /** Whether the page was still working (same document only) */
+    settle?: SettleSignals;
+    /** Elements the action showed (when asked for) */
+    shown?: ShownElement[];
+}
+/** What collecting saw of the page's work, for {@link pendingChanges} */
+export interface PageWork {
+    /** Signals of the last read, when there was one in the same document */
+    settle?: SettleSignals;
+    /** The DOM kept changing in bursts over a second look ({@link domLooksBusy}) */
+    domChanging: boolean;
+    /** A read got no answer within its time (a long script) */
+    unresponsive: boolean;
+    /** A main-frame load was still pending */
+    navigating: boolean;
+}
+/** Effects, plus the page's work for deciding whether it had settled */
+export interface CollectedEffects extends ActionEffects {
+    work?: PageWork;
+}
+/** 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[];
+/**
+ * Elements to report as shown: those whose text is not already reported as
+ * a new message, at most {@link MAX_SHOWN_ELEMENTS}, texts cut to
+ * {@link MAX_MESSAGE_LENGTH} characters.
+ *
+ * @param shown - Elements the page found shown by the action
+ * @param messages - New messages being reported
+ * @returns Elements to report
+ */
+export declare function shownElements(shown: ShownElement[], messages: NewMessage[]): ShownElement[];
+/**
+ * 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.
+ *
+ * @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).
+ *
+ * @param settle - Signals of the second read
+ * @param sinceMs - Time since the first read
+ * @returns True when the DOM is still changing
+ */
+export declare function domKeptChanging(settle: SettleSignals | undefined, sinceMs: number): boolean;
+/**
+ * What the page was still working on when the action returned, or undefined
+ * when it looked settled: content requests (documents, fetch/XHR, scripts)
+ * still pending, a new document still loading, a loading indicator that
+ * appeared, a DOM still changing ({@link domKeptChanging}), or a page that
+ * did not answer (a long script). A result a timer renders later, with no
+ * DOM change before it, is not seen.
+ *
+ * @param work - What collecting saw
+ * @param requests - Requests the action triggered (with pending ones)
+ * @returns Pending work, or undefined
+ */
+export declare function pendingChanges(work: PageWork, requests?: TriggeredRequest[]): PendingChanges | undefined;
+/**
+ * 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, shown element, 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;
+/** What collecting looks at besides navigation and messages */
+export interface CollectOptions {
+    /** Dialogs the action opened */
+    dialogs: number;
+    /** Decide "no effect" (with a second look when nothing seemed to happen) */
+    detectNoEffect: boolean;
+    /** List the elements the action showed */
+    reportShown?: boolean;
+    /** Take a second look when the DOM looks busy, to tell whether it is still changing */
+    detectUnsettled?: boolean;
+}
+/** Collects what changed, once the action and its wait are done */
+export interface ActionEffectsWatch {
+    /**
+     * @param options - Dialogs, and what to decide and list
+     * @returns What changed, and the page's work at the end
+     */
+    collect(options: CollectOptions): Promise<CollectedEffects>;
+    /** 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