browser-debugger-cli 0.8.0 → 0.9.0

package/dist/ipc/client.d.ts

@@ -28,6 +28,7 @@ export declare function connectToDaemon(): Promise<HandshakeResponse>;
  * Request status information from the daemon.
  * Returns daemon state, session metadata, and activity metrics.
  *
+ * @param socketPath - Daemon socket to ask (default: the selected session's)
  * @returns Status response with daemon and session information
  * @throws Error if connection fails or times out
  *
@@ -40,7 +41,7 @@ export declare function connectToDaemon(): Promise<HandshakeResponse>;
  * }
  * ```
  */
-export declare function getStatus(): Promise<StatusResponse>;
+export declare function getStatus(socketPath?: string): Promise<StatusResponse>;
 /**
  * Request preview data from the daemon.
  * Returns snapshot of collected telemetry without stopping session.
@@ -221,4 +222,14 @@ export declare function pageNavigate(params: NoType<(typeof COMMANDS)['page_navi
 export declare function domFormDiscover(): Promise<ClientResponse<'dom_form_discover'>>;
 /** List the event listeners that run for an element. */
 export declare function domListeners(params: NoType<(typeof COMMANDS)['dom_listeners']['requestSchema']>): Promise<ClientResponse<'dom_listeners'>>;
+/** Positions, sizes and visibility of elements. */
+export declare function domLayout(params: NoType<(typeof COMMANDS)['dom_layout']['requestSchema']>): Promise<ClientResponse<'dom_layout'>>;
+/**
+ * Wait until elements appear, become visible, contain a text or are gone,
+ * and/or the page has loaded.
+ *
+ * @param params - Condition and timeout
+ * @returns What the page showed once the condition was met
+ */
+export declare function domWait(params: NoType<(typeof COMMANDS)['dom_wait']['requestSchema']>): Promise<ClientResponse<'dom_wait'>>;
 //# sourceMappingURL=client.d.ts.map

package/dist/ipc/client.js

@@ -4,7 +4,7 @@
  * Public API for communicating with the daemon via Unix socket.
  * Provides high-level functions for session lifecycle and queries.
  */
-import { getQuickIPCRequestTimeout } from '../constants.js';
+import { getIPCRequestTimeout, getQuickIPCRequestTimeout } from '../constants.js';
 import { CommandError } from '../errors/index.js';
 import { EXIT_CODES } from '../utils/exitCodes.js';
 import { sendRequest } from './transport/index.js';
@@ -42,6 +42,7 @@ async function assertResponsive() {
  * Request status information from the daemon.
  * Returns daemon state, session metadata, and activity metrics.
  *
+ * @param socketPath - Daemon socket to ask (default: the selected session's)
  * @returns Status response with daemon and session information
  * @throws Error if connection fails or times out
  *
@@ -54,9 +55,9 @@ async function assertResponsive() {
  * }
  * ```
  */
