browser-debugger-cli 0.13.0 → 0.14.0

package/dist/telemetry/network.js

@@ -1,12 +1,13 @@
 import { CDPHandlerRegistry } from '../connection/handlers.js';
 import { TypedCDPConnection } from '../connection/typed-cdp.js';
-import { MAX_NETWORK_REQUESTS, MAX_RESPONSE_SIZE, CHROME_NETWORK_BUFFER_TOTAL, CHROME_NETWORK_BUFFER_PER_RESOURCE, CHROME_POST_DATA_LIMIT, } from '../constants.js';
+import { MAX_NETWORK_REQUESTS, MAX_RESPONSE_SIZE, MAX_TOTAL_BODY_BYTES, CHROME_NETWORK_BUFFER_TOTAL, CHROME_NETWORK_BUFFER_PER_RESOURCE, CHROME_POST_DATA_LIMIT, } from '../constants.js';
 import { attachChildTargets } from './attachedTargets.js';
 import { createLogger } from '../ui/logging/index.js';
 import { getErrorMessage } from '../utils/errors.js';
 import { filterDefined } from '../utils/objects.js';
 import { shouldExcludeDomain, shouldExcludeUrl, shouldFetchBodyWithReason } from './filters.js';
 import { ExtraInfoTracker } from './networkExtraInfo.js';
+import { RequestRetention, skippedBodyPlaceholder, } from './networkRetention.js';
 const log = createLogger('network');
 /**
  * Check if a request should be filtered out based on domain and URL patterns.
@@ -21,27 +22,26 @@ function shouldFilterRequest(url, includeAll, networkInclude, networkExclude) {
     return false;
 }
 /**
- * Fetch response body for a request with cancellation support.
+ * Fetch response body for a request with cancellation support: a body that
+ * arrives after its fetch was cancelled (removed from `pendingFetches`: the
+ * collector stopped, or the request was dropped) is discarded.
  *
  * @param cdp - CDP connection instance
  * @param requestId - Request ID to fetch body for
- * @param request - Network request object to populate with body
+ * @param request - Network request the body belongs to
  * @param pendingFetches - Set to track pending fetch operations for cleanup
+ * @param retention - Stores the body within the session's body budget
+ * @param sessionId - Session of the iframe or worker that made the request
  */
