rea-agents 2.4.0 → 3.0.0

package/dist/browser/BrowserScenarioSecrets.js

@@ -0,0 +1,53 @@
+import { createHash } from "node:crypto";
+const REDACTION_PREFIX = "[REDACTED:";
+/** Resolved secret values kept only for one in-memory scenario session. */
+export class BrowserScenarioSecrets {
+    values;
+    constructor(values) {
+        this.values = values;
+    }
+    static resolve(scenario, environment) {
+        const values = new Map();
+        for (const declaration of scenario.secrets) {
+            const value = environment[declaration.environment_variable];
+            if (value === undefined)
+                return undefined;
+            values.set(declaration.secret_id, value);
+        }
+        return new BrowserScenarioSecrets(values);
+    }
+    value(source) {
+        if (source.source === "literal")
+            return source.value;
+        const value = this.values.get(source.secret_id);
+        if (value === undefined)
+            throw new Error("Validated browser secret was not resolved");
+        return value;
+    }
+    url(destination) {
+        const url = new URL(destination.url);
+        for (const { name, value } of destination.query)
+            url.searchParams.append(name, this.value(value));
+        return url.href;
+    }
+    redact(value) {
+        let output = value;
+        const replacements = [...this.values].sort(([leftId, left], [rightId, right]) => right.length - left.length ||
+            (leftId < rightId ? -1 : leftId > rightId ? 1 : 0));
+        for (const [id, secret] of replacements)
+            if (secret !== "")
+                output = output.replaceAll(secret, `${REDACTION_PREFIX}${id}]`);
+        return output;
+    }
+    fingerprint(value) {
+        for (const secret of this.values.values())
+            if (secret !== "" && value.includes(secret))
+                return { value_state: "redacted-secret", value_sha256: null };
+        return {
+            value_state: "hashed",
+            value_sha256: createHash("sha256")
+                .update(this.redact(value))
+                .digest("hex"),
+        };
+    }
+}

package/dist/browser/BrowserScenarioSessionPort.js

@@ -0,0 +1 @@
+export {};

package/dist/browser/CdpBrowserProvider.js

@@ -3,7 +3,7 @@ import { analyzeCapturedWebBundle } from "../domain/webBundleAnalyzer.js";
 import { webBundleAnalysisSchema, } from "../domain/webBundleAnalysis.js";
 import { webObservationSessionSchema, } from "../domain/browserSession.js";
 import { webMcpDiscoverySchema, } from "../domain/webMcpDiscovery.js";