-export async function getStatus() {
+export async function getStatus(socketPath) {
     const request = withSession({ type: 'status_request' });
-    return sendRequest(request, 'status', 'status_response', getQuickIPCRequestTimeout());
+    return sendRequest(request, 'status', 'status_response', getQuickIPCRequestTimeout(), socketPath);
 }
 /**
  * Request preview data from the daemon.
@@ -145,6 +146,8 @@ export async function startSession(url, options) {
             headless: options.headless,
             chromeWsUrl: options.chromeWsUrl,
             chromeFlags: options.chromeFlags,
+            viewport: options.viewport,
+            colorScheme: options.colorScheme,
         }),
     });
     await assertResponsive();
@@ -318,4 +321,20 @@ export async function domFormDiscover() {
 export async function domListeners(params) {
     return sendCommand('dom_listeners', params);
 }
+/** Positions, sizes and visibility of elements. */
+export async function domLayout(params) {
+    return sendCommand('dom_layout', params);
+}
+/** Time the client gives `dom wait` beyond its --timeout (the daemon reports the timeout first) */
+const WAIT_IPC_MARGIN_MS = 10_000;
+/**
+ * Wait until elements appear, become visible, contain a text or are gone,
+ * and/or the page has loaded.
+ *
+ * @param params - Condition and timeout
+ * @returns What the page showed once the condition was met
+ */
+export async function domWait(params) {
+    return sendCommand('dom_wait', params, Math.max(getIPCRequestTimeout(), params.timeout + WAIT_IPC_MARGIN_MS));
+}
 //# sourceMappingURL=client.js.map

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

@@ -5,7 +5,7 @@
  * Each command has a request schema (input) and response data schema (output).
  */
 import type { HintDetails } from '../../errors/notices.js';
-import type { ClickResult, FillResult, ListenersResult, PressKeyResult, RawFormData, ScrollResult, SubmitResult } from './domTypes.js';
+import type { ClickResult, FillResult, LayoutResult, ListenersResult, PressKeyResult, RawFormData, ScrollResult, SubmitResult } from './domTypes.js';
 import type { PageState, SessionActivity } from '../session/types.js';
 import type { NetworkRequest } from '../../types.js';
 /**
@@ -147,6 +147,14 @@ export interface SessionNetworkHeadersData {
     url: string;
     /** Request ID for correlation with peek output. */
     requestId: string;
+    /** HTTP method. */
+    method?: string;
+    /** HTTP status (0: failed without a response; missing while pending). */
+    status?: number;
+    /** Status text sent by the server (empty for HTTP/2). */
+    statusText?: string;
+    /** Why loading failed, when it did. */
+    errorText?: string;
     /** Request headers. */
     requestHeaders: Record<string, string>;
     /** Response headers. */
@@ -167,7 +175,7 @@ export interface DomEvalData {
     type: string;
     /** Object subtype (node, date, array, ...) */
     subtype?: string;
-    /** URL of the iframe the script ran in (with `frame`) */
+    /** URL of the iframe the script ran in (with `frame`; empty when it has none) */
     frame?: string;
 }
 /** An iframe of the page, as listed by `bdg dom frames` */
@@ -180,12 +188,18 @@ export interface DomFrame {
     name?: string;
     /** `id` attribute of the iframe element */
     id?: string;
-    /** Security origin */
+    /**
+     * Origin the frame's scripts run with: inherited from the parent for
+     * srcdoc and about:blank, `"null"` (opaque) for data: URLs and sandboxes
+     * without allow-same-origin
+     */
     origin: string;
-    /** Origin differs from the page's */
+    /** The page cannot reach its document: the origin differs from the page's, or is opaque */
     crossOrigin: boolean;
     /** Runs in its own renderer process (site isolation) */
     outOfProcess: boolean;
+    /** Index of the frame it is nested in (missing for frames of the page itself) */
+    parentIndex?: number;
 }
 /**
  * dom_frames: list the page's iframes (including nested and out-of-process ones).
@@ -276,8 +290,21 @@ export interface DomListenersCommand {
     backendNodeId?: number;
     /** Only these event types (default: all) */
     types?: string[];
+    /** List every listener of framework roots instead of one summary per node */
+    all?: boolean;
 }
 export type DomListenersData = ListenersResult;
+/**
+ * dom_layout: positions, sizes and visibility of elements.
+ */
+export interface DomLayoutCommand {
+    selector: string;
+    /** Only this match (default: every match) */
+    index?: number;
+    /** Exact element from the query cache (overrides selector/index) */
+    backendNodeId?: number;
+}
+export type DomLayoutData = LayoutResult;
 /**
  * dom_form_discover: run the form discovery script and return raw form data.
  */
@@ -309,6 +336,8 @@ export type RegistryShape = {
     dom_scroll: CommandDef<DomScrollCommand, DomScrollData>;
     dom_form_discover: CommandDef<DomFormDiscoverCommand, DomFormDiscoverData>;
     dom_listeners: CommandDef<DomListenersCommand, DomListenersData>;
+    dom_layout: CommandDef<DomLayoutCommand, DomLayoutData>;
+    dom_wait: CommandDef<DomWaitCommand, DomWaitData>;
     page_navigate: CommandDef<PageNavigateCommand, PageNavigationResult>;
 };
 /** What `bdg page` does */
