browser-debugger-cli 0.7.1 → 0.8.0

package/dist/types.d.ts

@@ -41,35 +41,6 @@ export interface BdgResponse<T = unknown> {
     /** Actionable suggestion for error recovery */
     suggestion?: string;
 }
-/**
- * Type guard to validate BdgResponse structure.
- *
- * Use this to verify responses from commands or IPC.
- *
- * @param value - Unknown value to check
- * @returns True if value is a valid BdgResponse
- */
-export declare function isBdgResponse(value: unknown): value is BdgResponse;
-/**
- * Type guard for successful BdgResponse.
- *
- * @param value - Unknown value to check
- * @returns True if value is a successful BdgResponse with data
- */
-export declare function isSuccessResponse<T>(value: unknown): value is BdgResponse<T> & {
-    success: true;
-    data: T;
-};
-/**
- * Type guard for error BdgResponse.
- *
- * @param value - Unknown value to check
- * @returns True if value is an error BdgResponse
- */
-export declare function isErrorResponse(value: unknown): value is BdgResponse & {
-    success: false;
-    error: string;
-};
 /**
  * Re-export connection types for backward compatibility.
  *
@@ -77,16 +48,6 @@ export declare function isErrorResponse(value: unknown): value is BdgResponse &
  * This re-export maintains backward compatibility with existing code.
  */
 export type { CDPMessage, CDPTarget, ConnectionOptions, LaunchedChrome, Logger, CleanupFunction, } from './connection/types.js';
-export interface DOMData {
-    url: string;
-    title: string;
-    outerHTML: string;
-    a11yTree?: {
-        root: A11yNode;
-        nodes: Record<string, A11yNode>;
-        count: number;
-    };
-}
 /**
  * WebSocket frame data captured during connection.
  */
@@ -97,8 +58,10 @@ export interface WebSocketFrame {
     direction: 'sent' | 'received';
     /** WebSocket opcode (1 = text, 2 = binary) */
     opcode: number;
-    /** Frame payload data */
+    /** Frame payload data (base64 for binary frames) */
     payloadData: string;
+    /** Original payload length in characters, when `payloadData` was truncated */
+    truncatedFrom?: number;
 }
 /**
  * WebSocket connection with lifecycle and frame data.
@@ -112,8 +75,12 @@ export interface WebSocketConnection {
     timestamp: number;
     /** Initiator URL (page that opened the WebSocket) */
     initiatorUrl?: string;
+    /** Request headers of the handshake */
+    requestHeaders?: Record<string, string>;
     /** Response status from handshake */
     status?: number;
+    /** Response status text from handshake */
+    statusText?: string;
     /** Response headers from handshake */
     responseHeaders?: Record<string, string>;
     /** Captured frames (sent and received) */
@@ -162,10 +129,29 @@ export interface NetworkRequest {
         receiveHeadersEnd?: number;
     };
     loadingFinishedTime?: number;
+    /** Chrome's monotonic time (seconds) when the request was sent; durations are measured from it */
+    sentTime?: number;
+    /** Milliseconds from the request start to its last byte or failure (a redirect hop: to the redirect) */
+    duration?: number;
+    /** For a redirect hop: the URL it redirected to */
+    redirectURL?: string;
     encodedDataLength?: number;
     decodedBodyLength?: number;
     serverIPAddress?: string;
     connection?: string;
+    /** Status text sent by the server (empty for HTTP/2) */
+    statusText?: string;
+    /** `responseBody` is base64 (binary content) */
+    responseBodyBase64?: boolean;
+    /** Served from the browser's memory, disk or prefetch cache */
+    fromCache?: boolean;
+    /** Why the response body was not captured (`details`; `responseBody` is then absent) */
+    bodyNotCaptured?: string;
+    /** Messages and lifecycle of a WebSocket connection (`resourceType` is `WebSocket`) */
+    webSocket?: {
+        frames: WebSocketFrame[];
+        closedTime?: number;
+    };
     /**
      * Network error text from loadingFailed events.
      * Contains specific error codes like net::ERR_CERT_DATE_INVALID, net::ERR_CONNECTION_REFUSED.
@@ -201,6 +187,8 @@ export interface StackFrame {
     scriptId?: string;
 }
 export interface ConsoleMessage {
+    /** Position in the session's message list (set in previews; `details console <n>` takes it) */
+    index?: number;
     type: Protocol.Runtime.ConsoleAPICalledEvent['type'];
     text: string;
     timestamp: number;
