rea-agents 6.1.0 → 6.2.0

package/dist/domain/providerAdapterError.js

@@ -4,11 +4,13 @@ export class ProviderAdapterError extends AnalysisError {
     providerId;
     operation;
     _tag = "ProviderAdapterError";
+    userMessage;
     diagnostics;
     constructor(providerId, operation, options = {}) {
         super(`Provider ${providerId} adapter failed during ${operation}`, options);
         this.providerId = providerId;
         this.operation = operation;
+        this.userMessage = options.userMessage;
         this.diagnostics =
             options.diagnostics === undefined
                 ? undefined

package/dist/domain/reconstructionCoverage.js

@@ -5,8 +5,11 @@ import { evidenceBundleSchema, parseEvidenceBundle } from "./evidenceBundle.js";
 import { evaluateReconstructionClaims, evaluateReconstructionPackageProofs, evaluateReconstructionSurfaces, evaluateReconstructionCoverageRisks, recommendedReconstructionProbes, } from "./reconstructionCoverageEvaluation.js";
 import { digestSchema } from "./../domain/digests.js";
 import { prefixedDigestSchema } from "./../domain/digests.js";
+import { offsetDateTimeSchema } from "./offsetDateTime.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
-const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]{0,199}$/u);
+const stableIdSchema = z
+    .string()
+    .regex(/^[A-Za-z][A-Za-z0-9._:\x2f\x2d]{0,199}$/u);
 const boundedTextSchema = z.string().trim().min(1);
 const authoritySchema = z.enum([
     "observed",
@@ -86,7 +89,7 @@ const verifierContractSchema = verifierContractBaseSchema.extend({
 const verifierResultSchema = z.strictObject({
     verifier_id: stableIdSchema,
     contract_sha256: digestSchema,
-    observed_at: z.string().datetime({ offset: true }),
+    observed_at: offsetDateTimeSchema,
     status: z.enum([
         "pass",
         "fail",

package/dist/domain/reconstructionObligationLedgerSchemas.js

@@ -1,9 +1,10 @@
 import { z } from "zod";
+import { STABLE_IDENTIFIER_PATTERN } from "./stringPatterns.js";
 import { evidenceBundleSchema } from "./evidenceBundle.js";
 import { digestSchema } from "./../domain/digests.js";
 import { prefixedDigestSchema } from "./../domain/digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
-const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]*$/u);
+const stableIdSchema = z.string().regex(STABLE_IDENTIFIER_PATTERN);
 const textSchema = z.string().trim().min(1);
 export const obligationStatusSchema = z.enum([
     "unowned",

package/dist/domain/reconstructionReadinessSchemas.js

@@ -1,10 +1,11 @@
 import { z } from "zod";
+import { STABLE_IDENTIFIER_PATTERN } from "./stringPatterns.js";
 import { evidenceBundleSchema } from "./evidenceBundle.js";
 import { reconstructionObligationLedgerSchema } from "./reconstructionObligationLedgerSchemas.js";
 import { digestSchema } from "./../domain/digests.js";
 import { prefixedDigestSchema } from "./../domain/digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
-const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]*$/u);
+const stableIdSchema = z.string().regex(STABLE_IDENTIFIER_PATTERN);
 const boundedTextSchema = z.string().trim().min(1);
 export const readinessStatusSchema = z.enum([
     "pass",

package/dist/domain/reconstructionVerification.js

@@ -7,13 +7,13 @@ import { uniqueSorted } from "./canonicalOrdering.js";
 import { comparisonSourceEvidenceSides } from "./comparisonSourceEvidence.js";
 import { parseEvidence } from "./evidence.js";
 import { parseEvidenceBundle } from "./evidenceBundle.js";
-import { functionComparisonResultSchema } from "./functionComparison.js";
+import { functionComparisonResultSchema } from "./functionComparisonSchemas.js";
 import { PROCESS_PROVIDER, isProcessEvidenceProvider, } from "./process/processEvidenceProvider.js";
 import { functionDossierSchema } from "./hopperValues.js";
-import { deriveProcessComparisonStatus, PROCESS_COMPARISON_DIMENSIONS, processCaptureComparisonSchema, parseProcessCapture, } from "./process/processCapture.js";
+import { deriveProcessComparisonStatus, PROCESS_COMPARISON_DIMENSIONS, processCaptureComparisonSchema, } from "./process/processComparison.js";
+import { parseProcessCapture } from "./process/processCaptureParsing.js";
 import { reconstructionClaimResultSchema, reconstructionSpecificationSchema, reconstructionVerificationResultSchema, } from "./reconstructionVerificationSchemas.js";
 import { reconstructionClaimUnknowns, reconstructionProbes, reconstructionUnknownHeads, } from "./reconstructionUnknowns.js";
-export { reconstructionVerificationInputSchema, reconstructionVerificationResultSchema, } from "./reconstructionVerificationSchemas.js";
 const providers = {
     behavioral: {
         operation: "compare_process_captures",

package/dist/domain/reconstructionVerificationSchemas.js

@@ -1,10 +1,11 @@
 import { z } from "zod";
+import { IDENTIFIER_PATTERN } from "./stringPatterns.js";
 import { digestSchema } from "./../domain/digests.js";
 import { prefixedDigestSchema } from "./../domain/digests.js";
 import { PROCESS_COMPARISON_DIMENSIONS } from "./process/processComparison.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
 const unknownIdSchema = prefixedDigestSchema("unk");
-const claimIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]*$/u);
+const claimIdSchema = z.string().regex(IDENTIFIER_PATTERN);
 const titleSchema = z.string().trim().min(1);
 const verificationStatusSchema = z.enum(["pass", "fail", "unknown"]);
 const commonClaim = {

package/dist/domain/referenceSourceGraph.js

@@ -66,26 +66,27 @@ const sourceDirectorySchema = z.strictObject({
 const symlinkTargetSchema = z
     .string()
     .min(1)
-    .refine((target) => target === "<outside-root>" ||
-    isPortableAbsoluteSymlinkTarget(target) ||
+    .refine((target) => isPortableAbsoluteSymlinkTarget(target) ||
     (!target.startsWith("/") &&
         !target.includes("\\") &&
         posix.normalize(target) === target), "Expected a normalized POSIX symlink target");
 const isPortableAbsoluteSymlinkTarget = (target) => target.startsWith("/") ||
     /^[A-Za-z]:[\\/]/u.test(target) ||
     /^\\\\[^\\/]+[\\/][^\\/]+/u.test(target);
-const sourceSymlinkSchema = z.strictObject({
-    ...entryBaseShape,
-    kind: z.literal("symlink"),
-    target: symlinkTargetSchema,
-    target_state: z.enum([
-        "internal",
-        "external",
-        "missing",
-        "unreadable",
-        "unknown",
-    ]),
-});
+const sourceSymlinkSchema = z.union([
+    z.strictObject({
+        ...entryBaseShape,
+        kind: z.literal("symlink"),
+        target: symlinkTargetSchema,
+        target_state: z.enum(["internal", "external", "missing"]),
+    }),
+    z.strictObject({
+        ...entryBaseShape,
+        kind: z.literal("symlink"),
+        target: z.null(),
+        target_state: z.enum(["unreadable", "unknown"]),
+    }),
+]);
 const sourceEntrySchema = z.union([
     sourceFileSchema,
     sourceDirectorySchema,
@@ -152,7 +153,7 @@ const graphShape = {
         caller: z
             .string()
             .min(1)
-            .regex(/^[\w .:@/+-]+$/u),
+            .regex(/^[\w .:@\x2f+\x2d]+$/u),
     }),
     limitations: z.array(boundedTextSchema),
 };
@@ -232,13 +233,11 @@ const checkSymlinks = (graph, paths, context) => {
     for (const [index, entry] of graph.entries.entries()) {
         if (entry.kind !== "symlink")
             continue;
+        if (entry.target === null)
+            continue;
         const absolute = isPortableAbsoluteSymlinkTarget(entry.target);
-        if ((entry.target_state === "external" &&
-            entry.target !== "<outside-root>" &&
-            !absolute) ||
-            (entry.target_state === "internal" &&
-                (entry.target === "<outside-root>" || absolute)) ||
-            (entry.target_state === "missing" && entry.target === "<outside-root>"))
+        if ((entry.target_state === "external" && !absolute) ||
+            (entry.target_state === "internal" && absolute))
             context.addIssue({
                 code: "custom",
                 message: "Symlink target path does not match its target state",

package/dist/domain/staticRuntimeCorrelation.js

@@ -5,9 +5,9 @@ import { artifactComparisonResultSchema } from "./artifactComparison.js";
 import { uniqueSorted } from "./canonicalOrdering.js";
 import { comparisonSourceEvidenceIds } from "./comparisonSourceEvidence.js";
 import { evidenceSchema, parseEvidence } from "./evidence.js";
-import { functionComparisonResultSchema } from "./functionComparison.js";
+import { functionComparisonResultSchema } from "./functionComparisonSchemas.js";
 import { PROCESS_PROVIDER, isProcessEvidenceProvider, } from "./process/processEvidenceProvider.js";
-import { comparisonStatusSchema, processCaptureComparisonSchema, } from "./process/processCapture.js";
+import { comparisonStatusSchema, processCaptureComparisonSchema, } from "./process/processComparison.js";
 import { PROCESS_COMPARISON_DIMENSIONS } from "./process/processComparison.js";
 import { prefixedDigestSchema } from "./../domain/digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");

package/dist/domain/stringPatterns.js

@@ -0,0 +1,6 @@
+/** Portable ASCII identifier starting with a letter. */
+export const IDENTIFIER_PATTERN = /^[A-Za-z][A-Za-z0-9._\x2d]*$/u;
+/** Stable evidence identifier, also admitting namespace and path separators. */
+export const STABLE_IDENTIFIER_PATTERN = /^[A-Za-z][A-Za-z0-9._:\x2f\x2d]*$/u;
+/** Canonical padded base64, including zero pad bits and the empty encoding. */
+export const CANONICAL_BASE64_PATTERN = /^(?:[A-Za-z0-9+\x2f]{4})*(?:[A-Za-z0-9+\x2f][AQgw]==|[A-Za-z0-9+\x2f]{2}[AEIMQUYcgkosw048]=)?$/;

package/dist/domain/swiftSymbolClassification.js

@@ -0,0 +1,61 @@
+const LEGACY_CATEGORIES = [
+    ["_TtC", "classes"],
+    ["_TtV", "structs"],
+    ["_TtO", "enums"],
+    ["_TtP", "protocols"],
+    ["_TtE", "extensions"],
+];
+const NOMINAL_CATEGORIES = new Map([
+    ["C", "classes"],
+    ["V", "structs"],
+    ["O", "enums"],
+    ["P", "protocols"],
+]);
+/**
+ * Recognize Swift manglings and decode literal module/nominal contexts.
+ * Substitutions, generic contexts, and other encodings remain unknown.
+ */
+export const classifySwiftSymbol = (name) => {
+    const prefix = /^_?(?:\$[sS]|_T0)/u.exec(name);
+    if (prefix === null) {
+        if (!name.includes("_Tt"))
+            return undefined;
+        return {
+            category: LEGACY_CATEGORIES.find(([prefix]) => name.startsWith(prefix))?.[1] ??
+                null,
+        };
+    }
+    const mangling = name.slice(prefix[0].length);
+    let offset = identifierEnd(mangling, 0);
+    if (offset === undefined)
+        return { category: null };
+    let category = null;
+    for (;;) {
+        const end = identifierEnd(mangling, offset);
+        if (end === undefined)
+            break;
+        const kind = mangling.charAt(end);
+        const nominal = NOMINAL_CATEGORIES.get(kind);
+        if (nominal === undefined) {
+            if (kind === "E" && category !== null)
+                category = "extensions";
+            break;
+        }
+        category = nominal;
+        offset = end + 1;
+    }
+    return { category };
+};
+const identifierEnd = (mangling, offset) => {
+    const lengthToken = /^[1-9][0-9]*/u.exec(mangling.slice(offset))?.[0];
+    if (lengthToken === undefined)
+        return undefined;
+    const start = offset + lengthToken.length;
+    const end = start + Number(lengthToken);
+    // Swift identifiers with substitutions/punycode need a fuller decoder.
+    if (!Number.isSafeInteger(end) ||
+        end > mangling.length ||
+        !/^[A-Za-z_][A-Za-z0-9_]*$/u.test(mangling.slice(start, end)))
+        return undefined;
+    return end;
+};

package/dist/domain/symbolAnalysis.js

@@ -1,3 +1,4 @@
+import { classifySwiftSymbol, } from "./swiftSymbolClassification.js";
 /** Select and deduplicate Objective-C class labels. */
 export const discoverObjcClasses = (names, pattern) => {
     const classes = uniqueByName(names
@@ -16,33 +17,80 @@ export const discoverObjcProtocols = (names) => {
         protocols: protocols.map(toJsonEntry),
     };
 };
-const SWIFT_CATEGORIES = [
-    ["classes", "_TtC"],
-    ["structs", "_TtV"],
-    ["enums", "_TtO"],
-    ["protocols", "_TtP"],
-    ["extensions", "_TtE"],
-];
-/** Categorize deduplicated Swift mangled symbols. */
-export const categorizeSwiftTypes = (procedures, filter = {}) => {
-    const groups = Object.fromEntries([...SWIFT_CATEGORIES.map(([category]) => category), "other"].map((category) => [category, []]));
+/** Categorize procedure names using Swift manglings at their exact addresses. */
+export const categorizeSwiftTypes = (procedures, filter = {}, symbols = []) => {
+    const groups = Object.fromEntries(["classes", "structs", "enums", "protocols", "extensions", "other"].map((category) => [category, []]));
+    const aliases = swiftAliasesByAddress(symbols);
+    const pattern = filter.pattern;
     const seen = new Set();
+    const unclassifiedNames = new Set();
+    const unclassified = [];
     for (const entry of procedures) {
-        if (!entry.name.includes("_Tt") || seen.has(entry.name))
+        if (seen.has(entry.name))
             continue;
-        const category = SWIFT_CATEGORIES.find(([, prefix]) => entry.name.startsWith(prefix))?.[0] ?? "other";
-        if (filter.category !== undefined && filter.category !== category)
+        const mangledNames = [
+            ...new Set([
+                ...(classifySwiftSymbol(entry.name) === undefined ? [] : [entry.name]),
+                ...(aliases.get(entry.address) ?? []),
+            ]),
+        ];
+        if (mangledNames.length === 0)
             continue;
-        if (filter.pattern !== undefined && !entry.name.includes(filter.pattern))
+        if (pattern !== undefined &&
+            ![entry.name, ...mangledNames].some((name) => name.includes(pattern)))
             continue;
-        seen.add(entry.name);
-        groups[category]?.push(entry);
+        const kinds = new Set(mangledNames.map((name) => classifySwiftSymbol(name)?.category ?? null));
+        const category = kinds.size === 1 ? ([...kinds][0] ?? null) : null;
+        const item = {
+            address: entry.address,
+            name: entry.name,
+            mangled_names: mangledNames,
+        };
+        if (category === null && !unclassifiedNames.has(entry.name)) {
+            unclassifiedNames.add(entry.name);
+            unclassified.push({
+                ...item,
+                reason: kinds.size > 1 && !kinds.has(null)
+                    ? "conflicting_categories"
+                    : "category_not_decoded",
+            });
+        }
+        const bucket = category ?? "other";
+        if (filter.category === undefined || filter.category === bucket) {
+            seen.add(entry.name);
+            groups[bucket]?.push(item);
+        }
     }
     const categories = Object.fromEntries(Object.entries(groups).map(([category, items]) => [
         category,
-        { count: items.length, items: items.map(toJsonEntry) },
+        { count: items.length, items },
     ]));
-    return { total: seen.size, categories };
+    return {
+        total: Object.values(groups).reduce((sum, items) => sum + items.length, 0),
+        categories,
+        unclassified,
+        limitations: [
+            "Identification uses Swift mangled procedure names or same-address symbol aliases. Demangled names without retained Swift manglings cannot be identified. Counts deduplicate procedure names, not source declarations.",
+            ...(unclassified.length === 0
+                ? []
+                : [
+                    "Some Swift categories could not be established from the retained manglings. Unclassified observations remain inline regardless of the category filter.",
+                ]),
+        ],
+    };
+};
+const swiftAliasesByAddress = (symbols) => {
+    const aliases = new Map();
+    for (const { address, name } of symbols) {
+        if (classifySwiftSymbol(name) === undefined)
+            continue;
+        const existing = aliases.get(address);
+        if (existing === undefined)
+            aliases.set(address, [name]);
+        else
+            existing.push(name);
+    }
+    return aliases;
 };
 const uniqueByName = (entries) => {
     const seen = new Set();

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

@@ -71,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/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: [