@@ -325,6 +354,62 @@ export interface PageNavigationResult {
     status?: number;
     /** Something worth knowing: an HTTP error, a download, a page still loading */
     warning?: string;
+    /** The new document had not finished loading within the wait (absent once complete) */
+    loading?: PageLoadingState;
+}
+/** A request the page is still waiting for */
+export interface PendingRequestInfo {
+    method: string;
+    url: string;
+    /** CDP resource type (Script, Stylesheet, Image, ...) when known */
+    resourceType?: string;
+    /** How long it has been running */
+    pendingMs: number;
+}
+/** A document that has not finished loading (`document.readyState` is not `complete`) */
+export interface PageLoadingState {
+    /** `loading` or `interactive` */
+    readyState: string;
+    /** The longest-running requests, load-blocking ones (scripts, styles, images, frames) first */
+    pending: PendingRequestInfo[];
+    /** All requests still running (more than `pending` lists when there are many) */
+    pendingCount: number;
+}
+/**
+ * dom_wait: wait until elements matching a selector appear, become visible,
+ * contain a text or are gone, and/or the page has loaded.
+ */
+export interface DomWaitCommand {
+    /** Selector (filters like :has-text and :visible allowed); optional with `load` */
+    selector?: string;
+    /** Text one of the matches must contain (case-insensitive) */
+    text?: string;
+    /** Wait for the matches (or visible matches with `visible`) to be gone */
+    gone?: boolean;
+    /** Only count visible matches */
+    visible?: boolean;
+    /** Also wait for `document.readyState` to be `complete` */
+    load?: boolean;
+    /** Give up after this many milliseconds */
+    timeout: number;
+}
+/** What the page showed when a `dom wait` condition was met */
+export interface DomWaitData {
+    selector?: string;
+    text?: string;
+    gone?: boolean;
+    visible?: boolean;
+    load?: boolean;
+    /** Time from the start of the wait until the condition was met */
+    elapsedMs: number;
+    /** Elements matching the selector */
+    count: number;
+    /** Of those, the ones containing `text` (with `text` only) */
+    textCount?: number;
+    /** Of those (or of the text matches), the visible ones */
+    visibleCount: number;
+    /** `document.readyState` of the page */
+    readyState: string;
 }
 /**
  * page_navigate: navigate, reload, or go back/forward, then wait for the page.

package/dist/ipc/protocol/commands.js

@@ -33,5 +33,7 @@ export const COMMANDS = {
     page_navigate: defineCommand(),
     dom_form_discover: defineCommand(),
     dom_listeners: defineCommand(),
+    dom_layout: defineCommand(),
+    dom_wait: defineCommand(),
 };
 //# sourceMappingURL=commands.js.map

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

@@ -6,7 +6,7 @@
  * CLI commands and IPC transport consume them directly. Keeping the contract
  * here lets runtime and transport evolve independently.
  */
-import type { FormStep, FieldOption } from '../../types.js';
+import type { FormStep, FieldOption, ViewportPosition } from '../../types.js';
 /**
  * A JavaScript dialog (alert, confirm, prompt, beforeunload) that bdg accepted
  * while a command ran.
@@ -17,20 +17,96 @@ export interface DialogInfo {
     /** Text the page showed */
     message: string;
 }
+/**
+ * A network request that started while a command ran (after the action began
+ * and before the command returned).
+ */
+export interface TriggeredRequest {
+    /** Request id (what `bdg details network <id>` takes) */
+    requestId: string;
+    method: string;
+    url: string;
+    /** CDP resource type, e.g. `Document`, `Fetch`, `Stylesheet` */
+    resourceType?: string;
+    /** HTTP status, once a response arrived */
+    status?: number;
+    /** How long it took, once it finished or failed */
+    durationMs?: number;
+    /** Set when it failed without a response (DNS, refused, aborted, blocked) */
+    failed?: true;
+    /** Why it failed (also set when loading failed after the response) */
+    errorText?: string;
+    /** Set when it was still running when the command returned */
+    pending?: true;
+    /**
+     * Set when the response arrived but its body was still loading when the
+     * command returned (a stream such as EventSource, a slow download)
+     */
+    loading?: true;
+}
+/** How the page changed location during an action */
+export interface PageNavigation {
+    /** URL the page shows after the action */
+    url: string;
+    /** True for a same-document change (history API, hash); false for a new document */
+    sameDocument: boolean;
+    /** HTTP status of the new document, when known */
+    status?: number;
+}
+/** A message (alert, status, flash, error text) the page showed during an action */
+export interface NewMessage {
+    /** Its visible text (close buttons and aria-hidden parts left out), at most 120 characters */
+    text: string;
+    /** The element showing it, e.g. `div#flash.flash.error` */
+    element: string;
+}
+/** What an action changed on the page, besides its triggered requests */
+export interface ActionEffects {
+    /** The page navigated or changed its URL (absent when it did not) */
+    navigation?: PageNavigation;
+    /** Messages that appeared or changed (at most 3; absent when none did) */
+    messages?: NewMessage[];
+    /** "none" when the action had no visible effect: no DOM change, request or navigation */
+    effect?: 'none';
+}
+/** A filled field's value differing from the one given */
+export interface FillValueMismatch {
+    /** Value given (for a select: the chosen option's value; checkboxes: checked/unchecked) */
+    expected: string;
+    /** Value the field has after filling */
+    actual: string;
+    /** Set when the page cut the value to the field's maxlength */
+    truncatedTo?: number;
+    /** Password fields (values masked): length of the value given */
+    expectedLength?: number;
+    /** Password fields (values masked): length of the field's value */
+    actualLength?: number;
+    /** Another field of the form that holds the value given, e.g. `input#first-name` */
+    movedTo?: string;
+}
 /**
  * Result of filling an element.
  */
