browser-debugger-cli 0.12.0 → 0.14.0

package/dist/session/sessionList.d.ts

@@ -4,13 +4,15 @@
  */
 import type { StatusResponseData } from '../ipc/session/queries.js';
 import { type SocketProbeResult } from './daemonSocket.js';
+import { type UnexpectedEndReason } from './lastSession.js';
 import { type SessionDirEntry } from './paths.js';
 /**
  * State of a session: its daemon runs (`active`, `starting`, `ending`,
- * `unresponsive`), or died and left its Chrome running (`crashed`) or only
- * files (`stale`).
+ * `unresponsive`), died and left its Chrome running (`crashed`) or only
+ * files (`stale`), or exited after the session ended without `bdg stop`
+ * (`ended`: Chrome crashed or was closed, the page was closed, `--timeout`).
  */
-export type RunningSessionState = 'active' | 'starting' | 'ending' | 'unresponsive' | 'crashed' | 'stale';
+export type RunningSessionState = 'active' | 'starting' | 'ending' | 'unresponsive' | 'crashed' | 'stale' | 'ended';
 /**
  * One session in the list.
  */
@@ -27,6 +29,10 @@ export interface RunningSessionInfo {
     chromePid?: number;
     /** Command that cleans up a crashed or stale session */
     cleanup?: string;
+    /** Why an `ended` session ended */
+    endReason?: UnexpectedEndReason;
+    /** When an `ended` session ended (epoch ms) */
+    endedAt?: number;
 }
 /**
  * Summarize a daemon's status response.
@@ -38,8 +44,10 @@ export interface RunningSessionInfo {
 export declare function toRunningSession(name: string | null, data: StatusResponseData): RunningSessionInfo;
 /**
  * A session whose daemon is gone: `crashed` while the Chrome bdg launched for
- * it still runs, `stale` when only its files are left. Nothing is changed on
- * disk; `cleanup` names the command that removes them.
+ * it still runs, `stale` when only its files are left, `ended` when it left
+ * only the record of an end without `bdg stop` ({@link describeEnded}).
+ * Nothing is changed on disk; `cleanup` names the command that removes
+ * leftover files.
  *
  * @param entry - Session directory
  * @param probe - Result of probing its daemon socket

package/dist/session/sessionList.js

@@ -6,6 +6,7 @@ import * as fs from 'fs';
 import { getStatus } from '../ipc/client.js';
 import { isSessionChrome, readLiveDaemonPid } from './cleanup/staleSession.js';
 import { probeDaemonSocket } from './daemonSocket.js';
+import { readLastSessionEnd } from './lastSession.js';
 import { SESSION_STATE_FILES, getNamedSessionDir, listSessionDirs, sessionFilePathIn, } from './paths.js';
 import { readPidFromFile } from './pid.js';
 import { readPortFile } from './portClaims.js';
@@ -58,9 +59,10 @@ async function describeSession(entry) {
     return { name, state: 'unresponsive' };
 }
 /**
- * A session whose daemon socket does not answer: `starting` while its daemon
- * (from daemon.pid, verified by command line) runs but has not bound the
- * socket yet, otherwise see {@link describeLeftovers}.
+ * A session whose daemon socket does not answer: `ending` while its daemon
+ * (from daemon.pid, verified by command line) still runs, since a daemon
+ * writes daemon.pid only after it opened its socket and removes the socket
+ * first when it shuts down; otherwise see {@link describeLeftovers}.
  *
  * @param entry - Session directory
  * @param probe - Result of probing its daemon socket
@@ -69,13 +71,15 @@ async function describeSession(entry) {
 function describeWithoutSocket(entry, probe) {
     const daemonPid = readLiveDaemonPid(entry.dir);
     if (daemonPid !== null)
-        return { name: entry.name, state: 'starting', daemonPid };
+        return { name: entry.name, state: 'ending', daemonPid };
     return describeLeftovers(entry, probe);
 }
 /**
  * A session whose daemon is gone: `crashed` while the Chrome bdg launched for
- * it still runs, `stale` when only its files are left. Nothing is changed on
- * disk; `cleanup` names the command that removes them.
+ * it still runs, `stale` when only its files are left, `ended` when it left
+ * only the record of an end without `bdg stop` ({@link describeEnded}).
+ * Nothing is changed on disk; `cleanup` names the command that removes
+ * leftover files.
  *
  * @param entry - Session directory
  * @param probe - Result of probing its daemon socket
@@ -87,7 +91,7 @@ export function describeLeftovers({ name, dir }, probe) {
     const leftover = probe === 'stale' ||
         SESSION_STATE_FILES.some((type) => fs.existsSync(sessionFilePathIn(dir, type)));
     if (!orphan && !leftover)
-        return null;
+        return describeEnded({ name, dir });
     const port = leftoverPort(dir);
     return {
         name,
@@ -97,6 +101,26 @@ export function describeLeftovers({ name, dir }, probe) {
         cleanup: sessionCommand('bdg cleanup', name),
     };
 }
+/**
+ * A session that ended without `bdg stop` and whose daemon exited cleanly:
+ * `ended`, with why and when, until the session starts again or
+ * `bdg cleanup` clears the record.
+ *
+ * @param entry - Session directory
+ * @returns Session info, or null when the directory holds no such record
+ */
+function describeEnded({ name, dir }) {
+    const end = readLastSessionEnd(dir);
+    if (end === null)
+        return null;
+    return {
+        name,
+        state: 'ended',
+        endReason: end.reason,
+        endedAt: end.endedAt,
+        cleanup: sessionCommand('bdg cleanup', name),
+    };
+}
 /**
  * The port a dead session used: from its metadata, else its `port.txt`.
  *

package/dist/telemetry/a11y.d.ts

@@ -1,5 +1,5 @@
 import type { Protocol } from '../connection/typed-cdp.js';
-import type { A11yNode, A11yTree, A11yQueryPattern, A11yQueryResult, NodeRef } from '../types.js';
+import type { A11yNode, A11yTree, A11yQueryPattern, A11yQueryResult, ListedA11yTree, NodeRef } from '../types.js';
 /**
  * Builds accessibility tree from raw CDP nodes.
  *
@@ -14,6 +14,20 @@ import type { A11yNode, A11yTree, A11yQueryPattern, A11yQueryResult, NodeRef } f
  * @throws Error if no root node found
  */
 export declare function buildTreeFromRawNodes(rawNodes: Protocol.Accessibility.AXNode[]): A11yTree;
