Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(managed)!: share member list facts and retain verification uncertainty
morluto3f6b5755b3e6
diff --git a/docs/managed-code-analysis.md b/docs/managed-code-analysis.mdindex f2d211d4e..27b7c7e54 100644--- a/docs/managed-code-analysis.md+++ b/docs/managed-code-analysis.md@@ -323,6 +323,9 @@ function implements a specific managed method.`verify_managed_native_boundaries` compares declared P/Invoke module and entrypoint identities with supplied native export or function evidence. Name/modulematches establish declaration links; they do not establish that a call executed.+When either side lacks a usable module identity, a matching name remains+unresolved and retains the candidate evidence; REA reports a module mismatch+only when both identities are available and differ.Metadata tokens are not native addresses. Native body mapping for C++/CLI,ReadyToRun, NativeAOT, and IL2CPP requires separately verified format and provider@@ -360,8 +363,9 @@ these indirections for member ownership and local attribute-constructor types;field and method tokens still identify the original definition rows.`field_list` and `method_list` retain the metadata's list coordinates, whichrefer to the pointer table when present rather than necessarily contiguous-definition rows. Malformed or ambiguous pointers leave the owner unknown with-partial coverage while preserving readable member and attribute facts.+definition rows. Invalid or nonmonotonic list coordinates and malformed or+ambiguous pointers leave affected owners unknown with partial coverage while+preserving readable member and attribute facts.The retained inverse indexes are admitted against the existing representationbudget before allocation.diff --git a/src/contracts/managed/managedWorkflowToolContracts.ts b/src/contracts/managed/managedWorkflowToolContracts.tsindex 18d78a310..a668e4a00 100644--- a/src/contracts/managed/managedWorkflowToolContracts.ts+++ b/src/contracts/managed/managedWorkflowToolContracts.ts@@ -116,7 +116,7 @@ export const MANAGED_WORKFLOW_TOOL_CONTRACTS = [name: "verify_managed_native_boundaries",...toolContractMetadata("verify_managed_native_boundaries"),description:- "Verify managed P/Invoke/native-boundary declarations against authenticated native export or function Evidence without executing managed code or translating managed metadata tokens into native addresses. The workflow preserves declaration-only, verified, inferred, contradicted, and unresolved states.",+ "Verify managed P/Invoke/native-boundary declarations against authenticated native export or function Evidence without executing managed code or translating managed metadata tokens into native addresses. The workflow preserves declaration-only, verified, inferred, contradicted, and unresolved states; a name candidate with missing managed or native module identity remains unresolved with its candidate evidence retained.",kind: "application",inputSchema: managedNativeVerificationInputSchema,outputSchema: nativeVerificationOutputSchema,diff --git a/src/domain/managed/managedMemberComparisonMatch.ts b/src/domain/managed/managedMemberComparisonMatch.tsindex 2cbe32a4a..e18da9ef5 100644--- a/src/domain/managed/managedMemberComparisonMatch.ts+++ b/src/domain/managed/managedMemberComparisonMatch.ts@@ -87,9 +87,10 @@ const keyMethod = (item: Method): Keyed<Method> => ({item.body.max_stack,item.body.init_locals,item.body.opcode_counts,- item.body.anchors.map(({ opcode, operand_kind }) => [+ item.body.anchors.map(({ opcode, operand_kind, operand }) => [opcode,operand_kind,+ operand_kind === "constant" ? operand : null,]),item.body.exception_regions.map((region) => [region.flags,diff --git a/src/domain/managed/managedNativeVerificationMatch.ts b/src/domain/managed/managedNativeVerificationMatch.tsindex bbe886a70..49cb0cdf3 100644--- a/src/domain/managed/managedNativeVerificationMatch.ts+++ b/src/domain/managed/managedNativeVerificationMatch.ts@@ -124,13 +124,21 @@ const moduleCompatible = (scope: string | null,symbol: NativeSymbol,): boolean => {- if (scope === null) return true;+ if (scope === null || scope.trim().length === 0) return false;const expected = normalizeModule(scope);return [symbol.module_name, symbol.module_path]- .filter((value): value is string => value !== null)+ .filter(+ (value): value is string =>+ value !== null && normalizeModule(value).length > 0,+ ).some((value) => nativeModuleIdentities(value).has(expected));};+const hasModuleIdentity = (symbol: NativeSymbol): boolean =>+ [symbol.module_name, symbol.module_path].some(+ (value) => value !== null && normalizeModule(value).length > 0,+ );+const candidateNames = (managed: Pick<PinvokeImport,@@ -190,6 +198,9 @@ const matchPinvoke = (};const candidates: [NativeSymbol, ...NativeSymbol[]] = [first, ...remaining];+ const scopeKnown =+ managed.import_scope_name !== null &&+ managed.import_scope_name.trim().length > 0;const exact = candidates.find((symbol) =>managed.import_name === symbol.name &&@@ -198,17 +209,13 @@ const matchPinvoke = (const decorated = candidates.find((symbol) =>moduleCompatible(managed.import_scope_name, symbol),);- const selected = exact ?? decorated ?? first;- if (!moduleCompatible(managed.import_scope_name, selected))- return {- match: {- status: "contradicted",- basis: "module-mismatch",- confidence: "unknown",- matched_native: selected,- candidates,- },- };+ const selected =+ exact ??+ decorated ??+ (scopeKnown+ ? candidates.find((symbol) => !hasModuleIdentity(symbol))+ : undefined) ??+ first;if (exact !== undefined)return {match: {@@ -222,11 +229,31 @@ const matchPinvoke = (candidates,},};+ if (decorated !== undefined)+ return {+ match: {+ basis: "decorated-name-candidate",+ status: "inferred",+ confidence: "inferred",+ matched_native: selected,+ candidates,+ },+ };+ if (!scopeKnown || !hasModuleIdentity(selected))+ return {+ match: {+ status: "unresolved",+ basis: "module-identity-unknown",+ confidence: "unknown",+ matched_native: selected,+ candidates,+ },+ };return {match: {- basis: "decorated-name-candidate",- status: "inferred",- confidence: "inferred",+ status: "contradicted",+ basis: "module-mismatch",+ confidence: "unknown",matched_native: selected,candidates,},@@ -234,26 +261,31 @@ const matchPinvoke = (};const pinvokeLimitations = (- status: PinvokeVerification["status"],+ match: PinvokeMatch,managed: PinvokeImport,): readonly string[] => [- ...(managed.import_scope_name === null+ ...(managed.import_scope_name === null ||+ managed.import_scope_name.trim().length === 0? ["Managed declaration does not name an import scope/module."]: []),- ...(status === "inferred"+ ...(match.status === "inferred"? ["Native symbol matched a decorated candidate rather than the exact declared import name.",]: []),- ...(status === "contradicted"+ ...(match.status === "contradicted"? ["A symbol name candidate exists, but the supplied native Evidence module identity does not match the managed import scope.",]: []),- ...(status === "unresolved"- ? [- "No supplied native export/function Evidence matched this declared import.",- ]+ ...(match.status === "unresolved"+ ? match.basis === "module-identity-unknown"+ ? [+ "A native name candidate exists, but a required module identity is unavailable; module correspondence is unknown.",+ ]+ : [+ "No supplied native export/function Evidence matched this declared import.",+ ]: []),];@@ -283,7 +315,7 @@ export const verifyPinvoke = ({declaration_verification: item.verification,};const selection = matchPinvoke(item, native.symbols, native.accepted);- const limitations = pinvokeLimitations(selection.match.status, item);+ const limitations = pinvokeLimitations(selection.match, item);return {verification: pinvokeVerificationSchema.parse({item_id: `mnv_pinvoke_${digest({diff --git a/src/domain/managed/managedNativeVerificationSchemas.ts b/src/domain/managed/managedNativeVerificationSchemas.tsindex 16afe4048..c83488a50 100644--- a/src/domain/managed/managedNativeVerificationSchemas.ts+++ b/src/domain/managed/managedNativeVerificationSchemas.ts@@ -51,7 +51,7 @@ const observedCandidatesSchema = z.tuple([nativeSymbolSchema]).rest(nativeSymbolSchema);-export const pinvokeVerificationSchema = z.discriminatedUnion("status", [+export const pinvokeVerificationSchema = z.union([z.strictObject({...pinvokeVerificationContextShape,status: z.literal("verified"),@@ -76,6 +76,14 @@ export const pinvokeVerificationSchema = z.discriminatedUnion("status", [matched_native: z.null(),candidates: emptyArraySchema,}),+ z.strictObject({+ ...pinvokeVerificationContextShape,+ status: z.literal("unresolved"),+ basis: z.literal("module-identity-unknown"),+ confidence: z.literal("unknown"),+ matched_native: nativeSymbolSchema,+ candidates: observedCandidatesSchema,+ }),z.strictObject({...pinvokeVerificationContextShape,status: z.literal("contradicted"),diff --git a/src/dotnet/ManagedArtifactInspector.ts b/src/dotnet/ManagedArtifactInspector.tsindex 625969aba..ab40afa9f 100644--- a/src/dotnet/ManagedArtifactInspector.ts+++ b/src/dotnet/ManagedArtifactInspector.ts@@ -24,6 +24,7 @@ import {readManagedMetadataLayout,type ManagedMetadataLayout,} from "./ManagedMetadataLayout.js";+import { readTypeMemberListFacts } from "./ManagedTypeMemberLists.js";import { ManagedReaderFailure } from "./ManagedReaderFailure.js";const flagNames = (flags: number): string[] => {@@ -384,10 +385,12 @@ export const inspectManagedArtifactBytes = (resourceIssues,);try {+ const memberLists = readTypeMemberListFacts(bytes, metadata);const inventory = readManagedMetadataInventory(bytes,metadata,resourceDirectory,+ memberLists,);const issues = [...resourceIssues, ...inventory.issues];const limitations = [diff --git a/src/dotnet/ManagedMemberInspector.test.ts b/src/dotnet/ManagedMemberInspector.test.tsindex ea4c41ac7..69fadc629 100644--- a/src/dotnet/ManagedMemberInspector.test.ts+++ b/src/dotnet/ManagedMemberInspector.test.ts@@ -11,6 +11,7 @@ import {type ManagedMetadataLayout,} from "./ManagedMetadataLayout.js";import { readManagedPeLayout } from "./ManagedPeReader.js";+import { memberListIndexSize } from "./ManagedMemberPointers.js";import { edges } from "./ManagedMemberRows.js";import { parseUserStrings } from "./ManagedUserStrings.js";import { signature, type ManagedMethod } from "./ManagedMemberInspectorCore.js";@@ -1224,7 +1225,173 @@ describe("managed derived caller names", () => {});});-describe("managed member reference bounds", () => {+describe("managed TypeDef list ownership bounds", () => {+ it("retains rows but leaves ownership unknown for zero TypeDef list starts", () => {+ const bytes = buildManagedPeFixture();+ const pe = readManagedPeLayout(bytes);+ if (pe.cli === null) throw new Error("fixture has no CLI header");+ const { rva, size } = pe.cli.metadata;+ const layout = readManagedMetadataLayout(+ bytes,+ pe.rvaToOffset(rva, size, "cli.metadata"),+ size,+ );+ const listOffset =+ metadataRowOffset(layout, 2, 1) ++ 4 ++ 2 * layout.stringIndexSize ++ layout.codedIndexSize("TypeDefOrRef");+ const listIndexWidth = Math.max(+ layout.tableIndexSize(3),+ layout.tableIndexSize(4),+ layout.tableIndexSize(5),+ layout.tableIndexSize(6),+ );+ const writeIndex = (offset: number) =>+ listIndexWidth === 2+ ? bytes.writeUInt16LE(0, offset)+ : bytes.writeUInt32LE(0, offset);+ writeIndex(listOffset);+ writeIndex(listOffset + listIndexWidth);++ const result = inspectManagedMembersBytes(+ bytes,+ managedPeFixtureTarget(bytes),+ );++ expect(result.types[0]).toMatchObject({+ field_list: { first_row: null, last_row: null, count: 0 },+ method_list: { first_row: null, last_row: null, count: 0 },+ });+ expect(result.fields[0]).toMatchObject({+ token: "0x04000001",+ name: "counter",+ declaring_type: null,+ });+ expect(result.methods[0]).toMatchObject({+ token: "0x06000001",+ name: "Main",+ declaring_type: null,+ });+ expect(result.coverage).toMatchObject({+ state: "partial",+ issues: [+ expect.objectContaining({+ code: "invalid-row",+ detail: expect.stringContaining("TypeDef FieldList start 0"),+ }),+ expect.objectContaining({+ code: "invalid-row",+ detail: expect.stringContaining("TypeDef MethodList start 0"),+ }),+ ],+ });+ });++ it("does not infer an earlier owner from an invalid next list endpoint", () => {+ const bytes = buildManagedPeFixture({ additionalEmptyTypes: 1 });+ const pe = readManagedPeLayout(bytes);+ if (pe.cli === null) throw new Error("fixture has no CLI header");+ const { rva, size } = pe.cli.metadata;+ const layout = readManagedMetadataLayout(+ bytes,+ pe.rvaToOffset(rva, size, "cli.metadata"),+ size,+ );+ const methodStartOffset =+ metadataRowOffset(layout, 2, 2) ++ 4 ++ 2 * layout.stringIndexSize ++ layout.codedIndexSize("TypeDefOrRef") ++ memberListIndexSize(layout, 4);+ if (memberListIndexSize(layout, 6) === 2)+ bytes.writeUInt16LE(0, methodStartOffset);+ else bytes.writeUInt32LE(0, methodStartOffset);++ const result = inspectManagedMembersBytes(+ bytes,+ managedPeFixtureTarget(bytes),+ );++ expect(result.methods[0]).toMatchObject({+ token: "0x06000001",+ declaring_type: null,+ });+ expect(result.types[0]?.method_list).toMatchObject({+ first_row: null,+ last_row: null,+ count: 0,+ });+ expect(result.coverage.state).toBe("partial");+ });+});++describe("managed TypeDef list ordering", () => {+ it("leaves adjacent ownership unknown when valid list starts decrease", () => {+ const bytes = buildManagedPeFixture({+ additionalEmptyTypes: 1,+ methodRowCount: 2,+ });+ const pe = readManagedPeLayout(bytes);+ if (pe.cli === null) throw new Error("fixture has no CLI header");+ const { rva, size } = pe.cli.metadata;+ const layout = readManagedMetadataLayout(+ bytes,+ pe.rvaToOffset(rva, size, "cli.metadata"),+ size,+ );+ const methodOffset =+ 4 ++ 2 * layout.stringIndexSize ++ layout.codedIndexSize("TypeDefOrRef") ++ memberListIndexSize(layout, 4);+ const writeMethodStart = (row: number, value: number): void => {+ const offset = metadataRowOffset(layout, 2, row) + methodOffset;+ if (memberListIndexSize(layout, 6) === 2)+ bytes.writeUInt16LE(value, offset);+ else bytes.writeUInt32LE(value, offset);+ };+ writeMethodStart(1, 2);+ writeMethodStart(2, 1);++ const result = inspectManagedMembersBytes(+ bytes,+ managedPeFixtureTarget(bytes),+ );++ expect(result.methods.map(({ declaring_type }) => declaring_type)).toEqual([+ null,+ null,+ ]);+ expect(result.coverage).toMatchObject({+ state: "partial",+ issues: [+ expect.objectContaining({+ code: "invalid-row",+ detail: expect.stringContaining(+ "MethodList start 1 decreases from preceding start 2",+ ),+ }),+ ],+ });+ });++ it("accepts the one-based start for an empty ordinary member table", () => {+ const bytes = buildManagedPeFixture({ methodRowCount: 0 });+ const result = inspectManagedMembersBytes(+ bytes,+ managedPeFixtureTarget(bytes),+ );+ expect(result.types[0]?.method_list).toEqual({+ first_row: null,+ last_row: null,+ count: 0,+ });+ expect(result.coverage).toMatchObject({ state: "complete", issues: [] });+ });+});++describe("managed metadata reference bounds", () => {it("retains members and reports an out-of-range TypeDef coded index as partial", () => {const bytes = buildManagedPeFixture({ extendsRaw: 12 });const result = inspectManagedMembersBytes(diff --git a/src/dotnet/ManagedMemberInspector.ts b/src/dotnet/ManagedMemberInspector.tsindex d6464b09d..ab074d146 100644--- a/src/dotnet/ManagedMemberInspector.ts+++ b/src/dotnet/ManagedMemberInspector.ts@@ -31,6 +31,7 @@ import {import { edgeTargets } from "./ManagedMethodSpecs.js";import { typeNameLookup } from "./ManagedTypeNames.js";import { parseUserStrings } from "./ManagedUserStrings.js";+import { readTypeMemberListFacts } from "./ManagedTypeMemberLists.js";import {edges,parseExportedTypes,@@ -113,12 +114,14 @@ const readMemberInventory = (rootOffset,cli.metadata.size,);+ const memberLists = readTypeMemberListFacts(bytes, layout);const inventory = readManagedMetadataInventory(bytes,layout,readManagedResourceDirectory(pe, issues),+ memberLists,);- return { layout, inventory };+ return { layout, inventory, memberLists };};const selectTypes = (@@ -185,9 +188,13 @@ export const inspectManagedMembersBytes = (return unavailable(target, bytes, pe.cliIssue, typeNames);const issues: ManagedParseIssue[] = [];try {- const { layout, inventory } = readMemberInventory(bytes, pe, issues);+ const { layout, inventory, memberLists } = readMemberInventory(+ bytes,+ pe,+ issues,+ );appendManagedParseIssues(issues, inventory.issues);- const ranges = typeRanges(bytes, layout, issues);+ const ranges = typeRanges(bytes, layout, issues, memberLists);const {tokens: selected,selection,@@ -197,7 +204,7 @@ export const inspectManagedMembersBytes = (appendManagedParseIssues(issues, parsedTypes.issues);const exportedTypes = parseExportedTypes(bytes, layout);appendManagedParseIssues(issues, exportedTypes.issues);- const fields = parseFields(bytes, layout, ranges, selected);+ const fields = parseFields(bytes, layout, ranges, memberLists, selected);const memberRefs = parseMemberRefs(bytes,layout,@@ -209,6 +216,7 @@ export const inspectManagedMembersBytes = (layout,pe,ranges,+ memberLists,selected,methodOffset,methodLimit,diff --git a/src/dotnet/ManagedMemberInspectorCore.ts b/src/dotnet/ManagedMemberInspectorCore.tsindex caac2e66e..858a6c2fb 100644--- a/src/dotnet/ManagedMemberInspectorCore.ts+++ b/src/dotnet/ManagedMemberInspectorCore.ts@@ -20,10 +20,8 @@ import {readMetadataString,sha256Bytes,} from "./ManagedMetadataHeaps.js";-import {- memberListIndexSize,- memberListTable,-} from "./ManagedMemberPointers.js";+import { memberListTable } from "./ManagedMemberPointers.js";+import type { TypeMemberListFacts } from "./ManagedTypeMemberLists.js";export type ManagedType = ManagedMemberInspection["types"][number];export type ManagedExportedType = NonNullable<@@ -47,10 +45,10 @@ export type ManagedExceptionRegion =export interface TypeRange {readonly token: string;readonly fullName: string | null;- readonly fieldStart: number;- readonly fieldEnd: number;- readonly methodStart: number;- readonly methodEnd: number;+ readonly fieldStart: number | null;+ readonly fieldEnd: number | null;+ readonly methodStart: number | null;+ readonly methodEnd: number | null;}/**@@ -80,18 +78,23 @@ export interface ParsedInstruction {const rowRange = (table: MetadataTableLayout | undefined,- start: number,- nextStart: number,+ start: number | null,+ end: number | null,): {readonly first: number | null;readonly last: number | null;readonly count: number;} => {const total = table?.rowCount ?? 0;- if (total === 0 || start === 0) return { first: null, last: null, count: 0 };- const end = Math.min(nextStart === 0 ? total + 1 : nextStart, total + 1);- if (start >= end) return { first: null, last: null, count: 0 };- return { first: start, last: end - 1, count: end - start };+ if (start === null || end === null)+ return { first: null, last: null, count: 0 };+ const lastExclusive = Math.min(end, total + 1);+ if (start >= lastExclusive) return { first: null, last: null, count: 0 };+ return {+ first: start,+ last: lastExclusive - 1,+ count: lastExclusive - start,+ };};export const fullName = (namespace: string, name: string): string =>@@ -102,9 +105,8 @@ const readTypeRange = (layout: ManagedMetadataLayout,row: number,issues: ManagedParseIssue[],+ memberLists: TypeMemberListFacts,): TypeRange => {- const methods = memberListTable(layout, 6);- const fields = memberListTable(layout, 4);const cursor = metadataRowCursor(bytes, layout, 2, row);cursor.readUInt32();const nameIndex = cursor.readIndex(layout.stringIndexSize);@@ -124,27 +126,14 @@ const readTypeRange = (issues,) ?? null;cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));- const fieldStart = cursor.readIndex(memberListIndexSize(layout, 4));- const methodStart = cursor.readIndex(memberListIndexSize(layout, 6));- let nextField = (fields?.rowCount ?? 0) + 1;- let nextMethod = (methods?.rowCount ?? 0) + 1;- const typeTable = layout.table(2);- if (typeTable !== undefined && row < typeTable.rowCount) {- const next = metadataRowCursor(bytes, layout, 2, row + 1);- next.readUInt32();- next.readIndex(layout.stringIndexSize);- next.readIndex(layout.stringIndexSize);- next.readIndex(layout.codedIndexSize("TypeDefOrRef"));- nextField = next.readIndex(memberListIndexSize(layout, 4));- nextMethod = next.readIndex(memberListIndexSize(layout, 6));- }+ const current = memberLists.entries[row - 1];return {token: metadataToken(2, row),fullName: declaredName,- fieldStart,- fieldEnd: nextField,- methodStart,- methodEnd: nextMethod,+ fieldStart: current?.field.start.value ?? null,+ fieldEnd: current?.field.end ?? null,+ methodStart: current?.method.start.value ?? null,+ methodEnd: current?.method.end ?? null,};};@@ -152,11 +141,13 @@ export const typeRanges = (bytes: Buffer,layout: ManagedMetadataLayout,issues: ManagedParseIssue[],+ memberLists: TypeMemberListFacts,): readonly TypeRange[] => {+ issues.push(...memberLists.issues);const typeTable = layout.table(2);const ranges: TypeRange[] = [];for (let row = 1; row <= (typeTable?.rowCount ?? 0); row += 1)- ranges.push(readTypeRange(bytes, layout, row, issues));+ ranges.push(readTypeRange(bytes, layout, row, issues, memberLists));return ranges;};@@ -193,18 +184,16 @@ export const parseTypes = (const extendsRaw = cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"),);- const fieldStart = cursor.readIndex(memberListIndexSize(layout, 4));- const methodStart = cursor.readIndex(memberListIndexSize(layout, 6));- const nextRange = ranges[row] ?? null;+ const currentRange = ranges[row - 1] ?? null;const fieldRange = rowRange(fields,- fieldStart,- nextRange?.fieldStart ?? 0,+ currentRange?.fieldStart ?? null,+ currentRange?.fieldEnd ?? null,);const methodRange = rowRange(methods,- methodStart,- nextRange?.methodStart ?? 0,+ currentRange?.methodStart ?? null,+ currentRange?.methodEnd ?? null,);const extendsReason = metadataCodedTokenInvalidReason(extendsRaw,diff --git a/src/dotnet/ManagedMemberOwnership.test.ts b/src/dotnet/ManagedMemberOwnership.test.tsindex 9e570a195..cee5e985a 100644--- a/src/dotnet/ManagedMemberOwnership.test.ts+++ b/src/dotnet/ManagedMemberOwnership.test.ts@@ -6,6 +6,7 @@ import { inspectManagedMembersBytes } from "./ManagedMemberInspector.js";import { managedDecodeBudget } from "./ManagedDecodeBudget.js";import { memberDeclaringTypeRowLookup } from "./ManagedMemberOwnership.js";import { memberListIndexSize } from "./ManagedMemberPointers.js";+import { readTypeMemberListFacts } from "./ManagedTypeMemberLists.js";import { readManagedMetadataLayout } from "./ManagedMetadataLayout.js";import {buildManagedMemberPointerFixture,@@ -28,15 +29,15 @@ const metadataLayout = (bytes: Buffer) => {describe("managed declaring type ownership", () => {it.prop([fc.tuple(- fc.tuple(- ...Array.from({ length: 3 }, () => fc.integer({ min: 0, max: 6 })),- ),- fc.tuple(- ...Array.from({ length: 3 }, () => fc.integer({ min: 0, max: 6 })),- ),+ fc+ .array(fc.integer({ min: 1, max: 3 }), { minLength: 3, maxLength: 3 })+ .map((starts) => starts.sort((left, right) => left - right)),+ fc+ .array(fc.integer({ min: 1, max: 3 }), { minLength: 3, maxLength: 3 })+ .map((starts) => starts.sort((left, right) => left - right)),),])(- "retains first-match field and method owners for arbitrary metadata lists",+ "matches literal ownership ranges for valid nondecreasing list starts",([fields, methods]) => {const bytes = buildManagedMemberPointerFixture();const layout = metadataLayout(bytes);@@ -64,11 +65,16 @@ describe("managed declaring type ownership", () => {] as const) {// The fixture's pointers reorder physical rows 1,2 to list positions 2,1.const expected = [2, 1].map((position) => {- const owner = starts.findIndex(- (start, index) =>- position >= start && position < (starts[index + 1] ?? 3),- );- return owner < 0 ? null : members.types[owner]?.full_name;+ let owner: number | null = null;+ for (let index = 0; index < starts.length; index += 1) {+ const start = starts[index];+ const end = starts[index + 1] ?? 3;+ if (start !== undefined && position >= start && position < end) {+ owner = index;+ break;+ }+ }+ return owner === null ? null : members.types[owner]?.full_name;});expect(members[table].map((member) => member.declaring_type)).toEqual(expected,@@ -80,10 +86,10 @@ describe("managed declaring type ownership", () => {},);- it("indexes large unordered member lists once per layout", () => {- const count = 100_000;+ it("indexes wide valid member lists once per layout", () => {+ const count = 65_538;const bytes = buildManagedPeFixture({- additionalEmptyTypes: count - 1,+ additionalEmptyTypes: count - 3,methodRowCount: count,});const layout = metadataLayout(bytes);@@ -95,24 +101,25 @@ describe("managed declaring type ownership", () => {2 * layout.stringIndexSize +layout.codedIndexSize("TypeDefOrRef") +memberListIndexSize(layout, 4);- // The first reversed range forces first-match semantics, with the owner last.- // 100,000 MethodDef rows require a four-byte method-list index.- bytes.writeUInt32LE(2, methodOffset);- const start = performance.now();- const lookup = memberDeclaringTypeRowLookup(bytes, layout, 6);- expect(- Array.from({ length: count }, (_, row) => lookup(row + 1)).every(- (owner) => owner === count,- ),- ).toBe(true);- expect(performance.now() - start).toBeLessThan(2000);- expect(memberDeclaringTypeRowLookup(bytes, layout, 6)).toBe(lookup);+ // Each preceding TypeDef owns one row; later TypeDefs have empty intervals.+ // This exercises the four-byte list-index boundary without malformed starts.+ for (let row = 0; row < count; row += 1)+ bytes.writeUInt32LE(+ Math.min(row + 1, 65_537),+ methodOffset + row * types.rowSize,+ );+ const facts = readTypeMemberListFacts(bytes, layout);+ const lookup = memberDeclaringTypeRowLookup(bytes, layout, 6, facts);+ expect(lookup(65_536)).toBe(65_536);+ expect(lookup(65_535)).toBe(65_535);+ expect(memberDeclaringTypeRowLookup(bytes, layout, 6, facts)).toBe(lookup);expect([lookup(0), lookup(count + 1)]).toEqual([0, 0]);});it("admits ownership storage before allocation and retains failed admission", () => {const bytes = buildManagedPeFixture();const layout = metadataLayout(bytes);+ const facts = readTypeMemberListFacts(bytes, layout);const budget = managedDecodeBudget(layout);const capacityFailure = new ManagedReaderFailure({code: "resource-limit",@@ -134,12 +141,12 @@ describe("managed declaring type ownership", () => {}),);try {- expect(() => memberDeclaringTypeRowLookup(bytes, layout, 6)).toThrow(- capacityFailure,- );- expect(() => memberDeclaringTypeRowLookup(bytes, layout, 6)).toThrow(- capacityFailure,- );+ expect(() =>+ memberDeclaringTypeRowLookup(bytes, layout, 6, facts),+ ).toThrow(capacityFailure);+ expect(() =>+ memberDeclaringTypeRowLookup(bytes, layout, 6, facts),+ ).toThrow(capacityFailure);expect(admission).toHaveBeenCalledTimes(1);expect(allocations).toBe(0);} finally {diff --git a/src/dotnet/ManagedMemberOwnership.ts b/src/dotnet/ManagedMemberOwnership.tsindex 0292f5e0a..6119b214f 100644--- a/src/dotnet/ManagedMemberOwnership.ts+++ b/src/dotnet/ManagedMemberOwnership.ts@@ -1,33 +1,35 @@import { managedDecodeBudget } from "./ManagedDecodeBudget.js";-import { metadataRowCursor } from "./ManagedMetadataHeaps.js";import type { ManagedMetadataLayout } from "./ManagedMetadataLayout.js";import {- memberListIndexSize,memberListRowLookup,memberListTable,} from "./ManagedMemberPointers.js";import { ManagedReaderFailure } from "./ManagedReaderFailure.js";+import type {+ MemberDefinitionTable,+ TypeMemberListFacts,+} from "./ManagedTypeMemberLists.js";-type MemberTable = 4 | 6;type OwnerLookup = (definitionRow: number) => number;const lookups = new WeakMap<- ManagedMetadataLayout,- Map<MemberTable, OwnerLookup | ManagedReaderFailure>+ TypeMemberListFacts,+ Map<MemberDefinitionTable, OwnerLookup | ManagedReaderFailure>>();/** One first-match TypeDef owner per physical member, shared by every inspection facet. */export const memberDeclaringTypeRowLookup = (bytes: Buffer,layout: ManagedMetadataLayout,- table: MemberTable,+ table: MemberDefinitionTable,+ facts: TypeMemberListFacts,): OwnerLookup => {- let byTable = lookups.get(layout);+ let byTable = lookups.get(facts);const cached = byTable?.get(table);if (cached instanceof ManagedReaderFailure) throw cached;if (cached !== undefined) return cached;if (byTable === undefined) {byTable = new Map();- lookups.set(layout, byTable);+ lookups.set(facts, byTable);}try {const positionOf = memberListRowLookup(bytes, layout, table);@@ -50,30 +52,26 @@ export const memberDeclaringTypeRowLookup = (}return root;};- const startForType = (row: number): number => {- const cursor = metadataRowCursor(bytes, layout, 2, row);- cursor.readUInt32();- cursor.readIndex(layout.stringIndexSize);- cursor.readIndex(layout.stringIndexSize);- cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));- const fieldStart = cursor.readIndex(memberListIndexSize(layout, 4));- return table === 4- ? fieldStart- : cursor.readIndex(memberListIndexSize(layout, 6));- };- let start = types === 0 ? 0 : startForType(1);for (let row = 1; row <= types; row += 1) {- const end = row === types ? positions + 1 : startForType(row + 1);- const limit = Math.min(end, positions + 1);- for (- let p = unowned(Math.min(Math.max(start, 1), positions + 1));- p < limit;- p = unowned(p + 1)- ) {- owners[p] = row;- next[p] = p + 1;+ const memberStart =+ table === 4+ ? facts.entries[row - 1]?.field+ : facts.entries[row - 1]?.method;+ const start = memberStart?.start.value ?? null;+ const end = memberStart?.end ?? null;+ // A malformed endpoint makes this entire interval uncertain. In+ // particular, zero must not become row one through owner-side clamping.+ if (start !== null && end !== null) {+ const limit = Math.min(end, positions + 1);+ for (+ let p = unowned(Math.min(start, positions + 1));+ p < limit;+ p = unowned(p + 1)+ ) {+ owners[p] = row;+ next[p] = p + 1;+ }}- start = end;}const definitions = layout.table(table)?.rowCount ?? 0;const lookup: OwnerLookup = (definition) =>diff --git a/src/dotnet/ManagedMemberPointers.ts b/src/dotnet/ManagedMemberPointers.tsindex 3517d0a11..876440c78 100644--- a/src/dotnet/ManagedMemberPointers.ts+++ b/src/dotnet/ManagedMemberPointers.ts@@ -1,5 +1,8 @@import { managedDecodeBudget } from "./ManagedDecodeBudget.js";-import type { ManagedMetadataLayout } from "./ManagedMetadataLayout.js";+import type {+ ManagedMetadataLayout,+ MetadataTableLayout,+} from "./ManagedMetadataLayout.js";import {managedFailure,ManagedReaderFailure,@@ -32,6 +35,17 @@ export const memberListIndexSize = (? 4: 2;+/** Normalize a TypeDef list coordinate once for parsing and owner lookup. */+export const validatedMemberListStart = (+ start: number,+ table: MetadataTableLayout | undefined,+): number | null => {+ const total = table?.rowCount ?? 0;+ return Number.isSafeInteger(start) && start >= 1 && start <= total + 1+ ? start+ : null;+};+/** Resolve physical definition rows to list positions without changing token identity. */export const memberListRowLookup = (bytes: Buffer,diff --git a/src/dotnet/ManagedMemberRows.ts b/src/dotnet/ManagedMemberRows.tsindex 0f2bcc633..0eb03c542 100644--- a/src/dotnet/ManagedMemberRows.ts+++ b/src/dotnet/ManagedMemberRows.ts@@ -30,6 +30,7 @@ import {import { readManagedValue } from "./ManagedReaderFailure.js";import { methodBody } from "./ManagedMethodBodyReader.js";import { memberDeclaringTypeRowLookup } from "./ManagedMemberOwnership.js";+import type { TypeMemberListFacts } from "./ManagedTypeMemberLists.js";/*** Declaring-type tokens whose members are decoded in full; null selects every@@ -47,6 +48,7 @@ export const parseFields = (bytes: Buffer,layout: ManagedMetadataLayout,ranges: readonly TypeRange[],+ memberLists: TypeMemberListFacts,selected: SelectedTypeTokens = null,): {readonly fields: readonly ManagedField[];@@ -58,7 +60,7 @@ export const parseFields = (const issues: ManagedParseIssue[] = [];const table = layout.table(4);const ownerRow = readManagedValue(- () => memberDeclaringTypeRowLookup(bytes, layout, 4),+ () => memberDeclaringTypeRowLookup(bytes, layout, 4, memberLists),issues,);for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {@@ -256,6 +258,7 @@ interface ParseMethodsInput {readonly layout: ManagedMetadataLayout;readonly pe: ManagedPeLayout;readonly ranges: readonly TypeRange[];+ readonly memberLists: TypeMemberListFacts;readonly selected?: SelectedTypeTokens;readonly methodOffset?: number;readonly methodLimit?: number;@@ -266,6 +269,7 @@ export const parseMethods = ({layout,pe,ranges,+ memberLists,selected = null,methodOffset = 0,methodLimit = Number.MAX_SAFE_INTEGER,@@ -285,7 +289,7 @@ export const parseMethods = ({let unscannedMethods = 0;const table = layout.table(6);const ownerRow = readManagedValue(- () => memberDeclaringTypeRowLookup(bytes, layout, 6),+ () => memberDeclaringTypeRowLookup(bytes, layout, 6, memberLists),issues,);for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {diff --git a/src/dotnet/ManagedMetadataInventory.ts b/src/dotnet/ManagedMetadataInventory.tsindex c31059d57..f2d5a9045 100644--- a/src/dotnet/ManagedMetadataInventory.ts+++ b/src/dotnet/ManagedMetadataInventory.ts@@ -15,6 +15,7 @@ import {readResource,} from "./ManagedMetadataInventoryRows.js";import { metadataToken } from "./ManagedMetadataHeaps.js";+import type { TypeMemberListFacts } from "./ManagedTypeMemberLists.js";import {readManagedValue,uniqueManagedParseIssues,@@ -149,13 +150,22 @@ const readAttributes = (bytes: Buffer,layout: ManagedMetadataLayout,issues: ManagedParseIssue[],+ memberLists: TypeMemberListFacts,): {readonly attributes: readonly CustomAttribute[];readonly targetFrameworks: readonly string[];} => {const attributes = readRows(layout.table(12), (row) =>readManagedValue(- () => readCustomAttribute(bytes, layout, row, heapExtent(layout), issues),+ () =>+ readCustomAttribute(+ bytes,+ layout,+ row,+ heapExtent(layout),+ issues,+ memberLists,+ ),issues,),);@@ -177,8 +187,9 @@ export const readManagedMetadataInventory = (bytes: Buffer,layout: ManagedMetadataLayout,resourceDirectory: ManagedResourceDirectory | null,+ memberLists: TypeMemberListFacts,): ManagedMetadataInventory => {- const issues: ManagedParseIssue[] = [];+ const issues: ManagedParseIssue[] = [...memberLists.issues];validateIdentityTableCounts(layout, issues);const module =readManagedValue(@@ -201,6 +212,7 @@ export const readManagedMetadataInventory = (bytes,layout,issues,+ memberLists,);return {module,diff --git a/src/dotnet/ManagedMetadataInventoryRows.ts b/src/dotnet/ManagedMetadataInventoryRows.tsindex 30f9e8e5a..3eb54cf50 100644--- a/src/dotnet/ManagedMetadataInventoryRows.ts+++ b/src/dotnet/ManagedMetadataInventoryRows.ts@@ -1,5 +1,6 @@import { managedDecodeBudget } from "./ManagedDecodeBudget.js";import { memberDeclaringTypeRowLookup } from "./ManagedMemberOwnership.js";+import type { TypeMemberListFacts } from "./ManagedTypeMemberLists.js";import type {ManagedArtifactInspection,@@ -248,8 +249,14 @@ const declaringTypeForMethod = (layout: ManagedMetadataLayout,methodRow: number,heapExtent: number,+ memberLists: TypeMemberListFacts,): string | null => {- const owner = memberDeclaringTypeRowLookup(bytes, layout, 6)(methodRow);+ const owner = memberDeclaringTypeRowLookup(+ bytes,+ layout,+ 6,+ memberLists,+ )(methodRow);if (owner === 0) return null;return readTypeName({ bytes, layout, table: 2, row: owner, heapExtent });};@@ -259,11 +266,13 @@ const attributeTypeName = (layout: ManagedMetadataLayout,rawType: number,heapExtent: number,+ memberLists: TypeMemberListFacts,): string | null => {const tag = rawType & 7;const row = Math.floor(rawType / 8);if (row === 0) return null;- if (tag === 2) return declaringTypeForMethod(bytes, layout, row, heapExtent);+ if (tag === 2)+ return declaringTypeForMethod(bytes, layout, row, heapExtent, memberLists);if (tag !== 3) return null;const memberRefs = layout.table(10);if (memberRefs === undefined || row > memberRefs.rowCount) return null;@@ -288,7 +297,13 @@ const attributeTypeName = (heapExtent,});if (parentTag === 3)- return declaringTypeForMethod(bytes, layout, parentRow, heapExtent);+ return declaringTypeForMethod(+ bytes,+ layout,+ parentRow,+ heapExtent,+ memberLists,+ );return null;};@@ -349,6 +364,7 @@ export const readCustomAttribute = (row: number,heapExtent: number,issues: ManagedParseIssue[],+ memberLists: TypeMemberListFacts,): CustomAttribute => {const cursor = metadataRowCursor(bytes, layout, 12, row);const parentRaw = cursor.readIndex(@@ -411,7 +427,8 @@ export const readCustomAttribute = (if (constructor !== null)typeName =readManagedValue(- () => attributeTypeName(bytes, layout, typeRaw, heapExtent),+ () =>+ attributeTypeName(bytes, layout, typeRaw, heapExtent, memberLists),issues,) ?? null;return {diff --git a/src/dotnet/ManagedNativeBoundaryInspector.ts b/src/dotnet/ManagedNativeBoundaryInspector.tsindex d2b84be04..ef0b62cf1 100644--- a/src/dotnet/ManagedNativeBoundaryInspector.ts+++ b/src/dotnet/ManagedNativeBoundaryInspector.ts@@ -13,6 +13,7 @@ import {readManagedMetadataLayout,type ManagedMetadataLayout,} from "./ManagedMetadataLayout.js";+import { readTypeMemberListFacts } from "./ManagedTypeMemberLists.js";import {readManagedPeLayout,type ManagedPeLayout,@@ -108,10 +109,12 @@ const readBoundaryInventory = (metadataOffset,cli.metadata.size,);+ const memberLists = readTypeMemberListFacts(bytes, layout);const inventory = readManagedMetadataInventory(bytes,layout,readManagedResourceDirectory(pe, issues),+ memberLists,);return { layout, inventory };};diff --git a/src/dotnet/ManagedTypeMemberLists.ts b/src/dotnet/ManagedTypeMemberLists.tsnew file mode 100644index 000000000..1db5674c6--- /dev/null+++ b/src/dotnet/ManagedTypeMemberLists.ts@@ -0,0 +1,147 @@+import type { ManagedParseIssue } from "../domain/managed/managedArtifact.js";+import { managedDecodeBudget } from "./ManagedDecodeBudget.js";+import type { ManagedMetadataLayout } from "./ManagedMetadataLayout.js";+import { metadataRowCursor, metadataToken } from "./ManagedMetadataHeaps.js";+import {+ memberListIndexSize,+ memberListTable,+ validatedMemberListStart,+} from "./ManagedMemberPointers.js";++export type MemberDefinitionTable = 4 | 6;++export interface TypeMemberListStart {+ readonly raw: number;+ readonly value: number | null;+ readonly offset: number;+}++export interface TypeMemberListRange {+ readonly start: TypeMemberListStart;+ /** Next TypeDef's validated start, or the one-past-end sentinel. */+ readonly end: number | null;+}++export interface TypeMemberListEntry {+ readonly field: TypeMemberListRange;+ readonly method: TypeMemberListRange;+}++/** Parsed TypeDef list coordinates for one metadata-layout lifetime. */+export interface TypeMemberListFacts {+ readonly entries: readonly TypeMemberListEntry[];+ readonly issues: readonly ManagedParseIssue[];+}++export const readTypeMemberListFacts = (+ bytes: Buffer,+ layout: ManagedMetadataLayout,+): TypeMemberListFacts => {+ const fields = memberListTable(layout, 4);+ const methods = memberListTable(layout, 6);+ const rows: { field: TypeMemberListStart; method: TypeMemberListStart }[] =+ [];+ const issues: ManagedParseIssue[] = [];+ const types = layout.table(2);+ const typeCount = types?.rowCount ?? 0;+ // Peak retained shape includes both the parsed-start and range arrays, their+ // nested records, plus each eventual JSON object/key projection. Malformed+ // row diagnostics are admitted separately before they are allocated.+ managedDecodeBudget(layout).reserve(+ typeCount * 512 + 256,+ types?.offset ?? null,+ );+ for (let row = 1; row <= typeCount; row += 1) {+ const cursor = metadataRowCursor(bytes, layout, 2, row);+ cursor.readUInt32();+ cursor.readIndex(layout.stringIndexSize);+ cursor.readIndex(layout.stringIndexSize);+ cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));+ const field = {+ offset: cursor.offset,+ raw: cursor.readIndex(memberListIndexSize(layout, 4)),+ };+ const method = {+ offset: cursor.offset,+ raw: cursor.readIndex(memberListIndexSize(layout, 6)),+ };+ const entry = {+ field: { ...field, value: validatedMemberListStart(field.raw, fields) },+ method: {+ ...method,+ value: validatedMemberListStart(method.raw, methods),+ },+ };+ rows.push(entry);+ for (const [name, start, table] of [+ ["FieldList", entry.field, fields],+ ["MethodList", entry.method, methods],+ ] as const)+ if (start.value === null) {+ managedDecodeBudget(layout).reserve(512, start.offset);+ issues.push({+ code: "invalid-row",+ scope: `metadata.TypeDef:${metadataToken(2, row)}`,+ offset: start.offset,+ detail: `TypeDef ${name} start ${String(start.raw)} is outside the one-based list range 1..${String((table?.rowCount ?? 0) + 1)}`,+ });+ }+ }+ const nonmonotonicFields = new Set<number>();+ const nonmonotonicMethods = new Set<number>();+ for (let index = 0; index + 1 < rows.length; index += 1) {+ const current = rows[index];+ const next = rows[index + 1];+ if (current === undefined || next === undefined) continue;+ for (const [name, before, after, affected] of [+ ["FieldList", current.field, next.field, nonmonotonicFields],+ ["MethodList", current.method, next.method, nonmonotonicMethods],+ ] as const)+ if (+ before.value !== null &&+ after.value !== null &&+ after.value < before.value+ ) {+ managedDecodeBudget(layout).reserve(512, after.offset);+ affected.add(index);+ affected.add(index + 1);+ issues.push({+ code: "invalid-row",+ scope: `metadata.TypeDef:${metadataToken(2, index + 2)}`,+ offset: after.offset,+ detail: `TypeDef ${name} start ${String(after.raw)} decreases from preceding start ${String(before.raw)}; adjacent member ranges are unknown`,+ });+ }+ }+ const entries: TypeMemberListEntry[] = rows.map((entry, index) => {+ const next = rows[index + 1];+ return {+ field: {+ start: {+ ...entry.field,+ value: nonmonotonicFields.has(index) ? null : entry.field.value,+ },+ end:+ next === undefined+ ? (fields?.rowCount ?? 0) + 1+ : nonmonotonicFields.has(index) || nonmonotonicFields.has(index + 1)+ ? null+ : next.field.value,+ },+ method: {+ start: {+ ...entry.method,+ value: nonmonotonicMethods.has(index) ? null : entry.method.value,+ },+ end:+ next === undefined+ ? (methods?.rowCount ?? 0) + 1+ : nonmonotonicMethods.has(index) ||+ nonmonotonicMethods.has(index + 1)+ ? null+ : next.method.value,+ },+ };+ });+ return { entries, issues };+};diff --git a/tests/boundary/providers/managed/managedMemberComparisonFromMetadata.test.ts b/tests/boundary/providers/managed/managedMemberComparisonFromMetadata.test.tsindex 5ffabdd59..0b3a69f6f 100644--- a/tests/boundary/providers/managed/managedMemberComparisonFromMetadata.test.ts+++ b/tests/boundary/providers/managed/managedMemberComparisonFromMetadata.test.ts@@ -12,6 +12,75 @@ import {managedPeFixtureTarget,} from "../../../../src/dotnet/ManagedPe.fixture.js";+describe("managed member structural matching", () => {+ it("keeps unequal constants from becoming a structural remap", () => {+ const observe = (+ typeName: string,+ methodName: string,+ constant: number,+ branchOffset: number,+ ) =>+ inspect(+ buildManagedPeFixture({+ typeName,+ methodName,+ ilBody: Buffer.from([+ 0x1e,+ 0x1f,+ constant,+ 0x26,+ 0x2b,+ branchOffset,+ 0x00,+ 0x2a,+ ]),+ }),+ `/tmp/${typeName}-${constant}.dll`,+ );+ const left = observe("OldType", "OldMethod", 5, 1);+ const differentConstant = observe("NewType", "NewMethod", 7, 1);+ const sameConstant = observe("NewType", "NewMethod", 5, 0);+ for (const [observed, constant] of [+ [left, 5],+ [differentConstant, 7],+ [sameConstant, 5],+ ] as const) {+ expect(observed.result.methods[0]?.body).toMatchObject({+ status: "present",+ normalized_il_sha256: expect.any(String),+ anchors: expect.arrayContaining([+ expect.objectContaining({+ operand_kind: "constant",+ operand: String(constant),+ }),+ ]),+ });+ }++ const different = compareManagedMembers(left, differentConstant);+ expect(different.methods.map(({ status }) => status)).toEqual([+ "removed",+ "added",+ ]);+ expect(+ different.methods.some(+ ({ match }) => match.basis === "structural-method-shape",+ ),+ ).toBe(false);++ expect(compareManagedMembers(left, sameConstant).methods).toContainEqual(+ expect.objectContaining({+ status: "changed",+ match: expect.objectContaining({+ status: "matched",+ basis: "structural-method-shape",+ confidence: "high",+ }),+ }),+ );+ });+});+describe("managed member comparison", () => {it("remaps renamed methods by exact CIL/signature without using names", () => {const leftBytes = buildManagedPeFixture();diff --git a/tests/conformance/providers/managed/managedNativeVerification.test.ts b/tests/conformance/providers/managed/managedNativeVerification.test.tsindex bca7dbfdc..6427853bf 100644--- a/tests/conformance/providers/managed/managedNativeVerification.test.ts+++ b/tests/conformance/providers/managed/managedNativeVerification.test.ts@@ -16,21 +16,27 @@ const exampleInput = () =>MANAGED_NATIVE_VERIFICATION_EXAMPLE,);-const nativeEvidenceWithExports = (names: readonly string[], path?: string) => {+const nativeEvidenceWithExports = (+ names: readonly string[],+ path?: string,+ subjectless = false,+) => {const input = exampleInput();const native = input.native_observations[0];if (native === undefined || native.subject === null)throw new Error("missing native example");const macho = inspectMachoSchema.parse(native.normalized_result);return createEvidence(- {- path: path ?? native.subject.local_path,- sha256: native.subject.digest.sha256,- format: native.subject.format,- ...(native.subject.architecture === null- ? {}- : { architecture: native.subject.architecture }),- },+ subjectless+ ? undefined+ : {+ path: path ?? native.subject.local_path,+ sha256: native.subject.digest.sha256,+ format: native.subject.format,+ ...(native.subject.architecture === null+ ? {}+ : { architecture: native.subject.architecture }),+ },native.provider,{operation: native.operation,@@ -60,7 +66,7 @@ const nativeEvidenceWithExports = (names: readonly string[], path?: string) => {);};-const inputWithImportScope = (scope: string) => {+const inputWithImportScope = (scope: string | null) => {const input = exampleInput();const managed = input.managed_boundaries;const normalized = managedNativeBoundaryInspectionSchema.parse(@@ -226,6 +232,41 @@ it("keeps literal module names distinct and accepts the shared-library lib alias});});+it("keeps name candidates unresolved when a required module identity is absent", () => {+ for (const scope of [null, "", " "]) {+ const result = verifyManagedNativeBoundaries({+ ...inputWithImportScope(scope),+ native_observations: [nativeEvidenceWithExports(["open_native"])],+ });+ expect(result.pinvoke_imports[0]).toMatchObject({+ status: "unresolved",+ basis: "module-identity-unknown",+ matched_native: { name: "open_native" },+ candidates: [{ name: "open_native" }],+ });+ expect(result.pinvoke_imports[0]?.limitations).toContain(+ "A native name candidate exists, but a required module identity is unavailable; module correspondence is unknown.",+ );+ }++ const subjectless = verifyManagedNativeBoundaries({+ ...inputWithImportScope("nativehelper.dll"),+ native_observations: [+ nativeEvidenceWithExports(["open_native"], undefined, true),+ ],+ });+ expect(subjectless.pinvoke_imports[0]).toMatchObject({+ status: "unresolved",+ basis: "module-identity-unknown",+ matched_native: {+ name: "open_native",+ module_name: null,+ module_path: null,+ },+ candidates: [{ name: "open_native" }],+ });+});+it("treats supported native Evidence with no symbols as unresolved", () => {const result = verifyManagedNativeBoundaries({...exampleInput(),