-function fetchResponseBody(cdp, requestId, request, pendingFetches, sessionId) {
+function fetchResponseBody(cdp, requestId, request, pendingFetches, retention, sessionId) {
     pendingFetches.add(requestId);
     void cdp
         .send('Network.getResponseBody', { requestId }, sessionId)
         .then((response) => {
         if (!pendingFetches.has(requestId))
             return;
-        const typedResponse = response;
-        request.responseBody = typedResponse.body;
-        if (typedResponse.base64Encoded)
-            request.responseBodyBase64 = true;
-        if (typedResponse.body) {
-            request.decodedBodyLength = Buffer.byteLength(typedResponse.body, typedResponse.base64Encoded ? 'base64' : 'utf-8');
-        }
+        const { body, base64Encoded } = response;
+        retention.storeBody(request, body, base64Encoded);
     })
         .catch((error) => {
         log.debug(`Failed to fetch response body for request ${requestId}: ${getErrorMessage(error)}`);
@@ -83,25 +83,6 @@ function createNetworkRequest(params, getCurrentNavigationId) {
         ...(params.type !== undefined && { resourceType: params.type }),
     };
 }
-const SKIPPED_BODY_PATTERN = /^\[SKIPPED: (.*)\]$/s;
-/**
- * Placeholder stored instead of a response body that was not fetched.
- *
- * @param reason - Why the body was skipped
- * @returns Placeholder text shown by `bdg details`
- */
-export function skippedBodyPlaceholder(reason) {
-    return `[SKIPPED: ${reason}]`;
-}
-/**
- * Extract the reason from a skipped-body placeholder.
- *
- * @param body - Stored response body
- * @returns Reason if `body` is a placeholder, otherwise undefined
- */
-export function skippedBodyReason(body) {
-    return body === undefined ? undefined : SKIPPED_BODY_PATTERN.exec(body)?.[1];
-}
 /**
  * Copy response fields (status, headers, timing, connection) onto a request.
  *
@@ -272,21 +253,31 @@ async function collectChildTargetNetwork(cdp) {
  *
  * @remarks
  * - Chrome buffer limits: 50MB total, 10MB per resource, 1MB POST data (with fallback)
- * - Stale requests (incomplete after 60s) are removed from tracking but NOT added to output
- * - Request limit of 10,000 prevents memory issues in long-running sessions
+ * - The newest 10,000 finished requests are kept: past that the oldest finished
+ *   ones are dropped (counted in `evictions.requestsDropped`); requests in flight
+ *   are tracked separately and never dropped mid-flight
+ * - Stored response bodies total at most 100MB: past that the oldest bodies are
+ *   replaced by a placeholder (counted in `evictions.bodiesEvicted`), their
+ *   request metadata stays
  * - Response bodies are automatically skipped for images, fonts, CSS, and source maps (see DEFAULT_SKIP_BODY_PATTERNS)
  * - Response bodies larger than 5MB are skipped with a placeholder message
  * - By default, common tracking/analytics domains are filtered out (use includeAll to disable)
  * - Pattern precedence: include patterns always trump exclude patterns
  */
 export async function startNetworkCollection(cdp, requests, options = {}) {
-    const { includeAll = false, fetchAllBodies = false, fetchBodiesInclude = [], fetchBodiesExclude = [], networkInclude = [], networkExclude = [], maxBodySize = MAX_RESPONSE_SIZE, getCurrentNavigationId, } = options;
+    const { includeAll = false, fetchAllBodies = false, fetchBodiesInclude = [], fetchBodiesExclude = [], networkInclude = [], networkExclude = [], maxBodySize = MAX_RESPONSE_SIZE, maxRequests = MAX_NETWORK_REQUESTS, maxTotalBodyBytes = MAX_TOTAL_BODY_BYTES, evictions = { requestsDropped: 0, bodiesEvicted: 0 }, getCurrentNavigationId, } = options;
     const requestMap = options.pendingRequests ?? new Map();
     const pendingFetches = new Set();
     const redirectHops = new Map();
     const extraInfo = new ExtraInfoTracker((requestId) => requestMap.get(requestId)?.request);
     const registry = new CDPHandlerRegistry();
     const typed = new TypedCDPConnection(cdp);
+    const retention = new RequestRetention(requests, { maxRequests, maxTotalBodyBytes }, evictions);
+    const record = (request) => {
+        const dropped = retention.add(request);
+        if (dropped)
+            pendingFetches.delete(dropped.requestId);
+    };
     let bodiesFetched = 0;
     let bodiesSkipped = 0;
     try {
@@ -305,11 +296,9 @@ export async function startNetworkCollection(cdp, requests, options = {}) {
         const entry = requestMap.get(requestId);
         if (!entry)
             return;
-        if (requests.length < MAX_NETWORK_REQUESTS) {
-            applyFailure(entry.request, failure);
-            requests.push(entry.request);
-            extraInfo.complete(requestId, entry.request);
-        }
+        applyFailure(entry.request, failure);
+        record(entry.request);
+        extraInfo.complete(requestId, entry.request);
         requestMap.delete(requestId);
         redirectHops.delete(requestId);
     };
@@ -349,16 +338,11 @@ export async function startNetworkCollection(cdp, requests, options = {}) {
             const hop = completeRedirectHop(previous.request, params, redirectHops);
             extraInfo.applyResponse(params.requestId, hop);
             extraInfo.recordRedirectHop(params.requestId, hop);
-            if (requests.length < MAX_NETWORK_REQUESTS)
-                requests.push(hop);
+            record(hop);
         }
         if (shouldFilterRequest(params.request.url, includeAll, networkInclude, networkExclude)) {
             return;
         }
-        if (requestMap.size >= MAX_NETWORK_REQUESTS) {
-            log.debug(`Warning: Network request limit reached (${MAX_NETWORK_REQUESTS}), dropping new requests`);
-            return;
-        }
         const request = createNetworkRequest(params, getCurrentNavigationId);
         extraInfo.applyRequest(params.requestId, request);
         if (params.type === 'Document' && params.loaderId) {
@@ -399,12 +383,6 @@ export async function startNetworkCollection(cdp, requests, options = {}) {
         const entry = requestMap.get(params.requestId);
         if (!entry)
             return;
-        if (requests.length >= MAX_NETWORK_REQUESTS) {
-            log.debug(`Warning: Network request limit reached (${MAX_NETWORK_REQUESTS})`);
-            requestMap.delete(params.requestId);
-            redirectHops.delete(params.requestId);
-            return;
-        }
         const request = entry.request;
         if (params.encodedDataLength !== undefined) {
             request.encodedDataLength = params.encodedDataLength;
@@ -419,13 +397,13 @@ export async function startNetworkCollection(cdp, requests, options = {}) {
         });
         if (decision.should) {
             bodiesFetched++;
-            fetchResponseBody(cdp, params.requestId, request, pendingFetches, entry.sessionId);
+            fetchResponseBody(cdp, params.requestId, request, pendingFetches, retention, entry.sessionId);
         }
         else {
             bodiesSkipped++;
             request.responseBody = skippedBodyPlaceholder(decision.reason ?? 'not captured');
         }
-        requests.push(request);
+        record(request);
         extraInfo.complete(params.requestId, request);
         requestMap.delete(params.requestId);
         redirectHops.delete(params.requestId);

package/dist/telemetry/networkRetention.d.ts

@@ -0,0 +1,83 @@
+/**
+ * What the network collector keeps of a long session: the newest finished
+ * requests up to a cap, and the newest response bodies up to a total size.
+ */
+import type { NetworkRequest } from '../types.js';
+/** Counts of what the session let go at its limits */
+export interface NetworkEvictions {
+    /** Finished requests dropped at the request cap, oldest first */
+    requestsDropped: number;
+    /** Response bodies replaced by a placeholder at the total body budget, oldest first */
+    bodiesEvicted: number;
+}
+/** Limits of {@link RequestRetention} */
+export interface RetentionLimits {
+    /** Finished requests kept at most */
+    maxRequests: number;
+    /** Total size of the stored response bodies (bytes) */
+    maxTotalBodyBytes: number;
+}
+/**
+ * Keeps finished requests, oldest first, dropping the oldest past the cap
+ * (requests in flight are never in the list, so never dropped), and tracks
+ * the size of their stored bodies, replacing the oldest bodies past the
+ * budget with a placeholder that says why.
+ *
+ * Stored bodies are kept in a Map, which iterates in insertion order: its
+ * first entry is the oldest body, and a dropped request's body is removed in
+ * O(1). Dropping from the front of the list is `Array.shift`, which V8 does
+ * without copying for arrays of this size.
+ */
+export declare class RequestRetention {
+    private readonly requests;
+    private readonly limits;
+    private readonly evictions;
+    private readonly bodySizes;
+    private storedBodyBytes;
+    /**
+     * @param requests - Finished requests, oldest first (updated in place)
+     * @param limits - Request cap and body budget
+     * @param evictions - Counters updated on each drop and eviction
+     */
+    constructor(requests: NetworkRequest[], limits: RetentionLimits, evictions: NetworkEvictions);
+    /**
+     * Add a finished request, dropping the oldest one past the cap.
+     *
+     * @param request - Finished request
+     * @returns The dropped request, if one was
+     */
+    add(request: NetworkRequest): NetworkRequest | undefined;
+    /**
+     * Store a fetched response body on a kept request, then evict the oldest
+     * bodies until the total fits the budget (a body larger than the whole
+     * budget is evicted itself). Storing a body again replaces the earlier one.
+     *
+     * @param request - Request the body belongs to
+     * @param body - Body as Chrome returned it
+     * @param base64Encoded - Whether `body` is base64
+     */
+    storeBody(request: NetworkRequest, body: string, base64Encoded: boolean): void;
+    /** Evict the oldest stored bodies while their total is over the budget. */
+    private enforceBodyBudget;
+    /**
+     * Stop counting a request's stored body.
+     *
+     * @param request - Request whose body is let go
+     */
+    private forgetBody;
+}
+/**
+ * Placeholder stored instead of a response body that was not fetched.
+ *
+ * @param reason - Why the body was skipped
+ * @returns Placeholder text shown by `bdg details`
+ */
+export declare function skippedBodyPlaceholder(reason: string): string;
+/**
+ * Extract the reason from a skipped-body placeholder.
+ *
+ * @param body - Stored response body
+ * @returns Reason if `body` is a placeholder, otherwise undefined
+ */
+export declare function skippedBodyReason(body: string | undefined): string | undefined;
+//# sourceMappingURL=networkRetention.d.ts.map

package/dist/telemetry/networkRetention.js

@@ -0,0 +1,117 @@
+/**
+ * What the network collector keeps of a long session: the newest finished
+ * requests up to a cap, and the newest response bodies up to a total size.
+ */
+import { bodyEvictedReason } from '../ui/messages/networkMessages.js';
+/**
+ * Keeps finished requests, oldest first, dropping the oldest past the cap
+ * (requests in flight are never in the list, so never dropped), and tracks
+ * the size of their stored bodies, replacing the oldest bodies past the
+ * budget with a placeholder that says why.
+ *
+ * Stored bodies are kept in a Map, which iterates in insertion order: its
+ * first entry is the oldest body, and a dropped request's body is removed in
+ * O(1). Dropping from the front of the list is `Array.shift`, which V8 does
+ * without copying for arrays of this size.
+ */
+export class RequestRetention {
+    requests;
+    limits;
+    evictions;
+    bodySizes = new Map();
+    storedBodyBytes = 0;
+    /**
+     * @param requests - Finished requests, oldest first (updated in place)
+     * @param limits - Request cap and body budget
+     * @param evictions - Counters updated on each drop and eviction
+     */
+    constructor(requests, limits, evictions) {
+        this.requests = requests;
+        this.limits = limits;
+        this.evictions = evictions;
+    }
+    /**
+     * Add a finished request, dropping the oldest one past the cap.
+     *
+     * @param request - Finished request
+     * @returns The dropped request, if one was
+     */
+    add(request) {
+        this.requests.push(request);
+        if (this.requests.length <= this.limits.maxRequests)
+            return undefined;
+        const dropped = this.requests.shift();
+        if (!dropped)
+            return undefined;
+        this.evictions.requestsDropped++;
+        this.forgetBody(dropped);
+        return dropped;
+    }
+    /**
+     * Store a fetched response body on a kept request, then evict the oldest
+     * bodies until the total fits the budget (a body larger than the whole
+     * budget is evicted itself). Storing a body again replaces the earlier one.
+     *
+     * @param request - Request the body belongs to
+     * @param body - Body as Chrome returned it
+     * @param base64Encoded - Whether `body` is base64
+     */
+    storeBody(request, body, base64Encoded) {
+        this.forgetBody(request);
+        request.responseBody = body;
+        if (base64Encoded)
+            request.responseBodyBase64 = true;
+        if (body) {
+            request.decodedBodyLength = Buffer.byteLength(body, base64Encoded ? 'base64' : 'utf-8');
+        }
+        const size = Buffer.byteLength(body);
+        this.bodySizes.set(request, size);
+        this.storedBodyBytes += size;
+        this.enforceBodyBudget();
+    }
+    /** Evict the oldest stored bodies while their total is over the budget. */
+    enforceBodyBudget() {
+        while (this.storedBodyBytes > this.limits.maxTotalBodyBytes) {
+            const oldest = this.bodySizes.keys().next();
+            if (oldest.done)
+                return;
+            const request = oldest.value;
+            this.forgetBody(request);
+            request.responseBody = skippedBodyPlaceholder(bodyEvictedReason(this.limits.maxTotalBodyBytes));
+            delete request.responseBodyBase64;
+            this.evictions.bodiesEvicted++;
+        }
+    }
+    /**
+     * Stop counting a request's stored body.
+     *
+     * @param request - Request whose body is let go
+     */
+    forgetBody(request) {
+        const size = this.bodySizes.get(request);
+        if (size === undefined)
+            return;
+        this.bodySizes.delete(request);
+        this.storedBodyBytes -= size;
+    }
+}
+const SKIPPED_BODY_PATTERN = /^\[SKIPPED: (.*)\]$/s;
+/**
+ * Placeholder stored instead of a response body that was not fetched.
+ *
+ * @param reason - Why the body was skipped
+ * @returns Placeholder text shown by `bdg details`
+ */
+export function skippedBodyPlaceholder(reason) {
+    return `[SKIPPED: ${reason}]`;
+}
+/**
+ * Extract the reason from a skipped-body placeholder.
+ *
+ * @param body - Stored response body
+ * @returns Reason if `body` is a placeholder, otherwise undefined
+ */
+export function skippedBodyReason(body) {
+    return body === undefined ? undefined : SKIPPED_BODY_PATTERN.exec(body)?.[1];
+}
+//# sourceMappingURL=networkRetention.js.map

package/dist/types.d.ts

@@ -204,6 +204,8 @@ export interface ConsoleMessage {
     stackTrace?: StackFrame[];
     /** Browser subsystem of a browser message (`network`, `security`, ...); absent for page console calls */
     source?: Protocol.Log.LogEntry['source'];
+    /** Original length of `text` when JSON output cut it (`--full` keeps it whole) */
+    truncatedFrom?: number;
 }
 /**
  * Console message level categories for user-facing filtering.
@@ -234,6 +236,10 @@ export interface BdgOutput {
         console: number;
         /** Console messages dropped at the limit, oldest first (indices start after them) */
         consoleDropped?: number;
+        /** Finished network requests dropped at the request cap, oldest first */
+        networkDropped?: number;
+        /** Response bodies evicted at the total body budget, oldest first */
+        networkBodiesEvicted?: number;
     };
     error?: string;
     partial?: boolean;
@@ -286,6 +292,24 @@ export interface A11yTree {
     /** Total node count */
     count: number;
 }
+/** An accessibility node as `dom a11y tree` lists it */
+export type ListedA11yNode = Omit<A11yNode, 'childIds'> & {
+    /** Indentation level (0 = root; left-out wrappers add none) */
+    depth: number;
+};
+/**
+ * The part of an accessibility tree `dom a11y tree` lists (`--limit`, `--depth`).
+ */
+export interface ListedA11yTree {
+    /** Listed nodes, depth-first from the root */
+    nodes: ListedA11yNode[];
+    /** Nodes in the whole tree (listed + omitted + skipped) */
+    count: number;
+    /** Nodes left out by `--limit` or `--depth` */
+    omitted?: number;
+    /** Nodes never listed: text boxes, blank or repeated text, nameless layout wrappers */
+    skipped?: number;
+}
 /**
  * Query pattern for searching accessibility tree.
  *
@@ -463,6 +487,8 @@ export interface DomGetResult {
         attributes?: Record<string, unknown>;
         classes?: string[];
         outerHTML?: string;
+        /** Original length of `outerHTML` when JSON output cut it (`--full` keeps it whole) */
+        truncatedFrom?: number;
     }>;
 }
 /**

package/dist/ui/OutputBuilder.d.ts

@@ -9,6 +9,16 @@ import type { BdgResponse } from '../types.js';
  * @returns `{ version, success: true, data }`
  */
 export declare function buildSuccessResponse<T>(data: T): BdgResponse<T>;
+/**
+ * Serialize a `--json` response envelope for stdout.
+ *
+ * Indented by two spaces when stdout is a terminal, so a person can read it;
+ * on one line otherwise, since agents and pipes only pay for the whitespace.
+ *
+ * @param envelope - Response envelope (or other `--json` payload)
+ * @returns JSON text
+ */
+export declare function stringifyEnvelope(envelope: unknown): string;
 /** Builders for JSON error envelopes. */
 export declare class OutputBuilder {
     /**

package/dist/ui/OutputBuilder.js

@@ -11,6 +11,18 @@ import { VERSION } from '../utils/version.js';
 export function buildSuccessResponse(data) {
     return { version: VERSION, success: true, data };
 }
+/**
+ * Serialize a `--json` response envelope for stdout.
+ *
+ * Indented by two spaces when stdout is a terminal, so a person can read it;
+ * on one line otherwise, since agents and pipes only pay for the whitespace.
+ *
+ * @param envelope - Response envelope (or other `--json` payload)
+ * @returns JSON text
+ */
+export function stringifyEnvelope(envelope) {
+    return process.stdout.isTTY ? JSON.stringify(envelope, null, 2) : JSON.stringify(envelope);
+}
 /** Builders for JSON error envelopes. */
 export class OutputBuilder {
     /**

package/dist/ui/formatters/a11y.d.ts

@@ -1,5 +1,5 @@
 import type { DomContext } from '../../types.js';
-import type { A11yTree, A11yQueryResult, A11yNode } from '../../types.js';
+import type { A11yQueryResult, A11yNode, ListedA11yTree } from '../../types.js';
 /**
  * Data structure for a11y node with DOM context.
  */
@@ -8,15 +8,13 @@ interface A11yNodeWithContext {
     domContext: DomContext | null;
 }
 /**
- * Format accessibility tree for human-readable output.
+ * Format the listed part of an accessibility tree for human-readable output:
+ * one indented line per node, and when nodes were cut, how to see more.
  *
- * Displays the tree structure with role, name, and key properties.
- * Shows up to 50 nodes by default for manageable output.
- *
- * @param tree - Accessibility tree data
+ * @param tree - Listed accessibility tree
  * @returns Formatted output string
  */
-export declare function formatA11yTree(tree: A11yTree): string;
+export declare function formatA11yTree(tree: ListedA11yTree): string;
 /**
  * Format query result for human-readable output.
  *

package/dist/ui/formatters/a11y.js

@@ -1,79 +1,25 @@
 import { OutputFormatter, areHintsHidden } from '../formatting.js';
-import { a11yMoreMatchesNote } from '../messages/commands.js';
-/**
- * Maximum number of nodes to display in tree output before truncating.
- * Prevents overwhelming terminal output for large accessibility trees.
- */
-const MAX_TREE_NODES_DISPLAY = 50;
+import { a11yMoreMatchesNote, a11yTreeMoreNote, a11yTreeShownNote, } from '../messages/commands.js';
 /**
  * Separator width for section dividers in formatted output.
  */
 const SEPARATOR_WIDTH = 50;
 /**
- * Format accessibility tree for human-readable output.
- *
- * Displays the tree structure with role, name, and key properties.
- * Shows up to 50 nodes by default for manageable output.
+ * Format the listed part of an accessibility tree for human-readable output:
+ * one indented line per node, and when nodes were cut, how to see more.
  *
- * @param tree - Accessibility tree data
+ * @param tree - Listed accessibility tree
  * @returns Formatted output string
  */
 export function formatA11yTree(tree) {
     const fmt = new OutputFormatter();
     fmt.text(`Accessibility Tree (${tree.count} nodes)`).separator('─', SEPARATOR_WIDTH).blank();
-    const { lines, truncated } = treeLines(tree);
-    lines.forEach((line) => fmt.text(line));
-    if (truncated) {
-        fmt
-            .blank()
-            .text(`Showing the first ${MAX_TREE_NODES_DISPLAY} nodes (text boxes and repeated text left out)`)
-            .text('Use --json flag for complete output, or bdg dom a11y query "role:<role>" to search');
+    tree.nodes.forEach((node) => fmt.text('  '.repeat(node.depth) + formatA11yNodeOneLine(node)));
+    if (tree.omitted) {
+        fmt.blank().text(a11yTreeShownNote(tree.nodes.length)).text(a11yTreeMoreNote(tree.omitted));
     }
     return fmt.build();
 }
-/** Roles that only lay out their children and say nothing themselves */
-const LAYOUT_ROLES = new Set([
-    'generic',
-    'none',
-    'presentation',
-    'LayoutTable',
-    'LayoutTableRow',
-    'LayoutTableCell',
-]);
-/**
- * The tree as indented lines, depth-first from the root. Text boxes, blank
- * text, text that repeats its parent's name, and nameless layout wrappers are left out
- * (their children move up a level), so the budget goes to meaningful nodes.
- *
- * @param tree - Accessibility tree
- * @returns Up to {@link MAX_TREE_NODES_DISPLAY} lines, and whether nodes were left
- */
-function treeLines(tree) {
-    const lines = [];
-    const visited = new Set();
-    let truncated = false;
-    const visit = (node, depth, parentName) => {
-        if (visited.has(node.nodeId))
-            return;
-        visited.add(node.nodeId);
-        if (lines.length >= MAX_TREE_NODES_DISPLAY) {
-            truncated = true;
-            return;
-        }
-        const skip = node.role === 'InlineTextBox' ||
-            (node.role === 'StaticText' && (node.name === parentName || !node.name?.trim())) ||
-            (LAYOUT_ROLES.has(node.role) && !node.name);
-        if (!skip)
-            lines.push('  '.repeat(depth) + formatA11yNodeOneLine(node));
-        for (const childId of node.childIds ?? []) {
-            const child = tree.nodes.get(childId);
-            if (child)
-                visit(child, skip ? depth : depth + 1, node.name ?? parentName);
-        }
-    };
-    visit(tree.root, 0, undefined);
-    return { lines, truncated };
-}
 /** Roles whose elements take a value (the next step is fill, not click) */
 const FILLABLE_ROLES = new Set([
     'textbox',

package/dist/ui/formatters/console/chronological.js

@@ -2,11 +2,11 @@
  * Chronological list view (--list mode): all messages with timestamps,
  * level prefixes, and navigation reload markers.
  */
+import { MAX_CONSOLE_TEXT_LENGTH } from '../../../constants.js';
+import { capForDisplay } from '../longValues.js';
 import { OutputFormatter } from '../../formatting.js';
 import { consoleDroppedNote, consoleIndexGapNote } from '../../messages/consoleMessages.js';
-import { truncateByLength } from '../../../utils/strings.js';
 import { formatSourceLocation, formatTimestamp } from './shared.js';
-const MAX_LIST_TEXT_LENGTH = 200;
 /**
  * Format console output as chronological list (--list mode).
  *
@@ -46,8 +46,8 @@ export function formatConsoleChronological(messages, options) {
             }
             lastNavigationId = msg.navigationId;
         }
-        const truncatedText = truncateByLength(msg.text, MAX_LIST_TEXT_LENGTH);
-        fmt.text(`${index}  ${level} ${time}  ${truncatedText}`);
+        const text = capForDisplay(msg.text, MAX_CONSOLE_TEXT_LENGTH, options.full);
+        fmt.text(`${index}  ${level} ${time}  ${text}`);
         const source = formatSourceLocation(msg.stackTrace);
         if (source) {
             fmt.text(`${sourceIndent}→ ${source}`);

package/dist/ui/formatters/console/follow.d.ts

@@ -6,14 +6,16 @@ import type { ConsoleMessage } from '../../../types.js';
 /**
  * Lines of the console stream: the new messages since the last poll, with
  * a rule the first time (the stream banner is on stderr) and a separator
- * after a navigation.
+ * after a navigation. Texts are cut like `console --list` cuts them.
  *
  * @param messages - New messages
- * @param options - `header` the first time; `navigationId` when the page changed
+ * @param options - `header` the first time; `navigationId` when the page
+ *   changed; `full` to print the texts whole
  * @returns Text to print (empty when there is nothing new)
  */
 export declare function formatConsoleFollowLines(messages: ConsoleMessage[], options?: {
     header?: boolean;
     navigationId?: number;
+    full?: boolean | undefined;
 }): string;
 //# sourceMappingURL=follow.d.ts.map

package/dist/ui/formatters/console/follow.js

@@ -2,15 +2,18 @@
  * Follow-mode (live streaming) view. Compact format optimised for
  * repeated polling output.
  */
+import { MAX_CONSOLE_TEXT_LENGTH } from '../../../constants.js';
+import { capForDisplay } from '../longValues.js';
 import { OutputFormatter } from '../../formatting.js';
 import { formatSourceLocation, formatTimestamp } from './shared.js';
 /**
  * Lines of the console stream: the new messages since the last poll, with
  * a rule the first time (the stream banner is on stderr) and a separator
- * after a navigation.
+ * after a navigation. Texts are cut like `console --list` cuts them.
  *
  * @param messages - New messages
- * @param options - `header` the first time; `navigationId` when the page changed
+ * @param options - `header` the first time; `navigationId` when the page
+ *   changed; `full` to print the texts whole
  * @returns Text to print (empty when there is nothing new)
  */
 export function formatConsoleFollowLines(messages, options = {}) {
@@ -26,7 +29,7 @@ export function formatConsoleFollowLines(messages, options = {}) {
     for (const msg of messages) {
         const time = formatTimestamp(msg.timestamp);
         const level = msg.type.padEnd(7);
-        fmt.text(`${time} ${level} ${msg.text}`);
+        fmt.text(`${time} ${level} ${capForDisplay(msg.text, MAX_CONSOLE_TEXT_LENGTH, options.full)}`);
         const source = formatSourceLocation(msg.stackTrace);
         if (source)
             fmt.text(`                → ${source}`);