-import { compareWebCaptures, webCaptureDiffSchema, } from "../domain/webCaptureDiff.js";
+import { browserCaptureComparisonSchema, compareBrowserCaptures, } from "../domain/browserCaptureComparison.js";
 import { webScreenshotDiffSchema, webScreenshotSchema, } from "../domain/webScreenshot.js";
 import { AnalysisError, BrowserObservationError, ProviderAdapterError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
@@ -136,7 +136,7 @@ export class CdpBrowserProvider {
     }
     async compareCaptures(input) {
         try {
-            return ok(webCaptureDiffSchema.parse(compareWebCaptures(input)));
+            return ok(browserCaptureComparisonSchema.parse(compareBrowserCaptures(input)));
         }
         catch (cause) {
             return err(providerError(cause, "compare_web_captures"));

package/dist/browser/CdpCaptureDocuments.js

@@ -156,6 +156,10 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
 };
 export const captureAccessibility = (results, maximum, options) => {
     const all = results.flatMap((result) => recordsValue(requiredRecord(result).nodes));
+    const nodeIds = new Set(all.flatMap((node) => {
+        const nodeId = stringValue(node.nodeId);
+        return nodeId === undefined ? [] : [nodeId];
+    }));
     let retainedBytes = 0;
     let excludedFields = 0;
     let truncatedFields = 0;
@@ -187,6 +191,7 @@ export const captureAccessibility = (results, maximum, options) => {
             name: captureText(node.name),
             description: captureText(node.description),
             ignored: node.ignored === true,
+            states: accessibilityStates(node.properties),
         };
     });
     for (const node of all.slice(maximum)) {
@@ -201,6 +206,11 @@ export const captureAccessibility = (results, maximum, options) => {
     return {
         total: all.length,
         nodes,
+        treeIncomplete: all.some((node) => Array.isArray(node.childIds) &&
+            node.childIds.some((childId) => {
+                const id = stringValue(childId);
+                return id !== undefined && !nodeIds.has(id);
+            })),
         textCapture: {
             status: options.unavailable
                 ? "unavailable"
@@ -215,6 +225,53 @@ export const captureAccessibility = (results, maximum, options) => {
         },
     };
 };
+const ACCESSIBILITY_STATE_NAMES = new Set([
+    "atomic",
+    "autocomplete",
+    "busy",
+    "checked",
+    "disabled",
+    "editable",
+    "expanded",
+    "focusable",
+    "focused",
+    "hasPopup",
+    "hidden",
+    "invalid",
+    "level",
+    "live",
+    "modal",
+    "multiline",
+    "multiselectable",
+    "orientation",
+    "pressed",
+    "readonly",
+    "required",
+    "selected",
+    "valuemax",
+    "valuemin",
+]);
+const accessibilityStates = (value) => {
+    const states = new Map();
+    for (const property of recordsValue(value)) {
+        const name = stringValue(property.name);
+        if (name === undefined || !ACCESSIBILITY_STATE_NAMES.has(name))
+            continue;
+        const raw = recordValue(property.value)?.value;
+        const state = typeof raw === "boolean"
+            ? raw
+            : typeof raw === "number"
+                ? numberValue(raw)
+                : typeof raw === "string"
+                    ? raw.slice(0, 256)
+                    : undefined;
+        if (state !== undefined)
+            states.set(name, state);
+    }
+    return [...states]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, state]) => ({ name, value: state }));
+};
 const axText = (value) => boundedText(recordValue(value)?.value, 1_024);
 const indexedString = (strings, index) => {
     const integer = numberValue(index);

package/dist/browser/CdpCaptureStorage.js

@@ -1,53 +1,95 @@
 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. */
 export const captureStorage = async (context, origin, limitations) => {
     const quota = recordValue(await optionalCdpCommand(context, "Storage.getUsageAndQuota", { origin }, limitations));
     const local = context.input.include_storage_keys
-        ? await storageKeys(context, origin, true, limitations)
-        : [];
+        ? await storageItems(context, origin, true, limitations)
+        : emptyStorageItems;
     const session = context.input.include_storage_keys
-        ? await storageKeys(context, origin, false, limitations)
-        : [];
-    const indexed = context.input.include_storage_keys
-        ? stringArray(recordValue(await optionalCdpCommand(context, "IndexedDB.requestDatabaseNames", { securityOrigin: origin }, limitations))?.databaseNames)
-        : [];
-    const caches = context.input.include_storage_keys
-        ? recordsValue(recordValue(await optionalCdpCommand(context, "CacheStorage.requestCacheNames", { securityOrigin: origin }, limitations))?.caches).flatMap((cache) => {
-            const name = stringValue(cache.cacheName);
-            return name === undefined ? [] : [name.slice(0, 1_024)];
-        })
-        : [];
+        ? await storageItems(context, origin, false, limitations)
+        : emptyStorageItems;
+    const indexedRaw = context.input.include_storage_keys
+        ? await optionalCdpCommand(context, "IndexedDB.requestDatabaseNames", { securityOrigin: origin }, limitations)
+        : undefined;
+    const indexedValues = recordValue(indexedRaw)?.databaseNames;
+    const indexed = stringArray(indexedValues);
+    const cacheRaw = context.input.include_storage_keys
+        ? await optionalCdpCommand(context, "CacheStorage.requestCacheNames", { securityOrigin: 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),
+            limitations,
+        })
+        : { items: [], complete: false, truncated: false };
+    const truncated = [local.items, session.items, indexed, caches].some((items) => items.length > maximum) || fingerprints.truncated;
+    const structuredStorageComplete = indexedRaw !== undefined &&
+        Array.isArray(indexedValues) &&
+        indexed.length === indexedValues.length &&
+        cacheRaw !== undefined &&
+        caches.length === cacheValues.length;
     return {
         value: {
             origin,
             usage_bytes: numberValue(quota?.usage) ?? null,
             quota_bytes: numberValue(quota?.quota) ?? null,
-            local_storage_keys: local.slice(0, maximum),
-            session_storage_keys: session.slice(0, maximum),
-            indexed_db_names: indexed.slice(0, maximum),
-            cache_names: caches.slice(0, maximum),
+            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),
+            content_fingerprints: [...fingerprints.items],
+            fingerprint_algorithm: "sha256",
+            fingerprints_complete: fingerprints.complete && structuredStorageComplete && !truncated,
             values_redacted: true,
         },
-        truncated: [local, session, indexed, caches].some((items) => items.length > maximum),
+        truncated,
     };
 };
