rea-agents 4.0.1 → 5.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))
@@ -312,7 +324,9 @@ const domDestination = (value, documentUrl, allowedOrigins) => {
             scope: "approved",
         };
     }
-    catch {
+    catch (cause) {
+        // Unparseable URLs are out of scope, not failures.
+        void cause;
         return { url: null, scope: "unsupported" };
     }
 };

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 { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
 import { requestBodyShape } from "./CdpCaptureEventBodyShapes.js";
 import { consolePrimitive, decodeBase64, exclusionReasonForUrl, executionContextKey, firstCallFrame, initiatorLocation, integerOrNull, 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,14 +48,16 @@ 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;
     try {
         rawUrl = new URL(declaredUrl, scriptUrl).href;
     }
-    catch {
+    catch (cause) {
+        // Unparseable URLs are recorded as unsupported, not as failures.
+        void cause;
         state.completeness.exclude("source_maps", "unsupported_url");
         return { sanitized: null, raw: null };
     }
@@ -66,7 +68,7 @@ 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");
@@ -79,13 +81,13 @@ export const handleRequestWillBeSent = (state, params) => {
     }
     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);
         return;
     }
     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));
@@ -93,13 +95,13 @@ 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,
         initiator: {
-            type: stringValue(initiator?.type) ?? "other",
+            type: cdpStringValue(initiator?.type) ?? "other",
             url: initiatorUrl?.url ?? null,
             line: integerOrNull(initiatorFrame?.lineNumber),
             column: integerOrNull(initiatorFrame?.columnNumber),
@@ -108,7 +110,7 @@ export const handleRequestWillBeSent = (state, params) => {
     });
 };
 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;
@@ -121,21 +123,21 @@ 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);
         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;
     const current = state.network.get(requestId);
@@ -154,14 +156,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),
@@ -196,12 +198,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)
@@ -226,8 +228,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;
@@ -240,7 +242,9 @@ export const handleWebSocketCreated = (state, params) => {
     try {
         parsed = new URL(rawUrl);
     }
-    catch {
+    catch (cause) {
+        // Unparseable URLs are recorded as unsupported, not as failures.
+        void cause;
         state.completeness.exclude("websocket_connections", "unsupported_url");
         return;
     }
@@ -264,8 +268,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/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];
     })
     : [];

package/dist/browser/CdpCaptureStorageFingerprints.js

@@ -1,10 +1,11 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
+import { compareCodePoints } from "../domain/canonicalOrdering.js";
 import { CdpConnection } from "./CdpConnection.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
