rea-agents 6.4.0 → 6.7.0

package/dist/browser/CdpElectronWorkers.js

@@ -1,7 +1,8 @@
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
+import { recordValue, 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({
@@ -14,7 +15,18 @@ export const captureElectronWorkers = async (input) => {
         return [];
     }
     const workers = [];
-    for (const target of recordsValue(recordValue(result)?.targetInfos)) {
+    // A missing target list or a non-record entry is unreadable, not empty.
+    const targetInfos = recordValue(result)?.targetInfos;
+    if (!Array.isArray(targetInfos)) {
+        input.completeness.exclude("workers", "invalid_protocol_value", null);
+        return [];
+    }
+    for (const entry of targetInfos) {
+        const target = recordValue(entry);
+        if (target === undefined) {
+            input.completeness.exclude("workers", "invalid_protocol_value");
+            continue;
+        }
         const type = cdpStringValue(target.type) ?? "";
         if (!type.includes("worker"))
             continue;
@@ -35,16 +47,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,
@@ -232,10 +282,11 @@ const accessibilityForFrames = async (state, frames) => {
     const capture = captureAccessibility(results, {
         includeText: context.input.include_accessibility_text,
         ...(results.length === 0 && unavailable ? { unavailable: true } : {}),
+        completeness: events.completeness,
     });
     if (!context.input.include_accessibility_text)
         events.completeness.exclude("accessibility", "not_approved", capture.textCapture.excluded_fields);
-    if (capture.treeIncomplete)
+    if (capture.hasUnobservedChildren)
         events.completeness.truncate("accessibility");
     return capture;
 };

package/dist/browser/CdpPageCaptureScripts.js

@@ -1,17 +1,19 @@
-import { reconcileCapturedWebScript, stableWebScriptKey, } from "../domain/webInventory.js";
+import { createCapturedWebScriptReconciler, 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 = {
-        context,
-        events,
-        frameIds,
-        rawResources,
-        resources,
-    };
+    let state;
     const drafts = [];
-    for (const script of events.scripts.values())
+    for (const script of events.scripts.values()) {
+        state ??= {
+            context,
+            events,
+            frameIds,
+            reconcileResource: createCapturedWebScriptReconciler(rawResources, resources),
+        };
         drafts.push(await buildScriptDraft(script, state));
+    }
     if (!context.input.include_script_sources)
         events.completeness.exclude("script_sources", "not_approved", events.scripts.size);
     return keyAndBuildInventory(drafts, events.scripts.size);
@@ -34,7 +36,10 @@ const buildScriptDraft = async (script, state) => {
         item: {
             ...inventoryScript,
             origin: script.origin,
-            resource_reconciliation: reconcileCapturedWebScript({ ...inventoryScript, rawUrl: script.rawUrl }, state.rawResources, state.resources),
+            resource_reconciliation: state.reconcileResource({
+                ...inventoryScript,
+                rawUrl: script.rawUrl,
+            }),
             source,
         },
         sourceMapRawUrl: script.sourceMapRawUrl,
@@ -50,9 +55,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

@@ -1,4 +1,4 @@
-import { allowedSanitizedUrl, isHttpUrl, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
+import { admitRecords, allowedSanitizedUrl, isHttpUrl, recordValue, cdpStringValue, } from "./CdpCaptureValues.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 export const captureWorkers = async (input, frameIds) => {
     const { context, allowedOrigins, limitations, events } = input;
@@ -7,14 +7,47 @@ export const captureWorkers = async (input, frameIds) => {
     const items = [];
     if (result === undefined)
         completeness.unavailable("workers");
-    for (const target of recordsValue(recordValue(result)?.targetInfos)) {
-        const type = cdpStringValue(target.type) ?? "";
-        const url = allowedSanitizedUrl(target.url, allowedOrigins);
-        const relatedToPage = cdpStringValue(target.openerId) === context.target.id ||
-            (cdpStringValue(target.parentFrameId) !== undefined &&
-                frameIds.has(cdpStringValue(target.parentFrameId) ?? ""));
+    const targets = admitRecords(recordValue(result)?.targetInfos);
+    if (result !== undefined && targets === undefined) {
+        completeness.exclude("workers", "invalid_protocol_value", null);
+        return items;
+    }
+    let malformedEntries = 0;
+    for (const entry of targets ?? []) {
+        const target = recordValue(entry);
+        if (target === undefined) {
+            malformedEntries += 1;
+            continue;
+        }
+        const type = cdpStringValue(target.type);
+        if (type === undefined || type.length === 0) {
+            malformedEntries += 1;
+            continue;
+        }
         if (!type.includes("worker"))
             continue;
+        const targetId = cdpStringValue(target.targetId);
+        if (targetId === undefined ||
+            targetId.length === 0 ||
+            typeof target.attached !== "boolean" ||
+            typeof target.url !== "string") {
+            malformedEntries += 1;
+            continue;
+        }
+        const openerId = target.openerId === undefined
+            ? undefined
+            : cdpStringValue(target.openerId);
+        const parentFrameId = target.parentFrameId === undefined
+            ? undefined
+            : cdpStringValue(target.parentFrameId);
+        if ((target.openerId !== undefined && openerId === undefined) ||
+            (target.parentFrameId !== undefined && parentFrameId === undefined)) {
+            malformedEntries += 1;
+            continue;
+        }
+        const url = allowedSanitizedUrl(target.url, allowedOrigins);
+        const relatedToPage = openerId === context.target.id ||
+            (parentFrameId !== undefined && frameIds.has(parentFrameId));
         if (!relatedToPage) {
             completeness.exclude("workers", "out_of_target_scope");
             continue;
@@ -29,14 +62,16 @@ export const captureWorkers = async (input, frameIds) => {
             continue;
         }
         items.push({
-            target_id: cdpStringValue(target.targetId) ?? "",
+            target_id: targetId,
             type,
             url: url.url,
             origin: url.origin,
-            attached: target.attached === true,
-            opener_target_id: cdpStringValue(target.openerId) ?? null,
-            parent_frame_id: cdpStringValue(target.parentFrameId) ?? null,
+            attached: target.attached,
+            opener_target_id: openerId ?? null,
+            parent_frame_id: parentFrameId ?? null,
         });
     }
+    if (malformedEntries > 0)
+        completeness.exclude("workers", "invalid_protocol_value", malformedEntries);
     return items;
 };