-const storageKeys = async (context, origin, isLocalStorage, limitations) => {
-    const result = recordValue(await optionalCdpCommand(context, "DOMStorage.getDOMStorageItems", { storageId: { securityOrigin: origin, isLocalStorage } }, limitations));
-    return Array.isArray(result?.entries)
-        ? result.entries.flatMap((entry) => {
-            if (!Array.isArray(entry))
-                return [];
-            const key = stringValue(entry[0]);
-            return key === undefined ? [] : [key.slice(0, 1_024)];
-        })
-        : [];
+const emptyStorageItems = {
+    items: [],
+    complete: false,
+};
+const capturedCaches = (values) => values.flatMap((cache) => {
+    const name = stringValue(cache.cacheName);
+    const id = stringValue(cache.cacheId);
+    return name === undefined || id === undefined ? [] : [{ name, id }];
+});
+const storageItems = async (context, origin, isLocalStorage, limitations) => {
+    const raw = await optionalCdpCommand(context, "DOMStorage.getDOMStorageItems", { storageId: { securityOrigin: origin, isLocalStorage } }, limitations);
+    const entries = recordValue(raw)?.entries;
+    if (raw === undefined || !Array.isArray(entries))
+        return { items: [], complete: false };
+    const items = entries.flatMap((entry) => {
+        if (!Array.isArray(entry))
+            return [];
+        const key = stringValue(entry[0]);
+        const value = stringValue(entry[1]);
+        return key === undefined || value === undefined ? [] : [{ key, value }];
+    });
+    return { items, complete: items.length === entries.length };
 };
 const stringArray = (value) => Array.isArray(value)
     ? value.flatMap((item) => {
         const text = stringValue(item);
-        return text === undefined ? [] : [text.slice(0, 1_024)];
+        return text === undefined ? [] : [text];
     })
     : [];

package/dist/browser/CdpCaptureStorageFingerprints.js

@@ -0,0 +1,328 @@
+import { createHash } from "node:crypto";
+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);
+    addStorageItems(state, "session_storage", session.items);
+    await addCookies(run, origin);
+    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 addStorageItems = (state, scope, items) => {
+    for (const item of items)
+        addFingerprint(state, {
+            scope,
+            identity: item.key,
+            value: item.value,
+            complete: true,
+        });
+};
+const addCookies = async (run, origin) => {
+    const raw = await optionalCdpCommand(run.context, "Network.getCookies", { urls: [origin] }, run.limitations);
+    if (raw === undefined) {
+        run.state.complete = false;
+        return;
+    }
+    const cookieValues = recordValue(raw)?.cookies;
+    if (!Array.isArray(cookieValues)) {
+        run.state.complete = false;
+        return;
+    }
+    const cookies = recordsValue(cookieValues);
+    if (cookies.length !== cookieValues.length)
+        run.state.complete = false;
+    for (const cookie of cookies) {
+        const name = stringValue(cookie.name);
+        const value = stringValue(cookie.value);
+        const domain = stringValue(cookie.domain);
+        const path = stringValue(cookie.path);
+        if (name === undefined ||
+            value === undefined ||
+            domain === undefined ||
+            path === undefined) {
+            run.state.complete = false;
+            continue;
+        }
+        addFingerprint(run.state, {
+            scope: "cookie",
+            identity: {
+                domain,
+                path,
+                name,
+                partition_key: cookie.partitionKey ?? null,
+            },
+            value,
+            complete: true,
+        });
+    }
+};
+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) {
+            run.state.complete = false;
+            continue;
+        }
+        if (stringValue(database.name) !== databaseName) {
+            run.state.complete = false;
+            continue;
+        }
+        if (!Array.isArray(database.objectStores)) {
+            run.state.complete = false;
+            continue;
+        }
+        const stores = recordsValue(database.objectStores);
+        if (stores.length !== database.objectStores.length)
+            run.state.complete = false;
+        addFingerprint(run.state, {
+            scope: "indexed_db_schema",
+            identity: databaseName,
+            value: stores.map(indexedDbStoreSchema),
+            complete: indexedDbSchemaComplete(stores),
+        });
+        for (const store of stores) {
+            const objectStoreName = stringValue(store.name);
+            if (objectStoreName === undefined) {
+                run.state.complete = false;
+                continue;
+            }
+            await addIndexedDbRecords(run, {
+                origin,
+                databaseName,
+                objectStoreName,
+            });
+        }
+    }
+};
+const indexedDbStoreSchema = (store) => ({
+    name: stringValue(store.name) ?? null,
+    key_path: stableValue(store.keyPath),
+    auto_increment: store.autoIncrement === true,
+    indexes: recordsValue(store.indexes).map((index) => ({
+        name: stringValue(index.name) ?? null,
+        key_path: stableValue(index.keyPath),
+        unique: index.unique === true,
+        multi_entry: index.multiEntry === true,
+    })),
+});
+const indexedDbSchemaComplete = (stores) => stores.every((store) => stringValue(store.name) !== undefined &&
+    stableValueComplete(store.keyPath) &&
+    typeof store.autoIncrement === "boolean" &&
+    Array.isArray(store.indexes) &&
+    recordsValue(store.indexes).length === store.indexes.length &&
+    recordsValue(store.indexes).every((index) => stringValue(index.name) !== undefined &&
+        stableValueComplete(index.keyPath) &&
+        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);
+        const result = recordValue(raw);
+        if (raw === undefined || result === undefined) {
+            run.state.complete = false;
+            continue;
+        }
+        if (!Array.isArray(result.cacheDataEntries) ||
+            typeof result.returnCount !== "number") {
+            run.state.complete = false;
+            continue;
+        }
+        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);
+        if (result.returnCount > entries.length)
+            run.state.truncated = true;
+    }
+};
+const addCacheEntry = async (run, cache, entry) => {
+    const requestURL = stringValue(entry.requestURL);
+    const requestMethod = stringValue(entry.requestMethod);
+    if (requestURL === undefined || requestMethod === undefined) {
+        run.state.complete = false;
+        return;
+    }
+    if (!Array.isArray(entry.requestHeaders)) {
+        run.state.complete = false;
+        return;
+    }
+    const headerRecords = recordsValue(entry.requestHeaders);
+    const requestHeaders = headerRecords.flatMap((header) => {
+        const name = stringValue(header.name);
+        const value = stringValue(header.value);
+        return name === undefined || value === undefined ? [] : [{ name, value }];
+    });
+    if (headerRecords.length !== entry.requestHeaders.length ||
+        requestHeaders.length !== headerRecords.length) {
+        run.state.complete = false;
+        return;
+    }
+    const raw = await optionalCdpCommand(run.context, "CacheStorage.requestCachedResponse", { cacheId: cache.id, requestURL, requestHeaders }, run.limitations);
+    const body = stringValue(recordValue(recordValue(raw)?.response)?.body);
+    const decoded = body === undefined ? null : decodeBase64(body);
+    const complete = decoded !== null && decoded.byteLength <= MAX_CACHE_BODY_BYTES;
+    if (!complete)
+        run.state.complete = false;
+    addFingerprint(run.state, {
+        scope: "cache_entry",
+        identity: { cache: cache.name, requestURL, requestMethod, requestHeaders },
+        value: decoded ?? undefined,
+        complete,
+    });
+};
+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),
+        value_sha256: input.value === undefined ? null : digest(input.value),
+        complete: input.complete &&
+            stableValueComplete(input.identity) &&
+            stableValueComplete(input.value),
+    });
+};
+const digest = (value) => createHash("sha256").update(encodedValue(value)).digest("hex");
+const encodedValue = (value) => {
+    if (value instanceof Uint8Array)
+        return value;
+    const encoded = canonicalize(stableValue(value));
+    if (encoded === undefined)
+        throw new TypeError("Expected canonical JSON");
+    return encoded;
+};
+const stableValue = (value, depth = 0) => {
+    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));
+    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)]));
+};
+const stableValueComplete = (value, depth = 0) => {
+    if (value instanceof Uint8Array)
+        return true;
+    if (value === null ||
+        value === undefined ||
+        typeof value === "string" ||
+        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)));
+    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)));
+};
+const remoteObjectComplete = (value) => {
+    const record = recordValue(value);
+    if (record === undefined)
+        return true;
+    return (record.objectId === undefined &&
+        record.preview === undefined &&
+        record.customPreview === undefined &&
+        (record.type !== "object" || record.value !== undefined) &&
+        stableValueComplete(record));
+};
+const decodeBase64 = (value) => {
+    if (value.length % 4 !== 0 ||
+        !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(value))
+        return null;
+    return Buffer.from(value, "base64");
+};
+const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;

