rea-agents 6.3.0 → 6.5.0

package/dist/dotnet/ManagedMemberRows.js

@@ -1,21 +1,35 @@
-import { createDeclaringTypeLookup, signature, } from "./ManagedMemberInspectorCore.js";
+import { admitManagedProjection, managedDecodeBudget, managedJsonStringBytes, } from "./ManagedDecodeBudget.js";
+import { signature, signatureGenericArity, } 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) => {
+import { memberDeclaringTypeRowLookup } from "./ManagedMemberOwnership.js";
+const isSelected = (selected, declared) => selected === null || (declared !== undefined && selected.has(declared.token));
+export const parseFields = (bytes, layout, ranges, memberLists, selected = null) => {
     const fields = [];
     const core = new Map();
     const issues = [];
     const table = layout.table(4);
-    const declaringType = createDeclaringTypeLookup(ranges, "field");
+    const ownerRow = readManagedValue(() => memberDeclaringTypeRowLookup(bytes, layout, 4, memberLists), issues);
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
         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 owner = ownerRow === undefined
+                ? 0
+                : (readManagedValue(() => ownerRow(row), issues) ?? 0);
+            const declared = ranges[owner - 1];
             const token = metadataToken(4, row);
+            core.set(token, {
+                token,
+                name,
+                declaringType: declared?.fullName ?? null,
+                kind: "field",
+            });
+            if (!isSelected(selected, declared))
+                return;
+            const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), layout.blob.size);
             fields.push({
                 token,
                 row_offset: cursor.start,
@@ -23,14 +37,53 @@ 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);
     }
     return { fields, core, issues };
 };
-export const parseMemberRefs = (bytes, layout) => {
+const TYPE_FORWARDER_FLAG = 0x0020_0000;
+/** Read ExportedType rows, including type forwarders, as declared. */
+export const parseExportedTypes = (bytes, layout) => {
+    const exportedTypes = [];
+    const issues = [];
+    const table = layout.table(39);
+    for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
+        readManagedValue(() => {
+            const cursor = metadataRowCursor(bytes, layout, 39, row);
+            const flags = cursor.readUInt32();
+            const typeDefId = 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 implementationOffset = cursor.offset;
+            const implementationRaw = cursor.readIndex(layout.codedIndexSize("Implementation"));
+            const token = metadataToken(39, row);
+            const implementationReason = metadataCodedTokenInvalidReason(implementationRaw, 2, [38, 35, 39], layout.rowCounts);
+            if (implementationReason !== null || implementationRaw === 0)
+                issues.push({
+                    code: "invalid-row",
+                    scope: `metadata.ExportedType:${token}`,
+                    offset: implementationOffset,
+                    detail: implementationReason === null
+                        ? "ExportedType implementation coded index 0x0 is null, but the Implementation column must reference a row"
+                        : `ExportedType implementation coded index 0x${implementationRaw.toString(16)} is invalid: ${implementationReason}`,
+                });
+            exportedTypes.push({
+                token,
+                row_offset: cursor.start,
+                namespace,
+                name,
+                flags,
+                forwarder: (flags & TYPE_FORWARDER_FLAG) !== 0,
+                type_def_id: typeDefId,
+                implementation_token: metadataCodedToken(implementationRaw, 2, [38, 35, 39], layout.rowCounts),
+            });
+        }, issues);
+    }
+    return { exportedTypes, issues };
+};
+export const parseMemberRefs = (bytes, layout, typeName) => {
     const refs = [];
     const core = new Map();
     const issues = [];
@@ -52,35 +105,78 @@ export const parseMemberRefs = (bytes, layout) => {
                         ? "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}`,
                 });
+            const parentToken = metadataCodedToken(parentRaw, 3, [2, 1, 26, 6, 27], layout.rowCounts);
+            const parentName = typeName(parentToken);
+            const decoded = budgetedSignature(sig, layout);
             refs.push({
                 token,
                 row_offset: cursor.start,
-                parent_token: metadataCodedToken(parentRaw, 3, [2, 1, 26, 6, 27], layout.rowCounts),
+                parent_token: parentToken,
+                parent_name: parentName,
                 name,
-                signature: signature(sig),
+                signature: decoded,
+            });
+            core.set(token, {
+                token,
+                name,
+                declaringType: parentName,
+                kind: decoded.kind,
+                genericArity: signatureGenericArity(decoded),
             });
