browser-debugger-cli 0.7.2 → 0.9.0

package/dist/ui/formatters/form.js

@@ -4,7 +4,8 @@
  * Formats discovered forms with semantic tables showing fields,
  * values, validation state, and suggested commands.
  */
-import { OutputFormatter } from '../../ui/formatting.js';
+import { OutputFormatter, areHintsHidden } from '../formatting.js';
+import { REQUIRED_FIELD_EMPTY_REASON, formReadinessMessage, requiredFieldsEmptyMessage, } from '../messages/commands.js';
 const COLUMN_WIDTHS = {
     index: 4,
     type: 12,
@@ -12,6 +13,16 @@ const COLUMN_WIDTHS = {
     value: 20,
     status: 10,
 };
+/**
+ * Cut text to a column width, marking the cut with "…".
+ *
+ * @param text - Text
+ * @param width - Column width
+ * @returns Text of at most `width` characters
+ */
+function fitText(text, width) {
+    return text.length > width ? `${text.slice(0, width - 1)}…` : text;
+}
 /**
  * Format field type for display.
  *
@@ -54,9 +65,15 @@ function formatFieldValue(field) {
  * @returns Status string with icon
  */
 function formatFieldStatus(field) {
+    if (field.hidden) {
+        return 'hidden';
+    }
     if (field.disabled) {
         return 'disabled';
     }
+    if (field.readOnly) {
+        return 'read-only';
+    }
     if (!field.validation.valid) {
         return 'invalid';
     }
@@ -83,9 +100,8 @@ function formatRequiredMarker(field) {
 function formatFieldRow(field) {
     const idx = String(field.index).padStart(COLUMN_WIDTHS.index);
     const type = formatFieldType(field).padEnd(COLUMN_WIDTHS.type);
-    const label = (field.label + formatRequiredMarker(field))
-        .slice(0, COLUMN_WIDTHS.label)
-        .padEnd(COLUMN_WIDTHS.label);
+    const marker = formatRequiredMarker(field);
+    const label = (fitText(field.label, COLUMN_WIDTHS.label - marker.length) + marker).padEnd(COLUMN_WIDTHS.label);
     const value = formatFieldValue(field).padEnd(COLUMN_WIDTHS.value);
     const status = formatFieldStatus(field);
     let warning = '';
@@ -115,12 +131,23 @@ function formatButtonRow(button) {
  * @returns Header string
  */
 function formatFormHeader(form) {
-    let header = `Form: "${form.name ?? 'Unnamed'}"`;
+    let header = `Form: "${form.name ?? 'Unnamed'}"${formVisibilityMarker(form)}`;
     if (form.step) {
         header += ` (step ${form.step.current} of ${form.step.total})`;
     }
     return header;
 }
+/**
+ * Marker of a form shown in an open dialog or not shown at all.
+ *
+ * @param form - Form (or its listing in "Other forms")
+ * @returns ` (in dialog)`, ` (hidden)`, or empty
+ */
+function formVisibilityMarker(form) {
+    if (form.hidden)
+        return ' (hidden)';
+    return form.inDialog ? ' (in dialog)' : '';
+}
 /**
  * Format table header row.
  *
@@ -135,7 +162,9 @@ function formatTableHeader() {
     return `${idx}  ${type} ${label} ${value} ${status}`;
 }
 /**
- * Format summary line.
+ * Format summary line, e.g. "Summary: 1/3 fields filled | 2 required fields
+ * empty: Last Name, Zip | NOT ready" (a radio or checkbox group counts as one
+ * field).
  *
  * @param summary - Form summary
  * @returns Summary string
@@ -146,15 +175,12 @@ function formatSummaryLine(summary) {
     if (summary.invalidFields > 0) {
         parts.push(`${summary.invalidFields} invalid`);
     }
-    if (summary.requiredRemaining > 0) {
-        parts.push(`${summary.requiredRemaining} required remaining`);
-    }
-    if (summary.readyToSubmit) {
-        parts.push('READY to submit');
-    }
-    else {
-        parts.push('NOT ready');
-    }
+    const requiredEmpty = summary.blockers
+        .filter((blocker) => blocker.reason === REQUIRED_FIELD_EMPTY_REASON)
+        .map((blocker) => blocker.label);
+    if (requiredEmpty.length > 0)
+        parts.push(requiredFieldsEmptyMessage(requiredEmpty));
+    parts.push(formReadinessMessage(summary));
     return `Summary: ${parts.join(' | ')}`;
 }
 /**
@@ -185,9 +211,7 @@ function formatSingleForm(form, fmt, brief = false) {
     fmt.text(formatTableHeader());
     fmt.text('─'.repeat(70));
     for (const field of form.fields) {
-        if (!field.hidden) {
-            fmt.text(formatFieldRow(field));
-        }
+        fmt.text(formatFieldRow(field));
     }
     if (form.buttons.length > 0) {
         fmt.text('─'.repeat(70));
@@ -213,19 +237,18 @@ function formatSingleForm(form, fmt, brief = false) {
  * @param fmt - Output formatter
  */
 function formatBriefFields(form, fmt) {
-    fmt.text('IDX  TYPE         LABEL                    REQ');
-    fmt.text('─'.repeat(50));
+    fmt.text('IDX  TYPE         LABEL                    REQ VALUE');
+    fmt.text('─'.repeat(70));
     for (const field of form.fields) {
-        if (field.hidden)
-            continue;
         const idx = `[${field.index}]`.padEnd(4);
         const type = (field.inputType ?? field.type).slice(0, 11).padEnd(12);
         const label = (field.label ?? field.name ?? '(no label)').slice(0, 23).padEnd(24);
-        const req = field.required ? '*' : '';
-        fmt.text(`${idx} ${type} ${label} ${req}`);
+        const req = (field.required ? '*' : '').padEnd(3);
+        const hidden = field.hidden ? ' (hidden)' : '';
+        fmt.text(`${idx} ${type} ${label} ${req} ${formatFieldValue(field)}${hidden}`);
     }
     if (form.buttons.length > 0) {
-        fmt.text('─'.repeat(50));
+        fmt.text('─'.repeat(70));
         for (const button of form.buttons) {
             const idx = `[${button.index}]`.padEnd(4);
             const type = 'button'.padEnd(12);
@@ -237,20 +260,16 @@ function formatBriefFields(form, fmt) {
 /**
  * Format other forms summary.
  *
- * @param forms - All forms
- * @param selectedIndex - Index of selected form
+ * @param others - Forms not shown, with their visible field counts
  * @param fmt - Output formatter
  */
-function formatOtherForms(forms, selectedIndex, fmt) {
-    const others = forms.filter((_, i) => i !== selectedIndex);
-    if (others.length === 0) {
+function formatOtherForms(others, fmt) {
+    if (others.length === 0)
         return;
-    }
     fmt.blank();
     fmt.text('Other forms on page:');
     for (const form of others) {
-        const fieldCount = form.fields.filter((f) => !f.hidden).length;
-        fmt.text(`  Form ${form.index}: "${form.name ?? 'Unnamed'}" - ${fieldCount} field(s)`);
+        fmt.text(`  Form ${form.index}: "${form.name ?? 'Unnamed'}"${formVisibilityMarker(form)} - ${form.fieldCount} field(s)`);
     }
     fmt.blank();
     fmt.text('Use --all to see all forms');
@@ -270,45 +289,16 @@ export function formatFormDiscovery(result) {
         formatSingleForm(form, fmt, result.brief);
         fmt.blank();
     }
-    if (result.forms.length === 1 && result.formCount > 1) {
-        const allForms = [];
-        for (let i = 0; i < result.formCount; i++) {
-            if (i === result.selectedForm) {
-                allForms.push(result.forms[0]);
-            }
-            else {
-                allForms.push({
-                    index: i,
-                    name: `Form ${i}`,
-                    action: null,
-                    method: 'GET',
-                    relevanceScore: 0,
-                    fields: [],
-                    buttons: [],
-                    summary: {
-                        totalFields: 0,
-                        filledFields: 0,
-                        emptyFields: 0,
-                        validFields: 0,
-                        invalidFields: 0,
-                        requiredTotal: 0,
-                        requiredFilled: 0,
-                        requiredRemaining: 0,
-                        readyToSubmit: true,
-                        blockers: [],
-                    },
-                });
-            }
-        }
-        formatOtherForms(allForms, result.selectedForm, fmt);
-    }
-    fmt.blank();
-    fmt.text('Suggested commands:');
-    fmt.text('  bdg dom fill <index> "<value>"     Fill a field');
-    fmt.text('  bdg dom click <index>              Click/check a field or button');
-    fmt.text('  bdg dom form                       Refresh to see current state');
-    fmt.blank();
-    fmt.text('Tip: Re-run "bdg dom form" after clicks that may reveal hidden fields');
+    if (result.otherForms)
+        formatOtherForms(result.otherForms, fmt);
+    fmt.hints('Suggested commands:', [
+        'bdg dom fill <index> "<value>"     Fill a field',
+        'bdg dom click <index>              Click/check a field or button',
+        'bdg dom form                       Refresh to see current state',
+    ]);
+    if (!areHintsHidden())
+        fmt.blank();
+    fmt.tip('Tip: Re-run "bdg dom form" after clicks that may reveal hidden fields');
     return fmt.build();
 }
 //# sourceMappingURL=form.js.map

package/dist/ui/formatters/helpFormatters.js

@@ -4,7 +4,8 @@
  * Provides well-structured sections for agent discovery, task examples,
  * and URL format guidance.
  */
-import { section } from '../../ui/formatting.js';
+import { getProtocolCounts } from '../../cdp/schema.js';
+import { section } from '../formatting.js';
 /**
  * Builds the agent discovery help section.
  *
@@ -14,11 +15,11 @@ import { section } from '../../ui/formatting.js';
  * @returns Formatted agent discovery section
  */
 export function buildAgentDiscoveryHelp() {
+    const counts = getProtocolCounts();
     return section('For AI Agents:', [
         'bdg --help --json          Machine-readable command schema',
-        'bdg cdp --list             List all 53 CDP domains',
-        'bdg cdp --search <term>    Search 300+ CDP methods',
-        '.claude/skills/bdg/        15+ recipes & workflow patterns',
+        `bdg cdp --list             List all ${counts.domains} CDP domains`,
+        `bdg cdp --search <term>    Search ${counts.methods} CDP methods`,
     ]);
 }
 /**

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

@@ -0,0 +1,31 @@
+/**
+ * Human-readable output of `bdg dom layout`.
+ */
+import type { ElementLayout, LayoutResult, LayoutSize } from '../../ipc/protocol/domTypes.js';
+import type { IndexSource } from '../../types.js';
+/** `bdg dom layout` data (the `success` flag is implied by the envelope), with the list an index refers to */
+type LayoutOutput = Omit<LayoutResult, 'success'> & {
+    indexSource?: IndexSource | undefined;
+};
+/**
+ * One element as a compact line: index, description, text, page position
+ * and size (not for hidden elements, which have no meaningful box), where it
+ * is relative to the viewport, what covers it, an inert or invisible element
+ * and the iframe or shadow root it is in (unless the position already names
+ * it as the clipping iframe).
+ *
+ * @param element - Element layout
+ * @param viewport - Viewport size, when known (an element larger than it is not centred by the scroll)
+ * @returns e.g. `[0] button#save "Save"  420,1180 120×40  below fold (scroll down 500px to centre it)`
+ */
+export declare function layoutLine(element: ElementLayout, viewport?: LayoutSize): string;
+/**
+ * Format `bdg dom layout` output: the page dimensions, then one line per
+ * element (the first {@link LAYOUT_DISPLAY_LIMIT}).
+ *
+ * @param data - Layout report
+ * @returns Formatted output
+ */
+export declare function formatLayout(data: LayoutOutput): string;
+export {};
+//# sourceMappingURL=layout.d.ts.map

package/dist/ui/formatters/layout.js

@@ -0,0 +1,53 @@
+/**
+ * Human-readable output of `bdg dom layout`.
+ */
+import { indexSourceText } from '../../errors/messages.js';
+import { OutputFormatter } from '../formatting.js';
+import { indexLayoutHeadline, layoutHeadline, layoutPositionLabel, moreMatchesNote, pageLayoutLine, } from '../messages/commands.js';
+/** Elements listed in human output (JSON has up to 100) */
+const LAYOUT_DISPLAY_LIMIT = 20;
+/**
+ * One element as a compact line: index, description, text, page position
+ * and size (not for hidden elements, which have no meaningful box), where it
+ * is relative to the viewport, what covers it, an inert or invisible element
+ * and the iframe or shadow root it is in (unless the position already names
+ * it as the clipping iframe).
+ *
+ * @param element - Element layout
+ * @param viewport - Viewport size, when known (an element larger than it is not centred by the scroll)
+ * @returns e.g. `[0] button#save "Save"  420,1180 120×40  below fold (scroll down 500px to centre it)`
+ */
+export function layoutLine(element, viewport) {
+    const { bounds } = element;
+    return [
+        `[${element.index}] ${element.element}${element.text ? ` "${element.text}"` : ''}`,
+        element.inViewport !== 'hidden' && `${bounds.x},${bounds.y} ${bounds.width}×${bounds.height}`,
+        layoutPositionLabel(element, viewport),
+        element.coveredBy && `covered by ${element.coveredBy}`,
+        element.inert && 'inert',
+        element.invisible,
+        element.context && element.context !== element.clippedBy && `in ${element.context}`,
+    ]
+        .filter(Boolean)
+        .join('  ');
+}
+/**
+ * Format `bdg dom layout` output: the page dimensions, then one line per
+ * element (the first {@link LAYOUT_DISPLAY_LIMIT}).
+ *
+ * @param data - Layout report
+ * @returns Formatted output
+ */
+export function formatLayout(data) {
+    const shown = data.elements.slice(0, LAYOUT_DISPLAY_LIMIT);
+    const more = data.elements.length - shown.length + (data.omitted ?? 0);
+    return new OutputFormatter()
+        .text(pageLayoutLine(data.page))
+        .text(data.indexSource
+        ? indexLayoutHeadline(indexSourceText(data.indexSource))
+        : layoutHeadline(data.count, data.elements.length + (data.omitted ?? 0), data.selector))
+        .list(shown.map((element) => layoutLine(element, data.page.viewport)))
+        .list(more > 0 ? [moreMatchesNote(more, data.omitted ? data.elements.length : undefined)] : [])
+        .build();
+}
+//# sourceMappingURL=layout.js.map

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

@@ -0,0 +1,25 @@
+/**
+ * Human-readable output of `bdg dom listeners`.
+ */
+import type { ElementListener, ListenersResult } from '../../ipc/protocol/domTypes.js';
+/** `bdg dom listeners` data (the `success` flag is implied by the envelope) */
+type ListenersOutput = Omit<ListenersResult, 'success'>;
+/**
+ * Where a handler is defined, as DevTools shows it (1-based line and column).
+ *
+ * @param handler - Listener handler
+ * @returns e.g. "script 42:18:6", or "native" for built-in functions
+ */
+export declare function handlerLocation(handler: ElementListener['handler']): string;
+/**
+ * Format `bdg dom listeners` output: listeners grouped by event type, the
+ * handlers nearest the element first, then one line per framework root,
+ * with notes for events the element has no listener of its own for.
+ *
+ * @param result - Listener report
+ * @param types - Event types asked for with --type, if any
+ * @returns Formatted output
+ */
+export declare function formatListeners(result: ListenersOutput, types?: string[]): string;
+export {};
+//# sourceMappingURL=listeners.d.ts.map

package/dist/ui/formatters/listeners.js

@@ -0,0 +1,160 @@
+/**
+ * Human-readable output of `bdg dom listeners`.
+ */
+import { delegationNotes } from '../../runtime/dom/listenerSummary.js';
+import { OutputFormatter } from '../formatting.js';
+import { COLLAPSED_LISTENERS_HEADING, NO_LISTENERS_HINT, collapsedListenersSummary, delegationNote, eventTypeSuggestion, jqueryHandlersSkippedNote, listenersHeadline, noListenersMessage, reactHandlersSkippedNote, } from '../messages/commands.js';
+import { truncateByLength } from '../../utils/strings.js';
+/** Longest handler name shown (JSON has the full name) */
+const NAME_MAX_LENGTH = 30;
+/** Shown for handlers without a name */
+const ANONYMOUS = '(anonymous)';
+/**
+ * Where a handler is defined, as DevTools shows it (1-based line and column).
+ *
+ * @param handler - Listener handler
+ * @returns e.g. "script 42:18:6", or "native" for built-in functions
+ */
+export function handlerLocation(handler) {
+    if (!handler.scriptId || handler.scriptId === '0')
+        return 'native';
+    return `script ${handler.scriptId}:${handler.lineNumber + 1}:${handler.columnNumber + 1}`;
+}
+/**
+ * Columns of one listener row: placement, node, handler name, location, and
+ * the flags with the source preview.
+ *
+ * @param listener - Listener
+ * @returns Row cells
+ */
+function listenerCells(listener) {
+    const flags = [
+        listener.reactProp ? `React ${listener.reactProp}` : listener.framework,
+        listener.delegateSelector && `delegate ${listener.delegateSelector}`,
+        listener.noop && 'no-op',
+        listener.useCapture && 'capture',
+        listener.passive && 'passive',
+        listener.once && 'once',
+    ].filter(Boolean);
+    const preview = flags.length > 0 ? `[${flags.join(', ')}] ` : '';
+    return [
+        listener.on,
+        listener.node,
+        truncateByLength(listener.handler.name || ANONYMOUS, NAME_MAX_LENGTH),
+        handlerLocation(listener.handler),
+        `${preview}${listener.handler.preview}`,
+    ];
+}
+/**
+ * Lay out rows as aligned columns (the last column is not padded).
+ *
+ * @param rows - Row cells
+ * @returns Lines
+ */
+function alignColumns(rows) {
+    const widths = (rows[0] ?? []).map((_, column) => Math.max(...rows.map((row) => (row[column] ?? '').length)));
+    return rows.map((row) => row
+        .map((cell, column) => (column === row.length - 1 ? cell : cell.padEnd(widths[column] ?? 0)))
+        .join('  '));
+}
+/** Dispatcher names listed per collapsed framework root */
+const COLLAPSED_HANDLERS_SHOWN = 3;
+/**
+ * Listeners by where they are attached, collapsed framework roots included.
+ *
+ * @param listeners - Listed listeners
+ * @param collapsed - Collapsed framework roots
+ * @returns Counts on the element, its ancestors, and document or window
+ */
+function listenerCounts(listeners, collapsed) {
+    const counts = { target: 0, ancestor: 0, global: 0 };
+    const add = (on, count) => {
+        if (on === 'target' || on === 'ancestor')
+            counts[on] += count;
+        else
+            counts.global += count;
+    };
+    listeners.forEach((listener) => add(listener.on, 1));
+    collapsed.forEach((root) => add(root.on, root.count));
+    return counts;
+}
+/**
+ * Format `bdg dom listeners` output: listeners grouped by event type, the
+ * handlers nearest the element first, then one line per framework root,
+ * with notes for events the element has no listener of its own for.
+ *
+ * @param result - Listener report
+ * @param types - Event types asked for with --type, if any
+ * @returns Formatted output
+ */
+export function formatListeners(result, types) {
+    const fmt = new OutputFormatter();
+    const collapsed = result.collapsed ?? [];
+    if (result.listeners.length === 0 && collapsed.length === 0) {
+        fmt.text(noListenersMessage(result.element, types));
+        if (result.typeSuggestions?.length)
+            fmt.text(eventTypeSuggestion(result.typeSuggestions));
+        fmt.tip(NO_LISTENERS_HINT);
+    }
+    else {
+        fmt.text(listenersHeadline(result.element, listenerCounts(result.listeners, collapsed), result));
+        appendListenerGroups(fmt, result.listeners);
+        appendCollapsed(fmt, collapsed);
+        appendDelegationNotes(fmt, result.listeners, collapsed);
+    }
+    if (result.jqueryHandlersSkipped) {
+        fmt.blank().text(jqueryHandlersSkippedNote(result.jqueryHandlersSkipped));
+    }
+    if (result.reactHandlersSkipped) {
+        fmt.blank().text(reactHandlersSkippedNote(result.reactHandlersSkipped));
+    }
+    if (result.warning)
+        fmt.blank().text(`⚠ Warning: ${result.warning}`);
+    return fmt.build();
+}
+/**
+ * Add a note per way events reach their handlers without a listener on the
+ * element itself (React props, React root, jQuery, plain delegation).
+ *
+ * @param fmt - Output being built
+ * @param listeners - Listeners
+ * @param collapsed - Collapsed roots
+ */
+function appendDelegationNotes(fmt, listeners, collapsed) {
+    const notes = delegationNotes(listeners, collapsed).flatMap((note) => delegationNote(note) ?? []);
+    if (notes.length > 0)
+        fmt.blank();
+    notes.forEach((note) => fmt.text(note));
+}
+/**
+ * Add the collapsed framework roots, one line per node.
+ *
+ * @param fmt - Output being built
+ * @param collapsed - Collapsed roots
+ */
+function appendCollapsed(fmt, collapsed) {
+    if (collapsed.length === 0)
+        return;
+    fmt.blank().text(COLLAPSED_LISTENERS_HEADING);
+    const rows = collapsed.map((root) => {
+        const names = root.handlers.map((handler) => truncateByLength(handler.name || ANONYMOUS, NAME_MAX_LENGTH));
+        const shown = [...new Set(names)].slice(0, COLLAPSED_HANDLERS_SHOWN);
+        return [root.on, root.node, collapsedListenersSummary({ ...root, handlers: shown })];
+    });
+    alignColumns(rows).forEach((line) => fmt.text(`  ${line}`));
+}
+/**
+ * Add one block per event type: the type, then its listeners.
+ *
+ * @param fmt - Output being built
+ * @param listeners - Listeners, grouped by type
+ */
+function appendListenerGroups(fmt, listeners) {
+    const lines = alignColumns(listeners.map(listenerCells));
+    listeners.forEach((listener, i) => {
+        if (listener.type !== listeners[i - 1]?.type)
+            fmt.blank().text(listener.type);
+        fmt.text(`  ${lines[i] ?? ''}`);
+    });
+}
+//# sourceMappingURL=listeners.js.map

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

@@ -3,12 +3,12 @@
  *
  * Formats network request and response headers for human-readable display.
  */
-import type { WorkerNetworkHeadersData } from '../../ipc/protocol/commands.js';
+import type { SessionNetworkHeadersData } from '../../ipc/protocol/commands.js';
 /**
  * Format network request headers for display.
  *
- * @param data - Network headers data from worker
+ * @param data - Network headers data from the session
  * @returns Formatted string for console output
  */
-export declare function formatNetworkHeaders(data: WorkerNetworkHeadersData): string;
+export declare function formatNetworkHeaders(data: SessionNetworkHeadersData): string;
 //# sourceMappingURL=networkHeaders.d.ts.map

package/dist/ui/formatters/networkHeaders.js

@@ -3,17 +3,19 @@
  *
  * Formats network request and response headers for human-readable display.
  */
-import { OutputFormatter } from '../../ui/formatting.js';
+import { formatRequestStatus } from './requestStatus.js';
+import { OutputFormatter } from '../formatting.js';
 /**
  * Format network request headers for display.
  *
- * @param data - Network headers data from worker
+ * @param data - Network headers data from the session
  * @returns Formatted string for console output
  */
 export function formatNetworkHeaders(data) {
     const fmt = new OutputFormatter();
     fmt.text('Network Request Headers').separator('━', 60).blank();
     fmt.text('URL:').text(`  ${data.url}`).blank();
+    fmt.text(`Status: ${requestStatusLine(data)}`).blank();
     if (Object.keys(data.responseHeaders).length > 0) {
         fmt.text('Response Headers:');
         formatHeaderSection(fmt, data.responseHeaders);
@@ -34,14 +36,28 @@ export function formatNetworkHeaders(data) {
 /**
  * Format a section of headers with consistent formatting.
  *
+ * Repeated headers (CDP joins e.g. multiple `Set-Cookie` values with newlines)
+ * are printed one per line.
+ *
  * @param fmt - Output formatter instance
  * @param headers - Headers to format
  */
 function formatHeaderSection(fmt, headers) {
     const entries = Object.entries(headers).sort(([a], [b]) => a.localeCompare(b));
-    const maxKeyLength = Math.max(...entries.map(([k]) => k.length));
+    const keyWidth = Math.max(...entries.map(([k]) => k.length)) + 4;
     entries.forEach(([key, value]) => {
-        fmt.keyValue(`  ${key}:`, value, maxKeyLength + 4);
+        value.split('\n').forEach((line) => fmt.keyValue(`  ${key}`, line, keyWidth));
     });
 }
+/**
+ * Status line of a request: method, HTTP status and status text, or how it failed.
+ *
+ * @param data - Network headers data
+ * @returns e.g. `GET 404 Not Found`, `GET FAILED (net::ERR_NAME_NOT_RESOLVED)`, `GET pending`
+ */
+function requestStatusLine(data) {
+    const status = formatRequestStatus(data);
+    const text = data.statusText && /^\d+$/.test(status) ? ` ${data.statusText}` : '';
+    return [data.method, `${status}${text}`].filter(Boolean).join(' ');
+}
 //# sourceMappingURL=networkHeaders.js.map

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

@@ -6,12 +6,24 @@
  */
 import type { NetworkRequest } from '../../types.js';
 export interface NetworkListOptions {
-    json?: boolean;
     verbose?: boolean;
     last?: number;
     totalCount?: number;
-    follow?: boolean;
+    /** Requests matching the filters, before --last (defaults to totalCount) */
+    filteredCount?: number;
 }
+/**
+ * Rows of the network stream: requests that finished since the last poll,
+ * with the column header the first time.
+ *
+ * @param requests - Newly finished requests
+ * @param options - `header` the first time; `verbose` for full URLs
+ * @returns Text to print (empty when there is nothing new)
+ */
+export declare function formatNetworkFollowRows(requests: NetworkRequest[], options?: {
+    header?: boolean;
+    verbose?: boolean;
+}): string;
 /**
  * Format network requests for display.
  */