Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(managed): retain type discovery after member limits (#5312)

Can371f3d91aec6
diff --git a/docs/managed-code-analysis.md b/docs/managed-code-analysis.md
index becd9aba1..0a293bbc5 100644
--- a/docs/managed-code-analysis.md
+++ b/docs/managed-code-analysis.md
@@ -200,8 +200,19 @@ rather than interpreted according to section order.
### Selected member inspection
-When whole-assembly member decoding reaches the representation budget, select
-known declaring types before their signatures and CIL bodies are decoded:
+Member inspection admits type names, tokens, list ranges/counts, nesting facts,
+module identity and their output representation before decoding members. If
+later decoding or projection reaches the 64 MiB representation budget, the
+result retains this type inventory with `coverage.state: "partial"` and the
+original `resource-limit` coordinate. It does not return partially admitted
+member collections: empty fields, methods, references and edges are unexamined,
+not proof of absence; exported types, user strings and signature-resolution
+attestation remain null. Summary and retained pages keep this partial coverage.
+The capacity limit is unchanged. If metadata or the type inventory itself cannot
+be admitted, the result remains unavailable.
+
+Use the returned `types[].full_name` values to select declaring types before
+their signatures and CIL bodies are decoded:
```bash
rea inspect-managed-members /absolute/path/Assembly.dll --type Example.Parser
@@ -233,6 +244,14 @@ opposite observation's selection unknown, and application graphs report their
selected scope as partial. Neither makes an absence claim about the whole
assembly. Older member Evidence without `selection` remains readable.
+For MCP callers, request `detail: "summary"` and page the `types` collection
+using the returned parent Evidence ID. Select one or more returned full names
+in a subsequent `inspect_managed_members` request. Selection is a recovery path,
+not a guarantee: a single type or the assembly-wide member references can still
+exhaust the representation budget. A successful command exit means the Evidence
+was returned; inspect `coverage.state` and `coverage.issues` before treating any
+collection as complete.
+
### User strings
`ldstr` anchors keep their build-local `0x70` tokens. `user_strings.literals`
diff --git a/src/domain/managed/managedArtifact.ts b/src/domain/managed/managedArtifact.ts
index d6e00b3f5..7b129ab9e 100644
--- a/src/domain/managed/managedArtifact.ts
+++ b/src/domain/managed/managedArtifact.ts
@@ -474,7 +474,7 @@ export const managedMemberInspectionSchema = z.object({
.nullable()
.default(null)
.describe(
- "Signature type-name resolution was examined, including unresolved operands; null means historical Evidence without this attestation.",
+ "Signature type-name resolution was examined, including unresolved operands; null means no attestation, including historical or capacity-limited Evidence.",
),
artifact: managedArtifactReferenceSchema,
module: moduleIdentitySchema.nullable(),
diff --git a/src/domain/managed/managedMemberComparisonCoverage.ts b/src/domain/managed/managedMemberComparisonCoverage.ts
index ee6021f5c..e2ca6529f 100644
--- a/src/domain/managed/managedMemberComparisonCoverage.ts
+++ b/src/domain/managed/managedMemberComparisonCoverage.ts
@@ -150,7 +150,7 @@ export const comparisonLimitations = (
);
if (left.exported_types === null || right.exported_types === null)
limitations.push(
- "At least one managed member observation predates ExportedType inspection; its exported and forwarded types are unknown.",
+ "At least one managed member observation did not examine ExportedType rows; its exported and forwarded types are unknown.",
);
if (
(left.exported_types?.length ?? 0) > 0 ||
diff --git a/src/dotnet/ManagedDecodeBudget.ts b/src/dotnet/ManagedDecodeBudget.ts
index aca84f254..cc1911a48 100644
--- a/src/dotnet/ManagedDecodeBudget.ts
+++ b/src/dotnet/ManagedDecodeBudget.ts
@@ -3,11 +3,23 @@ import { createHash } from "node:crypto";
import { jsonStringByteLength } from "../domain/jsonStringByteLength.js";
import type { ManagedMetadataLayout } from "./ManagedMetadataLayout.js";
-import { managedFailure } from "./ManagedReaderFailure.js";
+import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
/** Per-inspection capacity for eagerly retained metadata and its JSON projection. */
const MAX_METADATA_REPRESENTATION_BYTES = 64 * 1024 * 1024;
+/** The capacity owner's diagnostic, also used to admit a recovery envelope. */
+export class ManagedRepresentationFailure extends ManagedReaderFailure {
+ constructor(offset: number | null) {
+ super({
+ code: "resource-limit",
+ scope: "metadata.representation",
+ detail: `Managed metadata exceeds the ${String(MAX_METADATA_REPRESENTATION_BYTES)} byte representation budget`,
+ offset,
+ });
+ }
+}
+
interface CachedString {
readonly value: string;
readonly encodedBytes: number;
@@ -56,12 +68,7 @@ export class ManagedDecodeBudget {
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,
- );
+ throw new ManagedRepresentationFailure(offset);
}
/** UTF-8 cannot decode to more UTF-16 units than bytes; JSON uses at most six bytes per unit. */
diff --git a/src/dotnet/ManagedMemberInspector.test.ts b/src/dotnet/ManagedMemberInspector.test.ts
index 8b65fc592..bf50c56ed 100644
--- a/src/dotnet/ManagedMemberInspector.test.ts
+++ b/src/dotnet/ManagedMemberInspector.test.ts
@@ -760,7 +760,7 @@ describe("managed exported types", () => {
expect(parsed.exported_types).toBeNull();
expect(comparisonLimitations(parsed, parsed)).toContain(
- "At least one managed member observation predates ExportedType inspection; its exported and forwarded types are unknown.",
+ "At least one managed member observation did not examine ExportedType rows; its exported and forwarded types are unknown.",
);
});
@@ -1264,7 +1264,7 @@ describe("managed member decoding budget", () => {
});
});
- it("still rejects dense one-byte instructions before exceeding capacity", () => {
+ it("rejects dense one-byte instructions while retaining admitted types", () => {
// All NOPs: unlike wide instructions, each IL byte adds a decoded record.
// A true oversized transient must remain an actionable resource limit.
const il = Buffer.alloc(270_001);
@@ -1282,12 +1282,12 @@ describe("managed member decoding budget", () => {
);
expect(result.coverage).toMatchObject({
- state: "unavailable",
+ state: "partial",
issues: [{ code: "resource-limit", scope: "metadata.representation" }],
});
// Report the originating IL coordinate, not a generic decoding error.
expect(result.coverage.issues[0]?.offset).toBeGreaterThan(0);
- expect(result.types).toEqual([]);
+ expect(result.types).toHaveLength(1);
expect(result.methods).toEqual([]);
});
@@ -1338,9 +1338,11 @@ describe("managed member decoding budget", () => {
);
expect(result.coverage).toMatchObject({
- state: "unavailable",
+ state: "partial",
issues: [{ code: "resource-limit" }],
});
+ expect(result.methods).toEqual([]);
+ expect(result.types).toHaveLength(1);
});
});
diff --git a/src/dotnet/ManagedMemberInspector.ts b/src/dotnet/ManagedMemberInspector.ts
index 48c36ff9f..4f543edcd 100644
--- a/src/dotnet/ManagedMemberInspector.ts
+++ b/src/dotnet/ManagedMemberInspector.ts
@@ -1,6 +1,7 @@
import {
admitManagedProjection,
managedDecodeBudget,
+ ManagedRepresentationFailure,
} from "./ManagedDecodeBudget.js";
import type { BinaryTarget } from "../domain/binaryTargetTypes.js";
import {
@@ -15,6 +16,7 @@ import {
import {
readManagedResourceDirectory,
readManagedMetadataInventory,
+ readManagedModuleIdentity,
} from "./ManagedMetadataInventory.js";
import { managedPeInspectionEnvelope } from "./ManagedPeInspectionEnvelope.js";
import { readManagedMetadataLayout } from "./ManagedMetadataLayout.js";
@@ -34,6 +36,7 @@ import { typeNameLookup } from "./ManagedTypeNames.js";
import { managedTypeReferences } from "./ManagedTypeReferences.js";
import { parseUserStrings } from "./ManagedUserStrings.js";
import { readTypeMemberListFacts } from "./ManagedTypeMemberLists.js";
+import { prepareManagedMemberRecovery } from "./ManagedMemberRecovery.js";
import {
edges,
parseExportedTypes,
@@ -100,11 +103,7 @@ const unavailable = (
}),
);
-const readMemberInventory = (
- bytes: Buffer,
- pe: ManagedPeLayout,
- issues: ManagedParseIssue[],
-) => {
+const readMemberLayout = (bytes: Buffer, pe: ManagedPeLayout) => {
const cli = pe.cli;
if (cli === null)
throw new TypeError("Managed inventory requires CLI metadata");
@@ -119,13 +118,7 @@ const readMemberInventory = (
cli.metadata.size,
);
const memberLists = readTypeMemberListFacts(bytes, layout);
- const inventory = readManagedMetadataInventory(
- bytes,
- layout,
- readManagedResourceDirectory(pe, issues),
- memberLists,
- );
- return { layout, inventory, memberLists };
+ return { layout, memberLists };
};
const selectTypes = (
@@ -191,13 +184,11 @@ export const inspectManagedMembersBytes = (
if (pe.cli === null)
return unavailable(target, bytes, pe.cliIssue, typeNames);
const issues: ManagedParseIssue[] = [];
+ let recover: ReturnType<typeof prepareManagedMemberRecovery> | undefined;
try {
- const { layout, inventory, memberLists } = readMemberInventory(
- bytes,
- pe,
- issues,
- );
- appendManagedParseIssues(issues, inventory.issues);
+ const { layout, memberLists } = readMemberLayout(bytes, pe);
+ const identity = readManagedModuleIdentity(bytes, layout);
+ appendManagedParseIssues(issues, identity.issues);
const ranges = typeRanges(bytes, layout, issues, memberLists);
const {
tokens: selected,
@@ -206,8 +197,6 @@ export const inspectManagedMembersBytes = (
} = selectTypes(ranges, typeNames);
const parsedTypes = parseTypes(bytes, layout, ranges);
appendManagedParseIssues(issues, parsedTypes.issues);
- const exportedTypes = parseExportedTypes(bytes, layout);
- appendManagedParseIssues(issues, exportedTypes.issues);
const typeReferences = managedTypeReferences(bytes, layout, issues);
const signatureTypeName = managedTypeNameDigests(
layout,
@@ -215,6 +204,68 @@ export const inspectManagedMembersBytes = (
parsedTypes,
typeReferences,
);
+ const types = parsedTypes.types
+ .filter((type) => selected === null || selected.has(type.token))
+ .map((type) => {
+ managedDecodeBudget(layout).reserve(512, type.row_offset);
+ return {
+ ...type,
+ name_sha256:
+ signatureTypeName(
+ Number.parseInt(type.token.slice(4), 16) * 4,
+ )?.toString("hex") ?? null,
+ };
+ });
+ const envelope = managedPeInspectionEnvelope(
+ target,
+ bytes.length,
+ layout,
+ identity.module,
+ issues,
+ );
+ const unnamedTypes = types.reduce(
+ (count, type) => count + Number(type.name_sha256 === null),
+ 0,
+ );
+ const typeIdentityLimitations =
+ unnamedTypes === 0
+ ? []
+ : [
+ `${String(unnamedTypes)} returned TypeDef name identity(s) remain unresolved; incomplete, missing, contradictory, cyclic or over-deep enclosing facts cannot be repaired by bare display names.`,
+ ];
+ const selectionLimitations = [
+ ...(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.`,
+ ]),
+ ];
+ recover = prepareManagedMemberRecovery(
+ {
+ ...envelope,
+ types,
+ nesting_read: parsedTypes.nesting.complete,
+ selection,
+ limitations: [...typeIdentityLimitations, ...selectionLimitations],
+ },
+ uniqueManagedParseIssues(issues),
+ managedDecodeBudget(layout),
+ );
+ const inventory = readManagedMetadataInventory(
+ bytes,
+ layout,
+ readManagedResourceDirectory(pe, issues),
+ memberLists,
+ identity,
+ );
+ appendManagedParseIssues(issues, inventory.issues);
+ const exportedTypes = parseExportedTypes(bytes, layout);
+ appendManagedParseIssues(issues, exportedTypes.issues);
const fields = parseFields(bytes, layout, ranges, memberLists, {
signatureTypeName,
selected,
@@ -266,33 +317,15 @@ export const inspectManagedMembersBytes = (
targets.members,
managedDecodeBudget(layout),
);
- const types = parsedTypes.types
- .filter((type) => selected === null || selected.has(type.token))
- .map((type) => {
- managedDecodeBudget(layout).reserve(512, type.row_offset);
- return {
- ...type,
- name_sha256:
- signatureTypeName(
- Number.parseInt(type.token.slice(4), 16) * 4,
- )?.toString("hex") ?? null,
- };
- });
- const unnamedTypes = types.reduce(
- (count, type) => count + Number(type.name_sha256 === null),
- 0,
- );
const coverageIssues = uniqueManagedParseIssues(issues);
return managedMemberInspectionSchema.parse(
admitManagedProjection(
{
- ...managedPeInspectionEnvelope(
- target,
- bytes.length,
- layout,
- inventory.module,
- issues,
- ),
+ ...envelope,
+ metadata: {
+ ...envelope.metadata,
+ status: issues.length === 0 ? "complete" : "partial",
+ },
types,
signature_resolution: "type-names-v1",
nesting_read: parsedTypes.nesting.complete,
@@ -312,34 +345,27 @@ export const inspectManagedMembersBytes = (
issues: coverageIssues,
},
limitations: [
- ...(unnamedTypes === 0
- ? []
- : [
- `${String(unnamedTypes)} returned TypeDef name identity(s) remain unresolved; incomplete, missing, contradictory, cyclic or over-deep enclosing facts cannot be repaired by bare display names.`,
- ]),
+ ...typeIdentityLimitations,
"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.",
"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.`,
- ]),
+ ...selectionLimitations,
],
},
managedDecodeBudget(layout),
),
);
} catch (cause: unknown) {
- if (cause instanceof ManagedReaderFailure)
+ if (cause instanceof ManagedReaderFailure) {
+ if (
+ recover !== undefined &&
+ cause instanceof ManagedRepresentationFailure
+ )
+ return recover(cause.issue.offset);
return unavailable(target, bytes, cause.issue, typeNames);
+ }
throw cause;
}
};
diff --git a/src/dotnet/ManagedMemberRecovery.ts b/src/dotnet/ManagedMemberRecovery.ts
new file mode 100644
index 000000000..be20b4452
--- /dev/null
+++ b/src/dotnet/ManagedMemberRecovery.ts
@@ -0,0 +1,70 @@
+import {
+ admitManagedProjection,
+ ManagedRepresentationFailure,
+ type ManagedDecodeBudget,
+} from "./ManagedDecodeBudget.js";
+import {
+ managedMemberInspectionSchema,
+ type ManagedMemberInspection,
+ type ManagedParseIssue,
+} from "../domain/managed/managedArtifact.js";
+
+type TypeInventory = Pick<
+ ManagedMemberInspection,
+ | "artifact"
+ | "module"
+ | "metadata"
+ | "identity_scope"
+ | "types"
+ | "nesting_read"
+ | "selection"
+ | "limitations"
+>;
+
+/**
+ * Admit recovery before spending capacity on members. The only later value is
+ * the capacity owner's byte coordinate: its longest safe-integer encoding is
+ * charged now, so recovery never needs a new budget or an unchecked allocation.
+ */
+export const prepareManagedMemberRecovery = (
+ inventory: TypeInventory,
+ issues: readonly ManagedParseIssue[],
+ budget: ManagedDecodeBudget,
+): ((offset: number | null) => ManagedMemberInspection) => {
+ const capacityIssue = new ManagedRepresentationFailure(
+ Number.MAX_SAFE_INTEGER,
+ ).issue;
+ const report: ManagedMemberInspection = {
+ ...inventory,
+ metadata: { ...inventory.metadata, status: "partial" },
+ signature_resolution: null,
+ exported_types: null,
+ fields: [],
+ methods: [],
+ member_refs: [],
+ call_edges: [],
+ field_accesses: [],
+ user_strings: null,
+ coverage: { state: "partial", issues: [...issues, capacityIssue] },
+ limitations: [
+ ...inventory.limitations,
+ "Member decoding exceeded capacity after the type inventory was admitted; fields, methods, member references, call edges, field accesses, exported types and user strings are not examined to completion. Empty member collections do not establish absence.",
+ "Use the returned TypeDef full_name values with type_names (CLI --type) to inspect a smaller selection; a single selected type can still exceed capacity.",
+ "Metadata tokens are build-local coordinates and require the reported artifact SHA-256 and MVID. Type names and list ranges retain their original metadata and nesting uncertainty.",
+ ],
+ };
+ admitManagedProjection(report, budget);
+ // A successful full report serializes these same immutable facts once.
+ // Transfer their existing charge, rather than charging the type list twice.
+ for (const value of Object.values(inventory)) {
+ if (value !== null && typeof value === "object") budget.prepay(value);
+ }
+ return (offset) =>
+ managedMemberInspectionSchema.parse({
+ ...report,
+ coverage: {
+ state: "partial",
+ issues: [...issues, { ...capacityIssue, offset }],
+ },
+ });
+};
diff --git a/src/dotnet/ManagedMemberTypeInventory.test.ts b/src/dotnet/ManagedMemberTypeInventory.test.ts
new file mode 100644
index 000000000..f4eae0229
--- /dev/null
+++ b/src/dotnet/ManagedMemberTypeInventory.test.ts
@@ -0,0 +1,208 @@
+import { expect, it } from "vitest";
+
+import { inspectManagedMembersBytes } from "./ManagedMemberInspector.js";
+import {
+ buildManagedPeFixture,
+ managedPeFixtureTarget,
+} from "./ManagedPe.fixture.js";
+import { buildManagedMemberCapacityFixture } from "../../tests/fixtures/managedMemberCapacity.js";
+import { readManagedPeLayout } from "./ManagedPeReader.js";
+import {
+ metadataRowOffset,
+ readManagedMetadataLayout,
+} from "./ManagedMetadataLayout.js";
+
+it("retains admitted type names, member counts and artifact identity", () => {
+ const bytes = buildManagedMemberCapacityFixture();
+ const result = inspectManagedMembersBytes(
+ bytes,
+ managedPeFixtureTarget(bytes),
+ );
+ expect(result.coverage.state).toBe("partial");
+ expect(result.coverage.issues).toContainEqual(
+ expect.objectContaining({
+ code: "resource-limit",
+ scope: "metadata.representation",
+ offset: expect.any(Number),
+ }),
+ );
+ expect(result.types).toHaveLength(3);
+ expect(
+ result.types.find((type) => type.full_name === "Fixture.Program"),
+ ).toMatchObject({
+ method_list: { count: 1 },
+ field_list: { count: 1 },
+ name_sha256: expect.any(String),
+ });
+ expect(result.module).toMatchObject({ mvid: expect.any(String) });
+ expect(result.identity_scope.requires_mvid).toBe(result.module?.mvid);
+ expect(result.metadata.table_row_counts).toMatchObject({
+ TypeDef: 3,
+ MethodDef: 1,
+ });
+ expect(result.metadata.version).not.toBeNull();
+ expect(result.methods).toEqual([]);
+ expect(result.fields).toEqual([]);
+ expect(result.member_refs).toEqual([]);
+ expect(result.call_edges).toEqual([]);
+ expect(result.field_accesses).toEqual([]);
+ expect(result.user_strings).toBeNull();
+ expect(result.exported_types).toBeNull();
+ expect(result.signature_resolution).toBeNull();
+ expect(result.limitations.join(" ")).toContain("not examined to completion");
+});
+
+it("lets a caller select an inventoried empty type without decoding the oversized body", () => {
+ const bytes = buildManagedMemberCapacityFixture();
+ const target = managedPeFixtureTarget(bytes);
+ const inventory = inspectManagedMembersBytes(bytes, target);
+ const empty = inventory.types.find((type) => type.method_list.count === 0);
+ expect(empty).toBeDefined();
+ const result = inspectManagedMembersBytes(bytes, target, {
+ typeNames: [empty!.full_name],
+ });
+ expect(result.coverage).toEqual({ state: "complete", issues: [] });
+ expect(result.types).toHaveLength(1);
+ expect(result.types[0]?.token).toBe(empty?.token);
+ expect(result.methods).toEqual([]);
+});
+
+it("preserves explicit type selection when its selected body exhausts capacity", () => {
+ const bytes = buildManagedMemberCapacityFixture();
+ const result = inspectManagedMembersBytes(
+ bytes,
+ managedPeFixtureTarget(bytes),
+ {
+ typeNames: ["Fixture.Program", "Missing.Type"],
+ },
+ );
+ expect(result.coverage.state).toBe("partial");
+ expect(result.types.map((type) => type.full_name)).toEqual([
+ "Fixture.Program",
+ ]);
+ expect(result.selection).toEqual({
+ type_names: ["Fixture.Program", "Missing.Type"],
+ unmatched_type_names: ["Missing.Type"],
+ });
+});
+
+it("retains types when a field signature exceeds the decoding bound", () => {
+ const bytes = buildManagedPeFixture({
+ fieldSignature: Buffer.alloc(270_001, 0x06),
+ });
+ const result = inspectManagedMembersBytes(
+ bytes,
+ managedPeFixtureTarget(bytes),
+ );
+ expect(result.coverage.state).toBe("partial");
+ expect(result.types[0]?.full_name).toBe("Fixture.Program");
+ expect(result.coverage.issues).toContainEqual(
+ expect.objectContaining({ code: "resource-limit" }),
+ );
+ expect(result.fields).toEqual([]);
+});
+
+it("keeps metadata admission failures unavailable rather than inventing an inventory", () => {
+ const bytes = buildManagedPeFixture({ corruptMetadataSignature: true });
+ const result = inspectManagedMembersBytes(
+ bytes,
+ managedPeFixtureTarget(bytes),
+ );
+ expect(result.coverage.state).toBe("unavailable");
+ expect(result.types).toEqual([]);
+ expect(result.metadata.status).toBe("malformed");
+});
+
+it("retains a large type inventory without relaxing the member budget", () => {
+ const bytes = buildManagedMemberCapacityFixture({
+ additionalEmptyTypes: 2_041,
+ });
+ const result = inspectManagedMembersBytes(
+ bytes,
+ managedPeFixtureTarget(bytes),
+ );
+ expect(result.coverage.state).toBe("partial");
+ expect(result.types).toHaveLength(2_042);
+ expect(result.types.at(-1)?.full_name).toBe("Fixture.Program");
+ expect(result.types.every((type) => type.name_sha256 !== null)).toBe(true);
+ expect(result.methods).toEqual([]);
+});
+
+it("does not recover an inventory whose names already exceed capacity", () => {
+ const bytes = buildManagedPeFixture({
+ typeName: "T".repeat(12 * 1024 * 1024),
+ });
+ const result = inspectManagedMembersBytes(
+ bytes,
+ managedPeFixtureTarget(bytes),
+ );
+ expect(result.coverage.state).toBe("unavailable");
+ expect(result.coverage.issues).toContainEqual(
+ expect.objectContaining({ code: "resource-limit" }),
+ );
+ expect(result.types).toEqual([]);
+});
+
+it("keeps malformed type facts alongside the later capacity diagnostic", () => {
+ const bytes = buildManagedMemberCapacityFixture({ extendsRaw: 0xffff });
+ const result = inspectManagedMembersBytes(
+ bytes,
+ managedPeFixtureTarget(bytes),
+ );
+ expect(result.coverage.state).toBe("partial");
+ expect(result.types).toHaveLength(3);
+ expect(result.types.every((type) => type.extends_token === null)).toBe(true);
+ expect(result.coverage.issues).toContainEqual(
+ expect.objectContaining({ code: "invalid-row" }),
+ );
+ expect(result.coverage.issues.at(-1)).toMatchObject({
+ code: "resource-limit",
+ });
+});
+
+it("does not repair cyclic nesting into a definite nominal identity", () => {
+ const bytes = buildManagedMemberCapacityFixture({
+ additionalEmptyTypes: 1,
+ nestedTypes: [
+ [1, 2],
+ [2, 1],
+ ],
+ });
+ const result = inspectManagedMembersBytes(
+ bytes,
+ managedPeFixtureTarget(bytes),
+ );
+ expect(result.coverage.state).toBe("partial");
+ expect(result.types).toHaveLength(2);
+ expect(result.types.every((type) => type.name_sha256 === null)).toBe(true);
+ expect(result.types.map((type) => type.enclosing_type_token)).toEqual([
+ "0x02000002",
+ "0x02000001",
+ ]);
+});
+
+it("does not turn an unreadable requested type name into observed absence during recovery", () => {
+ const bytes = buildManagedMemberCapacityFixture();
+ const pe = readManagedPeLayout(bytes);
+ if (pe.cli === null) throw new Error("Expected CLI fixture");
+ const layout = readManagedMetadataLayout(
+ bytes,
+ pe.rvaToOffset(pe.cli.metadata.rva, pe.cli.metadata.size, "cli.metadata"),
+ pe.cli.metadata.size,
+ );
+ expect(layout.stringIndexSize).toBe(2);
+ bytes.writeUInt16LE(0xffff, metadataRowOffset(layout, 2, 1) + 4);
+ const result = inspectManagedMembersBytes(
+ bytes,
+ managedPeFixtureTarget(bytes),
+ {
+ typeNames: ["Fixture.Program", "Fixture.Empty0"],
+ },
+ );
+ expect(result.coverage.state).toBe("partial");
+ expect(result.selection?.unmatched_type_names).toEqual(["Fixture.Empty0"]);
+ expect(result.types.map((type) => type.full_name)).toEqual([
+ "Fixture.Program",
+ ]);
+ expect(result.limitations.join(" ")).toContain("absence is not observed");
+});
diff --git a/src/dotnet/ManagedMetadataInventory.ts b/src/dotnet/ManagedMetadataInventory.ts
index f2d5a9045..640b9c0d1 100644
--- a/src/dotnet/ManagedMetadataInventory.ts
+++ b/src/dotnet/ManagedMetadataInventory.ts
@@ -101,6 +101,21 @@ const validateIdentityTableCounts = (
});
};
+/** Module identity is independent of assembly references, attributes and resources. */
+export const readManagedModuleIdentity = (
+ bytes: Buffer,
+ layout: ManagedMetadataLayout,
+): Pick<ManagedMetadataInventory, "module" | "issues"> => {
+ const issues: ManagedParseIssue[] = [];
+ validateIdentityTableCounts(layout, issues);
+ const module =
+ readManagedValue(
+ () => readModule(bytes, layout, heapExtent(layout)),
+ issues,
+ ) ?? null;
+ return { module, issues };
+};
+
const readReferences = (
bytes: Buffer,
layout: ManagedMetadataLayout,
@@ -188,14 +203,14 @@ export const readManagedMetadataInventory = (
layout: ManagedMetadataLayout,
resourceDirectory: ManagedResourceDirectory | null,
memberLists: TypeMemberListFacts,
+ identity: Pick<
+ ManagedMetadataInventory,
+ "module" | "issues"
+ > = readManagedModuleIdentity(bytes, layout),
): ManagedMetadataInventory => {
const issues: ManagedParseIssue[] = [...memberLists.issues];
- validateIdentityTableCounts(layout, issues);
- const module =
- readManagedValue(
- () => readModule(bytes, layout, heapExtent(layout)),
- issues,
- ) ?? null;
+ issues.push(...identity.issues);
+ const { module } = identity;
const assembly =
readManagedValue(
() => readAssembly(bytes, layout, heapExtent(layout)),
diff --git a/tests/acceptance/managedMemberRecovery.test.ts b/tests/acceptance/managedMemberRecovery.test.ts
new file mode 100644
index 000000000..7ad694457
--- /dev/null
+++ b/tests/acceptance/managedMemberRecovery.test.ts
@@ -0,0 +1,179 @@
+import { createHash } from "node:crypto";
+import { unlink, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { Client } from "@modelcontextprotocol/client";
+import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { expect } from "vitest";
+
+import { parseEvidence } from "../../src/domain/evidence.js";
+import { managedMemberInspectionSchema } from "../../src/domain/managed/managedArtifact.js";
+import {
+ analysisViewResultSchema,
+ managedMemberSummaryViewResultSchema,
+} from "../../src/domain/analysisView/analysisView.js";
+import { buildManagedMemberCapacityFixture } from "../fixtures/managedMemberCapacity.js";
+import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";
+import { cliTest } from "../support/cli/cliFixture.js";
+
+const createTransport = () =>
+ new StdioClientTransport({
+ command: process.execPath,
+ args: [resolve("scripts/rea.mjs"), "mcp"],
+ cwd: process.cwd(),
+ env: {
+ PATH: process.env.PATH ?? "",
+ REA_LOG_LEVEL: "silent",
+ ...(process.platform === "win32"
+ ? {
+ SystemRoot: process.env.SystemRoot ?? "",
+ TEMP: tmpdir(),
+ TMP: tmpdir(),
+ }
+ : {}),
+ },
+ stderr: "pipe",
+ });
+
+cliTest(
+ "CLI and stdio MCP recover type discovery and preserve partial retained pages",
+ async ({ cli }) => {
+ const root = await createTestTempDirectory("rea-managed-member-recovery-");
+ const path = join(root, "large-method.dll");
+ const bytes = buildManagedMemberCapacityFixture();
+ await writeFile(path, bytes);
+ const sha256 = createHash("sha256").update(bytes).digest("hex");
+ const transport = createTransport();
+ transport.stderr?.on("data", () => undefined);
+ const client = new Client({ name: "managed-type-recovery", version: "1" });
+ try {
+ await client.connect(transport);
+ const definition = (await client.listTools()).tools.find(
+ (tool) => tool.name === "inspect_managed_members",
+ );
+ const ajv = new Ajv2020({ strict: false, validateFormats: false });
+ if (definition?.outputSchema === undefined)
+ throw new Error("Managed member schema is absent");
+ const outputSchema: Record<string, unknown> = definition.outputSchema;
+ expect(ajv.validateSchema(definition.inputSchema)).toBe(true);
+ expect(ajv.validateSchema(outputSchema)).toBe(true);
+ const output = await cli.run({
+ arguments: ["inspect-managed-members", path, "--json"],
+ });
+ expect(output.exitCode, output.stderr).toBe(0);
+ const cliEvidence = parseEvidence(output.json);
+ const response = await client.callTool({
+ name: "inspect_managed_members",
+ arguments: { path },
+ });
+ expect(response.isError, JSON.stringify(response)).not.toBe(true);
+ expect(
+ ajv.validate(outputSchema, response.structuredContent),
+ JSON.stringify(ajv.errors),
+ ).toBe(true);
+ const mcpEvidence = parseEvidence(response.structuredContent);
+ expect(mcpEvidence.normalized_result).toEqual(
+ cliEvidence.normalized_result,
+ );
+ expect(mcpEvidence.subject?.digest.sha256).toBe(sha256);
+ expect(cliEvidence.subject?.digest.sha256).toBe(sha256);
+ const report = managedMemberInspectionSchema.parse(
+ mcpEvidence.normalized_result,
+ );
+ expect(report.coverage.state).toBe("partial");
+ expect(report.types).toHaveLength(3);
+ expect(report.methods).toEqual([]);
+ const empty = report.types.find((type) => type.method_list.count === 0);
+ expect(empty).toBeDefined();
+ const selectedCli = await cli.run({
+ arguments: [
+ "inspect-managed-members",
+ path,
+ "--type",
+ empty!.full_name,
+ "--json",
+ ],
+ });
+ expect(selectedCli.exitCode, selectedCli.stderr).toBe(0);
+ const selected = await client.callTool({
+ name: "inspect_managed_members",
+ arguments: { path, type_names: [empty!.full_name] },
+ });
+ expect(selected.isError).not.toBe(true);
+ const selectedEvidence = parseEvidence(selected.structuredContent);
+ expect(selectedEvidence.normalized_result).toEqual(
+ parseEvidence(selectedCli.json).normalized_result,
+ );
+ expect(selectedEvidence.normalized_result).toMatchObject({
+ coverage: { state: "complete", issues: [] },
+ });
+
+ const summaryReply = await client.callTool({
+ name: "inspect_managed_members",
+ arguments: { path, detail: "summary" },
+ });
+ expect(summaryReply.isError).not.toBe(true);
+ const summary = managedMemberSummaryViewResultSchema.parse(
+ parseEvidence(summaryReply.structuredContent).normalized_result,
+ );
+ expect(summary.summary).toMatchObject({
+ coverage: { state: "partial" },
+ reported_counts: {
+ types: 3,
+ methods: 0,
+ exported_types: null,
+ user_strings: null,
+ },
+ });
+ await unlink(path);
+ for (const collection of ["types", "methods"] as const) {
+ const reply = await client.callTool({
+ name: "inspect_analysis_view",
+ arguments: {
+ source: {
+ kind: "retained-evidence",
+ evidence_id: summary.parent_evidence_id,
+ },
+ view: { kind: "managed-members", collection, offset: 0, limit: 10 },
+ },
+ });
+ expect(reply.isError, JSON.stringify(reply)).not.toBe(true);
+ const page = analysisViewResultSchema.parse(
+ parseEvidence(reply.structuredContent).normalized_result,
+ );
+ if (page.kind !== "managed-members")
+ throw new Error("Expected managed member page");
+ expect(page.source_coverage.state).toBe("partial");
+ expect(page.page.rows).toEqual(
+ collection === "types" ? report.types : [],
+ );
+ }
+ const unknown = await client.callTool({
+ name: "inspect_analysis_view",
+ arguments: {
+ source: {
+ kind: "retained-evidence",
+ evidence_id: summary.parent_evidence_id,
+ },
+ view: {
+ kind: "managed-members",
+ collection: "exported_types",
+ offset: 0,
+ limit: 10,
+ },
+ },
+ });
+ expect(unknown.isError).toBe(true);
+ expect(JSON.stringify(unknown)).toContain(
+ "did not examine exported_types",
+ );
+ } finally {
+ try {
+ await client.close();
+ } finally {
+ await transport.close();
+ }
+ }
+ },
+);
diff --git a/tests/boundary/providers/managed/managedMemberComparison.test.ts b/tests/boundary/providers/managed/managedMemberComparison.test.ts
index cafda31f5..523f8e2a4 100644
--- a/tests/boundary/providers/managed/managedMemberComparison.test.ts
+++ b/tests/boundary/providers/managed/managedMemberComparison.test.ts
@@ -29,6 +29,38 @@ import {
readManagedSnapshot,
} from "../../../../src/dotnet/ManagedSnapshot.js";
import * as boundedFileBytes from "../../../../src/process/BoundedFileBytes.js";
+import { buildManagedMemberCapacityFixture } from "../../../fixtures/managedMemberCapacity.js";
+
+it("keeps missing members unknown when the opposite inspection retains only types", async () => {
+ const directory = await createTestTempDirectory(
+ "rea-managed-type-recovery-comparison-",
+ );
+ const completePath = join(directory, "complete.dll");
+ const limitedPath = join(directory, "limited.dll");
+ await writeFile(
+ completePath,
+ buildManagedPeFixture({ additionalEmptyTypes: 2 }),
+ );
+ await writeFile(limitedPath, buildManagedMemberCapacityFixture());
+ for (const [leftPath, rightPath] of [
+ [completePath, limitedPath],
+ [limitedPath, completePath],
+ ]) {
+ const result = await compareManagedMemberPaths({
+ leftPath: leftPath!,
+ rightPath: rightPath!,
+ });
+ if (!result.ok) throw result.error;
+ const report = managedMemberComparisonResultSchema.parse(
+ result.value.normalized_result,
+ );
+ expect(report.coverage.status).toBe("partial");
+ expect(report.methods).toHaveLength(1);
+ expect(report.fields).toHaveLength(1);
+ expect(report.methods[0]?.status).toBe("unknown");
+ expect(report.fields[0]?.status).toBe("unknown");
+ }
+});
it.each([
["accessibility", 6, 0x0011],
diff --git a/tests/fixtures/managedMemberCapacity.ts b/tests/fixtures/managedMemberCapacity.ts
new file mode 100644
index 000000000..8512d02c8
--- /dev/null
+++ b/tests/fixtures/managedMemberCapacity.ts
@@ -0,0 +1,18 @@
+import { buildManagedPeFixture } from "../../src/dotnet/ManagedPe.fixture.js";
+
+/** Valid dense CIL exceeds the unchanged decoding bound, after TypeDef admission. */
+export const buildManagedMemberCapacityFixture = (
+ options: Parameters<typeof buildManagedPeFixture>[0] = {},
+): Buffer => {
+ const il = Buffer.alloc(270_001);
+ il[il.length - 1] = 0x2a;
+ const header = Buffer.alloc(12);
+ header.writeUInt16LE(0x3003);
+ header.writeUInt16LE(8, 2);
+ header.writeUInt32LE(il.length, 4);
+ return buildManagedPeFixture({
+ additionalEmptyTypes: 2,
+ ...options,
+ ilBody: Buffer.concat([header, il]),
+ });
+};