browser-debugger-cli 0.15.0 → 0.16.0

package/dist/telemetry/networkRetention.d.ts

@@ -1,38 +1,42 @@
 /**
  * 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.
+ * requests up to a cap, and the newest request and 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 */
+    /** Request and 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) */
+    /** Total size of the stored request and 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.
+ * the size of their stored request and response bodies under one budget,
+ * replacing the oldest bodies past it 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.
+ * A request body is counted when its request finishes, a response body when
+ * it is fetched. Stored bodies are kept in a Set, which iterates in insertion
+ * order: its first entry is the oldest body. Each part is also indexed by
+ * request, so a dropped request's bodies are 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 readonly storedBodies;
+    private readonly bodiesByPart;
     private storedBodyBytes;
     /**
      * @param requests - Finished requests, oldest first (updated in place)
@@ -41,12 +45,19 @@ export declare class RequestRetention {
      */
     constructor(requests: NetworkRequest[], limits: RetentionLimits, evictions: NetworkEvictions);
     /**
-     * Add a finished request, dropping the oldest one past the cap.
+     * Add a finished request, drop the oldest request past the cap, then count
+     * the new request's body against the budget.
      *
      * @param request - Finished request
      * @returns The dropped request, if one was
      */
     add(request: NetworkRequest): NetworkRequest | undefined;
+    /**
+     * Drop the oldest request when the list is over the cap, with its bodies.
+     *
+     * @returns The dropped request, if one was
+     */
+    private dropOldestPastCap;
     /**
      * 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
@@ -57,17 +68,27 @@ export declare class RequestRetention {
      * @param base64Encoded - Whether `body` is base64
      */
     storeBody(request: NetworkRequest, body: string, base64Encoded: boolean): void;
+    /**
+     * Count a stored body (replacing an earlier count of the same part), then
+     * evict the oldest bodies while the total is over the budget.
+     *
+     * @param request - Request the body belongs to
+     * @param part - Which of its bodies
+     * @param size - Body size (bytes)
+     */
+    private countBody;
     /** Evict the oldest stored bodies while their total is over the budget. */
     private enforceBodyBudget;
     /**
-     * Stop counting a request's stored body.
+     * Stop counting one of a request's stored bodies.
      *
      * @param request - Request whose body is let go
+     * @param part - Which of its bodies
      */
     private forgetBody;
 }
 /**
- * Placeholder stored instead of a response body that was not fetched.
+ * Placeholder stored instead of a body that was not fetched or not kept.
  *
  * @param reason - Why the body was skipped
  * @returns Placeholder text shown by `bdg details`
@@ -76,7 +97,7 @@ export declare function skippedBodyPlaceholder(reason: string): string;
 /**
  * Extract the reason from a skipped-body placeholder.
  *
- * @param body - Stored response body
+ * @param body - Stored request or response body
  * @returns Reason if `body` is a placeholder, otherwise undefined
  */
 export declare function skippedBodyReason(body: string | undefined): string | undefined;

package/dist/telemetry/networkRetention.js