-import { recordValue, recordsValue, stringValue } from "./CdpCaptureValues.js";
+import { recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
 /** Capture stable hashes of approved storage content without returning values. */
-export const captureStorageFingerprints = async ({ context, origin, local, session, indexedDbNames, caches, limitations, }) => {
+export const captureStorageFingerprints = async ({ context, origin, cookieUrl, local, session, indexedDbNames, caches, limitations, }) => {
     const state = {
         items: [],
         complete: local.complete && session.complete,
@@ -12,7 +13,7 @@ export const captureStorageFingerprints = async ({ context, origin, local, sessi
     const run = { context, limitations, state };
     addStorageItems(state, "local_storage", local.items);
     addStorageItems(state, "session_storage", session.items);
-    await addCookies(run, origin);
+    await addCookies(run, cookieUrl);
     await addIndexedDb(run, origin, indexedDbNames);
     await addCaches(run, caches);
     state.items.sort((left, right) => compareCodePoints(`${left.scope}:${left.identity_sha256}`, `${right.scope}:${right.identity_sha256}`));
@@ -28,8 +29,9 @@ const addStorageItems = (state, scope, items) => {
             complete: true,
         });
 };
-const addCookies = async (run, origin) => {
-    const raw = await optionalCdpCommand(run.context, "Network.getCookies", { urls: [origin] }, run.limitations);
+const addCookies = async (run, pageUrl) => {
+    run.limitations.push("Cookie fingerprints cover cookies applicable to the current main-frame URL, not every path on its origin.");
+    const raw = await optionalCdpCommand(run.context, "Network.getCookies", { urls: [pageUrl] }, run.limitations);
     if (raw === undefined) {
         run.state.complete = false;
         return;
@@ -43,10 +45,10 @@ const addCookies = async (run, origin) => {
     if (cookies.length !== cookieValues.length)
         run.state.complete = false;
     for (const cookie of cookies) {
-        const name = stringValue(cookie.name);
-        const value = stringValue(cookie.value);
-        const domain = stringValue(cookie.domain);
-        const path = stringValue(cookie.path);
+        const name = cdpStringValue(cookie.name);
+        const value = cdpStringValue(cookie.value);
+        const domain = cdpStringValue(cookie.domain);
+        const path = cdpStringValue(cookie.path);
         if (name === undefined ||
             value === undefined ||
             domain === undefined ||
@@ -75,7 +77,7 @@ const addIndexedDb = async (run, origin, names) => {
             run.state.complete = false;
             continue;
         }
-        if (stringValue(database.name) !== databaseName) {
+        if (cdpStringValue(database.name) !== databaseName) {
             run.state.complete = false;
             continue;
         }
@@ -93,7 +95,7 @@ const addIndexedDb = async (run, origin, names) => {
             complete: indexedDbSchemaComplete(stores),
         });
         for (const store of stores) {
-            const objectStoreName = stringValue(store.name);
+            const objectStoreName = cdpStringValue(store.name);
             if (objectStoreName === undefined) {
                 run.state.complete = false;
                 continue;
@@ -107,22 +109,22 @@ const addIndexedDb = async (run, origin, names) => {
     }
 };
 const indexedDbStoreSchema = (store) => ({
-    name: stringValue(store.name) ?? null,
+    name: cdpStringValue(store.name) ?? null,
     key_path: stableValue(store.keyPath),
     auto_increment: store.autoIncrement === true,
     indexes: recordsValue(store.indexes).map((index) => ({
-        name: stringValue(index.name) ?? null,
+        name: cdpStringValue(index.name) ?? null,
         key_path: stableValue(index.keyPath),
         unique: index.unique === true,
         multi_entry: index.multiEntry === true,
     })),
 });
-const indexedDbSchemaComplete = (stores) => stores.every((store) => stringValue(store.name) !== undefined &&
+const indexedDbSchemaComplete = (stores) => stores.every((store) => cdpStringValue(store.name) !== undefined &&
     stableValueComplete(store.keyPath) &&
     typeof store.autoIncrement === "boolean" &&
     Array.isArray(store.indexes) &&
     recordsValue(store.indexes).length === store.indexes.length &&
-    recordsValue(store.indexes).every((index) => stringValue(index.name) !== undefined &&
+    recordsValue(store.indexes).every((index) => cdpStringValue(index.name) !== undefined &&
         stableValueComplete(index.keyPath) &&
         typeof index.unique === "boolean" &&
         typeof index.multiEntry === "boolean"));
@@ -133,7 +135,6 @@ const addIndexedDbRecords = async (run, input) => {
             securityOrigin: input.origin,
             databaseName: input.databaseName,
             objectStoreName: input.objectStoreName,
-            indexName: "",
             skipCount,
             pageSize: STORAGE_ENTRY_PAGE_SIZE,
         }, run.limitations);
@@ -163,7 +164,9 @@ const addIndexedDbRecords = async (run, input) => {
                     primaryKey,
                 },
                 value,
-                complete: remoteObjectComplete(entry.value),
+                complete: remoteObjectComplete(entry.key) &&
+                    remoteObjectComplete(entry.primaryKey) &&
+                    remoteObjectComplete(entry.value),
             });
         }
         if (result.hasMore !== true)
@@ -212,8 +215,8 @@ const addCaches = async (run, caches) => {
     }
 };
 const addCacheEntry = async (run, cache, entry) => {
-    const requestURL = stringValue(entry.requestURL);
-    const requestMethod = stringValue(entry.requestMethod);
+    const requestURL = cdpStringValue(entry.requestURL);
+    const requestMethod = cdpStringValue(entry.requestMethod);
     if (requestURL === undefined || requestMethod === undefined) {
         run.state.complete = false;
         return;
@@ -224,8 +227,8 @@ const addCacheEntry = async (run, cache, entry) => {
     }
     const headerRecords = recordsValue(entry.requestHeaders);
     const requestHeaders = headerRecords.flatMap((header) => {
-        const name = stringValue(header.name);
-        const value = stringValue(header.value);
+        const name = cdpStringValue(header.name);
+        const value = cdpStringValue(header.value);
         return name === undefined || value === undefined ? [] : [{ name, value }];
     });
     if (headerRecords.length !== entry.requestHeaders.length ||
@@ -234,7 +237,7 @@ const addCacheEntry = async (run, cache, entry) => {
         return;
     }
     const raw = await optionalCdpCommand(run.context, "CacheStorage.requestCachedResponse", { cacheId: cache.id, requestURL, requestHeaders }, run.limitations);
-    const body = stringValue(recordValue(recordValue(raw)?.response)?.body);
+    const body = cdpStringValue(recordValue(recordValue(raw)?.response)?.body);
     const decoded = body === undefined ? null : decodeBase64(body);
     const complete = decoded !== null;
     if (!complete)
@@ -315,4 +318,3 @@ const decodeBase64 = (value) => {
         return null;
     return Buffer.from(value, "base64");
 };
-const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;