rea-agents 3.1.0 → 3.2.1

package/dist/browser/CdpCaptureValues.js

@@ -17,10 +17,6 @@ export const requiredRecord = (value) => {
         throw new BrowserObservationError("inspect_web_page", "protocol_error");
     return record;
 };
-export const boundedText = (value, maximum = 1_024) => {
-    const text = stringValue(value);
-    return text === undefined ? null : text.slice(0, maximum);
-};
 export const isHttpUrl = (value) => {
     if (value === undefined)
         return false;
@@ -47,22 +43,26 @@ export const sourceResult = (source) => ({
 });
 export const sourceExcluded = (reason) => ({ included: false, reason });
 export const delayWithCancellation = async (durationMs, operation, signal) => {
-    if (durationMs === 0)
-        return;
-    if (signal?.aborted === true)
-        throw new AnalysisCancelledError(operation);
-    await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve();
-        }, durationMs);
-        const onAbort = () => {
-            clearTimeout(timer);
-            signal?.removeEventListener("abort", onAbort);
-            reject(new AnalysisCancelledError(operation));
-        };
-        signal?.addEventListener("abort", onAbort, { once: true });
+    const maximumTimerDelay = 2_147_483_647;
+    let remaining = durationMs;
+    while (remaining > 0) {
         if (signal?.aborted === true)
-            onAbort();
-    });
+            throw new AnalysisCancelledError(operation);
+        const delay = Math.min(remaining, maximumTimerDelay);
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                signal?.removeEventListener("abort", onAbort);
+                resolve();
+            }, delay);
+            const onAbort = () => {
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", onAbort);
+                reject(new AnalysisCancelledError(operation));
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            if (signal?.aborted === true)
+                onAbort();
+        });
+        remaining -= delay;
+    }
 };

package/dist/browser/CdpConnection.js

@@ -1,10 +1,6 @@
 import WebSocket, {} from "ws";