@@ -1,24 +1,31 @@
 /**
  * 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.
+ * requests up to a cap, and the newest request and 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.
+ * the size of their stored request and response bodies under one budget,
+ * replacing the oldest bodies past it 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.
+ * A request body is counted when its request finishes, a response body when
+ * it is fetched. Stored bodies are kept in a Set, which iterates in insertion
+ * order: its first entry is the oldest body. Each part is also indexed by
+ * request, so a dropped request's bodies are 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();
+    storedBodies = new Set();
+    bodiesByPart = {
+        requestBody: new Map(),
+        responseBody: new Map(),
+    };
     storedBodyBytes = 0;
     /**
      * @param requests - Finished requests, oldest first (updated in place)
@@ -31,20 +38,34 @@ export class RequestRetention {
         this.evictions = evictions;
     }
     /**
-     * Add a finished request, dropping the oldest one past the cap.
+     * Add a finished request, drop the oldest request past the cap, then count
+     * the new request's body against the budget.
      *
      * @param request - Finished request
      * @returns The dropped request, if one was
      */
     add(request) {
         this.requests.push(request);
+        const dropped = this.dropOldestPastCap();
+        if (request.requestBody) {
+            this.countBody(request, 'requestBody', Buffer.byteLength(request.requestBody));
+        }
+        return dropped;
+    }
+    /**
+     * Drop the oldest request when the list is over the cap, with its bodies.
+     *
+     * @returns The dropped request, if one was
+     */
+    dropOldestPastCap() {
         if (this.requests.length <= this.limits.maxRequests)
             return undefined;
         const dropped = this.requests.shift();
         if (!dropped)
             return undefined;
         this.evictions.requestsDropped++;
-        this.forgetBody(dropped);
+        this.forgetBody(dropped, 'requestBody');
+        this.forgetBody(dropped, 'responseBody');
         return dropped;
     }
     /**
@@ -57,47 +78,62 @@ export class RequestRetention {
      * @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.countBody(request, 'responseBody', Buffer.byteLength(body));
+    }
+    /**
+     * Count a stored body (replacing an earlier count of the same part), then
+     * evict the oldest bodies while the total is over the budget.
+     *
+     * @param request - Request the body belongs to
+     * @param part - Which of its bodies
+     * @param size - Body size (bytes)
+     */
+    countBody(request, part, size) {
+        this.forgetBody(request, part);
+        const stored = { request, part, size };
+        this.storedBodies.add(stored);
+        this.bodiesByPart[part].set(request, stored);
         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();
+            const oldest = this.storedBodies.values().next();
             if (oldest.done)
                 return;
-            const request = oldest.value;
-            this.forgetBody(request);
-            request.responseBody = skippedBodyPlaceholder(bodyEvictedReason(this.limits.maxTotalBodyBytes));
-            delete request.responseBodyBase64;
+            const { request, part } = oldest.value;
+            this.forgetBody(request, part);
+            request[part] = skippedBodyPlaceholder(bodyEvictedReason(this.limits.maxTotalBodyBytes));
+            if (part === 'responseBody')
+                delete request.responseBodyBase64;
             this.evictions.bodiesEvicted++;
         }
     }
     /**
-     * Stop counting a request's stored body.
+     * Stop counting one of a request's stored bodies.
      *
      * @param request - Request whose body is let go
+     * @param part - Which of its bodies
      */
-    forgetBody(request) {
-        const size = this.bodySizes.get(request);
-        if (size === undefined)
+    forgetBody(request, part) {
+        const stored = this.bodiesByPart[part].get(request);
+        if (!stored)
             return;
-        this.bodySizes.delete(request);
-        this.storedBodyBytes -= size;
+        this.bodiesByPart[part].delete(request);
+        this.storedBodies.delete(stored);
+        this.storedBodyBytes -= stored.size;
     }
 }
 const SKIPPED_BODY_PATTERN = /^\[SKIPPED: (.*)\]$/s;
 /**
- * Placeholder stored instead of a response body that was not fetched.
+ * Placeholder stored instead of a body that was not fetched or not kept.
  *
  * @param reason - Why the body was skipped
  * @returns Placeholder text shown by `bdg details`
@@ -108,7 +144,7 @@ export function skippedBodyPlaceholder(reason) {
 /**
  * Extract the reason from a skipped-body placeholder.
  *
- * @param body - Stored response body
+ * @param body - Stored request or response body
  * @returns Reason if `body` is a placeholder, otherwise undefined
  */
 export function skippedBodyReason(body) {

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import type { Protocol } from './connection/typed-cdp.js';
+import type { DownloadInfo } from './ipc/protocol/domTypes.js';
 /**
  * Standard response envelope for all bdg command JSON output.
  *
@@ -40,6 +41,8 @@ export interface BdgResponse<T = unknown> {
     exitCode?: number;
     /** Actionable suggestion for error recovery */
     suggestion?: string;
+    /** How the command ran despite something unusual (e.g. a CDP method bdg's protocol lacks) */
+    warning?: string;
 }
 /**
  * Re-export connection types for backward compatibility.
@@ -150,6 +153,8 @@ export interface NetworkRequest {
     fromCache?: boolean;
     /** Why the response body was not captured (`details`; `responseBody` is then absent) */
     bodyNotCaptured?: string;