-            core.set(token, { token, name });
         }, issues);
     }
     return { refs, core, issues };
 };
-export const parseMethods = ({ bytes, layout, pe, ranges, }) => {
+export const parseMethods = ({ bytes, layout, pe, ranges, memberLists, selected = null, methodOffset = 0, methodLimit = Number.MAX_SAFE_INTEGER, }) => {
     const methods = [];
     const core = new Map();
     const issues = [];
+    let unscannedMethods = 0;
     const table = layout.table(6);
-    const declaringType = createDeclaringTypeLookup(ranges, "method");
+    const ownerRow = readManagedValue(() => memberDeclaringTypeRowLookup(bytes, layout, 6, memberLists), issues);
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
+        // The owner is read first: a row that produced no method hides a selected
+        // body only when its owner is selected, unknown, or unreadably named.
+        const owner = ownerRow === undefined
+            ? undefined
+            : readManagedValue(() => ownerRow(row), issues);
+        const declared = owner === undefined ? undefined : ranges[owner - 1];
+        const inPage = row > methodOffset && row - methodOffset <= methodLimit;
+        const mayBeSelected = inPage &&
+            (selected === null ||
+                owner === undefined ||
+                isSelected(selected, declared) ||
+                // A type whose name is unreadable may be one the caller requested.
+                declared?.fullName === null);
+        const produced = methods.length;
         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 token = metadataToken(6, row);
+            const member = {
+                token,
+                name,
+                declaringType: declared?.fullName ?? null,
+                kind: "method",
+            };
+            core.set(token, member);
+            if (!inPage)
+                return;
+            if (!isSelected(selected, declared))
+                return;
             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);
+            const decoded = budgetedSignature(sig, layout);
+            core.set(token, {
+                ...member,
+                genericArity: signatureGenericArity(decoded),
+            });
+            const read = methodBody(bytes, pe, rva, { implFlags, flags }, managedDecodeBudget(layout));
+            if (!read.scanned)
+                unscannedMethods += 1;
             methods.push({
                 token,
                 row_offset: cursor.start,
@@ -90,18 +186,23 @@ export const parseMethods = ({ bytes, layout, pe, ranges, }) => {
                 rva,
                 impl_flags: implFlags,
                 flags,
-                signature: signature(sig),
-                body: methodBody(bytes, pe, rva, { implFlags, flags }),
-            });
-            core.set(token, {
-                token,
-                name,
-                declaringType: declared?.fullName ?? null,
+                signature: decoded,
+                body: read.body,
             });
         }, issues);
+        if (mayBeSelected && methods.length === produced)
+            unscannedMethods += 1;
     }
-    return { methods, core, issues };
+    return { methods, core, issues, unscannedMethods };
 };
+/**
+ * Member kinds each operand kind may name. A MemberRef whose signature does
+ * not decode keeps its name on calls, as before, but is never named a field.
+ */
+const NAMEABLE_KINDS = new Map([
+    ["method", new Set(["method", "unknown"])],
+    ["field", new Set(["field"])],
+]);
 const targetKind = (token) => token.startsWith("0x06")
     ? "method-def"
     : token.startsWith("0x0a")
@@ -109,40 +210,77 @@ const targetKind = (token) => token.startsWith("0x06")
         : token.startsWith("0x2b")
             ? "method-spec"
             : "unknown";