+/**
+ * The nodes `dom a11y tree` lists, depth-first from the root (then nodes not
+ * under it, such as frame content): the first `limit` (0 = all) no deeper
+ * than `maxDepth`. Noise ({@link isTreeNoise}) is counted as skipped and its
+ * children move up a level, so the budget goes to meaningful nodes; nodes cut
+ * by the limit or depth are counted as omitted. Every node of the tree is
+ * listed, omitted or skipped.
+ *
+ * @param tree - Accessibility tree
+ * @param limit - Nodes to list (0 = all listable ones)
+ * @param maxDepth - Deepest level to list (0 = root only; undefined = all)
+ * @returns Listed nodes with their depth, the tree size, and how many were cut or skipped
+ */
+export declare function listA11yTree(tree: A11yTree, limit: number, maxDepth?: number): ListedA11yTree;
 /**
  * Collects the full accessibility tree from the page via IPC.
  *

package/dist/telemetry/a11y.js

@@ -1,6 +1,6 @@
 import { CommandError } from '../errors/index.js';
 import { unknownQueryFieldError } from '../errors/messages.js';
-import { callCDP } from '../ipc/client.js';
+import { callBdgScript, callCDP } from '../ipc/client.js';
 import { MASKED_VALUE, SENSITIVE_FIELD_JS } from '../runtime/dom/elementInfo.js';
 import { childFrameIds } from '../runtime/dom/frameLayout.js';
 import { ConcurrencyLimiter } from '../utils/concurrency.js';
@@ -47,6 +47,89 @@ export function buildTreeFromRawNodes(rawNodes) {
     const root = nodes.get(rootRaw.nodeId);
     return { root, nodes, count: nodes.size };
 }
+/** Roles that only lay out their children and say nothing themselves */
+const LAYOUT_ROLES = new Set([
+    'generic',
+    'none',
+    'presentation',
+    'LayoutTable',
+    'LayoutTableRow',
+    'LayoutTableCell',
+]);
+/**
+ * Whether a node is left out of `dom a11y tree`: text boxes, blank text,
+ * text that repeats its parent's name, and nameless layout wrappers.
+ *
+ * @param node - Accessibility node
+ * @param parentName - Name of the nearest named ancestor
+ * @returns True when the node says nothing of its own
+ */
+function isTreeNoise(node, parentName) {
+    return (node.role === 'InlineTextBox' ||
+        (node.role === 'StaticText' && (node.name === parentName || !node.name?.trim())) ||
+        (LAYOUT_ROLES.has(node.role) && !node.name));
+}
+/**
+ * The nodes `dom a11y tree` lists, depth-first from the root (then nodes not
+ * under it, such as frame content): the first `limit` (0 = all) no deeper
+ * than `maxDepth`. Noise ({@link isTreeNoise}) is counted as skipped and its
+ * children move up a level, so the budget goes to meaningful nodes; nodes cut
+ * by the limit or depth are counted as omitted. Every node of the tree is
+ * listed, omitted or skipped.
+ *
+ * @param tree - Accessibility tree
+ * @param limit - Nodes to list (0 = all listable ones)
+ * @param maxDepth - Deepest level to list (0 = root only; undefined = all)
+ * @returns Listed nodes with their depth, the tree size, and how many were cut or skipped
+ */
+export function listA11yTree(tree, limit, maxDepth) {
+    const nodes = [];
+    const visited = new Set();
+    let omitted = 0;
+    let skipped = 0;
+    const visit = (node, depth, parentName) => {
+        if (visited.has(node.nodeId))
+            return;
+        visited.add(node.nodeId);
+        const listable = !isTreeNoise(node, parentName);
+        if (listable) {
+            const fits = (limit === 0 || nodes.length < limit) && (maxDepth ?? depth) >= depth;
+            if (fits)
+                nodes.push(listedNode(node, depth));
+            else
+                omitted++;
+        }
+        else {
+            skipped++;
+        }
+        for (const childId of node.childIds ?? []) {
+            const child = tree.nodes.get(childId);
+            if (child)
+                visit(child, listable ? depth + 1 : depth, node.name ?? parentName);
+        }
+    };
+    visit(tree.root, 0, undefined);
+    for (const node of tree.nodes.values())
+        visit(node, 0, undefined);
+    return {
+        nodes,
+        count: tree.count,
+        ...(omitted > 0 && { omitted }),
+        ...(skipped > 0 && { skipped }),
+    };
+}
+/**
+ * A node as the tree lists it: its depth instead of child ids (its children
+ * follow it, one level deeper).
+ *
+ * @param node - Accessibility node
+ * @param depth - Its level in the listing
+ * @returns Listed node
+ */
+function listedNode(node, depth) {
+    const { childIds: _childIds, ...rest } = node;
+    return { ...rest, depth };
+}
 /**
  * Ids of a node's children as shown: ignored children are replaced by their
  * own non-ignored descendants; ids missing from the tree are dropped.
@@ -118,7 +201,7 @@ async function sensitiveNodeIds(tree) {
  */
 async function isSensitiveField(backendNodeId) {
     const objectGroup = 'bdg-a11y-secret';
-    const resolved = await callCDP('DOM.resolveNode', { backendNodeId, objectGroup });
+    const resolved = await callBdgScript('DOM.resolveNode', { backendNodeId, objectGroup });
     const objectId = resolved.data?.result?.object
         ?.objectId;
     if (!objectId)

package/dist/telemetry/console.d.ts

@@ -31,7 +31,8 @@ export declare function formatExceptionText(details: Protocol.Runtime.ExceptionD
  * @param messages - Array to populate with console messages
  * @param includeAll - If true, disable default pattern filtering
  * @param getCurrentNavigationId - Function to get current navigation ID
+ * @param onDropped - Called for each message dropped at the limit (the oldest go first)
  * @returns Cleanup function to remove event handlers
  */
-export declare function startConsoleCollection(cdp: CDPConnection, messages: ConsoleMessage[], includeAll?: boolean, getCurrentNavigationId?: () => number): Promise<CleanupFunction>;
+export declare function startConsoleCollection(cdp: CDPConnection, messages: ConsoleMessage[], includeAll?: boolean, getCurrentNavigationId?: () => number, onDropped?: () => void): Promise<CleanupFunction>;
 //# sourceMappingURL=console.d.ts.map

package/dist/telemetry/console.js

@@ -75,15 +75,23 @@ function createMessage(type, text, timestamp, args, context) {
     };
 }
 /**
- * Insert a message in timestamp order.
- * Messages are kept sorted by timestamp to handle async expansion delays.
+ * Insert a message in timestamp order (async expansion can deliver a message
+ * late). At {@link MAX_CONSOLE_MESSAGES} the oldest message is dropped to
+ * make room, so the newest are kept; a late message older than all kept ones
+ * is dropped itself.
  *
- * @returns False when the message limit is reached (the message is dropped)
+ * @param messages - Messages, oldest first (updated)
+ * @param message - Message to add
+ * @param onDropped - Called for each message dropped
+ * @returns False when the message itself was dropped
  */
-function insertMessageByTimestamp(messages, message) {
+function insertMessageByTimestamp(messages, message, onDropped) {
     if (messages.length >= MAX_CONSOLE_MESSAGES) {
-        log.debug(`Warning: Console message limit reached (${MAX_CONSOLE_MESSAGES})`);
-        return false;
+        const oldest = messages[0];
+        onDropped();
+        if (oldest && message.timestamp < oldest.timestamp)
+            return false;
+        messages.shift();
     }
     const insertIndex = findInsertIndex(messages, message.timestamp);
     messages.splice(insertIndex, 0, message);
@@ -111,32 +119,31 @@ function findInsertIndex(messages, timestamp) {
 /**
  * Handle a console API call event with object expansion.
  */
-function handleConsoleAPICall(cdp, messages, params, context, includeAll) {
+function handleConsoleAPICall(cdp, insert, params, context, includeAll) {
     const basicText = formatConsoleArgs(params.args);
     if (shouldExcludeConsoleMessage(basicText, params.type, includeAll)) {
         return;
     }
     if (hasArgsNeedingExpansion(params.args) && !usesFormatSpecifiers(params.args)) {
-        handleExpandableMessage(cdp, messages, params, context, basicText);
+        handleExpandableMessage(cdp, insert, params, context, basicText);
     }
     else {
-        const message = createMessage(params.type, basicText, params.timestamp, params.args, context);
-        insertMessageByTimestamp(messages, message);
+        insert(createMessage(params.type, basicText, params.timestamp, params.args, context));
     }
 }
 /**
  * Handle a message with expandable objects.
  */
-function handleExpandableMessage(cdp, messages, params, context, fallbackText) {
+function handleExpandableMessage(cdp, insert, params, context, fallbackText) {
     void expandConsoleArgs(cdp, params.args)
         .then((expandedText) => {
         const message = createMessage(params.type, expandedText, params.timestamp, params.args, context);
-        insertMessageByTimestamp(messages, message);
+        insert(message);
     })
         .catch((error) => {
         log.debug(`Object expansion failed, using basic text: ${String(error)}`);
         const message = createMessage(params.type, fallbackText, params.timestamp, params.args, context);
-        insertMessageByTimestamp(messages, message);
+        insert(message);
     });
 }
 /**
@@ -178,14 +185,14 @@ export function formatExceptionText(details) {
  *
  * @returns The message added, undefined when filtered out or over the limit
  */
-function handleExceptionThrown(messages, params, context, includeAll) {
+function handleExceptionThrown(insert, params, context, includeAll) {
     const exception = params.exceptionDetails;
     const text = formatExceptionText(exception);
     if (shouldExcludeConsoleMessage(text, 'error', includeAll)) {
         return undefined;
     }
     const message = createMessage('error', text, params.timestamp, undefined, context);
-    return insertMessageByTimestamp(messages, message) ? message : undefined;
+    return insert(message) ? message : undefined;
 }
 /** CDP's text of an unhandled promise rejection (the only kind Chrome revokes) */
 const UNHANDLED_REJECTION_TEXT = 'Uncaught (in promise)';
@@ -270,7 +277,7 @@ class RevocableRejections {
  * Worker entries are skipped: workers are attached directly, so their console
  * calls already arrive (with arguments) from the worker's own session.
  */
-function handleLogEntry(messages, entry, navigationId, includeAll) {
+function handleLogEntry(insert, entry, navigationId, includeAll) {
     const type = LOG_LEVEL_TYPES[entry.level];
     if (entry.source === 'worker' || shouldExcludeConsoleMessage(entry.text, type, includeAll)) {
         return;
@@ -287,7 +294,7 @@ function handleLogEntry(messages, entry, navigationId, includeAll) {
         stackTrace: convertStackTrace(entry.stackTrace) ?? location,
         source: entry.source,
     };
-    insertMessageByTimestamp(messages, createMessage(type, entry.text, entry.timestamp, undefined, context));
+    insert(createMessage(type, entry.text, entry.timestamp, undefined, context));
 }
 /**
  * Enable console and log events on an attached target's session.
@@ -325,17 +332,19 @@ async function startOptionalSources(cdp, typed) {
  * @param messages - Array to populate with console messages
  * @param includeAll - If true, disable default pattern filtering
  * @param getCurrentNavigationId - Function to get current navigation ID
+ * @param onDropped - Called for each message dropped at the limit (the oldest go first)
  * @returns Cleanup function to remove event handlers
  */
-export async function startConsoleCollection(cdp, messages, includeAll = false, getCurrentNavigationId) {
+export async function startConsoleCollection(cdp, messages, includeAll = false, getCurrentNavigationId, onDropped = () => undefined) {
     const registry = new CDPHandlerRegistry();
     const typed = new TypedCDPConnection(cdp);
+    const insert = (message) => insertMessageByTimestamp(messages, message, onDropped);
     registry.registerTyped(typed, 'Runtime.consoleAPICalled', (params, sessionId) => {
         const context = {
             navigationId: getCurrentNavigationId?.(),
             stackTrace: convertStackTrace(params.stackTrace),
         };
-        handleConsoleAPICall(senderFor(cdp, sessionId), messages, params, context, includeAll);
+        handleConsoleAPICall(senderFor(cdp, sessionId), insert, params, context, includeAll);
     });
     const rejections = new RevocableRejections();
     registry.registerTyped(typed, 'Runtime.exceptionThrown', (params, sessionId) => {
@@ -343,7 +352,7 @@ export async function startConsoleCollection(cdp, messages, includeAll = false,
             navigationId: getCurrentNavigationId?.(),
             stackTrace: convertStackTrace(params.exceptionDetails.stackTrace),
         };
-        const message = handleExceptionThrown(messages, params, context, includeAll);
+        const message = handleExceptionThrown(insert, params, context, includeAll);
         if (message)
             rejections.track(params.exceptionDetails, message, sessionId);
     });
@@ -357,7 +366,7 @@ export async function startConsoleCollection(cdp, messages, includeAll = false,
         rejections.forgetSession(sessionId);
     });
     registry.registerTyped(typed, 'Log.entryAdded', ({ entry }) => {
-        handleLogEntry(messages, entry, getCurrentNavigationId?.(), includeAll);
+        handleLogEntry(insert, entry, getCurrentNavigationId?.(), includeAll);
     });
     try {
         await typed.send('Runtime.enable', {});

package/dist/telemetry/har/builder.js

@@ -2,7 +2,7 @@
  * HAR (HTTP Archive) builder for transforming network telemetry to HAR 1.2 format.
  */
 import { createRequire } from 'node:module';
-import { skippedBodyReason } from '../network.js';
+import { skippedBodyReason } from '../networkRetention.js';
 /**
  * Loads Node builtins on first use: importing `node:http` in an ES module
  * reads all its exports, which loads undici and zlib (about 8 ms of every CLI

package/dist/telemetry/network.d.ts

@@ -1,19 +1,6 @@
 import type { CDPConnection } from '../connection/cdp.js';
 import type { NetworkRequest, WebSocketConnection, CleanupFunction } from '../types.js';
-/**
- * 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;
+import { type NetworkEvictions } from './networkRetention.js';
 /**
  * A request that has started but not finished or failed yet.
  */
@@ -41,6 +28,12 @@ export interface NetworkCollectionOptions {
     networkInclude?: string[];
     networkExclude?: string[];
     maxBodySize?: number;
+    /** Finished requests kept at most; past it the oldest are dropped (default {@link MAX_NETWORK_REQUESTS}) */
+    maxRequests?: number;
+    /** Total size of stored response bodies; past it the oldest are evicted (default {@link MAX_TOTAL_BODY_BYTES}) */
+    maxTotalBodyBytes?: number;
+    /** Counters of dropped requests and evicted bodies; otherwise the collector keeps private ones */
+    evictions?: NetworkEvictions | undefined;
     getCurrentNavigationId?: (() => number) | undefined;
 }
 /**
@@ -56,8 +49,12 @@ export interface NetworkCollectionOptions {
  *
  * @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)

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);