+    /** Why the request body was not kept (`details`; `requestBody` is then absent) */
+    requestBodyNotCaptured?: string;
     /** Messages and lifecycle of a WebSocket connection (`resourceType` is `WebSocket`) */
     webSocket?: {
         frames: WebSocketFrame[];
@@ -230,6 +235,8 @@ export interface BdgOutput {
     currentNavigationId?: number;
     /** When the page's renderer crashed (epoch ms), while it is not loaded again */
     pageCrashedAt?: number;
+    /** Downloads that began during the session, oldest first (live previews) */
+    downloads?: DownloadInfo[];
     /** Counts of all captured items matching the request (e.g. `peek --type`), when `data` holds only the most recent ones */
     totals?: {
         network: number;
@@ -528,8 +535,8 @@ export interface ScreenshotResult {
         /** `--padding` given: CSS px of page added around the captured area */
         padding?: number;
     };
-    /** Capture mode used */
-    captureMode?: 'full_page' | 'viewport';
+    /** Capture mode used: the whole page, the viewport, or one element */
+    captureMode?: 'full_page' | 'viewport' | 'element';
     /** Whether the image was auto-resized to fit token budget */
     resized?: boolean;
     /** Original width before resize (pixels) */
@@ -560,18 +567,6 @@ export interface DomGetOptions {
     all?: boolean;
     nth?: number;
 }
-/**
- * Options for screenshot operation.
- */
-export interface ScreenshotOptions {
-    format?: 'png' | 'jpeg';
-    quality?: number;
-    fullPage?: boolean;
-    /** Disable auto-resize to 1568px max edge */
-    noResize?: boolean;
-    /** Scroll element into view before capture */
-    scroll?: string;
-}
 /**
  * Field validation state from HTML5 or custom validation.
  */

package/dist/ui/OutputBuilder.d.ts

@@ -6,9 +6,10 @@ import type { BdgResponse } from '../types.js';
  * Build a success response envelope.
  *
  * @param data - Response payload
- * @returns `{ version, success: true, data }`
+ * @param warning - Warning about how the command ran, if any
+ * @returns `{ version, success: true, data }`, plus `warning` when given
  */
-export declare function buildSuccessResponse<T>(data: T): BdgResponse<T>;
+export declare function buildSuccessResponse<T>(data: T, warning?: string): BdgResponse<T>;
 /**
  * Serialize a `--json` response envelope for stdout.
  *

package/dist/ui/OutputBuilder.js

@@ -6,10 +6,11 @@ import { VERSION } from '../utils/version.js';
  * Build a success response envelope.
  *
  * @param data - Response payload
- * @returns `{ version, success: true, data }`
+ * @param warning - Warning about how the command ran, if any
+ * @returns `{ version, success: true, data }`, plus `warning` when given
  */
-export function buildSuccessResponse(data) {
-    return { version: VERSION, success: true, data };
+export function buildSuccessResponse(data, warning) {
+    return { version: VERSION, success: true, data, ...(warning && { warning }) };
 }
 /**
  * Serialize a `--json` response envelope for stdout.

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

@@ -67,6 +67,15 @@ interface CdpField {
     description?: string | undefined;
     items?: string | undefined;
 }
+/** A parameter (or type property) in `--describe`: `enum` also holds a `$ref` type's values */
+interface CdpParameter extends CdpField {
+    required: boolean;
+    enum?: string[] | undefined;
+    ref?: string | undefined;
+    refType?: string | undefined;
+    experimental?: boolean | undefined;
+    deprecated?: boolean | undefined;
+}
 /** `bdg cdp <Domain.method> --describe` result */
 export interface CdpMethodDescription extends ProtocolEntry {
     type: 'method';
@@ -74,19 +83,31 @@ export interface CdpMethodDescription extends ProtocolEntry {
     domain: string;
     method: string;
     note?: string | undefined;
-    parameters: (CdpField & {
-        required: boolean;
-        enum?: string[] | undefined;
-        deprecated?: boolean | undefined;
-    })[];
+    parameters: CdpParameter[];
     returns: (CdpField & {
         optional: boolean;
     })[];
+    redirect?: {
+        method: string;
+        resolved: boolean;
+        parameters: CdpParameter[];
+    } | undefined;
     example?: {
         command: string;
         params?: Record<string, unknown> | undefined;
     } | undefined;
 }
+/** `bdg cdp <Domain.Type> --describe` result */
+export interface CdpTypeDescription extends ProtocolEntry {
+    type: 'type';
+    name: string;
+    domain: string;
+    id: string;
+    baseType: string;
+    enum?: string[] | undefined;
+    items?: string | undefined;
+    properties?: CdpParameter[] | undefined;
+}
 /** `bdg cdp <Domain.method>` result */
 export interface CdpExecuteData {
     method: string;
@@ -114,12 +135,14 @@ export declare function formatCdpDomains(data: CdpDomainListData): string;
  */
 export declare function formatCdpDomainMethods(data: CdpDomainMethodsData): string;
 /**
- * Format `bdg cdp <Domain.method> --describe` or `bdg cdp <Domain> --describe`.
+ * Format `bdg cdp <Domain.method> --describe`, `bdg cdp <Domain> --describe`
+ * or `bdg cdp <Domain.Type> --describe`.
  *
- * @param data - Method or domain description
- * @returns Description, parameters (`?` = optional), returns, note and example
+ * @param data - Method, domain or type description
+ * @returns Description, parameters (`?` = optional, `$ref` enums inline),
+ *   the redirect target's parameters, returns, note and example
  */
-export declare function formatCdpDescription(data: CdpMethodDescription | CdpDomainDescription): string;
+export declare function formatCdpDescription(data: CdpMethodDescription | CdpDomainDescription | CdpTypeDescription): string;
 /**
  * Whether a CDP method returned nothing (null, undefined or an empty object).
  *

package/dist/ui/formatters/cdp.js

@@ -3,6 +3,7 @@
  * lists, method schemas and method results (`--json` prints the data as is).
  */
 import { joinLines, pluralize } from '../formatting.js';
+import { cdpRedirectTitle, cdpUnresolvedRedirectLine } from '../messages/commands.js';
 /**
  * First sentence (or line) of a protocol description.
  *
@@ -43,6 +44,24 @@ function columns(rows) {
 function typeText(field) {
     return field.items ? `${field.type}<${field.items}>` : field.type;
 }
+/** Enum values listed in text before the rest are counted */
+const MAX_ENUM_VALUES = 8;
+/**
+ * What a field's type stands for, in parentheses: enum values (the first
+ * {@link MAX_ENUM_VALUES}), or the base type of a referenced non-object type.
+ *
+ * @param field - Field with its inline or referenced enum and referenced base type
+ * @returns e.g. " (Strict|Lax|None)", " (number)", or an empty string
+ */
+function expansionText(field) {
+    const values = field.enum;
+    if (!values || values.length === 0) {
+        return field.refType && field.refType !== 'object' ? ` (${field.refType})` : '';
+    }
+    const shown = values.slice(0, MAX_ENUM_VALUES);
+    const more = values.length - shown.length;
+    return ` (${[...shown, ...(more > 0 ? [`… ${more} more`] : [])].join('|')})`;
+}
 /**
  * Format `bdg cdp --search <query>`.
  *
@@ -89,22 +108,74 @@ function fieldSection(title, fields) {
     return [
         `${title}:`,
         ...columns(fields.map((f) => [
-            `${f.name}${f.optional ? '?' : ''}: ${typeText(f)}`,
-            (f.description ?? '').replace(/\s*\n\s*/g, ' '),
+            `${f.name}${f.optional ? '?' : ''}: ${typeText(f)}${expansionText(f)}`,
+            `${(f.description ?? '').replace(/\s*\n\s*/g, ' ')}${tags(f)}`,
         ])),
     ];
 }
 /**
- * Format `bdg cdp <Domain.method> --describe` or `bdg cdp <Domain> --describe`.
+ * Parameters as fields with `?` for optional ones.
+ *
+ * @param parameters - Parameters or type properties
+ * @returns Fields for {@link fieldSection}
+ */
+function parameterFields(parameters) {
+    return parameters.map((p) => ({ ...p, optional: !p.required }));
+}
+/**
+ * How to describe the first object type a parameter refers to (enums and
+ * other types are already shown inline).
+ *
+ * @param parameters - Parameters, the redirect target's included
+ * @returns Hint line, or undefined when no parameter refers to such a type
+ */
+function typeHint(parameters) {
+    const ref = parameters.find((p) => p.refType === 'object')?.ref;
+    return ref && `Describe a type: bdg cdp ${ref} --describe`;
+}
+/**
+ * Lines naming the method a redirected one runs, with its parameters, or
+ * saying the protocol lacks it.
+ *
+ * @param redirect - Redirect target, if any
+ * @returns Title and parameter lines, or nothing without a redirect
+ */
+function redirectSection(redirect) {
+    if (!redirect)
+        return [];
+    if (!redirect.resolved)
+        return [cdpUnresolvedRedirectLine(redirect.method)];
+    const title = cdpRedirectTitle(redirect.method);
+    return redirect.parameters.length === 0
+        ? [title]
+        : fieldSection(`${title}, with these parameters`, parameterFields(redirect.parameters));
+}
+/**
+ * Format `bdg cdp <Domain.Type> --describe`.
+ *
+ * @param data - Type description
+ * @returns Base type, description and values or properties
+ */
+function formatCdpType(data) {
+    const properties = data.properties ?? [];
+    return joinLines(`${data.name}: ${typeText({ name: data.id, type: data.baseType, items: data.items })}${tags(data)}`, data.description, data.enum && `Values: ${data.enum.join(', ')}`, ...fieldSection('Properties', parameterFields(properties)), typeHint(properties));
+}
+/**
+ * Format `bdg cdp <Domain.method> --describe`, `bdg cdp <Domain> --describe`
+ * or `bdg cdp <Domain.Type> --describe`.
  *
- * @param data - Method or domain description
- * @returns Description, parameters (`?` = optional), returns, note and example
+ * @param data - Method, domain or type description
+ * @returns Description, parameters (`?` = optional, `$ref` enums inline),
+ *   the redirect target's parameters, returns, note and example
  */
 export function formatCdpDescription(data) {
+    if (data.type === 'type')
+        return formatCdpType(data);
     if (data.type === 'domain') {
         return joinLines(`${data.domain}: ${pluralize(data.commands, 'method')}, ${pluralize(data.events, 'event')}${tags(data)}`, data.description, data.note, data.nextStep);
     }
-    return joinLines(`${data.name}${tags(data)}`, data.description, ...fieldSection('Parameters', data.parameters.map((p) => ({ ...p, optional: !p.required }))), ...fieldSection('Returns', data.returns), data.note && `Note: ${data.note}`, data.example && `Example: ${data.example.command}`);
+    const redirected = data.redirect?.parameters ?? [];
+    return joinLines(`${data.name}${tags(data)}`, data.description, ...fieldSection('Parameters', parameterFields(data.parameters)), ...redirectSection(data.redirect), ...fieldSection('Returns', data.returns), data.note && `Note: ${data.note}`, typeHint([...data.parameters, ...redirected]), data.example && `Example: ${data.example.command}`);
 }
 /**
  * Whether a CDP method returned nothing (null, undefined or an empty object).

package/dist/ui/formatters/details.js

@@ -2,7 +2,7 @@ import { skippedBodyReason } from '../../telemetry/networkRetention.js';
 import { formatFramePosition, formatTimestamp } from './console/shared.js';
 import { headerValueLines } from './networkHeaders.js';
 import { formatRequestStatus } from './requestStatus.js';
-import { OutputFormatter } from '../formatting.js';
+import { OutputFormatter, formatBytes } from '../formatting.js';
 import { localProxyNote } from '../messages/networkMessages.js';
 import { sessionCommand } from '../messages/sessionCommand.js';
 import { truncateByLength } from '../../utils/strings.js';
@@ -85,19 +85,6 @@ function addWebSocketMessages(fmt, webSocket) {
 }
 /** Characters of a text body shown in human output (`--json` has all of it) */
 const BODY_PREVIEW_LENGTH = 20000;
