rea-agents 6.1.0 → 6.3.0

package/dist/dotnet/ManagedArtifactInspector.js

@@ -1,6 +1,6 @@
 import { managedArtifactInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import { readManagedPeLayout, } from "./ManagedPeReader.js";
-import { managedTableRowCounts, readManagedMetadataInventory, } from "./ManagedMetadataInventory.js";
+import { managedTableRowCounts, readManagedMetadataInventory, readManagedResourceDirectory, } from "./ManagedMetadataInventory.js";
 import { readManagedMetadataLayout, } from "./ManagedMetadataLayout.js";
 import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
 const flagNames = (flags) => {
@@ -228,23 +228,6 @@ const partialMetadataResult = ({ target, bytes, layout, issue, }) => ({
         "CLI metadata could not be read because the PE/CLI structure is malformed or unsupported.",
     ],
 });
-const mapResources = (bytes, layout, issues) => {
-    const resources = layout.cli?.resources;
-    if (resources === undefined || (resources.rva === 0 && resources.size === 0))
-        return null;
-    try {
-        return {
-            offset: layout.rvaToOffset(resources.rva, resources.size, "cli.resources"),
-            size: resources.size,
-        };
-    }
-    catch (cause) {
-        if (!(cause instanceof ManagedReaderFailure))
-            throw cause;
-        issues.push(cause.issue);
-        return null;
-    }
-};
 /** Inspect PE/CLI identity directly from local bytes without CLR loading. */
 export const inspectManagedArtifactBytes = (bytes, target) => {
     const layout = readManagedPeLayout(bytes);
@@ -267,7 +250,7 @@ export const inspectManagedArtifactBytes = (bytes, target) => {
         }));
     }
     const resourceIssues = [];
-    const resourceDirectory = mapResources(bytes, layout, resourceIssues);
+    const resourceDirectory = readManagedResourceDirectory(layout, resourceIssues);
     const inventory = readManagedMetadataInventory(bytes, metadata, resourceDirectory);
     const issues = [...resourceIssues, ...inventory.issues];
     const limitations = [

package/dist/dotnet/ManagedMemberInspector.js

@@ -1,8 +1,8 @@
 import { managedMemberInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import { readManagedPeLayout, } from "./ManagedPeReader.js";
-import { managedTableRowCounts, readManagedMetadataInventory, } from "./ManagedMetadataInventory.js";
+import { readManagedResourceDirectory, managedTableRowCounts, readManagedMetadataInventory, } from "./ManagedMetadataInventory.js";
 import { readManagedMetadataLayout } from "./ManagedMetadataLayout.js";
-import { ManagedReaderFailure } from "./ManagedReaderFailure.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({
@@ -39,23 +39,13 @@ const unavailable = (target, bytes, issue) => managedMemberInspectionSchema.pars
             : "The CLI metadata could not be admitted; managed member inspection is unavailable.",
     ],
 });
