rea-agents 6.4.0 → 6.7.0

package/dist/browser/CdpCaptureDomSvg.js

@@ -1,42 +1,50 @@
-import { numberValue } from "./CdpCaptureValues.js";
+import { recordValue } from "./CdpCaptureValues.js";
 const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
 const XLINK_NAMESPACE = "http://www.w3.org/1999/xlink";
-const UNRESOLVED = {
-    svgElement: false,
-    xlinkHref: undefined,
-};
-const stringAt = (strings, index) => {
-    const integer = numberValue(index);
-    return integer === undefined ? "" : (strings[Math.trunc(integer)] ?? "");
+/** Bind the browser's SVG flag to the exact snapshotted element. */
+export const capturedSvgNodeKind = (query, result) => {
+    const node = recordValue(recordValue(result)?.node);
+    if (node?.backendNodeId !== query.backendNodeId ||
+        node.nodeName !== query.nodeName ||
+        node.nodeType !== 1)
+        return undefined;
+    // CDP omits isSVG for non-SVG nodes. Other values are malformed, not false.
+    return node.isSVG === undefined
+        ? false
+        : typeof node.isSVG === "boolean"
+            ? node.isSVG
+            : undefined;
 };
-const numberArray = (value) => Array.isArray(value)
-    ? value.flatMap((item) => {
-        const number = numberValue(item);
-        return number === undefined ? [] : [number];
-    })
-    : [];
 // DOMSnapshot has no namespace URI. HTML documents use uppercase `HTML` and
 // the parser's local names. XML documents preserve prefixed names and xmlns
 // declarations, including those on standalone SVG roots.
 const xmlDocument = (nodes) => {
-    const documentIndex = nodes.nodeTypes.findIndex((nodeType) => Math.trunc(nodeType) === 9);
+    const documentIndex = nodes.nodeTypes.findIndex((nodeType) => nodeType === 9);
     if (documentIndex < 0)
         return false;
+    if (svgSourceNode(nodes, documentIndex) === undefined ||
+        nodes.parents[documentIndex] !== -1)
+        return undefined;
     for (let index = 0; index < nodes.nodeTypes.length; index += 1) {
-        if (Math.trunc(nodes.nodeTypes[index] ?? 0) !== 1)
+        if (nodes.nodeTypes[index] !== 1)
             continue;
-        if (Math.trunc(nodes.parents[index] ?? -1) !== documentIndex)
+        if (nodes.parents[index] !== documentIndex)
             continue;
-        const name = stringAt(nodes.strings, nodes.nodeNames[index]);
+        const source = svgSourceNode(nodes, index);
+        if (source === undefined)
+            return undefined;
+        const name = source.nodeName;
         if (name === "HTML")
             return false;
         if (name === "html" || name.includes(":"))
             return true;
         // Explicit namespaces also identify standalone SVG and other XML roots.
         // Namespace-free synthetic snapshots retain the legacy HTML behavior.
-        const attributes = numberArray(nodes.attributes[index]);
-        return attributes.some((value, offset) => offset % 2 === 0 &&
-            xmlnsPrefix(stringAt(nodes.strings, value)) !== undefined);
+        const attributes = source.attributes;
+        for (const [attributeName] of attributes)
+            if (xmlnsPrefix(attributeName) !== undefined)
+                return true;
+        return false;
     }
     return false;
 };
@@ -44,58 +52,38 @@ export const createDocumentSvgAncestry = (nodes) => {
     const xml = xmlDocument(nodes);
     return {
         xml,
-        nodes,
-        svgContexts: new Map(),
-        xmlLinks: xml ? resolveXmlElements(nodes) : new Map(),
+        xmlLinks: xml === true ? resolveXmlElements(nodes) : new Map(),
     };
 };
 export const domSvgLink = (ancestry, index) => {
-    if (!ancestry.xml) {
+    if (ancestry.xml === false) {
         return {
-            svgElement: elementInSvgContext(index, ancestry.nodes, ancestry.svgContexts),
+            svgElement: false,
             xmlDocument: false,
             xlinkHref: undefined,
         };
     }
-    const resolved = ancestry.xmlLinks.get(index) ?? UNRESOLVED;
+    if (ancestry.xml === undefined) {
+        return {
+            svgElement: false,
+            xmlDocument: undefined,
+            xlinkHref: undefined,
+        };
+    }
+    const resolved = ancestry.xmlLinks.get(index);
+    if (resolved === undefined) {
+        return {
+            svgElement: false,
+            xmlDocument: undefined,
+            xlinkHref: undefined,
+        };
+    }
     return {
         svgElement: resolved.svgElement,
         xmlDocument: true,
         xlinkHref: resolved.xlinkHref,
     };
 };
-// Chrome's HTML parser records SVG local names (`svg`, `foreignObject`).
-// Descendants of foreignObject are HTML until a nested `svg`.
-const elementInSvgContext = (index, nodes, contexts) => {
-    let current = index;
-    const seen = new Set();
-    let inSvg = false;
-    while (current >= 0 &&
-        current < nodes.nodeNames.length &&
-        !seen.has(current)) {
-        const cached = contexts.get(current);
-        if (cached !== undefined) {
-            inSvg = cached;
-            break;
-        }
-        seen.add(current);
-        if (stringAt(nodes.strings, nodes.nodeNames[current]) === "svg") {
-            inSvg = true;
-            break;
-        }
-        const parent = Math.trunc(nodes.parents[current] ?? -1);
-        if (parent < 0 || parent === current)
-            break;
-        if (stringAt(nodes.strings, nodes.nodeNames[parent]) === "foreignObject")
-            break;
-        current = parent;
-    }
-    // Cache the entire examined chain, including forward references and cycles,
-    // so shared ancestors are examined once per document.
-    for (const node of seen)
-        contexts.set(node, inSvg);
-    return inSvg;
-};
 // Walk parent-before-child with one mutable namespace environment. Restore
 // declarations on exit so siblings retain their own scope. Only declarations
 // on the active path are retained, rather than cumulative maps at every node.
@@ -103,10 +91,12 @@ const resolveXmlElements = (nodes) => {
     const children = new Map();
     const pending = [];
     for (let node = 0; node < nodes.nodeNames.length; node += 1) {
-        const parent = Math.trunc(nodes.parents[node] ?? -1);
+        const parent = nodes.parents[node];
+        if (parent === undefined)
+            continue;
         if (parent < 0)
             pending.push({ node });
-        else if (parent < nodes.nodeNames.length && parent !== node) {
+        else {
             const siblings = children.get(parent);
             if (siblings === undefined)
                 children.set(parent, [node]);
@@ -130,15 +120,16 @@ const resolveXmlElements = (nodes) => {
             continue;
         }
         const { node } = step;
-        const attributes = numberArray(nodes.attributes[node]);
-        const restore = applyDeclarations(bindings, attributes, nodes.strings);
-        const svgElement = Math.trunc(nodes.nodeTypes[node] ?? 0) === 1 &&
-            elementNamespace(stringAt(nodes.strings, nodes.nodeNames[node]), bindings) === SVG_NAMESPACE;
+        const source = svgSourceNode(nodes, node);
+        if (source === undefined)
+            continue;
+        const attributes = source.attributes;
+        const restore = applyDeclarations(bindings, attributes);
+        const svgElement = source.nodeType === 1 &&
+            elementNamespace(source.nodeName, bindings) === SVG_NAMESPACE;
         resolved.set(node, {
             svgElement,
-            xlinkHref: svgElement
-                ? xlinkHrefValue(attributes, nodes.strings, bindings)
-                : undefined,
+            xlinkHref: svgElement ? xlinkHrefValue(attributes, bindings) : undefined,
         });
         pending.push({ restore });
         for (const child of children.get(node) ?? [])
@@ -148,16 +139,15 @@ const resolveXmlElements = (nodes) => {
     // so remain unresolved instead of deriving URLs from an invalid ancestry.
     return resolved;
 };
-const applyDeclarations = (bindings, attributes, strings) => {
+const applyDeclarations = (bindings, attributes) => {
     const restore = [];
     const seen = new Set();
-    for (let index = 0; index + 1 < attributes.length; index += 2) {
-        const prefix = xmlnsPrefix(stringAt(strings, attributes[index]));
+    for (const [name, value] of attributes) {
+        const prefix = xmlnsPrefix(name);
         if (prefix === undefined || seen.has(prefix))
             continue;
         seen.add(prefix);
         restore.push({ prefix, previous: bindings.get(prefix) });
-        const value = stringAt(strings, attributes[index + 1]);
         if (value.length === 0)
             bindings.delete(prefix);
         else
@@ -166,6 +156,8 @@ const applyDeclarations = (bindings, attributes, strings) => {
     return restore;
 };
 const xmlnsPrefix = (name) => {
+    if (name === undefined)
+        return undefined;
     if (name === "xmlns")
         return "";
     if (!name.startsWith("xmlns:"))
@@ -176,6 +168,8 @@ const xmlnsPrefix = (name) => {
     return prefix;
 };
 const elementNamespace = (nodeName, bindings) => {
+    if (nodeName === undefined)
+        return "";
     const colon = nodeName.indexOf(":");
     if (colon < 0)
         return bindings.get("") ?? "";
@@ -190,10 +184,9 @@ const elementNamespace = (nodeName, bindings) => {
 };
 // First prefixed href bound to the XLink namespace. Duplicate names keep the
 // earlier value. Plain href is applied by the caller and wins even when empty.
-const xlinkHrefValue = (attributes, strings, bindings) => {
+const xlinkHrefValue = (attributes, bindings) => {
     const seen = new Set();
-    for (let index = 0; index + 1 < attributes.length; index += 2) {
-        const name = stringAt(strings, attributes[index]);
+    for (const [name, value] of attributes) {
         if (seen.has(name))
             continue;
         seen.add(name);
@@ -204,7 +197,18 @@ const xlinkHrefValue = (attributes, strings, bindings) => {
         const local = name.slice(colon + 1);
         if (local !== "href" || bindings.get(prefix) !== XLINK_NAMESPACE)
             continue;
-        return stringAt(strings, attributes[index + 1]);
+        return value;
     }
     return undefined;
 };
+// Namespace interpretation needs these parsed facts even when a node value is unknown.
+const svgSourceNode = (nodes, index) => {
+    const nodeType = nodes.nodeTypes[index];
+    const nodeName = nodes.nodeNames[index];
+    const attributes = nodes.attributes[index];
+    return nodeType === undefined ||
+        nodeName === undefined ||
+        attributes === undefined
+        ? undefined
+        : { nodeType, nodeName, attributes };
+};

package/dist/browser/CdpCaptureEventBodyShapes.js

@@ -4,18 +4,20 @@ import { decodeBase64, isJsonContentType } from "./CdpCaptureEventHelpers.js";
 export const ingestResponseBodyShape = (state, requestId, value) => {
     const result = recordValue(value);
     const body = cdpStringValue(result?.body);
-    if (body === undefined) {
+    const base64Encoded = result?.base64Encoded;
+    if (body === undefined || typeof base64Encoded !== "boolean") {
         invalidResponseBodyShape(state, requestId);
         return;
     }
-    const decoded = result?.base64Encoded === true
-        ? decodeBase64(body)?.toString("utf8")
-        : body;
+    const decoded = base64Encoded ? decodeBase64(body)?.toString("utf8") : body;
     if (decoded === undefined) {
         invalidResponseBodyShape(state, requestId);
         return;
     }
-    updateResponseBodyShape(state, requestId, inferJsonShape(decoded));
+    const shape = inferJsonShape(decoded);
+    if (shape === null)
+        state.completeness.unavailable("json_body_shapes");
+    updateResponseBodyShape(state, requestId, shape);
 };
 export const requestBodyShape = (state, request) => {
     if (!state.input.include_json_body_shapes)
@@ -24,6 +26,8 @@ export const requestBodyShape = (state, request) => {
     if (!isJsonContentType(recordValue(request.headers)) || body === undefined)
         return { status: "unavailable", request: null, response: null };
     const shape = inferJsonShape(body);
+    if (shape === null)
+        state.completeness.unavailable("json_body_shapes");
     return {
         status: shape === null ? "unavailable" : "included",
         request: shape,

package/dist/browser/CdpCaptureEventHandlers.js

@@ -147,10 +147,15 @@ export const handleRequestWillBeSent = (state, params) => {
         previous !== undefined &&
         preserveMalformedRedirectEvidence(state, requestId, previous))
         return;
-    if (request === undefined) {
-        state.completeness.exclude("network_requests", "invalid_protocol_value");
-        state.network.delete(requestId);
-        state.networkRequestTimestamps.delete(requestId);
+    const method = cdpStringValue(request?.method);
+    const initiator = recordValue(params.initiator);
+    const initiatorType = cdpStringValue(initiator?.type);
+    if (request === undefined ||
+        method === undefined ||
+        method.length === 0 ||
+        initiatorType === undefined ||
+        initiatorType.length === 0) {
+        preserveMalformedRedirectEvidence(state, requestId, previous);
         return;
     }
     const sanitized = allowedSanitizedUrl(request.url, state.allowedOrigins);
@@ -190,6 +195,9 @@ export const handleRequestWillBeSent = (state, params) => {
             return;
         }
         else {
+            const encodedDataLength = numberValue(redirectResponse.encodedDataLength);
+            if (encodedDataLength === undefined || encodedDataLength < 0)
+                state.completeness.exclude("network_requests", "invalid_protocol_value");
             redirects.push({
                 url: previous.url,
                 response_url: responseUrl.url,
@@ -197,10 +205,9 @@ export const handleRequestWillBeSent = (state, params) => {
                 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);
-                })(),
+                encoded_data_length: encodedDataLength === undefined || encodedDataLength < 0
+                    ? null
+                    : encodedDataLength,
                 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.
@@ -208,7 +215,6 @@ export const handleRequestWillBeSent = (state, params) => {
             });
         }
     }
-    const initiator = recordValue(params.initiator);
     const initiatorFrame = initiatorLocation(initiator);
     const rawInitiatorUrl = cdpStringValue(initiatorFrame?.url);
     const initiatorUrl = allowedSanitizedUrl(rawInitiatorUrl, state.allowedOrigins);
@@ -218,14 +224,14 @@ export const handleRequestWillBeSent = (state, params) => {
         request_id: requestId,
         url: sanitized.url,
         origin: sanitized.origin ?? "",
-        method: cdpStringValue(request.method) ?? "GET",
+        method,
         resource_type: cdpStringValue(params.type) ?? null,
         status: null,
         mime_type: null,
         encoded_data_length: null,
         redirects,
         initiator: {
-            type: cdpStringValue(initiator?.type) ?? "other",
+            type: initiatorType,
             url: initiatorUrl?.url ?? null,
             line: integerOrNull(initiatorFrame?.lineNumber),
             column: integerOrNull(initiatorFrame?.columnNumber),
@@ -301,9 +307,14 @@ export const handleLoadingFinished = (state, params) => {
     const current = state.network.get(requestId);
     if (current === undefined)
         return;
+    const encodedDataLength = numberValue(params.encodedDataLength);
+    if (encodedDataLength === undefined || encodedDataLength < 0) {
+        state.completeness.exclude("network_requests", "invalid_protocol_value");
+        return;
+    }
     state.network.set(requestId, {
         ...current,
-        encoded_data_length: Math.max(0, numberValue(params.encodedDataLength) ?? 0),
+        encoded_data_length: encodedDataLength,
     });
 };
 export const handleConsoleAPICalled = (state, params) => {

package/dist/browser/CdpCaptureEvents.js

@@ -2,10 +2,12 @@ import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
 import * as bodyShapes from "./CdpCaptureEventBodyShapes.js";
 import * as handlers from "./CdpCaptureEventHandlers.js";
 import { isJsonMediaType } from "./CdpCaptureEventHelpers.js";
-import { recordValue } from "./CdpCaptureValues.js";
+import { cdpStringValue, recordValue } from "./CdpCaptureValues.js";
 /** Event accumulator that validates and normalizes payloads at ingestion. */
 export class CdpCaptureEvents {
     #scriptMetadataBudgetExclusionsRecorded = false;
+    #networkRequestOccurrences = new Map();
+    #responseBodyExaminedOccurrences = new Map();
     scripts = new Map();
     scriptMetadataBudgetOmissionsById = new Map();
     rejectedScriptMetadataBudgetCount = 0;
@@ -52,6 +54,8 @@ export class CdpCaptureEvents {
         this.executionContextFrames.clear();
         this.network.clear();
         this.networkRequestTimestamps.clear();
+        this.#networkRequestOccurrences.clear();
+        this.#responseBodyExaminedOccurrences.clear();
         this.malformedRedirectRequestIds.clear();
         this.webSocketConnectionsById.clear();
         this.console.length = 0;
@@ -106,9 +110,14 @@ export class CdpCaptureEvents {
             case "Debugger.scriptParsed":
                 handlers.handleScriptParsed(this, params);
                 break;
-            case "Network.requestWillBeSent":
+            case "Network.requestWillBeSent": {
+                const requestId = cdpStringValue(params.requestId);
+                const previous = requestId === undefined ? undefined : this.network.get(requestId);
                 handlers.handleRequestWillBeSent(this, params);
+                if (requestId !== undefined && this.network.get(requestId) !== previous)
+                    this.#networkRequestOccurrences.set(requestId, (this.#networkRequestOccurrences.get(requestId) ?? 0) + 1);
                 break;
+            }
             case "Network.responseReceived":
                 handlers.handleResponseReceived(this, params);
                 break;
@@ -138,23 +147,53 @@ export class CdpCaptureEvents {
             ? script.frameId
             : null;
     }
-    responseBodyRequestIds() {
+    responseBodyRequests() {
         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);
+            .flatMap((request) => {
+            const occurrence = this.#networkRequestOccurrences.get(request.request_id);
+            return occurrence === undefined
+                ? []
+                : [{ requestId: request.request_id, occurrence }];
+        });
     }
-    responseBodyUnavailable(requestId) {
-        if (this.malformedRedirectRequestIds.has(requestId))
+    currentResponseBodyRequest(candidate) {
+        if (candidate.occurrence !==
+            this.#networkRequestOccurrences.get(candidate.requestId))
+            return undefined;
+        return this.network.get(candidate.requestId);
+    }
+    responseBodyUnavailable(candidate) {
+        if (this.currentResponseBodyRequest(candidate) === undefined)
+            return;
+        this.#responseBodyExaminedOccurrences.set(candidate.requestId, candidate.occurrence);
+        if (this.malformedRedirectRequestIds.has(candidate.requestId))
             return;
-        bodyShapes.updateResponseBodyShape(this, requestId, null);
+        bodyShapes.updateResponseBodyShape(this, candidate.requestId, null);
         this.completeness.unavailable("json_body_shapes");
     }
-    ingestResponseBody(requestId, value) {
-        if (this.malformedRedirectRequestIds.has(requestId))
+    /**
+     * Mark eligible response bodies that arrived after the fetch pass was
+     * enumerated.
+     */
+    settleUnexaminedResponseBodies() {
+        for (const candidate of this.responseBodyRequests()) {
+            const request = this.currentResponseBodyRequest(candidate);
+            if (request?.body_shapes.response === null &&
+                this.#responseBodyExaminedOccurrences.get(candidate.requestId) !==
+                    candidate.occurrence)
+                this.responseBodyUnavailable(candidate);
+        }
+    }
+    ingestResponseBody(candidate, value) {
+        if (this.currentResponseBodyRequest(candidate) === undefined)
+            return;
+        this.#responseBodyExaminedOccurrences.set(candidate.requestId, candidate.occurrence);
+        if (this.malformedRedirectRequestIds.has(candidate.requestId))
             return;
-        bodyShapes.ingestResponseBodyShape(this, requestId, value);
+        bodyShapes.ingestResponseBodyShape(this, candidate.requestId, value);
     }
 }

package/dist/browser/CdpCaptureStorage.js

@@ -20,8 +20,8 @@ export const captureStorage = async (context, pageUrl, limitations) => {
     const cacheRaw = context.input.include_storage_keys
         ? await optionalCdpCommand(context, "CacheStorage.requestCacheNames", { securityOrigin: origin }, limitations)
         : undefined;
-    const cacheValues = recordsValue(recordValue(cacheRaw)?.caches);
-    const caches = capturedCaches(cacheValues);
+    const cacheField = recordValue(cacheRaw)?.caches;
+    const caches = capturedCaches(recordsValue(cacheField));
     const fingerprints = context.input.include_storage_fingerprints
         ? await captureStorageFingerprints({
             context,
@@ -37,9 +37,22 @@ export const captureStorage = async (context, pageUrl, limitations) => {
     const structuredStorageComplete = indexedRaw !== undefined &&
         Array.isArray(indexedValues) &&
         indexed.length === indexedValues.length &&
-        cacheRaw !== undefined &&
-        caches.length === cacheValues.length;
+        // Like IndexedDB names, a missing, non-array or partly unusable cache
+        // list is an incomplete enumeration rather than an empty one.
+        Array.isArray(cacheField) &&
+        caches.length === cacheField.length;
+    const keysExclusion = !context.input.include_storage_keys
+        ? undefined
+        : local.exclusion === "provider_unavailable" ||
+            session.exclusion === "provider_unavailable" ||
+            indexedRaw === undefined ||
+            cacheRaw === undefined
+            ? "provider_unavailable"
+            : !local.complete || !session.complete || !structuredStorageComplete
+                ? "invalid_protocol_value"
+                : undefined;
     return {
+        keysExclusion,
         value: {
             origin,
             usage_bytes: numberValue(quota?.usage) ?? null,
@@ -68,7 +81,11 @@ const storageItems = async (context, origin, isLocalStorage, limitations) => {
     const raw = await optionalCdpCommand(context, "DOMStorage.getDOMStorageItems", { storageId: { securityOrigin: origin, isLocalStorage } }, limitations);
     const entries = recordValue(raw)?.entries;
     if (raw === undefined || !Array.isArray(entries))
-        return { items: [], complete: false };
+        return {
+            items: [],
+            complete: false,
+            exclusion: raw === undefined ? "provider_unavailable" : "invalid_protocol_value",
+        };
     const items = entries.flatMap((entry) => {
         if (!Array.isArray(entry))
             return [];

package/dist/browser/CdpCaptureStorageFingerprints.js

@@ -92,7 +92,8 @@ const addIndexedDb = async (run, origin, names) => {
             scope: "indexed_db_schema",
             identity: databaseName,
             value: stores.map(indexedDbStoreSchema),
-            complete: indexedDbSchemaComplete(stores),
+            complete: stores.length === database.objectStores.length &&
+                indexedDbSchemaComplete(stores),
         });
         for (const store of stores) {
             const objectStoreName = cdpStringValue(store.name);
@@ -120,14 +121,30 @@ const indexedDbStoreSchema = (store) => ({
     })),
 });
 const indexedDbSchemaComplete = (stores) => stores.every((store) => cdpStringValue(store.name) !== undefined &&
-    stableValueComplete(store.keyPath) &&
+    indexedDbKeyPathComplete(store.keyPath) &&
     typeof store.autoIncrement === "boolean" &&
     Array.isArray(store.indexes) &&
     recordsValue(store.indexes).length === store.indexes.length &&
     recordsValue(store.indexes).every((index) => cdpStringValue(index.name) !== undefined &&
-        stableValueComplete(index.keyPath) &&
+        indexedDbKeyPathComplete(index.keyPath) &&
         typeof index.unique === "boolean" &&
         typeof index.multiEntry === "boolean"));
+const indexedDbKeyPathComplete = (value) => {
+    const keyPath = recordValue(value);
+    if (keyPath === undefined)
+        return false;
+    switch (keyPath.type) {
+        case "null":
+            return true;
+        case "string":
+            return typeof keyPath.string === "string";
+        case "array":
+            return (Array.isArray(keyPath.array) &&
+                keyPath.array.every((key) => typeof key === "string"));
+        default:
+            return false;
+    }
+};
 const addIndexedDbRecords = async (run, input) => {
     let skipCount = 0;
     while (true) {
@@ -154,7 +171,9 @@ const addIndexedDbRecords = async (run, input) => {
         for (const entry of entries) {
             const key = stableValue(entry.key);
             const primaryKey = stableValue(entry.primaryKey);
-            const value = stableValue(entry.value);
+            // A missing remote object is an omission, not the JavaScript value
+            // "undefined". Keep the unavailable digest null and coverage partial.
+            const value = entry.value === undefined ? undefined : stableValue(entry.value);
             addFingerprint(run.state, {
                 scope: "indexed_db_record",
                 identity: {
@@ -304,13 +323,37 @@ const stableValueComplete = (value) => {
 };
 const remoteObjectComplete = (value) => {
     const record = recordValue(value);
-    if (record === undefined)
-        return true;
-    return (record.objectId === undefined &&
-        record.preview === undefined &&
-        record.customPreview === undefined &&
-        (record.type !== "object" || record.value !== undefined) &&
-        stableValueComplete(record));
+    if (record === undefined ||
+        record.objectId !== undefined ||
+        record.preview !== undefined ||
+        record.customPreview !== undefined ||
+        !stableValueComplete(record))
+        return false;
+    switch (record.type) {
+        case "undefined":
+            return (record.value === undefined && record.unserializableValue === undefined);
+        case "string":
+        case "boolean":
+            return (typeof record.value === record.type &&
+                record.unserializableValue === undefined);
+        case "number":
+            return record.unserializableValue === undefined
+                ? typeof record.value === "number" && Number.isFinite(record.value)
+                : record.value === undefined &&
+                    typeof record.unserializableValue === "string" &&
+                    ["-0", "NaN", "Infinity", "-Infinity"].includes(record.unserializableValue);
+        case "bigint":
+            return (record.value === undefined &&
+                typeof record.unserializableValue === "string" &&
+                /^-?\d+n$/u.test(record.unserializableValue));
+        case "object":
+            return (record.unserializableValue === undefined &&
+                (record.subtype === "null"
+                    ? record.value === null
+                    : record.value !== null && typeof record.value === "object"));
+        default:
+            return false;
+    }
 };
 const decodeBase64 = (value) => {
     if (value.length % 4 !== 0 ||

package/dist/browser/CdpCaptureValues.js

@@ -1,10 +1,12 @@
 import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
-import {} from "../domain/browserObservationErrors.js";
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
 import { createWebTextArtifact } from "../domain/webContentArtifact.js";
+import { err, ok } from "../domain/result.js";
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 export const recordValue = (value) => isRecord(value) ? value : undefined;
+/** Preserve an omitted producer inventory as unknown rather than empty. */
+export const admitRecords = (value) => Array.isArray(value) ? value : undefined;
 export const recordsValue = (value) => Array.isArray(value)
     ? value.flatMap((item) => {
         const record = recordValue(item);
@@ -13,6 +15,15 @@ export const recordsValue = (value) => Array.isArray(value)
     : [];
 export const cdpStringValue = (value) => typeof value === "string" ? value : undefined;
 export const numberValue = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+/** An omitted resource size is unknown; a supplied invalid size is malformed. */
+export const resourceContentSize = (value) => {
+    if (value === undefined)
+        return ok(null);
+    const size = numberValue(value);
+    return size !== undefined && size >= 0
+        ? ok(size)
+        : err({ _tag: "InvalidCdpResourceSize" });
+};
 /** Preserve partial script declarations; omitted or invalid fields remain unknown. */
 export const scriptMetadataValues = (value) => {
     const length = numberValue(value?.length);