rea-agents 6.3.0 → 6.5.0

package/dist/dotnet/ManagedArtifactInspector.js

@@ -1,7 +1,9 @@
+import { admitManagedProjection, managedDecodeBudget, } from "./ManagedDecodeBudget.js";
 import { managedArtifactInspectionSchema, } from "../domain/managed/managedArtifact.js";
-import { readManagedPeLayout, } from "./ManagedPeReader.js";
+import { managedCli32BitRequirement, readManagedPeLayout, } from "./ManagedPeReader.js";
 import { managedTableRowCounts, readManagedMetadataInventory, readManagedResourceDirectory, } from "./ManagedMetadataInventory.js";
 import { readManagedMetadataLayout, } from "./ManagedMetadataLayout.js";
+import { readTypeMemberListFacts } from "./ManagedTypeMemberLists.js";
 import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
 const flagNames = (flags) => {
     const names = [];
@@ -64,7 +66,7 @@ const base = (target, bytes, layout) => ({
     pe: peProjection(layout),
 });
 const unavailableResult = (target, bytes, layout) => {
-    const malformed = layout.cliDirectoryPresent;
+    const malformed = layout.cliDirectoryState !== "absent";
     const issues = layout.cliIssue === null ? [] : [layout.cliIssue];
     const limitations = malformed
         ? [
@@ -73,7 +75,7 @@ const unavailableResult = (target, bytes, layout) => {
         : [
             "The PE has no CLI data directory; managed metadata and CIL are unavailable.",
         ];
-    return managedArtifactInspectionSchema.parse({
+    return managedArtifactInspectionSchema.parse(admitManagedProjection({
         ...base(target, bytes, layout),
         classification: {
             status: malformed ? "malformed" : "not-managed",
@@ -83,7 +85,9 @@ const unavailableResult = (target, bytes, layout) => {
             managed_architecture: "unknown",
             evidence: [
                 {
-                    code: malformed ? "cli-directory-malformed" : "cli-directory-absent",
+                    code: malformed
+                        ? "cli-directory-malformed"
+                        : "cli-directory-absent",
                     detail: limitations[0],
                     file_offset: layout.cliIssue?.offset ?? null,
                 },
@@ -106,8 +110,13 @@ const unavailableResult = (target, bytes, layout) => {
             issues,
         },
         limitations,
-    });
+    }));
 };
+const runtimeFamilyFromCliHeader = (cli) => cli?.readyToRunSignature === true
+    ? "modern-dotnet"
+    : cli !== null && (cli.flags & 1) === 0
+        ? "mixed-clr-native"
+        : "unknown";
 const runtimeFamilyFor = (cli, inventory, metadata, layout) => {
     const evidence = [
         {
@@ -119,7 +128,9 @@ const runtimeFamilyFor = (cli, inventory, metadata, layout) => {
     const frameworks = inventory.targetFrameworks;
     const hasUnity = inventory.referenceNames.some((name) => name === "UnityEngine" || name.startsWith("UnityEngine."));
     let runtimeFamily = "unknown";
-    if ((cli.flags & 1) === 0) {
+    // crossgen2 clears ILONLY on ReadyToRun output, so only a clear flag
+    // without the ReadyToRun signature indicates mixed CLR/native code.
+    if (runtimeFamilyFromCliHeader(cli) === "mixed-clr-native") {
         runtimeFamily = "mixed-clr-native";
         evidence.push({
             code: "cli-il-only-clear",
@@ -143,7 +154,7 @@ const runtimeFamilyFor = (cli, inventory, metadata, layout) => {
             file_offset: metadata.table(12)?.offset ?? null,
         });
     }
-    else if (frameworks.some((value) => value.startsWith(".NETCoreApp,") || value.startsWith(".NETStandard,")) ||
+    else if (frameworks.some((value) => value.startsWith(".NETCoreApp,")) ||
         cli.readyToRunSignature) {
         runtimeFamily = "modern-dotnet";
         evidence.push({
@@ -158,23 +169,29 @@ const runtimeFamilyFor = (cli, inventory, metadata, layout) => {
                 : (metadata.table(12)?.offset ?? null),
         });
     }
+    else if (frameworks.some((value) => value.startsWith(".NETStandard,"))) {
+        evidence.push({
+            code: "target-framework-observed",
+            detail: "An assembly-level TargetFrameworkAttribute names .NET Standard, an API specification that does not identify a runtime family.",
+            file_offset: metadata.table(12)?.offset ?? null,
+        });
+    }
     return { runtime_family: runtimeFamily, evidence };
 };
 const implementationFor = (cli, metadata) => {
-    if ((cli.flags & 1) === 0)
-        return "cpp-cli-mixed";
     if (cli.readyToRunSignature)
         return "cil-and-ready-to-run";
+    if ((cli.flags & 1) === 0)
+        return "cpp-cli-mixed";
     return (metadata.rowCounts[6] ?? 0) === 0 ? "metadata-only" : "cil";
 };
 const managedArchitectureFor = (layout, cli) => {
     if (layout.architecture !== "x86" || (cli.flags & 1) === 0)
         return layout.architecture;
-    if ((cli.flags & 0x0000_0002) !== 0)
+    const requirement = managedCli32BitRequirement(cli.flags);
+    if (requirement === "required")
         return "x86";
-    if ((cli.flags & 0x0002_0000) !== 0)
-        return "anycpu-prefer-32";
-    return "anycpu";
+    return requirement === "preferred" ? "anycpu-prefer-32" : "anycpu";
 };
 const runtimeClassification = ({ layout, metadata, inventory, }) => {
     const cli = layout.cli;
@@ -198,9 +215,9 @@ const runtimeClassification = ({ layout, metadata, inventory, }) => {
 const partialMetadataResult = ({ target, bytes, layout, issue, }) => ({
     ...base(target, bytes, layout),
     classification: {
-        status: "malformed",
+        status: issue.code === "resource-limit" ? "managed" : "malformed",
         container: "pe",
-        runtime_family: (layout.cli?.flags ?? 1) & 1 ? "unknown" : "mixed-clr-native",
+        runtime_family: runtimeFamilyFromCliHeader(layout.cli),
         implementation: "unknown",
         managed_architecture: "unknown",
         evidence: [
@@ -212,7 +229,7 @@ const partialMetadataResult = ({ target, bytes, layout, issue, }) => ({
         ],
     },
     metadata: {
-        status: "malformed",
+        status: issue.code === "resource-limit" ? "partial" : "malformed",
         version: null,
         stream_names: [],
         table_row_counts: {},
@@ -225,7 +242,9 @@ const partialMetadataResult = ({ target, bytes, layout, issue, }) => ({
     attributes: [],
     coverage: { state: "partial", issues: [issue] },
     limitations: [
-        "CLI metadata could not be read because the PE/CLI structure is malformed or unsupported.",
+        issue.code === "resource-limit"
+            ? "CLI metadata inspection stopped at its representation budget; omitted facts are unknown."
+            : "CLI metadata could not be read because the PE/CLI structure is malformed or unsupported.",
     ],
 });
 /** Inspect PE/CLI identity directly from local bytes without CLR loading. */
@@ -242,48 +261,56 @@ export const inspectManagedArtifactBytes = (bytes, target) => {
     catch (cause) {
         if (!(cause instanceof ManagedReaderFailure))
             throw cause;
-        return managedArtifactInspectionSchema.parse(partialMetadataResult({
+        return managedArtifactInspectionSchema.parse(admitManagedProjection(partialMetadataResult({
             target,
             bytes,
             layout,
             issue: cause.issue,
-        }));
+        })));
     }
     const resourceIssues = [];
     const resourceDirectory = readManagedResourceDirectory(layout, resourceIssues);
-    const inventory = readManagedMetadataInventory(bytes, metadata, resourceDirectory);
-    const issues = [...resourceIssues, ...inventory.issues];
-    const limitations = [
-        ...(issues.length === 0
-            ? []
-            : [
-                "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.",
-    ];
-    return managedArtifactInspectionSchema.parse({
-        ...base(target, bytes, layout),
-        classification: {
-            status: "managed",
-            container: "pe",
-            ...runtimeClassification({ layout, metadata, inventory }),
-        },
-        metadata: {
-            status: issues.length === 0 ? "complete" : "partial",
-            version: metadata.version,
-            stream_names: metadata.streamNames,
-            table_row_counts: managedTableRowCounts(metadata),
-        },
-        module: inventory.module,
-        assembly: inventory.assembly,
-        target_frameworks: inventory.targetFrameworks,
-        references: inventory.references,
-        resources: inventory.resources,
-        attributes: inventory.attributes,
-        coverage: {
-            state: issues.length === 0 ? "complete" : "partial",
-            issues,
-        },
-        limitations,
-    });
+    try {
+        const memberLists = readTypeMemberListFacts(bytes, metadata);
+        const inventory = readManagedMetadataInventory(bytes, metadata, resourceDirectory, memberLists);
+        const issues = [...resourceIssues, ...inventory.issues];
+        const limitations = [
+            ...(issues.length === 0
+                ? []
+                : [
+                    "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.",
+        ];
+        return managedArtifactInspectionSchema.parse(admitManagedProjection({
+            ...base(target, bytes, layout),
+            classification: {
+                status: "managed",
+                container: "pe",
+                ...runtimeClassification({ layout, metadata, inventory }),
+            },
+            metadata: {
+                status: issues.length === 0 ? "complete" : "partial",
+                version: metadata.version,
+                stream_names: metadata.streamNames,
+                table_row_counts: managedTableRowCounts(metadata),
+            },
+            module: inventory.module,
+            assembly: inventory.assembly,
+            target_frameworks: inventory.targetFrameworks,
+            references: inventory.references,
+            resources: inventory.resources,
+            attributes: inventory.attributes,
+            coverage: {
+                state: issues.length === 0 ? "complete" : "partial",
+                issues,
+            },
+            limitations,
+        }, managedDecodeBudget(metadata)));
+    }
+    catch (cause) {
+        if (!(cause instanceof ManagedReaderFailure))
+            throw cause;
+        return managedArtifactInspectionSchema.parse(admitManagedProjection(partialMetadataResult({ target, bytes, layout, issue: cause.issue })));
+    }
 };

package/dist/dotnet/ManagedDecodeBudget.js

@@ -0,0 +1,138 @@
+import { createHash } from "node:crypto";
+import { managedFailure } from "./ManagedReaderFailure.js";
+/** Per-inspection capacity for eagerly retained metadata and its JSON projection. */
+const MAX_METADATA_REPRESENTATION_BYTES = 64 * 1024 * 1024;
+/** The layout owns decoding capacity and heap identity for all of its consumers. */
+export class ManagedDecodeBudget {
+    #remaining = MAX_METADATA_REPRESENTATION_BYTES;
+    #transient = 0;
+    #rows = new Map();
+    #strings = new Map();
+    #digests = new WeakMap();
+    reserve(bytes, offset) {
+        this.#admit(bytes, offset);
+        this.#remaining -= bytes;
+    }
+    /** Retain one bookkeeping reservation per physical row, independently of lookup replay. */
+    reserveRow(table, row, offset) {
+        let rows = this.#rows.get(table);
+        if (rows?.has(row) === true)
+            return;
+        this.reserve(256, offset);
+        if (rows === undefined) {
+            rows = new Set();
+            this.#rows.set(table, rows);
+        }
+        rows.add(row);
+    }
+    /** Bound a decoding allocation that stays live until `releaseTransient`; only retained output is reserved. */
+    admitTransient(bytes, offset) {
+        this.#admit(bytes, offset);
+        this.#transient += bytes;
+    }
+    /** End the current item's decoding; its bookkeeping is unreachable and only reserved output remains. */
+    releaseTransient() {
+        this.#transient = 0;
+    }
+    #admit(bytes, offset) {
+        if (!Number.isSafeInteger(bytes) ||
+            bytes < 0 ||
+            bytes > this.#remaining - this.#transient)
+            throw managedFailure("resource-limit", "metadata.representation", `Managed metadata exceeds the ${String(MAX_METADATA_REPRESENTATION_BYTES)} byte representation budget`, offset);
+    }
+    /** UTF-8 cannot decode to more UTF-16 units than bytes; JSON uses at most six bytes per unit. */
+    reserveString(encodedBytes, offset) {
+        this.reserve(encodedBytes * 6 + 2, offset);
+    }
+    /** Snapshot buffers are immutable within a layout; cache exact backing-buffer ranges. */
+    digest(bytes, algorithm) {
+        let ranges = this.#digests.get(bytes.buffer);
+        if (ranges === undefined) {
+            ranges = new Map();
+            this.#digests.set(bytes.buffer, ranges);
+        }
+        const key = `${algorithm}:${String(bytes.byteOffset)}:${String(bytes.byteLength)}`;
+        const cached = ranges.get(key);
+        if (cached !== undefined)
+            return cached;
+        this.reserve(256, null);
+        const digest = createHash(algorithm).update(bytes).digest("hex");
+        ranges.set(key, digest);
+        return digest;
+    }
+    cachedString(index) {
+        return this.#strings.get(index);
+    }
+    cacheString(index, value, encodedBytes) {
+        this.#strings.set(index, { value, encodedBytes });
+    }
+}
+const budgets = new WeakMap();
+/** Transfer metadata-root admission capacity to its completed immutable layout. */
+export const attachManagedDecodeBudget = (layout, budget) => {
+    budgets.set(layout, budget);
+};
+/** Share one owner for the lifetime of the admitted layout, including all inspection facets. */
+export const managedDecodeBudget = (layout) => {
+    let budget = budgets.get(layout);
+    if (budget === undefined) {
+        budget = new ManagedDecodeBudget();
+        budgets.set(layout, budget);
+    }
+    return budget;
+};
+/** Exact UTF-8 bytes of a JSON string literal, counted without serializing it. */
+export const managedJsonStringBytes = (value) => {
+    let bytes = 2;
+    for (let index = 0; index < value.length; index++) {
+        const unit = value.charCodeAt(index);
+        if (unit === 0x22 || unit === 0x5c)
+            bytes += 2;
+        else if (unit < 0x20)
+            bytes += [0x08, 0x09, 0x0a, 0x0c, 0x0d].includes(unit) ? 2 : 6;
+        else if (unit < 0x80)
+            bytes += 1;
+        else if (unit < 0x800)
+            bytes += 2;
+        else if (unit >= 0xd800 && unit <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                bytes += 4;
+                index++;
+            }
+            else
+                bytes += 6;
+        }
+        else if (unit >= 0xdc00 && unit <= 0xdfff)
+            bytes += 6;
+        else
+            bytes += 3;
+    }
+    return bytes;
+};
+/** Exact UTF-8 JSON bytes of a decoded scalar or key, including escapes. */
+const jsonBytes = (item) => typeof item === "string"
+    ? managedJsonStringBytes(item)
+    : Buffer.byteLength(JSON.stringify(item) ?? "null");
+/** Admit repeated values too: shared heap strings still expand at the JSON boundary. */
+export const admitManagedProjection = (value, budget = new ManagedDecodeBudget()) => {
+    const visit = (item) => {
+        if (Array.isArray(item)) {
+            budget.reserve(item.length + 2, null);
+            for (const child of item)
+                visit(child);
+        }
+        else if (item !== null && typeof item === "object") {
+            budget.reserve(2, null);
+            for (const key of Object.keys(item)) {
+                budget.reserve(jsonBytes(key) + 2, null);
+                visit(Reflect.get(item, key));
+            }
+        }
+        else {
+            budget.reserve(jsonBytes(item), null);
+        }
+    };
+    visit(value);
+    return value;
+};

package/dist/dotnet/ManagedMemberInspector.js

@@ -1,11 +1,16 @@
+import { admitManagedProjection, managedDecodeBudget, } from "./ManagedDecodeBudget.js";
 import { managedMemberInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import { readManagedPeLayout, } from "./ManagedPeReader.js";
 import { readManagedResourceDirectory, managedTableRowCounts, readManagedMetadataInventory, } from "./ManagedMetadataInventory.js";
 import { readManagedMetadataLayout } from "./ManagedMetadataLayout.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({
+import { appendManagedParseIssues, ManagedReaderFailure, uniqueManagedParseIssues, } from "./ManagedReaderFailure.js";
+import { parseTypes, typeRanges, } from "./ManagedMemberInspectorCore.js";
+import { edgeTargets } from "./ManagedMethodSpecs.js";
+import { typeNameLookup } from "./ManagedTypeNames.js";
+import { parseUserStrings } from "./ManagedUserStrings.js";
+import { readTypeMemberListFacts } from "./ManagedTypeMemberLists.js";
+import { edges, parseExportedTypes, parseFields, parseMemberRefs, parseMethods, } from "./ManagedMemberRows.js";
+const unavailable = (target, bytes, issue, typeNames) => managedMemberInspectionSchema.parse(admitManagedProjection({
     artifact: {
         path: target.path,
         sha256: target.sha256,
@@ -14,7 +19,11 @@ const unavailable = (target, bytes, issue) => managedMemberInspectionSchema.pars
     },
     module: null,
     metadata: {
-        status: issue === null ? "absent" : "malformed",
+        status: issue === null
+            ? "absent"
+            : issue.code === "resource-limit"
+                ? "partial"
+                : "malformed",
         version: null,
         table_row_counts: {},
     },
@@ -24,11 +33,17 @@ const unavailable = (target, bytes, issue) => managedMemberInspectionSchema.pars
         requires_mvid: null,
     },
     types: [],
+    exported_types: null,
+    user_strings: null,
     fields: [],
     methods: [],
     member_refs: [],
     call_edges: [],
     field_accesses: [],
+    // Nothing was examined, so no requested name is known to be unmatched.
+    selection: typeNames === undefined
+        ? null
+        : { type_names: [...typeNames], unmatched_type_names: [] },
     coverage: {
         state: "unavailable",
         issues: issue === null ? [] : [issue],
@@ -38,44 +53,97 @@ const unavailable = (target, bytes, issue) => managedMemberInspectionSchema.pars
             ? "The PE has no admitted CLI metadata; managed member inspection is unavailable."
             : "The CLI metadata could not be admitted; managed member inspection is unavailable.",
     ],
-});
+}));
 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, readManagedResourceDirectory(pe, issues));
-    return { layout, inventory };
+    const memberLists = readTypeMemberListFacts(bytes, layout);
+    const inventory = readManagedMetadataInventory(bytes, layout, readManagedResourceDirectory(pe, issues), memberLists);
+    return { layout, inventory, memberLists };
 };
-/** Inspect metadata members and method bodies without loading target code. */
-export const inspectManagedMembersBytes = (bytes, target) => {
+const selectTypes = (ranges, typeNames) => {
+    if (typeNames === undefined)
+        return { tokens: null, selection: null, unreadableNames: 0 };
+    const requested = new Set(typeNames);
+    const tokens = new Set();
+    const matched = new Set();
+    for (const range of ranges) {
+        if (range.fullName === null || !requested.has(range.fullName))
+            continue;
+        tokens.add(range.token);
+        matched.add(range.fullName);
+    }
+    return {
+        tokens,
+        unreadableNames: ranges.filter(({ fullName }) => fullName === null).length,
+        selection: {
+            type_names: [...typeNames],
+            unmatched_type_names: typeNames.filter((name) => !matched.has(name)),
+        },
+    };
+};
+/**
+ * Inspect metadata members and method bodies without loading target code.
+ * Selected type names restrict full decoding to members of those exact types.
+ * A caller that never reads literals, such as member comparison, can skip
+ * user strings; they are then reported as not examined.
+ */
+export const inspectManagedMembersBytes = (bytes, target, { typeNames, methodOffset = 0, methodLimit = Number.MAX_SAFE_INTEGER, userStrings: readUserStrings = true, } = {}) => {
+    if (!Number.isSafeInteger(methodOffset) ||
+        methodOffset < 0 ||
+        !Number.isSafeInteger(methodLimit) ||
+        methodLimit < 0)
+        throw new RangeError("methodOffset and methodLimit must be non-negative safe integers");
     const pe = readManagedPeLayout(bytes);
     if (pe.cli === null)
-        return unavailable(target, bytes, pe.cliIssue);
+        return unavailable(target, bytes, pe.cliIssue, typeNames);
     const issues = [];
     try {
-        const { layout, inventory } = readMemberInventory(bytes, pe, issues);
-        issues.push(...inventory.issues);
-        const ranges = typeRanges(bytes, layout, issues);
+        const { layout, inventory, memberLists } = readMemberInventory(bytes, pe, issues);
+        appendManagedParseIssues(issues, inventory.issues);
+        const ranges = typeRanges(bytes, layout, issues, memberLists);
+        const { tokens: selected, selection, unreadableNames, } = selectTypes(ranges, typeNames);
         const parsedTypes = parseTypes(bytes, layout, ranges);
-        issues.push(...parsedTypes.issues);
-        const fields = parseFields(bytes, layout, ranges);
-        const memberRefs = parseMemberRefs(bytes, layout);
-        issues.push(...memberRefs.issues);
+        appendManagedParseIssues(issues, parsedTypes.issues);
+        const exportedTypes = parseExportedTypes(bytes, layout);
+        appendManagedParseIssues(issues, exportedTypes.issues);
+        const fields = parseFields(bytes, layout, ranges, memberLists, selected);
+        const memberRefs = parseMemberRefs(bytes, layout, typeNameLookup(bytes, layout, ranges, issues));
+        appendManagedParseIssues(issues, memberRefs.issues);
         const methods = parseMethods({
             bytes,
             layout,
             pe,
             ranges,
+            memberLists,
+            selected,
+            methodOffset,
+            methodLimit,
         });
-        issues.push(...fields.issues, ...methods.issues);
+        appendManagedParseIssues(issues, fields.issues, methods.issues);
+        // #US literals sit beside the member inventory and carry their own
+        // coverage, so their issues never make member facts partial.
+        const userStrings = readUserStrings
+            ? parseUserStrings(bytes, layout, {
+                ...methods,
+                unreadableSelectedTypes: unreadableNames,
+            })
+            : null;
+        const targets = edgeTargets(bytes, layout, methods.methods, [
+            fields.core,
+            memberRefs.core,
+            methods.core,
+        ]);
+        appendManagedParseIssues(issues, targets.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({
+        const related = edges(methods.methods, targets.members, managedDecodeBudget(layout));
+        return managedMemberInspectionSchema.parse(admitManagedProjection({
             artifact: {
                 path: target.path,
                 sha256: target.sha256,
@@ -93,26 +161,45 @@ export const inspectManagedMembersBytes = (bytes, target) => {
                 requires_artifact_sha256: target.sha256,
                 requires_mvid: inventory.module?.mvid ?? null,
             },
-            types: parsedTypes.types,
+            types: selected === null
+                ? parsedTypes.types
+                : parsedTypes.types.filter((type) => selected.has(type.token)),
+            exported_types: exportedTypes.exportedTypes,
             fields: fields.fields,
             methods: methods.methods,
             member_refs: memberRefs.refs,
             call_edges: related.callEdges,
             field_accesses: related.fieldAccesses,
+            user_strings: userStrings,
+            selection,
             coverage: {
-                state: issues.length === 0 && !incompleteMembers ? "complete" : "partial",
+                state: issues.length === 0 && !incompleteMembers
+                    ? "complete"
+                    : "partial",
                 issues: coverageIssues,
             },
             limitations: [
                 "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.",
+                "Exported types are reported from ExportedType rows as declared; forwarded types are not resolved in their implementing assemblies.",
+                "User strings are the #US literals loaded by ldstr in the inspected method bodies, with their own coverage; instruction anchors and normalized CIL digests keep their build-local tokens.",
+                "Member signatures decode ECMA-335 primitive, class, valuetype, generic instantiation, generic variable, pointer, byref, single-dimension and general array, function pointer, custom modifier, and typed reference forms; class and valuetype operands keep their encoded TypeDefOrRefOrSpec values, and unsupported forms such as vararg sentinels retain raw signature hashes.",
+                ...(selection === null
+                    ? []
+                    : [
+                        "Types, fields, methods, call edges, field accesses, and user strings cover only the selected declaring types; coverage describes that selection. Edge targets outside it keep their names but are not described.",
+                    ]),
+                ...(unreadableNames === 0
+                    ? []
+                    : [
+                        `${String(unreadableNames)} TypeDef name(s) could not be read; a name in selection.unmatched_type_names may belong to one of them, so its absence is not observed.`,
+                    ]),
             ],
-        });
+        }, managedDecodeBudget(layout)));
     }
     catch (cause) {
         if (cause instanceof ManagedReaderFailure)
-            return unavailable(target, bytes, cause.issue);
+            return unavailable(target, bytes, cause.issue, typeNames);
         throw cause;
     }
 };