browser-debugger-cli 0.13.0 → 0.15.0

package/dist/telemetry/har/sanitizeBody.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Credential redaction in request bodies and `name=value` lists, for
+ * sanitized HAR exports (see sanitize.ts).
+ *
+ * Matching is by field name only, so it over-redacts: any primitive whose
+ * name looks like a credential (`tokenCount: 5`) is replaced too.
+ */
+/** Replaces a credential value */
+export declare const REDACTED = "[redacted]";
+/**
+ * Whether a body field, form field or query parameter name looks like it
+ * holds a credential.
+ *
+ * @param name - Field name
+ * @returns True for password, token, secret, key, session and signature names
+ */
+export declare function isSensitiveField(name: string): boolean;
+/**
+ * Redact credential values in an `&`-separated `name=value` list (a form body,
+ * query string or fragment), leaving the other pairs byte for byte.
+ *
+ * @param text - List like `user=ann&password=hunter2`
+ * @param isSensitive - Whether a decoded name holds a credential
+ * @param replacement - Value written instead
+ * @returns List with credential values replaced
+ */
+export declare function redactPairs(text: string, isSensitive: (name: string) => boolean, replacement: string): string;
+/**
+ * Redact credential fields of a request body: multipart parts, form fields
+ * (by Content-Type or shape) and JSON fields at any depth.
+ *
+ * @param text - Body text
+ * @param mimeType - Content-Type of the body
+ * @returns Body with credential values replaced; the text unchanged when
+ *   there were none
+ */
+export declare function redactRequestBody(text: string, mimeType: string): string;
+//# sourceMappingURL=sanitizeBody.d.ts.map

package/dist/telemetry/har/sanitizeBody.js