-const resourceDirectory = (pe) => {
-    if (pe.cli === null ||
-        pe.cli.resources.rva === 0 ||
-        pe.cli.resources.size === 0)
-        return null;
-    return {
-        offset: pe.rvaToOffset(pe.cli.resources.rva, pe.cli.resources.size, "cli.resources"),
-        size: pe.cli.resources.size,
-    };
-};
-const readMemberInventory = (bytes, pe) => {
+const readMemberInventory = (bytes, pe, issues) => {
     const cli = pe.cli;
     if (cli === null)
         throw new TypeError("Managed inventory requires CLI metadata");
     const rootOffset = pe.rvaToOffset(cli.metadata.rva, cli.metadata.size, "cli.metadata");
     const layout = readManagedMetadataLayout(bytes, rootOffset, cli.metadata.size);
-    const inventory = readManagedMetadataInventory(bytes, layout, resourceDirectory(pe));
+    const inventory = readManagedMetadataInventory(bytes, layout, readManagedResourceDirectory(pe, issues));
     return { layout, inventory };
 };
 /** Inspect metadata members and method bodies without loading target code. */
@@ -65,9 +55,9 @@ export const inspectManagedMembersBytes = (bytes, target) => {
         return unavailable(target, bytes, pe.cliIssue);
     const issues = [];
     try {
-        const { layout, inventory } = readMemberInventory(bytes, pe);
+        const { layout, inventory } = readMemberInventory(bytes, pe, issues);
         issues.push(...inventory.issues);
-        const ranges = typeRanges(bytes, layout);
+        const ranges = typeRanges(bytes, layout, issues);
         const parsedTypes = parseTypes(bytes, layout, ranges);
         issues.push(...parsedTypes.issues);
         const fields = parseFields(bytes, layout, ranges);
@@ -79,7 +69,11 @@ export const inspectManagedMembersBytes = (bytes, target) => {
             pe,
             ranges,
         });
-        const coverageIssues = issues;
+        issues.push(...fields.issues, ...methods.issues);
+        const coverageIssues = uniqueManagedParseIssues(issues);
+        const incompleteMembers = [...fields.fields, ...memberRefs.refs, ...methods.methods].some((member) => member.signature.parse_status !== "decoded") ||
+            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({
             artifact: {
@@ -106,7 +100,7 @@ export const inspectManagedMembersBytes = (bytes, target) => {
             call_edges: related.callEdges,
             field_accesses: related.fieldAccesses,
             coverage: {
-                state: coverageIssues.length === 0 ? "complete" : "partial",
+                state: issues.length === 0 && !incompleteMembers ? "complete" : "partial",
                 issues: coverageIssues,
             },
             limitations: [

package/dist/dotnet/ManagedMemberInspectorCore.js

@@ -1,4 +1,4 @@
-import { managedFailure, ManagedReaderFailure, } from "./ManagedReaderFailure.js";
+import { managedFailure, ManagedReaderFailure, readManagedValue, } from "./ManagedReaderFailure.js";
 import {} from "./ManagedMetadataLayout.js";
 import { metadataRowCursor, metadataCodedToken, metadataCodedTokenInvalidReason, metadataToken, readMetadataString, sha256Bytes, } from "./ManagedMetadataHeaps.js";
 const rowRange = (table, start, nextStart) => {
@@ -11,13 +11,14 @@ const rowRange = (table, start, nextStart) => {
     return { first: start, last: end - 1, count: end - start };
 };
 const fullName = (namespace, name) => namespace.length === 0 ? name : `${namespace}.${name}`;
-const readTypeRange = (bytes, layout, row) => {
+const readTypeRange = (bytes, layout, row, issues) => {
     const methods = layout.table(6);
     const fields = layout.table(4);
     const cursor = metadataRowCursor(bytes, layout, 2, row);
     cursor.readUInt32();
-    const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
-    const namespace = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
+    const nameIndex = cursor.readIndex(layout.stringIndexSize);
+    const namespaceIndex = cursor.readIndex(layout.stringIndexSize);
+    const declaredName = readManagedValue(() => fullName(readMetadataString(bytes, layout, namespaceIndex, layout.strings.size), readMetadataString(bytes, layout, nameIndex, layout.strings.size)), issues) ?? null;
     cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));
     const fieldStart = cursor.readIndex(layout.tableIndexSize(4));
     const methodStart = cursor.readIndex(layout.tableIndexSize(6));
@@ -35,18 +36,18 @@ const readTypeRange = (bytes, layout, row) => {
     }
     return {
         token: metadataToken(2, row),
-        fullName: fullName(namespace, name),
+        fullName: declaredName,
         fieldStart,
         fieldEnd: nextField,
         methodStart,
         methodEnd: nextMethod,
     };
 };
-export const typeRanges = (bytes, layout) => {
+export const typeRanges = (bytes, layout, issues) => {
     const typeTable = layout.table(2);
     const ranges = [];
     for (let row = 1; row <= (typeTable?.rowCount ?? 0); row += 1)
-        ranges.push(readTypeRange(bytes, layout, row));
+        ranges.push(readTypeRange(bytes, layout, row, issues));
     return ranges;
 };
 export const declaringType = (ranges, table, row) => {
@@ -99,44 +100,46 @@ export const parseTypes = (bytes, layout, ranges) => {
     const items = [];
     const issues = [];
     for (let row = 1; row <= (typeTable?.rowCount ?? 0); row += 1) {
-        const cursor = metadataRowCursor(bytes, layout, 2, row);
-        const flags = cursor.readUInt32();
-        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
-        const namespace = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
-        const extendsOffset = cursor.offset;
-        const extendsRaw = cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));
-        const fieldStart = cursor.readIndex(layout.tableIndexSize(4));
-        const methodStart = cursor.readIndex(layout.tableIndexSize(6));
-        const nextRange = ranges[row] ?? null;
-        const fieldRange = rowRange(fields, fieldStart, nextRange?.fieldStart ?? 0);
-        const methodRange = rowRange(methods, methodStart, nextRange?.methodStart ?? 0);
-        const extendsReason = metadataCodedTokenInvalidReason(extendsRaw, 2, [2, 1, 27], layout.rowCounts);
-        if (extendsReason !== null)
-            issues.push({
-                code: "invalid-row",
-                scope: `metadata.TypeDef:${metadataToken(2, row)}`,
-                offset: extendsOffset,
-                detail: `TypeDef Extends coded index 0x${extendsRaw.toString(16)} is invalid: ${extendsReason}`,
+        readManagedValue(() => {
+            const cursor = metadataRowCursor(bytes, layout, 2, row);
+            const flags = cursor.readUInt32();
+            const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
+            const namespace = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
+            const extendsOffset = cursor.offset;
+            const extendsRaw = cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));
+            const fieldStart = cursor.readIndex(layout.tableIndexSize(4));
+            const methodStart = cursor.readIndex(layout.tableIndexSize(6));
+            const nextRange = ranges[row] ?? null;
+            const fieldRange = rowRange(fields, fieldStart, nextRange?.fieldStart ?? 0);
+            const methodRange = rowRange(methods, methodStart, nextRange?.methodStart ?? 0);
+            const extendsReason = metadataCodedTokenInvalidReason(extendsRaw, 2, [2, 1, 27], layout.rowCounts);
+            if (extendsReason !== null)
+                issues.push({
+                    code: "invalid-row",
+                    scope: `metadata.TypeDef:${metadataToken(2, row)}`,
+                    offset: extendsOffset,
+                    detail: `TypeDef Extends coded index 0x${extendsRaw.toString(16)} is invalid: ${extendsReason}`,
+                });
+            items.push({
+                token: metadataToken(2, row),
+                row_offset: cursor.start,
+                namespace,
+                name,
+                full_name: fullName(namespace, name),
+                flags,
+                extends_token: metadataCodedToken(extendsRaw, 2, [2, 1, 27], layout.rowCounts),
+                field_list: {
+                    first_row: fieldRange.first,
+                    last_row: fieldRange.last,
+                    count: fieldRange.count,
+                },
+                method_list: {
+                    first_row: methodRange.first,
+                    last_row: methodRange.last,
+                    count: methodRange.count,
+                },
             });
-        items.push({
-            token: metadataToken(2, row),
-            row_offset: cursor.start,
-            namespace,
-            name,
-            full_name: fullName(namespace, name),
-            flags,
-            extends_token: metadataCodedToken(extendsRaw, 2, [2, 1, 27], layout.rowCounts),
-            field_list: {
-                first_row: fieldRange.first,
-                last_row: fieldRange.last,
-                count: fieldRange.count,
-            },
-            method_list: {
-                first_row: methodRange.first,
-                last_row: methodRange.last,
-                count: methodRange.count,
-            },
-        });
+        }, issues);
     }
     return { types: items, issues };
 };

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;

package/dist/dotnet/ManagedMemberRows.js

@@ -1,30 +1,34 @@
 import { createDeclaringTypeLookup, signature, } from "./ManagedMemberInspectorCore.js";
 import { metadataToken, metadataRowCursor, metadataCodedToken, metadataCodedTokenInvalidReason, readMetadataBlob, readMetadataString, } from "./ManagedMetadataHeaps.js";
+import { readManagedValue } from "./ManagedReaderFailure.js";
 import { methodBody } from "./ManagedMethodBodyReader.js";
 export const parseFields = (bytes, layout, ranges) => {
     const fields = [];
     const core = new Map();
+    const issues = [];
     const table = layout.table(4);
     const declaringType = createDeclaringTypeLookup(ranges, "field");
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
-        const cursor = metadataRowCursor(bytes, layout, 4, row);
-        const flags = cursor.readUInt16();
-        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
-        const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), layout.blob.size);
-        const declared = declaringType(row);
-        const token = metadataToken(4, row);
-        fields.push({
-            token,
-            row_offset: cursor.start,
-            declaring_type_token: declared?.token ?? null,
-            declaring_type: declared?.fullName ?? null,
-            name,
-            flags,
-            signature: signature(sig),
-        });
-        core.set(token, { token, name });
+        readManagedValue(() => {
+            const cursor = metadataRowCursor(bytes, layout, 4, row);
+            const flags = cursor.readUInt16();
+            const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
+            const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), layout.blob.size);
+            const declared = declaringType(row);
+            const token = metadataToken(4, row);
+            fields.push({
+                token,
+                row_offset: cursor.start,
+                declaring_type_token: declared?.token ?? null,
+                declaring_type: declared?.fullName ?? null,
+                name,
+                flags,
+                signature: signature(sig),
+            });
+            core.set(token, { token, name });
+        }, issues);
     }
-    return { fields, core };
+    return { fields, core, issues };
 };
 export const parseMemberRefs = (bytes, layout) => {
     const refs = [];
@@ -32,62 +36,71 @@ export const parseMemberRefs = (bytes, layout) => {
     const issues = [];
     const table = layout.table(10);
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
-        const cursor = metadataRowCursor(bytes, layout, 10, row);
-        const parentRaw = cursor.readIndex(layout.codedIndexSize("MemberRefParent"));
-        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
-        const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), layout.blob.size);
-        const token = metadataToken(10, row);
-        const parentReason = metadataCodedTokenInvalidReason(parentRaw, 3, [2, 1, 26, 6, 27], layout.rowCounts);
-        if (parentReason !== null || parentRaw === 0)
-            issues.push({
-                code: "invalid-row",
-                scope: `metadata.MemberRef:${token}`,
-                offset: cursor.start,
-                detail: parentReason === null
-                    ? "MemberRef parent coded index 0x0 is null, but the Class column must reference a row"
-                    : `MemberRef parent coded index 0x${parentRaw.toString(16)} is invalid: ${parentReason}`,
+        readManagedValue(() => {
+            const cursor = metadataRowCursor(bytes, layout, 10, row);
+            const parentRaw = cursor.readIndex(layout.codedIndexSize("MemberRefParent"));
+            const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
+            const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), layout.blob.size);
+            const token = metadataToken(10, row);
+            const parentReason = metadataCodedTokenInvalidReason(parentRaw, 3, [2, 1, 26, 6, 27], layout.rowCounts);
+            if (parentReason !== null || parentRaw === 0)
+                issues.push({
+                    code: "invalid-row",
+                    scope: `metadata.MemberRef:${token}`,
+                    offset: cursor.start,
+                    detail: parentReason === null
+                        ? "MemberRef parent coded index 0x0 is null, but the Class column must reference a row"
+                        : `MemberRef parent coded index 0x${parentRaw.toString(16)} is invalid: ${parentReason}`,
+                });
+            refs.push({
+                token,
+                row_offset: cursor.start,
+                parent_token: metadataCodedToken(parentRaw, 3, [2, 1, 26, 6, 27], layout.rowCounts),
+                name,
+                signature: signature(sig),
             });
-        refs.push({
-            token,
-            row_offset: cursor.start,
-            parent_token: metadataCodedToken(parentRaw, 3, [2, 1, 26, 6, 27], layout.rowCounts),
-            name,
-            signature: signature(sig),
-        });
-        core.set(token, { token, name });
+            core.set(token, { token, name });
+        }, issues);
     }
     return { refs, core, issues };
 };
 export const parseMethods = ({ bytes, layout, pe, ranges, }) => {
     const methods = [];
     const core = new Map();
+    const issues = [];
     const table = layout.table(6);
     const declaringType = createDeclaringTypeLookup(ranges, "method");
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
-        const cursor = metadataRowCursor(bytes, layout, 6, row);
-        const rva = cursor.readUInt32();
-        const implFlags = cursor.readUInt16();
-        const flags = cursor.readUInt16();
-        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
-        const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), layout.blob.size);
-        cursor.readIndex(layout.tableIndexSize(8));
-        const declared = declaringType(row);
-        const token = metadataToken(6, row);
-        methods.push({
-            token,
-            row_offset: cursor.start,
-            declaring_type_token: declared?.token ?? null,
-            declaring_type: declared?.fullName ?? null,
-            name,
-            rva,
-            impl_flags: implFlags,
-            flags,
-            signature: signature(sig),
-            body: methodBody(bytes, pe, rva, { implFlags, flags }),
-        });
-        core.set(token, { token, name, declaringType: declared?.fullName ?? null });
+        readManagedValue(() => {
+            const cursor = metadataRowCursor(bytes, layout, 6, row);
+            const rva = cursor.readUInt32();
+            const implFlags = cursor.readUInt16();
+            const flags = cursor.readUInt16();
+            const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
+            const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), layout.blob.size);
+            cursor.readIndex(layout.tableIndexSize(8));
+            const declared = declaringType(row);
+            const token = metadataToken(6, row);
+            methods.push({
+                token,
+                row_offset: cursor.start,
+                declaring_type_token: declared?.token ?? null,
+                declaring_type: declared?.fullName ?? null,
+                name,
+                rva,
+                impl_flags: implFlags,
+                flags,
+                signature: signature(sig),
+                body: methodBody(bytes, pe, rva, { implFlags, flags }),
+            });
+            core.set(token, {
+                token,
+                name,
+                declaringType: declared?.fullName ?? null,
+            });
+        }, issues);
     }