-export const edges = (methods, methodCore, fieldCore, refCore) => {
+/** The member an operand names, if the operand kind can name that member's kind. */
+const namedTarget = (members, operandKind, operand) => {
+    const member = members.get(operand);
+    return member !== undefined &&
+        NAMEABLE_KINDS.get(operandKind)?.has(member.kind) === true
+        ? member
+        : undefined;
+};
+export const edges = (methods, members, budget) => {
     const callEdges = [];
     const fieldAccesses = [];
     for (const method of methods) {
+        const derives = method.body.anchors.some((anchor) => anchor.opcode !== "ldtoken" &&
+            anchor.operand !== null &&
+            (anchor.operand_kind === "method" || anchor.operand_kind === "field"));
+        if (derives)
+            budget.admitTransient(callerNameBytes(method), null);
+        // Built once per method, only after its exact size was admitted.
+        const caller = derives ? callerName(method) : method.name;
         for (const anchor of method.body.anchors) {
             if (anchor.opcode === "ldtoken")
                 continue;
-            if (anchor.operand_kind === "method" && anchor.operand !== null) {
-                const named = methodCore.get(anchor.operand)?.name ??
-                    refCore.get(anchor.operand)?.name ??
-                    null;
-                callEdges.push({
+            const { operand } = anchor;
+            if (operand === null)
+                continue;
+            const target = namedTarget(members, anchor.operand_kind, operand);
+            if (anchor.operand_kind === "method") {
+                // Each derived record is admitted before the graph grows further.
+                callEdges.push(admitManagedProjection({
                     caller_token: method.token,
-                    caller: method.declaring_type === null
-                        ? method.name
-                        : `${method.declaring_type}.${method.name}`,
+                    caller,
                     opcode: anchor.opcode,
-                    target_token: anchor.operand,
-                    target_kind: targetKind(anchor.operand),
-                    target_name: named,
-                });
+                    target_token: operand,
+                    target_kind: targetKind(operand),
+                    target_name: target?.name ?? null,
+                    target_declaring_type: target?.declaringType ?? null,
+                }, budget));
             }
-            if (anchor.operand_kind === "field" && anchor.operand !== null) {
-                fieldAccesses.push({
+            if (anchor.operand_kind === "field") {
+                fieldAccesses.push(admitManagedProjection({
                     method_token: method.token,
-                    method: method.declaring_type === null
-                        ? method.name
-                        : `${method.declaring_type}.${method.name}`,
+                    method: caller,
                     opcode: anchor.opcode,
-                    field_token: anchor.operand,
-                    field_name: fieldCore.get(anchor.operand)?.name ?? null,
-                });
+                    field_token: operand,
+                    field_name: target?.name ?? null,
+                    field_declaring_type: target?.declaringType ?? null,
+                }, budget));
             }
         }
+        // Every record now reserves the name it carries.
+        if (derives)
+            budget.releaseTransient();
     }
     return { callEdges, fieldAccesses };
 };
+const callerName = (method) => method.declaring_type === null
+    ? method.name
+    : `${method.declaring_type}.${method.name}`;
+/** JSON bytes of `callerName`, from its parts: the joining dot adds one byte. */
+const callerNameBytes = (method) => method.declaring_type === null
+    ? managedJsonStringBytes(method.name)
+    : managedJsonStringBytes(method.declaring_type) +
+        managedJsonStringBytes(method.name) -
+        1;
+const budgetedSignature = (bytes, layout) => {
+    const budget = managedDecodeBudget(layout);
+    budget.admitTransient(bytes.length * 256, layout.blob.offset);
+    try {
+        return admitManagedProjection(signature(bytes, budget.digest(bytes, "sha256")), budget);
+    }
+    finally {
+        budget.releaseTransient();
+    }
+};

package/dist/dotnet/ManagedMetadataHeaps.js

@@ -1,10 +1,7 @@
 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) => {
-    if (offset < 0 || length < 0 || offset > bytes.length - length)
-        throw managedFailure("invalid-row", scope, `${scope} leaves the artifact byte range`, offset >= 0 ? offset : null);
-};
 /** Cursor for checked fixed-width metadata row decoding. */
 export class MetadataRowCursor {
     bytes;
@@ -42,29 +39,35 @@ export class MetadataRowCursor {
             throw managedFailure("invalid-row", this.scope, `${this.scope} row ended before all declared columns`, this.#offset);
     }
 }
-const compressedLength = (bytes, offset, scope) => {
-    requireRange(bytes, offset, 1, scope);
+// Issue code and label for the heap item a compressed length prefixes.
+const PREFIXED_ITEMS = {
+    blob: { code: "invalid-blob", label: "Metadata blob" },
+    userString: { code: "invalid-string", label: "User string" },
+};
+const compressedLength = (bytes, offset, scope, item) => {
+    const { code, label } = PREFIXED_ITEMS[item];
+    const requirePrefix = (size) => {
+        if (offset < 0 || offset > bytes.length - size)
+            throw managedFailure(code, scope, `${label} length prefix leaves the artifact byte range`, offset >= 0 ? offset : null);
+    };
+    requirePrefix(1);
     const first = bytes[offset] ?? 0;
     if ((first & 0x80) === 0)
-        return { length: first, prefix: 1 };
+        return { length: first, prefix: 1, minimal: true };
     if ((first & 0xc0) === 0x80) {
-        requireRange(bytes, offset, 2, scope);
-        return {
-            length: ((first & 0x3f) << 8) | (bytes[offset + 1] ?? 0),
-            prefix: 2,
-        };
+        requirePrefix(2);
+        const length = ((first & 0x3f) << 8) | (bytes[offset + 1] ?? 0);
+        return { length, prefix: 2, minimal: length >= 0x80 };
     }
     if ((first & 0xe0) === 0xc0) {
-        requireRange(bytes, offset, 4, scope);
-        return {
-            length: (first & 0x1f) * 0x01_00_00_00 +
-                (bytes[offset + 1] ?? 0) * 0x01_00_00 +
-                (bytes[offset + 2] ?? 0) * 0x0100 +
-                (bytes[offset + 3] ?? 0),
-            prefix: 4,
-        };
+        requirePrefix(4);
+        const length = (first & 0x1f) * 0x01_00_00_00 +
+            (bytes[offset + 1] ?? 0) * 0x01_00_00 +
+            (bytes[offset + 2] ?? 0) * 0x0100 +
+            (bytes[offset + 3] ?? 0);
+        return { length, prefix: 4, minimal: length >= 0x4000 };
     }
-    throw managedFailure("invalid-blob", scope, "Metadata blob uses a reserved compressed-length prefix", offset);
+    throw managedFailure(code, scope, `${label} uses a reserved compressed-length prefix`, offset);
 };
 /** Read one UTF-8 value from #Strings within its PE/CLI stream extent. */
 export const readMetadataString = (bytes, layout, index, heapExtent) => {
@@ -73,14 +76,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;
@@ -94,7 +108,7 @@ export const readMetadataBlob = (bytes, layout, index, heapExtent) => {
     if (index < 0 || index >= layout.blob.size)
         throw managedFailure("invalid-heap-index", "metadata.#Blob", "Blob heap index is outside #Blob", layout.blob.offset + Math.max(index, 0));
     const start = layout.blob.offset + index;
-    const decoded = compressedLength(bytes, start, "metadata.#Blob");
+    const decoded = compressedLength(bytes, start, "metadata.#Blob", "blob");
     if (decoded.length > heapExtent)
         throw managedFailure("invalid-blob", "metadata.#Blob", "Blob length exceeds the admitted heap extent", start);
     const content = start + decoded.prefix;
@@ -102,6 +116,89 @@ export const readMetadataBlob = (bytes, layout, index, heapExtent) => {
         throw managedFailure("invalid-blob", "metadata.#Blob", "Blob heap item leaves #Blob", start);
     return bytes.subarray(content, content + decoded.length);
 };
+/**
+ * Read the #US literal named by a `0x70` user-string token: a compressed byte
+ * length, UTF-16LE code units, then one ECMA-335 terminal flag byte. Code units
+ * are kept as stored, including unpaired surrogates. `parseUserStrings` owns
+ * which `ldstr` operands are user-string tokens.
+ */
+export const readMetadataUserString = (bytes, layout, token) => {
+    const heap = layout.userStrings;
+    const scope = `metadata.#US:${token}`;
+    if (heap === null)
+        throw managedFailure("missing-stream", scope, "ldstr references #US, but the metadata has no #US stream");
+    const index = Number.parseInt(token.slice(4), 16);
+    if (index >= heap.size)
+        throw managedFailure("invalid-heap-index", scope, "ldstr operand does not name an item inside #US", heap.offset + index);
+    const start = heap.offset + index;
+    const decoded = compressedLength(bytes, start, scope, "userString");
+    const content = start + decoded.prefix;
+    if (content > heap.offset + heap.size - decoded.length)
+        throw managedFailure("invalid-string", scope, "User string leaves #US", start);
+    const budget = managedDecodeBudget(layout);
+    // A wider length prefix than the value needs still reads unambiguously, so
+    // it is reported like the flag rather than discarding the literal. It is
+    // admitted only on paths that return the literal, so a fatal item leaves
+    // no budget behind.
+    const conformance = () => {
+        if (decoded.minimal)
+            return [];
+        budget.reserve(512, start);
+        return [
+            {
+                code: "invalid-string",
+                scope,
+                offset: start,
+                detail: `User string length ${String(decoded.length)} uses a ${String(decoded.prefix)}-byte prefix wider than ECMA-335 II.23.2 assigns; readable UTF-16 is preserved and runtime acceptance is not assessed`,
+            },
+        ];
+    };
+    // ECMA-335 II.24.2.4: offset 0 is the heap's empty entry, a zero length
+    // with no terminal flag byte; every other item carries the flag.
+    if (index === 0) {
+        if (decoded.length === 0)
+            return { offset: start, value: "", issues: conformance() };
+        throw managedFailure("invalid-string", scope, `#US offset 0 is the reserved empty entry, but it encodes ${String(decoded.length)} byte(s)`, start);
+    }
+    if (decoded.length % 2 !== 1)
+        throw managedFailure("invalid-string", scope, "User string length is not UTF-16 code units plus one terminal flag byte", start);
+    const units = (decoded.length - 1) / 2;
+    // Admit the literal before scanning it: JSON spends at most six bytes per
+    // UTF-16 code unit.
+    budget.reserveString(units, start);
+    // Check the serialized flag independently of literal decoding. A difference
+    // from ECMA-335 is observable metadata, not proof of runtime rejection.
+    let expectedFlag = 0;
+    for (let unitIndex = 0; unitIndex < units; unitIndex++) {
+        const unit = bytes.readUInt16LE(content + unitIndex * 2);
+        if (unit > 0xff ||
+            (unit >= 0x01 && unit <= 0x08) ||
+            (unit >= 0x0e && unit <= 0x1f) ||
+            unit === 0x27 ||
+            unit === 0x2d ||
+            unit === 0x7f) {
+            expectedFlag = 1;
+            break;
+        }
+    }
+    const flagOffset = content + units * 2;
+    const actualFlag = bytes[flagOffset];
+    const issues = conformance();
+    if (actualFlag !== expectedFlag) {
+        budget.reserve(512, flagOffset);
+        issues.push({
+            code: "invalid-string",
+            scope,
+            offset: flagOffset,
+            detail: `User string terminal flag ${String(actualFlag)} differs from ECMA-335 II.24.2.4 value ${String(expectedFlag)}; readable UTF-16 is preserved and runtime acceptance is not assessed`,
+        });
+    }
+    return {
+        offset: start,
+        value: bytes.subarray(content, flagOffset).toString("utf16le"),
+        issues,
+    };
+};
 /** Read one conventional GUID value from the one-based #GUID heap. */
 export const readMetadataGuid = (bytes, layout, index) => {
     if (index === 0)
@@ -127,16 +224,15 @@ 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);
+    // Temporary cursors may revisit a row while resolving owners or references.
+    // Bind fixed retained bookkeeping to that row's identity, not each lookup.
+    managedDecodeBudget(layout).reserveRow(table, row, 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/ManagedMetadataInventory.js

@@ -55,8 +55,8 @@ const readResources = ({ bytes, layout, resourceDirectory, issues, }) => readRow
     directory: resourceDirectory,
     issues,
 }), issues));
-const readAttributes = (bytes, layout, issues) => {
-    const attributes = readRows(layout.table(12), (row) => readManagedValue(() => readCustomAttribute(bytes, layout, row, heapExtent(layout)), issues));
+const readAttributes = (bytes, layout, issues, memberLists) => {
+    const attributes = readRows(layout.table(12), (row) => readManagedValue(() => readCustomAttribute(bytes, layout, row, heapExtent(layout), issues, memberLists), issues));
     const targetFrameworks = new Set();
     for (const attribute of attributes) {
         if (attribute.parent_token === metadataToken(32, 1) &&
@@ -68,8 +68,8 @@ const readAttributes = (bytes, layout, issues) => {
     return { attributes, targetFrameworks: [...targetFrameworks].sort() };
 };
 /** Inventory identity tables without CLR reflection or execution. */
-export const readManagedMetadataInventory = (bytes, layout, resourceDirectory) => {
-    const issues = [];
+export const readManagedMetadataInventory = (bytes, layout, resourceDirectory, memberLists) => {
+    const issues = [...memberLists.issues];
     validateIdentityTableCounts(layout, issues);
     const module = readManagedValue(() => readModule(bytes, layout, heapExtent(layout)), issues) ?? null;
     const assembly = readManagedValue(() => readAssembly(bytes, layout, heapExtent(layout)), issues) ?? null;
@@ -80,7 +80,7 @@ export const readManagedMetadataInventory = (bytes, layout, resourceDirectory) =
         resourceDirectory,
         issues,
     });
-    const { attributes, targetFrameworks } = readAttributes(bytes, layout, issues);
+    const { attributes, targetFrameworks } = readAttributes(bytes, layout, issues, memberLists);
     return {
         module,
         assembly,