package/dist/browser/CdpEndpoint.js

@@ -24,10 +24,10 @@ const endpointTargetSchema = z.object({
 const endpointTargetsSchema = z.array(endpointTargetSchema).max(1_000);
 /** Read bounded CDP discovery endpoints without following redirects. */
 export const discoverCdpEndpoint = async (endpoint, operation, signal) => {
-    const versionInput = await readJson(new URL("/json/version", endpoint), MAX_VERSION_BYTES, operation, signal);
-    const targetsInput = await readJson(new URL("/json/list", endpoint), MAX_TARGET_LIST_BYTES, operation, signal);
-    const version = parseEndpointValue(endpointVersionSchema, versionInput, operation);
-    const targets = parseEndpointValue(endpointTargetsSchema, targetsInput, operation);
+    const versionInput = await readBoundedCdpJson(new URL("/json/version", endpoint), MAX_VERSION_BYTES, operation, signal);
+    const targetsInput = await readBoundedCdpJson(new URL("/json/list", endpoint), MAX_TARGET_LIST_BYTES, operation, signal);
+    const version = parseCdpEndpointValue(endpointVersionSchema, versionInput, operation);
+    const targets = parseCdpEndpointValue(endpointTargetsSchema, targetsInput, operation);
     return {
         webSocket: safeCdpWebSocketEndpoint(endpoint, version.webSocketDebuggerUrl, operation),
         version: {
@@ -110,7 +110,8 @@ const availableCdpTargetWebSocket = (discovery, target) => {
         ? discovery.webSocket
         : undefined;
 };
-const parseEndpointValue = (schema, input, operation) => {
+/** Parse one CDP discovery value through its exact boundary schema. */
+export const parseCdpEndpointValue = (schema, input, operation) => {
     const parsed = schema.safeParse(input);
     if (!parsed.success)
         throw new BrowserObservationError(operation, "invalid_endpoint_response", {
@@ -173,7 +174,8 @@ const targetWebSocket = (endpoint, target, operation) => {
         return {};
     }
 };
-const readJson = async (url, maximumBytes, operation, signal) => await new Promise((resolve, reject) => {
+/** Read one bounded loopback CDP discovery document without redirects. */
+export const readBoundedCdpJson = async (url, maximumBytes, operation, signal) => await new Promise((resolve, reject) => {
     if (signal?.aborted === true) {
         reject(new AnalysisCancelledError(operation));
         return;

package/dist/browser/CdpPageCapture.js

@@ -226,6 +226,8 @@ const accessibilityForFrames = async (state, frames) => {
         events.completeness.exclude("accessibility", "not_approved", capture.textCapture.excluded_fields);
     if (capture.textCapture.status === "truncated")
         events.completeness.truncate("accessibility");
+    if (capture.treeIncomplete)
+        events.completeness.truncate("accessibility");
     return capture;
 };
 const publicResource = ({ rawUrl: _rawUrl, ...resource }) => resource;