rea-agents 6.5.0 → 6.7.0

package/dist/browser/BrowserScenarioPartialObservation.js

@@ -1,8 +1,7 @@
 import { PLAYWRIGHT_RESPONSE_BODY_PROVENANCE_LIMITATION } from "../domain/browserNetworkEvidence.js";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
-import { AnalysisCancelledError, AnalysisTimeoutError, } from "../domain/analysisErrorCore.js";
-import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
-import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY } from "./providerIdentities.js";
 const OPERATION = "capture_browser_scenario";
@@ -33,6 +32,8 @@ const browserScenarioLimitations = (session, scenario, events) => {
         ...(session.mode === "connect"
             ? [
                 "CDP attachment cannot recover pre-attach events or guarantee launch-time context options.",
+                `Attached locale ${scenario.environment.locale} applies to Intl formatting only; navigator.language(s) and Accept-Language remain caller-controlled. Use launch mode for matching page and request languages.`,
+                "Detaching a CDP page session may clear caller-owned navigator.platform emulation. REA cannot snapshot the caller's complete user-agent/client-hint state before attachment; use launch mode to avoid mutating that external browser.",
             ]
             : []),
     ];
@@ -56,6 +57,7 @@ export const browserScenarioCaptureData = (input) => {
                 .sort(),
             network_content: input.scenario.capture.network,
             event_families: [...new Set(input.scenario.capture.events)].sort(),
+            limits: input.scenario.capture.limits,
         },
         duration_ms: Math.max(0, Math.round(performance.now() - input.startedAt)),
         steps: [...input.steps],
@@ -80,49 +82,13 @@ export const browserScenarioOperationFailure = (cause, partialObservation, clean
     const primary = cause instanceof AnalysisError
         ? cause
         : new ProviderAdapterError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, OPERATION, { cause });
-    const primaryProjection = projectAnalysisError(primary);
-    const cleanupCause = cleanupFailure === undefined
-        ? undefined
-        : cleanupFailure.cause instanceof AnalysisError
-            ? cleanupFailure.cause
-            : new ProviderAdapterError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, "close_browser_scenario", { cause: cleanupFailure.cause });
-    const cleanupObservation = cleanupFailure === undefined
-        ? undefined
-        : browserScenarioCleanupObservation(cleanupFailure.cause);
-    const retainedOptions = {
-        cause: primary,
-        partialObservation,
-        ...(primary.capturedOutput === undefined
-            ? {}
-            : { capturedOutput: primary.capturedOutput }),
-        ...(primary.cleanup === undefined ? {} : { cleanup: primary.cleanup }),
-    };
-    if (cleanupCause === undefined) {
-        if (primary instanceof AnalysisCancelledError)
-            return new AnalysisCancelledError(primary.operation, retainedOptions);
-        if (primary instanceof AnalysisTimeoutError)
-            return new AnalysisTimeoutError(primary.operation, primary.timeoutMs, retainedOptions);
-        if (primary instanceof BrowserObservationError)
-            return new BrowserObservationError(primary.operation, primary.reason, {
-                ...retainedOptions,
-                ...(primary.userMessage === undefined
-                    ? {}
-                    : { detail: primary.userMessage }),
-            });
-    }
-    const cleanup = cleanupObservation ?? primary.cleanup;
-    return new ProviderAdapterError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, OPERATION, {
-        ...retainedOptions,
-        cause: cleanupCause === undefined
-            ? primary
-            : new AggregateError([primary, cleanupCause], "Browser scenario operation and cleanup both failed", { cause: primary }),
-        userMessage: primaryProjection.message,
-        ...(cleanup === undefined ? {} : { cleanup }),
-        diagnostics: {
-            primary_error: primaryProjection,
-            ...(cleanupCause === undefined
-                ? {}
-                : { cleanup_error: projectAnalysisError(cleanupCause) }),
-        },
-    });
+    primary.retainPartialObservation(partialObservation);
+    if (cleanupFailure === undefined)
+        return primary;
+    const observation = browserScenarioCleanupObservation(cleanupFailure.cause);
+    const cleanup = cleanupFailure.cause instanceof AnalysisError &&
+        cleanupFailure.cause.cleanupIncomplete
+        ? cleanupFailure.cause
+        : new ProviderCleanupError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, observation.resources, { reason: observation.reason }, { operation: "close_browser_scenario", cause: cleanupFailure.cause });
+    return analysisErrorWithCleanupFailure(primary, cleanup, OPERATION).bindCleanupDependencies([primary, cleanup]);
 };