-    return { methods, core };
+    return { methods, core, issues };
 };
 const targetKind = (token) => token.startsWith("0x06")
     ? "method-def"

package/dist/dotnet/ManagedMetadataInventory.js

@@ -1,17 +1,16 @@
 import { METADATA_TABLE_NAMES, } from "./ManagedMetadataLayout.js";
 import { readAssembly, readAssemblyReference, readCustomAttribute, readModule, readResource, } from "./ManagedMetadataInventoryRows.js";
 import { metadataToken } from "./ManagedMetadataHeaps.js";
-import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
-const safeRead = (operation, issues) => {
-    try {
-        return operation();
-    }
-    catch (cause) {
-        if (!(cause instanceof ManagedReaderFailure))
-            throw cause;
-        issues.push(cause.issue);
-        return undefined;
-    }
+import { readManagedValue, uniqueManagedParseIssues, } from "./ManagedReaderFailure.js";
+/** Map optional embedded resources without discarding admitted CLI metadata. */
+export const readManagedResourceDirectory = (pe, issues) => {
+    const resources = pe.cli?.resources;
+    if (resources === undefined || (resources.rva === 0 && resources.size === 0))
+        return null;
+    return (readManagedValue(() => ({
+        offset: pe.rvaToOffset(resources.rva, resources.size, "cli.resources"),
+        size: resources.size,
+    }), issues) ?? null);
 };
 const readRows = (descriptor, read) => {
     const total = descriptor?.rowCount ?? 0;
@@ -23,9 +22,6 @@ const readRows = (descriptor, read) => {
     }
     return items;
 };
-const uniqueIssues = (issues) => [
-    ...new Map(issues.map((issue) => [JSON.stringify(issue), issue])).values(),
-];
 const heapExtent = (layout) => Math.max(layout.strings.size, layout.blob.size);
 const validateIdentityTableCounts = (layout, issues) => {
     const moduleRows = layout.table(0)?.rowCount ?? 0;
@@ -46,13 +42,13 @@ const validateIdentityTableCounts = (layout, issues) => {
         });
 };
 const readReferences = (bytes, layout, issues) => {
-    const references = readRows(layout.table(35), (row) => safeRead(() => readAssemblyReference(bytes, layout, row, heapExtent(layout)), issues));
+    const references = readRows(layout.table(35), (row) => readManagedValue(() => readAssemblyReference(bytes, layout, row, heapExtent(layout)), issues));
     return {
         references,
         referenceNames: [...new Set(references.map(({ name }) => name))].sort(),
     };
 };
