rea-agents 3.0.0 → 3.2.0

package/dist/dotnet/ManagedMemberInspector.js

@@ -2,11 +2,10 @@ import { managedMemberInspectionSchema, } from "../domain/managedArtifact.js";
 import { readManagedPeLayout, } from "./ManagedPeReader.js";
 import { managedTableRowCounts, readManagedMetadataInventory, } from "./ManagedMetadataInventory.js";
 import { readManagedMetadataLayout } from "./ManagedMetadataLayout.js";
-import { ManagedReaderFailure, managedFailure, } from "./ManagedReaderFailure.js";
-import { emptyPage, page, parseTypes, typeRanges, } from "./ManagedMemberInspectorCore.js";
+import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
+import { parseTypes, typeRanges } from "./ManagedMemberInspectorCore.js";
 import { edges, parseFields, parseMemberRefs, parseMethods, } from "./ManagedMemberRows.js";
-const unavailable = (target, bytes, limits, issue) => managedMemberInspectionSchema.parse({
-    schema_version: 1,
+const unavailable = (target, bytes, issue) => managedMemberInspectionSchema.parse({
     artifact: {
         path: target.path,
         sha256: target.sha256,
@@ -24,12 +23,12 @@ const unavailable = (target, bytes, limits, issue) => managedMemberInspectionSch
         requires_artifact_sha256: target.sha256,
         requires_mvid: null,
     },
-    types: emptyPage(limits.typeOffset, limits.typeLimit),
-    fields: emptyPage(limits.fieldOffset, limits.fieldLimit),
-    methods: emptyPage(limits.methodOffset, limits.methodLimit),
-    member_refs: emptyPage(limits.memberRefOffset, limits.memberRefLimit),
-    call_edges: emptyPage(limits.edgeOffset, limits.edgeLimit),
-    field_accesses: emptyPage(limits.edgeOffset, limits.edgeLimit),
+    types: [],
+    fields: [],
+    methods: [],
+    member_refs: [],
+    call_edges: [],
+    field_accesses: [],
     coverage: {
         state: "unavailable",
         issues: issue === null ? [] : [issue],
@@ -50,62 +49,37 @@ const resourceDirectory = (pe) => {
         size: pe.cli.resources.size,
     };
 };
-const collectMethodBodyIssues = (methods, limits) => methods.methods.flatMap((method) => method.body.status === "partial"
-    ? [
-        {
-            code: "limit-exceeded",
-            scope: `method.${method.token}.body.instructions`,
-            offset: method.body.file_offset,
-            detail: method.body.issue ??
-                `Instruction decode reached max_method_instructions ${String(limits.maxMethodInstructions)}`,
-        },
-    ]
-    : []);
-const readMemberInventory = (bytes, pe, limits) => {
+const readMemberInventory = (bytes, pe) => {
     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");
-    if (cli.metadata.size > limits.maxMetadataBytes)
-        throw managedFailure("limit-exceeded", "metadata.root", `CLI metadata size exceeds max_metadata_bytes ${String(limits.maxMetadataBytes)}`, rootOffset);
-    const layout = readManagedMetadataLayout(bytes, rootOffset, cli.metadata.size, limits.maxTableRows);
-    const inventory = readManagedMetadataInventory(bytes, layout, {
-        referenceOffset: 0,
-        referenceLimit: 1,
-        resourceOffset: 0,
-        resourceLimit: 1,
-        attributeOffset: 0,
-        attributeLimit: 1,
-        maxHeapItemBytes: limits.maxHeapItemBytes,
-    }, resourceDirectory(pe));
+    const layout = readManagedMetadataLayout(bytes, rootOffset, cli.metadata.size);
+    const inventory = readManagedMetadataInventory(bytes, layout, resourceDirectory(pe));
     return { layout, inventory };
 };
 /** Inspect metadata members and method bodies without loading target code. */
-export const inspectManagedMembersBytes = (bytes, target, limits) => {
+export const inspectManagedMembersBytes = (bytes, target) => {
     const pe = readManagedPeLayout(bytes);
     if (pe.cli === null)
-        return unavailable(target, bytes, limits, pe.cliIssue);
+        return unavailable(target, bytes, pe.cliIssue);
     const issues = [];
     try {
-        const { layout, inventory } = readMemberInventory(bytes, pe, limits);
+        const { layout, inventory } = readMemberInventory(bytes, pe);
         issues.push(...inventory.issues);
-        const ranges = typeRanges(bytes, layout, limits.maxHeapItemBytes);
-        const types = parseTypes(bytes, layout, ranges, limits.maxHeapItemBytes);
-        const fields = parseFields(bytes, layout, ranges, limits.maxHeapItemBytes);
-        const memberRefs = parseMemberRefs(bytes, layout, limits.maxHeapItemBytes);
+        const ranges = typeRanges(bytes, layout);
+        const types = parseTypes(bytes, layout, ranges);
+        const fields = parseFields(bytes, layout, ranges);
+        const memberRefs = parseMemberRefs(bytes, layout);
         const methods = parseMethods({
             bytes,
             layout,
             pe,
             ranges,
-            maxBytes: limits.maxHeapItemBytes,
-            limits,
         });
-        const methodBodyIssues = collectMethodBodyIssues(methods, limits);
-        const coverageIssues = [...issues, ...methodBodyIssues];
+        const coverageIssues = issues;
         const related = edges(methods.methods, methods.core, fields.core, memberRefs.core);
         return managedMemberInspectionSchema.parse({
-            schema_version: 1,
             artifact: {
                 path: target.path,
                 sha256: target.sha256,
@@ -123,12 +97,12 @@ export const inspectManagedMembersBytes = (bytes, target, limits) => {
                 requires_artifact_sha256: target.sha256,
                 requires_mvid: inventory.module?.mvid ?? null,
             },
-            types: page(types, limits.typeOffset, limits.typeLimit),
-            fields: page(fields.fields, limits.fieldOffset, limits.fieldLimit),
-            methods: page(methods.methods, limits.methodOffset, limits.methodLimit),
-            member_refs: page(memberRefs.refs, limits.memberRefOffset, limits.memberRefLimit),
-            call_edges: page(related.callEdges, limits.edgeOffset, limits.edgeLimit),
-            field_accesses: page(related.fieldAccesses, limits.edgeOffset, limits.edgeLimit),
+            types,
+            fields: fields.fields,
+            methods: methods.methods,
+            member_refs: memberRefs.refs,
+            call_edges: related.callEdges,
+            field_accesses: related.fieldAccesses,
             coverage: {
                 state: coverageIssues.length === 0 ? "complete" : "partial",
                 issues: coverageIssues,
@@ -137,17 +111,12 @@ export const inspectManagedMembersBytes = (bytes, target, limits) => {
                 "Metadata tokens are build-local coordinates and are only meaningful with the reported artifact SHA-256 and MVID.",
                 "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.",
-                ...(methodBodyIssues.length > 0
-                    ? [
-                        "At least one CIL method body reached max_method_instructions; its decoded prefix is partial and has no normalized CIL identity.",
-                    ]
-                    : []),
             ],
         });
     }
     catch (cause) {
         if (cause instanceof ManagedReaderFailure)
-            return unavailable(target, bytes, limits, cause.issue);
+            return unavailable(target, bytes, cause.issue);
         throw cause;
     }
 };

package/dist/dotnet/ManagedMemberInspectorCore.js

@@ -1,42 +1,5 @@
-import { metadataRowOffset, } from "./ManagedMetadataLayout.js";
-import { MetadataRowCursor, metadataToken, readMetadataString, sha256Bytes, } from "./ManagedMetadataHeaps.js";
-import { managedFailure } from "./ManagedReaderFailure.js";
-export const emptyPage = (offset, limit) => ({
-    items: [],
-    offset,
-    limit,
-    total: 0,
-    returned: 0,
-    dropped: 0,
-    complete: offset === 0,
-});
-export const page = (all, offset, limit) => {
-    const items = all.slice(offset, offset + limit);
-    return {
-        items,
-        offset,
-        limit,
-        total: all.length,
-        returned: items.length,
-        dropped: all.length - items.length,
-        complete: offset === 0 && offset + limit >= all.length,
-    };
-};
-export const rowCursor = (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);
-    return new MetadataRowCursor(bytes, start, start + descriptor.rowSize, `metadata.${descriptor.name}`);
-};
-export const codedToken = (raw, bits, tables) => {
-    if (raw === 0)
-        return null;
-    const tag = raw & (2 ** bits - 1);
-    const row = Math.floor(raw / 2 ** bits);
-    const table = tables[tag];
-    return table === undefined || row === 0 ? null : metadataToken(table, row);
-};
+import {} from "./ManagedMetadataLayout.js";
+import { metadataRowCursor, metadataCodedToken, metadataToken, readMetadataString, sha256Bytes, } from "./ManagedMetadataHeaps.js";
 const rowRange = (table, start, nextStart) => {
     const total = table?.rowCount ?? 0;
     if (total === 0 || start === 0)
@@ -47,13 +10,13 @@ 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, maxBytes) => {
+const readTypeRange = (bytes, layout, row) => {
     const methods = layout.table(6);
     const fields = layout.table(4);
-    const cursor = rowCursor(bytes, layout, 2, row);
+    const cursor = metadataRowCursor(bytes, layout, 2, row);
     cursor.readUInt32();
-    const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
-    const namespace = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
+    const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
+    const namespace = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
     cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));
     const fieldStart = cursor.readIndex(layout.tableIndexSize(4));
     const methodStart = cursor.readIndex(layout.tableIndexSize(6));
@@ -61,7 +24,7 @@ const readTypeRange = (bytes, layout, row, maxBytes) => {
     let nextMethod = (methods?.rowCount ?? 0) + 1;
     const typeTable = layout.table(2);
     if (typeTable !== undefined && row < typeTable.rowCount) {
-        const next = rowCursor(bytes, layout, 2, row + 1);
+        const next = metadataRowCursor(bytes, layout, 2, row + 1);
         next.readUInt32();
         next.readIndex(layout.stringIndexSize);
         next.readIndex(layout.stringIndexSize);
@@ -78,11 +41,11 @@ const readTypeRange = (bytes, layout, row, maxBytes) => {
         methodEnd: nextMethod,
     };
 };
-export const typeRanges = (bytes, layout, maxBytes) => {
+export const typeRanges = (bytes, layout) => {
     const typeTable = layout.table(2);
     const ranges = [];
     for (let row = 1; row <= (typeTable?.rowCount ?? 0); row += 1)
-        ranges.push(readTypeRange(bytes, layout, row, maxBytes));
+        ranges.push(readTypeRange(bytes, layout, row));
     return ranges;
 };
 export const declaringType = (ranges, table, row) => {
@@ -94,16 +57,16 @@ export const declaringType = (ranges, table, row) => {
     }
     return null;
 };
-export const parseTypes = (bytes, layout, ranges, maxBytes) => {
+export const parseTypes = (bytes, layout, ranges) => {
     const typeTable = layout.table(2);
     const fields = layout.table(4);
     const methods = layout.table(6);
     const items = [];
     for (let row = 1; row <= (typeTable?.rowCount ?? 0); row += 1) {
-        const cursor = rowCursor(bytes, layout, 2, row);
+        const cursor = metadataRowCursor(bytes, layout, 2, row);
         const flags = cursor.readUInt32();
-        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
-        const namespace = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
+        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 extendsRaw = cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));
         const fieldStart = cursor.readIndex(layout.tableIndexSize(4));
         const methodStart = cursor.readIndex(layout.tableIndexSize(6));
@@ -117,7 +80,7 @@ export const parseTypes = (bytes, layout, ranges, maxBytes) => {
             name,
             full_name: fullName(namespace, name),
             flags,
-            extends_token: codedToken(extendsRaw, 2, [2, 1, 27]),
+            extends_token: metadataCodedToken(extendsRaw, 2, [2, 1, 27]),
             field_list: {
                 first_row: fieldRange.first,
                 last_row: fieldRange.last,

package/dist/dotnet/ManagedMemberInstructionDecoder.js

@@ -342,12 +342,12 @@ const readOperand = (il, offset, kind) => {
         return { next: offset + 4, anchorKind: tokenKind(token), value: token };
     return { next: offset, anchorKind: "unknown", value: null };
 };
-export const decodeInstructions = (il, limit) => {
+export const decodeInstructions = (il) => {
     const parsed = [];
     let offset = 0;
     let issue = null;
     try {
-        while (offset < il.length && parsed.length < limit) {
+        while (offset < il.length) {
             const start = offset;
             const first = il.readUInt8(offset);
             offset += 1;

package/dist/dotnet/ManagedMemberRows.js

@@ -1,15 +1,15 @@
-import { codedToken, declaringType, rowCursor, signature, } from "./ManagedMemberInspectorCore.js";
-import { metadataToken, readMetadataBlob, readMetadataString, } from "./ManagedMetadataHeaps.js";
+import { declaringType, signature, } from "./ManagedMemberInspectorCore.js";
+import { metadataToken, metadataRowCursor, metadataCodedToken, readMetadataBlob, readMetadataString, } from "./ManagedMetadataHeaps.js";
 import { methodBody } from "./ManagedMethodBodyReader.js";
-export const parseFields = (bytes, layout, ranges, maxBytes) => {
+export const parseFields = (bytes, layout, ranges) => {
     const fields = [];
     const core = new Map();
     const table = layout.table(4);
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
-        const cursor = rowCursor(bytes, layout, 4, row);
+        const cursor = metadataRowCursor(bytes, layout, 4, row);
         const flags = cursor.readUInt16();
-        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
-        const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), maxBytes);
+        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(ranges, "field", row);
         const token = metadataToken(4, row);
         fields.push({
@@ -25,20 +25,20 @@ export const parseFields = (bytes, layout, ranges, maxBytes) => {
     }
     return { fields, core };
 };
-export const parseMemberRefs = (bytes, layout, maxBytes) => {
+export const parseMemberRefs = (bytes, layout) => {
     const refs = [];
     const core = new Map();
     const table = layout.table(10);
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
-        const cursor = rowCursor(bytes, layout, 10, row);
+        const cursor = metadataRowCursor(bytes, layout, 10, row);
         const parentRaw = cursor.readIndex(layout.codedIndexSize("MemberRefParent"));
-        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
-        const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), maxBytes);
+        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);
         refs.push({
             token,
             row_offset: cursor.start,
-            parent_token: codedToken(parentRaw, 3, [2, 1, 26, 6, 27]),
+            parent_token: metadataCodedToken(parentRaw, 3, [2, 1, 26, 6, 27]),
             name,
             signature: signature(sig),
         });
@@ -46,17 +46,17 @@ export const parseMemberRefs = (bytes, layout, maxBytes) => {
     }
     return { refs, core };
 };
-export const parseMethods = ({ bytes, layout, pe, ranges, maxBytes, limits, }) => {
+export const parseMethods = ({ bytes, layout, pe, ranges, }) => {
     const methods = [];
     const core = new Map();
     const table = layout.table(6);
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
-        const cursor = rowCursor(bytes, layout, 6, row);
+        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), maxBytes);
-        const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), maxBytes);
+        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(ranges, "method", row);
         const token = metadataToken(6, row);
@@ -70,7 +70,7 @@ export const parseMethods = ({ bytes, layout, pe, ranges, maxBytes, limits, }) =
             impl_flags: implFlags,
             flags,
             signature: signature(sig),
-            body: methodBody(bytes, pe, rva, limits),
+            body: methodBody(bytes, pe, rva),
         });
         core.set(token, { token, name, declaringType: declared?.fullName ?? null });
     }

package/dist/dotnet/ManagedMetadataHeaps.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+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)
@@ -65,19 +66,19 @@ const compressedLength = (bytes, offset, scope) => {
     }
     throw managedFailure("invalid-blob", scope, "Metadata blob uses a reserved compressed-length prefix", offset);
 };
-/** Read one bounded UTF-8 value from #Strings. */
-export const readMetadataString = (bytes, layout, index, maxBytes) => {
+/** Read one UTF-8 value from #Strings within its PE/CLI stream extent. */
+export const readMetadataString = (bytes, layout, index, heapExtent) => {
     if (index === 0)
         return "";
     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 maximum = Math.min(layout.strings.offset + layout.strings.size, start + maxBytes + 1);
+    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("limit-exceeded", "metadata.#Strings", `String heap item exceeds max_heap_item_bytes ${String(maxBytes)}`, start);
+        throw managedFailure("invalid-string", "metadata.#Strings", "String heap item has no terminator within #Strings", start);
     try {
         return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(start, end));
     }
@@ -85,16 +86,16 @@ export const readMetadataString = (bytes, layout, index, maxBytes) => {
         throw managedFailure("invalid-string", "metadata.#Strings", "String heap item is not valid UTF-8", start);
     }
 };
-/** Read one bounded item from #Blob without interpreting its contents. */
-export const readMetadataBlob = (bytes, layout, index, maxBytes) => {
+/** Read one #Blob item while validating its encoded extent against the heap. */
+export const readMetadataBlob = (bytes, layout, index, heapExtent) => {
     if (index === 0)
         return Buffer.alloc(0);
     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");
-    if (decoded.length > maxBytes)
-        throw managedFailure("limit-exceeded", "metadata.#Blob", `Blob heap item exceeds max_heap_item_bytes ${String(maxBytes)}`, start);
+    if (decoded.length > heapExtent)
+        throw managedFailure("invalid-blob", "metadata.#Blob", "Blob length exceeds the admitted heap extent", start);
     const content = start + decoded.prefix;
     if (content > layout.blob.offset + layout.blob.size - decoded.length)
         throw managedFailure("invalid-blob", "metadata.#Blob", "Blob heap item leaves #Blob", start);
@@ -129,3 +130,20 @@ export const sha256Bytes = (bytes) => createHash("sha256").update(bytes).digest(
 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);
+    return new MetadataRowCursor(bytes, start, start + descriptor.rowSize, `metadata.${descriptor.name}`);
+};
+/** Decode a metadata coded index without signed 32-bit coercion. */
+export const metadataCodedToken = (raw, bits, tables) => {
+    if (raw === 0)
+        return null;
+    const tag = raw & (2 ** bits - 1);
+    const row = Math.floor(raw / 2 ** bits);
+    const table = tables[tag];
+    return table === undefined || row === 0 ? null : metadataToken(table, row);
+};

package/dist/dotnet/ManagedMetadataInventory.js

@@ -13,53 +13,44 @@ const safeRead = (operation, issues) => {
         return undefined;
     }
 };
-const pageRows = (descriptor, offset, limit, read) => {
+const readRows = (descriptor, read) => {
     const total = descriptor?.rowCount ?? 0;
     const items = [];
-    const end = Math.min(total, offset + limit);
-    for (let index = offset; index < end; index += 1) {
+    for (let index = 0; index < total; index += 1) {
         const item = read(index + 1);
         if (item !== undefined)
             items.push(item);
     }
-    return {
-        items,
-        offset,
-        limit,
-        total,
-        returned: items.length,
-        dropped: total - items.length,
-        complete: offset === 0 && end === total && items.length === total,
-    };
+    return items;
 };
 const uniqueIssues = (issues) => [
     ...new Map(issues.map((issue) => [JSON.stringify(issue), issue])).values(),
 ];
-const readPagedReferences = (bytes, layout, input, issues) => pageRows(layout.table(35), input.referenceOffset, input.referenceLimit, (row) => safeRead(() => readAssemblyReference(bytes, layout, row, input.maxHeapItemBytes), issues));
-const readPagedResources = ({ bytes, layout, input, resourceDirectory, issues, }) => pageRows(layout.table(40), input.resourceOffset, input.resourceLimit, (row) => safeRead(() => readResource({
+const heapExtent = (layout) => Math.max(layout.strings.size, layout.blob.size);
+const readReferences = (bytes, layout, issues) => readRows(layout.table(35), (row) => safeRead(() => readAssemblyReference(bytes, layout, row, heapExtent(layout)), issues));
+const readResources = ({ bytes, layout, resourceDirectory, issues, }) => readRows(layout.table(40), (row) => safeRead(() => readResource({
     bytes,
     layout,
     row,
-    maxBytes: input.maxHeapItemBytes,
     directory: resourceDirectory,
     issues,
 }), issues));
-const readPagedAttributes = (bytes, layout, input, issues) => pageRows(layout.table(12), input.attributeOffset, input.attributeLimit, (row) => safeRead(() => readCustomAttribute(bytes, layout, row, input.maxHeapItemBytes), issues));
-const collectReferenceNames = (bytes, layout, maxBytes, issues) => {
+const readAttributes = (bytes, layout, issues) => readRows(layout.table(12), (row) => safeRead(() => readCustomAttribute(bytes, layout, row, heapExtent(layout)), issues));
+const collectReferenceNames = (bytes, layout, issues) => {
     const names = [];
     const referenceTable = layout.table(35);
     for (let row = 1; row <= (referenceTable?.rowCount ?? 0); row += 1) {
-        const reference = safeRead(() => readAssemblyReference(bytes, layout, row, maxBytes), issues);
+        const reference = safeRead(() => readAssemblyReference(bytes, layout, row, heapExtent(layout)), issues);
         if (reference !== undefined)
             names.push(reference.name);
     }
     return names;
 };
-const collectTargetFrameworks = (bytes, layout, maxBytes, issues) => {
+const collectTargetFrameworks = (bytes, layout, issues) => {
     const targetFrameworks = [];
     const attributeTable = layout.table(12);
     for (let row = 1; row <= (attributeTable?.rowCount ?? 0); row += 1) {
-        const attribute = safeRead(() => readCustomAttribute(bytes, layout, row, maxBytes), issues);
+        const attribute = safeRead(() => readCustomAttribute(bytes, layout, row, heapExtent(layout)), issues);
         if (attribute?.parent_token === metadataToken(32, 1) &&
             attribute.type_name ===
                 "System.Runtime.Versioning.TargetFrameworkAttribute" &&
@@ -69,23 +60,23 @@ const collectTargetFrameworks = (bytes, layout, maxBytes, issues) => {
     }
     return targetFrameworks;
 };
-/** Inventory bounded identity tables without CLR reflection or execution. */
-export const readManagedMetadataInventory = (bytes, layout, input, resourceDirectory) => {
+/** Inventory identity tables without CLR reflection or execution. */
+export const readManagedMetadataInventory = (bytes, layout, resourceDirectory) => {
     const issues = [];
-    const module = safeRead(() => readModule(bytes, layout, input.maxHeapItemBytes), issues) ??
+    const module = safeRead(() => readModule(bytes, layout, heapExtent(layout)), issues) ??
+        null;
+    const assembly = safeRead(() => readAssembly(bytes, layout, heapExtent(layout)), issues) ??
         null;
-    const assembly = safeRead(() => readAssembly(bytes, layout, input.maxHeapItemBytes), issues) ?? null;
-    const references = readPagedReferences(bytes, layout, input, issues);
-    const resources = readPagedResources({
+    const references = readReferences(bytes, layout, issues);
+    const resources = readResources({
         bytes,
         layout,
-        input,
         resourceDirectory,
         issues,
     });
-    const attributes = readPagedAttributes(bytes, layout, input, issues);
-    const referenceNames = collectReferenceNames(bytes, layout, input.maxHeapItemBytes, issues);
-    const targetFrameworks = collectTargetFrameworks(bytes, layout, input.maxHeapItemBytes, issues);
+    const attributes = readAttributes(bytes, layout, issues);
+    const referenceNames = collectReferenceNames(bytes, layout, issues);
+    const targetFrameworks = collectTargetFrameworks(bytes, layout, issues);
     return {
         module,
         assembly,