browser-debugger-cli 0.10.0 → 0.12.0

package/dist/ipc/client.d.ts

@@ -231,6 +231,10 @@ export declare function domFormDiscover(): Promise<ClientResponse<'dom_form_disc
 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'>>;
+/** Page-wide checks: contrast, overflow, layers, animations. */
+export declare function domAudit(params: NoType<(typeof COMMANDS)['dom_audit']['requestSchema']>): Promise<ClientResponse<'dom_audit'>>;
+/** Find text in the page's stylesheets. */
+export declare function cssSearch(params: NoType<(typeof COMMANDS)['css_search']['requestSchema']>): Promise<ClientResponse<'css_search'>>;
 /** What one element looks like: styles, box, layout and child tree. */
 export declare function domInspect(params: NoType<(typeof COMMANDS)['dom_inspect']['requestSchema']>): Promise<ClientResponse<'dom_inspect'>>;
 /**

package/dist/ipc/client.js

@@ -334,6 +334,14 @@ export async function domListeners(params) {
 export async function domLayout(params) {
     return sendCommand('dom_layout', params);
 }
+/** Page-wide checks: contrast, overflow, layers, animations. */
+export async function domAudit(params) {
+    return sendCommand('dom_audit', params);
+}
+/** Find text in the page's stylesheets. */
+export async function cssSearch(params) {
+    return sendCommand('css_search', params);
+}
 /** What one element looks like: styles, box, layout and child tree. */
 export async function domInspect(params) {
     return sendCommand('dom_inspect', params);

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

@@ -0,0 +1,129 @@
+/**
+ * Types of `bdg dom audit` (page-wide checks) and `bdg css search`.
+ */
+/** A check `dom audit` can run */
+export type AuditCheck = 'contrast' | 'overflow' | 'layers' | 'animations';
+/** Every check, in the order they are shown */
+export declare const AUDIT_CHECKS: readonly AuditCheck[];
+/** Text below the contrast level */
+export interface AuditContrastItem {
+    /** `tag#id` or `tag.firstClass` */
+    element: string;
+    text: string;
+    /** WCAG ratio, rounded down to 2 decimals */
+    ratio: number;
+    color: string;
+    /** Background behind the text, composited */
+    background: string;
+    /** Font size (px) and weight: large text needs less contrast */
+    size: number;
+    weight: number;
+    inView: boolean;
+    /** Why the ratio is approximate (blend modes, filters) */
+    approximate?: string[];
+}
+/** An image drawn larger than its pixels, or with another aspect ratio */
+export interface AuditImage {
+    element: string;
+    natural: {
+        w: number;
+        h: number;
+    };
+    rendered: {
+        w: number;
+        h: number;
+    };
+    /** Pixels needed (rendered size × pixel ratio) over the image's pixels, the larger of width and height */
+    scale: number;
+    /** Identical findings this one stands for (2 or more) */
+    count?: number;
+    upscaled?: true;
+    distorted?: true;
+}
+/** What `dom audit` found */
+export interface AuditResult {
+    checks: AuditCheck[];
+    /** Elements walked */
+    walked: number;
+    /** The walk stopped at its cap: the page has more elements */
+    capped?: true;
+    contrast?: {
+        level: 'AA' | 'AAA';
+        /** Text holders checked */
+        checked: number;
+        /** How many are below the level */
+        failing: number;
+        /** The weakest ones, at most `--limit` */
+        items: AuditContrastItem[];
+    };
+    overflow?: {
+        pageWidth: number;
+        viewportWidth: number;
+        /** The page is wider than its viewport (it scrolls sideways) */
+        scrollsSideways: boolean;
+        /** Elements reaching past the viewport's right edge (not inside a scroller), farthest first */
+        wide: Array<{
+            element: string;
+            right: number;
+            width: number;
+        }>;
+        /** Text cut off: `ellipsis`, `clamp` or `clip` */
+        truncated: Array<{
+            element: string;
+            text: string;
+            kind: string;
+            count?: number;
+        }>;
+        images: AuditImage[];
+        /** Device pixel ratio the image scale counts in (an image needs that many pixels per CSS px) */
+        pixelRatio: number;
+        /** Elements whose content scrolls sideways inside them (carousels, tab strips): fine, but cut off at first sight */
+        scrollers: Array<{
+            element: string;
+            scrollWidth: number;
+            width: number;
+        }>;
+    };
+    layers?: Array<{
+        element: string;
+        position: string;
+        zIndex: string;
+        /** Viewport position and size */
+        rect: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
+        inView: boolean;
+    }>;
+    animations?: Array<{
+        element: string;
+        name: string;
+        type: string;
+        /** Duration (ms) */
+        duration: number | string;
+        iterations: number | string;
+        /** Driven by scrolling, not time */
+        scrollDriven?: true;
+        /** Identical animations this one stands for (2 or more) */
+        count?: number;
+    }>;
+}
+/** A stylesheet line where `css search` found the text */
+export interface CssSearchMatch {
+    /** `app.css:12`, `bootstrap.min.css:5:52628`, `<style> in index.html:40` */
+    source: string;
+    /** The rule (or line) around the match, cut to a few hundred characters */
+    text: string;
+}
+/** What `css search` found */
+export interface CssSearchResult {
+    query: string;
+    /** Stylesheets searched */
+    sheets: number;
+    /** Matches found (the list may be shorter: `--limit`) */
+    total: number;
+    matches: CssSearchMatch[];
+}
+//# sourceMappingURL=auditTypes.d.ts.map

package/dist/ipc/protocol/auditTypes.js

@@ -0,0 +1,6 @@
+/**
+ * Types of `bdg dom audit` (page-wide checks) and `bdg css search`.
+ */
+/** Every check, in the order they are shown */
+export const AUDIT_CHECKS = ['contrast', 'overflow', 'layers', 'animations'];
+//# sourceMappingURL=auditTypes.js.map

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

@@ -5,6 +5,7 @@
  * Each command has a request schema (input) and response data schema (output).
  */
 import type { HintDetails } from '../../errors/notices.js';
+import type { AuditCheck, AuditResult, CssSearchResult } from './auditTypes.js';
 import type { ClickResult, FillResult, LayoutResult, ListenersResult, PressKeyResult, RawFormData, ScrollResult, SubmitResult } from './domTypes.js';
 import type { InspectResult } from './inspectTypes.js';
 import type { PageState, SessionActivity } from '../session/types.js';
@@ -312,6 +313,26 @@ export interface DomLayoutCommand {
     backendNodeId?: number;
 }
 export type DomLayoutData = LayoutResult;
+/**
+ * dom_audit: page-wide checks (contrast, overflow, layers, animations).
+ */
+export interface DomAuditCommand {
+    checks: AuditCheck[];
+    /** WCAG level text must reach (default AA) */
+    level?: 'AA' | 'AAA';
+    /** Findings listed per check */
+    limit?: number;
+}
+export type DomAuditData = AuditResult;
+/**
+ * css_search: find text in the page's stylesheets.
+ */
+export interface CssSearchCommand {
+    query: string;
+    /** Matches listed at most */
+    limit?: number;
+}
+export type CssSearchData = CssSearchResult;
 /**
  * dom_inspect: what one element looks like (styles, box, layout, child tree).
  */
@@ -369,6 +390,8 @@ export type RegistryShape = {
     dom_form_discover: CommandDef<DomFormDiscoverCommand, DomFormDiscoverData>;
     dom_listeners: CommandDef<DomListenersCommand, DomListenersData>;
     dom_layout: CommandDef<DomLayoutCommand, DomLayoutData>;
+    dom_audit: CommandDef<DomAuditCommand, DomAuditData>;
+    css_search: CommandDef<CssSearchCommand, CssSearchData>;
     dom_inspect: CommandDef<DomInspectCommand, DomInspectData>;
     dom_wait: CommandDef<DomWaitCommand, DomWaitData>;
     page_navigate: CommandDef<PageNavigateCommand, PageNavigationResult>;

package/dist/ipc/protocol/commands.js

@@ -35,6 +35,8 @@ export const COMMANDS = {
     dom_form_discover: defineCommand(),
     dom_listeners: defineCommand(),
     dom_layout: defineCommand(),
+    dom_audit: defineCommand(),
+    css_search: defineCommand(),
     dom_inspect: defineCommand(),
     dom_wait: defineCommand(),
 };

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

@@ -86,6 +86,8 @@ export interface ActionEffects {
     navigation?: PageNavigation;
     /** Messages that appeared or changed (at most 3; absent when none did) */
     messages?: NewMessage[];
+    /** How many more new messages there were than `messages` lists */
+    moreMessages?: number;
     /** Elements a hover or key press showed (at most 3, outermost first; absent when none) */
     shown?: ShownElement[];
     /** "none" when the action had no visible effect: no DOM change, request or navigation */
@@ -405,6 +407,8 @@ export interface ElementLayout {
     scrollBy?: LayoutPoint;
     /** Ancestor or iframe cutting it off (scroll that container instead of the page) */
     clippedBy?: string;
+    /** It or a container is `position: fixed`: page scroll does not move it */
+    fixed?: true;
     /** 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 */

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

@@ -14,6 +14,13 @@ export interface InspectRect {
     y: number;
     w: number;
     h: number;
+    /** `viewport`: x and y are in the viewport (a fixed element stays there however the page scrolls) */
+    in?: 'viewport';
+    /** Size of the box it covers on screen when a transform (rotation, skew) makes that differ; x and y are its corner */
+    screen?: {
+        w: number;
+        h: number;
+    };
 }
 /** Sides top, right, bottom, left */
 export type Sides = [CssLength, CssLength, CssLength, CssLength];
@@ -104,17 +111,29 @@ export interface InspectContrast {
     /** 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 of the element and its ancestors (below 1): each translucent
+     * element fades its background and the text over it before the ratio is
+     * taken
      */
     opacity?: number;
+    /**
+     * Why the ratio is approximate: `mix-blend-mode hard-light on h1`,
+     * `filter on div.skin-invert`, `canvas behind`, `div.overlay on top`
+     */
+    approximate?: string[];
 }
 /** Typography (for containers without text of their own: only what differs from the parent) */
 export interface InspectText {
+    /**
+     * Label of the descendant that draws most of the text when it is not the
+     * element (`abbr`, `slot.button__label`): the fields describe its text
+     */
+    holder?: string;
     family?: string;
-    /** Font Chrome rendered the text with, when it is not the first family */
+    /** Font Chrome rendered the text with, when it is a fallback for the first family */
     rendered?: string;
+    /** Font a generic first family (`sans-serif`, `system-ui`) resolved to */
+    resolved?: string;
     /** The rendered font is a web font */
     webfont?: boolean;
     weight?: number;
@@ -132,19 +151,30 @@ export interface InspectText {
     clamp?: string;
     shadow?: string;
     features?: string;
+    /** The text is cut off (clipped by overflow, with or without an ellipsis, or by a line clamp) */
+    truncated?: true;
+    /** The text is painted with its background (`background-clip: text`, transparent fill): no single color, so no contrast */
+    gradientFill?: true;
 }
 /** A background layer */
 export type InspectFill = {
     type: 'solid';
     color: string;
 } | {
-    type: 'gradient';
-    value: string;
-} | {
-    type: 'image';
+    type: 'gradient' | 'image';
     value: string;
     size?: string;
+    position?: string;
 };
+/** How an SVG element is painted */
+export interface InspectSvgPaint {
+    /** Fill color (hex), `none` or a paint server (`url(#grad)`) */
+    fill: string;
+    /** Stroke color, `none` or a paint server */
+    stroke: string;
+    /** Stroke width (px), when there is a stroke */
+    strokeWidth?: CssLength;
+}
 /** A border side (or all four) */
 export interface InspectStroke {
     side: 'all' | 'top' | 'right' | 'bottom' | 'left';
@@ -184,6 +214,8 @@ export interface InspectPseudo {
     content?: string;
     display?: string;
     position?: string;
+    /** Offsets of a positioned one (top right bottom left) */
+    inset?: string;
     size?: {
         w: number;
         h: number;
@@ -212,6 +244,12 @@ export interface InspectTreeNode {
     /** `flex` or `grid` container */
     layout?: 'flex' | 'grid';
     text?: string;
+    /** `display: contents` (a text-only slot): no box of its own */
+    contents?: true;
+    /** Reached through a slot or a `display: contents` wrapper (`slot.label`, `div.row (contents)`) */
+    via?: string;
+    /** In the shadow root of its parent */
+    shadow?: true;
     /** Identical siblings this row stands for (2 or more) */
     count?: number;
     children?: InspectTreeNode[];
@@ -251,6 +289,10 @@ export interface InspectHint {
     reason: string;
     /** e.g. `use display: flex or grid on this element` */
     fix: string;
+    /** The longhands of a shorthand that have no effect, when the others do (`margin-top`, `margin-bottom`) */
+    only?: string[];
+    /** The custom properties that are not set (`unset-variable`) */
+    variables?: string[];
     /** e.g. `.hero (app.css:12)` */
     source: string;
 }
@@ -264,6 +306,8 @@ export interface InspectRule {
     computed?: string;
     /** e.g. `.btn-primary (bootstrap.min.css:5:52628)`, `style attribute` */
     source: string;
+    /** The rule as written (selector and declarations); a rule over 300 characters is cut to its selector and this declaration */
+    rule?: string;
     /** Selectors of the declarations it beats */
     overrides?: string[];
     /** Set on an ancestor this many levels up (inherited) */
@@ -286,8 +330,15 @@ export interface InspectWhyEntry {
     source: string;
     /** Specificity of the rule's selector (ids, classes, types) */
     specificity?: [number, number, number];
+    /** The rule as written (selector and declarations); a rule over 300 characters is cut to its selector and this declaration */
+    rule?: string;
     /** `applied` (wins), `overridden`, or `inherited` (from an ancestor: the winner, or one it beat there) */
     status: 'applied' | 'overridden' | 'inherited';
+    /**
+     * Why the winner changes nothing: `no effect: position is static`, or for
+     * an invalid `var()`, what applies instead (`falls back to the initial value`)
+     */
+    note?: string;
     important?: true;
     layer?: string;
     condition?: string;
@@ -300,6 +351,12 @@ export interface InspectWhy {
     chain: InspectWhyEntry[];
     /** Where the custom properties of the winning value are set */
     variables?: InspectVariable[];
+    /** Rules for the element that set it under a `@media`/`@supports` condition that does not apply now */
+    inactive?: Array<{
+        value: string;
+        selector: string;
+        condition: string;
+    }>;
 }
 /** A custom property a winning value uses, and where it is set */
 export interface InspectVariable {
@@ -324,6 +381,8 @@ export interface InspectResult {
      * rendered) or the first
      */
     picked?: 'first-visible' | 'first';
+    /** The selector named a pseudo-element (`a::after`): its element was inspected, the pseudo-element is under `pseudo` */
+    pseudoOf?: '::before' | '::after';
     /** `tag#id.c1.c2(+N)` */
     element: string;
     /** Its text (innerText) or form value, at most 30 characters; not for containers */
@@ -341,6 +400,8 @@ export interface InspectResult {
      * theme's
      */
     theme?: 'dark';
+    /** The dark preference behind `theme` comes from `page emulate`, not the system */
+    themeFrom?: 'emulation';
     /**
      * Running CSS transitions (their property) and animations (their name):
      * the values read are mid-way and will still change
@@ -352,6 +413,8 @@ export interface InspectResult {
     layout?: InspectLayout;
     text?: InspectText;
     fills?: InspectFill[];
+    /** SVG paint: `fill` and `stroke` (with its width) of an SVG element */
+    paint?: InspectSvgPaint;
     opacity?: number;
     blend?: string;
     strokes?: InspectStroke[];

package/dist/runtime/css/search.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `bdg css search <text>`: find text in the page's stylesheets, cross-origin
+ * ones included (CDP reads every stylesheet's text), and show the rule
+ * around each match with its `file:line`.
+ */
+import type { CDPConnection } from '../../connection/cdp.js';
+import type { CssSearchResult } from '../../ipc/protocol/auditTypes.js';
+import type { CssSearchCommand } from '../../ipc/protocol/commands.js';
+/** Matches listed without `--limit` */
+export declare const DEFAULT_CSS_SEARCH_LIMIT = 20;
+/**
+ * Search the stylesheets for a text (case-insensitive).
+ *
+ * @param cdp - CDP connection
+ * @param params - Text and limit
+ * @returns Matches with their place
+ */
+export declare function searchStyleSheets(cdp: CDPConnection, params: CssSearchCommand): Promise<CssSearchResult>;
+/**
+ * Where a text occurs in a stylesheet (case-insensitive): how many times,
+ * and for the first `limit` matches the 0-based line and column and the
+ * rule around it (from the end of the previous rule to the end of this one,
+ * whitespace collapsed, at most {@link RULE_CONTEXT} characters each side).
+ * Lines are counted as the search moves on, so a big sheet is read once.
+ *
+ * @param text - Stylesheet text
+ * @param query - Text to find
+ * @param limit - Matches described at most
+ * @returns Match count and the described matches
+ */
+export declare function findInSheet(text: string, query: string, limit?: number): {
+    total: number;
+    matches: Array<{
+        line: number;
+        column: number;
+        rule: string;
+    }>;
+};
+//# sourceMappingURL=search.d.ts.map

package/dist/runtime/css/search.js

@@ -0,0 +1,122 @@
+/**
+ * `bdg css search <text>`: find text in the page's stylesheets, cross-origin
+ * ones included (CDP reads every stylesheet's text), and show the rule
+ * around each match with its `file:line`.
+ */
+import { enableStyleDomains } from '../dom/inspect.js';
+import { stylesheetPositionLabel, styleSheetHeaders } from '../dom/inspectRules.js';
+import { createLogger } from '../../ui/logging/index.js';
+import { getErrorMessage } from '../../utils/errors.js';
+const log = createLogger('dom');
+/** Matches listed without `--limit` */
+export const DEFAULT_CSS_SEARCH_LIMIT = 20;
+/** Characters of a rule shown around a match */
+const RULE_CONTEXT = 240;
+/**
+ * Search the stylesheets for a text (case-insensitive).
+ *
+ * @param cdp - CDP connection
+ * @param params - Text and limit
+ * @returns Matches with their place
+ */
+export async function searchStyleSheets(cdp, params) {
+    await enableStyleDomains(cdp);
+    const headers = [...styleSheetHeaders(cdp)].filter((header) => header.origin !== 'user-agent');
+    const limit = params.limit ?? DEFAULT_CSS_SEARCH_LIMIT;
+    const texts = await Promise.all(headers.map((header) => sheetText(cdp, header.styleSheetId)));
+    const matches = [];
+    let total = 0;
+    headers.forEach((header, i) => {
+        const found = findInSheet(texts[i] ?? '', params.query, Number.POSITIVE_INFINITY);
+        const seen = new Set();
+        for (const match of found.matches) {
+            if (seen.has(match.rule))
+                continue;
+            seen.add(match.rule);
+            total++;
+            if (matches.length >= limit)
+                continue;
+            matches.push({
+                source: stylesheetPositionLabel(header, match.line, match.column),
+                text: match.rule,
+            });
+        }
+    });
+    return { query: params.query, sheets: headers.length, total, matches };
+}
+/**
+ * A stylesheet's text; empty when Chrome cannot give it.
+ *
+ * @param cdp - CDP connection
+ * @param styleSheetId - Stylesheet
+ * @returns Text
+ */
+async function sheetText(cdp, styleSheetId) {
+    try {
+        const response = (await cdp.send('CSS.getStyleSheetText', {
+            styleSheetId,
+        }));
+        return response.text;
+    }
+    catch (error) {
+        log.debug(`No text for stylesheet ${styleSheetId}: ${getErrorMessage(error)}`);
+        return '';
+    }
+}
+/**
+ * Where a text occurs in a stylesheet (case-insensitive): how many times,
+ * and for the first `limit` matches the 0-based line and column and the
+ * rule around it (from the end of the previous rule to the end of this one,
+ * whitespace collapsed, at most {@link RULE_CONTEXT} characters each side).
+ * Lines are counted as the search moves on, so a big sheet is read once.
+ *
+ * @param text - Stylesheet text
+ * @param query - Text to find
+ * @param limit - Matches described at most
+ * @returns Match count and the described matches
+ */
+export function findInSheet(text, query, limit = Number.POSITIVE_INFINITY) {
+    const matches = [];
+    const haystack = text.toLowerCase();
+    const needle = query.toLowerCase();
+    if (needle === '')
+        return { total: 0, matches };
+    let total = 0;
+    let line = 0;
+    let lineStart = 0;
+    let scanned = 0;
+    for (let at = haystack.indexOf(needle); at >= 0; at = haystack.indexOf(needle, at + needle.length)) {
+        total++;
+        if (matches.length >= limit)
+            continue;
+        for (let i = text.indexOf('\n', scanned); i >= 0 && i < at; i = text.indexOf('\n', i + 1)) {
+            line++;
+            lineStart = i + 1;
+        }
+        scanned = at;
+        matches.push({ line, column: at - lineStart, rule: ruleAround(text, at) });
+    }
+    return { total, matches };
+}
+/**
+ * The rule around a position: whole when short, else its selector and the
+ * declarations near the position (`.btn { … color: var(--brand); … }`),
+ * whitespace collapsed.
+ *
+ * @param text - Stylesheet text
+ * @param at - Position of the match
+ * @returns Rule text
+ */
+function ruleAround(text, at) {
+    const ruleStart = text.lastIndexOf('}', at) + 1;
+    const open = text.indexOf('{', ruleStart);
+    const close = text.indexOf('}', at);
+    const ruleEnd = close < 0 ? text.length : close + 1;
+    const collapse = (part) => part.replace(/\s+/g, ' ').trim();
+    if (ruleEnd - ruleStart <= 2 * RULE_CONTEXT || open < 0 || open > at) {
+        return collapse(text.slice(Math.max(ruleStart, at - RULE_CONTEXT), Math.min(ruleEnd, at + RULE_CONTEXT)));
+    }
+    const near = collapse(text.slice(Math.max(open + 1, at - RULE_CONTEXT / 2), Math.min(ruleEnd - 1, at + RULE_CONTEXT / 2)));
+    return `${collapse(text.slice(ruleStart, open))} { … ${near} … }`;
+}
+//# sourceMappingURL=search.js.map

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

@@ -81,7 +81,10 @@ export interface OtherActivity {
  * @param newDocument - Whether a new document loaded
  * @returns New messages
  */
-export declare function newMessages(before: SeenMessage[], after: SeenMessage[], newDocument: boolean): NewMessage[];
+export declare function newMessages(before: SeenMessage[], after: SeenMessage[], newDocument: boolean): {
+    messages: NewMessage[];
+    more: number;
+};
 /**
  * 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

package/dist/runtime/dom/actionEffects.js

@@ -81,8 +81,6 @@ export function newMessages(before, after, newDocument) {
     const reported = new Set();
     const result = [];
     for (const message of after) {
-        if (result.length >= MAX_NEW_MESSAGES)
-            break;
         if (reported.has(message.text) || TICKING_TEXT.test(message.text))
             continue;
         if (!isNew(message))
@@ -90,7 +88,10 @@ export function newMessages(before, after, newDocument) {
         reported.add(message.text);
         result.push({ text: cutText(message.text), element: message.element });
     }
-    return result;
+    return {
+        messages: result.slice(0, MAX_NEW_MESSAGES),
+        more: Math.max(0, result.length - MAX_NEW_MESSAGES),
+    };
 }
 /**
  * Cut a text to {@link MAX_MESSAGE_LENGTH} characters, marking the cut.
@@ -333,11 +334,14 @@ function pageWork(watch, snapshot, domChanging = false) {
  */
 function effectsOf(start, snapshot, events) {
     const navigation = pageNavigation(start?.href, snapshot, events);
-    const messages = start && snapshot ? newMessages(start.messages, snapshot.messages, snapshot.fresh) : [];
+    const { messages, more } = start && snapshot
+        ? newMessages(start.messages, snapshot.messages, snapshot.fresh)
+        : { messages: [], more: 0 };
     const shown = shownElements(snapshot?.shown ?? [], messages);
     return {
         ...(navigation && { navigation }),
         ...(messages.length > 0 && { messages }),
+        ...(more > 0 && { moreMessages: more }),
         ...(shown.length > 0 && { shown }),
     };
 }

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

@@ -0,0 +1,19 @@
+/**
+ * `bdg dom audit`: page-wide checks in one page walk
+ * ({@link AUDIT_PAGE_JS}), turned into findings by {@link buildAudit}.
+ */
+import type { CDPConnection } from '../../connection/cdp.js';
+import type { AuditResult } from '../../ipc/protocol/auditTypes.js';
+import type { DomAuditCommand } from '../../ipc/protocol/commands.js';
+/** Findings listed per check without `--limit` */
+export declare const DEFAULT_AUDIT_LIMIT = 20;
+/**
+ * Run the page-wide checks.
+ *
+ * @param cdp - CDP connection
+ * @param params - Checks, WCAG level and limit
+ * @returns Findings
+ * @throws CommandError (91) when the page script fails
+ */
+export declare function auditPage(cdp: CDPConnection, params: DomAuditCommand): Promise<AuditResult>;
+//# sourceMappingURL=audit.d.ts.map