-const readResources = ({ bytes, layout, resourceDirectory, issues, }) => readRows(layout.table(40), (row) => safeRead(() => readResource({
+const readResources = ({ bytes, layout, resourceDirectory, issues, }) => readRows(layout.table(40), (row) => readManagedValue(() => readResource({
     bytes,
     layout,
     row,
@@ -60,7 +56,7 @@ const readResources = ({ bytes, layout, resourceDirectory, issues, }) => readRow
     issues,
 }), issues));
 const readAttributes = (bytes, layout, issues) => {
-    const attributes = readRows(layout.table(12), (row) => safeRead(() => readCustomAttribute(bytes, layout, row, heapExtent(layout)), issues));
+    const attributes = readRows(layout.table(12), (row) => readManagedValue(() => readCustomAttribute(bytes, layout, row, heapExtent(layout)), issues));
     const targetFrameworks = new Set();
     for (const attribute of attributes) {
         if (attribute.parent_token === metadataToken(32, 1) &&
@@ -75,10 +71,8 @@ const readAttributes = (bytes, layout, issues) => {
 export const readManagedMetadataInventory = (bytes, layout, resourceDirectory) => {
     const issues = [];
     validateIdentityTableCounts(layout, issues);
-    const module = safeRead(() => readModule(bytes, layout, heapExtent(layout)), issues) ??
-        null;
-    const assembly = safeRead(() => readAssembly(bytes, layout, heapExtent(layout)), issues) ??
-        null;
+    const module = readManagedValue(() => readModule(bytes, layout, heapExtent(layout)), issues) ?? null;
+    const assembly = readManagedValue(() => readAssembly(bytes, layout, heapExtent(layout)), issues) ?? null;
     const { references, referenceNames } = readReferences(bytes, layout, issues);
     const resources = readResources({
         bytes,
@@ -95,7 +89,7 @@ export const readManagedMetadataInventory = (bytes, layout, resourceDirectory) =
         references,
         resources,
         attributes,
-        issues: uniqueIssues(issues),
+        issues: uniqueManagedParseIssues(issues),
     };
 };
 /** Stable table-name/count projection for caller-visible coverage. */

package/dist/dotnet/ManagedMethodBodyReader.js

@@ -1,6 +1,7 @@
 import { decodeInstructions, parseExceptionRegions, } from "./ManagedMemberInstructionDecoder.js";
 import { validateExceptionRegionRanges } from "./ManagedExceptionRegionValidation.js";
 import { sha256Bytes } from "./ManagedMetadataHeaps.js";
+import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
 const bodyStatus = (decodedIssue, truncatedInstructions, exceptionRegions) => {
     if (decodedIssue !== null || exceptionRegions?.status === "malformed")
         return "malformed";
@@ -114,6 +115,9 @@ export const methodBody = (bytes, pe, rva, implementation = {
         };
     }
     catch (cause) {
+        if (!(cause instanceof ManagedReaderFailure) &&
+            !(cause instanceof RangeError))
+            throw cause;
         return emptyMethodBody(rva, "malformed", cause instanceof Error ? cause.message : "Method body parse failed");
     }
 };