package/dist/browser/CdpBrowserProvider.js

@@ -6,10 +6,12 @@ import { webObservationSessionSchema, } from "../domain/browserSession.js";
 import { webMcpDiscoverySchema, } from "../domain/webMcpDiscovery.js";
 import { browserCaptureComparisonSchema, compareBrowserCaptures, } from "../domain/browserCaptureComparison.js";
 import { webScreenshotDiffSchema, webScreenshotSchema, } from "../domain/webScreenshot.js";
-import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { AnalysisError, } from "../domain/analysisErrorBase.js";
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
 import { AnalysisCancelledError, AnalysisInputError, } from "../domain/analysisErrorCore.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
 import { err, ok } from "../domain/result.js";
 import { hasCdpTargetWebSocket, } from "./CdpEndpoint.js";
 import { attachCdpTargetSession, closeCdpTargetSession, openCdpEndpoint, openCdpTargetSession, } from "./CdpTargetSession.js";
@@ -22,16 +24,28 @@ import { captureCdpScreenshot } from "./CdpScreenshot.js";
 import { comparePngScreenshots } from "./PngVisualDiff.js";
 import { CDP_BROWSER_PROVIDER_IDENTITY } from "./providerIdentities.js";
 import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
-const CLEANUP_DOMAINS = ["Network", "Debugger", "Runtime", "Page"];
+import { CdpTargetSessionOwner, bindCdpTransportCleanup, } from "./CdpTargetSessionOwner.js";
+const CLEANUP_DOMAINS = [
+    "Network",
+    "Debugger",
+    "Runtime",
+    "Page",
+    "WebMCP",
+];
 /** Passive browser observation through a selected user-owned CDP endpoint. */
 export class CdpBrowserProvider {
+    #owner = new CdpTargetSessionOwner();
+    close() {
+        return this.#owner.close();
+    }
     identity() {
         return CDP_BROWSER_PROVIDER_IDENTITY;
     }
     async listTargets(input, options = {}) {
         try {
-            const endpoint = await openCdpEndpoint(input.cdp_endpoint, "list_browser_targets", options.signal);
-            await endpoint.connection?.close();
+            const endpoint = await openCdpEndpoint(input.cdp_endpoint, "list_browser_targets", options.signal, undefined, this.#owner);
+            if (endpoint.connection !== undefined)
+                await this.#owner.finish(endpoint.connection);
             const { discovery } = endpoint;
             const selected = selectTargets(discovery, input.allowed_origins.length === 0
                 ? undefined
@@ -71,8 +85,9 @@ export class CdpBrowserProvider {
         }
     }
     async analyzeBundle(input, options = {}) {
+        let captured;
         try {
-            const captured = await this.#capture(input, options, "analyze_web_bundle");
+            captured = await this.#capture(input, options, "analyze_web_bundle");
             const sourceMaps = input.fetch_source_maps
                 ? await fetchWebSourceMaps(captured.sourceMapRequests, {
                     ...input,
@@ -87,14 +102,19 @@ export class CdpBrowserProvider {
             // fetchWebSourceMaps rethrows the exact abort reason. Preserve cancellation
             // even when a caller supplied an AnalysisError as that reason.
             if (options.signal?.aborted === true && cause === options.signal.reason) {
-                return err(new AnalysisCancelledError("analyze_web_bundle", { cause }));
+                return err(new AnalysisCancelledError("analyze_web_bundle", {
+                    cause,
+                    ...(captured === undefined
+                        ? {}
+                        : { partialObservation: captured.inspection }),
+                }));
             }
             return err(providerError(cause, "analyze_web_bundle", options.signal));
         }
     }
     async observeSession(input, options = {}) {
         try {
-            return ok(webObservationSessionSchema.parse(await withTargetSession(input, "observe_web_session", options, observeCdpSession)));
+            return ok(webObservationSessionSchema.parse(await withTargetSession(input, "observe_web_session", options, observeCdpSession, this.#owner)));
         }
         catch (cause) {
             return err(providerError(cause, "observe_web_session", options.signal));
@@ -102,7 +122,7 @@ export class CdpBrowserProvider {
     }
     async discoverWebMcpTools(input, options = {}) {
         try {
-            return ok(webMcpDiscoverySchema.parse(await withTargetSession(input, "discover_webmcp_tools", options, discoverWebMcp)));
+            return ok(webMcpDiscoverySchema.parse(await withTargetSession(input, "discover_webmcp_tools", options, discoverWebMcp, this.#owner)));
         }
         catch (cause) {
             return err(providerError(cause, "discover_webmcp_tools", options.signal));
@@ -118,7 +138,7 @@ export class CdpBrowserProvider {
     }
     async captureScreenshot(input, options = {}) {
         try {
-            return ok(webScreenshotSchema.parse(await withTargetSession(input, "capture_web_screenshot", options, captureCdpScreenshot)));
+            return ok(webScreenshotSchema.parse(await withTargetSession(input, "capture_web_screenshot", options, captureCdpScreenshot, this.#owner)));
         }
         catch (cause) {
             return err(providerError(cause, "capture_web_screenshot", options.signal));
@@ -137,44 +157,75 @@ export class CdpBrowserProvider {
         }
     }
     async #capture(input, options, operation) {
-        return await withTargetSession(input, operation, options, async (session) => await capturePage({ ...session, operation }));
+        return await withTargetSession(input, operation, options, async (session) => await capturePage({ ...session, operation }), this.#owner, (captured) => captured.inspection);
     }
 }
 /** Authorize one discovered target, run work in its session, and close REA's socket. */
-const withTargetSession = async (input, operation, options, work) => {
-    const endpoint = await openCdpEndpoint(input.cdp_endpoint, operation, options.signal);
+const withTargetSession = async (input, operation, options, work, owner, partialObservation) => {
+    const endpoint = await openCdpEndpoint(input.cdp_endpoint, operation, options.signal, undefined, owner);
     let targetSession;
-    let output;
+    let outcome;
+    let cleanupFailure;
     try {
         const target = authorizeTarget(endpoint.discovery, input);
         const scopedInput = scopeToTargetOrigin(input, target);
         targetSession =
             endpoint.connection === undefined
-                ? await openCdpTargetSession(endpoint.discovery, target, operation, options.signal)
-                : await attachCdpTargetSession(endpoint.connection, target, operation, options.signal);
-        output = await work({
+                ? await openCdpTargetSession(endpoint.discovery, target, operation, options.signal, undefined, owner)
+                : await attachCdpTargetSession(endpoint.connection, target, operation, options.signal, owner);
+        outcome = ok(await work({
             connection: targetSession.connection,
             sessionId: targetSession.sessionId,
             discovery: endpoint.discovery,
             target,
             input: scopedInput,
             ...(options.signal === undefined ? {} : { signal: options.signal }),
-            ...(options.progress === undefined ? {} : { progress: options.progress }),
-        });
+            ...(options.progress === undefined
+                ? {}
+                : { progress: options.progress }),
+        }));
+    }
+    catch (cause) {
+        outcome = err(cause);
     }
-    finally {
+    try {
         if (targetSession !== undefined)
-            await closeCdpTargetSession(targetSession, CLEANUP_DOMAINS, options.signal);
-        // An unadopted browser socket is closed here; closing is idempotent.
-        await endpoint.connection?.close();
-    }
-    // Cancellation during teardown must not publish the completed observation.
-    // Errors from work or cleanup still propagate through the try/finally above.
-    if (options.signal?.aborted === true)
-        throw new AnalysisCancelledError(operation, {
-            cause: options.signal.reason,
-        });
-    return output;
+            await closeCdpTargetSession(targetSession, CLEANUP_DOMAINS, options.signal, owner);
+        if (endpoint.connection !== undefined &&
+            endpoint.connection !== targetSession?.connection)
+            await owner.finish(endpoint.connection);
+    }
+    catch (cause) {
+        cleanupFailure =
+            cause instanceof AnalysisError
+                ? cause
+                : new ProviderCleanupError("rea-cdp-browser", [input.target_id], { reason: cause instanceof Error ? cause.message : String(cause) }, { operation, cause });
+    }
+    if (outcome.ok && options.signal?.aborted === true)
+        outcome = err(partialObservation === undefined
+            ? new AnalysisCancelledError(operation, {
+                cause: options.signal.reason,
+            })
+            : new AnalysisCancelledError(operation, {
+                cause: options.signal.reason,
+                partialObservation: partialObservation(outcome.value),
+            }));
+    if (cleanupFailure !== undefined) {
+        if (!outcome.ok && outcome.error instanceof AnalysisError)
+            throw bindCdpTransportCleanup(cleanupFailure, analysisErrorWithCleanupFailure(outcome.error, cleanupFailure, operation));
+        if (!outcome.ok)
+            throw new AggregateError([outcome.error, cleanupFailure], `CDP operation ${operation} failed and cleanup remains incomplete.`, { cause: outcome.error });
+        throw bindCdpTransportCleanup(cleanupFailure, new ProviderCleanupError("rea-cdp-browser", cleanupFailure.cleanupResources, { cleanup_error: cleanupFailure.message }, {
+            operation,
+            cause: cleanupFailure,
+            ...(partialObservation === undefined
+                ? {}
+                : { partialObservation: partialObservation(outcome.value) }),
+        }));
+    }
+    if (!outcome.ok)
+        throw outcome.error;
+    return outcome.value;
 };
 const selectTargets = (discovery, allowedOrigins) => {
     const allowed = [];

package/dist/browser/CdpCaptureDocuments.js

@@ -1,5 +1,6 @@
-import { allowedSanitizedUrl, numberValue, recordValue, recordsValue, requiredRecord, cdpStringValue, } from "./CdpCaptureValues.js";
-import { cdpSnapshotAttributesResolve, cdpSnapshotString, cdpSnapshotValueString, } from "./CdpSnapshotStrings.js";
+import { allowedSanitizedUrl, admitRecords, numberValue, resourceContentSize, recordValue, recordsValue, requiredRecord, cdpStringValue, } from "./CdpCaptureValues.js";
+import { cdpSnapshotString, cdpSnapshotValueString, } from "./CdpSnapshotStrings.js";
+import { snapshotDocumentNodes, snapshotNodeAt, } from "./CdpSnapshotNodes.js";
 import { exclusionReasonForUrl } from "./CdpCaptureEventHelpers.js";
 import { createDocumentSvgAncestry, domSvgLink, } from "./CdpCaptureDomSvg.js";
 import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
@@ -49,45 +50,51 @@ export const captureResources = (result, allowedOrigins, completeness) => {
         return { items: [] };
     }
     const items = [];
-    for (const tree of walkFrameTrees(root, (omittedCount) => completeness?.exclude("resources", "invalid_protocol_value", omittedCount))) {
+    for (const resource of frameTreeResources(root, (count) => completeness?.exclude("resources", "invalid_protocol_value", count))) {
+        const url = allowedSanitizedUrl(resource.url, allowedOrigins);
+        if (url === undefined || url.origin === null) {
+            completeness?.exclude("resources", exclusionReasonForUrl(cdpStringValue(resource.url)));
+            continue;
+        }
+        const type = cdpStringValue(resource.type);
+        const mimeType = cdpStringValue(resource.mimeType);
+        if (type === undefined || type.length === 0 || mimeType === undefined) {
+            completeness?.exclude("resources", "invalid_protocol_value");
+            continue;
+        }
+        const contentSize = resourceContentSize(resource.contentSize);
+        if (!contentSize.ok)
+            completeness?.exclude("resources", "invalid_protocol_value");
+        items.push({
+            rawUrl: cdpStringValue(resource.url) ?? "",
+            url: url.url,
+            origin: url.origin,
+            type,
+            mime_type: mimeType,
+            content_size: contentSize.ok ? contentSize.value : null,
+        });
+    }
+    return { items };
+};
+/**
+ * Yield resource records from every frame of a resource tree. A missing or
+ * non-array `resources` list, or a non-record entry, is reported as invalid
+ * rather than read as an empty frame.
+ */
+export const frameTreeResources = function* (root, onInvalid) {
+    for (const tree of walkFrameTrees(root, onInvalid)) {
         if (!Array.isArray(tree.resources)) {
-            completeness?.exclude("resources", "invalid_protocol_value", null);
+            onInvalid(null);
             continue;
         }
         for (const entry of tree.resources) {
             const resource = recordValue(entry);
-            if (resource === undefined) {
-                completeness?.exclude("resources", "invalid_protocol_value");
-                continue;
-            }
-            const url = allowedSanitizedUrl(resource.url, allowedOrigins);
-            if (url === undefined || url.origin === null) {
-                completeness?.exclude("resources", exclusionReasonForUrl(cdpStringValue(resource.url)));
-                continue;
-            }
-            const type = cdpStringValue(resource.type);
-            const mimeType = cdpStringValue(resource.mimeType);
-            if (type === undefined || type.length === 0 || mimeType === undefined) {
-                completeness?.exclude("resources", "invalid_protocol_value");
-                continue;
-            }
-            const rawContentSize = numberValue(resource.contentSize);
-            const contentSize = rawContentSize !== undefined && rawContentSize >= 0
-                ? rawContentSize
-                : null;
-            if (resource.contentSize !== undefined && contentSize === null)
-                completeness?.exclude("resources", "invalid_protocol_value");
-            items.push({
-                rawUrl: cdpStringValue(resource.url) ?? "",
-                url: url.url,
-                origin: url.origin,
-                type,
-                mime_type: mimeType,
-                content_size: contentSize,
-            });
+            if (resource === undefined)
+                onInvalid(1);
+            else
+                yield resource;
         }
     }
-    return { items };
 };
 export const walkFrameTrees = function* (root, onMalformedChild) {
     const pending = [root];
@@ -131,7 +138,7 @@ export function* captureDom(result, allowedOrigins, input, completeness) {
     let unresolvedSvgNodes = 0;
     if (!Array.isArray(root.strings))
         excludeDocumentEvidence(completeness, "invalid_protocol_value", null);
-    for (const document of snapshotDocuments(root.documents, completeness)) {
+    for (const document of snapshotDocuments(root.documents, (count) => excludeDocumentEvidence(completeness, "invalid_protocol_value", count))) {
         const documentUrl = cdpSnapshotString(strings, document.documentURL);
         if (documentUrl === undefined) {
             excludeDocumentEvidence(completeness, "invalid_protocol_value");
@@ -149,67 +156,27 @@ export function* captureDom(result, allowedOrigins, input, completeness) {
             continue;
         }
         const baseUrl = baseUrlValue || documentUrl;
-        const documentNodes = recordValue(document.nodes);
+        const documentNodes = snapshotDocumentNodes(document.nodes, strings);
         if (documentNodes === undefined) {
             excludeDocumentEvidence(completeness, "invalid_protocol_value");
             continue;
         }
-        const rawNodeTypes = numberArray(documentNodes.nodeType);
-        const rawNodeNames = numberArray(documentNodes.nodeName);
-        const rawNodeValues = numberArray(documentNodes.nodeValue);
-        const rawParents = numberArray(documentNodes.parentIndex);
-        const rawAttributes = Array.isArray(documentNodes.attributes)
-            ? documentNodes.attributes
-            : undefined;
-        if (rawNodeTypes === undefined ||
-            rawNodeNames === undefined ||
-            rawNodeValues === undefined ||
-            rawParents === undefined ||
-            rawAttributes === undefined ||
-            rawNodeNames.length !== rawNodeTypes.length ||
-            rawNodeValues.length !== rawNodeTypes.length ||
-            rawParents.length !== rawNodeTypes.length) {
-            excludeDocumentEvidence(completeness, "invalid_protocol_value");
-            continue;
-        }
-        if (rawAttributes.length > rawNodeTypes.length)
-            excludeDocumentEvidence(completeness, "invalid_protocol_value", rawAttributes.length - rawNodeTypes.length);
-        const backendNodeIds = Array.isArray(documentNodes.backendNodeId)
-            ? documentNodes.backendNodeId
-            : [];
+        const { nodeTypes, backendNodeIds } = documentNodes;
+        if (documentNodes.excessAttributes > 0)
+            excludeDocumentEvidence(completeness, "invalid_protocol_value", documentNodes.excessAttributes);
         const baseIndex = total;
-        total += rawNodeTypes.length;
-        const ancestry = createDocumentSvgAncestry({
-            nodeTypes: rawNodeTypes,
-            nodeNames: rawNodeNames,
-            parents: rawParents,
-            strings,
-            attributes: rawAttributes,
-        });
+        total += nodeTypes.length;
+        const ancestry = createDocumentSvgAncestry(documentNodes);
         const pendingMetadata = [];
-        for (let index = 0; index < rawNodeTypes.length; index += 1) {
-            const nodeType = rawNodeTypes[index];
-            const nodeNameIndex = rawNodeNames[index];
-            const nodeValueIndex = rawNodeValues[index];
-            const parent = rawParents[index];
-            const attributeIndexes = numberArray(rawAttributes[index]);
-            const nodeName = cdpSnapshotString(strings, nodeNameIndex);
-            const nodeValue = cdpSnapshotValueString(strings, nodeValueIndex);
-            if (nodeType === undefined ||
-                nodeName === undefined ||
-                nodeValue === undefined ||
-                parent === undefined ||
-                parent < -1 ||
-                parent === index ||
-                parent >= rawNodeTypes.length ||
-                attributeIndexes === undefined ||
-                !cdpSnapshotAttributesResolve(strings, attributeIndexes)) {
+        for (let index = 0; index < nodeTypes.length; index += 1) {
+            const admitted = snapshotNodeAt(documentNodes, index);
+            if (!admitted.ok) {
                 excludeDocumentEvidence(completeness, "invalid_protocol_value");
                 continue;
             }
-            const attributes = attributeIndexes;
+            const { nodeType, nodeName, nodeValue, parent, attributes } = admitted.value;
             const nodeIndex = baseIndex + index;
-            const attributeNames = uniqueAttributeNames(attributes, strings);
+            const attributeNames = [...new Set(attributes.map(([name]) => name))];
             const svgLink = domSvgLink(ancestry, index);
             if (svgLink.xmlDocument === undefined)
                 completeness?.exclude("metadata", "invalid_protocol_value");
@@ -218,13 +185,9 @@ export function* captureDom(result, allowedOrigins, input, completeness) {
                 nodeType === 1 &&
                 attributeNames.includes("xlink:href") &&
                 !attributeNames.includes("href")) {
-                const backendNodeId = numberValue(backendNodeIds[index]);
+                const backendNodeId = backendNodeIds[index];
                 svgQuery =
-                    backendNodeId !== undefined &&
-                        Number.isSafeInteger(backendNodeId) &&
-                        backendNodeId > 0
-                        ? { backendNodeId, nodeName }
-                        : null;
+                    backendNodeId !== undefined ? { backendNodeId, nodeName } : null;
             }
             nodes.push({
                 index: nodeIndex,
@@ -237,7 +200,6 @@ export function* captureDom(result, allowedOrigins, input, completeness) {
             pendingMetadata.push({
                 svgQuery,
                 options: {
-                    strings,
                     attributes,
                     // The BASE element itself resolves against the document fallback URL.
                     baseUrl: nodeName.toLowerCase() === "base" ? documentUrl : baseUrl,
@@ -249,7 +211,7 @@ export function* captureDom(result, allowedOrigins, input, completeness) {
                 },
             });
             if (pendingMetadata.length === DOM_METADATA_BATCH_SIZE ||
-                index === rawNodeTypes.length - 1) {
+                index === nodeTypes.length - 1) {
                 const metadata = yield* captureDomMetadata(pendingMetadata, completeness);
                 urls.push(...metadata.urls);
                 agentHints.push(...metadata.agentHints);
@@ -281,15 +243,19 @@ const excludeDocumentEvidence = (completeness, reason, count = 1) => {
     completeness?.exclude("dom", reason, count);
     completeness?.exclude("metadata", reason, count);
 };
-const snapshotDocuments = (value, completeness) => {
+/**
+ * Read DOMSnapshot documents. A snapshot always describes at least one
+ * document, so a missing or empty list is invalid rather than an empty DOM.
+ */
+export const snapshotDocuments = (value, onInvalid) => {
     if (!Array.isArray(value) || value.length === 0) {
-        excludeDocumentEvidence(completeness, "invalid_protocol_value", null);
+        onInvalid(null);
         return [];
     }
     return value.flatMap((item) => {
         const document = recordValue(item);
         if (document === undefined)
-            excludeDocumentEvidence(completeness, "invalid_protocol_value");
+            onInvalid(1);
         return document === undefined ? [] : [document];
     });
 };
@@ -326,7 +292,38 @@ function* captureDomMetadata(pending, completeness) {
     return { urls, agentHints, unresolvedSvgNodes, excludedUrls };
 }
 export const captureAccessibility = (results, options) => {
-    const all = results.flatMap((result) => recordsValue(requiredRecord(result).nodes));
+    const all = results.flatMap((result) => {
+        const inventory = admitRecords(requiredRecord(result).nodes);
+        if (inventory === undefined) {
+            options.completeness?.exclude("accessibility", "invalid_protocol_value", null);
+            return [];
+        }
+        const nodes = [];
+        let malformedCount = 0;
+        for (const entry of inventory) {
+            const node = recordValue(entry);
+            if (node === undefined ||
+                cdpStringValue(node.nodeId) === undefined ||
+                cdpStringValue(node.nodeId)?.length === 0 ||
+                typeof node.ignored !== "boolean") {
+                malformedCount += 1;
+                continue;
+            }
+            const parentId = cdpStringValue(node.parentId);
+            if (node.parentId !== undefined &&
+                (parentId === undefined || parentId.length === 0))
+                malformedCount += 1;
+            if (node.childIds !== undefined &&
+                (!Array.isArray(node.childIds) ||
+                    node.childIds.some((childId) => cdpStringValue(childId) === undefined ||
+                        cdpStringValue(childId)?.length === 0)))
+                malformedCount += 1;
+            nodes.push(node);
+        }
+        if (malformedCount > 0)
+            options.completeness?.exclude("accessibility", "invalid_protocol_value", malformedCount);
+        return nodes;
+    });
     const nodeIds = new Set(all.flatMap((node) => {
         const nodeId = cdpStringValue(node.nodeId);
         return nodeId === undefined ? [] : [nodeId];
@@ -356,7 +353,7 @@ export const captureAccessibility = (results, options) => {
     return {
         total: all.length,
         nodes,
-        treeIncomplete: all.some((node) => Array.isArray(node.childIds) &&
+        hasUnobservedChildren: all.some((node) => Array.isArray(node.childIds) &&
             node.childIds.some((childId) => {
                 const id = cdpStringValue(childId);
                 return id !== undefined && !nodeIds.has(id);
@@ -422,30 +419,6 @@ const accessibilityStates = (value) => {
         .map(([name, state]) => ({ name, value: state }));
 };
 const axText = (value) => cdpStringValue(recordValue(value)?.value) ?? null;
-const uniqueAttributeNames = (attributeIndexes, strings) => {
-    const names = [];
-    const seen = new Set();
-    for (let index = 0; index < attributeIndexes.length; index += 2) {
-        const name = cdpSnapshotString(strings, attributeIndexes[index]);
-        if (name === undefined)
-            continue;
-        if (seen.has(name))
-            continue;
-        seen.add(name);
-        names.push(name);
-    }
-    return names;
-};
-const numberArray = (value) => {
-    if (!Array.isArray(value))
-        return undefined;
-    return value.map((item) => {
-        const number = numberValue(item);
-        return number !== undefined && Number.isSafeInteger(number)
-            ? number
-            : undefined;
-    });
-};
 // Chrome reads an SVG XLink href only when href itself is absent, and an
 // empty href still wins. HTML keeps the literal attribute name `xlink:href`.
 // XML uses any prefix bound to the XLink namespace. Both are stored as href.
@@ -458,15 +431,10 @@ const hrefAttributeValue = (pairs, attribute, options) => {
     return options.xmlDocument ? options.xlinkHref : pairs.get("xlink:href");
 };
 const domMetadata = (options) => {
-    const { strings, attributes, baseUrl, documentUrl, nodeIndex, nodeName, allowedOrigins, } = options;
+    const { attributes, baseUrl, documentUrl, nodeIndex, nodeName, allowedOrigins, } = options;
     const pairs = new Map();
-    for (let index = 0; index + 1 < attributes.length; index += 2) {
-        // Chrome already folds HTML names; SVG/XML names remain case-sensitive.
-        const name = cdpSnapshotString(strings, attributes[index]);
-        const value = cdpSnapshotValueString(strings, attributes[index + 1]);
-        if (name === undefined || value === undefined)
-            continue;
-        // HTML keeps the first declaration. A later repeat must not move dom_urls.
+    for (const [name, value] of attributes) {
+        // HTML keeps the first declaration; SVG/XML spelling stays case-sensitive.
         if (!pairs.has(name))
             pairs.set(name, value);
     }