rea-agents 3.1.0 → 3.2.1

package/dist/domain/webScreenshot.js

@@ -2,15 +2,13 @@ import { createHash } from "node:crypto";
 import { z } from "zod";
 import { browserCompletenessSchema } from "./browserCompleteness.js";
 import { browserAllowedOriginsSchema, browserEndpointSchema, } from "./browserObservation.js";
-const MAX_SCREENSHOT_BYTES = 8 * 1_024 * 1_024;
 /** Self-verifying inline PNG artifact for CLI/MCP parity. */
 export const webScreenshotArtifactSchema = z
     .object({
-    uri: z.string().regex(/^rea:\/\/web-screenshot\/sha256\/[a-f0-9]{64}$/u),
     sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-    bytes: z.number().int().min(1).max(MAX_SCREENSHOT_BYTES),
+    bytes: z.number().int().min(1),
     media_type: z.literal("image/png"),
-    data_base64: z.string().max(Math.ceil((MAX_SCREENSHOT_BYTES * 4) / 3) + 4),
+    data_base64: z.string(),
 })
     .superRefine((artifact, context) => {
     const bytes = decodeCanonicalBase64(artifact.data_base64);
@@ -19,27 +17,17 @@ export const webScreenshotArtifactSchema = z
         return;
     }
     const sha256 = createHash("sha256").update(bytes).digest("hex");
-    if (bytes.byteLength !== artifact.bytes ||
-        sha256 !== artifact.sha256 ||
-        artifact.uri !== `rea://web-screenshot/sha256/${sha256}`)
+    if (bytes.byteLength !== artifact.bytes || sha256 !== artifact.sha256)
         context.addIssue({
             code: "custom",
             message: "Screenshot artifact digest or size mismatch",
         });
 });
 /** Input for one read-only visible-viewport screenshot. */
