rea-agents 3.1.0 → 3.2.0

package/dist/browser/CdpCaptureEventHandlers.js

@@ -1,7 +1,7 @@
 import { inferJsonShape } from "../domain/jsonShape.js";
 import { safeResponseMetadata } from "./CdpSafeMetadata.js";
-import { boundedSensitiveText } from "./SensitiveTextCapture.js";
-import { allowedSanitizedUrl, boundedText, isHttpUrl, numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
+import { redactSensitiveText } from "./SensitiveTextCapture.js";
+import { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
 import { requestBodyShape } from "./CdpCaptureEventBodyShapes.js";
 import { consolePrimitive, decodeBase64, exclusionReasonForUrl, executionContextKey, firstCallFrame, initiatorLocation, integerOrNull, } from "./CdpCaptureEventHelpers.js";
 export const handleExecutionContextCreated = (state, params) => {
@@ -10,15 +10,9 @@ export const handleExecutionContextCreated = (state, params) => {
     const frameId = stringValue(recordValue(context?.auxData)?.frameId);
     if (identifier === undefined ||
         !Number.isSafeInteger(identifier) ||
-        frameId === undefined ||
-        frameId.length > 256)
+        frameId === undefined)
         return;
     const key = String(identifier);
-    if (state.executionContextFrames.size >= state.input.limits.max_scripts &&
-        !state.executionContextFrames.has(key)) {
-        state.completeness.truncate("scripts");
-        return;
-    }
     state.executionContextFrames.set(key, frameId);
 };
 export const handleExecutionContextDestroyed = (state, params) => {
@@ -30,7 +24,7 @@ export const handleScriptParsed = (state, params) => {
     const scriptId = stringValue(params.scriptId);
     const rawUrl = stringValue(params.url) ?? "";
     const sanitized = allowedSanitizedUrl(rawUrl, state.allowedOrigins);
-    if (scriptId === undefined || scriptId.length > 256) {
+    if (scriptId === undefined) {
         state.completeness.exclude("scripts", "invalid_protocol_value");
         return;
     }
@@ -38,21 +32,16 @@ export const handleScriptParsed = (state, params) => {
         state.completeness.exclude("scripts", exclusionReasonForUrl(rawUrl));
         return;
     }
-    if (state.scripts.size >= state.input.limits.max_scripts &&
-        !state.scripts.has(scriptId)) {
-        state.completeness.drop("scripts");
-        return;
-    }
     const sourceMap = sourceMapForScript(params.sourceMapURL, rawUrl, state);
     const script = {
         scriptId,
         rawUrl,
         url: sanitized.url,
         origin: sanitized.origin,
-        hash: (stringValue(params.hash) ?? "").slice(0, 512),
+        hash: stringValue(params.hash) ?? "",
         length: Math.max(0, Math.min(Number.MAX_SAFE_INTEGER, Math.trunc(numberValue(params.length) ?? 0))),
         isModule: params.isModule === true,
-        language: boundedText(params.scriptLanguage, 100),
+        language: stringValue(params.scriptLanguage) ?? null,
         sourceMapUrl: sourceMap.sanitized,
         sourceMapRawUrl: sourceMap.raw,
         executionContextKey: executionContextKey(params.executionContextId),
@@ -80,7 +69,7 @@ const sourceMapForScript = (value, scriptUrl, state) => {
 export const handleRequestWillBeSent = (state, params) => {
     const requestId = stringValue(params.requestId);
     const request = recordValue(params.request);
-    if (requestId === undefined || requestId.length > 256) {
+    if (requestId === undefined) {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         return;
     }
@@ -95,11 +84,6 @@ export const handleRequestWillBeSent = (state, params) => {
         state.network.delete(requestId);
         return;
     }
-    if (state.network.size >= state.input.limits.max_network_events &&
-        !state.network.has(requestId)) {
-        state.completeness.drop("network_requests");
-        return;
-    }
     const initiator = recordValue(params.initiator);
     const initiatorFrame = initiatorLocation(initiator);
     const rawInitiatorUrl = stringValue(initiatorFrame?.url);
@@ -110,13 +94,13 @@ export const handleRequestWillBeSent = (state, params) => {
         request_id: requestId,
         url: sanitized.url,
         origin: sanitized.origin ?? "",
-        method: (stringValue(request.method) ?? "GET").slice(0, 32),
-        resource_type: boundedText(params.type, 100),
+        method: stringValue(request.method) ?? "GET",
+        resource_type: stringValue(params.type) ?? null,
         status: null,
         mime_type: null,
         encoded_data_length: null,
         initiator: {
-            type: (stringValue(initiator?.type) ?? "other").slice(0, 100),
+            type: stringValue(initiator?.type) ?? "other",
             url: initiatorUrl?.url ?? null,
             line: integerOrNull(initiatorFrame?.lineNumber),
             column: integerOrNull(initiatorFrame?.columnNumber),
@@ -126,7 +110,7 @@ export const handleRequestWillBeSent = (state, params) => {
 };
 export const handleResponseReceived = (state, params) => {
     const requestId = stringValue(params.requestId);
-    if (requestId === undefined || requestId.length > 256) {
+    if (requestId === undefined) {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         return;
     }
@@ -145,19 +129,15 @@ export const handleResponseReceived = (state, params) => {
     state.network.set(requestId, {
         ...current,
         status: numberValue(response.status) ?? null,
-        mime_type: boundedText(response.mimeType, 256),
+        mime_type: stringValue(response.mimeType) ?? null,
     });
-    if (state.responseMetadata.length >= state.input.limits.max_network_events) {
-        state.completeness.truncate("metadata");
-        return;
-    }
     const metadata = safeResponseMetadata(requestId, sanitized.url, response, state.allowedOrigins);
     state.responseMetadata.push(metadata.response);
     state.agentHints.push(...metadata.agentHints);
 };
 export const handleLoadingFinished = (state, params) => {
     const requestId = stringValue(params.requestId);
-    if (requestId === undefined || requestId.length > 256)
+    if (requestId === undefined)
         return;
     const current = state.network.get(requestId);
     if (current === undefined)
@@ -178,17 +158,11 @@ export const handleConsoleAPICalled = (state, params) => {
         state.completeness.exclude("console_events", exclusionReasonForUrl(stringValue(frame.url)));
         return;
     }
-    if (state.console.length >= state.input.limits.max_console_events) {
-        state.completeness.drop("console_events");
-        return;
-    }
     const arguments_ = recordsValue(params.args);
     state.console.push({
-        type: (stringValue(params.type) ?? "unknown").slice(0, 100),
+        type: stringValue(params.type) ?? "unknown",
         timestamp: numberValue(params.timestamp) ?? 0,
-        argument_types: arguments_
-            .map((argument) => (stringValue(argument.type) ?? "unknown").slice(0, 100))
-            .slice(0, 100),
+        argument_types: arguments_.map((argument) => stringValue(argument.type) ?? "unknown"),
         url: source.url,
         line: integerOrNull(frame.lineNumber),
         column: integerOrNull(frame.columnNumber),
@@ -201,50 +175,32 @@ const captureConsoleText = (state, arguments_) => {
             status: "not_approved",
             values: [],
             retained_bytes: 0,
-            truncated_values: 0,
         };
     const values = [];
     let retainedBytes = 0;
-    let truncatedValues = 0;
     for (const [argumentIndex, argument] of arguments_.entries()) {
         const primitive = consolePrimitive(argument);
         if (primitive === undefined)
             continue;
-        const remaining = state.input.limits.max_total_console_text_bytes - state.consoleTextBytes;
-        if (remaining <= 0) {
-            truncatedValues += 1;
-            continue;
-        }
-        const bounded = boundedSensitiveText(primitive.text, Math.min(state.input.limits.max_console_text_field_bytes, remaining));
+        const text = redactSensitiveText(primitive.text);
         values.push({
             argument_index: argumentIndex,
             type: primitive.type,
-            text: bounded.text,
+            text,
         });
-        retainedBytes += bounded.bytes;
-        state.consoleTextBytes += bounded.bytes;
-        if (bounded.truncated)
-            truncatedValues += 1;
+        retainedBytes += Buffer.byteLength(text);
     }
-    if (truncatedValues > 0)
-        state.completeness.truncate("console_text");
     return {
-        status: truncatedValues > 0 ? "truncated" : "included",
+        status: "included",
         values,
         retained_bytes: retainedBytes,
-        truncated_values: truncatedValues,
     };
 };
 export const handleWebSocketFrame = (state, params, direction) => {
     const requestId = stringValue(params.requestId);
     if (requestId === undefined ||
-        requestId.length > 256 ||
         (!state.network.has(requestId) && !state.allowedWebSockets.has(requestId)))
         return;
-    if (state.websockets.length >= state.input.limits.max_websocket_events) {
-        state.completeness.drop("websocket_frames");
-        return;
-    }
     const response = recordValue(params.response);
     const payload = stringValue(response?.payloadData) ?? "";
     const opcode = Math.max(0, Math.trunc(numberValue(response?.opcode) ?? 0));
@@ -263,33 +219,17 @@ const captureWebSocketShape = (state, payload, opcode) => {
     if (!state.input.include_websocket_shapes)
         return null;
     if (opcode !== 1)
-        return { format: "binary", json_shape: null, truncated: false };
-    const bytes = Buffer.byteLength(payload);
-    const remaining = state.input.limits.max_total_websocket_shape_bytes -
-        state.websocketShapeBytes;
-    if (bytes > state.input.limits.max_websocket_shape_bytes ||
-        bytes > remaining) {
-        state.completeness.truncate("websocket_shapes");
-        return { format: "text", json_shape: null, truncated: true };
-    }
-    state.websocketShapeBytes += bytes;
-    const shape = inferJsonShape(payload, {
-        maximumBytes: state.input.limits.max_websocket_shape_bytes,
-        maximumNodes: state.input.limits.max_json_shape_nodes,
-        maximumDepth: state.input.limits.max_json_shape_depth,
-    });
-    if (shape?.truncated === true)
-        state.completeness.truncate("websocket_shapes");
+        return { format: "binary", json_shape: null };
+    const shape = inferJsonShape(payload);
     return {
         format: shape === null ? "text" : "json",
         json_shape: shape,
-        truncated: shape?.truncated === true,
     };
 };
 export const handleWebSocketCreated = (state, params) => {
     const requestId = stringValue(params.requestId);
     const rawUrl = stringValue(params.url);
-    if (requestId === undefined || requestId.length > 256) {
+    if (requestId === undefined) {
         state.completeness.exclude("websocket_connections", "invalid_protocol_value");
         return;
     }
@@ -317,11 +257,6 @@ export const handleWebSocketCreated = (state, params) => {
         state.completeness.exclude("websocket_connections", "disallowed_origin");
         return;
     }
-    if (!state.allowedWebSockets.has(requestId) &&
-        state.allowedWebSockets.size >= state.input.limits.max_websocket_events) {
-        state.completeness.drop("websocket_connections");
-        return;
-    }
     state.allowedWebSockets.add(requestId);
 };
 export const handleFrameNavigated = (state, params) => {

package/dist/browser/CdpCaptureEvents.js

@@ -4,7 +4,7 @@ import * as handlers from "./CdpCaptureEventHandlers.js";
 import { isJsonMediaType } from "./CdpCaptureEventHelpers.js";
 import { recordValue } from "./CdpCaptureValues.js";
 export {} from "./CdpCaptureEventTypes.js";
-/** Bounded event accumulator that drops payload values at ingestion time. */
+/** Event accumulator that validates and normalizes payloads at ingestion. */
 export class CdpCaptureEvents {
     scripts = new Map();
     executionContextFrames = new Map();
@@ -24,9 +24,6 @@ export class CdpCaptureEvents {
     originViolation = false;
     navigationDuringCapture = false;
     mainFrameId = undefined;
-    consoleTextBytes = 0;
-    jsonBodyBytes = 0;
-    websocketShapeBytes = 0;
     input;
     allowedOrigins;
     constructor(input, allowedOrigins) {
@@ -45,9 +42,6 @@ export class CdpCaptureEvents {
         this.websockets.length = 0;
         this.responseMetadata.length = 0;
         this.agentHints.length = 0;
-        this.consoleTextBytes = 0;
-        this.jsonBodyBytes = 0;
-        this.websocketShapeBytes = 0;
         this.completeness.reset();
         if (!this.input.include_console_text)
             this.completeness.exclude("console_text", "not_approved", null);
@@ -120,7 +114,7 @@ export class CdpCaptureEvents {
             .map((request) => request.request_id);
     }
     responseBodyUnavailable(requestId) {
-        bodyShapes.updateResponseBodyShape(this, requestId, null, false);
+        bodyShapes.updateResponseBodyShape(this, requestId, null);
         this.completeness.unavailable("json_body_shapes");
     }
     ingestResponseBody(requestId, value) {

package/dist/browser/CdpCaptureStorage.js

@@ -2,7 +2,7 @@ import { CdpConnection } from "./CdpConnection.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 import { captureStorageFingerprints, } from "./CdpCaptureStorageFingerprints.js";
 import { numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
-/** Capture redacted, bounded storage metadata for one authorized origin. */
+/** Capture redacted storage metadata for one authorized origin. */
 export const captureStorage = async (context, origin, limitations) => {
     const quota = recordValue(await optionalCdpCommand(context, "Storage.getUsageAndQuota", { origin }, limitations));
     const local = context.input.include_storage_keys
@@ -21,19 +21,17 @@ export const captureStorage = async (context, origin, limitations) => {
         : undefined;
     const cacheValues = recordsValue(recordValue(cacheRaw)?.caches);
     const caches = capturedCaches(cacheValues);
-    const maximum = context.input.limits.max_storage_keys;
     const fingerprints = context.input.include_storage_fingerprints
         ? await captureStorageFingerprints({
             context,
             origin,
             local,
             session,
-            indexedDbNames: indexed.slice(0, maximum),
-            caches: caches.slice(0, maximum),
+            indexedDbNames: indexed,
+            caches,
             limitations,
         })
-        : { items: [], complete: false, truncated: false };
-    const truncated = [local.items, session.items, indexed, caches].some((items) => items.length > maximum) || fingerprints.truncated;
+        : { items: [], complete: false };
     const structuredStorageComplete = indexedRaw !== undefined &&
         Array.isArray(indexedValues) &&
         indexed.length === indexedValues.length &&
@@ -44,24 +42,15 @@ export const captureStorage = async (context, origin, limitations) => {
             origin,
             usage_bytes: numberValue(quota?.usage) ?? null,
             quota_bytes: numberValue(quota?.quota) ?? null,
-            local_storage_keys: local.items
-                .map(({ key }) => key.slice(0, 1_024))
-                .slice(0, maximum),
-            session_storage_keys: session.items
-                .map(({ key }) => key.slice(0, 1_024))
-                .slice(0, maximum),
-            indexed_db_names: indexed
-                .map((name) => name.slice(0, 1_024))
-                .slice(0, maximum),
-            cache_names: caches
-                .map(({ name }) => name.slice(0, 1_024))
-                .slice(0, maximum),
+            local_storage_keys: local.items.map(({ key }) => key),
+            session_storage_keys: session.items.map(({ key }) => key),
+            indexed_db_names: [...indexed],
+            cache_names: caches.map(({ name }) => name),
             content_fingerprints: [...fingerprints.items],
             fingerprint_algorithm: "sha256",
-            fingerprints_complete: fingerprints.complete && structuredStorageComplete && !truncated,
+            fingerprints_complete: fingerprints.complete && structuredStorageComplete,
             values_redacted: true,
         },
-        truncated,
     };
 };
 const emptyStorageItems = {

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,16 +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}`));
-    const complete = state.complete &&
-        !state.truncated &&
-        state.items.every(({ complete }) => complete);
-    return complete
-        ? { items: state.items, complete: true, truncated: false }
-        : {
-            items: state.items,
-            complete: false,
-            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)
@@ -80,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) {
@@ -142,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) => {
@@ -239,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, {
@@ -250,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),
@@ -263,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)
@@ -272,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 ||
@@ -300,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);