-import { AnalysisCancelledError, AnalysisError, AnalysisTimeoutError, BrowserObservationError, } from "../domain/errors.js";
-const CONNECT_TIMEOUT_MS = 5_000;
-const COMMAND_TIMEOUT_MS = 5_000;
-const MAX_PAYLOAD_BYTES = 16 * 1_024 * 1_024;
-const MAX_PENDING_COMMANDS = 128;
-/** Correlated, bounded JSON-RPC transport for one CDP target operation. */
+import { AnalysisCancelledError, AnalysisError, BrowserObservationError, } from "../domain/errors.js";
+/** Correlated JSON-RPC transport for one CDP target operation. */
 export class CdpConnection {
     socket;
     operation;
@@ -26,8 +22,8 @@ export class CdpConnection {
         if (signal?.aborted === true)
             throw new AnalysisCancelledError(operation);
         const socket = new WebSocket(url, {
-            handshakeTimeout: CONNECT_TIMEOUT_MS,
-            maxPayload: MAX_PAYLOAD_BYTES,
+            handshakeTimeout: 0,
+            maxPayload: 0,
             perMessageDeflate: false,
         });
         await waitForOpen(socket, operation, signal);
@@ -47,14 +43,12 @@ export class CdpConnection {
         this.#disconnectListeners.add(listener);
         return () => this.#disconnectListeners.delete(listener);
     }
-    /** Execute one bounded command, optionally within a flat target session. */
+    /** 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");
-        if (this.#pending.size >= MAX_PENDING_COMMANDS)
-            throw new BrowserObservationError(this.operation, "payload_limit");
         if (signal?.aborted === true)
             throw new AnalysisCancelledError(this.operation);
         const id = this.#nextId;
@@ -64,21 +58,14 @@ export class CdpConnection {
                 const pending = this.#pending.get(id);
                 if (pending === undefined)
                     return;
-                clearTimeout(pending.timer);
                 pending.removeAbort();
                 this.#pending.delete(id);
                 reject(new AnalysisCancelledError(this.operation));
             };
             signal?.addEventListener("abort", onAbort, { once: true });
-            const timer = setTimeout(() => {
-                signal?.removeEventListener("abort", onAbort);
-                this.#pending.delete(id);
-                reject(new AnalysisTimeoutError(this.operation, COMMAND_TIMEOUT_MS));
-            }, COMMAND_TIMEOUT_MS);
             this.#pending.set(id, {
                 resolve,
                 reject,
-                timer,
                 removeAbort: () => signal?.removeEventListener("abort", onAbort),
             });
             this.socket.send(JSON.stringify({
@@ -171,7 +158,6 @@ export class CdpConnection {
         pending.resolve("result" in message ? message.result : {});
     }
     #complete(id, pending) {
-        clearTimeout(pending.timer);
         pending.removeAbort();
         this.#pending.delete(id);
     }
@@ -202,11 +188,6 @@ const rawText = (data) => Array.isArray(data)
         : Buffer.from(data).toString("utf8");
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const waitForOpen = async (socket, operation, signal) => await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-        cleanup();
-        terminateSocket(socket);
-        reject(new AnalysisTimeoutError(operation, CONNECT_TIMEOUT_MS));
-    }, CONNECT_TIMEOUT_MS);
     const onOpen = () => {
         cleanup();
         resolve();
@@ -219,18 +200,22 @@ const waitForOpen = async (socket, operation, signal) => await new Promise((reso
                 cause,
             }));
     };
+    const onClose = (code, reason) => {
+        onFailure(new Error(`CDP WebSocket closed before opening (${code}: ${reason.toString("utf8")})`));
+    };
     const onAbort = () => {
         terminateSocket(socket);
         onFailure(new AnalysisCancelledError(operation));
     };
     const cleanup = () => {
-        clearTimeout(timer);
         socket.off("open", onOpen);
         socket.off("error", onFailure);
+        socket.off("close", onClose);
         signal?.removeEventListener("abort", onAbort);
     };
     socket.once("open", onOpen);
     socket.once("error", onFailure);
+    socket.once("close", onClose);
     signal?.addEventListener("abort", onAbort, { once: true });
     if (signal?.aborted === true)
         onAbort();

package/dist/browser/CdpElectronInspection.js

@@ -1,23 +1,21 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
 import { BrowserObservationError } from "../domain/errors.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
+import { canonicalJsonDigest } from "./CdpCanonicalJsonDigest.js";
 import { delayWithCancellation, numberValue, recordValue, recordsValue, requiredRecord, stringValue, } from "./CdpCaptureValues.js";
 import { ingestElectronScriptEvent, } from "./CdpElectronScriptEvents.js";
 import { captureElectronScripts } from "./CdpElectronScripts.js";
 import { captureElectronWorkers } from "./CdpElectronWorkers.js";
-import { authorizedElectronFile, canonicalElectronRoots, } from "./ElectronFileScope.js";
-/** Passively inspect one root-confined Electron file page. */
+import { authorizedElectronFile } from "./ElectronFileScope.js";
+/** Passively inspect one Electron file page from the selected CDP endpoint. */
 export const inspectCdpElectronPage = async (context) => {
     const state = {
-        roots: await canonicalElectronRoots(context.input.allowed_file_roots),
         completeness: new CdpCaptureCompleteness(),
         scripts: [],
         executionContextFrames: new Map(),
         limitations: [
-            "Only canonical file paths contained by an approved root are retained.",
+            "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.",
-            "Script contents require separate source-capture approval and remain byte bounded.",
+            "Script contents require separate source-capture approval.",
         ],
         mainFrameId: undefined,
         navigationDuringCapture: false,
@@ -54,12 +52,11 @@ const runElectronInspection = async (context, state, startedAt) => {
     await assertStableMainFrame(context, state, main.file_path);
     await report(context.progress, 3, "Electron inspection complete");
     return {
-        schema_version: 1,
         browser: context.discovery.version,
         target: {
             target_id: context.target.id,
             type: context.target.type,
-            title: context.target.title.slice(0, 16_384),
+            title: context.target.title,
             file_path: main.file_path,
             attached: context.target.attached,
         },
@@ -78,26 +75,25 @@ const authorizeInitialFrames = async (context, state) => {
     await report(context.progress, 1, "Authorizing Electron file frames");
     await context.connection.send("Page.enable", {}, context.sessionId, context.signal);
     const result = await context.connection.send("Page.getFrameTree", {}, context.sessionId, context.signal);
-    const frames = await captureFrames(result, state.roots, context.input.limits.max_frames, state.completeness);
+    const frames = await captureFrames(result, state.completeness);
     if (frames[0] === undefined)
         throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
     return frames;
 };
 const enableElectronCapture = async (context) => {
     await context.connection.send("Runtime.enable", {}, context.sessionId, context.signal);
-    await context.connection.send("Debugger.enable", { maxScriptsCacheSize: 4 * 1_024 * 1_024 }, context.sessionId, context.signal);
+    await context.connection.send("Debugger.enable", {}, context.sessionId, context.signal);
 };
 const captureElectronContent = async (context, state, frames) => {
     await report(context.progress, 2, "Capturing Electron structure");
     const frameIds = new Set(frames.map((frame) => frame.frame_id));
-    const resources = await captureResources(context, state.roots, state.completeness);
-    const dom = await captureDom(context, state.roots, state.completeness);
+    const resources = await captureResources(context, state.completeness);
+    const dom = await captureDom(context, state.completeness);
     const scripts = await captureElectronScripts({
         connection: context.connection,
         sessionId: context.sessionId,
         ...(context.signal === undefined ? {} : { signal: context.signal }),
         request: context.input,
-        roots: state.roots,
         scripts: state.scripts,
         executionContextFrames: state.executionContextFrames,
         frameIds,
@@ -108,7 +104,6 @@ const captureElectronContent = async (context, state, frames) => {
         ...(context.signal === undefined ? {} : { signal: context.signal }),
         target: context.target,
         request: context.input,
-        roots: state.roots,
         frameIds,
         completeness: state.completeness,
         limitations: state.limitations,
@@ -117,7 +112,7 @@ const captureElectronContent = async (context, state, frames) => {
 };
 const assertStableMainFrame = async (context, state, expectedPath) => {
     const result = await context.connection.send("Page.getFrameTree", {}, context.sessionId, context.signal);
-    const afterPath = await mainFilePath(result, state.roots);
+    const afterPath = await mainFilePath(result);
     if (afterPath === undefined)
         throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
     if (state.navigationDuringCapture || afterPath !== expectedPath)
@@ -133,7 +128,7 @@ const navigatedFrameId = (event) => {
         return stringValue(params.frameId);
     return undefined;
 };
-const captureFrames = async (result, roots, maximum, completeness) => {
+const captureFrames = async (result, completeness) => {
     const frameTree = recordValue(requiredRecord(result).frameTree);
     if (frameTree === undefined)
         throw new BrowserObservationError("inspect_web_page", "protocol_error");
@@ -145,26 +140,22 @@ const captureFrames = async (result, roots, maximum, completeness) => {
             break;
         const frame = recordValue(current.tree.frame);
         const frameId = stringValue(frame?.id);
-        const path = await authorizedElectronFile(stringValue(frame?.url) ?? "", roots);
+        const path = await authorizedElectronFile(stringValue(frame?.url) ?? "");
         if (frameId === undefined || path === undefined) {
             completeness.exclude("frames", "out_of_target_scope");
             continue;
         }
-        if (frames.length >= maximum) {
-            completeness.truncate("frames");
-            continue;
-        }
         frames.push({
-            frame_id: frameId.slice(0, 256),
+            frame_id: frameId,
             parent_frame_id: current.parent,
             file_path: path,
         });
         for (const child of recordsValue(current.tree.childFrames))
-            pending.push({ tree: child, parent: frameId.slice(0, 256) });
+            pending.push({ tree: child, parent: frameId });
     }
     return frames;
 };
-const captureResources = async (context, roots, completeness) => {
+const captureResources = async (context, completeness) => {
     const result = await context.connection.send("Page.getResourceTree", {}, context.sessionId, context.signal);
     const root = recordValue(requiredRecord(result).frameTree);
     if (root === undefined)
@@ -177,27 +168,23 @@ const captureResources = async (context, roots, completeness) => {
         if (tree === undefined)
             break;
         for (const resource of recordsValue(tree.resources)) {
-            const path = await authorizedElectronFile(stringValue(resource.url) ?? "", roots);
+            const path = await authorizedElectronFile(stringValue(resource.url) ?? "");
             if (path === undefined) {
                 completeness.exclude("resources", "out_of_target_scope");
                 continue;
             }
             const item = {
                 file_path: path,
-                type: (stringValue(resource.type) ?? "Other").slice(0, 100),
-                mime_type: (stringValue(resource.mimeType) ?? "").slice(0, 256),
+                type: stringValue(resource.type) ?? "Other",
+                mime_type: stringValue(resource.mimeType) ?? "",
                 content_size: numberValue(resource.contentSize) === undefined
                     ? null
                     : Math.max(0, numberValue(resource.contentSize) ?? 0),
             };
-            const resourceKey = `electron_resource_${digest(item)}`;
+            const resourceKey = `electron_resource_${canonicalJsonDigest(item)}`;
             if (seen.has(resourceKey))
                 continue;
             seen.add(resourceKey);
-            if (resources.length >= context.input.limits.max_resources) {
-                completeness.truncate("resources");
-                continue;
-            }
             resources.push({
                 resource_key: resourceKey,
                 ...item,
@@ -207,7 +194,7 @@ const captureResources = async (context, roots, completeness) => {
     }
     return resources.sort((left, right) => left.resource_key.localeCompare(right.resource_key));
 };
-const captureDom = async (context, roots, completeness) => {
+const captureDom = async (context, completeness) => {
     const result = requiredRecord(await context.connection.send("DOMSnapshot.captureSnapshot", { computedStyles: [], includePaintOrder: false, includeDOMRects: false }, context.sessionId, context.signal));
     const strings = Array.isArray(result.strings)
         ? result.strings.map((value) => (typeof value === "string" ? value : ""))
@@ -216,7 +203,7 @@ const captureDom = async (context, roots, completeness) => {
     let total = 0;
     for (const document of recordsValue(result.documents)) {
         const documentUrl = stringAt(strings, document.documentURL);
-        if ((await authorizedElectronFile(documentUrl, roots)) === undefined) {
+        if ((await authorizedElectronFile(documentUrl)) === undefined) {
             completeness.exclude("dom", "out_of_target_scope");
             continue;
         }
@@ -229,31 +216,26 @@ const captureDom = async (context, roots, completeness) => {
         const baseIndex = nodes.length;
         total += nodeTypes.length;
         for (let index = 0; index < nodeTypes.length; index += 1) {
-            if (nodes.length >= context.input.limits.max_dom_nodes)
-                continue;
             const attributeIndexes = arrayValue(attributes[index]);
             const parent = integer(parents[index], -1);
             nodes.push({
                 index: nodes.length,
                 parent_index: parent < 0 ? -1 : baseIndex + parent,
                 node_type: integer(nodeTypes[index], 0),
-                node_name: stringAt(strings, nodeNames[index]).slice(0, 1_024),
+                node_name: stringAt(strings, nodeNames[index]),
                 node_value_length: Buffer.byteLength(stringAt(strings, nodeValues[index])),
                 attribute_names: attributeIndexes
                     .filter((_value, attributeIndex) => attributeIndex % 2 === 0)
-                    .map((value) => stringAt(strings, value).slice(0, 1_024))
-                    .slice(0, 256),
+                    .map((value) => stringAt(strings, value)),
             });
         }
     }
-    if (total > nodes.length)
-        completeness.truncate("dom");
     return { total_nodes: total, nodes };
 };
-const mainFilePath = async (result, roots) => {
+const mainFilePath = async (result) => {
     const frameTree = recordValue(requiredRecord(result).frameTree);
     const frame = recordValue(frameTree?.frame);
-    return await authorizedElectronFile(stringValue(frame?.url) ?? "", roots);
+    return await authorizedElectronFile(stringValue(frame?.url) ?? "");
 };
 const arrayValue = (value) => Array.isArray(value) ? value : [];
 const stringAt = (strings, value) => strings[integer(value, -1)] ?? "";
@@ -261,12 +243,6 @@ const integer = (value, fallback) => {
     const number = numberValue(value);
     return number === undefined ? fallback : Math.trunc(number);
 };
-const digest = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Expected canonical JSON");
-    return createHash("sha256").update(encoded).digest("hex");
-};
 const report = async (progress, completed, message) => await progress?.report({
     phase: "browser_observation",
     completed,

package/dist/browser/CdpElectronProvider.js

@@ -4,7 +4,7 @@ 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, canonicalElectronRoots, } from "./ElectronFileScope.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",
@@ -12,17 +12,15 @@ export const CDP_ELECTRON_PROVIDER_IDENTITY = Object.freeze({
     version: "1",
 });
 const IDENTITY = CDP_ELECTRON_PROVIDER_IDENTITY;
-/** Passive Electron provider with canonical file-root confinement. */
+/** Passive Electron provider for local file pages exposed by loopback CDP. */
 export class CdpElectronProvider {
     identity() {
         return IDENTITY;
     }
     async listTargets(input, options = {}) {
         try {
-            const roots = await canonicalElectronRoots(input.allowed_file_roots);
             const discovery = await discoverCdpEndpoint(input.cdp_endpoint, "list_electron_targets", options.signal);
             const allowed = [];
-            let outsideRoot = 0;
             let unsupportedUrl = 0;
             let nonPage = 0;
             let unconnectable = 0;
@@ -31,12 +29,9 @@ export class CdpElectronProvider {
                     nonPage += 1;
                     continue;
                 }
-                const path = await authorizedElectronFile(target.url, roots);
+                const path = await authorizedElectronFile(target.url);
                 if (path === undefined) {
-                    if (isFileUrl(target.url))
-                        outsideRoot += 1;
-                    else
-                        unsupportedUrl += 1;
+                    unsupportedUrl += 1;
                     continue;
                 }
                 if (!hasCdpTargetWebSocket(discovery, target)) {
@@ -46,32 +41,21 @@ export class CdpElectronProvider {
                 allowed.push({
                     target_id: target.id,
                     type: target.type,
-                    title: target.title.slice(0, 16_384),
+                    title: target.title,
                     file_path: path,
                     attached: target.attached,
                 });
             }
             allowed.sort((left, right) => left.target_id.localeCompare(right.target_id));
-            const items = allowed.slice(input.offset, input.offset + input.limit);
-            const next = input.offset + items.length;
             return ok(electronTargetListSchema.parse({
-                schema_version: 1,
                 browser: discovery.version,
-                targets: {
-                    items,
-                    offset: input.offset,
-                    limit: input.limit,
-                    total: allowed.length,
-                    next_offset: next < allowed.length ? next : null,
-                    has_more: next < allowed.length,
-                },
+                targets: allowed,
                 excluded: {
-                    outside_root: outsideRoot,
                     unsupported_url: unsupportedUrl,
                     non_page: nonPage,
                 },
                 limitations: [
-                    "Only page targets whose canonical file path is contained by an approved root are listed.",
+                    "Every local file page exposed by the selected loopback CDP endpoint is eligible for listing.",
                     ...(unconnectable === 0
                         ? []
                         : [
@@ -87,9 +71,8 @@ export class CdpElectronProvider {
     async inspectPage(input, options = {}) {
         let targetSession;
         try {
-            const roots = await canonicalElectronRoots(input.allowed_file_roots);
             const discovery = await discoverCdpEndpoint(input.cdp_endpoint, "inspect_electron_page", options.signal);
-            const target = await authorizeTarget(discovery.targets, input.target_id, roots);
+            const target = await authorizeTarget(discovery.targets, input.target_id);
             targetSession = await openCdpTargetSession(discovery, target, "inspect_electron_page", options.signal);
             return ok(electronPageInspectionSchema.parse(await inspectCdpElectronPage({
                 connection: targetSession.connection,
@@ -116,23 +99,15 @@ export class CdpElectronProvider {
         }
     }
 }
-const authorizeTarget = async (targets, targetId, roots) => {
+const authorizeTarget = async (targets, targetId) => {
     const target = targets.find(({ id }) => id === targetId);
     if (target === undefined)
         throw new BrowserObservationError("inspect_web_page", "target_not_found");
     if (target.type !== "page" ||
-        (await authorizedElectronFile(target.url, roots)) === undefined)
+        (await authorizedElectronFile(target.url)) === undefined)
         throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
     return target;
 };
-const isFileUrl = (value) => {
-    try {
-        return new URL(value).protocol === "file:";
-    }
-    catch {
-        return false;
-    }
-};
 const providerError = (cause, operation) => cause instanceof BrowserObservationError && cause.operation !== operation
     ? new BrowserObservationError(operation, cause.reason, { cause })
     : cause instanceof AnalysisError

package/dist/browser/CdpElectronScriptEvents.js

@@ -1,6 +1,6 @@
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { boundedText, numberValue, recordValue, stringValue, } from "./CdpCaptureValues.js";
-/** Retain only bounded script/frame metadata from passive Electron events. */
+import { numberValue, recordValue, stringValue } from "./CdpCaptureValues.js";
+/** Retain script/frame metadata from passive Electron events. */
 export const ingestElectronScriptEvent = (input) => {
     if (input.event.method === "Runtime.executionContextsCleared") {
         input.executionContextFrames.clear();
@@ -14,7 +14,7 @@ export const ingestElectronScriptEvent = (input) => {
         return;
     }
     if (input.event.method === "Runtime.executionContextCreated") {
-        retainExecutionContext(input.event, input.executionContextFrames, input.completeness);
+        retainExecutionContext(input.event, input.executionContextFrames);
         return;
     }
     if (input.event.method !== "Debugger.scriptParsed")
@@ -22,7 +22,7 @@ export const ingestElectronScriptEvent = (input) => {
     const value = recordValue(input.event.params);
     const scriptId = stringValue(value?.scriptId);
     const rawUrl = stringValue(value?.url);
-    if (scriptId === undefined || scriptId.length > 256) {
+    if (scriptId === undefined) {
         input.completeness.exclude("scripts", "invalid_protocol_value");
         return;
     }
@@ -30,31 +30,23 @@ export const ingestElectronScriptEvent = (input) => {
         input.completeness.exclude("scripts", "unattributed_origin");
         return;
     }
-    if (input.scripts.length >= 2_000) {
-        input.completeness.drop("scripts");
-        return;
-    }
     input.scripts.push({
         scriptId,
         rawUrl,
-        hash: (stringValue(value?.hash) ?? "").slice(0, 512),
+        hash: stringValue(value?.hash) ?? "",
         length: nonnegativeInteger(value?.length),
         isModule: value?.isModule === true,
-        language: boundedText(value?.scriptLanguage, 100),
+        language: stringValue(value?.scriptLanguage) ?? null,
         executionContextKey: executionContextKey(value?.executionContextId),
     });
 };
-const retainExecutionContext = (event, frames, completeness) => {
+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);
-    if (contextKey === null || frameId === undefined || frameId.length > 256)
+    if (contextKey === null || frameId === undefined)
         return;
-    if (frames.size >= 2_000 && !frames.has(contextKey)) {
-        completeness.truncate("scripts");
-        return;
-    }
     frames.set(contextKey, frameId);
 };
 const nonnegativeInteger = (value) => {

package/dist/browser/CdpElectronScripts.js

@@ -1,17 +1,15 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
 import { createWebTextArtifact } from "../domain/webContentArtifact.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
+import { canonicalJsonDigest } from "./CdpCanonicalJsonDigest.js";
 import { requiredRecord, stringValue } from "./CdpCaptureValues.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
-/** Normalize root-confined script metadata and optionally approved source. */
+/** Normalize local script metadata and optionally approved source. */
 export const captureElectronScripts = async (input) => {
     let total = 0;
-    let sourceBytes = 0;
     const items = [];
     const seen = new Set();
     for (const script of input.scripts) {
-        const path = await authorizedElectronFile(script.rawUrl, input.roots);
+        const path = await authorizedElectronFile(script.rawUrl);
         if (path === undefined) {
             input.completeness.exclude("scripts", "out_of_target_scope");
             continue;
@@ -29,17 +27,12 @@ export const captureElectronScripts = async (input) => {
             is_module: script.isModule,
             language: script.language,
         };
-        const scriptKey = `electron_script_${digest(identity)}`;
+        const scriptKey = `electron_script_${canonicalJsonDigest(identity)}`;
         if (seen.has(scriptKey))
             continue;
         seen.add(scriptKey);
         total += 1;
-        if (items.length >= input.request.limits.max_scripts) {
-            input.completeness.drop("scripts");
-            continue;
-        }
-        const capturedSource = await captureScriptSource(input, script, sourceBytes);
-        sourceBytes += capturedSource.bytes;
+        const capturedSource = await captureScriptSource(input, script);
         items.push({
             script_key: scriptKey,
             ...identity,
@@ -53,42 +46,20 @@ export const captureElectronScripts = async (input) => {
         items: items.sort((left, right) => left.script_key.localeCompare(right.script_key)),
     };
 };
-const captureScriptSource = async (input, script, sourceBytes) => {
+const captureScriptSource = async (input, script) => {
     if (!input.request.include_script_sources)
         return {
             source: {
                 included: false,
                 reason: "source capture was not approved",
             },
-            bytes: 0,
         };
-    if (sourceLimitReached(input.request.limits, script.length, sourceBytes))
-        return sourceLimitResult(input.completeness);
     const result = requiredRecord(await input.connection.send("Debugger.getScriptSource", { scriptId: script.scriptId }, input.sessionId, input.signal));
     const text = stringValue(result.scriptSource) ?? "";
-    const bytes = Buffer.byteLength(text);
-    if (sourceLimitReached(input.request.limits, bytes, sourceBytes))
-        return sourceLimitResult(input.completeness);
     return {
         source: {
             included: true,
             artifact: createWebTextArtifact(text, "text/javascript"),
         },
-        bytes,
-    };
-};
-const sourceLimitReached = (limits, bytes, previousBytes) => bytes > limits.max_script_source_bytes ||
-    previousBytes + bytes > limits.max_total_script_source_bytes;
-const sourceLimitResult = (completeness) => {
-    completeness.truncate("script_sources");
-    return {
-        source: { included: false, reason: "script source byte limit reached" },
-        bytes: 0,
     };
 };
-const digest = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Expected canonical JSON");
-    return createHash("sha256").update(encoded).digest("hex");
-};