rea-agents 3.0.0 → 3.2.0

package/dist/browser/CdpCaptureDocuments.js

@@ -1,17 +1,16 @@
-import { allowedSanitizedUrl, boundedText, numberValue, recordValue, recordsValue, requiredRecord, stringValue, } from "./CdpCaptureValues.js";
+import { allowedSanitizedUrl, numberValue, recordValue, recordsValue, requiredRecord, stringValue, } from "./CdpCaptureValues.js";
 import { exclusionReasonForUrl } from "./CdpCaptureEventHelpers.js";
-/** Normalize allowed frames while retaining a bounded prefix and total count. */
+/** Normalize every allowed frame, optionally selecting a leading frame. */
 export const captureFrames = (result, allowedOrigins, maximum, completeness) => {
     const root = recordValue(requiredRecord(result).frameTree);
     if (root === undefined)
-        return { total: 0, items: [] };
+        return { items: [] };
     const items = [];
-    let total = 0;
     for (const tree of walkFrameTrees(root)) {
         const frame = recordValue(tree.frame);
         const frameId = stringValue(frame?.id);
         const sanitized = allowedSanitizedUrl(frame?.url, allowedOrigins);
-        if (frame === undefined || frameId === undefined || frameId.length > 256) {
+        if (frame === undefined || frameId === undefined) {
             completeness?.exclude("frames", "invalid_protocol_value");
             continue;
         }
@@ -19,27 +18,25 @@ export const captureFrames = (result, allowedOrigins, maximum, completeness) =>
             completeness?.exclude("frames", exclusionReasonForUrl(stringValue(frame.url)));
             continue;
         }
-        total += 1;
-        if (items.length >= maximum)
+        if (maximum !== undefined && items.length >= maximum)
             continue;
         items.push({
             frame_id: frameId,
-            parent_frame_id: (stringValue(frame.parentId) ?? "").slice(0, 256) || null,
+            parent_frame_id: stringValue(frame.parentId) ?? null,
             url: sanitized.url,
             origin: sanitized.origin,
         });
     }
-    return { total, items };
+    return { items };
 };
 /** Read the current main-frame URL from an untrusted Page.getFrameTree result. */
 export const mainFrameUrl = (result) => stringValue(recordValue(recordValue(requiredRecord(result).frameTree)?.frame)?.url);