-/**
- * Format a byte count for humans.
- *
- * @param bytes - Byte count
- * @returns e.g. "512 B", "12.3 KB"
- */
-function formatBytes(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    return bytes < 1024 * 1024
-        ? `${(bytes / 1024).toFixed(1)} KB`
-        : `${(bytes / 1024 / 1024).toFixed(1)} MB`;
-}
 /**
  * Whether an IP address is a loopback address (`127.0.0.0/8`, `::1`).
  *
@@ -229,7 +216,12 @@ export function formatNetworkDetails(request) {
     fmt.blank();
     if (request.requestHeaders)
         addHeaders(fmt, 'Request Headers:', request.requestHeaders);
-    if (request.requestBody) {
+    if (request.requestBodyNotCaptured) {
+        fmt.text('Request Body:').separator('━', 70);
+        fmt.text(`(not captured: ${request.requestBodyNotCaptured})`);
+        fmt.blank();
+    }
+    else if (request.requestBody) {
         fmt.text('Request Body:').separator('━', 70);
         fmt.text(request.requestBody);
         fmt.blank();

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

@@ -57,6 +57,8 @@ export interface PreviewJsonData {
     totals?: BdgOutput['totals'];
     /** When the page's renderer crashed (epoch ms), while it is not loaded again */
     pageCrashedAt?: number;
