rea-agents 3.0.0 → 3.2.0

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)}`,
-});

package/dist/dotnet/ManagedNativeBoundaryHelpers.js

@@ -1,57 +1,28 @@
 import { managedNativeBoundaryInspectionSchema, } from "../domain/managedArtifact.js";
-import { metadataRowOffset, } from "./ManagedMetadataLayout.js";
-import { MetadataRowCursor, metadataToken, readMetadataString, } from "./ManagedMetadataHeaps.js";
+import {} from "./ManagedMetadataLayout.js";
+import { metadataRowCursor, metadataCodedToken, metadataToken, readMetadataString, } from "./ManagedMetadataHeaps.js";
 import { managedTableRowCounts } from "./ManagedMetadataInventory.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 codedToken = (raw, tagBits, tables) => {
-    const tagMask = (1 << tagBits) - 1;
-    const table = tables[raw & tagMask];
-    const row = raw >> tagBits;
-    if (table === undefined || row === 0)
-        return null;
-    return metadataToken(table, row);
-};
 const flagsHex = (value) => `0x${value.toString(16).padStart(4, "0")}`;
-const page = (items, offset, limit) => {
-    const safeOffset = Math.min(offset, items.length);
-    const selected = items.slice(safeOffset, safeOffset + limit);
-    return {
-        items: selected,
-        offset,
-        limit,
-        total: items.length,
-        returned: selected.length,
-        dropped: Math.max(0, items.length - safeOffset - selected.length),
-        complete: safeOffset === 0 && selected.length === items.length,
-    };
-};
-export const parseModuleRefs = (bytes, layout, maxBytes) => {
+export const parseModuleRefs = (bytes, layout, heapExtent) => {
     const refs = [];
     const table = layout.table(26);
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
-        const cursor = rowCursor({ bytes, layout, table: 26, row });
+        const cursor = metadataRowCursor(bytes, layout, 26, row);
         refs.push({
             token: metadataToken(26, row),
             row_offset: cursor.start,
-            name: readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes),
+            name: readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), heapExtent),
         });
     }
     return refs;
 };
-export const parseFields = (bytes, layout, maxBytes) => {
+export const parseFields = (bytes, layout, heapExtent) => {
     const fields = new Map();
     const table = layout.table(4);
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
-        const cursor = rowCursor({ bytes, layout, table: 4, row });
+        const cursor = metadataRowCursor(bytes, layout, 4, row);
         const flags = cursor.readUInt16();
-        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
+        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), heapExtent);
         cursor.readIndex(layout.blobIndexSize);
         const token = metadataToken(4, row);
         fields.set(token, {
@@ -66,15 +37,15 @@ export const parseFields = (bytes, layout, maxBytes) => {
     }
     return fields;
 };
-export const parseMethods = (bytes, layout, maxBytes) => {
+export const parseMethods = (bytes, layout, heapExtent) => {
     const methods = new Map();
     const table = layout.table(6);
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
-        const cursor = rowCursor({ bytes, layout, table: 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 name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), heapExtent);
         cursor.readIndex(layout.blobIndexSize);
         cursor.readIndex(layout.tableIndexSize(8));
         const token = metadataToken(6, row);
@@ -90,15 +61,15 @@ export const parseMethods = (bytes, layout, maxBytes) => {
     }
     return methods;
 };
-export const parseImplMaps = ({ bytes, layout, maxBytes, modules, members, }) => {
+export const parseImplMaps = ({ bytes, layout, heapExtent, modules, members, }) => {
     const moduleNames = new Map(modules.map((module) => [module.token, module]));
     const imports = [];
     const table = layout.table(28);
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
-        const cursor = rowCursor({ bytes, layout, table: 28, row });
+        const cursor = metadataRowCursor(bytes, layout, 28, row);
         const mappingFlags = cursor.readUInt16();
-        const memberToken = codedToken(cursor.readIndex(layout.codedIndexSize("MemberForwarded")), 1, [4, 6]);
-        const importName = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
+        const memberToken = metadataCodedToken(cursor.readIndex(layout.codedIndexSize("MemberForwarded")), 1, [4, 6]);
+        const importName = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), heapExtent);
         const importScopeRow = cursor.readIndex(layout.tableIndexSize(26));
         const importScopeToken = importScopeRow === 0 ? null : metadataToken(26, importScopeRow);
         const member = memberToken === null ? undefined : members.get(memberToken);
@@ -267,8 +238,7 @@ export const cliNative = (pe) => {
         managed_native_header_size: pe.cli.managedNativeHeader.size,
     };
 };
-export const buildNativeBoundaryInspection = ({ target, bytes, limits, layout, inventory, moduleRefs, imports, implementations, native, issues, }) => managedNativeBoundaryInspectionSchema.parse({
-    schema_version: 1,
+export const buildNativeBoundaryInspection = ({ target, bytes, layout, inventory, moduleRefs, imports, implementations, native, issues, }) => managedNativeBoundaryInspectionSchema.parse({
     artifact: {
         path: target.path,
         sha256: target.sha256,
@@ -287,9 +257,9 @@ export const buildNativeBoundaryInspection = ({ target, bytes, limits, layout, i
         requires_mvid: inventory.module?.mvid ?? null,
     },
     cli_native: native,
-    module_refs: page(moduleRefs, limits.moduleRefOffset, limits.moduleRefLimit),
-    pinvoke_imports: page(imports, limits.importOffset, limits.importLimit),
-    native_implementations: page(implementations, limits.implementationOffset, limits.implementationLimit),
+    module_refs: moduleRefs,
+    pinvoke_imports: imports,
+    native_implementations: implementations,
     summary: {
         module_ref_count: moduleRefs.length,
         pinvoke_import_count: imports.length,

package/dist/dotnet/ManagedNativeBoundaryInspector.js

@@ -4,17 +4,7 @@ import { readManagedMetadataLayout, } from "./ManagedMetadataLayout.js";
 import { readManagedPeLayout, } from "./ManagedPeReader.js";
 import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
 import { buildNativeBoundaryInspection, cliNative, nativeImplementations, parseFields, parseImplMaps, parseMethods, parseModuleRefs, } from "./ManagedNativeBoundaryHelpers.js";
-const emptyPage = () => ({
-    items: [],
-    offset: 0,
-    limit: 0,
-    total: 0,
-    returned: 0,
-    dropped: 0,
-    complete: true,
-});
 const emptyInspection = (target, bytes, classification, issues = []) => managedNativeBoundaryInspectionSchema.parse({
-    schema_version: 1,
     artifact: {
         path: target.path,
         sha256: target.sha256,
@@ -43,9 +33,9 @@ const emptyInspection = (target, bytes, classification, issues = []) => managedN
         managed_native_header_rva: 0,
         managed_native_header_size: 0,
     },
-    module_refs: emptyPage(),
-    pinvoke_imports: emptyPage(),
-    native_implementations: emptyPage(),
+    module_refs: [],
+    pinvoke_imports: [],
+    native_implementations: [],
     summary: {
         module_ref_count: 0,
         pinvoke_import_count: 0,
@@ -59,33 +49,18 @@ const emptyInspection = (target, bytes, classification, issues = []) => managedN
         "Static inspection does not load or execute target code, so native export resolution is not performed.",
     ],
 });
-const readBoundaryInventory = (bytes, pe, limits) => {
-    const cli = pe.cli;
+const readBoundaryInventory = (bytes, pe, cli) => {
     const metadataOffset = pe.rvaToOffset(cli.metadata.rva, cli.metadata.size, "cli.metadata");
-    const layout = readManagedMetadataLayout(bytes, metadataOffset, cli.metadata.size, limits.maxTableRows);
+    const layout = readManagedMetadataLayout(bytes, metadataOffset, cli.metadata.size);
     const resourceDirectory = {
         offset: pe.rvaToOffset(cli.resources.rva, cli.resources.size, "cli.resources"),
         size: cli.resources.size,
     };
-    const inventory = readManagedMetadataInventory(bytes, layout, {
-        referenceOffset: 0,
-        referenceLimit: 0,
-        resourceOffset: 0,
-        resourceLimit: 0,
-        attributeOffset: 0,
-        attributeLimit: 0,
-        maxHeapItemBytes: limits.maxHeapItemBytes,
-    }, resourceDirectory);
+    const inventory = readManagedMetadataInventory(bytes, layout, resourceDirectory);
     return { layout, inventory };
 };
-const metadataLimitIssue = (cli, maxBytes) => ({
-    code: "limit-exceeded",
-    scope: "cli.metadata",
-    offset: cli.headerOffset + 8,
-    detail: `CLI metadata size exceeds max_metadata_bytes ${String(maxBytes)}`,
-});
 /** Inspect managed/native boundary declarations from PE metadata without execution. */
-export const inspectManagedNativeBoundariesBytes = (bytes, target, limits) => {
+export const inspectManagedNativeBoundariesBytes = (bytes, target) => {
     let pe;
     try {
         pe = readManagedPeLayout(bytes);
@@ -97,29 +72,26 @@ export const inspectManagedNativeBoundariesBytes = (bytes, target, limits) => {
     }
     if (pe.cli === null)
         return emptyInspection(target, bytes, pe.cliDirectoryPresent ? "malformed" : "not-managed", pe.cliIssue === null ? [] : [pe.cliIssue]);
-    if (pe.cli.metadata.size > limits.maxMetadataBytes)
-        return emptyInspection(target, bytes, "malformed", [
-            metadataLimitIssue(pe.cli, limits.maxMetadataBytes),
-        ]);
     let layout;
     let inventory;
     try {
-        ({ layout, inventory } = readBoundaryInventory(bytes, pe, limits));
+        ({ layout, inventory } = readBoundaryInventory(bytes, pe, pe.cli));
     }
     catch (cause) {
         if (!(cause instanceof ManagedReaderFailure))
             throw cause;
         return emptyInspection(target, bytes, "malformed", [cause.issue]);
     }
-    const moduleRefs = parseModuleRefs(bytes, layout, limits.maxHeapItemBytes);
+    const heapExtent = Math.max(layout.strings.size, layout.blob.size);
+    const moduleRefs = parseModuleRefs(bytes, layout, heapExtent);
     const members = new Map([
-        ...parseFields(bytes, layout, limits.maxHeapItemBytes),
-        ...parseMethods(bytes, layout, limits.maxHeapItemBytes),
+        ...parseFields(bytes, layout, heapExtent),
+        ...parseMethods(bytes, layout, heapExtent),
     ]);
     const imports = parseImplMaps({
         bytes,
         layout,
-        maxBytes: limits.maxHeapItemBytes,
+        heapExtent,
         modules: moduleRefs,
         members,
     });
@@ -130,7 +102,6 @@ export const inspectManagedNativeBoundariesBytes = (bytes, target, limits) => {
     return buildNativeBoundaryInspection({
         target,
         bytes,
-        limits,
         pe,
         layout,
         inventory,

package/dist/dotnet/ManagedPeReader.js

@@ -104,8 +104,8 @@ const readCoffHeader = (bytes) => {
     const coff = peOffset + 4;
     const machine = bytes.readUInt16LE(coff);
     const sectionCount = bytes.readUInt16LE(coff + 2);
-    if (sectionCount === 0 || sectionCount > 96)
-        throw managedFailure("invalid-directory", "pe.sections", "PE section count is outside the admitted range", coff + 2);
+    if (sectionCount === 0)
+        throw managedFailure("invalid-directory", "pe.sections", "PE section count must be positive", coff + 2);
     const optionalSize = bytes.readUInt16LE(coff + 16);
     const characteristics = bytes.readUInt16LE(coff + 18);
     return { coff, machine, sectionCount, optionalSize, characteristics };