rea-agents 4.1.0 → 6.0.0

package/dist/browser/CdpCaptureStorageFingerprints.js

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

package/dist/browser/CdpCaptureValues.js

@@ -11,7 +11,7 @@ export const recordsValue = (value) => Array.isArray(value)
         return record === undefined ? [] : [record];
     })
     : [];
-export const stringValue = (value) => typeof value === "string" ? value : undefined;
+export const cdpStringValue = (value) => typeof value === "string" ? value : undefined;
 export const numberValue = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
 export const requiredRecord = (value) => {
     const record = recordValue(value);
@@ -33,7 +33,7 @@ export const isHttpUrl = (value) => {
     }
 };
 export const allowedSanitizedUrl = (value, allowedOrigins) => {
-    const text = stringValue(value);
+    const text = cdpStringValue(value);
     if (text === undefined)
         return undefined;
     const sanitized = sanitizeBrowserUrl(text);

package/dist/browser/CdpCommandRejection.js

@@ -0,0 +1,17 @@
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+/** Preserve a producer's command rejection independently from fatal transport parsing errors. */
+export class CdpCommandRejection extends BrowserObservationError {
+    command;
+    code;
+    reportedMessage;
+    constructor(operation, command, code, reportedMessage) {
+        super(operation, "protocol_error", {
+            detail: reportedMessage === null
+                ? "CDP returned a malformed command error."
+                : `CDP ${command} failed (${code === null ? "unknown code" : String(code)}): ${reportedMessage}`,
+        });
+        this.command = command;
+        this.code = code;
+        this.reportedMessage = reportedMessage;
+    }
+}

package/dist/browser/CdpConnection.js

@@ -2,36 +2,43 @@ import WebSocket, {} from "ws";
 import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { CdpCommandRejection } from "./CdpCommandRejection.js";
 import {} from "../domain/browserObservationErrors.js";
 import { safeParseJson } from "../domain/safeJson.js";
 /** Correlated JSON-RPC transport for one CDP target operation. */
 export class CdpConnection {
     socket;
     operation;
+    maxPayloadBytes;
     #pending = new Map();
     #listeners = new Set();
     #disconnectListeners = new Set();
+    #protocolFailureListeners = new Set();
     #nextId = 1;
     #closed = false;
     #protocolFailed = false;
-    constructor(socket, operation) {
+    #transportFailure = "disconnected";
+    constructor(socket, operation, maxPayloadBytes) {
         this.socket = socket;
         this.operation = operation;
+        this.maxPayloadBytes = maxPayloadBytes;
         socket.on("message", (data) => this.#receive(data));
         socket.on("close", () => this.#disconnect());
-        socket.on("error", () => this.#disconnect());
+        socket.on("error", (cause) => this.#disconnect(isRecord(cause) && cause.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
+            ? "payload_limit"
+            : "disconnected"));
     }
     /** Connect to one already-validated loopback CDP WebSocket. */
-    static async connect(url, operation, signal) {
+    static async connect(url, operation, signal, limits) {
         if (signal?.aborted === true)
             throw new AnalysisCancelledError(operation);
         const socket = new WebSocket(url, {
             handshakeTimeout: 0,
-            maxPayload: 0,
+            maxPayload: limits?.maxPayloadBytes ?? 0,
             perMessageDeflate: false,
         });
         await waitForOpen(socket, operation, signal);
-        return new CdpConnection(socket, operation);
+        return new CdpConnection(socket, operation, limits?.maxPayloadBytes ?? 0);
     }
     /** Subscribe to validated CDP event envelopes. */
     onEvent(listener) {
@@ -47,12 +54,21 @@ export class CdpConnection {
         this.#disconnectListeners.add(listener);
         return () => this.#disconnectListeners.delete(listener);
     }
+    /** Notify fatal wire parsing failure even when no command is outstanding. */
+    onProtocolFailure(listener) {
+        if (this.#protocolFailed) {
+            listener(this.#transportError("protocol_error"));
+            return () => undefined;
+        }
+        this.#protocolFailureListeners.add(listener);
+        return () => this.#protocolFailureListeners.delete(listener);
+    }
     /** Execute one command, optionally within a flat target session. */
     async send(method, params = {}, sessionId, signal) {
         if (this.#protocolFailed)
             throw new BrowserObservationError(this.operation, "protocol_error");
         if (this.#closed || this.socket.readyState !== WebSocket.OPEN)
-            throw new BrowserObservationError(this.operation, "disconnected");
+            throw this.#transportError(this.#transportFailure);
         if (signal?.aborted === true)
             throw new AnalysisCancelledError(this.operation);
         const id = this.#nextId;
@@ -68,6 +84,7 @@ export class CdpConnection {
             };
             signal?.addEventListener("abort", onAbort, { once: true });
             this.#pending.set(id, {
+                method,
                 resolve,
                 reject,
                 removeAbort: () => signal?.removeEventListener("abort", onAbort),
@@ -111,6 +128,8 @@ export class CdpConnection {
         });
     }
     #receive(data) {
+        if (this.#closed || this.#protocolFailed)
+            return;
         const parsed = safeParseJson(rawText(data));
         if (!parsed.ok) {
             this.#failPending("protocol_error");
@@ -154,7 +173,12 @@ export class CdpConnection {
             return;
         this.#complete(id, pending);
         if ("error" in message) {
-            pending.reject(new BrowserObservationError(this.operation, "protocol_error"));
+            const reported = message.error;
+            pending.reject(new CdpCommandRejection(this.operation, pending.method, isRecord(reported) && typeof reported.code === "number"
+                ? reported.code
+                : null, isRecord(reported) && typeof reported.message === "string"
+                ? reported.message
+                : null));
             return;
         }
         pending.resolve("result" in message ? message.result : {});
@@ -164,24 +188,40 @@ export class CdpConnection {
         this.#pending.delete(id);
     }
     #failPending(reason) {
-        if (reason === "disconnected")
+        const wasProtocolFailed = this.#protocolFailed;
+        if (reason !== "protocol_error")
             this.#closed = true;
         else
             this.#protocolFailed = true;
         for (const [id, pending] of this.#pending) {
             this.#complete(id, pending);
-            pending.reject(new BrowserObservationError(this.operation, reason));
+            pending.reject(this.#transportError(reason));
+        }
+        if (reason === "protocol_error" && !wasProtocolFailed) {
+            const error = this.#transportError(reason);
+            for (const listener of this.#protocolFailureListeners)
+                listener(error);
+            this.#protocolFailureListeners.clear();
         }
     }
-    #disconnect() {
+    #disconnect(reason = "disconnected") {
         const wasClosed = this.#closed;
-        this.#failPending("disconnected");
+        if (!wasClosed)
+            this.#transportFailure = reason;
+        this.#failPending(reason);
         if (wasClosed)
             return;
         for (const listener of this.#disconnectListeners)
             listener();
         this.#disconnectListeners.clear();
     }
+    #transportError(reason) {
+        return new BrowserObservationError(this.operation, reason, reason === "payload_limit"
+            ? {
+                detail: `CDP message exceeded the selected ${String(this.maxPayloadBytes)} byte protocol budget.`,
+            }
+            : undefined);
+    }
 }
 const rawText = (data) => Array.isArray(data)
     ? Buffer.concat(data).toString("utf8")

package/dist/browser/CdpElectronInspection.js

@@ -1,7 +1,7 @@
 import { canonicalDigest } from "../domain/comparisonSemantics.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { delayWithCancellation, numberValue, recordValue, recordsValue, requiredRecord, stringValue, } from "./CdpCaptureValues.js";
+import { delayWithCancellation, numberValue, recordValue, recordsValue, requiredRecord, cdpStringValue, } from "./CdpCaptureValues.js";
 import { walkFrameTrees } from "./CdpCaptureDocuments.js";
 import { ingestElectronScriptEvent, } from "./CdpElectronScriptEvents.js";
 import { captureElectronScripts } from "./CdpElectronScripts.js";
@@ -124,9 +124,9 @@ const navigatedFrameId = (event) => {
     if (params === undefined)
         return undefined;
     if (event.method === "Page.frameNavigated")
-        return stringValue(recordValue(params.frame)?.id);
+        return cdpStringValue(recordValue(params.frame)?.id);
     if (event.method === "Page.navigatedWithinDocument")
-        return stringValue(params.frameId);
+        return cdpStringValue(params.frameId);
     return undefined;
 };
 const captureFrames = async (result, completeness) => {
@@ -136,15 +136,15 @@ const captureFrames = async (result, completeness) => {
     const frames = [];
     for (const tree of walkFrameTrees(frameTree, () => completeness.exclude("frames", "invalid_protocol_value"))) {
         const frame = recordValue(tree.frame);
-        const frameId = stringValue(frame?.id);
-        const path = await authorizedElectronFile(stringValue(frame?.url) ?? "");
+        const frameId = cdpStringValue(frame?.id);
+        const path = await authorizedElectronFile(cdpStringValue(frame?.url) ?? "");
         if (frameId === undefined || path === undefined) {
             completeness.exclude("frames", "out_of_target_scope");
             continue;
         }
         frames.push({
             frame_id: frameId,
-            parent_frame_id: stringValue(frame?.parentId) ?? null,
+            parent_frame_id: cdpStringValue(frame?.parentId) ?? null,
             file_path: path,
         });
     }
@@ -163,15 +163,15 @@ const captureResources = async (context, completeness) => {
         if (tree === undefined)
             break;
         for (const resource of recordsValue(tree.resources)) {
-            const path = await authorizedElectronFile(stringValue(resource.url) ?? "");
+            const path = await authorizedElectronFile(cdpStringValue(resource.url) ?? "");
             if (path === undefined) {
                 completeness.exclude("resources", "out_of_target_scope");
                 continue;
             }
             const item = {
                 file_path: path,
-                type: stringValue(resource.type) ?? "Other",
-                mime_type: stringValue(resource.mimeType) ?? "",
+                type: cdpStringValue(resource.type) ?? "Other",
+                mime_type: cdpStringValue(resource.mimeType) ?? "",
                 content_size: numberValue(resource.contentSize) === undefined
                     ? null
                     : Math.max(0, numberValue(resource.contentSize) ?? 0),
@@ -230,7 +230,7 @@ const captureDom = async (context, completeness) => {
 const mainFilePath = async (result) => {
     const frameTree = recordValue(requiredRecord(result).frameTree);
     const frame = recordValue(frameTree?.frame);
-    return await authorizedElectronFile(stringValue(frame?.url) ?? "");
+    return await authorizedElectronFile(cdpStringValue(frame?.url) ?? "");
 };
 const arrayValue = (value) => Array.isArray(value) ? value : [];
 const stringAt = (strings, value) => strings[integer(value, -1)] ?? "";

package/dist/browser/CdpElectronProvider.js

@@ -1,4 +1,4 @@
-import { electronPageInspectionSchema, electronTargetListSchema, } from "../domain/electronObservation.js";
+import { electronPageInspectionSchema, electronTargetListSchema, } from "../domain/javascript/electronObservation.js";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
@@ -9,11 +9,8 @@ import { closeCdpTargetSession, openCdpTargetSession, } from "./CdpTargetSession
 import { inspectCdpElectronPage } from "./CdpElectronInspection.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
 /** Public identity committed by passive Electron observations. */
-export const CDP_ELECTRON_PROVIDER_IDENTITY = Object.freeze({
-    id: "rea-cdp-electron",
-    name: "REA Electron file-page CDP observation provider",
-    version: "1",
-});
+export { CDP_ELECTRON_PROVIDER_IDENTITY } from "./providerIdentities.js";
+import { CDP_ELECTRON_PROVIDER_IDENTITY } from "./providerIdentities.js";
 const IDENTITY = CDP_ELECTRON_PROVIDER_IDENTITY;
 /** Passive Electron provider for local file pages exposed by loopback CDP. */
 export class CdpElectronProvider {

package/dist/browser/CdpElectronScriptEvents.js

@@ -1,5 +1,5 @@
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { numberValue, recordValue, stringValue } from "./CdpCaptureValues.js";
+import { numberValue, recordValue, cdpStringValue, } from "./CdpCaptureValues.js";
 /** Retain script/frame metadata from passive Electron events. */
 export const ingestElectronScriptEvent = (input) => {
     if (input.event.method === "Runtime.executionContextsCleared") {
@@ -20,8 +20,8 @@ export const ingestElectronScriptEvent = (input) => {
     if (input.event.method !== "Debugger.scriptParsed")
         return;
     const value = recordValue(input.event.params);
-    const scriptId = stringValue(value?.scriptId);
-    const rawUrl = stringValue(value?.url);
+    const scriptId = cdpStringValue(value?.scriptId);
+    const rawUrl = cdpStringValue(value?.url);
     if (scriptId === undefined) {
         input.completeness.exclude("scripts", "invalid_protocol_value");
         return;
@@ -33,10 +33,10 @@ export const ingestElectronScriptEvent = (input) => {
     input.scripts.push({
         scriptId,
         rawUrl,
-        hash: stringValue(value?.hash) ?? "",
+        hash: cdpStringValue(value?.hash) ?? "",
         length: nonnegativeInteger(value?.length),
         isModule: value?.isModule === true,
-        language: stringValue(value?.scriptLanguage) ?? null,
+        language: cdpStringValue(value?.scriptLanguage) ?? null,
         executionContextKey: executionContextKey(value?.executionContextId),
     });
 };
@@ -44,7 +44,7 @@ const retainExecutionContext = (event, frames) => {
     const parameters = recordValue(event.params);
     const runtimeContext = recordValue(parameters?.context);
     const contextKey = executionContextKey(runtimeContext?.id);
-    const frameId = stringValue(recordValue(runtimeContext?.auxData)?.frameId);
+    const frameId = cdpStringValue(recordValue(runtimeContext?.auxData)?.frameId);
     if (contextKey === null || frameId === undefined)
         return;
     frames.set(contextKey, frameId);

package/dist/browser/CdpElectronScripts.js

@@ -1,7 +1,7 @@
 import { canonicalDigest } from "../domain/comparisonSemantics.js";
 import { createWebTextArtifact } from "../domain/webContentArtifact.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { requiredRecord, stringValue } from "./CdpCaptureValues.js";
+import { requiredRecord, cdpStringValue } from "./CdpCaptureValues.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
 /** Normalize local script metadata and optionally approved source. */
 export const captureElectronScripts = async (input) => {
@@ -55,7 +55,7 @@ const captureScriptSource = async (input, script) => {
             },
         };
     const result = requiredRecord(await input.connection.send("Debugger.getScriptSource", { scriptId: script.scriptId }, input.sessionId, input.signal));
-    const text = stringValue(result.scriptSource) ?? "";
+    const text = cdpStringValue(result.scriptSource) ?? "";
     return {
         source: {
             included: true,

package/dist/browser/CdpElectronWorkers.js

@@ -1,5 +1,5 @@
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { recordValue, recordsValue, stringValue } from "./CdpCaptureValues.js";
+import { recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
 /** Inventory local worker targets without attaching to them. */
@@ -15,7 +15,7 @@ export const captureElectronWorkers = async (input) => {
     }
     const workers = [];
     for (const target of recordsValue(recordValue(result)?.targetInfos)) {
-        const type = stringValue(target.type) ?? "";
+        const type = cdpStringValue(target.type) ?? "";
         if (!type.includes("worker"))
             continue;
         const openerTargetId = boundedTargetField(target.openerId);
@@ -25,7 +25,7 @@ export const captureElectronWorkers = async (input) => {
             input.completeness.exclude("workers", "out_of_target_scope");
             continue;
         }
-        const path = await authorizedElectronFile(stringValue(target.url) ?? "");
+        const path = await authorizedElectronFile(cdpStringValue(target.url) ?? "");
         if (path === undefined) {
             input.completeness.exclude("workers", "out_of_target_scope");
             continue;
@@ -47,6 +47,6 @@ export const captureElectronWorkers = async (input) => {
     return workers.sort((left, right) => left.target_id.localeCompare(right.target_id));
 };
 const boundedTargetField = (value) => {
-    const field = stringValue(value);
+    const field = cdpStringValue(value);
     return field === undefined || field === "" ? null : field;
 };

package/dist/browser/CdpObservationSession.js

@@ -3,9 +3,10 @@ import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { CdpConnection } from "./CdpConnection.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
 import { authorizedMainFrame } from "./CdpAuthorizedMainFrame.js";
-import { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, stringValue, } from "./CdpCaptureValues.js";
+import { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, cdpStringValue, } from "./CdpCaptureValues.js";
 import { mainFrameUrl } from "./CdpCaptureDocuments.js";
 import { isMainFrameNavigation } from "./CdpCaptureEventHelpers.js";
+import { cdpTargetEventMatches } from "./CdpTargetEvents.js";
 /** Observe external user actions without rejecting approved same-origin navigation. */
 export const observeCdpSession = async (context) => {
     const allowedOrigins = new Set(context.input.allowed_origins);
@@ -14,7 +15,7 @@ export const observeCdpSession = async (context) => {
         sessionId: context.sessionId,
         signal: context.signal,
         allowedOrigins,
-        delayOperation: "observe_web_session",
+        operation: "observe_web_session",
     });
     const initialUrl = mainFrameUrl(initial) ?? "";
     const mainFrameId = frameId(initial);
@@ -22,7 +23,7 @@ export const observeCdpSession = async (context) => {
         throw new BrowserObservationError("inspect_web_page", "protocol_error");
     const capture = new TimelineCapture(allowedOrigins, mainFrameId, initialUrl);
     const removeListener = context.connection.onEvent((event) => {
-        if (observationEventMatches(event, context.sessionId))
+        if (cdpTargetEventMatches(event, context.sessionId))
             capture.ingest(event);
     });
     const removeDisconnectListener = context.connection.onDisconnect(() => capture.targetTerminated());
@@ -160,7 +161,7 @@ class TimelineCapture {
         this.#add({
             type: "navigation_requested",
             params,
-            rawUrl: stringValue(params.url) ?? null,
+            rawUrl: cdpStringValue(params.url) ?? null,
             requestId: null,
             detail: reason,
         });
@@ -169,7 +170,7 @@ class TimelineCapture {
         const frame = recordValue(params.frame);
         if (!isMainFrameNavigation(event, this.mainFrameId))
             return;
-        const rawUrl = stringValue(frame?.url);
+        const rawUrl = cdpStringValue(frame?.url);
         const destination = scopedUrl(rawUrl, this.allowedOrigins);
         this.#add({
             type: this.#pendingReload ? "same_origin_reload" : "navigation_committed",
@@ -190,7 +191,7 @@ class TimelineCapture {
     #sameDocument(event, params) {
         if (!isMainFrameNavigation(event, this.mainFrameId))
             return;
-        const rawUrl = stringValue(params.url);
+        const rawUrl = cdpStringValue(params.url);
         const destination = scopedUrl(rawUrl, this.allowedOrigins);
         this.#add({
             type: "same_document_navigation",
@@ -208,20 +209,20 @@ class TimelineCapture {
         }
     }
     #redirect(params) {
-        const resourceType = stringValue(params.type);
+        const resourceType = cdpStringValue(params.type);
         if (resourceType !== undefined && resourceType !== "Document")
             return;
-        if (stringValue(params.frameId) !== this.mainFrameId ||
+        if (cdpStringValue(params.frameId) !== this.mainFrameId ||
             recordValue(params.redirectResponse) === undefined)
             return;
         const request = recordValue(params.request);
-        const rawUrl = stringValue(request?.url);
+        const rawUrl = cdpStringValue(request?.url);
         const destination = scopedUrl(rawUrl, this.allowedOrigins);
         this.#add({
             type: "redirect",
             params,
             rawUrl: rawUrl ?? null,
-            requestId: stringValue(params.requestId) ?? null,
+            requestId: cdpStringValue(params.requestId) ?? null,
             detail: null,
         });
         if (destination.scope !== "approved") {
@@ -230,19 +231,19 @@ class TimelineCapture {
         }
     }
     #loadingFailed(params) {
-        const frame = stringValue(params.frameId);
+        const frame = cdpStringValue(params.frameId);
         if (frame !== undefined && frame !== this.mainFrameId)
             return;
         this.#add({
             type: "load_failed",
             params,
             rawUrl: null,
-            requestId: stringValue(params.requestId) ?? null,
+            requestId: cdpStringValue(params.requestId) ?? null,
             detail: safeNetworkError(params.errorText),
         });
     }
     #lifecycle(params) {
-        if (stringValue(params.frameId) !== this.mainFrameId)
+        if (cdpStringValue(params.frameId) !== this.mainFrameId)
             return;
         this.#add({
             type: "lifecycle",
@@ -269,12 +270,6 @@ class TimelineCapture {
         });
     }
 }
-const observationEventMatches = (event, sessionId) => {
-    if (event.method !== "Target.detachedFromTarget")
-        return event.sessionId === sessionId;
-    return (sessionId !== undefined &&
-        stringValue(recordValue(event.params)?.sessionId) === sessionId);
-};
 const waitForWindow = async (durationMs, capture, signal) => await new Promise((resolve, reject) => {
     let settled = false;
     let removeEnd = () => { };
@@ -313,7 +308,7 @@ const captureFinalUrl = async (context, capture, allowedOrigins) => {
     capture.completeness.exclude("timeline", url === undefined ? "invalid_protocol_value" : "out_of_target_scope");
     return "target_left_scope";
 };
-const frameId = (result) => stringValue(recordValue(recordValue(recordValue(result)?.frameTree)?.frame)?.id);
+const frameId = (result) => cdpStringValue(recordValue(recordValue(recordValue(result)?.frameTree)?.frame)?.id);
 const scopedUrl = (value, allowedOrigins) => {
     const allowed = allowedSanitizedUrl(value, allowedOrigins);
     if (allowed !== undefined)
@@ -322,15 +317,15 @@ const scopedUrl = (value, allowedOrigins) => {
         ? { url: null, scope: "outside_policy" }
         : { url: null, scope: "unsupported" };
 };
-const boundedId = (value) => stringValue(value) ?? null;
+const boundedId = (value) => cdpStringValue(value) ?? null;
 const safeDetail = (value) => {
-    const detail = stringValue(value)?.toLowerCase();
+    const detail = cdpStringValue(value)?.toLowerCase();
     return detail !== undefined && /^[a-z0-9_.:-]{1,100}$/u.test(detail)
         ? detail
         : null;
 };
 const safeNetworkError = (value) => {
-    const error = stringValue(value);
+    const error = cdpStringValue(value);
     return error !== undefined && /^net::ERR_[A-Z0-9_]{1,100}$/u.test(error)
         ? error
         : null;