+    /** Downloads that began during the session, oldest first */
+    downloads?: BdgOutput['downloads'];
     network?: BdgOutput['data']['network'];
     console?: BdgOutput['data']['console'];
 }

package/dist/ui/formatters/preview.js

@@ -4,7 +4,7 @@ import { capMessageText, formatTimestamp } from './console/shared.js';
 import { capForDisplay } from './longValues.js';
 import { failureReason, formatRequestStatus, getRequestState, } from './requestStatus.js';
 import { OutputFormatter, truncateUrl, truncateText } from '../formatting.js';
-import { moreCharsNote, withPageCrashedNote } from '../messages/commands.js';
+import { downloadsSummary, moreCharsNote, withPageCrashedNote } from '../messages/commands.js';
 import { consoleDroppedNote } from '../messages/consoleMessages.js';
 import { networkEvictedNote } from '../messages/networkMessages.js';
 import { PREVIEW_EMPTY_STATES, PREVIEW_HEADERS, compactTipsMessage, verboseCommandsMessage, } from '../messages/preview.js';
@@ -76,6 +76,7 @@ export function buildPreviewJsonData(output, options) {
         ...(output.partial !== undefined && { partial: output.partial }),
         ...(output.totals && { totals: output.totals }),
         ...(output.pageCrashedAt !== undefined && { pageCrashedAt: output.pageCrashedAt }),
+        ...(output.downloads && { downloads: output.downloads }),
         ...(pick('network') && output.data.network && { network: last(output.data.network) }),
         ...(pick('console') &&
             output.data.console && {
@@ -194,6 +195,8 @@ function formatPreviewCompact(output, options) {
             fmt.blank();
         }
     }
+    if (output.downloads?.length)
+        fmt.text(`Downloads: ${downloadsSummary(output.downloads)}`).blank();
     if (!options.follow) {
         fmt.tip(compactTipsMessage());
     }
@@ -296,6 +299,9 @@ function formatPreviewVerbose(output, options) {
             fmt.blank();
         }
     }
+    if (output.downloads?.length) {
+        fmt.keyValue('Downloads', downloadsSummary(output.downloads), 18).blank();
+    }
     if (!options.follow) {
         fmt.tip(verboseCommandsMessage());
     }

package/dist/ui/formatters/status.js

@@ -1,7 +1,7 @@
 import { describeRunningChrome } from '../../session/chrome.js';
 import { calculateDuration, formatTimeAgo } from '../../session/statusData.js';
 import { OutputFormatter } from '../formatting.js';
-import { colorSchemeLabel, sessionActiveLine } from '../messages/commands.js';
+import { colorSchemeLabel, downloadsSummary, sessionActiveLine } from '../messages/commands.js';
 import { networkEvictedNote } from '../messages/networkMessages.js';
 import { lastSessionEndText } from '../messages/session.js';
 import { noActiveSessionMessage, sessionCommand } from '../messages/sessionCommand.js';
@@ -62,6 +62,11 @@ export function formatSessionStatus(metadata, pid, activity, pageState, verbose
         if (activity.lastConsoleMessageAt) {
             fmt.keyValue('  Last Message', formatTimeAgo(activity.lastConsoleMessageAt), 18);
         }
+        const downloadRows = [
+            ...(activity.downloads?.length ? [downloadsSummary(activity.downloads)] : []),
+            ...(activity.downloadsWarning ? [`⚠ ${activity.downloadsWarning}`] : []),
+        ];
+        downloadRows.forEach((row, index) => index === 0 ? fmt.keyValue('Downloads', row, 18) : fmt.text(`${' '.repeat(18)}${row}`));
     }
     fmt.blank().text('Collectors').separator('━', 50);
     const activeTelemetry = metadata.activeTelemetry ?? ['network', 'console', 'dom'];