rea-agents 4.1.0 → 6.0.0

package/dist/browser/CdpCaptureDocuments.js

@@ -1,4 +1,4 @@
-import { allowedSanitizedUrl, numberValue, recordValue, recordsValue, requiredRecord, stringValue, } from "./CdpCaptureValues.js";
+import { allowedSanitizedUrl, numberValue, recordValue, recordsValue, requiredRecord, cdpStringValue, } from "./CdpCaptureValues.js";
 import { exclusionReasonForUrl } from "./CdpCaptureEventHelpers.js";
 /** Normalize every allowed frame, optionally selecting a leading frame. */
 export const captureFrames = (result, allowedOrigins, maximum, completeness) => {
@@ -10,21 +10,21 @@ export const captureFrames = (result, allowedOrigins, maximum, completeness) =>
     const items = [];
     for (const tree of walkFrameTrees(root, () => completeness?.exclude("frames", "invalid_protocol_value"))) {
         const frame = recordValue(tree.frame);
-        const frameId = stringValue(frame?.id);
+        const frameId = cdpStringValue(frame?.id);
         const sanitized = allowedSanitizedUrl(frame?.url, allowedOrigins);
         if (frame === undefined || frameId === undefined) {
             completeness?.exclude("frames", "invalid_protocol_value");
             continue;
         }
         if (sanitized === undefined || sanitized.origin === null) {
-            completeness?.exclude("frames", exclusionReasonForUrl(stringValue(frame.url)));
+            completeness?.exclude("frames", exclusionReasonForUrl(cdpStringValue(frame.url)));
             continue;
         }
         if (maximum !== undefined && items.length >= maximum)
             continue;
         items.push({
             frame_id: frameId,
-            parent_frame_id: stringValue(frame.parentId) ?? null,
+            parent_frame_id: cdpStringValue(frame.parentId) ?? null,
             url: sanitized.url,
             origin: sanitized.origin,
         });
@@ -32,7 +32,7 @@ export const captureFrames = (result, allowedOrigins, maximum, completeness) =>
     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);
+export const mainFrameUrl = (result) => cdpStringValue(recordValue(recordValue(requiredRecord(result).frameTree)?.frame)?.url);
 /** Normalize every allowed resource. */
 export const captureResources = (result, allowedOrigins, completeness) => {
     const root = recordValue(recordValue(result)?.frameTree);
@@ -45,16 +45,16 @@ export const captureResources = (result, allowedOrigins, completeness) => {
         for (const resource of recordsValue(tree.resources)) {
             const url = allowedSanitizedUrl(resource.url, allowedOrigins);
             if (url === undefined || url.origin === null) {
-                completeness?.exclude("resources", exclusionReasonForUrl(stringValue(resource.url)));
+                completeness?.exclude("resources", exclusionReasonForUrl(cdpStringValue(resource.url)));
                 continue;
             }
             const contentSize = numberValue(resource.contentSize);
             items.push({
-                rawUrl: stringValue(resource.url) ?? "",
+                rawUrl: cdpStringValue(resource.url) ?? "",
                 url: url.url,
                 origin: url.origin,
-                type: stringValue(resource.type) ?? "Other",
-                mime_type: stringValue(resource.mimeType) ?? "",
+                type: cdpStringValue(resource.type) ?? "Other",
+                mime_type: cdpStringValue(resource.mimeType) ?? "",
                 content_size: contentSize === undefined ? null : Math.max(0, contentSize),
             });
         }
@@ -89,7 +89,7 @@ export const walkFrameTrees = function* (root, onMalformedChild) {
 export const captureDom = (result, allowedOrigins, input, completeness) => {
     const root = requiredRecord(result);
     const strings = Array.isArray(root.strings)
-        ? root.strings.map((value) => stringValue(value) ?? "")
+        ? root.strings.map((value) => cdpStringValue(value) ?? "")
         : [];
     const nodes = [];
     const urls = [];
@@ -102,6 +102,7 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
             completeness?.exclude("dom", exclusionReasonForUrl(documentUrl));
             continue;
         }
+        const baseUrl = indexedString(strings, document.baseURL) || documentUrl;
         const documentNodes = recordValue(document.nodes);
         if (documentNodes === undefined)
             continue;
@@ -132,6 +133,8 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
             const metadata = domMetadata({
                 strings,
                 attributes: attributeIndexes,
+                // The BASE element itself resolves against the document fallback URL.
+                baseUrl: nodeName.toLowerCase() === "base" ? documentUrl : baseUrl,
                 documentUrl,
                 nodeIndex,
                 nodeName,
@@ -160,13 +163,13 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
 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);
+        const nodeId = cdpStringValue(node.nodeId);
         return nodeId === undefined ? [] : [nodeId];
     }));
     let excludedFields = 0;
     const nodes = all.map((node) => {
         const captureText = (value) => {
-            const raw = stringValue(recordValue(value)?.value);
+            const raw = cdpStringValue(recordValue(value)?.value);
             if (raw === undefined)
                 return null;
             if (!options.includeText) {
@@ -176,8 +179,8 @@ export const captureAccessibility = (results, options) => {
             return raw;
         };
         return {
-            node_id: stringValue(node.nodeId) ?? "",
-            parent_id: stringValue(node.parentId) ?? null,
+            node_id: cdpStringValue(node.nodeId) ?? "",
+            parent_id: cdpStringValue(node.parentId) ?? null,
             role: axText(node.role),
             name: captureText(node.name),
             description: captureText(node.description),
@@ -190,7 +193,7 @@ export const captureAccessibility = (results, options) => {
         nodes,
         treeIncomplete: all.some((node) => Array.isArray(node.childIds) &&
             node.childIds.some((childId) => {
-                const id = stringValue(childId);
+                const id = cdpStringValue(childId);
                 return id !== undefined && !nodeIds.has(id);
             })),
         textCapture: {
@@ -235,7 +238,7 @@ const ACCESSIBILITY_STATE_NAMES = new Set([
 const accessibilityStates = (value) => {
     const states = new Map();
     for (const property of recordsValue(value)) {
-        const name = stringValue(property.name);
+        const name = cdpStringValue(property.name);
         if (name === undefined || !ACCESSIBILITY_STATE_NAMES.has(name))
             continue;
         const raw = recordValue(property.value)?.value;
@@ -253,7 +256,7 @@ const accessibilityStates = (value) => {
         .sort(([left], [right]) => left.localeCompare(right))
         .map(([name, state]) => ({ name, value: state }));
 };
-const axText = (value) => stringValue(recordValue(value)?.value) ?? null;
+const axText = (value) => cdpStringValue(recordValue(value)?.value) ?? null;
 const indexedString = (strings, index) => {
     const integer = numberValue(index);
     return integer === undefined ? "" : (strings[Math.trunc(integer)] ?? "");
@@ -265,7 +268,7 @@ const numberArray = (value) => Array.isArray(value)
     })
     : [];
 const domMetadata = (options) => {
-    const { strings, attributes, documentUrl, nodeIndex, nodeName, allowedOrigins, } = options;
+    const { strings, attributes, baseUrl, documentUrl, nodeIndex, nodeName, allowedOrigins, } = options;
     const pairs = new Map();
     for (let index = 0; index + 1 < attributes.length; index += 2) {
         const name = indexedString(strings, attributes[index]).toLowerCase();
@@ -277,7 +280,16 @@ const domMetadata = (options) => {
         const value = pairs.get(attribute);
         if (value === undefined)
             continue;
-        const destination = domDestination(value, documentUrl, allowedOrigins);
+        const tagName = nodeName.toLowerCase();
+        // Chrome strips HTML whitespace for FORM.action, while submit controls
+        // use the document URL only for an exactly empty formaction attribute.
+        const usesDocumentUrl = (tagName === "form" &&
+            attribute === "action" &&
+            /^[\t\n\f\r ]*$/u.test(value)) ||
+            ((tagName === "button" || tagName === "input") &&
+                attribute === "formaction" &&
+                value === "");
+        const destination = domDestination(usesDocumentUrl ? documentUrl : value, baseUrl, allowedOrigins);
         urls.push({
             node_index: nodeIndex,
             attribute,
@@ -300,9 +312,9 @@ const domMetadata = (options) => {
         : [];
     return { urls, agentHints };
 };
-const domDestination = (value, documentUrl, allowedOrigins) => {
+const domDestination = (value, baseUrl, allowedOrigins) => {
     try {
-        const parsed = new URL(value, documentUrl);
+        const parsed = new URL(value, baseUrl);
         if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
             return { url: null, scope: "unsupported" };
         if (!allowedOrigins.has(parsed.origin))

package/dist/browser/CdpCaptureEventBodyShapes.js

@@ -1,9 +1,9 @@
 import { inferJsonShape } from "../domain/jsonShape.js";
-import { recordValue, stringValue, } from "./CdpCaptureValues.js";
+import { recordValue, cdpStringValue, } from "./CdpCaptureValues.js";
 import { decodeBase64, isJsonContentType } from "./CdpCaptureEventHelpers.js";
 export const ingestResponseBodyShape = (state, requestId, value) => {
     const result = recordValue(value);
-    const body = stringValue(result?.body);
+    const body = cdpStringValue(result?.body);
     if (body === undefined) {
         invalidResponseBodyShape(state, requestId);
         return;
@@ -21,7 +21,7 @@ export const ingestResponseBodyShape = (state, requestId, value) => {
 export const requestBodyShape = (state, request) => {
     if (!state.input.include_json_body_shapes)
         return { status: "not_approved", request: null, response: null };
-    const body = stringValue(request.postData);
+    const body = cdpStringValue(request.postData);
     if (!isJsonContentType(recordValue(request.headers)) || body === undefined)
         return { status: "unavailable", request: null, response: null };
     const inferred = inferBodyShape(body);

package/dist/browser/CdpCaptureEventHandlers.js

@@ -1,12 +1,12 @@
 import { inferJsonShape } from "../domain/jsonShape.js";
 import { safeResponseMetadata } from "./CdpSafeMetadata.js";
-import { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
-import { requestBodyShape } from "./CdpCaptureEventBodyShapes.js";
-import { consolePrimitive, decodeBase64, exclusionReasonForUrl, executionContextKey, firstCallFrame, initiatorLocation, integerOrNull, isMainFrameNavigation, } from "./CdpCaptureEventHelpers.js";
+import { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
+import { requestBodyShape, updateResponseBodyShape, } from "./CdpCaptureEventBodyShapes.js";
+import { consolePrimitive, decodeBase64, exclusionReasonForUrl, executionContextKey, firstCallFrame, initiatorLocation, integerOrNull, isJsonMediaType, isMainFrameNavigation, } from "./CdpCaptureEventHelpers.js";
 export const handleExecutionContextCreated = (state, params) => {
     const context = recordValue(params.context);
     const identifier = numberValue(context?.id);
-    const frameId = stringValue(recordValue(context?.auxData)?.frameId);
+    const frameId = cdpStringValue(recordValue(context?.auxData)?.frameId);
     if (identifier === undefined ||
         !Number.isSafeInteger(identifier) ||
         frameId === undefined)
@@ -20,8 +20,8 @@ export const handleExecutionContextDestroyed = (state, params) => {
         state.executionContextFrames.delete(key);
 };
 export const handleScriptParsed = (state, params) => {
-    const scriptId = stringValue(params.scriptId);
-    const rawUrl = stringValue(params.url) ?? "";
+    const scriptId = cdpStringValue(params.scriptId);
+    const rawUrl = cdpStringValue(params.url) ?? "";
     const sanitized = allowedSanitizedUrl(rawUrl, state.allowedOrigins);
     if (scriptId === undefined) {
         state.completeness.exclude("scripts", "invalid_protocol_value");
@@ -37,10 +37,10 @@ export const handleScriptParsed = (state, params) => {
         rawUrl,
         url: sanitized.url,
         origin: sanitized.origin,
-        hash: stringValue(params.hash) ?? "",
+        hash: cdpStringValue(params.hash) ?? "",
         length: Math.max(0, Math.min(Number.MAX_SAFE_INTEGER, Math.trunc(numberValue(params.length) ?? 0))),
         isModule: params.isModule === true,
-        language: stringValue(params.scriptLanguage) ?? null,
+        language: cdpStringValue(params.scriptLanguage) ?? null,
         sourceMapUrl: sourceMap.sanitized,
         sourceMapRawUrl: sourceMap.raw,
         executionContextKey: executionContextKey(params.executionContextId),
@@ -48,7 +48,7 @@ export const handleScriptParsed = (state, params) => {
     state.scripts.set(scriptId, script);
 };
 const sourceMapForScript = (value, scriptUrl, state) => {
-    const declaredUrl = stringValue(value);
+    const declaredUrl = cdpStringValue(value);
     if (declaredUrl === undefined || declaredUrl === "")
         return { sanitized: null, raw: null };
     let rawUrl;
@@ -68,26 +68,79 @@ const sourceMapForScript = (value, scriptUrl, state) => {
     return { sanitized: null, raw: null };
 };
 export const handleRequestWillBeSent = (state, params) => {
-    const requestId = stringValue(params.requestId);
+    const requestId = cdpStringValue(params.requestId);
     const request = recordValue(params.request);
     if (requestId === undefined) {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         return;
     }
+    if (state.malformedRedirectRequestIds.has(requestId))
+        return;
     if (request === undefined) {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         state.network.delete(requestId);
+        state.networkRequestTimestamps.delete(requestId);
         return;
     }
     const sanitized = allowedSanitizedUrl(request.url, state.allowedOrigins);
     if (sanitized === undefined) {
-        state.completeness.exclude("network_requests", exclusionReasonForUrl(stringValue(request.url)));
+        state.completeness.exclude("network_requests", exclusionReasonForUrl(cdpStringValue(request.url)));
         state.network.delete(requestId);
+        state.networkRequestTimestamps.delete(requestId);
+        return;
+    }
+    const previous = state.network.get(requestId);
+    const redirectResponse = recordValue(params.redirectResponse);
+    if (Object.hasOwn(params, "redirectResponse") &&
+        redirectResponse === undefined &&
+        preserveMalformedRedirectEvidence(state, requestId, previous))
         return;
+    const redirects = [...(previous?.redirects ?? [])];
+    if (redirectResponse !== undefined) {
+        const rawResponseUrl = cdpStringValue(redirectResponse.url);
+        const responseUrl = rawResponseUrl === undefined || rawResponseUrl === ""
+            ? undefined
+            : allowedSanitizedUrl(rawResponseUrl, state.allowedOrigins);
+        const responseUrlReason = redirectResponseUrlReason(rawResponseUrl);
+        if (previous === undefined) {
+            if (responseUrl === undefined)
+                state.completeness.exclude("network_requests", responseUrlReason);
+            else
+                // CDP may deliver the continuation after its predecessor was excluded
+                // by origin policy or before capture began. Keep the final request but
+                // report missing prior coverage without calling it malformed protocol.
+                state.completeness.attachLimited("network_requests");
+        }
+        else if (responseUrl === undefined) {
+            // redirectResponse belongs to the same request ID and can contain an
+            // excluded origin. Drop the entire chain before retaining any details.
+            state.completeness.exclude("network_requests", responseUrlReason);
+            state.network.delete(requestId);
+            state.networkRequestTimestamps.delete(requestId);
+            return;
+        }
+        else {
+            redirects.push({
+                url: previous.url,
+                response_url: responseUrl.url,
+                method: previous.method,
+                resource_type: previous.resource_type,
+                status: numberValue(redirectResponse.status) ?? null,
+                mime_type: cdpStringValue(redirectResponse.mimeType) ?? null,
+                encoded_data_length: (() => {
+                    const length = numberValue(redirectResponse.encodedDataLength);
+                    return length === undefined ? null : Math.max(0, length);
+                })(),
+                request_timestamp: state.networkRequestTimestamps.get(requestId) ?? null,
+                // CDP reports redirectResponse on the next requestWillBeSent event.
+                // This is the event boundary, not a separately observed response time.
+                redirect_event_timestamp: numberValue(params.timestamp) ?? null,
+            });
+        }
     }
     const initiator = recordValue(params.initiator);
     const initiatorFrame = initiatorLocation(initiator);
-    const rawInitiatorUrl = stringValue(initiatorFrame?.url);
+    const rawInitiatorUrl = cdpStringValue(initiatorFrame?.url);
     const initiatorUrl = allowedSanitizedUrl(rawInitiatorUrl, state.allowedOrigins);
     if (rawInitiatorUrl !== undefined && initiatorUrl === undefined)
         state.completeness.exclude("network_initiators", exclusionReasonForUrl(rawInitiatorUrl));
@@ -95,26 +148,58 @@ export const handleRequestWillBeSent = (state, params) => {
         request_id: requestId,
         url: sanitized.url,
         origin: sanitized.origin ?? "",
-        method: stringValue(request.method) ?? "GET",
-        resource_type: stringValue(params.type) ?? null,
+        method: cdpStringValue(request.method) ?? "GET",
+        resource_type: cdpStringValue(params.type) ?? null,
         status: null,
         mime_type: null,
         encoded_data_length: null,
+        redirects,
         initiator: {
-            type: stringValue(initiator?.type) ?? "other",
+            type: cdpStringValue(initiator?.type) ?? "other",
             url: initiatorUrl?.url ?? null,
             line: integerOrNull(initiatorFrame?.lineNumber),
             column: integerOrNull(initiatorFrame?.columnNumber),
         },
         body_shapes: requestBodyShape(state, request),
     });
+    const timestamp = numberValue(params.timestamp);
+    if (timestamp === undefined)
+        state.networkRequestTimestamps.delete(requestId);
+    else
+        state.networkRequestTimestamps.set(requestId, timestamp);
+};
+const preserveMalformedRedirectEvidence = (state, requestId, previous) => {
+    state.completeness.exclude("network_requests", "invalid_protocol_value");
+    if (previous === undefined)
+        return false;
+    state.malformedRedirectRequestIds.add(requestId);
+    if (state.input.include_json_body_shapes &&
+        isJsonMediaType(previous.mime_type) &&
+        previous.body_shapes.response === null) {
+        updateResponseBodyShape(state, requestId, null);
+        state.completeness.exclude("json_body_shapes", "invalid_protocol_value");
+    }
+    return true;
+};
+const redirectResponseUrlReason = (value) => {
+    if (value === undefined || value === "")
+        return "invalid_protocol_value";
+    try {
+        new URL(value);
+    }
+    catch {
+        return "invalid_protocol_value";
+    }
+    return exclusionReasonForUrl(value);
 };
 export const handleResponseReceived = (state, params) => {
-    const requestId = stringValue(params.requestId);
+    const requestId = cdpStringValue(params.requestId);
     if (requestId === undefined) {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         return;
     }
+    if (state.malformedRedirectRequestIds.has(requestId))
+        return;
     const current = state.network.get(requestId);
     const response = recordValue(params.response);
     if (current === undefined)
@@ -123,23 +208,26 @@ export const handleResponseReceived = (state, params) => {
     if (response === undefined || sanitized === undefined) {
         state.completeness.exclude("network_requests", response === undefined
             ? "invalid_protocol_value"
-            : exclusionReasonForUrl(stringValue(response.url)));
+            : exclusionReasonForUrl(cdpStringValue(response.url)));
         state.network.delete(requestId);
+        state.networkRequestTimestamps.delete(requestId);
         return;
     }
     state.network.set(requestId, {
         ...current,
         status: numberValue(response.status) ?? null,
-        mime_type: stringValue(response.mimeType) ?? null,
+        mime_type: cdpStringValue(response.mimeType) ?? null,
     });
     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);
+    const requestId = cdpStringValue(params.requestId);
     if (requestId === undefined)
         return;
+    if (state.malformedRedirectRequestIds.has(requestId))
+        return;
     const current = state.network.get(requestId);
     if (current === undefined)
         return;
@@ -156,14 +244,14 @@ export const handleConsoleAPICalled = (state, params) => {
     }
     const source = allowedSanitizedUrl(frame.url, state.allowedOrigins);
     if (source === undefined) {
-        state.completeness.exclude("console_events", exclusionReasonForUrl(stringValue(frame.url)));
+        state.completeness.exclude("console_events", exclusionReasonForUrl(cdpStringValue(frame.url)));
         return;
     }
     const arguments_ = recordsValue(params.args);
     state.console.push({
-        type: stringValue(params.type) ?? "unknown",
+        type: cdpStringValue(params.type) ?? "unknown",
         timestamp: numberValue(params.timestamp) ?? 0,
-        argument_types: arguments_.map((argument) => stringValue(argument.type) ?? "unknown"),
+        argument_types: arguments_.map((argument) => cdpStringValue(argument.type) ?? "unknown"),
         url: source.url,
         line: integerOrNull(frame.lineNumber),
         column: integerOrNull(frame.columnNumber),
@@ -198,12 +286,12 @@ const captureConsoleText = (state, arguments_) => {
     };
 };
 export const handleWebSocketFrame = (state, params, direction) => {
-    const requestId = stringValue(params.requestId);
+    const requestId = cdpStringValue(params.requestId);
     if (requestId === undefined ||
         (!state.network.has(requestId) && !state.allowedWebSockets.has(requestId)))
         return;
     const response = recordValue(params.response);
-    const payload = stringValue(response?.payloadData) ?? "";
+    const payload = cdpStringValue(response?.payloadData) ?? "";
     const opcode = Math.max(0, Math.trunc(numberValue(response?.opcode) ?? 0));
     const decoded = opcode === 1 ? undefined : decodeBase64(payload);
     if (opcode !== 1 && decoded === undefined)
@@ -228,8 +316,8 @@ const captureWebSocketShape = (state, payload, opcode) => {
     };
 };
 export const handleWebSocketCreated = (state, params) => {
-    const requestId = stringValue(params.requestId);
-    const rawUrl = stringValue(params.url);
+    const requestId = cdpStringValue(params.requestId);
+    const rawUrl = cdpStringValue(params.url);
     if (requestId === undefined) {
         state.completeness.exclude("websocket_connections", "invalid_protocol_value");
         return;
@@ -268,8 +356,8 @@ export const handleFrameNavigated = (state, params) => {
         return;
     if (!isMainFrameNavigation({ method: "Page.frameNavigated", params }, state.mainFrameId))
         return;
-    const rawUrl = stringValue(frame?.url);
-    const loaderId = stringValue(frame?.loaderId);
+    const rawUrl = cdpStringValue(frame?.url);
+    const loaderId = cdpStringValue(frame?.loaderId);
     // `frameNavigated` re-fires for a document already reported (same URL and
     // loader). Treating that as a navigation aborted a valid capture with
     // `target_changed`, which is a false claim that the target moved.

package/dist/browser/CdpCaptureEventHelpers.js

@@ -1,14 +1,14 @@
-import { isHttpUrl, numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
+import { isHttpUrl, numberValue, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
 /** Identify a top-level navigation event from its untrusted CDP envelope. */
 export const isMainFrameNavigation = (event, mainFrameId) => {
     const params = recordValue(event.params);
     if (params === undefined)
         return false;
     const frameId = event.method === "Page.frameNavigated"
-        ? stringValue(recordValue(params.frame)?.id)
+        ? cdpStringValue(recordValue(params.frame)?.id)
         : event.method === "Page.frameRequestedNavigation" ||
             event.method === "Page.navigatedWithinDocument"
-            ? stringValue(params.frameId)
+            ? cdpStringValue(params.frameId)
             : undefined;
     return frameId === mainFrameId;
 };
@@ -21,7 +21,7 @@ export const initiatorLocation = (initiator) => {
             return frame;
         stack = recordValue(stack.parent);
     }
-    return stringValue(initiator?.url) === undefined ? undefined : initiator;
+    return cdpStringValue(initiator?.url) === undefined ? undefined : initiator;
 };
 export const exclusionReasonForUrl = (value) => value === undefined || value === ""
     ? "unattributed_origin"
@@ -43,7 +43,7 @@ export const isJsonContentType = (headers) => {
         return false;
     for (const [name, value] of Object.entries(headers))
         if (name.toLowerCase() === "content-type" &&
-            isJsonMediaType(stringValue(value)))
+            isJsonMediaType(cdpStringValue(value)))
             return true;
     return false;
 };
@@ -52,7 +52,7 @@ export const isJsonMediaType = (value) => {
     return (mediaType === "application/json" || mediaType?.endsWith("+json") === true);
 };
 export const consolePrimitive = (value) => {
-    const type = stringValue(value.type);
+    const type = cdpStringValue(value.type);
     switch (type) {
         case "string":
             return typeof value.value === "string"

package/dist/browser/CdpCaptureEvents.js

@@ -9,6 +9,8 @@ export class CdpCaptureEvents {
     scripts = new Map();
     executionContextFrames = new Map();
     network = new Map();
+    networkRequestTimestamps = new Map();
+    malformedRedirectRequestIds = new Set();
     allowedWebSockets = new Set();
     console = [];
     websockets = [];
@@ -39,6 +41,8 @@ export class CdpCaptureEvents {
         this.scripts.clear();
         this.executionContextFrames.clear();
         this.network.clear();
+        this.networkRequestTimestamps.clear();
+        this.malformedRedirectRequestIds.clear();
         this.allowedWebSockets.clear();
         this.console.length = 0;
         this.websockets.length = 0;
@@ -119,14 +123,19 @@ export class CdpCaptureEvents {
         if (!this.input.include_json_body_shapes)
             return [];
         return [...this.network.values()]
+            .filter((request) => !this.malformedRedirectRequestIds.has(request.request_id))
             .filter((request) => isJsonMediaType(request.mime_type))
             .map((request) => request.request_id);
     }
     responseBodyUnavailable(requestId) {
+        if (this.malformedRedirectRequestIds.has(requestId))
+            return;
         bodyShapes.updateResponseBodyShape(this, requestId, null);
         this.completeness.unavailable("json_body_shapes");
     }
     ingestResponseBody(requestId, value) {
+        if (this.malformedRedirectRequestIds.has(requestId))
+            return;
         bodyShapes.ingestResponseBodyShape(this, requestId, value);
     }
 }

package/dist/browser/CdpCaptureStorage.js

@@ -1,9 +1,10 @@
 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 storage metadata for one authorized origin. */
-export const captureStorage = async (context, origin, limitations) => {
+import { numberValue, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
+/** Capture redacted storage metadata for an authorized page and its origin. */
+export const captureStorage = async (context, pageUrl, limitations) => {
+    const origin = new URL(pageUrl).origin;
     const quota = recordValue(await optionalCdpCommand(context, "Storage.getUsageAndQuota", { origin }, limitations));
     const local = context.input.include_storage_keys
         ? await storageItems(context, origin, true, limitations)
@@ -25,6 +26,7 @@ export const captureStorage = async (context, origin, limitations) => {
         ? await captureStorageFingerprints({
             context,
             origin,
+            cookieUrl: pageUrl,
             local,
             session,
             indexedDbNames: indexed,
@@ -58,8 +60,8 @@ const emptyStorageItems = {
     complete: false,
 };
 const capturedCaches = (values) => values.flatMap((cache) => {
-    const name = stringValue(cache.cacheName);
-    const id = stringValue(cache.cacheId);
+    const name = cdpStringValue(cache.cacheName);
+    const id = cdpStringValue(cache.cacheId);
     return name === undefined || id === undefined ? [] : [{ name, id }];
 });
 const storageItems = async (context, origin, isLocalStorage, limitations) => {
@@ -70,15 +72,15 @@ const storageItems = async (context, origin, isLocalStorage, limitations) => {
     const items = entries.flatMap((entry) => {
         if (!Array.isArray(entry))
             return [];
-        const key = stringValue(entry[0]);
-        const value = stringValue(entry[1]);
+        const key = cdpStringValue(entry[0]);
+        const value = cdpStringValue(entry[1]);
         return key === undefined || value === undefined ? [] : [{ key, value }];
     });
     return { items, complete: items.length === entries.length };
 };
 const stringArray = (value) => Array.isArray(value)
     ? value.flatMap((item) => {
-        const text = stringValue(item);
+        const text = cdpStringValue(item);
         return text === undefined ? [] : [text];
     })
     : [];