-export const captureWebScreenshotInputSchema = z.object({
+export const captureWebScreenshotInputSchema = z.strictObject({
     cdp_endpoint: browserEndpointSchema,
     allowed_origins: browserAllowedOriginsSchema,
-    target_id: z.string().trim().min(1).max(256),
-    approved: z.literal(true),
-    screenshot_approved: z.literal(true),
-    maximum_image_bytes: z
-        .number()
-        .int()
-        .min(1)
-        .max(MAX_SCREENSHOT_BYTES)
-        .default(4 * 1_024 * 1_024),
+    target_id: z.string().trim().min(1),
 });
 const browserVersionSchema = z.object({
     product: z.string(),
@@ -48,9 +36,8 @@ const browserVersionSchema = z.object({
     user_agent: z.string(),
     js_version: z.string(),
 });
-/** Bounded screenshot observation with embedded immutable artifact bytes. */
+/** Screenshot observation with embedded immutable artifact bytes. */
 export const webScreenshotSchema = z.object({
-    schema_version: z.literal(1),
     browser: browserVersionSchema,
     target: z.object({
         target_id: z.string(),
@@ -66,17 +53,14 @@ export const webScreenshotSchema = z.object({
     completeness: browserCompletenessSchema,
     limitations: z.array(z.string()),
 });
-/** Input for bounded local pixel comparison of two screenshot artifacts. */
-export const compareWebScreenshotsInputSchema = z.object({
+/** Input for local pixel comparison of two screenshot artifacts. */
+export const compareWebScreenshotsInputSchema = z.strictObject({
     before: webScreenshotArtifactSchema,
     after: webScreenshotArtifactSchema,
     channel_threshold: z.number().int().min(0).max(255).default(0),
-    maximum_pixels: z.number().int().min(1).max(32_000_000).default(16_000_000),
 });
 /** Value-only visual difference metrics; no OCR or image mutation. */
-export const webScreenshotDiffSchema = z.object({
-    schema_version: z.literal(1),
-    status: z.enum(["identical", "different", "dimension_mismatch"]),
+const webScreenshotDiffContextShape = {
     before: z.object({
         width: z.number().int().min(1),
         height: z.number().int().min(1),
@@ -86,18 +70,59 @@ export const webScreenshotDiffSchema = z.object({
         height: z.number().int().min(1),
     }),
     channel_threshold: z.number().int().min(0).max(255),
-    compared_pixels: z.number().int().min(0),
-    changed_pixels: z.number().int().min(0).nullable(),
-    changed_ratio: z.number().min(0).max(1).nullable(),
-    maximum_channel_delta: z.number().int().min(0).max(255).nullable(),
-    mean_absolute_channel_delta: z.number().min(0).max(255).nullable(),
     limitations: z.array(z.string()),
+};
+export const webScreenshotDiffSchema = z
+    .discriminatedUnion("status", [
+    z.object({
+        ...webScreenshotDiffContextShape,
+        status: z.literal("identical"),
+        compared_pixels: z.number().int().positive(),
+        changed_pixels: z.literal(0),
+        changed_ratio: z.literal(0),
+        maximum_channel_delta: z.number().int().min(0).max(255),
+        mean_absolute_channel_delta: z.number().min(0).max(255),
+    }),
+    z.object({
+        ...webScreenshotDiffContextShape,
+        status: z.literal("different"),
+        compared_pixels: z.number().int().positive(),
+        changed_pixels: z.number().int().positive(),
+        changed_ratio: z.number().positive().max(1),
+        maximum_channel_delta: z.number().int().positive().max(255),
+        mean_absolute_channel_delta: z.number().positive().max(255),
+    }),
+    z.object({
+        ...webScreenshotDiffContextShape,
+        status: z.literal("dimension_mismatch"),
+        compared_pixels: z.literal(0),
+        changed_pixels: z.null(),
+        changed_ratio: z.null(),
+        maximum_channel_delta: z.null(),
+        mean_absolute_channel_delta: z.null(),
+    }),
+])
+    .superRefine((diff, context) => {
+    const sameDimensions = diff.before.width === diff.after.width &&
+        diff.before.height === diff.after.height;
+    if (sameDimensions !== (diff.status !== "dimension_mismatch"))
+        context.addIssue({
+            code: "custom",
+            path: ["status"],
+            message: "Screenshot comparison status must match viewport dimensions",
+        });
+    if (diff.status !== "dimension_mismatch" &&
+        diff.compared_pixels !== diff.before.width * diff.before.height)
+        context.addIssue({
+            code: "custom",
+            path: ["compared_pixels"],
+            message: "Compared pixel count must match the shared dimensions",
+        });
 });
-/** Create a content-addressed PNG artifact from already bounded bytes. */
+/** Create a content-addressed PNG artifact from captured bytes. */
 export const createWebScreenshotArtifact = (bytes) => {
     const sha256 = createHash("sha256").update(bytes).digest("hex");
     return webScreenshotArtifactSchema.parse({
-        uri: `rea://web-screenshot/sha256/${sha256}`,
         sha256,
         bytes: bytes.byteLength,
         media_type: "image/png",
@@ -106,9 +131,8 @@ export const createWebScreenshotArtifact = (bytes) => {
 };
 /** Strict canonical base64 decoder used before digest validation. */
 export const decodeCanonicalBase64 = (value) => {
-    if (value.length === 0 || value.length % 4 !== 0 || !BASE64.test(value))
+    if (value.length === 0 || value.length % 4 !== 0)
         return undefined;
     const decoded = Buffer.from(value, "base64");
     return decoded.toString("base64") === value ? decoded : undefined;
 };
-const BASE64 = /^(?:[A-Za-z\d+/]{4})*(?:[A-Za-z\d+/]{2}==|[A-Za-z\d+/]{3}=)?$/u;

package/dist/domain/zipPackageFormat.js

@@ -1,3 +1,10 @@
+/** Recognize local-header, empty-archive, or split-archive ZIP signatures, not archive validity. */
+export const hasZipSignature = (bytes) => bytes.length >= 4 &&
+    bytes[0] === 0x50 &&
+    bytes[1] === 0x4b &&
+    ((bytes[2] === 0x03 && bytes[3] === 0x04) ||
+        (bytes[2] === 0x05 && bytes[3] === 0x06) ||
+        (bytes[2] === 0x07 && bytes[3] === 0x08));
 /**
  * Classify a ZIP-backed package by its complete lower-cased path suffix.
  *

package/dist/dotnet/ManagedArtifactInspector.js

@@ -3,15 +3,6 @@ import { readManagedPeLayout, } from "./ManagedPeReader.js";
 import { managedTableRowCounts, readManagedMetadataInventory, } from "./ManagedMetadataInventory.js";
 import { readManagedMetadataLayout, } from "./ManagedMetadataLayout.js";
 import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
-const emptyPage = (offset, limit) => ({
-    items: [],
-    offset,
-    limit,
-    total: 0,
-    returned: 0,
-    dropped: 0,
-    complete: offset === 0,
-});
 const flagNames = (flags) => {
     const names = [];
     for (const [mask, name] of [
@@ -64,7 +55,6 @@ const peProjection = (layout) => ({
     cli: layout.cli === null ? null : cliProjection(layout.cli),
 });
 const base = (target, bytes, layout) => ({
-    schema_version: 1,
     artifact: {
         path: target.path,
         sha256: target.sha256,
@@ -73,7 +63,7 @@ const base = (target, bytes, layout) => ({
     },
     pe: peProjection(layout),
 });
-const unavailableResult = (target, bytes, layout, limits) => {
+const unavailableResult = (target, bytes, layout) => {
     const malformed = layout.cliDirectoryPresent;
     const issues = layout.cliIssue === null ? [] : [layout.cliIssue];
     const limitations = malformed
@@ -108,9 +98,9 @@ const unavailableResult = (target, bytes, layout, limits) => {
         module: null,
         assembly: null,
         target_frameworks: [],
-        references: emptyPage(limits.referenceOffset, limits.referenceLimit),
-        resources: emptyPage(limits.resourceOffset, limits.resourceLimit),
-        attributes: emptyPage(limits.attributeOffset, limits.attributeLimit),
+        references: [],
+        resources: [],
+        attributes: [],
         coverage: {
             state: malformed ? "partial" : "unavailable",
             issues,
@@ -205,7 +195,7 @@ const runtimeClassification = ({ layout, metadata, inventory, }) => {
         evidence,
     };
 };
-const partialMetadataResult = ({ target, bytes, layout, limits, issue, }) => ({
+const partialMetadataResult = ({ target, bytes, layout, issue, }) => ({
     ...base(target, bytes, layout),
     classification: {
         status: "malformed",
@@ -222,7 +212,7 @@ const partialMetadataResult = ({ target, bytes, layout, limits, issue, }) => ({
         ],
     },
     metadata: {
-        status: issue.code === "limit-exceeded" ? "partial" : "malformed",
+        status: "malformed",
         version: null,
         stream_names: [],
         table_row_counts: {},
@@ -230,12 +220,12 @@ const partialMetadataResult = ({ target, bytes, layout, limits, issue, }) => ({
     module: null,
     assembly: null,
     target_frameworks: [],
-    references: emptyPage(limits.referenceOffset, limits.referenceLimit),
-    resources: emptyPage(limits.resourceOffset, limits.resourceLimit),
-    attributes: emptyPage(limits.attributeOffset, limits.attributeLimit),
+    references: [],
+    resources: [],
+    attributes: [],
     coverage: { state: "partial", issues: [issue] },
     limitations: [
-        "CLI metadata triage stopped at the reported bounded format or resource limit.",
+        "CLI metadata could not be read because the PE/CLI structure is malformed or unsupported.",
     ],
 });
 const mapResources = (bytes, layout, issues) => {
@@ -255,32 +245,16 @@ const mapResources = (bytes, layout, issues) => {
         return null;
     }
 };
-const inventoryPagesComplete = (inventory) => inventory.references.complete &&
-    inventory.resources.complete &&
-    inventory.attributes.complete;
-/** Inspect PE/CLI identity directly from bounded bytes without CLR loading. */
-export const inspectManagedArtifactBytes = (bytes, target, limits) => {
+/** Inspect PE/CLI identity directly from local bytes without CLR loading. */
+export const inspectManagedArtifactBytes = (bytes, target) => {
     const layout = readManagedPeLayout(bytes);
     if (layout.cli === null)
-        return unavailableResult(target, bytes, layout, limits);
+        return unavailableResult(target, bytes, layout);
     const cli = layout.cli;
-    if (cli.metadata.size > limits.maxMetadataBytes)
-        return managedArtifactInspectionSchema.parse(partialMetadataResult({
-            target,
-            bytes,
-            layout,
-            limits,
-            issue: {
-                code: "limit-exceeded",
-                scope: "cli.metadata",
-                offset: cli.headerOffset + 8,
-                detail: `CLI metadata size exceeds max_metadata_bytes ${String(limits.maxMetadataBytes)}`,
-            },
-        }));
     let metadata;
     try {
         const metadataOffset = layout.rvaToOffset(cli.metadata.rva, cli.metadata.size, "cli.metadata");
-        metadata = readManagedMetadataLayout(bytes, metadataOffset, cli.metadata.size, limits.maxTableRows);
+        metadata = readManagedMetadataLayout(bytes, metadataOffset, cli.metadata.size);
     }
     catch (cause) {
         if (!(cause instanceof ManagedReaderFailure))
@@ -289,25 +263,18 @@ export const inspectManagedArtifactBytes = (bytes, target, limits) => {
             target,
             bytes,
             layout,
-            limits,
             issue: cause.issue,
         }));
     }
     const resourceIssues = [];
     const resourceDirectory = mapResources(bytes, layout, resourceIssues);
-    const inventory = readManagedMetadataInventory(bytes, metadata, limits, resourceDirectory);
+    const inventory = readManagedMetadataInventory(bytes, metadata, resourceDirectory);
     const issues = [...resourceIssues, ...inventory.issues];
-    const pagesComplete = inventoryPagesComplete(inventory);
     const limitations = [
-        ...(pagesComplete
-            ? []
-            : [
-                "At least one caller-selected metadata page omits rows; use its offset and total to continue.",
-            ]),
         ...(issues.length === 0
             ? []
             : [
-                "At least one bounded metadata or resource item was unavailable; coverage is partial.",
+                "At least one metadata or resource item could not be read; coverage is partial.",
             ]),
         "Static inspection did not load the assembly, resolve dependencies through a CLR, decompile C#, or execute target code.",
     ];
@@ -331,7 +298,7 @@ export const inspectManagedArtifactBytes = (bytes, target, limits) => {
         resources: inventory.resources,
         attributes: inventory.attributes,
         coverage: {
-            state: pagesComplete && issues.length === 0 ? "complete" : "partial",
+            state: issues.length === 0 ? "complete" : "partial",
             issues,
         },
         limitations,

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;