-export interface FillResult {
+export interface FillResult extends ActionEffects {
     success: boolean;
     error?: string;
     selector?: string;
     value?: string;
+    /** The element acted on, e.g. `input.toggle in div.view "Write report"` */
+    element?: string;
     elementType?: string;
     inputType?: string | null;
     checked?: boolean;
+    /**
+     * Set when the field's value read back after filling is not the one given
+     * (the page rejected, reformatted or moved it; passwords masked)
+     */
+    valueMismatch?: FillValueMismatch;
     suggestion?: string;
     /** Set when the target is a file input (filled through CDP instead) */
     fileInput?: boolean;
+    /** Set when the target is not a field (nor a label of one): a list from another command was likely meant */
+    unsuitableElement?: boolean;
     /** Something the page will likely object to (e.g. a value above max) */
     warning?: string;
     /** Elements the selector matched */
@@ -38,14 +114,20 @@ export interface FillResult {
     exitCode?: number;
     /** Dialogs accepted while the command ran */
     dialogs?: DialogInfo[];
+    /** Requests the action triggered (absent when network telemetry is off) */
+    triggeredRequests?: TriggeredRequest[];
+    /** Requests left out of `triggeredRequests` (it lists the first 50) */
+    triggeredRequestsOmitted?: number;
 }
 /**
  * Result of clicking an element.
  */
-export interface ClickResult {
+export interface ClickResult extends ActionEffects {
     success: boolean;
     error?: string;
     selector?: string;
+    /** The element acted on, e.g. `input.toggle in div.view "Write report"` */
+    element?: string;
     elementType?: string;
     matchCount?: number;
     selectedIndex?: number;
@@ -61,14 +143,20 @@ export interface ClickResult {
     warning?: string;
     /** Dialogs accepted while the command ran */
     dialogs?: DialogInfo[];
+    /** Requests the action triggered (absent when network telemetry is off) */
+    triggeredRequests?: TriggeredRequest[];
+    /** Requests left out of `triggeredRequests` (it lists the first 50) */
+    triggeredRequestsOmitted?: number;
 }
 /**
  * Result of pressing a key on an element.
  */
-export interface PressKeyResult {
+export interface PressKeyResult extends ActionEffects {
     success: boolean;
     error?: string;
     selector?: string;
+    /** The element acted on, e.g. `input.toggle in div.view "Write report"` */
+    element?: string;
     key?: string;
     times?: number;
     /** Modifier keys held, e.g. ["Ctrl", "Shift"] */
@@ -82,17 +170,23 @@ export interface PressKeyResult {
     warning?: string;
     /** Dialogs accepted while the command ran */
     dialogs?: DialogInfo[];
+    /** Requests the action triggered (absent when network telemetry is off) */
+    triggeredRequests?: TriggeredRequest[];
+    /** Requests left out of `triggeredRequests` (it lists the first 50) */
+    triggeredRequestsOmitted?: number;
 }
 /**
  * Result of a scroll operation.
  */
-export interface ScrollResult {
+export interface ScrollResult extends ActionEffects {
     success: boolean;
     error?: string;
     suggestion?: string;
     exitCode?: number;
     scrollType: 'element' | 'position' | 'offset';
     selector?: string;
+    /** The element acted on, e.g. `input.toggle in div.view "Write report"` */
+    element?: string;
     scrolledTo?: {
         x: number;
         y: number;
@@ -113,22 +207,36 @@ export interface ScrollResult {
     matchCount?: number;
     /** Set when the selector matched several elements */
     warning?: string;
+    /** Requests the action triggered (absent when network telemetry is off) */
+    triggeredRequests?: TriggeredRequest[];
+    /** Requests left out of `triggeredRequests` (it lists the first 50) */
+    triggeredRequestsOmitted?: number;
 }
 /**
  * Result of submitting a form.
  */
-export interface SubmitResult {
+export interface SubmitResult extends ActionEffects {
     success: boolean;
     error?: string;
     selector?: string;
+    /** The element acted on, e.g. `input.toggle in div.view "Write report"` */
+    element?: string;
     clicked?: boolean;
+    /** Set when the target is neither a form nor a button: a list from another command was likely meant */
+    unsuitableElement?: boolean;
     networkRequests?: number;
     navigationOccurred?: boolean;
     waitTimeMs?: number;
+    /** Set when the page loaded but its requests had not finished by the timeout */
+    warning?: string;
     suggestion?: string;
     exitCode?: number;
     /** Dialogs accepted while the command ran */
     dialogs?: DialogInfo[];
+    /** Requests the action triggered (absent when network telemetry is off) */
+    triggeredRequests?: TriggeredRequest[];
+    /** Requests left out of `triggeredRequests` (it lists the first 50) */
+    triggeredRequestsOmitted?: number;
 }
 /** Where an event listener is attached, seen from the inspected element. */
 export type ListenerPlacement = 'target' | 'ancestor' | 'document' | 'window';
@@ -157,6 +265,40 @@ export interface ElementListener {
     passive: boolean;
     once: boolean;
     handler: ListenerHandler;
+    /** The handler does nothing (an empty function, like React's `onclick` placeholder) */
+    noop?: true;
+    /**
+     * Registered through this framework; `handler` is the real handler, not
+     * the framework's dispatcher. React handlers are `on…` props of the node
+     * (`reactProp`), run by React's dispatchers on its root container.
+     */
+    framework?: 'jQuery' | 'React';
+    /** React prop the handler is set as, e.g. `onClick`, `onClickCapture` */
+    reactProp?: string;
+    /** jQuery delegate selector (`.on(type, selector, fn)`) the element matched */
+    delegateSelector?: string;
+}
+/**
+ * Listeners of one node collapsed into a summary: a framework root (React's
+ * root container) registers the same few dispatchers for dozens of event types.
+ */
+export interface CollapsedListeners {
+    /** Where the listeners are attached */
+    on: ListenerPlacement;
+    /** The node or object they are attached to, e.g. `div#__next` */
+    node: string;
+    /** Framework recognised on the node, e.g. `React root` */
+    framework?: string;
+    /** Event types, alphabetically */
+    types: string[];
+    /** Number of listeners collapsed */
+    count: number;
+    /** Some listen in the capture phase */
+    capture: boolean;
+    /** Some listen in the bubble phase */
+    bubble: boolean;
+    /** The distinct dispatcher functions */
+    handlers: ListenerHandler[];
 }
 /**
  * Event listeners of an element, its ancestors, its document and window,
@@ -172,11 +314,106 @@ export interface ListenersResult {
     /** The inspected element, e.g. `button#save` */
     element: string;
     listeners: ElementListener[];
+    /** Framework root listeners, one entry per node (missing with `all`) */
+    collapsed?: CollapsedListeners[];
+    /** The iframe element whose document holds the element, e.g. `iframe#checkout` */
+    frame?: string;
+    /** jQuery handlers not resolved (over 50 per call): their dispatcher is listed instead */
+    jqueryHandlersSkipped?: number;
+    /** React `on…` props not resolved (over 50 per call) */
+    reactHandlersSkipped?: number;
+    /** Event types with listeners close to the requested ones, when none matched (`Click` → `click`) */
+    typeSuggestions?: string[];
     /** Elements the selector matched */
     matchCount?: number;
     /** Set when several elements matched and no --index was given */
     warning?: string;
 }
+/** A point in CSS pixels. */
+export interface LayoutPoint {
+    x: number;
+    y: number;
+}
+/** A width and height in CSS pixels. */
+export interface LayoutSize {
+    width: number;
+    height: number;
+}
+/** Position and size of an element's border box in CSS pixels. */
+export type LayoutBox = LayoutPoint & LayoutSize;
+/** Computed styles that decide whether and how an element shows. */
+export interface LayoutComputedStyle {
+    display: string;
+    visibility: string;
+    position: string;
+    opacity: string;
+    zIndex: string;
+}
+/** Where one element is on the page and whether a user can see it. */
+export interface ElementLayout {
+    /** Index among the selector's matches (or in the cached query) */
+    index: number;
+    tag: string;
+    /** Short description, e.g. `button#save.primary` */
+    element: string;
+    /** Text preview */
+    text?: string;
+    /** Enclosing iframe(s) and shadow root, e.g. `iframe#pay > shadow root of <x-card>` */
+    context?: string;
+    /** Border box relative to the top-level document (page coordinates) */
+    bounds: LayoutBox;
+    /** Top-left corner relative to the top-level viewport */
+    viewport: LayoutPoint;
+    inViewport: ViewportPosition;
+    /** Share of the element in view, for `partly` */
+    percentVisible?: number;
+    /** Why it is `hidden`, e.g. `display: none` */
+    hiddenReason?: string;
+    /**
+     * Page scroll (`window.scrollBy`) that shows all of it, when the page can
+     * scroll there: for a `partly` visible element the smallest such scroll (the
+     * part cut off at the edge; the start of one larger than the viewport), for
+     * one out of view the scroll centring it (as `dom scroll <selector>` does)
+     */
+    scrollBy?: LayoutPoint;
+    /** Ancestor or iframe cutting it off (scroll that container instead of the page) */
+    clippedBy?: string;
+    /** Why page scroll cannot bring it fully into view: it is fixed, or beyond the page's scroll range */
+    offScreenReason?: string;
+    /** Topmost element at the center of its visible part, when that is another element */
+    coveredBy?: string;
+    /**
+     * Why it cannot be seen although it is rendered: `opacity: 0` on it or an
+     * ancestor, or a `clip-path`/`clip` that cuts it away entirely, e.g.
+     * `opacity: 0 on div#menu` (`inViewport` still says where it is)
+     */
+    invisible?: string;
+    /** Inside an `inert` element: shown, but a user cannot interact with it */
+    inert?: true;
+    computed: LayoutComputedStyle;
+}
+/** Viewport, scroll position and document size of the top-level page. */
+export interface PageLayout {
+    /** Layout viewport without scrollbars (as `dom scroll` reports it) */
+    viewport: LayoutSize;
+    scroll: LayoutPoint;
+    document: LayoutSize;
+    /** `prefers-color-scheme` the page sees (the system's unless `--color-scheme` was given at start) */
+    colorScheme?: 'light' | 'dark';
+}
+/** Layout of the elements a selector (or cached index) refers to. */
+export interface LayoutResult {
+    /** Always true: failures are reported as errors */
+    success: true;
+    /** Selector the elements were found with (for an index: the cached query's) */
+    selector: string;
+    /** Elements the selector matched (1 for an index) */
+    count: number;
+    page: PageLayout;
+    elements: ElementLayout[];
+    /** Matches left out of `elements` (beyond the limit) */
+    omitted?: number;
+}
 /**
  * Raw form data returned from the page-context form-discovery script.
  */
@@ -186,6 +423,8 @@ export interface RawFormData {
     frameForms?: Array<{
         url: string;
     }>;
+    /** The page's `document.readyState` when the forms were read */
+    readyState?: string;
 }
 export interface RawForm {
     index: number;
@@ -194,6 +433,10 @@ export interface RawForm {
     method: string;
     step: FormStep | null;
     relevanceScore: number;
+    /** Not rendered (or visibility-hidden), or all its fields are */
+    hidden?: boolean;
+    /** Shown inside an open dialog (`dialog[open]`, `aria-modal`, a dialog role) */
+    inDialog?: boolean;
     inIframe: boolean;
     iframeUrl?: string;
     crossOrigin?: boolean;
@@ -209,7 +452,10 @@ export interface RawField {
     label: string;
     name: string | null;
     placeholder?: string;
+    /** `required`, aria-required, or a label marked with an asterisk */
     required: boolean;
+    /** Name of the radio/checkbox group (legend, radiogroup label or name) */
+    groupLabel?: string;
     disabled: boolean;
     readOnly: boolean;
     hidden: boolean;
@@ -231,6 +477,11 @@ export interface RawButton {
     label: string;
     type: string;
     disabled: boolean;
-    isPrimary: boolean;
+    /** A submit button by markup: `<input type=submit>` or `type="submit"` written out */
+    explicitSubmit: boolean;
+    /** A `<button>` without a type in a form: submits it, like Enter does */
+    formDefault: boolean;
+    /** Has a class like `primary`, `btn-primary` or `submit` */
+    primaryClass: boolean;
 }
 //# sourceMappingURL=domTypes.d.ts.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. */