rea-agents 6.2.0 → 6.4.0

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

@@ -1,4 +1,3 @@
-const opcode = (code) => OPCODES.get(code);
 const PREFIX_OPCODES = new Set([
     "unaligned.",
     "volatile.",
@@ -361,7 +360,7 @@ export const decodeInstructions = (il) => {
             const first = il.readUInt8(offset);
             offset += 1;
             const code = first === 0xfe ? 0xfe00 + il.readUInt8(offset++) : first;
-            const descriptor = opcode(code);
+            const descriptor = OPCODES.get(code);
             if (descriptor === undefined) {
                 issue = `Unsupported CIL opcode 0x${code.toString(16)} at IL offset ${String(start)}`;
                 break;
@@ -394,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;
@@ -424,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)));

package/dist/dotnet/ManagedNativeBoundaryInspector.js

@@ -1,3 +1,4 @@
+import { admitManagedProjection } from "./ManagedDecodeBudget.js";
 import { managedNativeBoundaryInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import { readManagedMetadataInventory, readManagedResourceDirectory, } from "./ManagedMetadataInventory.js";
 import { readManagedMetadataLayout, } from "./ManagedMetadataLayout.js";
@@ -10,7 +11,7 @@ import { buildNativeBoundaryInspection, cliNative, nativeBoundarySummary, native
  * the header is absent (`not-managed`) or unreadable (`malformed`).
  */
 const emptyInspection = (target, bytes, classification, { native = null, issues = [], } = {}) => {
-    return managedNativeBoundaryInspectionSchema.parse({
+    return managedNativeBoundaryInspectionSchema.parse(admitManagedProjection({
         artifact: {
             path: target.path,
             sha256: target.sha256,
@@ -19,7 +20,11 @@ const emptyInspection = (target, bytes, classification, { native = null, issues
         },
         module: null,
         metadata: {
-            status: classification === "malformed" ? "malformed" : "absent",
+            status: issues.some((issue) => issue.code === "resource-limit")
+                ? "partial"
+                : classification === "malformed"
+                    ? "malformed"
+                    : "absent",
             version: null,
             table_row_counts: {},
         },
@@ -42,7 +47,7 @@ const emptyInspection = (target, bytes, classification, { native = null, issues
             "No CLI metadata was admitted; native boundary declarations are unavailable.",
             "Static inspection does not load or execute target code, so native export resolution is not performed.",
         ],
-    });
+    }));
 };
 const readBoundaryInventory = (bytes, pe, cli, issues) => {
     const metadataOffset = pe.rvaToOffset(cli.metadata.rva, cli.metadata.size, "cli.metadata");
@@ -79,35 +84,45 @@ export const inspectManagedNativeBoundariesBytes = (bytes, target) => {
             issues: [cause.issue],
         });
     }
-    const heapExtent = Math.max(layout.strings.size, layout.blob.size);
-    issues.push(...inventory.issues);
-    const moduleRefs = parseModuleRefs(bytes, layout, heapExtent, issues);
-    const members = new Map([
-        ...parseFields(bytes, layout, heapExtent, issues),
-        ...parseMethods(bytes, layout, heapExtent, issues),
-    ]);
-    const imports = parseImplMaps({
-        bytes,
-        layout,
-        heapExtent,
-        modules: moduleRefs,
-        members,
-        issues,
-    });
-    const pinvokeTokens = new Set(imports
-        .map(({ member_token }) => member_token)
-        .filter((token) => token !== null));
-    const implementations = nativeImplementations(members.values(), pinvokeTokens);
-    return buildNativeBoundaryInspection({
-        target,
-        bytes,
-        pe,
-        layout,
-        inventory,
-        moduleRefs,
-        imports,
-        implementations,
-        native: cliNative(pe),
-        issues,
-    });
+    try {
+        const heapExtent = Math.max(layout.strings.size, layout.blob.size);
+        issues.push(...inventory.issues);
+        const moduleRefs = parseModuleRefs(bytes, layout, heapExtent, issues);
+        const members = new Map([
+            ...parseFields(bytes, layout, heapExtent, issues),
+            ...parseMethods(bytes, layout, heapExtent, issues),
+        ]);
+        const imports = parseImplMaps({
+            bytes,
+            layout,
+            heapExtent,
+            modules: moduleRefs,
+            members,
+            issues,
+        });
+        const pinvokeTokens = new Set(imports
+            .map(({ member_token }) => member_token)
+            .filter((token) => token !== null));
+        const implementations = nativeImplementations(members.values(), pinvokeTokens);
+        return buildNativeBoundaryInspection({
+            target,
+            bytes,
+            pe,
+            layout,
+            inventory,
+            moduleRefs,
+            imports,
+            implementations,
+            native: cliNative(pe),
+            issues,
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof ManagedReaderFailure))
+            throw cause;
+        return emptyInspection(target, bytes, "malformed", {
+            native: cliNative(pe),
+            issues: [...issues, cause.issue],
+        });
+    }
 };