rea-agents 6.0.0 → 6.2.0

package/dist/domain/webBundleAnalyzerResult.js

@@ -3,10 +3,16 @@ export const buildWebBundleAnalysis = (inspection, sourceScripts, sourceMaps, ac
     const unavailable = inspection.scripts.items
         .filter((script) => !script.source.included)
         .map(({ script_key }) => script_key);
+    const omittedScripts = captureBudgetOmission(inspection, "scripts");
+    const omittedSourceMaps = sourceMaps.status === "not_requested"
+        ? undefined
+        : captureBudgetOmission(inspection, "source_maps");
     const sourceMapIncomplete = sourceMaps.status === "partial" || sourceMaps.status === "unavailable";
     const partial = accumulator.parseFailures > 0 ||
         unavailable.length > 0 ||
-        sourceMapIncomplete;
+        sourceMapIncomplete ||
+        omittedScripts !== undefined ||
+        omittedSourceMaps !== undefined;
     return webBundleAnalysisSchema.parse({
         capture: buildCaptureObservation(inspection, sourceScripts),
         observations: {
@@ -25,6 +31,8 @@ export const buildWebBundleAnalysis = (inspection, sourceScripts, sourceMaps, ac
             unavailable,
             parseFailures: accumulator.parseFailures,
             sourceMaps,
+            omittedScripts,
+            omittedSourceMaps,
         }),
         completeness: buildCompleteness({
             partial,
@@ -58,6 +66,15 @@ const chunkNode = (script) => {
     };
 };
 const buildUnknowns = (input) => [
+    ...(input.omittedScripts === undefined
+        ? []
+        : [
+            {
+                dimension: "script_inventory",
+                reason: captureBudgetReason("script records", input.omittedScripts),
+                affected_script_keys: [],
+            },
+        ]),
     ...(input.unavailable.length === 0
         ? []
         : [
@@ -76,13 +93,23 @@ const buildUnknowns = (input) => [
                 affected_script_keys: input.sourceScripts.map(({ script_key }) => script_key),
             },
         ]),
+    ...(input.omittedSourceMaps === undefined
+        ? []
+        : [
+            {
+                dimension: "source_maps",
+                reason: captureBudgetReason("source-map declarations", input.omittedSourceMaps),
+                affected_script_keys: [],
+            },
+        ]),
     ...(input.sourceMaps.status === "not_requested" ||
         input.sourceMaps.status === "included"
         ? []
         : [
             {
                 dimension: "source_maps",
-                reason: "One or more requested source maps were unavailable or incomplete",
+                reason: input.sourceMaps.limitation ??
+                    "One or more requested source maps were unavailable or incomplete",
                 affected_script_keys: input.sourceMaps.items
                     .filter(({ status }) => status !== "included")
                     .map(({ script_key }) => script_key)
@@ -90,6 +117,18 @@ const buildUnknowns = (input) => [
             },
         ]),
 ];
+const captureBudgetOmission = (inspection, section) => {
+    const exclusions = inspection.completeness.excluded.filter((exclusion) => exclusion.section === section &&
+        exclusion.reason === "resource_budget_exhausted");
+    if (exclusions.length === 0)
+        return undefined;
+    if (exclusions.some(({ count }) => count === null))
+        return null;
+    return exclusions.reduce((sum, { count }) => sum + (count ?? 0), 0);
+};
+const captureBudgetReason = (label, count) => count === null
+    ? `Capture omitted an unknown number of ${label} because its resource budget was exhausted.`
+    : `Capture omitted ${String(count)} ${label} because its resource budget was exhausted.`;
 const buildCompleteness = (input) => ({
     status: input.partial ? "partial" : "complete",
     parsed_scripts: input.parsedScripts,

package/dist/domain/webCaptureDiff.js

@@ -1,6 +1,5 @@
 import { canonicalDigest } from "./comparisonSemantics.js";
 import { webCaptureDiffSchema, } from "./webCaptureDiffSchemas.js";
-export { captureSnapshotSchema, compareWebCapturesInputSchema, webCaptureDiffSchema, } from "./webCaptureDiffSchemas.js";
 /** Compare normalized observations without treating incomplete absence as proof. */
 export const compareWebCaptures = (input) => {
     const before = input.before.inspection;

package/dist/domain/webCaptureDiffSchemas.js

@@ -1,11 +1,14 @@
 import { z } from "zod";
 import { emptyArraySchema } from "./emptyArraySchema.js";
-import { webPageInspectionSchema } from "./browserObservation.js";
+import { webPageInspectionSchema } from "./browserObservationSchemas.js";
 import { webMcpDiscoverySchema } from "./webMcpDiscovery.js";
 /** One normalized passive page snapshot accepted by capture comparison. */
 export const captureSnapshotSchema = z.object({
-    inspection: webPageInspectionSchema,
-    webmcp: webMcpDiscoverySchema.nullable().default(null),
+    inspection: webPageInspectionSchema.describe("Complete normalized_result from inspect_web_page, including capture identity, observations, completeness, and limitations."),
+    webmcp: webMcpDiscoverySchema
+        .nullable()
+        .default(null)
+        .describe("Complete normalized_result from discover_webmcp_tools for this capture, or null when it was not recorded."),
 });
 /** Input for deterministic comparison of two normalized web captures. */
 export const compareWebCapturesInputSchema = z.strictObject({

package/dist/domain/webEventListeners.js

@@ -1,12 +1,13 @@
 import { z } from "zod";
-import { webRuntimeBrowserSchema, webRuntimeLocationSchema, webRuntimeScopeSchema, webRuntimeSourceSchema, webRuntimeTargetSchema, } from "./webRuntime.js";
+import { webRuntimeLocationSchema, webRuntimeScopeSchema, webRuntimeSourceSchema, webRuntimeTargetSchema, } from "./webRuntime.js";
+import { browserVersionSchema } from "./browserObservationSchemas.js";
 /** Inspect listeners registered directly on the first main-document CSS match. */
 export const inspectWebEventListenersInputSchema = webRuntimeScopeSchema.extend({
     selector: z.string().min(1),
 });
 /** A listener declaration and its source location do not establish that it ran. */
 export const webEventListenersSchema = z.object({
-    browser: webRuntimeBrowserSchema,
+    browser: browserVersionSchema,
     target: webRuntimeTargetSchema,
     inspected_at: z.iso.datetime(),
     selected_node: z.object({

package/dist/domain/webExecution.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { jsonObjectSchema } from "./jsonValue.js";
-import { webRuntimeBrowserSchema, webRuntimeLocationSchema, webRuntimeScopeSchema, webRuntimeSourceSchema, webRuntimeTargetSchema, } from "./webRuntime.js";
+import { webRuntimeLocationSchema, webRuntimeScopeSchema, webRuntimeSourceSchema, webRuntimeTargetSchema, } from "./webRuntime.js";
+import { browserVersionSchema } from "./browserObservationSchemas.js";
 /** Explicit instrumentation request for one finite, externally driven execution window. */
 export const observeWebExecutionInputSchema = webRuntimeScopeSchema.extend({
     observation_ms: z.number().int().min(1).max(2_147_483_647).default(10_000),
@@ -18,7 +19,7 @@ const functionSchema = z.object({
 });
 /** Precise V8 ranges retain their nested structure and counts without summing them. */
 export const webExecutionSchema = z.object({
-    browser: webRuntimeBrowserSchema,
+    browser: browserVersionSchema,
     target: webRuntimeTargetSchema,
     window: z.object({
         armed_at: z.iso.datetime(),

package/dist/domain/webRuntime.js

@@ -2,6 +2,20 @@ import { z } from "zod";
 import { browserAllowedOriginsSchema, browserEndpointSchema, } from "./browserObservation.js";
 import { browserVersionSchema } from "./browserObservationSchemas.js";
 import { jsonObjectSchema } from "./jsonValue.js";
+// CDP positions are zero-based and relative to the resource named by url.
+// With a script ID that is the script's enclosing resource: the script file,
+// or the HTML document for an inline script. An empty script ID marks a
+// position a request initiator reported, such as parser markup or a module
+// import in a script file; it still locates url, but has no session-script
+// association to join captured source or resource_start.
+// trace_web_source_location takes one-based, script-relative lines, so the
+// advertised units keep callers from passing a position off by one or by an
+// inline script's offset.
+const SCRIPT_ID = "CDP session script ID; empty for a position a request initiator reported, which has no session-script association for joining captured source or resource_start.";
+const RESOURCE_LINE = "Zero-based line in the resource named by url, as reported by CDP: the script file for an external script (including a module-import initiator), or the HTML document for an inline script or parser markup.";
+const RESOURCE_COLUMN = "Zero-based UTF-16 column on that line of the resource named by url, as reported by CDP.";
+const START_LINE = "Zero-based line where the script text starts in its enclosing resource (the HTML document for an inline script).";
+const START_COLUMN = "Zero-based UTF-16 column where the script text starts on that line of its enclosing resource.";
 /** Scope for one externally owned page; omitted origins select its current origin. */
 export const webRuntimeScopeSchema = z.strictObject({
     cdp_endpoint: browserEndpointSchema,
@@ -22,8 +36,8 @@ export const webRuntimeSourceSchema = z.object({
     language: z.string().nullable(),
     resource_start: z
         .object({
-        line_number: z.number().int().min(0),
-        column_number: z.number().int().min(0),
+        line_number: z.number().int().min(0).describe(START_LINE),
+        column_number: z.number().int().min(0).describe(START_COLUMN),
     })
         .nullable(),
     source: z.discriminatedUnion("state", [
@@ -42,10 +56,10 @@ export const webRuntimeSourceSchema = z.object({
 });
 /** Producer callsite coordinates are zero-based resource lines and UTF-16 columns. */
 export const webRuntimeLocationSchema = z.object({
-    script_id: z.string(),
+    script_id: z.string().describe(SCRIPT_ID),
     url: z.string().nullable(),
-    line_number: z.number().int().min(0),
-    column_number: z.number().int().min(0).nullable(),
+    line_number: z.number().int().min(0).describe(RESOURCE_LINE),
+    column_number: z.number().int().min(0).nullable().describe(RESOURCE_COLUMN),
     function_name: z.string().nullable(),
     source_association: z.enum(["script_id", "unknown"]),
 });
@@ -57,8 +71,6 @@ export const webRuntimeTargetSchema = z.object({
     frame_id: z.string().min(1),
     loader_id: z.string().nullable(),
 });
-/** Producer product identity is observed separately from the unknown host platform. */
-export const webRuntimeBrowserSchema = browserVersionSchema;
 /** Complete runtime evidence has explicit byte budgets rather than silent item truncation. */
 export const WEB_RUNTIME_LIMITS = {
     protocolBytes: 64 * 1024 * 1024,

package/dist/domain/webScriptExport.js

@@ -18,7 +18,7 @@ const sourceSchema = z.discriminatedUnion("kind", [
         kind: z.literal("page-script"),
         script_key: z.string().min(1),
         frame_id: z.string().nullable(),
-        is_module: z.boolean(),
+        is_module: z.boolean().nullable(),
         language: z.string().nullable(),
         source_map_url: z.string().nullable(),
     }),

package/dist/domain/webSourceLocation.js

@@ -85,6 +85,7 @@ export const WEB_SOURCE_MAP_LIMITS = {
     outputBytes: 32 * 1024 * 1024,
     decodedRows: 262144,
     decodedSegments: 262144,
+    decodedRecords: 262144,
     sectionDepth: 64,
     decodeTimeoutMs: 20000,
 };

package/dist/dotnet/ManagedArtifactInspector.js

@@ -1,6 +1,6 @@
 import { managedArtifactInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import { readManagedPeLayout, } from "./ManagedPeReader.js";
-import { managedTableRowCounts, readManagedMetadataInventory, } from "./ManagedMetadataInventory.js";
+import { managedTableRowCounts, readManagedMetadataInventory, readManagedResourceDirectory, } from "./ManagedMetadataInventory.js";
 import { readManagedMetadataLayout, } from "./ManagedMetadataLayout.js";
 import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
 const flagNames = (flags) => {
@@ -228,23 +228,6 @@ const partialMetadataResult = ({ target, bytes, layout, issue, }) => ({
         "CLI metadata could not be read because the PE/CLI structure is malformed or unsupported.",
     ],
 });
-const mapResources = (bytes, layout, issues) => {
-    const resources = layout.cli?.resources;
-    if (resources === undefined || (resources.rva === 0 && resources.size === 0))
-        return null;
-    try {
-        return {
-            offset: layout.rvaToOffset(resources.rva, resources.size, "cli.resources"),
-            size: resources.size,
-        };
-    }
-    catch (cause) {
-        if (!(cause instanceof ManagedReaderFailure))
-            throw cause;
-        issues.push(cause.issue);
-        return null;
-    }
-};
 /** Inspect PE/CLI identity directly from local bytes without CLR loading. */
 export const inspectManagedArtifactBytes = (bytes, target) => {
     const layout = readManagedPeLayout(bytes);
@@ -267,7 +250,7 @@ export const inspectManagedArtifactBytes = (bytes, target) => {
         }));
     }
     const resourceIssues = [];
-    const resourceDirectory = mapResources(bytes, layout, resourceIssues);
+    const resourceDirectory = readManagedResourceDirectory(layout, resourceIssues);
     const inventory = readManagedMetadataInventory(bytes, metadata, resourceDirectory);
     const issues = [...resourceIssues, ...inventory.issues];
     const limitations = [

package/dist/dotnet/ManagedMemberInspector.js

@@ -1,8 +1,8 @@
 import { managedMemberInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import { readManagedPeLayout, } from "./ManagedPeReader.js";
-import { managedTableRowCounts, readManagedMetadataInventory, } from "./ManagedMetadataInventory.js";
+import { readManagedResourceDirectory, managedTableRowCounts, readManagedMetadataInventory, } from "./ManagedMetadataInventory.js";
 import { readManagedMetadataLayout } from "./ManagedMetadataLayout.js";
-import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
+import { ManagedReaderFailure, uniqueManagedParseIssues, } from "./ManagedReaderFailure.js";
 import { parseTypes, typeRanges } from "./ManagedMemberInspectorCore.js";
 import { edges, parseFields, parseMemberRefs, parseMethods, } from "./ManagedMemberRows.js";
 const unavailable = (target, bytes, issue) => managedMemberInspectionSchema.parse({
@@ -39,23 +39,13 @@ const unavailable = (target, bytes, issue) => managedMemberInspectionSchema.pars
             : "The CLI metadata could not be admitted; managed member inspection is unavailable.",
     ],
 });
-const resourceDirectory = (pe) => {
-    if (pe.cli === null ||
-        pe.cli.resources.rva === 0 ||
-        pe.cli.resources.size === 0)
-        return null;
-    return {
-        offset: pe.rvaToOffset(pe.cli.resources.rva, pe.cli.resources.size, "cli.resources"),
-        size: pe.cli.resources.size,
-    };
-};
-const readMemberInventory = (bytes, pe) => {
+const readMemberInventory = (bytes, pe, issues) => {
     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");
     const layout = readManagedMetadataLayout(bytes, rootOffset, cli.metadata.size);
-    const inventory = readManagedMetadataInventory(bytes, layout, resourceDirectory(pe));
+    const inventory = readManagedMetadataInventory(bytes, layout, readManagedResourceDirectory(pe, issues));
     return { layout, inventory };
 };
 /** Inspect metadata members and method bodies without loading target code. */
@@ -65,9 +55,9 @@ export const inspectManagedMembersBytes = (bytes, target) => {
         return unavailable(target, bytes, pe.cliIssue);
     const issues = [];
     try {
-        const { layout, inventory } = readMemberInventory(bytes, pe);
+        const { layout, inventory } = readMemberInventory(bytes, pe, issues);
         issues.push(...inventory.issues);
-        const ranges = typeRanges(bytes, layout);
+        const ranges = typeRanges(bytes, layout, issues);
         const parsedTypes = parseTypes(bytes, layout, ranges);
         issues.push(...parsedTypes.issues);
         const fields = parseFields(bytes, layout, ranges);
@@ -79,7 +69,11 @@ export const inspectManagedMembersBytes = (bytes, target) => {
             pe,
             ranges,
         });
-        const coverageIssues = issues;
+        issues.push(...fields.issues, ...methods.issues);
+        const coverageIssues = uniqueManagedParseIssues(issues);
+        const incompleteMembers = [...fields.fields, ...memberRefs.refs, ...methods.methods].some((member) => member.signature.parse_status !== "decoded") ||
+            methods.methods.some((method) => method.body.status === "partial" ||
+                method.body.status === "malformed");
         const related = edges(methods.methods, methods.core, fields.core, memberRefs.core);
         return managedMemberInspectionSchema.parse({
             artifact: {
@@ -106,7 +100,7 @@ export const inspectManagedMembersBytes = (bytes, target) => {
             call_edges: related.callEdges,
             field_accesses: related.fieldAccesses,
             coverage: {
-                state: coverageIssues.length === 0 ? "complete" : "partial",
+                state: issues.length === 0 && !incompleteMembers ? "complete" : "partial",
                 issues: coverageIssues,
             },
             limitations: [

package/dist/dotnet/ManagedMemberInspectorCore.js

@@ -1,4 +1,4 @@
-import { managedFailure, ManagedReaderFailure, } from "./ManagedReaderFailure.js";
+import { managedFailure, ManagedReaderFailure, readManagedValue, } from "./ManagedReaderFailure.js";
 import {} from "./ManagedMetadataLayout.js";
 import { metadataRowCursor, metadataCodedToken, metadataCodedTokenInvalidReason, metadataToken, readMetadataString, sha256Bytes, } from "./ManagedMetadataHeaps.js";
 const rowRange = (table, start, nextStart) => {
@@ -11,13 +11,14 @@ 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) => {
+const readTypeRange = (bytes, layout, row, issues) => {
     const methods = layout.table(6);
     const fields = layout.table(4);
     const cursor = metadataRowCursor(bytes, layout, 2, row);
     cursor.readUInt32();
-    const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
-    const namespace = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
+    const nameIndex = cursor.readIndex(layout.stringIndexSize);
+    const namespaceIndex = cursor.readIndex(layout.stringIndexSize);
+    const declaredName = readManagedValue(() => fullName(readMetadataString(bytes, layout, namespaceIndex, layout.strings.size), readMetadataString(bytes, layout, nameIndex, layout.strings.size)), issues) ?? null;
     cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));
     const fieldStart = cursor.readIndex(layout.tableIndexSize(4));
     const methodStart = cursor.readIndex(layout.tableIndexSize(6));
@@ -35,18 +36,18 @@ const readTypeRange = (bytes, layout, row) => {
     }
     return {
         token: metadataToken(2, row),
-        fullName: fullName(namespace, name),
+        fullName: declaredName,
         fieldStart,
         fieldEnd: nextField,
         methodStart,
         methodEnd: nextMethod,
     };
 };
-export const typeRanges = (bytes, layout) => {
+export const typeRanges = (bytes, layout, issues) => {
     const typeTable = layout.table(2);
     const ranges = [];
     for (let row = 1; row <= (typeTable?.rowCount ?? 0); row += 1)
-        ranges.push(readTypeRange(bytes, layout, row));
+        ranges.push(readTypeRange(bytes, layout, row, issues));
     return ranges;
 };
 export const declaringType = (ranges, table, row) => {
@@ -99,44 +100,46 @@ export const parseTypes = (bytes, layout, ranges) => {
     const items = [];
     const issues = [];
     for (let row = 1; row <= (typeTable?.rowCount ?? 0); row += 1) {
-        const cursor = metadataRowCursor(bytes, layout, 2, row);
-        const flags = cursor.readUInt32();
-        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
-        const namespace = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
-        const extendsOffset = cursor.offset;
-        const extendsRaw = cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));
-        const fieldStart = cursor.readIndex(layout.tableIndexSize(4));
-        const methodStart = cursor.readIndex(layout.tableIndexSize(6));
-        const nextRange = ranges[row] ?? null;
-        const fieldRange = rowRange(fields, fieldStart, nextRange?.fieldStart ?? 0);
-        const methodRange = rowRange(methods, methodStart, nextRange?.methodStart ?? 0);
-        const extendsReason = metadataCodedTokenInvalidReason(extendsRaw, 2, [2, 1, 27], layout.rowCounts);
-        if (extendsReason !== null)
-            issues.push({
-                code: "invalid-row",
-                scope: `metadata.TypeDef:${metadataToken(2, row)}`,
-                offset: extendsOffset,
-                detail: `TypeDef Extends coded index 0x${extendsRaw.toString(16)} is invalid: ${extendsReason}`,
+        readManagedValue(() => {
+            const cursor = metadataRowCursor(bytes, layout, 2, row);
+            const flags = cursor.readUInt32();
+            const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
+            const namespace = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
+            const extendsOffset = cursor.offset;
+            const extendsRaw = cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));
+            const fieldStart = cursor.readIndex(layout.tableIndexSize(4));
+            const methodStart = cursor.readIndex(layout.tableIndexSize(6));
+            const nextRange = ranges[row] ?? null;
+            const fieldRange = rowRange(fields, fieldStart, nextRange?.fieldStart ?? 0);
+            const methodRange = rowRange(methods, methodStart, nextRange?.methodStart ?? 0);
+            const extendsReason = metadataCodedTokenInvalidReason(extendsRaw, 2, [2, 1, 27], layout.rowCounts);
+            if (extendsReason !== null)
+                issues.push({
+                    code: "invalid-row",
+                    scope: `metadata.TypeDef:${metadataToken(2, row)}`,
+                    offset: extendsOffset,
+                    detail: `TypeDef Extends coded index 0x${extendsRaw.toString(16)} is invalid: ${extendsReason}`,
+                });
+            items.push({
+                token: metadataToken(2, row),
+                row_offset: cursor.start,
+                namespace,
+                name,
+                full_name: fullName(namespace, name),
+                flags,
+                extends_token: metadataCodedToken(extendsRaw, 2, [2, 1, 27], layout.rowCounts),
+                field_list: {
+                    first_row: fieldRange.first,
+                    last_row: fieldRange.last,
+                    count: fieldRange.count,
+                },
+                method_list: {
+                    first_row: methodRange.first,
+                    last_row: methodRange.last,
+                    count: methodRange.count,
+                },
             });
-        items.push({
-            token: metadataToken(2, row),
-            row_offset: cursor.start,
-            namespace,
-            name,
-            full_name: fullName(namespace, name),
-            flags,
-            extends_token: metadataCodedToken(extendsRaw, 2, [2, 1, 27], layout.rowCounts),
-            field_list: {
-                first_row: fieldRange.first,
-                last_row: fieldRange.last,
-                count: fieldRange.count,
-            },
-            method_list: {
-                first_row: methodRange.first,
-                last_row: methodRange.last,
-                count: methodRange.count,
-            },
-        });
+        }, issues);
     }
     return { types: items, issues };
 };

package/dist/dotnet/ManagedMemberRows.js

@@ -1,30 +1,34 @@
 import { createDeclaringTypeLookup, signature, } from "./ManagedMemberInspectorCore.js";
 import { metadataToken, metadataRowCursor, metadataCodedToken, metadataCodedTokenInvalidReason, readMetadataBlob, readMetadataString, } from "./ManagedMetadataHeaps.js";
+import { readManagedValue } from "./ManagedReaderFailure.js";
 import { methodBody } from "./ManagedMethodBodyReader.js";
 export const parseFields = (bytes, layout, ranges) => {
     const fields = [];
     const core = new Map();
+    const issues = [];
     const table = layout.table(4);
     const declaringType = createDeclaringTypeLookup(ranges, "field");
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
-        const cursor = metadataRowCursor(bytes, layout, 4, row);
-        const flags = cursor.readUInt16();
-        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
-        const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), layout.blob.size);
-        const declared = declaringType(row);
-        const token = metadataToken(4, row);
-        fields.push({
-            token,
-            row_offset: cursor.start,
-            declaring_type_token: declared?.token ?? null,
-            declaring_type: declared?.fullName ?? null,
-            name,
-            flags,
-            signature: signature(sig),
-        });
-        core.set(token, { token, name });
+        readManagedValue(() => {
+            const cursor = metadataRowCursor(bytes, layout, 4, row);
+            const flags = cursor.readUInt16();
+            const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
+            const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), layout.blob.size);
+            const declared = declaringType(row);
+            const token = metadataToken(4, row);
+            fields.push({
+                token,
+                row_offset: cursor.start,
+                declaring_type_token: declared?.token ?? null,
+                declaring_type: declared?.fullName ?? null,
+                name,
+                flags,
+                signature: signature(sig),
+            });
+            core.set(token, { token, name });
+        }, issues);
     }
-    return { fields, core };
+    return { fields, core, issues };
 };
 export const parseMemberRefs = (bytes, layout) => {
     const refs = [];
@@ -32,62 +36,71 @@ export const parseMemberRefs = (bytes, layout) => {
     const issues = [];
     const table = layout.table(10);
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
-        const cursor = metadataRowCursor(bytes, layout, 10, row);
-        const parentRaw = cursor.readIndex(layout.codedIndexSize("MemberRefParent"));
-        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);
-        const parentReason = metadataCodedTokenInvalidReason(parentRaw, 3, [2, 1, 26, 6, 27], layout.rowCounts);
-        if (parentReason !== null || parentRaw === 0)
-            issues.push({
-                code: "invalid-row",
-                scope: `metadata.MemberRef:${token}`,
-                offset: cursor.start,
-                detail: parentReason === null
-                    ? "MemberRef parent coded index 0x0 is null, but the Class column must reference a row"
-                    : `MemberRef parent coded index 0x${parentRaw.toString(16)} is invalid: ${parentReason}`,
+        readManagedValue(() => {
+            const cursor = metadataRowCursor(bytes, layout, 10, row);
+            const parentRaw = cursor.readIndex(layout.codedIndexSize("MemberRefParent"));
+            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);
+            const parentReason = metadataCodedTokenInvalidReason(parentRaw, 3, [2, 1, 26, 6, 27], layout.rowCounts);
+            if (parentReason !== null || parentRaw === 0)
+                issues.push({
+                    code: "invalid-row",
+                    scope: `metadata.MemberRef:${token}`,
+                    offset: cursor.start,
+                    detail: parentReason === null
+                        ? "MemberRef parent coded index 0x0 is null, but the Class column must reference a row"
+                        : `MemberRef parent coded index 0x${parentRaw.toString(16)} is invalid: ${parentReason}`,
+                });
+            refs.push({
+                token,
+                row_offset: cursor.start,
+                parent_token: metadataCodedToken(parentRaw, 3, [2, 1, 26, 6, 27], layout.rowCounts),
+                name,
+                signature: signature(sig),
             });
-        refs.push({
-            token,
-            row_offset: cursor.start,
-            parent_token: metadataCodedToken(parentRaw, 3, [2, 1, 26, 6, 27], layout.rowCounts),
-            name,
-            signature: signature(sig),
-        });
-        core.set(token, { token, name });
+            core.set(token, { token, name });
+        }, issues);
     }
     return { refs, core, issues };
 };
 export const parseMethods = ({ bytes, layout, pe, ranges, }) => {
     const methods = [];
     const core = new Map();
+    const issues = [];
     const table = layout.table(6);
     const declaringType = createDeclaringTypeLookup(ranges, "method");
     for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
-        const cursor = metadataRowCursor(bytes, layout, 6, row);
-        const rva = cursor.readUInt32();
-        const implFlags = cursor.readUInt16();
-        const flags = cursor.readUInt16();
-        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
-        const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), layout.blob.size);
-        cursor.readIndex(layout.tableIndexSize(8));
-        const declared = declaringType(row);
-        const token = metadataToken(6, row);
-        methods.push({
-            token,
-            row_offset: cursor.start,
-            declaring_type_token: declared?.token ?? null,
-            declaring_type: declared?.fullName ?? null,
-            name,
-            rva,
-            impl_flags: implFlags,
-            flags,
-            signature: signature(sig),
-            body: methodBody(bytes, pe, rva, { implFlags, flags }),
-        });
-        core.set(token, { token, name, declaringType: declared?.fullName ?? null });
+        readManagedValue(() => {
+            const cursor = metadataRowCursor(bytes, layout, 6, row);
+            const rva = cursor.readUInt32();
+            const implFlags = cursor.readUInt16();
+            const flags = cursor.readUInt16();
+            const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
+            const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), layout.blob.size);
+            cursor.readIndex(layout.tableIndexSize(8));
+            const declared = declaringType(row);
+            const token = metadataToken(6, row);
+            methods.push({
+                token,
+                row_offset: cursor.start,
+                declaring_type_token: declared?.token ?? null,
+                declaring_type: declared?.fullName ?? null,
+                name,
+                rva,
+                impl_flags: implFlags,
+                flags,
+                signature: signature(sig),
+                body: methodBody(bytes, pe, rva, { implFlags, flags }),
+            });
+            core.set(token, {
+                token,
+                name,
+                declaringType: declared?.fullName ?? null,
+            });
+        }, issues);
     }
-    return { methods, core };
+    return { methods, core, issues };
 };
 const targetKind = (token) => token.startsWith("0x06")
     ? "method-def"