rea-agents 3.0.0 → 3.2.0

package/dist/browser/CdpCaptureStorageFingerprints.js

@@ -3,14 +3,11 @@ import canonicalize from "canonicalize";
 import { CdpConnection } from "./CdpConnection.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 import { recordValue, recordsValue, stringValue } from "./CdpCaptureValues.js";
-const MAX_CACHE_BODY_BYTES = 64 * 1_024;
 /** Capture stable hashes of approved storage content without returning values. */
 export const captureStorageFingerprints = async ({ context, origin, local, session, indexedDbNames, caches, limitations, }) => {
     const state = {
         items: [],
-        maximum: context.input.limits.max_storage_keys,
         complete: local.complete && session.complete,
-        truncated: false,
     };
     const run = { context, limitations, state };
     addStorageItems(state, "local_storage", local.items);
@@ -19,13 +16,8 @@ export const captureStorageFingerprints = async ({ context, origin, local, sessi
     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}`));
-    return {
-        items: state.items,
-        complete: state.complete &&
-            !state.truncated &&
-            state.items.every(({ complete }) => complete),
-        truncated: state.truncated,
-    };
+    const complete = state.complete && state.items.every(({ complete }) => complete);
+    return { items: state.items, complete };
 };
 const addStorageItems = (state, scope, items) => {
     for (const item of items)
@@ -77,10 +69,6 @@ const addCookies = async (run, origin) => {
 };
 const addIndexedDb = async (run, origin, names) => {
     for (const databaseName of names) {
-        if (run.state.items.length >= run.state.maximum) {
-            run.state.truncated = true;
-            return;
-        }
         const raw = await optionalCdpCommand(run.context, "IndexedDB.requestDatabase", { securityOrigin: origin, databaseName }, run.limitations);
         const database = recordValue(recordValue(raw)?.databaseWithObjectStores);
         if (raw === undefined || database === undefined) {
@@ -139,76 +127,88 @@ const indexedDbSchemaComplete = (stores) => stores.every((store) => stringValue(
         typeof index.unique === "boolean" &&
         typeof index.multiEntry === "boolean"));
 const addIndexedDbRecords = async (run, input) => {
-    const remaining = run.state.maximum - run.state.items.length;
-    if (remaining <= 0) {
-        run.state.truncated = true;
-        return;
-    }
-    const raw = await optionalCdpCommand(run.context, "IndexedDB.requestData", {
-        securityOrigin: input.origin,
-        databaseName: input.databaseName,
-        objectStoreName: input.objectStoreName,
-        indexName: "",
-        skipCount: 0,
-        pageSize: remaining,
-    }, run.limitations);
-    const result = recordValue(raw);
-    if (raw === undefined || result === undefined) {
-        run.state.complete = false;
-        return;
-    }
-    if (!Array.isArray(result.objectStoreDataEntries) ||
-        typeof result.hasMore !== "boolean") {
-        run.state.complete = false;
-        return;
-    }
-    const entries = recordsValue(result.objectStoreDataEntries);
-    if (entries.length !== result.objectStoreDataEntries.length)
-        run.state.complete = false;
-    for (const entry of entries) {
-        const key = stableValue(entry.key);
-        const primaryKey = stableValue(entry.primaryKey);
-        const value = stableValue(entry.value);
-        addFingerprint(run.state, {
-            scope: "indexed_db_record",
-            identity: {
-                database: input.databaseName,
-                store: input.objectStoreName,
-                key,
-                primaryKey,
-            },
-            value,
-            complete: remoteObjectComplete(entry.value),
-        });
-    }
-    if (result.hasMore === true || entries.length > remaining)
-        run.state.truncated = true;
-};
-const addCaches = async (run, caches) => {
-    for (const cache of caches) {
-        const remaining = run.state.maximum - run.state.items.length;
-        if (remaining <= 0) {
-            run.state.truncated = true;
-            return;
-        }
-        const raw = await optionalCdpCommand(run.context, "CacheStorage.requestEntries", { cacheId: cache.id, skipCount: 0, pageSize: remaining }, run.limitations);
+    let skipCount = 0;
+    while (true) {
+        const raw = await optionalCdpCommand(run.context, "IndexedDB.requestData", {
+            securityOrigin: input.origin,
+            databaseName: input.databaseName,
+            objectStoreName: input.objectStoreName,
+            indexName: "",
+            skipCount,
+            pageSize: STORAGE_ENTRY_PAGE_SIZE,
+        }, run.limitations);
         const result = recordValue(raw);
         if (raw === undefined || result === undefined) {
             run.state.complete = false;
-            continue;
+            return;
         }
-        if (!Array.isArray(result.cacheDataEntries) ||
-            typeof result.returnCount !== "number") {
+        if (!Array.isArray(result.objectStoreDataEntries) ||
+            typeof result.hasMore !== "boolean") {
             run.state.complete = false;
-            continue;
+            return;
+        }
+        const entries = recordsValue(result.objectStoreDataEntries);
+        if (entries.length !== result.objectStoreDataEntries.length)
+            run.state.complete = false;
+        for (const entry of entries) {
+            const key = stableValue(entry.key);
+            const primaryKey = stableValue(entry.primaryKey);
+            const value = stableValue(entry.value);
+            addFingerprint(run.state, {
+                scope: "indexed_db_record",
+                identity: {
+                    database: input.databaseName,
+                    store: input.objectStoreName,
+                    key,
+                    primaryKey,
+                },
+                value,
+                complete: remoteObjectComplete(entry.value),
+            });
         }
-        const entries = recordsValue(result.cacheDataEntries);
-        if (entries.length !== result.cacheDataEntries.length)
+        if (result.hasMore !== true)
+            return;
+        if (entries.length === 0 ||
+            skipCount > Number.MAX_SAFE_INTEGER - entries.length) {
             run.state.complete = false;
-        for (const entry of entries)
-            await addCacheEntry(run, cache, entry);
-        if (result.returnCount > entries.length)
-            run.state.truncated = true;
+            return;
+        }
+        skipCount += entries.length;
+    }
+};
+const addCaches = async (run, caches) => {
+    for (const cache of caches) {
+        let skipCount = 0;
+        let returnCount;
+        while (returnCount === undefined || skipCount < returnCount) {
+            const raw = await optionalCdpCommand(run.context, "CacheStorage.requestEntries", { cacheId: cache.id, skipCount, pageSize: STORAGE_ENTRY_PAGE_SIZE }, run.limitations);
+            const result = recordValue(raw);
+            if (raw === undefined || result === undefined) {
+                run.state.complete = false;
+                break;
+            }
+            if (!Array.isArray(result.cacheDataEntries) ||
+                typeof result.returnCount !== "number" ||
+                !Number.isSafeInteger(result.returnCount) ||
+                result.returnCount < 0) {
+                run.state.complete = false;
+                break;
+            }
+            const entries = recordsValue(result.cacheDataEntries);
+            if (entries.length !== result.cacheDataEntries.length)
+                run.state.complete = false;
+            for (const entry of entries)
+                await addCacheEntry(run, cache, entry);
+            returnCount = result.returnCount;
+            if (skipCount + entries.length >= returnCount)
+                break;
+            if (entries.length === 0 ||
+                skipCount > Number.MAX_SAFE_INTEGER - entries.length) {
+                run.state.complete = false;
+                break;
+            }
+            skipCount += entries.length;
+        }
     }
 };
 const addCacheEntry = async (run, cache, entry) => {
@@ -236,7 +236,7 @@ const addCacheEntry = async (run, cache, entry) => {
     const raw = await optionalCdpCommand(run.context, "CacheStorage.requestCachedResponse", { cacheId: cache.id, requestURL, requestHeaders }, run.limitations);
     const body = stringValue(recordValue(recordValue(raw)?.response)?.body);
     const decoded = body === undefined ? null : decodeBase64(body);
-    const complete = decoded !== null && decoded.byteLength <= MAX_CACHE_BODY_BYTES;
+    const complete = decoded !== null;
     if (!complete)
         run.state.complete = false;
     addFingerprint(run.state, {
@@ -247,10 +247,6 @@ const addCacheEntry = async (run, cache, entry) => {
     });
 };
 const addFingerprint = (state, input) => {
-    if (state.items.length >= state.maximum) {
-        state.truncated = true;
-        return;
-    }
     state.items.push({
         scope: input.scope,
         identity_sha256: digest(input.identity),
@@ -260,6 +256,7 @@ const addFingerprint = (state, input) => {
             stableValueComplete(input.value),
     });
 };
+const STORAGE_ENTRY_PAGE_SIZE = 1_000;
 const digest = (value) => createHash("sha256").update(encodedValue(value)).digest("hex");
 const encodedValue = (value) => {
     if (value instanceof Uint8Array)
@@ -269,26 +266,23 @@ const encodedValue = (value) => {
         throw new TypeError("Expected canonical JSON");
     return encoded;
 };
-const stableValue = (value, depth = 0) => {
+const stableValue = (value) => {
     if (value === null ||
         typeof value === "string" ||
         typeof value === "number" ||
         typeof value === "boolean")
         return value;
-    if (depth >= 8)
-        return "<depth-limit>";
     if (Array.isArray(value))
-        return value.slice(0, 64).map((item) => stableValue(item, depth + 1));
+        return value.map((item) => stableValue(item));
     const record = recordValue(value);
     if (record === undefined)
         return String(value);
     return Object.fromEntries(Object.entries(record)
         .filter(([key]) => key !== "objectId" && key !== "customPreview")
         .sort(([left], [right]) => compareCodePoints(left, right))
-        .slice(0, 64)
-        .map(([key, item]) => [key, stableValue(item, depth + 1)]));
+        .map(([key, item]) => [key, stableValue(item)]));
 };
-const stableValueComplete = (value, depth = 0) => {
+const stableValueComplete = (value) => {
     if (value instanceof Uint8Array)
         return true;
     if (value === null ||
@@ -297,17 +291,13 @@ const stableValueComplete = (value, depth = 0) => {
         typeof value === "number" ||
         typeof value === "boolean")
         return true;
-    if (depth >= 8)
-        return false;
     if (Array.isArray(value))
-        return (value.length <= 64 &&
-            value.every((item) => stableValueComplete(item, depth + 1)));
+        return value.every((item) => stableValueComplete(item));
     const record = recordValue(value);
     if (record === undefined)
         return false;
     const entries = Object.entries(record).filter(([key]) => key !== "objectId" && key !== "customPreview");
-    return (entries.length <= 64 &&
-        entries.every(([, item]) => stableValueComplete(item, depth + 1)));
+    return entries.every(([, item]) => stableValueComplete(item));
 };
 const remoteObjectComplete = (value) => {
     const record = recordValue(value);

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,
@@ -44,7 +42,9 @@ export const inspectCdpElectronPage = async (context) => {
 };
 const runElectronInspection = async (context, state, startedAt) => {
     const frames = await authorizeInitialFrames(context, state);
-    const main = frames[0];
+    const main = frames.at(0);
+    if (main === undefined)
+        throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
     state.mainFrameId = main.frame_id;
     await enableElectronCapture(context);
     await delayWithCancellation(context.input.observation_ms, "inspect_electron_page", context.signal);
@@ -52,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,
         },
@@ -76,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,
@@ -106,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,
@@ -115,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)
@@ -131,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");
@@ -143,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)
@@ -175,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,
@@ -205,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 : ""))
@@ -214,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;
         }
@@ -227,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)] ?? "";
@@ -259,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,