rea-agents 3.1.0 → 3.2.0

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,

package/dist/dotnet/ManagedMetadataInventoryRows.js

@@ -1,13 +1,6 @@
 import { metadataRowOffset, } from "./ManagedMetadataLayout.js";
-import { MetadataRowCursor, metadataToken, readMetadataBlob, readMetadataGuid, readMetadataString, sha256Bytes, strongNameToken, } from "./ManagedMetadataHeaps.js";
+import { metadataRowCursor, metadataCodedToken, metadataToken, readMetadataBlob, readMetadataGuid, readMetadataString, sha256Bytes, strongNameToken, } from "./ManagedMetadataHeaps.js";
 import { managedFailure } from "./ManagedReaderFailure.js";
-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}`);
-};
 const publicKeyIdentity = (bytes, kind) => ({
     kind: bytes.length === 0 ? "none" : kind,
     byte_length: bytes.length,
@@ -20,13 +13,13 @@ const publicKeyIdentity = (bytes, kind) => ({
                 ? bytes.toString("hex")
                 : null,
 });
-export const readModule = (bytes, layout, maxBytes) => {
+export const readModule = (bytes, layout, heapExtent) => {
     const table = layout.table(0);
     if (table === undefined || table.rowCount === 0)
         return null;
-    const cursor = rowCursor({ bytes, layout, table: 0, row: 1 });
+    const cursor = metadataRowCursor(bytes, layout, 0, 1);
     const generation = cursor.readUInt16();
-    const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
+    const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), heapExtent);
     const mvid = readMetadataGuid(bytes, layout, cursor.readIndex(layout.guidIndexSize));
     const encId = readMetadataGuid(bytes, layout, cursor.readIndex(layout.guidIndexSize));
     const encBaseId = readMetadataGuid(bytes, layout, cursor.readIndex(layout.guidIndexSize));
@@ -40,11 +33,11 @@ export const readModule = (bytes, layout, maxBytes) => {
         row_offset: table.offset,
     };
 };
-export const readAssembly = (bytes, layout, maxBytes) => {
+export const readAssembly = (bytes, layout, heapExtent) => {
     const table = layout.table(32);
     if (table === undefined || table.rowCount === 0)
         return null;
-    const cursor = rowCursor({ bytes, layout, table: 32, row: 1 });
+    const cursor = metadataRowCursor(bytes, layout, 32, 1);
     const hashAlgorithm = cursor.readUInt32();
     const version = [
         cursor.readUInt16(),
@@ -53,9 +46,9 @@ export const readAssembly = (bytes, layout, maxBytes) => {
         cursor.readUInt16(),
     ].join(".");
     const flags = cursor.readUInt32();
-    const key = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), maxBytes);
-    const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
-    const culture = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
+    const key = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), heapExtent);
+    const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), heapExtent);
+    const culture = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), heapExtent);
     return {
         name,
         version,
@@ -67,8 +60,8 @@ export const readAssembly = (bytes, layout, maxBytes) => {
         row_offset: table.offset,
     };
 };
-export const readAssemblyReference = (bytes, layout, row, maxBytes) => {
-    const cursor = rowCursor({ bytes, layout, table: 35, row });
+export const readAssemblyReference = (bytes, layout, row, heapExtent) => {
+    const cursor = metadataRowCursor(bytes, layout, 35, row);
     const version = [
         cursor.readUInt16(),
         cursor.readUInt16(),
@@ -76,10 +69,10 @@ export const readAssemblyReference = (bytes, layout, row, maxBytes) => {
         cursor.readUInt16(),
     ].join(".");
     const flags = cursor.readUInt32();
-    const keyOrToken = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), maxBytes);
-    const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
-    const culture = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
-    const hashValue = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), maxBytes);
+    const keyOrToken = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), heapExtent);
+    const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), heapExtent);
+    const culture = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), heapExtent);
+    const hashValue = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), heapExtent);
     return {
         name,
         version,
@@ -92,34 +85,26 @@ export const readAssemblyReference = (bytes, layout, row, maxBytes) => {
         row_offset: metadataRowOffset(layout, 35, row),
     };
 };
-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);
-};
-const readTypeName = ({ bytes, layout, table, row, maxBytes, }) => {
+const readTypeName = ({ bytes, layout, table, row, heapExtent, }) => {
     const descriptor = layout.table(table);
     if (descriptor === undefined || row < 1 || row > descriptor.rowCount)
         return null;
-    const cursor = rowCursor({ bytes, layout, table, row });
+    const cursor = metadataRowCursor(bytes, layout, table, row);
     if (table === 1)
         cursor.readIndex(layout.codedIndexSize("ResolutionScope"));
     else
         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), heapExtent);
+    const namespace = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), heapExtent);
     return namespace.length === 0 ? name : `${namespace}.${name}`;
 };
-const declaringTypeForMethod = (bytes, layout, methodRow, maxBytes) => {
+const declaringTypeForMethod = (bytes, layout, methodRow, heapExtent) => {
     const types = layout.table(2);
     const methods = layout.table(6);
     if (types === undefined || methods === undefined)
         return null;
     for (let row = 1; row <= types.rowCount; row += 1) {
-        const cursor = rowCursor({ bytes, layout, table: 2, row });
+        const cursor = metadataRowCursor(bytes, layout, 2, row);
         cursor.readUInt32();
         const nameIndex = cursor.readIndex(layout.stringIndexSize);
         const namespaceIndex = cursor.readIndex(layout.stringIndexSize);
@@ -131,14 +116,14 @@ const declaringTypeForMethod = (bytes, layout, methodRow, maxBytes) => {
             : methodListForType(bytes, layout, row + 1);
         if (methodRow < methodStart || methodRow >= methodEnd)
             continue;
-        const name = readMetadataString(bytes, layout, nameIndex, maxBytes);
-        const namespace = readMetadataString(bytes, layout, namespaceIndex, maxBytes);
+        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 = rowCursor({ bytes, layout, table: 2, row });
+    const cursor = metadataRowCursor(bytes, layout, 2, row);
     cursor.readUInt32();
     cursor.readIndex(layout.stringIndexSize);
     cursor.readIndex(layout.stringIndexSize);
@@ -146,28 +131,40 @@ const methodListForType = (bytes, layout, row) => {
     cursor.readIndex(layout.tableIndexSize(4));
     return cursor.readIndex(layout.tableIndexSize(6));
 };
-const attributeTypeName = (bytes, layout, rawType, maxBytes) => {
+const attributeTypeName = (bytes, layout, rawType, heapExtent) => {
     const tag = rawType & 7;
     const row = Math.floor(rawType / 8);
     if (row === 0)
         return null;
     if (tag === 2)
-        return declaringTypeForMethod(bytes, layout, row, maxBytes);
+        return declaringTypeForMethod(bytes, layout, row, heapExtent);
     if (tag !== 3)
         return null;
     const memberRefs = layout.table(10);
     if (memberRefs === undefined || row > memberRefs.rowCount)
         return null;
-    const cursor = rowCursor({ bytes, layout, table: 10, row });
+    const cursor = metadataRowCursor(bytes, layout, 10, row);
     const parent = cursor.readIndex(layout.codedIndexSize("MemberRefParent"));
     const parentTag = parent & 7;
     const parentRow = Math.floor(parent / 8);
     if (parentTag === 0)
-        return readTypeName({ bytes, layout, table: 2, row: parentRow, maxBytes });
+        return readTypeName({
+            bytes,
+            layout,
+            table: 2,
+            row: parentRow,
+            heapExtent,
+        });
     if (parentTag === 1)
-        return readTypeName({ bytes, layout, table: 1, row: parentRow, maxBytes });
+        return readTypeName({
+            bytes,
+            layout,
+            table: 1,
+            row: parentRow,
+            heapExtent,
+        });
     if (parentTag === 3)
-        return declaringTypeForMethod(bytes, layout, parentRow, maxBytes);
+        return declaringTypeForMethod(bytes, layout, parentRow, heapExtent);
     return null;
 };
 const decodeCompressedLength = (blob, offset) => {
@@ -210,21 +207,26 @@ const decodeFixedString = (blob) => {
         return null;
     }
 };
-export const readCustomAttribute = (bytes, layout, row, maxBytes) => {
-    const cursor = rowCursor({ bytes, layout, table: 12, row });
+export const readCustomAttribute = (bytes, layout, row, heapExtent) => {
+    const cursor = metadataRowCursor(bytes, layout, 12, row);
     const parentRaw = cursor.readIndex(layout.codedIndexSize("HasCustomAttribute"));
     const typeRaw = cursor.readIndex(layout.codedIndexSize("CustomAttributeType"));
-    const value = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), maxBytes);
-    const parent = codedToken(parentRaw, 5, [
+    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,
     ]);
     if (parent === null)
         throw managedFailure("invalid-row", "metadata.CustomAttribute", "CustomAttribute parent coded index is invalid", cursor.start);
-    const typeName = attributeTypeName(bytes, layout, typeRaw, maxBytes);
+    const typeName = attributeTypeName(bytes, layout, typeRaw, heapExtent);
     return {
         parent_token: parent,
-        constructor_token: codedToken(typeRaw, 3, [undefined, undefined, 6, 10]),
+        constructor_token: metadataCodedToken(typeRaw, 3, [
+            undefined,
+            undefined,
+            6,
+            10,
+        ]),
         type_name: typeName,
         value_length: value.length,
         value_sha256: sha256Bytes(value),
@@ -235,13 +237,13 @@ export const readCustomAttribute = (bytes, layout, row, maxBytes) => {
         row_offset: cursor.start,
     };
 };
-export const readResource = ({ bytes, layout, row, maxBytes, directory, issues, }) => {
-    const cursor = rowCursor({ bytes, layout, table: 40, row });
+export const readResource = ({ bytes, layout, row, directory, issues, }) => {
+    const cursor = metadataRowCursor(bytes, layout, 40, row);
     const declaredOffset = cursor.readUInt32();
     const flags = cursor.readUInt32();
-    const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
+    const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), Math.max(layout.strings.size, layout.blob.size));
     const implementationRaw = cursor.readIndex(layout.codedIndexSize("Implementation"));
-    const implementationToken = codedToken(implementationRaw, 2, [38, 35, 39]);
+    const implementationToken = metadataCodedToken(implementationRaw, 2, [38, 35, 39]);
     let dataLength = null;
     let dataSha256 = null;
     if (implementationRaw === 0) {
@@ -264,14 +266,6 @@ export const readResource = ({ bytes, layout, row, maxBytes, directory, issues,
                     detail: "Embedded resource length leaves the CLI resources directory",
                 });
             }
-            else if (dataLength > maxBytes) {
-                issues.push({
-                    code: "limit-exceeded",
-                    scope: `metadata.ManifestResource:${metadataToken(40, row)}`,
-                    offset: start + 4,
-                    detail: `Embedded resource exceeds max_heap_item_bytes ${String(maxBytes)}; digest omitted`,
-                });
-            }
             else {
                 dataSha256 = sha256Bytes(bytes.subarray(start + 4, start + 4 + dataLength));
             }

package/dist/dotnet/ManagedMetadataLayout.js

@@ -166,7 +166,7 @@ const readTablesHeader = (bytes, streams) => {
         throw managedFailure("invalid-tables", "metadata.valid-mask", "Metadata valid mask names unsupported tables outside the admitted ECMA-335 range", tablesStream.offset + 8);
     return { tableBytes, tablesOffset: tablesStream.offset, heaps, valid };
 };
-const readRowCounts = (tableBytes, valid, maxTableRows, tablesOffset) => {
+const readRowCounts = (tableBytes, valid) => {
     const rowCounts = Array(METADATA_TABLE_NAMES.length).fill(0);
     let tableCursor = 24;
     for (let index = 0; index < METADATA_TABLE_NAMES.length; index += 1) {
@@ -174,8 +174,6 @@ const readRowCounts = (tableBytes, valid, maxTableRows, tablesOffset) => {
             continue;
         requireRange(tableBytes, tableCursor, 4, "metadata.table-row-count");
         const count = tableBytes.readUInt32LE(tableCursor);
-        if (count > maxTableRows)
-            throw managedFailure("limit-exceeded", `metadata.${METADATA_TABLE_NAMES[index] ?? String(index)}`, `Metadata table row count ${String(count)} exceeds max_table_rows ${String(maxTableRows)}`, tablesOffset + tableCursor);
         rowCounts[index] = count;
         tableCursor += 4;
     }
@@ -218,13 +216,13 @@ const buildMetadataTables = ({ tableBytes, rowCounts, heaps, valid, tablesOffset
     return tables;
 };
 /** Parse ECMA-335 stream and table layout with checked byte extents. */
-export const readManagedMetadataLayout = (artifact, rootOffset, size, maxTableRows) => {
+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 { tableBytes, tablesOffset, heaps, valid } = readTablesHeader(artifact, streams);
-    const rowCounts = readRowCounts(tableBytes, valid, maxTableRows, tablesOffset);
+    const rowCounts = readRowCounts(tableBytes, valid);
     const tables = buildMetadataTables({
         tableBytes,
         rowCounts,

package/dist/dotnet/ManagedMethodBodyReader.js

@@ -31,28 +31,24 @@ const readMethodBodyHeader = (bytes, offset) => {
         localSig: bytes.readUInt32LE(offset + 8),
     };
 };
-export const methodBody = (bytes, pe, rva, limits) => {
+export const methodBody = (bytes, pe, rva) => {
     if (rva === 0)
         return emptyMethodBody(rva, "absent", null);
     try {
         const offset = pe.rvaToOffset(rva, 1, "method.body");
         const header = readMethodBodyHeader(bytes, offset);
-        if (header.ilSize > limits.maxMethodBodyBytes)
-            return oversizedMethodBody(header, rva, offset, limits);
         const ilOffset = offset + header.size;
         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, limits.maxMethodInstructions);
+        const decoded = decodeInstructions(il);
         const opcodeCounts = {};
         for (const instruction of decoded.parsed)
             opcodeCounts[instruction.opcode] =
                 (opcodeCounts[instruction.opcode] ?? 0) + 1;
         const anchors = decoded.parsed
-            .map((instruction, index) => ({ instruction, index }))
-            .filter(({ instruction }) => instruction.operandKind !== "none")
-            .slice(0, limits.instructionAnchorLimit)
-            .map(({ instruction }) => ({
+            .filter((instruction) => instruction.operandKind !== "none")
+            .map((instruction) => ({
             il_offset: instruction.offset,
             opcode: instruction.opcode,
             operand_kind: instruction.operandKind,
@@ -93,7 +89,7 @@ export const methodBody = (bytes, pe, rva, limits) => {
                 : [],
             issue: decoded.issue ??
                 (decoded.truncated > 0
-                    ? `Instruction decode reached max_method_instructions ${String(limits.maxMethodInstructions)} before the end of the method body`
+                    ? "Instruction decoding stopped before the end of the method body"
                     : null),
         };
     }
@@ -120,24 +116,3 @@ const emptyMethodBody = (rva, status, issue) => ({
     exception_regions: [],
     issue,
 });
-const oversizedMethodBody = (header, rva, offset, limits) => ({
-    status: "too-large",
-    header_format: header.format,
-    rva,
-    file_offset: offset,
-    max_stack: header.maxStack,
-    init_locals: (header.flags & 0x10) !== 0,
-    local_var_sig_token: header.localSig === 0
-        ? null
-        : `0x${header.localSig.toString(16).padStart(8, "0")}`,
-    il_size: header.ilSize,
-    il_sha256: null,
-    normalized_il_sha256: null,
-    instruction_count: 0,
-    decoded_instruction_count: 0,
-    truncated_instructions: 0,
-    opcode_counts: {},
-    anchors: [],
-    exception_regions: [],
-    issue: `Method body exceeds max_method_body_bytes ${String(limits.maxMethodBodyBytes)}`,
-});