-/** Normalize allowed resources while retaining a bounded prefix and total count. */
-export const captureResources = (result, allowedOrigins, maximum, completeness) => {
+/** Normalize every allowed resource. */
+export const captureResources = (result, allowedOrigins, completeness) => {
     const root = recordValue(requiredRecord(result).frameTree);
     if (root === undefined)
-        return { total: 0, items: [] };
+        return { items: [] };
     const items = [];
-    let total = 0;
     for (const tree of walkFrameTrees(root)) {
         for (const resource of recordsValue(tree.resources)) {
             const url = allowedSanitizedUrl(resource.url, allowedOrigins);
@@ -47,21 +44,18 @@ export const captureResources = (result, allowedOrigins, maximum, completeness)
                 completeness?.exclude("resources", exclusionReasonForUrl(stringValue(resource.url)));
                 continue;
             }
-            total += 1;
-            if (items.length >= maximum)
-                continue;
             const contentSize = numberValue(resource.contentSize);
             items.push({
                 rawUrl: stringValue(resource.url) ?? "",
                 url: url.url,
                 origin: url.origin,
-                type: (stringValue(resource.type) ?? "Other").slice(0, 100),
-                mime_type: (stringValue(resource.mimeType) ?? "").slice(0, 256),
+                type: stringValue(resource.type) ?? "Other",
+                mime_type: stringValue(resource.mimeType) ?? "",
                 content_size: contentSize === undefined ? null : Math.max(0, contentSize),
             });
         }
     }
-    return { total, items };
+    return { items };
 };
 const walkFrameTrees = function* (root) {
     const pending = [root];
@@ -106,11 +100,11 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
             : [];
         const baseIndex = nodes.length;
         total += nodeTypes.length;
-        for (let index = 0; index < nodeTypes.length && nodes.length < input.limits.max_dom_nodes; index += 1) {
+        for (let index = 0; index < nodeTypes.length; index += 1) {
             const attributeIndexes = numberArray(attributes[index]);
             const parent = Math.trunc(parents[index] ?? -1);
             const nodeIndex = nodes.length;
-            const nodeName = indexedString(strings, nodeNames[index]).slice(0, 256);
+            const nodeName = indexedString(strings, nodeNames[index]);
             nodes.push({
                 index: nodeIndex,
                 parent_index: parent < 0 ? -1 : baseIndex + parent,
@@ -119,8 +113,7 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
                 node_value_length: indexedString(strings, nodeValues[index]).length,
                 attribute_names: attributeIndexes
                     .filter((_value, attributeIndex) => attributeIndex % 2 === 0)
-                    .map((value) => indexedString(strings, value).slice(0, 256))
-                    .slice(0, 200),
+                    .map((value) => indexedString(strings, value)),
             });
             const metadata = domMetadata({
                 strings,
@@ -131,10 +124,6 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
                 allowedOrigins,
             });
             for (const url of metadata.urls) {
-                if (urls.length >= input.limits.max_resources) {
-                    completeness?.truncate("metadata");
-                    continue;
-                }
                 urls.push(url);
                 if (url.destination_scope !== "approved") {
                     excludedUrls += 1;
@@ -150,20 +139,18 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
         total,
         nodes,
         urls,
-        agentHints: agentHints.slice(0, input.limits.max_resources),
+        agentHints,
         excludedUrls,
     };
 };
-export const captureAccessibility = (results, maximum, options) => {
+export const captureAccessibility = (results, options) => {
     const all = results.flatMap((result) => recordsValue(requiredRecord(result).nodes));
     const nodeIds = new Set(all.flatMap((node) => {
         const nodeId = stringValue(node.nodeId);
         return nodeId === undefined ? [] : [nodeId];
     }));
-    let retainedBytes = 0;
     let excludedFields = 0;
-    let truncatedFields = 0;
-    const nodes = all.slice(0, maximum).map((node) => {
+    const nodes = all.map((node) => {
         const captureText = (value) => {
             const raw = stringValue(recordValue(value)?.value);
             if (raw === undefined)
@@ -172,21 +159,11 @@ export const captureAccessibility = (results, maximum, options) => {
                 excludedFields += 1;
                 return null;
             }
-            const available = Math.max(0, options.maximumTotalBytes - retainedBytes);
-            const captured = boundedUtf8(raw, Math.min(options.maximumFieldBytes, available));
-            retainedBytes += captured.bytes;
-            if (captured.truncated) {
-                truncatedFields += 1;
-                if (captured.text === "" && raw !== "") {
-                    excludedFields += 1;
-                    return null;
-                }
-            }
-            return captured.text;
+            return raw;
         };
         return {
-            node_id: (stringValue(node.nodeId) ?? "").slice(0, 256),
-            parent_id: (stringValue(node.parentId) ?? "").slice(0, 256) || null,
+            node_id: stringValue(node.nodeId) ?? "",
+            parent_id: stringValue(node.parentId) ?? null,
             role: axText(node.role),
             name: captureText(node.name),
             description: captureText(node.description),
@@ -194,15 +171,6 @@ export const captureAccessibility = (results, maximum, options) => {
             states: accessibilityStates(node.properties),
         };
     });
-    for (const node of all.slice(maximum)) {
-        for (const value of [node.name, node.description]) {
-            if (stringValue(recordValue(value)?.value) === undefined)
-                continue;
-            excludedFields += 1;
-            if (options.includeText)
-                truncatedFields += 1;
-        }
-    }
     return {
         total: all.length,
         nodes,
@@ -216,12 +184,11 @@ export const captureAccessibility = (results, maximum, options) => {
                 ? "unavailable"
                 : !options.includeText
                     ? "not_approved"
-                    : truncatedFields > 0
-                        ? "truncated"
-                        : "included",
-            retained_bytes: retainedBytes,
+                    : "included",
+            retained_bytes: nodes.reduce((total, node) => total +
+                Buffer.byteLength(node.name ?? "") +
+                Buffer.byteLength(node.description ?? ""), 0),
             excluded_fields: excludedFields,
-            truncated_fields: truncatedFields,
         },
     };
 };
@@ -263,7 +230,7 @@ const accessibilityStates = (value) => {
             : typeof raw === "number"
                 ? numberValue(raw)
                 : typeof raw === "string"
-                    ? raw.slice(0, 256)
+                    ? raw
                     : undefined;
         if (state !== undefined)
             states.set(name, state);
@@ -272,7 +239,7 @@ const accessibilityStates = (value) => {
         .sort(([left], [right]) => left.localeCompare(right))
         .map(([name, state]) => ({ name, value: state }));
 };
-const axText = (value) => boundedText(recordValue(value)?.value, 1_024);
+const axText = (value) => stringValue(recordValue(value)?.value) ?? null;
 const indexedString = (strings, index) => {
     const integer = numberValue(index);
     return integer === undefined ? "" : (strings[Math.trunc(integer)] ?? "");
@@ -335,21 +302,6 @@ const domDestination = (value, documentUrl, allowedOrigins) => {
         return { url: null, scope: "unsupported" };
     }
 };
-const boundedUtf8 = (value, maximumBytes) => {
-    const total = Buffer.byteLength(value);
-    if (total <= maximumBytes)
-        return { text: value, bytes: total, truncated: false };
-    let text = "";
-    let bytes = 0;
-    for (const character of value) {
-        const characterBytes = Buffer.byteLength(character);
-        if (bytes + characterBytes > maximumBytes)
-            break;
-        text += character;
-        bytes += characterBytes;
-    }
-    return { text, bytes, truncated: true };
-};
 const domUrlAttributes = [
     "href",
     "src",

package/dist/browser/CdpCaptureEventBodyShapes.js

@@ -15,8 +15,8 @@ export const ingestResponseBodyShape = (state, requestId, value) => {
         invalidResponseBodyShape(state, requestId);
         return;
     }
-    const inferred = inferBodyShape(state, decoded);
-    updateResponseBodyShape(state, requestId, inferred.shape, inferred.truncated);
+    const inferred = inferBodyShape(decoded);
+    updateResponseBodyShape(state, requestId, inferred.shape);
 };
 export const requestBodyShape = (state, request) => {
     if (!state.input.include_json_body_shapes)
@@ -24,52 +24,32 @@ export const requestBodyShape = (state, request) => {
     const body = stringValue(request.postData);
     if (!isJsonContentType(recordValue(request.headers)) || body === undefined)
         return { status: "unavailable", request: null, response: null };
-    const inferred = inferBodyShape(state, body);
+    const inferred = inferBodyShape(body);
     return {
-        status: inferred.truncated
-            ? "truncated"
-            : inferred.shape === null
-                ? "unavailable"
-                : "included",
+        status: inferred.shape === null ? "unavailable" : "included",
         request: inferred.shape,
         response: null,
     };
 };
-export const updateResponseBodyShape = (state, requestId, response, truncated) => {
+export const updateResponseBodyShape = (state, requestId, response) => {
     const current = state.network.get(requestId);
     if (current === undefined)
         return;
     const request = current.body_shapes.request;
-    const status = truncated || current.body_shapes.status === "truncated"
-        ? "truncated"
-        : response !== null
-            ? "included"
-            : request !== null
-                ? "partial"
-                : "unavailable";
+    const status = response !== null
+        ? "included"
+        : request !== null
+            ? "partial"
+            : "unavailable";
     state.network.set(requestId, {
         ...current,
         body_shapes: { status, request, response },
     });
 };
-const inferBodyShape = (state, text) => {
-    const bytes = Buffer.byteLength(text);
-    const remaining = state.input.limits.max_total_json_body_bytes - state.jsonBodyBytes;
-    if (bytes > state.input.limits.max_json_body_bytes || bytes > remaining) {
-        state.completeness.truncate("json_body_shapes");
-        return { shape: null, truncated: true };
-    }
-    state.jsonBodyBytes += bytes;
-    const shape = inferJsonShape(text, {
-        maximumBytes: state.input.limits.max_json_body_bytes,
-        maximumNodes: state.input.limits.max_json_shape_nodes,
-        maximumDepth: state.input.limits.max_json_shape_depth,
-    });
-    if (shape?.truncated === true)
-        state.completeness.truncate("json_body_shapes");
-    return { shape, truncated: shape?.truncated === true };
+const inferBodyShape = (text) => {
+    return { shape: inferJsonShape(text) };
 };
 const invalidResponseBodyShape = (state, requestId) => {
-    updateResponseBodyShape(state, requestId, null, false);
+    updateResponseBodyShape(state, requestId, null);
     state.completeness.exclude("json_body_shapes", "invalid_protocol_value");
 };

package/dist/browser/CdpCaptureEventHandlers.js

@@ -1,7 +1,7 @@
 import { inferJsonShape } from "../domain/jsonShape.js";
 import { safeResponseMetadata } from "./CdpSafeMetadata.js";
-import { boundedSensitiveText } from "./SensitiveTextCapture.js";
-import { allowedSanitizedUrl, boundedText, isHttpUrl, numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
+import { redactSensitiveText } from "./SensitiveTextCapture.js";
+import { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
 import { requestBodyShape } from "./CdpCaptureEventBodyShapes.js";
 import { consolePrimitive, decodeBase64, exclusionReasonForUrl, executionContextKey, firstCallFrame, initiatorLocation, integerOrNull, } from "./CdpCaptureEventHelpers.js";
 export const handleExecutionContextCreated = (state, params) => {
@@ -10,15 +10,9 @@ export const handleExecutionContextCreated = (state, params) => {
     const frameId = stringValue(recordValue(context?.auxData)?.frameId);
     if (identifier === undefined ||
         !Number.isSafeInteger(identifier) ||
-        frameId === undefined ||
-        frameId.length > 256)
+        frameId === undefined)
         return;
     const key = String(identifier);
-    if (state.executionContextFrames.size >= state.input.limits.max_scripts &&
-        !state.executionContextFrames.has(key)) {
-        state.completeness.truncate("scripts");
-        return;
-    }
     state.executionContextFrames.set(key, frameId);
 };
 export const handleExecutionContextDestroyed = (state, params) => {
@@ -30,7 +24,7 @@ export const handleScriptParsed = (state, params) => {
     const scriptId = stringValue(params.scriptId);
     const rawUrl = stringValue(params.url) ?? "";
     const sanitized = allowedSanitizedUrl(rawUrl, state.allowedOrigins);
-    if (scriptId === undefined || scriptId.length > 256) {
+    if (scriptId === undefined) {
         state.completeness.exclude("scripts", "invalid_protocol_value");
         return;
     }
@@ -38,21 +32,16 @@ export const handleScriptParsed = (state, params) => {
         state.completeness.exclude("scripts", exclusionReasonForUrl(rawUrl));
         return;
     }
-    if (state.scripts.size >= state.input.limits.max_scripts &&
-        !state.scripts.has(scriptId)) {
-        state.completeness.drop("scripts");
-        return;
-    }
     const sourceMap = sourceMapForScript(params.sourceMapURL, rawUrl, state);
     const script = {
         scriptId,
         rawUrl,
         url: sanitized.url,
         origin: sanitized.origin,
-        hash: (stringValue(params.hash) ?? "").slice(0, 512),
+        hash: stringValue(params.hash) ?? "",
         length: Math.max(0, Math.min(Number.MAX_SAFE_INTEGER, Math.trunc(numberValue(params.length) ?? 0))),
         isModule: params.isModule === true,
-        language: boundedText(params.scriptLanguage, 100),
+        language: stringValue(params.scriptLanguage) ?? null,
         sourceMapUrl: sourceMap.sanitized,
         sourceMapRawUrl: sourceMap.raw,
         executionContextKey: executionContextKey(params.executionContextId),
@@ -80,7 +69,7 @@ const sourceMapForScript = (value, scriptUrl, state) => {
 export const handleRequestWillBeSent = (state, params) => {
     const requestId = stringValue(params.requestId);
     const request = recordValue(params.request);
-    if (requestId === undefined || requestId.length > 256) {
+    if (requestId === undefined) {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         return;
     }
@@ -95,11 +84,6 @@ export const handleRequestWillBeSent = (state, params) => {
         state.network.delete(requestId);
         return;
     }
-    if (state.network.size >= state.input.limits.max_network_events &&
-        !state.network.has(requestId)) {
-        state.completeness.drop("network_requests");
-        return;
-    }
     const initiator = recordValue(params.initiator);
     const initiatorFrame = initiatorLocation(initiator);
     const rawInitiatorUrl = stringValue(initiatorFrame?.url);
@@ -110,13 +94,13 @@ export const handleRequestWillBeSent = (state, params) => {
         request_id: requestId,
         url: sanitized.url,
         origin: sanitized.origin ?? "",
-        method: (stringValue(request.method) ?? "GET").slice(0, 32),
-        resource_type: boundedText(params.type, 100),
+        method: stringValue(request.method) ?? "GET",
+        resource_type: stringValue(params.type) ?? null,
         status: null,
         mime_type: null,
         encoded_data_length: null,
         initiator: {
-            type: (stringValue(initiator?.type) ?? "other").slice(0, 100),
+            type: stringValue(initiator?.type) ?? "other",
             url: initiatorUrl?.url ?? null,
             line: integerOrNull(initiatorFrame?.lineNumber),
             column: integerOrNull(initiatorFrame?.columnNumber),
@@ -126,7 +110,7 @@ export const handleRequestWillBeSent = (state, params) => {
 };
 export const handleResponseReceived = (state, params) => {
     const requestId = stringValue(params.requestId);
-    if (requestId === undefined || requestId.length > 256) {
+    if (requestId === undefined) {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         return;
     }
@@ -145,19 +129,15 @@ export const handleResponseReceived = (state, params) => {
     state.network.set(requestId, {
         ...current,
         status: numberValue(response.status) ?? null,
-        mime_type: boundedText(response.mimeType, 256),
+        mime_type: stringValue(response.mimeType) ?? null,
     });
-    if (state.responseMetadata.length >= state.input.limits.max_network_events) {
-        state.completeness.truncate("metadata");
-        return;
-    }
     const metadata = safeResponseMetadata(requestId, sanitized.url, response, state.allowedOrigins);
     state.responseMetadata.push(metadata.response);
     state.agentHints.push(...metadata.agentHints);
 };
 export const handleLoadingFinished = (state, params) => {
     const requestId = stringValue(params.requestId);
-    if (requestId === undefined || requestId.length > 256)
+    if (requestId === undefined)
         return;
     const current = state.network.get(requestId);
     if (current === undefined)
@@ -178,17 +158,11 @@ export const handleConsoleAPICalled = (state, params) => {
         state.completeness.exclude("console_events", exclusionReasonForUrl(stringValue(frame.url)));
         return;
     }
-    if (state.console.length >= state.input.limits.max_console_events) {
-        state.completeness.drop("console_events");
-        return;
-    }
     const arguments_ = recordsValue(params.args);
     state.console.push({
-        type: (stringValue(params.type) ?? "unknown").slice(0, 100),
+        type: stringValue(params.type) ?? "unknown",
         timestamp: numberValue(params.timestamp) ?? 0,
-        argument_types: arguments_
-            .map((argument) => (stringValue(argument.type) ?? "unknown").slice(0, 100))
-            .slice(0, 100),
+        argument_types: arguments_.map((argument) => stringValue(argument.type) ?? "unknown"),
         url: source.url,
         line: integerOrNull(frame.lineNumber),
         column: integerOrNull(frame.columnNumber),
@@ -201,50 +175,32 @@ const captureConsoleText = (state, arguments_) => {
             status: "not_approved",
             values: [],
             retained_bytes: 0,
-            truncated_values: 0,
         };
     const values = [];
     let retainedBytes = 0;
-    let truncatedValues = 0;
     for (const [argumentIndex, argument] of arguments_.entries()) {
         const primitive = consolePrimitive(argument);
         if (primitive === undefined)
             continue;
-        const remaining = state.input.limits.max_total_console_text_bytes - state.consoleTextBytes;
-        if (remaining <= 0) {
-            truncatedValues += 1;
-            continue;
-        }
-        const bounded = boundedSensitiveText(primitive.text, Math.min(state.input.limits.max_console_text_field_bytes, remaining));
+        const text = redactSensitiveText(primitive.text);
         values.push({
             argument_index: argumentIndex,
             type: primitive.type,
-            text: bounded.text,
+            text,
         });
-        retainedBytes += bounded.bytes;
-        state.consoleTextBytes += bounded.bytes;
-        if (bounded.truncated)
-            truncatedValues += 1;
+        retainedBytes += Buffer.byteLength(text);
     }
-    if (truncatedValues > 0)
-        state.completeness.truncate("console_text");
     return {
-        status: truncatedValues > 0 ? "truncated" : "included",
+        status: "included",
         values,
         retained_bytes: retainedBytes,
-        truncated_values: truncatedValues,
     };
 };
 export const handleWebSocketFrame = (state, params, direction) => {
     const requestId = stringValue(params.requestId);
     if (requestId === undefined ||
-        requestId.length > 256 ||
         (!state.network.has(requestId) && !state.allowedWebSockets.has(requestId)))
         return;
-    if (state.websockets.length >= state.input.limits.max_websocket_events) {
-        state.completeness.drop("websocket_frames");
-        return;
-    }
     const response = recordValue(params.response);
     const payload = stringValue(response?.payloadData) ?? "";
     const opcode = Math.max(0, Math.trunc(numberValue(response?.opcode) ?? 0));
@@ -263,33 +219,17 @@ const captureWebSocketShape = (state, payload, opcode) => {
     if (!state.input.include_websocket_shapes)
         return null;
     if (opcode !== 1)
-        return { format: "binary", json_shape: null, truncated: false };
-    const bytes = Buffer.byteLength(payload);
-    const remaining = state.input.limits.max_total_websocket_shape_bytes -
-        state.websocketShapeBytes;
-    if (bytes > state.input.limits.max_websocket_shape_bytes ||
-        bytes > remaining) {
-        state.completeness.truncate("websocket_shapes");
-        return { format: "text", json_shape: null, truncated: true };
-    }
-    state.websocketShapeBytes += bytes;
-    const shape = inferJsonShape(payload, {
-        maximumBytes: state.input.limits.max_websocket_shape_bytes,
-        maximumNodes: state.input.limits.max_json_shape_nodes,
-        maximumDepth: state.input.limits.max_json_shape_depth,
-    });
-    if (shape?.truncated === true)
-        state.completeness.truncate("websocket_shapes");
+        return { format: "binary", json_shape: null };
+    const shape = inferJsonShape(payload);
     return {
         format: shape === null ? "text" : "json",
         json_shape: shape,
-        truncated: shape?.truncated === true,
     };
 };
 export const handleWebSocketCreated = (state, params) => {
     const requestId = stringValue(params.requestId);
     const rawUrl = stringValue(params.url);
-    if (requestId === undefined || requestId.length > 256) {
+    if (requestId === undefined) {
         state.completeness.exclude("websocket_connections", "invalid_protocol_value");
         return;
     }
@@ -317,11 +257,6 @@ export const handleWebSocketCreated = (state, params) => {
         state.completeness.exclude("websocket_connections", "disallowed_origin");
         return;
     }
-    if (!state.allowedWebSockets.has(requestId) &&
-        state.allowedWebSockets.size >= state.input.limits.max_websocket_events) {
-        state.completeness.drop("websocket_connections");
-        return;
-    }
     state.allowedWebSockets.add(requestId);
 };
 export const handleFrameNavigated = (state, params) => {

package/dist/browser/CdpCaptureEvents.js

@@ -4,7 +4,7 @@ import * as handlers from "./CdpCaptureEventHandlers.js";
 import { isJsonMediaType } from "./CdpCaptureEventHelpers.js";
 import { recordValue } from "./CdpCaptureValues.js";
 export {} from "./CdpCaptureEventTypes.js";
-/** Bounded event accumulator that drops payload values at ingestion time. */
+/** Event accumulator that validates and normalizes payloads at ingestion. */
 export class CdpCaptureEvents {
     scripts = new Map();
     executionContextFrames = new Map();
@@ -24,9 +24,6 @@ export class CdpCaptureEvents {
     originViolation = false;
     navigationDuringCapture = false;
     mainFrameId = undefined;
-    consoleTextBytes = 0;
-    jsonBodyBytes = 0;
-    websocketShapeBytes = 0;
     input;
     allowedOrigins;
     constructor(input, allowedOrigins) {
@@ -45,9 +42,6 @@ export class CdpCaptureEvents {
         this.websockets.length = 0;
         this.responseMetadata.length = 0;
         this.agentHints.length = 0;
-        this.consoleTextBytes = 0;
-        this.jsonBodyBytes = 0;
-        this.websocketShapeBytes = 0;
         this.completeness.reset();
         if (!this.input.include_console_text)
             this.completeness.exclude("console_text", "not_approved", null);
@@ -120,7 +114,7 @@ export class CdpCaptureEvents {
             .map((request) => request.request_id);
     }
     responseBodyUnavailable(requestId) {
-        bodyShapes.updateResponseBodyShape(this, requestId, null, false);
+        bodyShapes.updateResponseBodyShape(this, requestId, null);
         this.completeness.unavailable("json_body_shapes");
     }
     ingestResponseBody(requestId, value) {

package/dist/browser/CdpCaptureStorage.js

@@ -2,7 +2,7 @@ import { CdpConnection } from "./CdpConnection.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 import { captureStorageFingerprints, } from "./CdpCaptureStorageFingerprints.js";
 import { numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
-/** Capture redacted, bounded storage metadata for one authorized origin. */
+/** Capture redacted storage metadata for one authorized origin. */
 export const captureStorage = async (context, origin, limitations) => {
     const quota = recordValue(await optionalCdpCommand(context, "Storage.getUsageAndQuota", { origin }, limitations));
     const local = context.input.include_storage_keys
@@ -21,19 +21,17 @@ export const captureStorage = async (context, origin, limitations) => {
         : undefined;
     const cacheValues = recordsValue(recordValue(cacheRaw)?.caches);
     const caches = capturedCaches(cacheValues);
-    const maximum = context.input.limits.max_storage_keys;
     const fingerprints = context.input.include_storage_fingerprints
         ? await captureStorageFingerprints({
             context,
             origin,
             local,
             session,
-            indexedDbNames: indexed.slice(0, maximum),
-            caches: caches.slice(0, maximum),
+            indexedDbNames: indexed,
+            caches,
             limitations,
         })
-        : { items: [], complete: false, truncated: false };
-    const truncated = [local.items, session.items, indexed, caches].some((items) => items.length > maximum) || fingerprints.truncated;
+        : { items: [], complete: false };
     const structuredStorageComplete = indexedRaw !== undefined &&
         Array.isArray(indexedValues) &&
         indexed.length === indexedValues.length &&
@@ -44,24 +42,15 @@ export const captureStorage = async (context, origin, limitations) => {
             origin,
             usage_bytes: numberValue(quota?.usage) ?? null,
             quota_bytes: numberValue(quota?.quota) ?? null,
-            local_storage_keys: local.items
-                .map(({ key }) => key.slice(0, 1_024))
-                .slice(0, maximum),
-            session_storage_keys: session.items
-                .map(({ key }) => key.slice(0, 1_024))
-                .slice(0, maximum),
-            indexed_db_names: indexed
-                .map((name) => name.slice(0, 1_024))
-                .slice(0, maximum),
-            cache_names: caches
-                .map(({ name }) => name.slice(0, 1_024))
-                .slice(0, maximum),
+            local_storage_keys: local.items.map(({ key }) => key),
+            session_storage_keys: session.items.map(({ key }) => key),
+            indexed_db_names: [...indexed],
+            cache_names: caches.map(({ name }) => name),
             content_fingerprints: [...fingerprints.items],
             fingerprint_algorithm: "sha256",
-            fingerprints_complete: fingerprints.complete && structuredStorageComplete && !truncated,
+            fingerprints_complete: fingerprints.complete && structuredStorageComplete,
             values_redacted: true,
         },
-        truncated,
     };
 };
 const emptyStorageItems = {