@@ -211,6 +199,8 @@ export interface ConsoleMessage {
      * First frame indicates the source location of the console call.
      */
     stackTrace?: StackFrame[];
+    /** Browser subsystem of a browser message (`network`, `security`, ...); absent for page console calls */
+    source?: Protocol.Log.LogEntry['source'];
 }
 /**
  * Console message level categories for user-facing filtering.
@@ -227,11 +217,17 @@ export interface BdgOutput {
         title: string;
     };
     data: {
-        dom?: DOMData;
         network?: NetworkRequest[];
         console?: ConsoleMessage[];
         websockets?: WebSocketConnection[];
     };
+    /** Navigation id of the page currently loaded (live previews) */
+    currentNavigationId?: number;
+    /** Counts of all captured items matching the request (e.g. `peek --type`), when `data` holds only the most recent ones */
+    totals?: {
+        network: number;
+        console: number;
+    };
     error?: string;
     partial?: boolean;
 }
@@ -243,6 +239,8 @@ export type TelemetryType = 'dom' | 'network' | 'console';
  * optimized for agent consumption and semantic queries.
  */
 export interface A11yNode {
+    /** Position in the last `a11y query` result (usable as a DOM index, e.g. `bdg dom click 0`) */
+    index?: number;
     /** Unique node identifier from CDP */
     nodeId: string;
     /** ARIA role (button, textbox, heading, etc.) */
@@ -319,6 +317,15 @@ export interface DomContext {
     classes?: string[];
     preview?: string;
 }
+/**
+ * Reference to a DOM node for CDP calls: a per-connection `nodeId` (valid only
+ * within one command) or a `backendNodeId` (valid while the node exists).
+ */
+export type NodeRef = {
+    nodeId: number;
+} | {
+    backendNodeId: number;
+};
 /**
  * Result of a DOM query operation.
  */
@@ -327,13 +334,21 @@ export interface DomQueryResult {
     count: number;
     nodes: Array<{
         index: number;
+        /** Backend node id (stable while the element exists; 0 if unknown) */
         nodeId: number;
         tag?: string;
+        /** `id`, `name` and `type` attributes, when present */
+        id?: string;
+        name?: string;
+        type?: string;
         classes?: string[];
+        /** Text content preview (display only, never used for targeting) */
         preview?: string;
+        /** Enclosing iframe(s) and shadow root, e.g. "iframe#pay > shadow root of <x-card>" */
+        context?: string;
+        /** Unique selector for this node (set by form discovery) */
+        selector?: string;
     }>;
-    /** Navigation ID when query was performed (for staleness detection). */
-    navigationId?: number;
 }
 /**
  * Result of a DOM get operation.
@@ -470,7 +485,6 @@ export interface FormField {
     options?: FieldOption[] | undefined;
     command: string;
     selectorCommand: string;
-    alternativeCommand?: string | undefined;
 }
 /**
  * Form button discovered on the page.
@@ -537,6 +551,12 @@ export interface FormDiscoveryResult {
     formCount: number;
     selectedForm: number;
     forms: DiscoveredForm[];
+    /** The forms not shown (without `--all`): name and number of visible fields */
+    otherForms?: Array<{
+        index: number;
+        name: string | null;
+        fieldCount: number;
+    }>;
     brief?: boolean | undefined;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -1,34 +1,2 @@
-/**
- * Type guard to validate BdgResponse structure.
- *
- * Use this to verify responses from commands or IPC.
- *
- * @param value - Unknown value to check
- * @returns True if value is a valid BdgResponse
- */
-export function isBdgResponse(value) {
-    if (typeof value !== 'object' || value === null) {
-        return false;
-    }
-    const obj = value;
-    return typeof obj['version'] === 'string' && typeof obj['success'] === 'boolean';
-}
-/**
- * Type guard for successful BdgResponse.
- *
- * @param value - Unknown value to check
- * @returns True if value is a successful BdgResponse with data
- */
-export function isSuccessResponse(value) {
-    return isBdgResponse(value) && value.success === true && value.data !== undefined;
-}
-/**
- * Type guard for error BdgResponse.
- *
- * @param value - Unknown value to check
- * @returns True if value is an error BdgResponse
- */
-export function isErrorResponse(value) {
-    return isBdgResponse(value) && value.success === false && typeof value.error === 'string';
-}
+export {};
 //# sourceMappingURL=types.js.map

package/dist/ui/OutputBuilder.d.ts

@@ -1,26 +1,29 @@
 /**
  * Structured output building for CLI commands.
  */
-import type { BdgOutput, BdgResponse, CDPTarget, NetworkRequest, ConsoleMessage, DOMData, TelemetryType } from '../types';
-export type OutputMode = 'preview' | 'full' | 'final';
-export interface OutputBuilderOptions {
-    mode: OutputMode;
-    target: CDPTarget;
-    startTime: number;
-    networkRequests: NetworkRequest[];
-    consoleLogs: ConsoleMessage[];
-    domData?: DOMData;
-    activeTelemetry: TelemetryType[];
-}
+import type { BdgResponse } from '../types.js';
+/**
+ * Build a success response envelope.
+ *
+ * @param data - Response payload
+ * @returns `{ version, success: true, data }`
+ */
 export declare function buildSuccessResponse<T>(data: T): BdgResponse<T>;
+/** Builders for JSON error envelopes. */
 export declare class OutputBuilder {
-    static build(options: OutputBuilderOptions): BdgOutput;
-    static buildError(error: unknown, startTime: number, target?: CDPTarget): BdgOutput;
+    /**
+     * Build an error response envelope.
+     *
+     * Envelope fields in `options` cannot override `version`, `success` or `error`.
+     *
+     * @param error - Error or message
+     * @param options - Exit code, suggestion and extra context fields
+     * @returns `{ version, success: false, error, ...options }`
+     */
     static buildJsonError(error: string | Error, options?: {
         exitCode?: number;
         suggestion?: string;
         context?: Record<string, string>;
     }): Record<string, unknown>;
-    static buildJsonSuccess(data: Record<string, unknown>): Record<string, unknown>;
 }
 //# sourceMappingURL=OutputBuilder.d.ts.map

package/dist/ui/OutputBuilder.js

@@ -1,104 +1,35 @@
 /**
  * Structured output building for CLI commands.
  */
-import { getErrorMessage } from '../utils/errors.js';
 import { VERSION } from '../utils/version.js';
+/**
+ * Build a success response envelope.
+ *
+ * @param data - Response payload
+ * @returns `{ version, success: true, data }`
+ */
 export function buildSuccessResponse(data) {
     return { version: VERSION, success: true, data };
 }
-function buildBaseOutput(target, startTime, partial) {
-    return {
-        version: VERSION,
-        success: true,
-        timestamp: new Date().toISOString(),
-        duration: Date.now() - startTime,
-        target: { url: target.url, title: target.title },
-        partial,
-    };
-}
-function buildPreviewData(networkRequests, consoleLogs, activeTelemetry) {
-    const data = {};
-    if (activeTelemetry.includes('network')) {
-        data['network'] = networkRequests.slice(-1000).map((req) => ({
-            requestId: req.requestId,
-            url: req.url,
-            method: req.method,
-            timestamp: req.timestamp,
-            status: req.status,
-            mimeType: req.mimeType,
-        }));
-    }
-    if (activeTelemetry.includes('console')) {
-        data['console'] = consoleLogs.slice(-1000).map((msg) => ({
-            type: msg.type,
-            text: msg.text,
-            timestamp: msg.timestamp,
-        }));
-    }
-    return data;
-}
-function buildFullData(networkRequests, consoleLogs, activeTelemetry) {
-    const data = {};
-    if (activeTelemetry.includes('network'))
-        data['network'] = networkRequests;
-    if (activeTelemetry.includes('console'))
-        data['console'] = consoleLogs;
-    return data;
-}
-function buildFinalData(networkRequests, consoleLogs, domData, activeTelemetry) {
-    const data = {};
-    if (activeTelemetry.includes('network'))
-        data['network'] = networkRequests;
-    if (activeTelemetry.includes('console'))
-        data['console'] = consoleLogs;
-    if (activeTelemetry.includes('dom') && domData)
-        data['dom'] = domData;
-    return data;
-}
+/** Builders for JSON error envelopes. */
 export class OutputBuilder {
-    static build(options) {
-        const { mode, target, startTime, networkRequests, consoleLogs, domData, activeTelemetry } = options;
-        const baseOutput = buildBaseOutput(target, startTime, mode !== 'final');
-        switch (mode) {
-            case 'preview':
-                return {
-                    ...baseOutput,
-                    data: buildPreviewData(networkRequests, consoleLogs, activeTelemetry),
-                };
-            case 'full':
-                return {
-                    ...baseOutput,
-                    data: buildFullData(networkRequests, consoleLogs, activeTelemetry),
-                };
-            case 'final':
-                return {
-                    ...baseOutput,
-                    partial: false,
-                    data: buildFinalData(networkRequests, consoleLogs, domData, activeTelemetry),
-                };
-        }
-    }
-    static buildError(error, startTime, target) {
-        return {
-            version: VERSION,
-            success: false,
-            timestamp: new Date().toISOString(),
-            duration: Date.now() - startTime,
-            target: target ? { url: target.url, title: target.title } : { url: '', title: '' },
-            data: {},
-            error: getErrorMessage(error),
-        };
-    }
+    /**
+     * Build an error response envelope.
+     *
+     * Envelope fields in `options` cannot override `version`, `success` or `error`.
+     *
+     * @param error - Error or message
+     * @param options - Exit code, suggestion and extra context fields
+     * @returns `{ version, success: false, error, ...options }`
+     */
     static buildJsonError(error, options) {
+        const { version: _version, success: _success, error: _error, ...rest } = (options ?? {});
         return {
             version: VERSION,
             success: false,
             error: error instanceof Error ? error.message : error,
-            ...options,
+            ...rest,
         };
     }
-    static buildJsonSuccess(data) {
-        return { version: VERSION, success: true, ...data };
-    }
 }
 //# sourceMappingURL=OutputBuilder.js.map

package/dist/ui/formatters/a11y.js

@@ -1,4 +1,4 @@
-import { OutputFormatter } from '../../ui/formatting.js';
+import { OutputFormatter, areHintsHidden } from '../formatting.js';
 /**
  * Maximum number of nodes to display in tree output before truncating.
  * Prevents overwhelming terminal output for large accessibility trees.
@@ -20,18 +20,68 @@ const SEPARATOR_WIDTH = 50;
 export function formatA11yTree(tree) {
     const fmt = new OutputFormatter();
     fmt.text(`Accessibility Tree (${tree.count} nodes)`).separator('─', SEPARATOR_WIDTH).blank();
-    const nodes = Array.from(tree.nodes.values()).slice(0, MAX_TREE_NODES_DISPLAY);
-    for (const node of nodes) {
-        fmt.text(formatA11yNodeOneLine(node));
-    }
-    if (tree.count > MAX_TREE_NODES_DISPLAY) {
+    const { lines, truncated } = treeLines(tree);
+    lines.forEach((line) => fmt.text(line));
+    if (truncated) {
         fmt
             .blank()
-            .text(`... and ${tree.count - MAX_TREE_NODES_DISPLAY} more nodes`)
-            .text('Use --json flag for complete output');
+            .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');
     }
     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',
+    'searchbox',
+    'combobox',
+    'spinbutton',
+    'slider',
+    'listbox',
+]);
 /**
  * Format query result for human-readable output.
  *
@@ -58,7 +108,16 @@ export function formatA11yQueryResult(result) {
         .separator('─', SEPARATOR_WIDTH)
         .blank();
     for (const node of result.nodes) {
-        fmt.text(formatA11yNodeOneLine(node)).blank();
+        const index = node.index !== undefined ? `[${node.index}] ` : '';
+        fmt.text(index + formatA11yNodeOneLine(node)).blank();
+    }
+    const first = result.nodes[0];
+    if (first?.index !== undefined && !areHintsHidden()) {
+        const fillable = FILLABLE_ROLES.has(first.role.toLowerCase());
+        fmt.section('Next steps:', [
+            'Inspect:  bdg dom a11y describe 0',
+            fillable ? 'Fill:     bdg dom fill 0 "<value>"' : 'Click:    bdg dom click 0',
+        ]);
     }
     return fmt.build();
 }
@@ -151,6 +210,10 @@ function formatA11yNodeOneLine(node) {
     if (node.value !== undefined && node.value !== '') {
         states.push(`value: ${truncate(node.value, 30)}`);
     }
+    const checked = node.properties?.['checked'];
+    if (checked !== undefined) {
+        states.push(checked === 'mixed' ? 'partly checked' : checked ? 'checked' : 'unchecked');
+    }
     if (node.focused) {
         states.push('focused');
     }

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

@@ -0,0 +1,14 @@
+/**
+ * Chronological list view (--list mode): all messages with timestamps,
+ * level prefixes, and navigation reload markers.
+ */
+import type { ConsoleMessage } from '../../../types.js';
+import { type ConsoleFormatOptions } from './shared.js';
+/**
+ * Format console output as chronological list (--list mode).
+ *
+ * Shows all messages in order with timestamps and levels. Includes
+ * navigation markers when page reloads are detected.
+ */
+export declare function formatConsoleChronological(messages: ConsoleMessage[], options: ConsoleFormatOptions): string;
+//# sourceMappingURL=chronological.d.ts.map

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

@@ -0,0 +1,58 @@
+/**
+ * Chronological list view (--list mode): all messages with timestamps,
+ * level prefixes, and navigation reload markers.
+ */
+import { OutputFormatter } from '../../formatting.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).
+ *
+ * Shows all messages in order with timestamps and levels. Includes
+ * navigation markers when page reloads are detected.
+ */
+export function formatConsoleChronological(messages, options) {
+    const fmt = new OutputFormatter();
+    let displayMessages = messages;
+    if (options.last && options.last > 0) {
+        displayMessages = messages.slice(-options.last);
+    }
+    const headerSuffix = options.history ? ' (all navigations)' : '';
+    const header = displayMessages.length === messages.length
+        ? `Console Messages (${messages.length} total)${headerSuffix}`
+        : `Console Messages (last ${displayMessages.length} of ${messages.length})${headerSuffix}`;
+    fmt.text(header);
+    fmt.separator('━', 50);
+    if (displayMessages.length === 0) {
+        fmt.text('No console messages');
+        return fmt.build();
+    }
+    const baseIndex = messages.length - displayMessages.length;
+    const indexOf = (msg, i) => msg.index ?? baseIndex + i;
+    const indexWidth = Math.max(...displayMessages.map((m, i) => `[${indexOf(m, i)}]`.length));
+    const levelWidth = Math.max(7, ...displayMessages.map((m) => m.type.length));
+    const sourceIndent = ' '.repeat(indexWidth + 2 + levelWidth + 1);
+    let lastNavigationId;
+    for (const [i, msg] of displayMessages.entries()) {
+        const index = `[${indexOf(msg, i)}]`.padEnd(indexWidth);
+        const time = formatTimestamp(msg.timestamp);
+        const level = msg.type.padEnd(levelWidth);
+        if (msg.navigationId !== undefined && msg.navigationId !== lastNavigationId) {
+            if (lastNavigationId !== undefined) {
+                fmt.blank();
+                fmt.text(`─── Next page (navigation #${msg.navigationId}) ───`);
+                fmt.blank();
+            }
+            lastNavigationId = msg.navigationId;
+        }
+        const truncatedText = truncateByLength(msg.text, MAX_LIST_TEXT_LENGTH);
+        fmt.text(`${index}  ${level} ${time}  ${truncatedText}`);
+        const source = formatSourceLocation(msg.stackTrace);
+        if (source) {
+            fmt.text(`${sourceIndent}→ ${source}`);
+        }
+    }
+    return fmt.build();
+}
+//# sourceMappingURL=chronological.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * Follow-mode (live streaming) view. Compact format optimised for
+ * repeated polling output.
+ */
+import type { ConsoleMessage } from '../../../types.js';
+/**
+ * Lines of the console stream: the new messages since the last poll, with
+ * the stream header the first time and a separator after a navigation.
+ *
+ * @param messages - New messages
+ * @param options - `header` the first time; `navigationId` when the page changed
+ * @returns Text to print (empty when there is nothing new)
+ */
+export declare function formatConsoleFollowLines(messages: ConsoleMessage[], options?: {
+    header?: boolean;
+    navigationId?: number;
+}): string;
+//# sourceMappingURL=follow.d.ts.map

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

@@ -0,0 +1,36 @@
+/**
+ * Follow-mode (live streaming) view. Compact format optimised for
+ * repeated polling output.
+ */
+import { OutputFormatter } from '../../formatting.js';
+import { formatSourceLocation, formatTimestamp } from './shared.js';
+/**
+ * Lines of the console stream: the new messages since the last poll, with
+ * the stream header the first time and a separator after a navigation.
+ *
+ * @param messages - New messages
+ * @param options - `header` the first time; `navigationId` when the page changed
+ * @returns Text to print (empty when there is nothing new)
+ */
+export function formatConsoleFollowLines(messages, options = {}) {
+    const fmt = new OutputFormatter();
+    if (options.header) {
+        fmt.text('Streaming console... (Ctrl+C to stop)');
+        fmt.separator('━', 40);
+        if (messages.length === 0)
+            fmt.text('Waiting for messages...');
+    }
+    if (options.navigationId !== undefined) {
+        fmt.text(`── Next page (navigation #${options.navigationId}) ──`);
+    }
+    for (const msg of messages) {
+        const time = formatTimestamp(msg.timestamp);
+        const level = msg.type.padEnd(7);
+        fmt.text(`${time} ${level} ${msg.text}`);
+        const source = formatSourceLocation(msg.stackTrace);
+        if (source)
+            fmt.text(`                → ${source}`);
+    }
+    return fmt.build();
+}
+//# sourceMappingURL=follow.js.map

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

@@ -0,0 +1,21 @@
+/**
+ * JSON output for console command. Includes summary statistics and
+ * deduplicated errors/warnings; full message list is included only when
+ * --list is set.
+ */
+import type { ConsoleMessage } from '../../../types.js';
+import { type ConsoleFormatOptions, type ConsoleJsonOutput } from './shared.js';
+/**
+ * Build the rich JSON output shape (summary + deduped errors/warnings, plus
+ * the full message list when --list is requested).
+ *
+ * Returns a plain object so callers (e.g. runCommand's JSON envelope) can
+ * embed it without re-parsing a stringified payload.
+ */
+export declare function buildConsoleJsonOutput(messages: ConsoleMessage[], options: ConsoleFormatOptions): ConsoleJsonOutput;
+/**
+ * Format console output as a JSON string. Thin wrapper around
+ * buildConsoleJsonOutput for callers that want a serialized payload.
+ */
+export declare function formatConsoleJson(messages: ConsoleMessage[], options: ConsoleFormatOptions): string;
+//# sourceMappingURL=json.d.ts.map