rea-agents 5.0.0 → 6.1.0

package/dist/artifacts/apple/NibViewHierarchy.js

@@ -1,5 +1,5 @@
 /** Project encoded view parents; archive owners are not inferred view parents. */
-export const projectNibViewHierarchy = (objects, retainedIds) => {
+export const projectNibViewHierarchy = (objects, retainedIds, reserveNode = () => true, maxNodes = 20_000) => {
     const { parents, involved, invalid } = collectNibParents(objects, retainedIds);
     if (parents.size === 0)
         return { hierarchy: null, omitted: invalid };
@@ -21,7 +21,10 @@ export const projectNibViewHierarchy = (objects, retainedIds) => {
         const item = pending.pop();
         if (item === undefined)
             break;
-        if (visited.has(item.id) || item.depth > 128 || visited.size >= 20_000)
+        if (visited.has(item.id) ||
+            item.depth > 128 ||
+            visited.size >= maxNodes ||
+            !reserveNode())
             continue;
         visited.add(item.id);
         const node = { objectID: String(item.id), children: [] };
@@ -35,7 +38,7 @@ export const projectNibViewHierarchy = (objects, retainedIds) => {
     };
 };
 /** Add encoded parent links once; conflicting legacy parents remain unknown. */
-export const mergeNibHierarchies = (legacy, recovered) => {
+export const mergeNibHierarchies = (legacy, recovered, reserveNode = () => true, maxNodes = 20_000) => {
     const existing = new Map();
     const owners = new Map();
     const parents = new Map();
@@ -70,6 +73,10 @@ export const mergeNibHierarchies = (legacy, recovered) => {
             break;
         let target = existing.get(entry.node.objectID);
         if (target === undefined) {
+            if (existing.size >= maxNodes || !reserveNode()) {
+                omitted += 1;
+                continue;
+            }
             target = { objectID: entry.node.objectID, children: [] };
             existing.set(target.objectID, target);
             entry.output.push(target);

package/dist/artifacts/apple/PlistNumberLiterals.js

@@ -0,0 +1,164 @@
+import { decodeXmlText } from "../../domain/propertyListKeys.js";
+const collector = () => {
+    const integers = new Map();
+    const reals = new Set();
+    let unsafeIntegerLiterals = 0;
+    let incompleteMetadata = false;
+    return {
+        integer: (literal) => {
+            if (!/^[+-]?\d+$/u.test(literal)) {
+                incompleteMetadata = true;
+                return;
+            }
+            const exact = BigInt(literal);
+            if (exact >= BigInt(Number.MIN_SAFE_INTEGER) &&
+                exact <= BigInt(Number.MAX_SAFE_INTEGER))
+                return;
+            unsafeIntegerLiterals += 1;
+            const rounded = Number(exact);
+            integers.set(rounded, (integers.get(rounded) ?? new Set()).add(exact.toString()));
+        },
+        real: (value) => {
+            reals.add(value);
+        },
+        markIncomplete: () => {
+            incompleteMetadata = true;
+        },
+        result: (incomplete = false) => ({
+            incomplete: incomplete || incompleteMetadata,
+            integers,
+            reals,
+            unsafeIntegerLiterals,
+        }),
+    };
+};
+// Consume quoted tag attributes and opaque comment/CDATA tokens whole.
+const XML_TOKEN = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<(?:[^>"']|"[^"]*"|'[^']*')*>/gu;
+const OPAQUE_ELEMENTS = new Set(["string", "key", "data", "date"]);
+/** Observe plist number element types without interpreting strings or class code. */
+export const xmlPlistNumberLiterals = (xml) => {
+    const output = collector();
+    const elements = [];
+    let number;
+    let cursor = 0;
+    for (const match of xml.matchAll(XML_TOKEN)) {
+        const index = match.index;
+        if (number !== undefined)
+            number.text += xml.slice(cursor, index);
+        const token = match[0];
+        cursor = index + token.length;
+        if (token.startsWith("<!--") || token.startsWith("<![CDATA[")) {
+            if (number !== undefined) {
+                number.plainText = false;
+                output.markIncomplete();
+            }
+            continue;
+        }
+        const tag = /^<\s*(\/?)\s*([\w:-]+)/u.exec(token);
+        if (tag === null) {
+            if (number !== undefined) {
+                number.plainText = false;
+                output.markIncomplete();
+            }
+            continue;
+        }
+        const closing = tag[1] === "/";
+        const name = tag[2];
+        if (name === undefined)
+            continue;
+        if (closing) {
+            if (number !== undefined &&
+                number.kind === name &&
+                number.depth === elements.length) {
+                if (number.plainText) {
+                    const text = decodeXmlText(number.text).trim();
+                    if (number.kind === "integer")
+                        output.integer(text);
+                    else
+                        output.real(Number.parseFloat(text));
+                }
+                number = undefined;
+            }
+            elements.pop();
+            continue;
+        }
+        // The pinned decoder reads only the first child for integers and only text
+        // nodes for reals. Mixed content cannot establish an exact association.
+        if (number !== undefined) {
+            number.plainText = false;
+            output.markIncomplete();
+        }
+        if (/\/\s*>$/u.test(token))
+            continue;
+        if (number === undefined &&
+            (name === "integer" || name === "real") &&
+            !elements.some((parent) => OPAQUE_ELEMENTS.has(parent)))
+            number = {
+                kind: name,
+                text: "",
+                depth: elements.length + 1,
+                plainText: true,
+            };
+        elements.push(name);
+    }
+    return output.result();
+};
+/** Observe bounded binary number markers without changing primary decode acceptance. */
+export const binaryPlistNumberLiterals = (bytes) => {
+    const output = collector();
+    if (bytes.length < 40 ||
+        bytes.subarray(0, 8).toString("ascii") !== "bplist00")
+        return output.result(true);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const trailer = bytes.length - 32;
+    const offsetWidth = bytes[trailer + 6] ?? 0;
+    if (![1, 2, 4, 8].includes(offsetWidth))
+        return output.result(true);
+    const countRaw = view.getBigUint64(trailer + 8);
+    const tableRaw = view.getBigUint64(trailer + 24);
+    const safeMaximum = BigInt(Number.MAX_SAFE_INTEGER);
+    if (countRaw === 0n || countRaw > safeMaximum || tableRaw > safeMaximum)
+        return output.result(true);
+    if (tableRaw < 8n || tableRaw >= BigInt(trailer))
+        return output.result(true);
+    const offsetTable = Number(tableRaw);
+    const capacity = Math.floor((trailer - offsetTable) / offsetWidth);
+    if (countRaw > BigInt(capacity))
+        return output.result(true);
+    const count = Number(countRaw);
+    const unsigned = (offset) => {
+        if (offset < offsetTable || offset + offsetWidth > trailer)
+            return undefined;
+        if (offsetWidth === 1)
+            return view.getUint8(offset);
+        if (offsetWidth === 2)
+            return view.getUint16(offset);
+        if (offsetWidth === 4)
+            return view.getUint32(offset);
+        const value = view.getBigUint64(offset);
+        return value > safeMaximum ? undefined : Number(value);
+    };
+    for (let index = 0; index < count; index += 1) {
+        const offset = unsigned(offsetTable + index * offsetWidth);
+        if (offset === undefined || offset < 8 || offset >= offsetTable)
+            return output.result(true);
+        const marker = bytes[offset] ?? 0;
+        const type = marker >> 4;
+        if (type !== 1 && type !== 2)
+            continue;
+        const width = 2 ** (marker & 0xf);
+        if (offset + 1 + width > offsetTable)
+            return output.result(true);
+        if (type === 1 && width === 8)
+            output.integer(view.getBigInt64(offset + 1).toString());
+        else if (type === 1 && width > 4)
+            return output.result(true);
+        else if (type === 2 && width === 4)
+            output.real(view.getFloat32(offset + 1));
+        else if (type === 2 && width === 8)
+            output.real(view.getFloat64(offset + 1));
+        else if (type === 2)
+            return output.result(true);
+    }
+    return output.result();
+};

package/dist/{application → artifacts/extraction}/ArtifactExtraction.js

@@ -1,14 +1,14 @@
 import { lstat, realpath } from "node:fs/promises";
-import { canonicalDigest } from "../domain/comparisonSemantics.js";
-import { AsarArtifactReader } from "../artifacts/AsarArtifactReader.js";
-import { ArtifactPathRegistry, normalizeArtifactPath, } from "../artifacts/ArtifactPaths.js";
-import { ArtifactReaderFailure, } from "../artifacts/ArtifactReader.js";
-import { DirectoryArtifactReader } from "../artifacts/DirectoryArtifactReader.js";
-import { SafeOutputTree } from "../artifacts/SafeOutputTree.js";
-import { ZipArtifactReader } from "../artifacts/ZipArtifactReader.js";
-import { MachOSliceArtifactReader } from "../artifacts/MachOSliceArtifactReader.js";
-import { artifactExtractionResultSchema, } from "../domain/artifactGraph.js";
-import { scanArtifactInventory } from "./ArtifactInventory.js";
+import { canonicalDigest } from "../../domain/comparisonSemantics.js";
+import { AsarArtifactReader } from "../AsarArtifactReader.js";
+import { ArtifactPathRegistry, normalizeArtifactPath, } from "../ArtifactPaths.js";
+import { ArtifactReaderFailure, } from "../ArtifactReader.js";
+import { DirectoryArtifactReader } from "../DirectoryArtifactReader.js";
+import { SafeOutputTree } from "../SafeOutputTree.js";
+import { ZipArtifactReader } from "../ZipArtifactReader.js";
+import { MachOSliceArtifactReader } from "../MachOSliceArtifactReader.js";
+import { artifactExtractionResultSchema, } from "../../domain/artifactGraph.js";
+import { scanArtifactInventory } from "../inventory/ArtifactInventory.js";
 /** Extract every regular inventory occurrence into an exclusively owned absent root. */
 export const extractArtifact = async (input, signal) => {
     const sourcePath = await realpath(input.inputPath);

package/dist/{application → artifacts/inventory}/ArtifactGraphConstruction.js

@@ -1,6 +1,7 @@
-import { canonicalDigest } from "../domain/comparisonSemantics.js";
-import { zipPackageFormatForPath } from "../domain/zipPackageFormat.js";
-import { mzWindowsHeaderOffset, parseDosMzHeader } from "../domain/dosMz.js";
+import { canonicalDigest } from "../../domain/comparisonSemantics.js";
+import { artifactEdgeId, artifactIdForContent, occurrenceIdForLocation, } from "../../domain/artifactIdentity.js";
+import { zipPackageFormatForPath } from "../../domain/zipPackageFormat.js";
+import { mzWindowsHeaderOffset, parseDosMzHeader } from "../../domain/dosMz.js";
 /** Index the first occurrence for each canonical logical path. */
 export const indexOccurrencesByPath = (occurrences) => {
     const byPath = new Map();
@@ -94,7 +95,7 @@ export const createRootNode = (input) => createArtifactNode({
     contentState: "materialized",
 });
 export const createArtifactNode = (input) => ({
-    artifact_id: `art_${canonicalDigest({ sha256: input.sha256 }, "Artifact")}`,
+    artifact_id: artifactIdForContent(input.sha256),
     kind: input.kind,
     format: input.format,
     sha256: input.sha256,
@@ -106,7 +107,11 @@ export const createArtifactNode = (input) => ({
     limitations: [...(input.limitations ?? [])],
 });
 export const rootOccurrenceFor = (node, declaredSize) => ({
-    occurrence_id: `occ_${canonicalDigest({ root: node.artifact_id }, "Artifact")}`,
+    occurrence_id: occurrenceIdForLocation({
+        rootArtifactId: node.artifact_id,
+        logicalPath: ".",
+        entryKind: node.format === "directory" ? "directory" : "file",
+    }),
     artifact_id: node.artifact_id,
     parent_occurrence_id: null,
     logical_path: ".",
@@ -122,11 +127,11 @@ export const rootOccurrenceFor = (node, declaredSize) => ({
 export const rekeyOccurrences = (rootArtifactId, occurrences) => {
     const replacements = new Map();
     for (const occurrence of occurrences)
-        replacements.set(occurrence.occurrence_id, `occ_${canonicalDigest({
-            root_artifact_id: rootArtifactId,
-            logical_path: occurrence.logical_path,
-            entry_kind: occurrence.entry_kind,
-        }, "Artifact")}`);
+        replacements.set(occurrence.occurrence_id, occurrenceIdForLocation({
+            rootArtifactId,
+            logicalPath: occurrence.logical_path,
+            entryKind: occurrence.entry_kind,
+        }));
     for (const occurrence of occurrences) {
         occurrence.occurrence_id =
             replacements.get(occurrence.occurrence_id) ?? occurrence.occurrence_id;
@@ -160,7 +165,7 @@ export const createArtifactEdges = (rootArtifactId, occurrences, producer) => {
             logical_path: occurrence.logical_path,
         };
         edges.push({
-            edge_id: `edge_${canonicalDigest(semantic, "Artifact")}`,
+            edge_id: artifactEdgeId(semantic),
             ...semantic,
             producer: occurrence.entry_kind === "slice" ? (producer ?? null) : null,
             ordinal: edges.length,

package/dist/{application → artifacts/inventory}/ArtifactInventory.js

@@ -1,8 +1,8 @@
 import { realpath } from "node:fs/promises";
-import { artifactInventoryResultSchema, } from "../domain/artifactGraph.js";
-import { abortIfNeeded } from "../artifacts/ArtifactHash.js";
-import { scanCanonicalArtifactInventory } from "./ArtifactInventory/scanCanonical.js";
-export { scanCanonicalArtifactInventory } from "./ArtifactInventory/scanCanonical.js";
+import { artifactInventoryResultSchema, } from "../../domain/artifactGraph.js";
+import { abortIfNeeded } from "../ArtifactHash.js";
+import { scanCanonicalArtifactInventory } from "./scanCanonical.js";
+export { scanCanonicalArtifactInventory } from "./scanCanonical.js";
 /** Inventory one local artifact and return every graph collection inline. */
 export const inventoryArtifact = async (inputPath, options = {}) => {
     const snapshot = await scanArtifactInventory(inputPath, options);

package/dist/{application/ArtifactInventory → artifacts/inventory}/classify.js

@@ -1,6 +1,6 @@
 import { open } from "node:fs/promises";
-import { classifyArtifactContent } from "../ArtifactGraphConstruction.js";
-import { ARTIFACT_CLASSIFICATION_PREFIX_BYTES } from "../../artifacts/ArtifactHash.js";
+import { classifyArtifactContent } from "./ArtifactGraphConstruction.js";
+import { ARTIFACT_CLASSIFICATION_PREFIX_BYTES } from "../ArtifactHash.js";
 import { hasZipSignature, zipPackageFormatForPath, } from "../../domain/zipPackageFormat.js";
 const classifyContainerExtension = (path) => {
     const lower = path.toLowerCase();

package/dist/{application/ArtifactInventory → artifacts/inventory}/reader.js

@@ -1,8 +1,8 @@
-import { AsarArtifactReader } from "../../artifacts/AsarArtifactReader.js";
-import { DirectoryArtifactReader } from "../../artifacts/DirectoryArtifactReader.js";
-import { MachOSliceArtifactReader } from "../../artifacts/MachOSliceArtifactReader.js";
-import { NativeDmgArtifactReader } from "../../artifacts/NativeDmgArtifactReader.js";
-import { ZipArtifactReader } from "../../artifacts/ZipArtifactReader.js";
+import { AsarArtifactReader } from "../AsarArtifactReader.js";
+import { DirectoryArtifactReader } from "../DirectoryArtifactReader.js";
+import { MachOSliceArtifactReader } from "../MachOSliceArtifactReader.js";
+import { NativeDmgArtifactReader } from "../NativeDmgArtifactReader.js";
+import { ZipArtifactReader } from "../ZipArtifactReader.js";
 export const createReader = async (path, format, signal) => {
     switch (format) {
         case "directory":

package/dist/{application/ArtifactInventory → artifacts/inventory}/scanCanonical.js

@@ -1,11 +1,11 @@
 import { createReadStream } from "node:fs";
 import { lstat } from "node:fs/promises";
-import { ArtifactReaderFailure, } from "../../artifacts/ArtifactReader.js";
+import { ArtifactReaderFailure, } from "../ArtifactReader.js";
 import { artifactInventoryResultSchema, } from "../../domain/artifactGraph.js";
-import { createArtifactEdges, createRootNode, indexOccurrencesByPath, materializeDirectoryNodes, rekeyOccurrences, rootOccurrenceFor, } from "../ArtifactGraphConstruction.js";
-import { canonicalDigest } from "../../domain/comparisonSemantics.js";
+import { createArtifactEdges, createRootNode, indexOccurrencesByPath, materializeDirectoryNodes, rekeyOccurrences, rootOccurrenceFor, } from "./ArtifactGraphConstruction.js";
+import { artifactContradictionId, artifactGraphDigest, artifactManifestId, } from "../../domain/artifactIdentity.js";
 import { classifyRoot } from "./classify.js";
-import { hashReadable } from "../../artifacts/ArtifactHash.js";
+import { hashReadable } from "../ArtifactHash.js";
 import { createReader, inventoryLimitations } from "./reader.js";
 import { scanReader, } from "./scanReader.js";
 import { STRICT_INTEGRITY_POLICY, } from "./types.js";
@@ -63,12 +63,12 @@ const buildInventorySnapshot = async (input) => {
     const orderedOccurrences = sortOccurrences(input.occurrences);
     const orderedEdges = sortEdges(edges);
     await verifyRootDigest(path, rootDigest, signal);
-    const graphSha256 = canonicalDigest({
+    const graphSha256 = artifactGraphDigest({
         nodes: orderedNodes,
         occurrences: orderedOccurrences,
         edges: orderedEdges,
-        integrity_contradictions: integrityContradictions,
-    }, "Artifact");
+        contradictions: integrityContradictions,
+    });
     const manifest = buildManifest({
         rootNode,
         graphSha256,
@@ -95,12 +95,12 @@ const buildIntegrityContradictions = (pending, occurrenceByPath, occurrenceById,
         : occurrenceById.get(occurrence.parent_occurrence_id);
     const parentArtifactId = parent?.artifact_id ?? rootNode.artifact_id;
     return {
-        contradiction_id: `ic_${canonicalDigest({
-            root_artifact_id: rootNode.artifact_id,
-            logical_path: contradiction.logicalPath,
-            declared_sha256: contradiction.declaredSha256,
-            observed_sha256: contradiction.observedSha256,
-        }, "Artifact")}`,
+        contradiction_id: artifactContradictionId({
+            rootArtifactId: rootNode.artifact_id,
+            logicalPath: contradiction.logicalPath,
+            declaredSha256: contradiction.declaredSha256,
+            observedSha256: contradiction.observedSha256,
+        }),
         occurrence_id: occurrence.occurrence_id,
         parent_artifact_id: parentArtifactId,
         logical_path: contradiction.logicalPath,
@@ -127,10 +127,7 @@ const sortNodes = (nodes) => nodes.sort((left, right) => left.artifact_id.locale
 const sortOccurrences = (occurrences) => occurrences.sort((left, right) => left.logical_path.localeCompare(right.logical_path, "en"));
 const sortEdges = (edges) => edges.sort((left, right) => left.edge_id.localeCompare(right.edge_id));
 const buildManifest = ({ rootNode, graphSha256, orderedNodes, orderedOccurrences, orderedEdges, }) => artifactInventoryResultSchema.shape.manifest.parse({
-    manifest_id: `agm_${canonicalDigest({
-        root_artifact_id: rootNode.artifact_id,
-        graph_sha256: graphSha256,
-    }, "Artifact")}`,
+    manifest_id: artifactManifestId(rootNode.artifact_id, graphSha256),
     root_artifact_id: rootNode.artifact_id,
     root_sha256: rootNode.sha256,
     root_format: rootNode.format,

package/dist/{application/ArtifactInventory → artifacts/inventory}/scanReader.js

@@ -1,10 +1,10 @@
 import { isAbsolute } from "node:path";
-import { ArtifactPathRegistry, normalizeArtifactPath, } from "../../artifacts/ArtifactPaths.js";
-import { ArtifactReaderFailure, } from "../../artifacts/ArtifactReader.js";
-import { AsarArtifactReader } from "../../artifacts/AsarArtifactReader.js";
-import { classifyArtifactContent, createArtifactNode, createOccurrence, nearestParent, } from "../ArtifactGraphConstruction.js";
+import { ArtifactPathRegistry, normalizeArtifactPath, } from "../ArtifactPaths.js";
+import { ArtifactReaderFailure, } from "../ArtifactReader.js";
+import { AsarArtifactReader } from "../AsarArtifactReader.js";
+import { classifyArtifactContent, createArtifactNode, createOccurrence, nearestParent, } from "./ArtifactGraphConstruction.js";
 import { STRICT_INTEGRITY_POLICY, } from "./types.js";
-import { hashReadable } from "../../artifacts/ArtifactHash.js";
+import { hashReadable } from "../ArtifactHash.js";
 const UNAVAILABLE_UNPACKED_LIMITATION = "ASAR unpacked companion bytes were unavailable; no content hash or child artifact was produced.";
 const emptyScan = () => ({ nodes: new Map(), occurrences: [], pendingContradictions: [] });
 export const scanReader = async (reader, signal, integrity = STRICT_INTEGRITY_POLICY) => {

package/dist/artifacts/javascript/JavaScriptArtifactFiles.js

@@ -125,7 +125,11 @@ const readText = async (context, input) => {
     try {
         return {
             included: true,
-            value: new TextDecoder("utf-8", { fatal: true }).decode(bytes),
+            value: new TextDecoder("utf-8", {
+                fatal: true,
+                ignoreBOM: input.expected.kind === "javascript" ||
+                    input.expected.kind === "html",
+            }).decode(bytes),
         };
     }
     catch (cause) {
@@ -204,7 +208,7 @@ const relevantKind = (path) => {
         return "package-json";
     if (lower.endsWith(".json"))
         return "json";
-    if (/\.(?:cjs|mjs|js|jsx|ts|tsx)$/u.test(lower))
+    if (/\.(?:cjs|cts|mjs|mts|js|jsx|ts|tsx)$/u.test(lower))
         return "javascript";
     if (/\.html?$/u.test(lower))
         return "html";

package/dist/artifacts/readStableArtifact.js

@@ -2,15 +2,31 @@ import { createHash } from "node:crypto";
 import { constants } from "node:fs";
 import { lstat, open } from "node:fs/promises";
 import { ArtifactReaderFailure } from "./ArtifactReader.js";
+const FILE_SYSTEM = {
+    lstat: (path) => lstat(path, { bigint: true }),
+    open,
+};
+const afterValidation = async (path, stage, read) => {
+    try {
+        return await read();
+    }
+    catch (cause) {
+        if (cause instanceof Error &&
+            "code" in cause &&
+            ["ENOENT", "ENOTDIR", "ELOOP"].includes(String(cause.code)))
+            throw new ArtifactReaderFailure("integrity", `Artifact changed ${stage}: ${path}`, { cause });
+        throw cause;
+    }
+};
 /** Read one bounded regular file and reject replacement or in-place changes. */
-export const readStableArtifact = async (path, maximumBytes, signal) => {
+export const readStableArtifact = async (path, maximumBytes, signal, fileSystem = FILE_SYSTEM) => {
     signal?.throwIfAborted();
-    const before = await lstat(path, { bigint: true });
+    const before = await fileSystem.lstat(path);
     if (!before.isFile() || before.isSymbolicLink())
         throw new ArtifactReaderFailure("path", `Expected a regular file without a symlink: ${path}`);
     if (before.size > BigInt(maximumBytes))
         throw new ArtifactReaderFailure("limit", `Selected artifact exceeds ${String(maximumBytes)} bytes: ${path}`);
-    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const file = await afterValidation(path, "before open", () => fileSystem.open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK));
     try {
         const initial = await file.stat({ bigint: true });
         if (!initial.isFile() ||
@@ -34,7 +50,7 @@ export const readStableArtifact = async (path, maximumBytes, signal) => {
             chunks.push(bytes);
         }
         const after = await file.stat({ bigint: true });
-        const current = await lstat(path, { bigint: true });
+        const current = await afterValidation(path, "during read", () => fileSystem.lstat(path));
         if ([after, current].some((stat) => !stat.isFile() ||
             stat.dev !== initial.dev ||
             stat.ino !== initial.ino ||

package/dist/browser/CdpCaptureCompleteness.js

@@ -44,6 +44,8 @@ export class CdpCaptureCompleteness {
         if (reason === "provider_unavailable" ||
             reason === "invalid_protocol_value")
             this.#unavailable.add(section);
+        if (reason === "resource_budget_exhausted")
+            this.#truncated.add(section);
         const key = `${section}\0${reason}`;
         const existing = this.#excluded.get(key);
         const combined = count === null || existing?.count === null