rea-agents 6.3.0 → 6.5.0

package/dist/dotnet/ManagedMetadataInventoryRows.js

@@ -1,14 +1,26 @@
+import { managedDecodeBudget } from "./ManagedDecodeBudget.js";
+import { memberDeclaringTypeRowLookup } from "./ManagedMemberOwnership.js";
 import { metadataRowOffset, } from "./ManagedMetadataLayout.js";
-import { metadataRowCursor, metadataCodedToken, metadataCodedTokenInvalidReason, metadataToken, readMetadataBlob, readMetadataGuid, readMetadataString, sha256Bytes, strongNameToken, } from "./ManagedMetadataHeaps.js";
-import { managedFailure } from "./ManagedReaderFailure.js";
-const publicKeyIdentity = (bytes, kind) => ({
+import { metadataRowCursor, metadataCodedToken, metadataCodedTokenInvalidReason, metadataToken, readMetadataBlob, readMetadataGuid, readMetadataString, } from "./ManagedMetadataHeaps.js";
+import { managedFailure, readManagedValue } from "./ManagedReaderFailure.js";
+const HAS_CUSTOM_ATTRIBUTE_TABLES = [
+    6, 4, 1, 2, 8, 9, 10, 0, 14, 23, 20, 17, 26, 27, 32, 35, 38, 39, 40, 42, 44,
+    43,
+];
+const CUSTOM_ATTRIBUTE_TYPE_TABLES = [undefined, undefined, 6, 10];
+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 +67,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 +90,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),
@@ -98,46 +112,19 @@ const readTypeName = ({ bytes, layout, table, row, heapExtent, }) => {
     const namespace = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), heapExtent);
     return namespace.length === 0 ? name : `${namespace}.${name}`;
 };
-const declaringTypeForMethod = (bytes, layout, methodRow, heapExtent) => {
-    const types = layout.table(2);
-    const methods = layout.table(6);
-    if (types === undefined || methods === undefined)
+const declaringTypeForMethod = (bytes, layout, methodRow, heapExtent, memberLists) => {
+    const owner = memberDeclaringTypeRowLookup(bytes, layout, 6, memberLists)(methodRow);
+    if (owner === 0)
         return null;
-    for (let row = 1; row <= types.rowCount; row += 1) {
-        const cursor = metadataRowCursor(bytes, layout, 2, row);
-        cursor.readUInt32();
-        const nameIndex = cursor.readIndex(layout.stringIndexSize);
-        const namespaceIndex = cursor.readIndex(layout.stringIndexSize);
-        cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));
-        cursor.readIndex(layout.tableIndexSize(4));
-        const methodStart = cursor.readIndex(layout.tableIndexSize(6));
-        const methodEnd = row === types.rowCount
-            ? methods.rowCount + 1
-            : methodListForType(bytes, layout, row + 1);
-        if (methodRow < methodStart || methodRow >= methodEnd)
-            continue;
-        const name = readMetadataString(bytes, layout, nameIndex, heapExtent);
-        const namespace = readMetadataString(bytes, layout, namespaceIndex, heapExtent);
-        return namespace.length === 0 ? name : `${namespace}.${name}`;
-    }
-    return null;
-};
-const methodListForType = (bytes, layout, row) => {
-    const cursor = metadataRowCursor(bytes, layout, 2, row);
-    cursor.readUInt32();
-    cursor.readIndex(layout.stringIndexSize);
-    cursor.readIndex(layout.stringIndexSize);
-    cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));
-    cursor.readIndex(layout.tableIndexSize(4));
-    return cursor.readIndex(layout.tableIndexSize(6));
+    return readTypeName({ bytes, layout, table: 2, row: owner, heapExtent });
 };
