rea-agents 6.4.0 → 6.5.0

package/dist/browser/CdpElectronInspection.js

@@ -7,6 +7,7 @@ import { ingestElectronScriptEvent, } from "./CdpElectronScriptEvents.js";
 import { captureElectronScripts } from "./CdpElectronScripts.js";
 import { captureElectronWorkers } from "./CdpElectronWorkers.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 /** Passively inspect one Electron file page from the selected CDP endpoint. */
 export const inspectCdpElectronPage = async (context) => {
     const state = {
@@ -17,6 +18,11 @@ export const inspectCdpElectronPage = async (context) => {
             "Local file paths exposed by the selected CDP target are retained in the observation.",
             "REA does not evaluate renderer JavaScript, invoke Electron APIs, navigate, click, or close the page.",
             "Select include_script_sources to retain script contents.",
+            ...(context.target.attached === null
+                ? [
+                    "CDP discovery omitted the target attachment state; attached is reported as unknown.",
+                ]
+                : []),
         ],
         mainFrameId: undefined,
         navigationDuringCapture: false,
@@ -129,7 +135,7 @@ const navigatedFrameId = (event) => {
         return cdpStringValue(params.frameId);
     return undefined;
 };
-const captureFrames = async (result, completeness) => {
+export const captureFrames = async (result, completeness) => {
     const frameTree = recordValue(requiredRecord(result).frameTree);
     if (frameTree === undefined)
         throw new BrowserObservationError("inspect_web_page", "protocol_error");
@@ -137,8 +143,12 @@ const captureFrames = async (result, completeness) => {
     for (const tree of walkFrameTrees(frameTree, () => completeness.exclude("frames", "invalid_protocol_value"))) {
         const frame = recordValue(tree.frame);
         const frameId = cdpStringValue(frame?.id);
-        const path = await authorizedElectronFile(cdpStringValue(frame?.url) ?? "");
-        if (frameId === undefined || path === undefined) {
+        if (frame === undefined || frameId === undefined) {
+            completeness.exclude("frames", "invalid_protocol_value");
+            continue;
+        }
+        const path = await authorizedElectronFile(cdpStringValue(frame.url) ?? "");
+        if (path === undefined) {
             completeness.exclude("frames", "out_of_target_scope");
             continue;
         }
@@ -187,7 +197,7 @@ const captureResources = async (context, completeness) => {
         }
         pending.push(...recordsValue(tree.childFrames));
     }
-    return resources.sort((left, right) => left.resource_key.localeCompare(right.resource_key));
+    return resources.sort((left, right) => compareUnicodeCodePoints(left.resource_key, right.resource_key));
 };
 const captureDom = async (context, completeness) => {
     const result = requiredRecord(await context.connection.send("DOMSnapshot.captureSnapshot", { computedStyles: [], includePaintOrder: false, includeDOMRects: false }, context.sessionId, context.signal));

package/dist/browser/CdpElectronProvider.js

@@ -2,13 +2,13 @@ import { electronPageInspectionSchema, electronTargetListSchema, } from "../doma
 import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
-import {} from "../domain/browserObservationErrors.js";
 import { err, ok } from "../domain/result.js";
 import { discoverCdpEndpoint, hasCdpTargetWebSocket, } from "./CdpEndpoint.js";
 import { closeCdpTargetSession, openCdpTargetSession, } from "./CdpTargetSession.js";
 import { inspectCdpElectronPage } from "./CdpElectronInspection.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
 import { CDP_ELECTRON_PROVIDER_IDENTITY } from "./providerIdentities.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 /** Passive Electron provider for local file pages exposed by loopback CDP. */
 export class CdpElectronProvider {
     identity() {
@@ -43,7 +43,7 @@ export class CdpElectronProvider {
                     attached: target.attached,
                 });
             }
-            allowed.sort((left, right) => left.target_id.localeCompare(right.target_id));
+            allowed.sort((left, right) => compareUnicodeCodePoints(left.target_id, right.target_id));
             return ok(electronTargetListSchema.parse({
                 browser: discovery.version,
                 targets: allowed,
@@ -58,6 +58,11 @@ export class CdpElectronProvider {
                         : [
                             `${String(unconnectable)} otherwise allowed page target(s) lacked a validated direct CDP WebSocket and were excluded.`,
                         ]),
+                    ...(allowed.some((target) => target.attached === null)
+                        ? [
+                            "CDP discovery omitted attachment state for one or more targets; attached is reported as unknown.",
+                        ]
+                        : []),
                 ],
             }));
         }

package/dist/browser/CdpElectronScripts.js

@@ -3,6 +3,7 @@ import { createWebTextArtifact } from "../domain/webContentArtifact.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
 import { requiredScriptSource } from "./CdpCaptureValues.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 /** Normalize local script metadata and optionally approved source. */
 export const captureElectronScripts = async (input) => {
     let total = 0;
@@ -43,7 +44,7 @@ export const captureElectronScripts = async (input) => {
         input.completeness.exclude("script_sources", "not_approved", total);
     return {
         total,
-        items: items.sort((left, right) => left.script_key.localeCompare(right.script_key)),
+        items: items.sort((left, right) => compareUnicodeCodePoints(left.script_key, right.script_key)),
     };
 };
 const captureScriptSource = async (input, script) => {

package/dist/browser/CdpElectronWorkers.js

@@ -2,6 +2,7 @@ import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
 import { recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 /** Inventory local worker targets without attaching to them. */
 export const captureElectronWorkers = async (input) => {
     const result = await optionalCdpCommand({
@@ -35,16 +36,20 @@ export const captureElectronWorkers = async (input) => {
             input.completeness.exclude("workers", "invalid_protocol_value");
             continue;
         }
+        if (typeof target.attached !== "boolean") {
+            input.completeness.exclude("workers", "invalid_protocol_value");
+            continue;
+        }
         workers.push({
             target_id: targetId,
             type,
             file_path: path,
-            attached: target.attached === true,
+            attached: target.attached,
             opener_target_id: openerTargetId,
             parent_frame_id: parentFrameId,
         });
     }
-    return workers.sort((left, right) => left.target_id.localeCompare(right.target_id));
+    return workers.sort((left, right) => compareUnicodeCodePoints(left.target_id, right.target_id));
 };
 const boundedTargetField = (value) => {
     const field = cdpStringValue(value);

package/dist/browser/CdpEndpoint.js

@@ -3,8 +3,8 @@ import { z } from "zod";
 import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
-import {} from "../domain/browserObservationErrors.js";
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
+import { urlDeclaresQueryOrFragment } from "../domain/urlComponents.js";
 import { safeParseJson } from "../domain/safeJson.js";
 const endpointVersionSchema = z.object({
     Browser: z.string().min(1),
@@ -19,10 +19,31 @@ const endpointTargetSchema = z.object({
     type: z.string().min(1),
     title: z.string().default(""),
     url: z.string(),
-    attached: z.boolean().default(false),
+    attached: z.boolean().nullable().optional(),
     webSocketDebuggerUrl: z.string().min(1).optional(),
 });
 const endpointTargetsSchema = z.array(endpointTargetSchema);
+/** Per-response bounds for loopback CDP discovery documents. */
+const CDP_DISCOVERY_RESPONSE_LIMITS = {
+    bytes: 8 * 1024 * 1024,
+    timeoutMs: 10_000,
+};
+const browserSocketVersionSchema = z.object({
+    protocolVersion: z.string().min(1),
+    product: z.string().min(1),
+    revision: z.string(),
+    userAgent: z.string(),
+    jsVersion: z.string(),
+});
+const browserSocketTargetsSchema = z.object({
+    targetInfos: z.array(z.object({
+        targetId: z.string().min(1),
+        type: z.string().min(1),
+        title: z.string().default(""),
+        url: z.string(),
+        attached: z.boolean().optional(),
+    })),
+});
 /** Read CDP discovery endpoints without following redirects. */
 export const discoverCdpEndpoint = async (endpoint, operation, signal) => {
     const versionInput = await readCdpJson(new URL("/json/version", endpoint), operation, signal);
@@ -43,11 +64,63 @@ export const discoverCdpEndpoint = async (endpoint, operation, signal) => {
             type: target.type,
             title: sanitizeTargetTitle(target.title, target.url),
             url: target.url,
-            attached: target.attached,
+            attached: target.attached ?? null,
             ...targetWebSocket(endpoint, target, operation),
         })),
     };
 };
+/**
+ * Run browser-socket discovery work, including its WebSocket handshake, under
+ * the HTTP discovery deadline. Reaching the deadline is a timeout, not a
+ * caller cancellation, so the internal abort is not carried as its cause.
+ */
+export const withCdpDiscoveryDeadline = async (operation, signal, work, timeoutMs = CDP_DISCOVERY_RESPONSE_LIMITS.timeoutMs) => {
+    const deadline = new AbortController();
+    const timer = setTimeout(() => deadline.abort(), timeoutMs);
+    try {
+        return await work(signal === undefined
+            ? deadline.signal
+            : AbortSignal.any([signal, deadline.signal]));
+    }
+    catch (cause) {
+        if (deadline.signal.aborted && signal?.aborted !== true)
+            throw new BrowserObservationError(operation, "timeout", {
+                detail: `CDP browser-socket discovery exceeded its ${String(timeoutMs)} ms deadline.`,
+            });
+        throw cause;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};
+/**
+ * Read discovery facts over a browser socket that has no HTTP discovery.
+ * Each reply is bounded by the connection's protocol message limit; callers
+ * apply the discovery deadline through `signal`.
+ */
+export const discoverCdpBrowserSocket = async (connection, url, operation, signal) => {
+    const versionInput = await connection.send("Browser.getVersion", {}, undefined, signal);
+    const targetsInput = await connection.send("Target.getTargets", {}, undefined, signal);
+    const version = parseCdpEndpointValue(browserSocketVersionSchema, versionInput, operation);
+    const targets = parseCdpEndpointValue(browserSocketTargetsSchema, targetsInput, operation);
+    return {
+        webSocket: { scope: "browser", url },
+        version: {
+            product: version.product,
+            protocol_version: version.protocolVersion,
+            revision: version.revision,
+            user_agent: version.userAgent,
+            js_version: version.jsVersion,
+        },
+        targets: targets.targetInfos.map((target) => ({
+            id: target.targetId,
+            type: target.type,
+            title: sanitizeTargetTitle(target.title, target.url),
+            url: target.url,
+            attached: target.attached ?? null,
+        })),
+    };
+};
 const sanitizeTargetTitle = (value, targetUrl) => {
     let url;
     try {
@@ -141,8 +214,7 @@ const safeCdpWebSocketEndpoint = (endpoint, reported, operation) => {
         parsed.port !== trustedEndpoint.port ||
         parsed.username !== "" ||
         parsed.password !== "" ||
-        parsed.search !== "" ||
-        parsed.hash !== "" ||
+        urlDeclaresQueryOrFragment(parsed) ||
         path === undefined)
         throw new BrowserObservationError(operation, "invalid_endpoint_response");
     parsed.hostname = trustedEndpoint.hostname;
@@ -181,30 +253,84 @@ const targetWebSocket = (endpoint, target, operation) => {
     }
 };
 /** Read one loopback CDP discovery document without redirects. */
-export const readCdpJson = async (url, operation, signal) => await new Promise((resolve, reject) => {
+export const readCdpJson = async (url, operation, signal, limits = CDP_DISCOVERY_RESPONSE_LIMITS) => await new Promise((resolve, reject) => {
     if (signal?.aborted === true) {
         reject(new AnalysisCancelledError(operation));
         return;
     }
-    const request_ = request(url, { method: "GET", signal, headers: { Accept: "application/json" } }, (response) => {
-        if (response.statusCode !== 200) {
-            response.resume();
-            reject(new BrowserObservationError(operation, "invalid_endpoint_response"));
+    let response;
+    let request_;
+    let timer;
+    let settled = false;
+    const removeAbort = () => signal?.removeEventListener("abort", onAbort);
+    const finish = (error, value) => {
+        if (settled)
+            return;
+        settled = true;
+        if (timer !== undefined)
+            clearTimeout(timer);
+        removeAbort();
+        if (error !== undefined) {
+            reject(error);
+            response?.destroy();
+            request_?.destroy();
+        }
+        else
+            resolve(value);
+    };
+    const onAbort = () => {
+        if (signal?.aborted === true)
+            finish(new AnalysisCancelledError(operation));
+    };
+    request_ = request(url, { method: "GET", headers: { Accept: "application/json" } }, (received) => {
+        response = received;
+        if (settled) {
+            received.destroy();
+            return;
+        }
+        if (received.statusCode !== 200) {
+            finish(new BrowserObservationError(operation, "invalid_endpoint_response"));
             return;
         }
         const chunks = [];
-        response.on("data", (chunk) => chunks.push(chunk));
-        response.on("end", () => {
-            const parsed = safeParseJson(Buffer.concat(chunks).toString("utf8"));
+        let bytes = 0;
+        received.on("data", (chunk) => {
+            if (settled)
+                return;
+            bytes += chunk.byteLength;
+            if (bytes > limits.bytes) {
+                finish(new BrowserObservationError(operation, "payload_limit", {
+                    detail: `CDP discovery response exceeds its ${String(limits.bytes)} byte limit.`,
+                }));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        received.on("end", () => {
+            if (settled)
+                return;
+            const parsed = safeParseJson(Buffer.concat(chunks, bytes).toString("utf8"));
             if (!parsed.ok) {
-                reject(new BrowserObservationError(operation, "invalid_endpoint_response", { cause: parsed.cause }));
+                finish(new BrowserObservationError(operation, "invalid_endpoint_response", { cause: parsed.cause }));
                 return;
             }
-            resolve(parsed.value);
+            finish(undefined, parsed.value);
+        });
+        received.on("aborted", () => finish(new BrowserObservationError(operation, "invalid_endpoint_response")));
+        received.on("close", () => {
+            if (!settled && !received.complete)
+                finish(new BrowserObservationError(operation, "invalid_endpoint_response"));
         });
-        response.on("error", (cause) => reject(endpointFailure(cause, operation, signal)));
+        received.on("error", (cause) => finish(endpointFailure(cause, operation, signal)));
     });
-    request_.on("error", (cause) => reject(endpointFailure(cause, operation, signal)));
+    request_.on("error", (cause) => finish(endpointFailure(cause, operation, signal)));
+    signal?.addEventListener("abort", onAbort, { once: true });
+    onAbort();
+    if (settled)
+        return;
+    timer = setTimeout(() => finish(new BrowserObservationError(operation, "timeout", {
+        detail: `CDP discovery response exceeded its ${String(limits.timeoutMs)} ms deadline.`,
+    })), limits.timeoutMs);
     request_.end();
 });
 const endpointFailure = (cause, operation, signal) => {

package/dist/browser/CdpObservationSession.js

@@ -48,6 +48,8 @@ export const observeCdpSession = async (context) => {
             message: "Browser observation window ended",
             terminal: true,
         });
+        if (capture.scopeExcluded)
+            endReason = "target_left_scope";
         return {
             browser: context.discovery.version,
             target: {
@@ -83,6 +85,7 @@ class TimelineCapture {
     finalUrl;
     #sequence = 0;
     #pendingReload = false;
+    #scopeExcluded = false;
     #endReason;
     #listeners = new Set();
     constructor(allowedOrigins, mainFrameId, initialUrl) {
@@ -92,7 +95,7 @@ class TimelineCapture {
             allowedSanitizedUrl(initialUrl, allowedOrigins)?.url ?? null;
     }
     ingest(event) {
-        if (this.#endReason !== undefined)
+        if (this.#endReason !== undefined || this.#scopeExcluded)
             return;
         const params = recordValue(event.params);
         if (params === undefined)
@@ -150,9 +153,21 @@ class TimelineCapture {
         this.end("target_terminated");
     }
     setFinalUrl(rawUrl) {
+        if (this.#scopeExcluded)
+            return;
         const destination = scopedUrl(rawUrl, this.allowedOrigins);
         this.finalUrl = destination.scope === "approved" ? destination.url : null;
     }
+    get scopeExcluded() {
+        return this.#scopeExcluded;
+    }
+    excludeTargetScope(reason) {
+        if (this.#scopeExcluded)
+            return;
+        this.#scopeExcluded = true;
+        this.finalUrl = null;
+        this.completeness.exclude("timeline", reason);
+    }
     #navigationRequested(event, params) {
         if (!isMainFrameNavigation(event, this.mainFrameId))
             return;
@@ -183,8 +198,7 @@ class TimelineCapture {
         if (destination.scope === "approved")
             this.finalUrl = destination.url;
         else {
-            this.finalUrl = null;
-            this.completeness.exclude("timeline", "out_of_target_scope");
+            this.excludeTargetScope("out_of_target_scope");
             this.end("target_left_scope");
         }
     }
@@ -203,8 +217,7 @@ class TimelineCapture {
         if (destination.scope === "approved")
             this.finalUrl = destination.url;
         else {
-            this.finalUrl = null;
-            this.completeness.exclude("timeline", "out_of_target_scope");
+            this.excludeTargetScope("out_of_target_scope");
             this.end("target_left_scope");
         }
     }
@@ -226,7 +239,7 @@ class TimelineCapture {
             detail: null,
         });
         if (destination.scope !== "approved") {
-            this.completeness.exclude("timeline", "out_of_target_scope");
+            this.excludeTargetScope("out_of_target_scope");
             this.end("target_left_scope");
         }
     }
@@ -297,15 +310,18 @@ const waitForWindow = async (durationMs, capture, signal) => await new Promise((
         onAbort();
 });
 const captureFinalUrl = async (context, capture, allowedOrigins) => {
+    if (capture.scopeExcluded)
+        return "target_left_scope";
     const result = await context.connection.send("Page.getFrameTree", {}, context.sessionId, context.signal);
+    if (capture.scopeExcluded)
+        return "target_left_scope";
     const url = mainFrameUrl(result);
     if (url !== undefined &&
         allowedSanitizedUrl(url, allowedOrigins) !== undefined) {
         capture.setFinalUrl(url);
         return "window_elapsed";
     }
-    capture.finalUrl = null;
-    capture.completeness.exclude("timeline", url === undefined ? "invalid_protocol_value" : "out_of_target_scope");
+    capture.excludeTargetScope(url === undefined ? "invalid_protocol_value" : "out_of_target_scope");
     return "target_left_scope";
 };
 const frameId = (result) => cdpStringValue(recordValue(recordValue(recordValue(result)?.frameTree)?.frame)?.id);

package/dist/browser/CdpPageCapture.js

@@ -1,5 +1,4 @@
 import { BrowserObservationError } from "../domain/browserObservationError.js";
-import {} from "../domain/browserObservationErrors.js";
 import { stableWebResources } from "../domain/webInventory.js";
 import { CdpConnection } from "./CdpConnection.js";
 import { CdpCaptureEvents } from "./CdpCaptureEvents.js";
@@ -8,6 +7,7 @@ import { captureStorage } from "./CdpCaptureStorage.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 import { CdpCommandRejection } from "./CdpCommandRejection.js";
 import { captureAccessibility, captureDom, captureFrames, captureResources, mainFrameUrl, } from "./CdpCaptureDocuments.js";
+import { capturedSvgNodeKind } from "./CdpCaptureDomSvg.js";
 import { allowedSanitizedUrl, delayWithCancellation, } from "./CdpCaptureValues.js";
 import { captureScripts } from "./CdpPageCaptureScripts.js";
 import { captureWorkers } from "./CdpPageCaptureWorkers.js";
@@ -29,6 +29,11 @@ export const capturePage = async (context) => {
             "Raw network headers, bodies, cookies, storage values, console objects, and WebSocket payloads are never retained; explicitly requested primitive console text is retained verbatim, while payload captures retain value-free shapes.",
             "Source maps are reported only as declarative URLs and are not fetched.",
             "URL-less scripts and console events without an allowed source URL are excluded because their origin cannot be proven.",
+            ...(context.target.attached === null
+                ? [
+                    "CDP discovery omitted the target attachment state; attached is reported as unknown.",
+                ]
+                : []),
         ],
         startedAt: new Date().toISOString(),
     };
@@ -73,6 +78,9 @@ const captureAuthorizedPage = async (state) => {
     const storageCapture = await captureStorage(context, attachedUrl, limitations);
     if (!input.include_storage_keys)
         state.events.completeness.exclude("storage_keys", "not_approved", null);
+    else if (storageCapture.keysExclusion !== undefined)
+        state.events.completeness.exclude("storage_keys", storageCapture.keysExclusion, null);
+    await report(context.progress, 3, "Normalizing browser evidence");
     const completedFrameResult = await authorizedMainFrame({
         connection: context.connection,
         sessionId: context.sessionId,
@@ -85,7 +93,10 @@ const captureAuthorizedPage = async (state) => {
         throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
     if (state.events.navigationDuringCapture || completedUrl !== attachedUrl)
         throw new BrowserObservationError("inspect_web_page", "target_changed");
-    await report(context.progress, 3, "Normalizing browser evidence");
+    // Body IDs were enumerated before asynchronous CDP reads. Events remain
+    // enabled through the final capture, so account for eligible responses that
+    // arrived while those reads were pending.
+    state.events.settleUnexaminedResponseBodies();
     state.events.recordScriptMetadataBudgetExclusions();
     return {
         inspection: normalizedInspection(state, {
@@ -102,21 +113,21 @@ const captureAuthorizedPage = async (state) => {
     };
 };
 const captureJsonResponseBodies = async (state) => {
-    const requestIds = state.events.responseBodyRequestIds();
-    for (let index = 0; index < requestIds.length; index += 1) {
-        const requestId = requestIds[index];
-        if (requestId === undefined)
+    const requests = state.events.responseBodyRequests();
+    for (let index = 0; index < requests.length; index += 1) {
+        const candidate = requests[index];
+        if (candidate === undefined)
             continue;
-        const request = state.events.network.get(requestId);
-        if (request === undefined)
+        const current = state.events.currentResponseBodyRequest(candidate);
+        if (current === undefined)
             continue;
-        if (request.encoded_data_length === null) {
-            state.events.responseBodyUnavailable(requestId);
+        if (current.encoded_data_length === null) {
+            state.events.responseBodyUnavailable(candidate);
             continue;
         }
         let result;
         try {
-            result = await optionalCdpCommand(state.context, "Network.getResponseBody", { requestId }, state.limitations);
+            result = await optionalCdpCommand(state.context, "Network.getResponseBody", { requestId: candidate.requestId }, state.limitations);
         }
         catch (cause) {
             if (!(cause instanceof CdpCommandRejection) ||
@@ -124,15 +135,15 @@ const captureJsonResponseBodies = async (state) => {
                 cause.code !== -32_000 ||
                 cause.reportedMessage === null)
                 throw cause;
-            state.events.responseBodyUnavailable(requestId);
-            state.limitations.push(`Response body unavailable for request ${requestId}: ${cause.userMessage}`);
+            state.events.responseBodyUnavailable(candidate);
+            state.limitations.push(`Response body unavailable for request ${candidate.requestId}: ${cause.userMessage}`);
             continue;
         }
         if (result !== undefined) {
-            state.events.ingestResponseBody(requestId, result);
+            state.events.ingestResponseBody(candidate, result);
             continue;
         }
-        for (const remaining of requestIds.slice(index))
+        for (const remaining of requests.slice(index))
             state.events.responseBodyUnavailable(remaining);
         return;
     }
@@ -166,7 +177,46 @@ const capturePageDom = async (state) => {
         includePaintOrder: false,
         includeDOMRects: false,
     }, context.sessionId, context.signal);
-    return captureDom(result, allowedOrigins, context.input, state.events.completeness);
+    const capture = captureDom(result, allowedOrigins, context.input, state.events.completeness);
+    let step = capture.next();
+    let descriptionUnavailable = false;
+    const pendingController = new AbortController();
+    const signal = context.signal === undefined
+        ? pendingController.signal
+        : AbortSignal.any([context.signal, pendingController.signal]);
+    while (!step.done) {
+        const pending = step.value.map(async (query) => {
+            if (descriptionUnavailable)
+                return undefined;
+            try {
+                return capturedSvgNodeKind(query, await context.connection.send("DOM.describeNode", { backendNodeId: query.backendNodeId, depth: 0 }, context.sessionId, signal));
+            }
+            catch (cause) {
+                // A detached node can disappear between snapshot and description.
+                // Preserve partial metadata, but propagate transport/cancellation errors.
+                if (!(cause instanceof CdpCommandRejection))
+                    throw cause;
+                if (cause.code === -32_601)
+                    descriptionUnavailable = true;
+                else if (cause.code !== -32_000)
+                    throw cause;
+                return undefined;
+            }
+        });
+        try {
+            // Promise.all preserves snapshot order even when CDP replies out of order.
+            step = capture.next(await Promise.all(pending));
+        }
+        catch (cause) {
+            // Stop and settle this bounded batch before the session can be detached.
+            pendingController.abort();
+            await Promise.allSettled(pending);
+            throw cause;
+        }
+    }
+    if (step.value.unresolvedSvgNodes > 0)
+        state.limitations.push(`SVG identity was unavailable for ${String(step.value.unresolvedSvgNodes)} snapshotted XLink candidate nodes; their URL destinations remain unknown.`);
+    return step.value;
 };
 const normalizedInspection = (state, captured) => ({
     browser: state.context.discovery.version,

package/dist/browser/CdpPageCaptureScripts.js

@@ -1,5 +1,6 @@
 import { reconcileCapturedWebScript, stableWebScriptKey, } from "../domain/webInventory.js";
 import { requiredScriptSource, sourceExcluded, sourceResult, } from "./CdpCaptureValues.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 export const captureScripts = async (options) => {
     const { context, events, rawResources, resources, frameIds } = options;
     const state = {
@@ -50,9 +51,9 @@ const keyAndBuildInventory = (drafts, scriptCount) => {
         ...draft,
         base: stableWebScriptKey(draft.item),
     }));
-    keyed.sort((left, right) => left.base.localeCompare(right.base) ||
-        sourceDigest(left.item.source).localeCompare(sourceDigest(right.item.source)) ||
-        (left.item.frame_id ?? "").localeCompare(right.item.frame_id ?? ""));
+    keyed.sort((left, right) => compareUnicodeCodePoints(left.base, right.base) ||
+        compareUnicodeCodePoints(sourceDigest(left.item.source), sourceDigest(right.item.source)) ||
+        compareUnicodeCodePoints(left.item.frame_id ?? "", right.item.frame_id ?? ""));
     const totals = new Map();
     for (const { base } of keyed)
         totals.set(base, (totals.get(base) ?? 0) + 1);

package/dist/browser/CdpPageCaptureWorkers.js

@@ -28,12 +28,16 @@ export const captureWorkers = async (input, frameIds) => {
                     : "unsupported_url");
             continue;
         }
+        if (typeof target.attached !== "boolean") {
+            completeness.exclude("workers", "invalid_protocol_value");
+            continue;
+        }
         items.push({
             target_id: cdpStringValue(target.targetId) ?? "",
             type,
             url: url.url,
             origin: url.origin,
-            attached: target.attached === true,
+            attached: target.attached,
             opener_target_id: cdpStringValue(target.openerId) ?? null,
             parent_frame_id: cdpStringValue(target.parentFrameId) ?? null,
         });