rea-agents 6.3.0 → 6.4.0

package/dist/dotnet/ManagedArtifactInspector.js

@@ -1,3 +1,4 @@
+import { admitManagedProjection, managedDecodeBudget, } from "./ManagedDecodeBudget.js";
 import { managedArtifactInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import { readManagedPeLayout, } from "./ManagedPeReader.js";
 import { managedTableRowCounts, readManagedMetadataInventory, readManagedResourceDirectory, } from "./ManagedMetadataInventory.js";
@@ -73,7 +74,7 @@ const unavailableResult = (target, bytes, layout) => {
         : [
             "The PE has no CLI data directory; managed metadata and CIL are unavailable.",
         ];
-    return managedArtifactInspectionSchema.parse({
+    return managedArtifactInspectionSchema.parse(admitManagedProjection({
         ...base(target, bytes, layout),
         classification: {
             status: malformed ? "malformed" : "not-managed",
@@ -83,7 +84,9 @@ const unavailableResult = (target, bytes, layout) => {
             managed_architecture: "unknown",
             evidence: [
                 {
-                    code: malformed ? "cli-directory-malformed" : "cli-directory-absent",
+                    code: malformed
+                        ? "cli-directory-malformed"
+                        : "cli-directory-absent",
                     detail: limitations[0],
                     file_offset: layout.cliIssue?.offset ?? null,
                 },
@@ -106,7 +109,7 @@ const unavailableResult = (target, bytes, layout) => {
             issues,
         },
         limitations,
-    });
+    }));
 };
 const runtimeFamilyFor = (cli, inventory, metadata, layout) => {
     const evidence = [
@@ -198,7 +201,7 @@ const runtimeClassification = ({ layout, metadata, inventory, }) => {
 const partialMetadataResult = ({ target, bytes, layout, issue, }) => ({
     ...base(target, bytes, layout),
     classification: {
-        status: "malformed",
+        status: issue.code === "resource-limit" ? "managed" : "malformed",
         container: "pe",
         runtime_family: (layout.cli?.flags ?? 1) & 1 ? "unknown" : "mixed-clr-native",
         implementation: "unknown",
@@ -212,7 +215,7 @@ const partialMetadataResult = ({ target, bytes, layout, issue, }) => ({
         ],
     },
     metadata: {
-        status: "malformed",
+        status: issue.code === "resource-limit" ? "partial" : "malformed",
         version: null,
         stream_names: [],
         table_row_counts: {},
@@ -225,7 +228,9 @@ const partialMetadataResult = ({ target, bytes, layout, issue, }) => ({
     attributes: [],
     coverage: { state: "partial", issues: [issue] },
     limitations: [
-        "CLI metadata could not be read because the PE/CLI structure is malformed or unsupported.",
+        issue.code === "resource-limit"
+            ? "CLI metadata inspection stopped at its representation budget; omitted facts are unknown."
+            : "CLI metadata could not be read because the PE/CLI structure is malformed or unsupported.",
     ],
 });
 /** Inspect PE/CLI identity directly from local bytes without CLR loading. */
@@ -242,48 +247,55 @@ export const inspectManagedArtifactBytes = (bytes, target) => {
     catch (cause) {
         if (!(cause instanceof ManagedReaderFailure))
             throw cause;
-        return managedArtifactInspectionSchema.parse(partialMetadataResult({
+        return managedArtifactInspectionSchema.parse(admitManagedProjection(partialMetadataResult({
             target,
             bytes,
             layout,
             issue: cause.issue,
-        }));
+        })));
     }
     const resourceIssues = [];
     const resourceDirectory = readManagedResourceDirectory(layout, resourceIssues);
-    const inventory = readManagedMetadataInventory(bytes, metadata, resourceDirectory);
-    const issues = [...resourceIssues, ...inventory.issues];
-    const limitations = [
-        ...(issues.length === 0
-            ? []
-            : [
-                "At least one metadata or resource item could not be read; coverage is partial.",
-            ]),
-        "Static inspection did not load the assembly, resolve dependencies through a CLR, decompile C#, or execute target code.",
-    ];
-    return managedArtifactInspectionSchema.parse({
-        ...base(target, bytes, layout),
-        classification: {
-            status: "managed",
-            container: "pe",
-            ...runtimeClassification({ layout, metadata, inventory }),
-        },
-        metadata: {
-            status: issues.length === 0 ? "complete" : "partial",
-            version: metadata.version,
-            stream_names: metadata.streamNames,
-            table_row_counts: managedTableRowCounts(metadata),
-        },
-        module: inventory.module,
-        assembly: inventory.assembly,
-        target_frameworks: inventory.targetFrameworks,
-        references: inventory.references,
-        resources: inventory.resources,
-        attributes: inventory.attributes,
-        coverage: {
-            state: issues.length === 0 ? "complete" : "partial",
-            issues,
-        },
-        limitations,
-    });
+    try {
+        const inventory = readManagedMetadataInventory(bytes, metadata, resourceDirectory);
+        const issues = [...resourceIssues, ...inventory.issues];
+        const limitations = [
+            ...(issues.length === 0
+                ? []
+                : [
+                    "At least one metadata or resource item could not be read; coverage is partial.",
+                ]),
+            "Static inspection did not load the assembly, resolve dependencies through a CLR, decompile C#, or execute target code.",
+        ];
+        return managedArtifactInspectionSchema.parse(admitManagedProjection({
+            ...base(target, bytes, layout),
+            classification: {
+                status: "managed",
+                container: "pe",
+                ...runtimeClassification({ layout, metadata, inventory }),
+            },
+            metadata: {
+                status: issues.length === 0 ? "complete" : "partial",
+                version: metadata.version,
+                stream_names: metadata.streamNames,
+                table_row_counts: managedTableRowCounts(metadata),
+            },
+            module: inventory.module,
+            assembly: inventory.assembly,
+            target_frameworks: inventory.targetFrameworks,
+            references: inventory.references,
+            resources: inventory.resources,
+            attributes: inventory.attributes,
+            coverage: {
+                state: issues.length === 0 ? "complete" : "partial",
+                issues,
+            },
+            limitations,
+        }, managedDecodeBudget(metadata)));
+    }
+    catch (cause) {
+        if (!(cause instanceof ManagedReaderFailure))
+            throw cause;
+        return managedArtifactInspectionSchema.parse(admitManagedProjection(partialMetadataResult({ target, bytes, layout, issue: cause.issue })));
+    }
 };

package/dist/dotnet/ManagedDecodeBudget.js

@@ -0,0 +1,80 @@
+import { createHash } from "node:crypto";
+import { managedFailure } from "./ManagedReaderFailure.js";
+/** Per-inspection capacity for eagerly retained metadata and its JSON projection. */
+const MAX_METADATA_REPRESENTATION_BYTES = 64 * 1024 * 1024;
+/** The layout owns decoding capacity and heap identity for all of its consumers. */
+export class ManagedDecodeBudget {
+    #remaining = MAX_METADATA_REPRESENTATION_BYTES;
+    #strings = new Map();
+    #digests = new WeakMap();
+    reserve(bytes, offset) {
+        if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > this.#remaining)
+            throw managedFailure("resource-limit", "metadata.representation", `Managed metadata exceeds the ${String(MAX_METADATA_REPRESENTATION_BYTES)} byte representation budget`, offset);
+        this.#remaining -= bytes;
+    }
+    /** UTF-8 cannot decode to more UTF-16 units than bytes; JSON uses at most six bytes per unit. */
+    reserveString(encodedBytes, offset) {
+        this.reserve(encodedBytes * 6 + 2, offset);
+    }
+    /** Snapshot buffers are immutable within a layout; cache exact backing-buffer ranges. */
+    digest(bytes, algorithm) {
+        let ranges = this.#digests.get(bytes.buffer);
+        if (ranges === undefined) {
+            ranges = new Map();
+            this.#digests.set(bytes.buffer, ranges);
+        }
+        const key = `${algorithm}:${String(bytes.byteOffset)}:${String(bytes.byteLength)}`;
+        const cached = ranges.get(key);
+        if (cached !== undefined)
+            return cached;
+        this.reserve(256, null);
+        const digest = createHash(algorithm).update(bytes).digest("hex");
+        ranges.set(key, digest);
+        return digest;
+    }
+    cachedString(index) {
+        return this.#strings.get(index);
+    }
+    cacheString(index, value, encodedBytes) {
+        this.#strings.set(index, { value, encodedBytes });
+    }
+}
+const budgets = new WeakMap();
+/** Transfer metadata-root admission capacity to its completed immutable layout. */
+export const attachManagedDecodeBudget = (layout, budget) => {
+    budgets.set(layout, budget);
+};
+/** Share one owner for the lifetime of the admitted layout, including all inspection facets. */
+export const managedDecodeBudget = (layout) => {
+    let budget = budgets.get(layout);
+    if (budget === undefined) {
+        budget = new ManagedDecodeBudget();
+        budgets.set(layout, budget);
+    }
+    return budget;
+};
+/** Admit repeated values too: shared heap strings still expand at the JSON boundary. */
+export const admitManagedProjection = (value, budget = new ManagedDecodeBudget()) => {
+    const visit = (item) => {
+        if (typeof item === "string") {
+            budget.reserveString(item.length, null);
+        }
+        else if (Array.isArray(item)) {
+            budget.reserve(item.length + 2, null);
+            for (const child of item)
+                visit(child);
+        }
+        else if (item !== null && typeof item === "object") {
+            budget.reserve(2, null);
+            for (const key of Object.keys(item)) {
+                budget.reserve(key.length * 6 + 4, null);
+                visit(Reflect.get(item, key));
+            }
+        }
+        else {
+            budget.reserve(32, null);
+        }
+    };
+    visit(value);
+    return value;
+};

package/dist/dotnet/ManagedMemberInspector.js

@@ -1,3 +1,4 @@
+import { admitManagedProjection, managedDecodeBudget, } from "./ManagedDecodeBudget.js";
 import { managedMemberInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import { readManagedPeLayout, } from "./ManagedPeReader.js";
 import { readManagedResourceDirectory, managedTableRowCounts, readManagedMetadataInventory, } from "./ManagedMetadataInventory.js";
@@ -5,7 +6,7 @@ import { readManagedMetadataLayout } from "./ManagedMetadataLayout.js";
 import { ManagedReaderFailure, uniqueManagedParseIssues, } from "./ManagedReaderFailure.js";
 import { parseTypes, typeRanges } from "./ManagedMemberInspectorCore.js";
 import { edges, parseFields, parseMemberRefs, parseMethods, } from "./ManagedMemberRows.js";
-const unavailable = (target, bytes, issue) => managedMemberInspectionSchema.parse({
+const unavailable = (target, bytes, issue) => managedMemberInspectionSchema.parse(admitManagedProjection({
     artifact: {
         path: target.path,
         sha256: target.sha256,
@@ -14,7 +15,11 @@ const unavailable = (target, bytes, issue) => managedMemberInspectionSchema.pars
     },
     module: null,
     metadata: {
-        status: issue === null ? "absent" : "malformed",
+        status: issue === null
+            ? "absent"
+            : issue.code === "resource-limit"
+                ? "partial"
+                : "malformed",
         version: null,
         table_row_counts: {},
     },
@@ -38,7 +43,7 @@ const unavailable = (target, bytes, issue) => managedMemberInspectionSchema.pars
             ? "The PE has no admitted CLI metadata; managed member inspection is unavailable."
             : "The CLI metadata could not be admitted; managed member inspection is unavailable.",
     ],
-});
+}));
 const readMemberInventory = (bytes, pe, issues) => {
     const cli = pe.cli;
     if (cli === null)
@@ -75,7 +80,7 @@ export const inspectManagedMembersBytes = (bytes, target) => {
             methods.methods.some((method) => method.body.status === "partial" ||
                 method.body.status === "malformed");
         const related = edges(methods.methods, methods.core, fields.core, memberRefs.core);
-        return managedMemberInspectionSchema.parse({
+        return managedMemberInspectionSchema.parse(admitManagedProjection({
             artifact: {
                 path: target.path,
                 sha256: target.sha256,
@@ -100,7 +105,9 @@ export const inspectManagedMembersBytes = (bytes, target) => {
             call_edges: related.callEdges,
             field_accesses: related.fieldAccesses,
             coverage: {
-                state: issues.length === 0 && !incompleteMembers ? "complete" : "partial",
+                state: issues.length === 0 && !incompleteMembers
+                    ? "complete"
+                    : "partial",
                 issues: coverageIssues,
             },
             limitations: [
@@ -108,7 +115,7 @@ export const inspectManagedMembersBytes = (bytes, target) => {
                 "CIL instruction anchors are decoded from file-backed method bodies only; no target assembly is loaded or executed.",
                 "Signatures are decoded for common ECMA-335 primitive, class, valuetype, pointer, byref, array, and generic variable forms; unsupported forms retain raw signature hashes.",
             ],
-        });
+        }, managedDecodeBudget(layout)));
     }
     catch (cause) {
         if (cause instanceof ManagedReaderFailure)

package/dist/dotnet/ManagedMemberInspectorCore.js

@@ -233,10 +233,10 @@ const callingConvention = (value) => {
                 : `unknown:${String(base)}`;
     return flags.length === 0 ? name : `${name} ${flags.join(" ")}`;
 };
-export const signature = (blob) => {
+export const signature = (blob, rawSha256) => {
     const raw = {
         raw_length: blob.length,
-        raw_sha256: sha256Bytes(blob),
+        raw_sha256: rawSha256 ?? sha256Bytes(blob),
     };
     try {
         if (blob.length === 0)

package/dist/dotnet/ManagedMemberInstructionDecoder.js

@@ -393,7 +393,7 @@ export const decodeInstructions = (il) => {
     const truncated = offset < il.length && issue === null ? 1 : 0;
     return { parsed, instructionStarts, count: parsed.length, truncated, issue };
 };
-export const parseExceptionRegions = (bytes, offset, methodEnd) => {
+export const parseExceptionRegions = (bytes, offset, methodEnd, budget) => {
     const regions = [];
     let sectionOffset = offset;
     let hasMoreSections = true;
@@ -423,7 +423,9 @@ export const parseExceptionRegions = (bytes, offset, methodEnd) => {
             (bytes[sectionOffset + 2] !== 0 || bytes[sectionOffset + 3] !== 0))
             return malformedExceptionRegions("Small exception section reserved bytes are nonzero", regions);
         const count = (size - 4) / clauseSize;
-        regions.push(...readExceptionClauses(bytes, sectionOffset + 4, count, fat));
+        budget?.reserve(count * 256, sectionOffset);
+        for (const region of readExceptionClauses(bytes, sectionOffset + 4, count, fat))
+            regions.push(region);
         hasMoreSections = (kind & 0x80) !== 0;
         sectionOffset += size;
     }

package/dist/dotnet/ManagedMemberRows.js

@@ -1,3 +1,4 @@
+import { managedDecodeBudget } from "./ManagedDecodeBudget.js";
 import { createDeclaringTypeLookup, signature, } from "./ManagedMemberInspectorCore.js";
 import { metadataToken, metadataRowCursor, metadataCodedToken, metadataCodedTokenInvalidReason, readMetadataBlob, readMetadataString, } from "./ManagedMetadataHeaps.js";
 import { readManagedValue } from "./ManagedReaderFailure.js";
@@ -23,7 +24,7 @@ export const parseFields = (bytes, layout, ranges) => {
                 declaring_type: declared?.fullName ?? null,
                 name,
                 flags,
-                signature: signature(sig),
+                signature: budgetedSignature(sig, layout),
             });
             core.set(token, { token, name });
         }, issues);
@@ -57,7 +58,7 @@ export const parseMemberRefs = (bytes, layout) => {
                 row_offset: cursor.start,
                 parent_token: metadataCodedToken(parentRaw, 3, [2, 1, 26, 6, 27], layout.rowCounts),
                 name,
-                signature: signature(sig),
+                signature: budgetedSignature(sig, layout),
             });
             core.set(token, { token, name });
         }, issues);
@@ -90,8 +91,8 @@ export const parseMethods = ({ bytes, layout, pe, ranges, }) => {
                 rva,
                 impl_flags: implFlags,
                 flags,
-                signature: signature(sig),
-                body: methodBody(bytes, pe, rva, { implFlags, flags }),
+                signature: budgetedSignature(sig, layout),
+                body: methodBody(bytes, pe, rva, { implFlags, flags }, managedDecodeBudget(layout)),
             });
             core.set(token, {
                 token,
@@ -146,3 +147,7 @@ export const edges = (methods, methodCore, fieldCore, refCore) => {
     }
     return { callEdges, fieldAccesses };
 };
+const budgetedSignature = (bytes, layout) => {
+    managedDecodeBudget(layout).reserve(bytes.length * 256, layout.blob.offset);
+    return signature(bytes, managedDecodeBudget(layout).digest(bytes, "sha256"));
+};

package/dist/dotnet/ManagedMetadataHeaps.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { managedDecodeBudget } from "./ManagedDecodeBudget.js";
 import { metadataRowOffset, } from "./ManagedMetadataLayout.js";
 import { managedFailure } from "./ManagedReaderFailure.js";
 const requireRange = (bytes, offset, length, scope) => {
@@ -73,14 +74,25 @@ export const readMetadataString = (bytes, layout, index, heapExtent) => {
     if (index < 0 || index >= layout.strings.size)
         throw managedFailure("invalid-heap-index", "metadata.#Strings", "String heap index is outside #Strings", layout.strings.offset + Math.max(index, 0));
     const start = layout.strings.offset + index;
+    const cached = managedDecodeBudget(layout).cachedString(index);
+    if (cached !== undefined && cached.encodedBytes <= heapExtent) {
+        managedDecodeBudget(layout).reserveString(cached.encodedBytes, start);
+        return cached.value;
+    }
     const maximum = Math.min(layout.strings.offset + layout.strings.size, start + heapExtent + 1);
     let end = start;
     while (end < maximum && bytes[end] !== 0)
         end += 1;
     if (end === maximum)
         throw managedFailure("invalid-string", "metadata.#Strings", "String heap item has no terminator within #Strings", start);
+    managedDecodeBudget(layout).reserveString(end - start, start);
     try {
-        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(start, end));
+        const value = new TextDecoder("utf-8", {
+            fatal: true,
+            ignoreBOM: true,
+        }).decode(bytes.subarray(start, end));
+        managedDecodeBudget(layout).cacheString(index, value, end - start);
+        return value;
     }
     catch (cause) {
         void cause;
@@ -127,16 +139,14 @@ export const readMetadataGuid = (bytes, layout, index) => {
 export const metadataToken = (table, row) => `0x${(table * 0x01_00_00_00 + row).toString(16).padStart(8, "0")}`;
 /** Hash bytes without exposing their contents. */
 export const sha256Bytes = (bytes) => createHash("sha256").update(bytes).digest("hex");
-/** Derive the conventional strong-name token from a full public key. */
-export const strongNameToken = (publicKey) => Buffer.from(createHash("sha1").update(publicKey).digest().subarray(-8))
-    .reverse()
-    .toString("hex");
 /** Create a cursor bounded to one admitted metadata table row. */
 export const metadataRowCursor = (bytes, layout, table, row) => {
     const descriptor = layout.table(table);
     const start = metadataRowOffset(layout, table, row);
     if (descriptor === undefined)
         throw managedFailure("invalid-row", `metadata.${String(table)}`, "Metadata table is absent", start);
+    // Reserve per-row object/index bookkeeping before readers retain decoded facts.
+    managedDecodeBudget(layout).reserve(256, start);
     return new MetadataRowCursor(bytes, start, start + descriptor.rowSize, `metadata.${descriptor.name}`);
 };
 /** Decode a metadata coded index without signed 32-bit coercion. */

package/dist/dotnet/ManagedMetadataInventoryRows.js

@@ -1,14 +1,20 @@
+import { managedDecodeBudget } from "./ManagedDecodeBudget.js";
 import { metadataRowOffset, } from "./ManagedMetadataLayout.js";
-import { metadataRowCursor, metadataCodedToken, metadataCodedTokenInvalidReason, metadataToken, readMetadataBlob, readMetadataGuid, readMetadataString, sha256Bytes, strongNameToken, } from "./ManagedMetadataHeaps.js";
+import { metadataRowCursor, metadataCodedToken, metadataCodedTokenInvalidReason, metadataToken, readMetadataBlob, readMetadataGuid, readMetadataString, } from "./ManagedMetadataHeaps.js";
 import { managedFailure } from "./ManagedReaderFailure.js";
-const publicKeyIdentity = (bytes, kind) => ({
+const publicKeyIdentity = (bytes, kind, layout) => ({
     kind: bytes.length === 0 ? "none" : kind,
     byte_length: bytes.length,
-    sha256: bytes.length === 0 ? null : sha256Bytes(bytes),
+    sha256: bytes.length === 0
+        ? null
+        : managedDecodeBudget(layout).digest(bytes, "sha256"),
     token: bytes.length === 0
         ? null
         : kind === "public-key"
-            ? strongNameToken(bytes)
+            ? Buffer.from(managedDecodeBudget(layout).digest(bytes, "sha1"), "hex")
+                .subarray(-8)
+                .reverse()
+                .toString("hex")
             : bytes.length === 8
                 ? bytes.toString("hex")
                 : null,
@@ -55,7 +61,7 @@ export const readAssembly = (bytes, layout, heapExtent) => {
         culture: culture.length === 0 ? null : culture,
         flags,
         hash_algorithm: hashAlgorithm,
-        public_key: publicKeyIdentity(key, (flags & 1) === 0 ? "public-key-token" : "public-key"),
+        public_key: publicKeyIdentity(key, (flags & 1) === 0 ? "public-key-token" : "public-key", layout),
         token: metadataToken(32, 1),
         row_offset: table.offset,
     };
@@ -78,8 +84,10 @@ export const readAssemblyReference = (bytes, layout, row, heapExtent) => {
         version,
         culture: culture.length === 0 ? null : culture,
         flags,
-        public_key_or_token: publicKeyIdentity(keyOrToken, (flags & 1) === 0 ? "public-key-token" : "public-key"),
-        hash_value_sha256: hashValue.length === 0 ? null : sha256Bytes(hashValue),
+        public_key_or_token: publicKeyIdentity(keyOrToken, (flags & 1) === 0 ? "public-key-token" : "public-key", layout),
+        hash_value_sha256: hashValue.length === 0
+            ? null
+            : managedDecodeBudget(layout).digest(hashValue, "sha256"),
         hash_value_length: hashValue.length,
         token: metadataToken(35, row),
         row_offset: metadataRowOffset(layout, 35, row),
@@ -191,7 +199,7 @@ const decodeCompressedLength = (blob, offset) => {
         };
     return undefined;
 };
-const decodeFixedString = (blob) => {
+const decodeFixedString = (blob, layout) => {
     if (blob.length < 3 || blob.readUInt16LE(0) !== 1 || blob[2] === 0xff)
         return null;
     const length = decodeCompressedLength(blob, 2);
@@ -200,6 +208,7 @@ const decodeFixedString = (blob) => {
     const start = 2 + length.prefix;
     if (start > blob.length - length.length)
         return null;
+    managedDecodeBudget(layout).reserveString(length.length, layout.blob.offset);
     try {
         return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(blob.subarray(start, start + length.length));
     }
@@ -236,9 +245,9 @@ export const readCustomAttribute = (bytes, layout, row, heapExtent) => {
         constructor_token: metadataCodedToken(typeRaw, 3, [undefined, undefined, 6, 10], layout.rowCounts),
         type_name: typeName,
         value_length: value.length,
-        value_sha256: sha256Bytes(value),
+        value_sha256: managedDecodeBudget(layout).digest(value, "sha256"),
         decoded_fixed_string: typeName === "System.Runtime.Versioning.TargetFrameworkAttribute"
-            ? decodeFixedString(value)
+            ? decodeFixedString(value, layout)
             : null,
         token: metadataToken(12, row),
         row_offset: cursor.start,
@@ -283,7 +292,7 @@ export const readResource = ({ bytes, layout, row, directory, issues, }) => {
                 });
             }
             else {
-                dataSha256 = sha256Bytes(bytes.subarray(start + 4, start + 4 + dataLength));
+                dataSha256 = managedDecodeBudget(layout).digest(bytes.subarray(start + 4, start + 4 + dataLength), "sha256");
             }
         }
     }

package/dist/dotnet/ManagedMetadataLayout.js

@@ -1,3 +1,4 @@
+import { attachManagedDecodeBudget, ManagedDecodeBudget, } from "./ManagedDecodeBudget.js";
 import { managedFailure } from "./ManagedReaderFailure.js";
 import { computeRowSize, } from "./ManagedMetadataRowSizes.js";
 export const METADATA_TABLE_NAMES = [
@@ -115,15 +116,17 @@ const codedSize = (name, rowCounts) => {
     return maximum < 2 ** (16 - descriptor.bits) ? 2 : 4;
 };
 const tableSize = (index, rows) => (rows[index] ?? 0) < 0x1_0000 ? 2 : 4;
-const readMetadataStreams = (bytes, rootOffset) => {
+const readMetadataStreams = (bytes, rootOffset, budget) => {
     if (bytes.readUInt32LE(0) !== 0x424a_5342)
         throw managedFailure("invalid-metadata-root", "metadata.signature", "CLI metadata signature is not BSJB", rootOffset);
     const versionLength = bytes.readUInt32LE(12);
     requireRange(bytes, 16, versionLength, "metadata.version");
     const versionBytes = bytes.subarray(16, 16 + versionLength);
     const zero = versionBytes.indexOf(0);
+    const decodedVersionLength = zero < 0 ? versionBytes.length : zero;
+    budget.reserveString(decodedVersionLength, rootOffset + 16);
     const version = versionBytes
-        .subarray(0, zero < 0 ? versionBytes.length : zero)
+        .subarray(0, decodedVersionLength)
         .toString("utf8");
     let cursor = align4(16 + versionLength);
     requireRange(bytes, cursor, 4, "metadata.stream-count");
@@ -220,7 +223,8 @@ export const readManagedMetadataLayout = (artifact, rootOffset, size) => {
     if (size < 20 || rootOffset < 0 || rootOffset > artifact.length - size)
         throw managedFailure("invalid-metadata-root", "metadata.root", "CLI metadata directory leaves the artifact byte range", rootOffset);
     const bytes = artifact.subarray(rootOffset, rootOffset + size);
-    const { streams, version } = readMetadataStreams(bytes, rootOffset);
+    const budget = new ManagedDecodeBudget();
+    const { streams, version } = readMetadataStreams(bytes, rootOffset, budget);
     const { tableBytes, tablesOffset, heaps, valid } = readTablesHeader(artifact, streams);
     const rowCounts = readRowCounts(tableBytes, valid);
     const tables = buildMetadataTables({
@@ -230,7 +234,7 @@ export const readManagedMetadataLayout = (artifact, rootOffset, size) => {
         valid,
         tablesOffset,
     });
-    return {
+    const layout = {
         rootOffset,
         size,
         version,
@@ -247,6 +251,8 @@ export const readManagedMetadataLayout = (artifact, rootOffset, size) => {
         tableIndexSize: (index) => tableSize(index, rowCounts),
         codedIndexSize: (name) => codedSize(name, rowCounts),
     };
+    attachManagedDecodeBudget(layout, budget);
+    return layout;
 };
 /** Resolve a one-based metadata row to its exact file offset. */
 export const metadataRowOffset = (layout, table, row) => {

package/dist/dotnet/ManagedMethodBodyReader.js

@@ -40,12 +40,11 @@ const readMethodBodyHeader = (bytes, offset) => {
         localSig: bytes.readUInt32LE(offset + 8),
     };
 };
-const readExceptionRegions = (bytes, sectionOffset, methodEnd, ilSize, instructionOffsets) => validateExceptionRegionRanges(parseExceptionRegions(bytes, sectionOffset, methodEnd), ilSize, instructionOffsets);
 /** Decode admitted managed CIL, retaining unavailable implementation metadata as partial. */
 export const methodBody = (bytes, pe, rva, implementation = {
     implFlags: 0,
     flags: 0,
-}) => {
+}, budget) => {
     if (rva === 0)
         return emptyMethodBody(rva, "absent", null);
     if ((implementation.implFlags & 7) !== 0 ||
@@ -62,6 +61,9 @@ export const methodBody = (bytes, pe, rva, implementation = {
         if (ilOffset > bytes.length - header.ilSize)
             throw new RangeError("Method IL bytes leave artifact");
         const il = bytes.subarray(ilOffset, ilOffset + header.ilSize);
+        // One byte can produce an instruction record, start index, normalized tuple,
+        // and anchor. Reserve conservative bookkeeping capacity before decoding.
+        budget?.reserve(il.length * 256, ilOffset);
         const decoded = decodeInstructions(il);
         const opcodeCounts = {};
         for (const instruction of decoded.parsed)
@@ -83,7 +85,7 @@ export const methodBody = (bytes, pe, rva, implementation = {
         const methodEnd = ilOffset + header.ilSize;
         const sectionOffset = (methodEnd + 3) & ~3;
         const exceptionRegions = header.format === "fat" && (header.flags & 8) !== 0
-            ? readExceptionRegions(bytes, sectionOffset, offset + methodExtent, header.ilSize, decoded.instructionStarts)
+            ? validateExceptionRegionRanges(parseExceptionRegions(bytes, sectionOffset, offset + methodExtent, budget), header.ilSize, decoded.instructionStarts)
             : null;
         const status = bodyStatus(decoded.issue, decoded.truncated, exceptionRegions);
         return {
@@ -115,6 +117,9 @@ export const methodBody = (bytes, pe, rva, implementation = {
         };
     }
     catch (cause) {
+        if (cause instanceof ManagedReaderFailure &&
+            cause.issue.code === "resource-limit")
+            throw cause;
         if (!(cause instanceof ManagedReaderFailure) &&
             !(cause instanceof RangeError))
             throw cause;

package/dist/dotnet/ManagedNativeBoundaryHelpers.js

@@ -1,3 +1,4 @@
+import { admitManagedProjection, managedDecodeBudget, } from "./ManagedDecodeBudget.js";
 import { managedNativeBoundaryInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import {} from "./ManagedMetadataLayout.js";
 import { metadataRowCursor, metadataCodedToken, metadataCodedTokenInvalidReason, metadataToken, readMetadataString, } from "./ManagedMetadataHeaps.js";
@@ -275,7 +276,7 @@ export const nativeBoundarySummary = (native, counts) => ({
             native.managed_native_header_size !== 0 ||
             native.native_entry_point,
 });
-export const buildNativeBoundaryInspection = ({ target, bytes, layout, inventory, moduleRefs, imports, implementations, native, issues, }) => managedNativeBoundaryInspectionSchema.parse({
+export const buildNativeBoundaryInspection = ({ target, bytes, layout, inventory, moduleRefs, imports, implementations, native, issues, }) => managedNativeBoundaryInspectionSchema.parse(admitManagedProjection({
     artifact: {
         path: target.path,
         sha256: target.sha256,
@@ -311,4 +312,4 @@ export const buildNativeBoundaryInspection = ({ target, bytes, layout, inventory
         "Managed metadata tokens are build-local coordinates and are only meaningful with the reported artifact SHA-256 and MVID.",
         "ReadyToRun, NativeAOT, C++/CLI, and IL2CPP native semantics require separately selected native-provider evidence; this tool does not translate managed tokens into native addresses.",
     ],
-});
+}, managedDecodeBudget(layout)));