-const attributeTypeName = (bytes, layout, rawType, heapExtent) => {
+const attributeTypeName = (bytes, layout, rawType, heapExtent, memberLists) => {
     const tag = rawType & 7;
     const row = Math.floor(rawType / 8);
     if (row === 0)
         return null;
     if (tag === 2)
-        return declaringTypeForMethod(bytes, layout, row, heapExtent);
+        return declaringTypeForMethod(bytes, layout, row, heapExtent, memberLists);
     if (tag !== 3)
         return null;
     const memberRefs = layout.table(10);
@@ -164,7 +151,7 @@ const attributeTypeName = (bytes, layout, rawType, heapExtent) => {
             heapExtent,
         });
     if (parentTag === 3)
-        return declaringTypeForMethod(bytes, layout, parentRow, heapExtent);
+        return declaringTypeForMethod(bytes, layout, parentRow, heapExtent, memberLists);
     return null;
 };
 const decodeCompressedLength = (blob, offset) => {
@@ -191,7 +178,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 +187,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));
     }
@@ -209,36 +197,41 @@ const decodeFixedString = (blob) => {
         return null;
     }
 };
-export const readCustomAttribute = (bytes, layout, row, heapExtent) => {
+export const readCustomAttribute = (bytes, layout, row, heapExtent, issues, memberLists) => {
     const cursor = metadataRowCursor(bytes, layout, 12, row);
     const parentRaw = cursor.readIndex(layout.codedIndexSize("HasCustomAttribute"));
     const typeOffset = cursor.offset;
     const typeRaw = cursor.readIndex(layout.codedIndexSize("CustomAttributeType"));
     const value = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), heapExtent);