@@ -0,0 +1,168 @@
+/**
+ * Credential redaction in request bodies and `name=value` lists, for
+ * sanitized HAR exports (see sanitize.ts).
+ *
+ * Matching is by field name only, so it over-redacts: any primitive whose
+ * name looks like a credential (`tokenCount: 5`) is replaced too.
+ */
+import { SENSITIVE_NAME_SOURCE } from '../../runtime/dom/elementInfo.js';
+import { createLogger } from '../../ui/logging/index.js';
+import { getErrorMessage } from '../../utils/errors.js';
+const log = createLogger('network');
+/** Replaces a credential value */
+export const REDACTED = '[redacted]';
+/**
+ * Field names holding credentials: password-like names (shared with form
+ * masking), tokens, secrets, keys, sessions, signatures and credentials
+ */
+const SENSITIVE_FIELD = new RegExp(`${SENSITIVE_NAME_SOURCE}|token|secret|api[-_]?key|authoriz|credential|jwt|private[-_]?key|access[-_]?key|session|signature`, 'i');
+/** A body that is a form whatever its Content-Type: `k=v&k=v`, no whitespace, not JSON */
+const FORM_BODY = /^[^\s=&{["]+=[^\s&]*(?:&[^\s=&]+=[^\s&]*)*$/;
+/**
+ * Whether a body field, form field or query parameter name looks like it
+ * holds a credential.
+ *
+ * @param name - Field name
+ * @returns True for password, token, secret, key, session and signature names
+ */
+export function isSensitiveField(name) {
+    return SENSITIVE_FIELD.test(name);
+}
+/**
+ * Redact credential values in an `&`-separated `name=value` list (a form body,
+ * query string or fragment), leaving the other pairs byte for byte.
+ *
+ * @param text - List like `user=ann&password=hunter2`
+ * @param isSensitive - Whether a decoded name holds a credential
+ * @param replacement - Value written instead
+ * @returns List with credential values replaced
+ */
+export function redactPairs(text, isSensitive, replacement) {
+    return text
+        .split('&')
+        .map((pair) => {
+        const eq = pair.indexOf('=');
+        if (eq === -1 || !isSensitive(decodeName(pair.slice(0, eq))))
+            return pair;
+        return `${pair.slice(0, eq)}=${replacement}`;
+    })
+        .join('&');
+}
+/**
+ * Redact credential fields of a request body: multipart parts, form fields
+ * (by Content-Type or shape) and JSON fields at any depth.
+ *
+ * @param text - Body text
+ * @param mimeType - Content-Type of the body
+ * @returns Body with credential values replaced; the text unchanged when
+ *   there were none
+ */
+export function redactRequestBody(text, mimeType) {
+    if (/multipart\/form-data/i.test(mimeType))
+        return redactMultipart(text, mimeType);
+    if (/x-www-form-urlencoded/i.test(mimeType) || FORM_BODY.test(text)) {
+        return redactPairs(text, isSensitiveField, REDACTED);
+    }
+    return redactJsonBody(text);
+}
+/**
+ * Decode a form or query name.
+ *
+ * @param name - Encoded name
+ * @returns Decoded name, or the raw name when it is not valid encoding
+ */
+function decodeName(name) {
+    try {
+        return decodeURIComponent(name.replace(/\+/g, ' '));
+    }
+    catch (error) {
+        log.debug(`Field name not decodable: ${getErrorMessage(error)}`);
+        return name;
+    }
+}
+/**
+ * Redact the values of credential parts of a multipart body, leaving the
+ * other parts byte for byte.
+ *
+ * @param text - Body text
+ * @param mimeType - Content-Type with the boundary
+ * @returns Body with credential part values replaced
+ */
+function redactMultipart(text, mimeType) {
+    const match = /boundary=(?:"([^"]+)"|([^;\s]+))/i.exec(mimeType);
+    const boundary = match?.[1] ?? match?.[2];
+    if (!boundary)
+        return text;
+    const delimiter = `--${boundary}`;
+    return text.split(delimiter).map(redactPart).join(delimiter);
+}
+/**
+ * Redact the value of one multipart part if its name holds a credential.
+ *
+ * @param part - Text between two boundary delimiters
+ * @returns The part, or the part with its value replaced
+ */
+function redactPart(part) {
+    const headerEnd = part.indexOf('\r\n\r\n');
+    if (headerEnd === -1)
+        return part;
+    const name = /;\s*name="([^"]*)"/i.exec(part.slice(0, headerEnd))?.[1];
+    if (name === undefined || !isSensitiveField(name))
+        return part;
+    const valueEnd = part.endsWith('\r\n') ? part.length - 2 : part.length;
+    return `${part.slice(0, headerEnd + 4)}${REDACTED}${part.slice(valueEnd)}`;
+}
+/**
+ * Redact credential fields of a JSON body.
+ *
+ * @param text - Body text
+ * @returns Re-serialized JSON when a field was redacted, the text unchanged
+ *   when none was or it is not JSON, and {@link REDACTED} for JSON too deep
+ *   to walk
+ */
+function redactJsonBody(text) {
+    if (!/^\s*[[{]/.test(text))
+        return text;
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        log.debug(`Request body not JSON: ${getErrorMessage(error)}`);
+        return error instanceof SyntaxError ? text : REDACTED;
+    }
+    try {
+        const hits = { count: 0 };
+        const redacted = redactJson(parsed, false, hits);
+        return hits.count > 0 ? JSON.stringify(redacted) : text;
+    }
+    catch (error) {
+        log.debug(`Request body redacted whole: ${getErrorMessage(error)}`);
+        return REDACTED;
+    }
+}
+/**
+ * Copy of parsed JSON with the primitives under credential names replaced.
+ * Objects and arrays keep their structure; every string, number and boolean
+ * inside a credential-named field is replaced, at any depth.
+ *
+ * @param value - Parsed JSON value
+ * @param sensitive - Whether an enclosing field name holds a credential
+ * @param hits - Counter of replaced values
+ * @returns Redacted copy
+ */
+function redactJson(value, sensitive, hits) {
+    if (Array.isArray(value))
+        return value.map((item) => redactJson(item, sensitive, hits));
+    if (value !== null && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, field]) => [
+            key,
+            redactJson(field, sensitive || isSensitiveField(key), hits),
+        ]));
+    }
+    if (!sensitive || !['string', 'number', 'boolean'].includes(typeof value))
+        return value;
+    hits.count++;
+    return REDACTED;
+}
+//# sourceMappingURL=sanitizeBody.js.map

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

package/dist/telemetry/networkRetention.d.ts

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

package/dist/telemetry/networkRetention.js

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

package/dist/types.d.ts

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