-    const parent = metadataCodedToken(parentRaw, 5, [
-        6, 4, 1, 2, 8, 9, 10, 0, 14, 23, 20, 17, 26, 27, 32, 35, 38, 39, 40, 42,
-        44, 43,
-    ], layout.rowCounts);
-    const parentReason = metadataCodedTokenInvalidReason(parentRaw, 5, [
-        6, 4, 1, 2, 8, 9, 10, 0, 14, 23, 20, 17, 26, 27, 32, 35, 38, 39, 40, 42,
-        44, 43,
-    ], layout.rowCounts);
-    if (parent === null)
+    const parent = metadataCodedToken(parentRaw, 5, HAS_CUSTOM_ATTRIBUTE_TABLES, layout.rowCounts);
+    if (parent === null) {
+        const parentReason = metadataCodedTokenInvalidReason(parentRaw, 5, HAS_CUSTOM_ATTRIBUTE_TABLES, layout.rowCounts);
         throw managedFailure("invalid-row", `metadata.CustomAttribute:${metadataToken(12, row)}`, `CustomAttribute parent coded index 0x${parentRaw.toString(16)} is invalid${parentReason === null ? " because the required parent is null" : `: ${parentReason}`}`, cursor.start);
-    const typeReason = metadataCodedTokenInvalidReason(typeRaw, 3, [undefined, undefined, 6, 10], layout.rowCounts);
-    if (typeReason !== null || typeRaw === 0)
-        throw managedFailure("invalid-row", `metadata.CustomAttribute:${metadataToken(12, row)}`, typeReason === null
-            ? "CustomAttribute constructor coded index 0x0 is null, but Type must reference a MethodDef or MemberRef row"
-            : `CustomAttribute constructor coded index 0x${typeRaw.toString(16)} is invalid: ${typeReason}`, typeOffset);
-    const typeName = attributeTypeName(bytes, layout, typeRaw, heapExtent);
+    }
+    const constructor = metadataCodedToken(typeRaw, 3, CUSTOM_ATTRIBUTE_TYPE_TABLES, layout.rowCounts);
+    if (constructor === null) {
+        const typeReason = metadataCodedTokenInvalidReason(typeRaw, 3, CUSTOM_ATTRIBUTE_TYPE_TABLES, layout.rowCounts);
+        issues.push({
+            code: "invalid-row",
+            scope: `metadata.CustomAttribute:${metadataToken(12, row)}`,
+            offset: typeOffset,
+            detail: typeReason === null
+                ? "CustomAttribute constructor coded index 0x0 is null, but Type must reference a MethodDef or MemberRef row"
+                : `CustomAttribute constructor coded index 0x${typeRaw.toString(16)} is invalid: ${typeReason}`,
+        });
+    }
+    let typeName = null;
+    if (constructor !== null)
+        typeName =
+            readManagedValue(() => attributeTypeName(bytes, layout, typeRaw, heapExtent, memberLists), issues) ?? null;
     return {
         parent_token: parent,
-        constructor_token: metadataCodedToken(typeRaw, 3, [undefined, undefined, 6, 10], layout.rowCounts),
+        constructor_token: constructor,
         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 +276,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 = [
@@ -77,7 +78,7 @@ const requireRange = (bytes, offset, length, scope) => {
         offset > bytes.length - length)
         throw managedFailure("invalid-metadata-root", scope, `${scope} leaves the metadata byte range`, Number.isSafeInteger(offset) && offset >= 0 ? offset : null);
 };
-const align4 = (value) => (value + 3) & ~3;
+const align4 = (value) => Math.ceil(value / 4) * 4;
 const readStreamName = (bytes, offset) => {
     const endLimit = Math.min(bytes.length, offset + 32);
     let end = offset;
@@ -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");
@@ -195,6 +198,13 @@ const buildMetadataTables = ({ tableBytes, rowCounts, heaps, valid, tablesOffset
             continue;
         tableCursor += 4;
     }
+    // CLR readers honor an optional extra-data word after the row counts.
+    // Its value is opaque; it is not a length or part of the first table row.
+    if (((tableBytes[6] ?? 0) & 0x40) !== 0) {
+        if (tableCursor > tableBytes.length - 4)
+            throw managedFailure("invalid-metadata-root", "metadata.tables-extra-data", "Metadata tables extra-data word is truncated", tablesOffset + tableCursor);
+        tableCursor += 4;
+    }
     for (let index = 0; index < METADATA_TABLE_NAMES.length; index += 1) {
         const count = rowCounts[index] ?? 0;
         if ((valid & (1n << BigInt(index))) === 0n)
@@ -220,7 +230,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 +241,7 @@ export const readManagedMetadataLayout = (artifact, rootOffset, size) => {
         valid,
         tablesOffset,
     });
-    return {
+    const layout = {
         rootOffset,
         size,
         version,
@@ -238,6 +249,7 @@ export const readManagedMetadataLayout = (artifact, rootOffset, size) => {
         strings: requireStream(streams, "#Strings"),
         guid: requireStream(streams, "#GUID"),
         blob: requireStream(streams, "#Blob"),
+        userStrings: streams.get("#US") ?? null,
         tables,
         rowCounts,
         stringIndexSize: heaps.string,
@@ -247,6 +259,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/ManagedMetadataRowSizes.js

@@ -2,7 +2,7 @@ import { managedFailure } from "./ManagedReaderFailure.js";
 const ROW_SIZE_FACTORIES = [
     ({ stringSize: s, guidSize: g }) => 2 + s + g * 3,
     ({ codedSize: c, stringSize: s }) => c("ResolutionScope") + s * 2,
-    ({ tableSize: t, codedSize: c, stringSize: s }) => 4 + s * 2 + c("TypeDefOrRef") + t(4) + t(6),
+    ({ tableSize: t, codedSize: c, stringSize: s }) => 4 + s * 2 + c("TypeDefOrRef") + Math.max(t(3), t(4)) + Math.max(t(5), t(6)),
     ({ tableSize: t }) => t(4),
     ({ stringSize: s, blobSize: b }) => 2 + s + b,
     ({ tableSize: t }) => t(6),

package/dist/dotnet/ManagedMethodBodyReader.js

@@ -1,3 +1,4 @@
+import { admitManagedProjection, } from "./ManagedDecodeBudget.js";
 import { decodeInstructions, parseExceptionRegions, } from "./ManagedMemberInstructionDecoder.js";
 import { validateExceptionRegionRanges } from "./ManagedExceptionRegionValidation.js";
 import { sha256Bytes } from "./ManagedMetadataHeaps.js";
@@ -40,17 +41,20 @@ 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) => {
+    // Without CIL there is nothing left unscanned.
     if (rva === 0)
-        return emptyMethodBody(rva, "absent", null);
-    if ((implementation.implFlags & 7) !== 0 ||
-        (implementation.flags & 0x2000) !== 0)
-        return emptyMethodBody(rva, "partial", "CIL decoding is unavailable for native, runtime, unmanaged, or P/Invoke implementations");
+        return { body: emptyMethodBody(rva, "absent", null), scanned: true };
+    const native = (implementation.implFlags & 7) !== 0 ||
+        (implementation.flags & 0x2000) !== 0;
+    if (native) {
+        const issue = "CIL decoding is unavailable for native, runtime, unmanaged, or P/Invoke implementations";
+        return { body: emptyMethodBody(rva, "partial", issue), scanned: true };
+    }
     try {
         const offset = pe.rvaToOffset(rva, 1, "method.body");
         const methodExtent = pe.rvaAvailableBytes(rva, "method.body");
@@ -62,7 +66,12 @@ 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);
-        const decoded = decodeInstructions(il);
+        // Bound the actual instruction records before allocating them. One raw
+        // byte is only an upper bound on count; wide operands do not create a
+        // separate instruction for every byte. Retained output is charged below.
+        const decoded = decodeInstructions(il, budget === undefined
+            ? undefined
+            : (start) => budget.admitTransient(256, ilOffset + start));
         const opcodeCounts = {};
         for (const instruction of decoded.parsed)
             opcodeCounts[instruction.opcode] =
@@ -81,12 +90,12 @@ export const methodBody = (bytes, pe, rva, implementation = {
             operand,
         ])), "utf8");
         const methodEnd = ilOffset + header.ilSize;
-        const sectionOffset = (methodEnd + 3) & ~3;
+        const sectionOffset = Math.ceil(methodEnd / 4) * 4;
         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 {
+        const body = {
             status,
             header_format: header.format,
             rva,
@@ -113,12 +122,26 @@ export const methodBody = (bytes, pe, rva, implementation = {
                     ? "Instruction decoding stopped before the end of the method body"
                     : null),
         };
+        return {
+            body: budget === undefined ? body : admitManagedProjection(body, budget),
+            scanned: decoded.issue === null && decoded.truncated === 0,
+        };
     }
     catch (cause) {
+        if (cause instanceof ManagedReaderFailure &&
+            cause.issue.code === "resource-limit")
+            throw cause;
         if (!(cause instanceof ManagedReaderFailure) &&
             !(cause instanceof RangeError))
             throw cause;
-        return emptyMethodBody(rva, "malformed", cause instanceof Error ? cause.message : "Method body parse failed");
+        return {
+            body: emptyMethodBody(rva, "malformed", cause instanceof Error ? cause.message : "Method body parse failed"),
+            scanned: false,
+        };
+    }
+    finally {
+        // IL and exception-section bookkeeping coexist until the body is built.
+        budget?.releaseTransient();
     }
 };
 const emptyMethodBody = (rva, status, issue) => ({

package/dist/dotnet/ManagedMethodSpecs.js

@@ -0,0 +1,78 @@
+import { methodGenericArity, specSignature, } from "./ManagedMemberInspectorCore.js";
+import { metadataCodedToken, metadataCodedTokenInvalidReason, metadataRowCursor, readMetadataBlob, } from "./ManagedMetadataHeaps.js";
+import { managedFailure, readManagedValue } from "./ManagedReaderFailure.js";
+/**
+ * Index fields, member references, and methods by token, then name each
+ * MethodSpec an inspected body calls after the generic method it instantiates,
+ * so every edge target resolves through one lookup.
+ */
+export const edgeTargets = (bytes, layout, methods, cores) => {
+    const members = new Map(cores.flatMap((core) => [...core]));
+    const issues = [];
+    const seen = new Set();
+    // Generic arity by method token, so instantiations of one method decode it once.
+    const arities = new Map();
+    for (const method of methods)
+        for (const { operand } of method.body.anchors) {
+            if (operand?.startsWith("0x2b") !== true || seen.has(operand))
+                continue;
+            seen.add(operand);
+            readManagedValue(() => readMethodSpec({ bytes, layout, members, issues, arities }, operand), issues);
+        }
+    return { members, issues };
+};
+/**
+ * Map one MethodSpec to its generic method, then check its instantiation
+ * decodes and matches that method's generic arity. A readable Method column
+ * keeps its name when the rest is malformed; the failure makes coverage partial.
+ */
+const readMethodSpec = ({ bytes, layout, members, issues, arities, }, token) => {
+    const scope = `metadata.MethodSpec:${token}`;
+    const cursor = metadataRowCursor(bytes, layout, 0x2b, Number.parseInt(token.slice(4), 16));
+    const methodRaw = cursor.readIndex(layout.codedIndexSize("MethodDefOrRef"));
+    const instantiation = cursor.readIndex(layout.blobIndexSize);
+    const methodReason = metadataCodedTokenInvalidReason(methodRaw, 1, [6, 10], layout.rowCounts);
+    if (methodReason !== null || methodRaw === 0)
+        issues.push({
+            code: "invalid-row",
+            scope,
+            offset: cursor.start,
+            detail: methodReason === null
+                ? "MethodSpec method coded index 0x0 is null, but the Method column must reference a row"
+                : `MethodSpec method coded index 0x${methodRaw.toString(16)} is invalid: ${methodReason}`,
+        });
+    const generic = metadataCodedToken(methodRaw, 1, [6, 10], layout.rowCounts);
+    const target = generic === null ? undefined : members.get(generic);
+    // A MethodSpec instantiates a method, so a field target never lends it a
+    // name, even to a field operand.
+    if (target !== undefined && target.kind !== "field")
+        members.set(token, { ...target, token });
+    const types = specSignature(layout, readMetadataBlob(bytes, layout, instantiation, layout.blob.size), { form: "instantiation", scope, offset: cursor.start });
+    if (generic === null)
+        return;
+    // Prefer the arity the target's owner decoded; read the raw signature only
+    // for a target nothing decoded, such as a MethodDef outside the selection.
+    if (target?.genericArity === undefined && !arities.has(generic))
+        arities.set(generic, methodGenericArity(layout, methodSignatureBlob(bytes, layout, generic)));
+    const arity = target?.genericArity === undefined
+        ? (arities.get(generic) ?? null)
+        : target.genericArity;
+    if (arity !== types.length)
+        throw managedFailure("invalid-row", scope, arity === null
+            ? "MethodSpec method does not have a decodable method signature"
+            : `MethodSpec supplies ${String(types.length)} type argument(s), but its method declares ${String(arity)} generic parameter(s)`, cursor.start);
+};
+/** The Signature column of a MethodDef or MemberRef row. */
+const methodSignatureBlob = (bytes, layout, token) => {
+    const table = Number.parseInt(token.slice(2, 4), 16);
+    const cursor = metadataRowCursor(bytes, layout, table, Number.parseInt(token.slice(4), 16));
+    if (table === 6) {
+        cursor.readUInt32();
+        cursor.readUInt16();
+        cursor.readUInt16();
+    }
+    else
+        cursor.readIndex(layout.codedIndexSize("MemberRefParent"));
+    cursor.readIndex(layout.stringIndexSize);
+    return readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), layout.blob.size);
+};

package/dist/dotnet/ManagedNativeBoundaryHelpers.js

@@ -1,7 +1,8 @@
+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";
 import { managedTableRowCounts } from "./ManagedMetadataInventory.js";
+import { managedCli32BitRequirement, } from "./ManagedPeReader.js";
 import { readManagedValue } from "./ManagedReaderFailure.js";
 const flagsHex = (value) => `0x${value.toString(16).padStart(4, "0")}`;
 export const parseModuleRefs = (bytes, layout, heapExtent, issues) => {
@@ -257,7 +258,7 @@ export const cliNative = (pe) => {
         return null;
     return {
         il_only: (pe.cli.flags & 0x0000_0001) !== 0,
-        requires_32bit: (pe.cli.flags & 0x0000_0002) !== 0,
+        requires_32bit: managedCli32BitRequirement(pe.cli.flags) === "required",
         strong_name_signed: (pe.cli.flags & 0x0000_0008) !== 0,
         native_entry_point: (pe.cli.flags & 0x0000_0010) !== 0,
         ready_to_run_signature: pe.cli.readyToRunSignature,
@@ -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,6 +1,8 @@
+import { admitManagedProjection } from "./ManagedDecodeBudget.js";
 import { managedNativeBoundaryInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import { readManagedMetadataInventory, readManagedResourceDirectory, } from "./ManagedMetadataInventory.js";
 import { readManagedMetadataLayout, } from "./ManagedMetadataLayout.js";
+import { readTypeMemberListFacts } from "./ManagedTypeMemberLists.js";
 import { readManagedPeLayout, } from "./ManagedPeReader.js";
 import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
 import { buildNativeBoundaryInspection, cliNative, nativeBoundarySummary, nativeImplementations, parseFields, parseImplMaps, parseMethods, parseModuleRefs, } from "./ManagedNativeBoundaryHelpers.js";
@@ -10,7 +12,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 +21,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,72 +48,74 @@ 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");
     const layout = readManagedMetadataLayout(bytes, metadataOffset, cli.metadata.size);
-    const inventory = readManagedMetadataInventory(bytes, layout, readManagedResourceDirectory(pe, issues));
+    const memberLists = readTypeMemberListFacts(bytes, layout);
+    const inventory = readManagedMetadataInventory(bytes, layout, readManagedResourceDirectory(pe, issues), memberLists);
     return { layout, inventory };
 };
 /** Inspect managed/native boundary declarations from PE metadata without execution. */
 export const inspectManagedNativeBoundariesBytes = (bytes, target) => {
-    let pe;
+    // An unmappable PE layout is invalid input for every managed operation.
+    const pe = readManagedPeLayout(bytes);
+    if (pe.cli === null)
+        return emptyInspection(target, bytes, pe.cliDirectoryState !== "absent" ? "malformed" : "not-managed", { issues: pe.cliIssue === null ? [] : [pe.cliIssue] });
+    const issues = [];
+    let layout;
+    let inventory;
     try {
-        pe = readManagedPeLayout(bytes);
+        ({ layout, inventory } = readBoundaryInventory(bytes, pe, pe.cli, issues));
     }
     catch (cause) {
         if (!(cause instanceof ManagedReaderFailure))
             throw cause;
         return emptyInspection(target, bytes, "malformed", {
+            native: cliNative(pe),
             issues: [cause.issue],
         });
     }
-    if (pe.cli === null)
-        return emptyInspection(target, bytes, pe.cliDirectoryPresent ? "malformed" : "not-managed", { issues: pe.cliIssue === null ? [] : [pe.cliIssue] });
-    const issues = [];
-    let layout;
-    let inventory;
     try {
-        ({ layout, inventory } = readBoundaryInventory(bytes, pe, pe.cli, issues));
+        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: [cause.issue],
+            issues: [...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,
-    });
 };