diff --git a/docs/reference/mcp-contracts.md b/docs/reference/mcp-contracts.md index 9eb0d5427d..afd1b039d8 100644 --- a/docs/reference/mcp-contracts.md +++ b/docs/reference/mcp-contracts.md @@ -1014,6 +1014,18 @@ finish without reading relationships, even when neither traversal mode is available. Discovery does not block that direct invocation or replace its typed partial/error outcomes. +`trace_native_values` includes `value_flow_support` for the provider routed to +`analyze_function`. `supported` declares that the provider may supply value flow; +it does not guarantee a model for the selected function. `unavailable` includes +the provider's reason, and `unknown` means no declaration. The provider ID is +preserved, or null if no analysis provider is routed. This declaration is separate +from operation readiness and the availability of call-target resolution. When +call-target resolution is missing, a direct trace may still return a local graph +with call-resolution unknowns; even `max_depth: 0` attempts to resolve call sites. +When support is unknown but the declared operation prerequisites are ready, +availability can still be true; it does not promise that value flow is present. +The trace's returned observations and unknowns remain authoritative for that call. + `trace_native_ui_action` reports authored-UI and native-seed modes separately. Apple dispatch metadata requires a Mach-O target; another provider may supply the symbol-only alternative on other formats. If neither mode is available, diff --git a/src/application/AnalysisProvider.ts b/src/application/AnalysisProvider.ts index 530703cce8..2aa8cd54a1 100644 --- a/src/application/AnalysisProvider.ts +++ b/src/application/AnalysisProvider.ts @@ -364,6 +364,10 @@ export type CapabilityDescriptor = CapabilityAvailability & { readonly operation: Exclude; readonly effects: CapabilityEffects; readonly limitations: readonly string[]; + /** Whether analyze_function can supply value flow for some procedures. */ + readonly nativeValueFlow?: + | { readonly status: "supported" } + | { readonly status: "unavailable"; readonly reason: string }; }; /** Factory and capability declaration for an analysis implementation. */ diff --git a/src/application/CapabilityInventory.ts b/src/application/CapabilityInventory.ts index 71ef1f6592..4397899b9a 100644 --- a/src/application/CapabilityInventory.ts +++ b/src/application/CapabilityInventory.ts @@ -24,7 +24,6 @@ import { toolAvailabilitySummaryInventory, TOOL_ANNOTATION_NAMES, TOOL_EFFECT_NAMES, - type ProviderCapability, type ToolAvailabilityInventory, type ToolAvailabilitySummaryInventory, type ToolAvailability, @@ -71,7 +70,7 @@ const statusSchema = z.object({ type ToolAvailabilityReason = "available" | ToolUnavailabilityReason; -type ProviderDescriptor = ProviderCapability; +type ProviderDescriptor = ReturnType[number]; type UnavailableDescriptor = Extract; /** Optional integrations whose verified hosts exclude some platforms. */ @@ -310,6 +309,22 @@ export const buildCapabilityInventory = ( const facts = { name: contract.name, surface: contract.kind, + ...(contract.name === "trace_native_values" + ? { + value_flow_support: (() => { + const source = descriptors.get("analyze_function"); + return source?.native_value_flow === undefined + ? { + status: "unknown" as const, + provider_id: source?.provider.id ?? null, + } + : { + ...source.native_value_flow, + provider_id: source.provider.id, + }; + })(), + } + : {}), ...(availability.defaultModeAvailable === undefined ? {} : { default_mode_available: availability.defaultModeAvailable }), @@ -377,6 +392,9 @@ export function compactToolAvailability( available: entry.available, reason: entry.reason, remediation: entry.remediation, + ...(entry.value_flow_support === undefined + ? {} + : { value_flow_support: entry.value_flow_support }), ...(entry.default_mode_available === undefined ? {} : { default_mode_available: entry.default_mode_available }), @@ -933,13 +951,38 @@ const composedAvailability = ( reason: "provider_missing", remediation: "No provider composition is declared for this operation.", }; - return "modes" in requirements - ? availabilityForModes( - requirements.modes, - requirements.defaultMode, - descriptors, - ) - : composedAvailabilityFor(requirements, descriptors).availability; + const result = + "modes" in requirements + ? availabilityForModes( + requirements.modes, + requirements.defaultMode, + descriptors, + ) + : composedAvailabilityFor(requirements, descriptors).availability; + if (name !== "trace_native_values") return result; + const source = descriptors.get("analyze_function"); + if (source?.available !== true) return result; + if (source.native_value_flow?.status === "unavailable") + return { + reason: + result.reason === "provider_unavailable" || + result.reason === "unsupported_host" + ? result.reason + : "provider_missing", + remediation: `${source.native_value_flow.reason} Select a provider that can report native value-flow observations; cross-function tracing also needs call-target resolution.${(result.reason === "provider_unavailable" || result.reason === "unsupported_host") && result.remediation !== null ? ` ${result.remediation}` : ""}`, + }; + if ( + result.reason === "provider_missing" && + descriptors.get("resolve_native_call_targets") === undefined + ) + return { + ...result, + remediation: + source.native_value_flow?.status === "supported" + ? "A direct trace may still return local value-flow observations with call-resolution unknowns. Configure a provider with resolve_native_call_targets for call resolution and cross-function tracing." + : "Value-flow support is undeclared. A direct trace may return partial results or an unknown. Configure a provider with resolve_native_call_targets for call resolution and cross-function tracing.", + }; + return result; }; /** Evaluate source groups once so discovery and missing-operation facts agree. */ diff --git a/src/application/binary/BinarySessionStatus.test.ts b/src/application/binary/BinarySessionStatus.test.ts index 8ee409feca..cd6b17fc87 100644 --- a/src/application/binary/BinarySessionStatus.test.ts +++ b/src/application/binary/BinarySessionStatus.test.ts @@ -10,6 +10,7 @@ import { analysisProviderCandidate, analysisProviderCandidateSummary, expandProviderCapabilities, + expandToolAvailability, sessionProviderFacts, type ProviderCapabilitySet, } from "../../contracts/toolOutputSchemaPrimitives.js"; @@ -30,6 +31,7 @@ import { import { NATIVE_MACOS_PROVIDER_IDENTITY } from "../../native/NativeMacosProviderIdentity.js"; import { buildCapabilityInventory, + compactToolAvailability, MULTI_MODE_REMEDIATION, } from "../CapabilityInventory.js"; @@ -74,7 +76,9 @@ type DescriptorOptions = { | { readonly available: false; readonly reason?: string; - readonly availabilityCode?: "architecture_unsupported"; + readonly availabilityCode?: + | "architecture_unsupported" + | "unsupported_host"; } ); @@ -850,3 +854,124 @@ it("groups readiness repairs exactly and drops one replaced by a runtime observa }), ]); }); + +it("keeps independent decompilation and value flow in distinct capability groups", async () => { + const status = await projectStatus( + [ + { + ...descriptor(providerA, "procedure_pseudo_code", []), + independentDecompile: true, + }, + { + ...descriptor(providerA, "analyze_function", []), + nativeValueFlow: { status: "supported" as const }, + }, + descriptor(providerA, "xrefs", []), + ], + [], + ); + const projected = z + .object({ capabilities: sessionProviderFacts.shape.capabilities }) + .parse(status); + const capabilities = expandProviderCapabilities(projected.capabilities); + expect( + capabilities.find((item) => item.operation === "procedure_pseudo_code"), + ).toMatchObject({ independent_decompile: true }); + expect( + capabilities.find((item) => item.operation === "analyze_function"), + ).toMatchObject({ native_value_flow: { status: "supported" } }); + expect( + capabilities.find((item) => item.operation === "xrefs"), + ).not.toHaveProperty("independent_decompile"); + expect( + capabilities.find((item) => item.operation === "xrefs"), + ).not.toHaveProperty("native_value_flow"); +}); + +it.each([ + { detail: "summary", supported: true }, + { detail: "complete", supported: true }, + { detail: "summary", supported: false }, + { detail: "complete", supported: false }, +] as const)( + "retains routed value-flow ownership and runtime failures in $detail discovery when supported=$supported", + async ({ detail, supported }) => { + const source = { + ...descriptor(providerA, "analyze_function", []), + nativeValueFlow: supported + ? { status: "supported" as const } + : { status: "unavailable" as const, reason: "No value flow." }, + }; + const resolver = descriptor(providerB, "resolve_native_call_targets", []); + const providerC = { id: "provider-c", name: "Provider C", version: "3" }; + const unselected = { + ...descriptor(providerC, "analyze_function", []), + nativeValueFlow: { status: "unavailable" as const, reason: "Unselected" }, + }; + const status = await projectStatus( + [source, resolver], + [{ ...candidate(providerC, [unselected]), selected: false }], + { + target: dispatchTarget("elf"), + detail, + runtimeUnavailability: new Map([ + ["resolve_native_call_targets", { reason: "Resolver failed." }], + ]), + }, + ); + const projected = z + .object({ capabilities: sessionProviderFacts.shape.capabilities }) + .parse(status); + const route = expandProviderCapabilities(projected.capabilities); + expect( + route.find((item) => item.operation === "analyze_function"), + ).toMatchObject({ + provider: providerA, + native_value_flow: { status: supported ? "supported" : "unavailable" }, + }); + const inventory = buildCapabilityInventory(status, { + processCaptureEnabled: false, + }); + const item = expandToolAvailability( + compactToolAvailability(inventory, detail), + ).find((candidate) => candidate.name === "trace_native_values"); + expect(item).toMatchObject({ + available: false, + reason: "provider_unavailable", + remediation: expect.stringContaining("Resolver failed."), + value_flow_support: { + status: supported ? "supported" : "unavailable", + provider_id: providerA.id, + }, + }); + if (!supported) expect(item?.remediation).toContain("No value flow."); + }, +); + +it("preserves an unsupported resolver host alongside unavailable value flow", async () => { + const source = { + ...descriptor(providerA, "analyze_function", []), + nativeValueFlow: { + status: "unavailable" as const, + reason: "No value flow.", + }, + }; + const resolver = { + ...descriptor(providerB, "resolve_native_call_targets", [], { + available: false, + reason: "Resolver host is unsupported.", + availabilityCode: "unsupported_host", + }), + remediation: "Use a supported resolver host.", + }; + const status = await projectStatus([source, resolver], [], { + target: dispatchTarget("elf"), + detail: "summary", + }); + const item = buildCapabilityInventory(status, { + processCaptureEnabled: false, + }).find((entry) => entry.name === "trace_native_values"); + expect(item).toMatchObject({ available: false, reason: "unsupported_host" }); + expect(item?.remediation).toContain("No value flow."); + expect(item?.remediation).toContain("Use a supported resolver host."); +}); diff --git a/src/application/binary/BinarySessionStatus.ts b/src/application/binary/BinarySessionStatus.ts index 75caae9a15..a3b69a6ba2 100644 --- a/src/application/binary/BinarySessionStatus.ts +++ b/src/application/binary/BinarySessionStatus.ts @@ -424,6 +424,7 @@ export const providerCapabilitySets = ( const key = JSON.stringify([ effects, limitations, + descriptor.nativeValueFlow ?? null, descriptor.independentDecompile ?? null, status.available, status.reason, @@ -437,6 +438,9 @@ export const providerCapabilitySets = ( operations: [descriptor.operation], effects, limitations, + ...(descriptor.nativeValueFlow === undefined + ? {} + : { native_value_flow: descriptor.nativeValueFlow }), ...(descriptor.independentDecompile === undefined ? {} : { independent_decompile: descriptor.independentDecompile }), diff --git a/src/contracts/toolOutputSchemaPrimitives.ts b/src/contracts/toolOutputSchemaPrimitives.ts index 34da0afe14..41d562939a 100644 --- a/src/contracts/toolOutputSchemaPrimitives.ts +++ b/src/contracts/toolOutputSchemaPrimitives.ts @@ -54,6 +54,29 @@ export const requireOutputSchema = < /** The readiness owner's repair instruction; never the failure description. */ const providerRemediation = z.string().min(1); +const nativeValueFlowDeclaration = z.discriminatedUnion("status", [ + z.strictObject({ status: z.literal("supported") }), + z.strictObject({ + status: z.literal("unavailable"), + reason: z.string().min(1), + }), +]); +const nativeValueFlowSupport = z.discriminatedUnion("status", [ + z.strictObject({ + status: z.literal("supported"), + provider_id: z.string().min(1), + }), + z.strictObject({ + status: z.literal("unavailable"), + provider_id: z.string().min(1), + reason: z.string().min(1), + }), + z.strictObject({ + status: z.literal("unknown"), + provider_id: z.string().min(1).nullable(), + }), +]); + const providerCapabilityFacts = { operation: z.string(), effects: z.object({ @@ -66,6 +89,7 @@ const providerCapabilityFacts = { requires_root: z.boolean(), }), limitations: z.array(z.string()), + native_value_flow: nativeValueFlowDeclaration.exactOptional(), independent_decompile: z.literal(true).exactOptional(), }; @@ -102,6 +126,7 @@ const providerCapabilityGroupFacts = { operations: z.array(z.string().min(1)).min(1), effects: z.array(providerCapabilityFacts.effects.keyof()), limitations: z.array(z.string()), + native_value_flow: nativeValueFlowDeclaration.exactOptional(), independent_decompile: providerCapabilityFacts.independent_decompile, }; @@ -141,6 +166,9 @@ export const expandProviderCapabilities = ( group.operations.map((operation) => ({ ...providerCapability.parse({ operation, + ...(group.native_value_flow === undefined + ? {} + : { native_value_flow: group.native_value_flow }), ...(group.independent_decompile === undefined ? {} : { independent_decompile: group.independent_decompile }), @@ -381,6 +409,11 @@ const toolAvailabilityFacts = { surface: z.string(), default_mode_available: z.boolean().optional(), modes: z.array(toolAvailabilityMode).optional(), + value_flow_support: nativeValueFlowSupport + .describe( + "The named provider's declared ability to supply value flow for some functions, separate from runtime readiness. Supported does not guarantee a model for a particular function; unknown means no declaration.", + ) + .exactOptional(), client_requirements: z.object({ required: z.array(clientFeatureNameSchema), optional: z.array(clientFeatureNameSchema), @@ -446,6 +479,7 @@ const toolAvailabilityStatusGroupFacts = { names: z.array(z.string().min(1)).min(1), default_mode_available: toolAvailabilityFacts.default_mode_available, modes: toolAvailabilityFacts.modes, + value_flow_support: toolAvailabilityFacts.value_flow_support, client_requirements: toolAvailabilityFacts.client_requirements.optional(), }; @@ -455,6 +489,7 @@ const toolAvailabilityGroupFacts = { default_mode_available: toolAvailabilityStatusGroupFacts.default_mode_available, modes: toolAvailabilityStatusGroupFacts.modes, + value_flow_support: toolAvailabilityStatusGroupFacts.value_flow_support, client_requirements: toolAvailabilityStatusGroupFacts.client_requirements, effects: z.array(toolAvailabilityFacts.effects.keyof()), annotations: z.array(toolAvailabilityFacts.annotations.keyof()), diff --git a/src/ghidra/GhidraProviderCapabilities.ts b/src/ghidra/GhidraProviderCapabilities.ts index 2496d6fbdd..63a8aa1df4 100644 --- a/src/ghidra/GhidraProviderCapabilities.ts +++ b/src/ghidra/GhidraProviderCapabilities.ts @@ -234,6 +234,9 @@ export const CAPABILITIES: readonly CapabilityDescriptor[] = Object.freeze( return Object.freeze({ provider: GHIDRA_PROVIDER_IDENTITY, operation, + ...(operation === "analyze_function" + ? { nativeValueFlow: { status: "supported" as const } } + : {}), available: true, reason: null, // Project writes are private import machinery. Analysis reads are bound diff --git a/src/kuna/KunaProviderCapabilities.ts b/src/kuna/KunaProviderCapabilities.ts index 86a9008f9c..9f3bbd91ba 100644 --- a/src/kuna/KunaProviderCapabilities.ts +++ b/src/kuna/KunaProviderCapabilities.ts @@ -29,6 +29,9 @@ export const KUNA_STRING_LIMITATION = export const KUNA_XREF_LIMITATION = "Kuna's static reference walk unifies forwarding aliases and omits references internal to that alias class. REA keeps only exact-address incoming edges; an empty result does not prove no reference exists."; +export const KUNA_VALUE_FLOW_UNAVAILABLE = + "REA's Kuna provider does not report native def-use observations."; + /** Whether an operation is one Kuna answers. */ export const isKunaOperation = ( operation: AnalysisOperation, @@ -104,6 +107,14 @@ export const kunaCapabilities = ( KUNA_OPERATIONS.map((operation) => ({ provider: KUNA_PROVIDER_IDENTITY, operation, + ...(operation === "analyze_function" + ? { + nativeValueFlow: { + status: "unavailable" as const, + reason: KUNA_VALUE_FLOW_UNAVAILABLE, + }, + } + : {}), ...(operation === "procedure_pseudo_code" ? { independentDecompile: true as const } : {}), diff --git a/src/kuna/KunaSessionClient.ts b/src/kuna/KunaSessionClient.ts index 7e10b27daf..f9ed36d4ab 100644 --- a/src/kuna/KunaSessionClient.ts +++ b/src/kuna/KunaSessionClient.ts @@ -86,6 +86,7 @@ import { isKunaOperation, KUNA_RELATIONSHIP_LIMITATION, KUNA_SINGLE_FUNCTION_LIMITATION, + KUNA_VALUE_FLOW_UNAVAILABLE, kunaLimitations, type KunaOperation, } from "./KunaProviderCapabilities.js"; @@ -346,10 +347,6 @@ const kunaVerificationLimitations = ( /** Kuna names a procedure by its inventory entry or by an exact entry address. */ const procedureSelectorSchema = z.string().min(1); -/** REA's Kuna integration does not supply a def-use model for any procedure. */ -export const KUNA_NATIVE_VALUE_FLOW_UNAVAILABLE = - "REA's Kuna provider does not report native def-use observations."; - /** * One Kuna analysis session for one target. * @@ -1733,7 +1730,7 @@ export class KunaSessionClient implements AnalysisClient { native_api: null, native_value_flow: { available: false, - reason: KUNA_NATIVE_VALUE_FLOW_UNAVAILABLE, + reason: KUNA_VALUE_FLOW_UNAVAILABLE, limitations: [], }, facet_availability: { diff --git a/tests/boundary/mcp/nativeValueFlowAvailability.test.ts b/tests/boundary/mcp/nativeValueFlowAvailability.test.ts new file mode 100644 index 0000000000..7333b3ece1 --- /dev/null +++ b/tests/boundary/mcp/nativeValueFlowAvailability.test.ts @@ -0,0 +1,176 @@ +import { writeFile } from "node:fs/promises"; +import { join } from "node:path"; +import { afterAll, expect, it } from "vitest"; +import type { AnalysisProvider } from "../../../src/application/AnalysisProvider.js"; +import { + valueTraceDiamond, + valueTraceProvider, +} from "../../../src/application/native/NativeValueTrace.fixture.js"; +import { createAnalysisProfile } from "../../../src/domain/analysisProfile.js"; +import { parseEvidence } from "../../../src/domain/evidence.js"; +import { functionDossierSchema } from "../../../src/domain/native/functionDossier.js"; +import { ok } from "../../../src/domain/result.js"; +import { createApplicationMcpHarness } from "../../fixtures/applicationMcpHarness.js"; +import { createTestBinarySession } from "../../fixtures/binarySession.js"; +import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js"; +import { advertisedMcpToolSchemas } from "../../fixtures/advertisedMcpTool.js"; +import { createMcpSchemaValidation } from "../../fixtures/mcpSchemaValidation.js"; + +const schemaValidation = createMcpSchemaValidation(); +afterAll(() => schemaValidation.clear()); + +it.each([ + { profile: "compact", state: "supported" }, + { profile: "full", state: "supported" }, + { profile: "compact", state: "unknown" }, + { profile: "full", state: "unknown" }, + { profile: "compact", state: "unavailable" }, + { profile: "full", state: "unavailable" }, +] as const)( + "reports $state value flow without a resolver in $profile MCP", + async ({ profile, state }) => { + const target = join( + await createTestTempDirectory("flow-capability-"), + "fixture.com", + ); + await writeFile(target, Buffer.from([0xb8, 0x00, 0x4c, 0xcd, 0x21])); + const graph = valueTraceDiamond({ sessionSubject: true }); + const provider: AnalysisProvider = { + identity: () => valueTraceProvider, + capabilities: () => [ + { + provider: valueTraceProvider, + operation: "analyze_function", + available: true, + reason: null, + ...(state === "unknown" + ? {} + : state === "supported" + ? { nativeValueFlow: { status: "supported" as const } } + : { + nativeValueFlow: { + status: "unavailable" as const, + reason: "Fixture has no value flow.", + }, + }), + effects: { + mutatesArtifact: false, + launchesProcess: false, + mayShowUi: false, + mayAccessNetwork: false, + mayWriteFilesystem: false, + changesPermissions: false, + requiresRoot: false, + }, + limitations: [], + }, + ], + resolveAnalysisProfile: async () => + ok({ + profile: createAnalysisProfile(valueTraceProvider, { fixture: true }), + }), + createClient: () => ({ + execute: async (operation, parameters, options) => { + const execution = await graph.port.execute( + operation, + parameters, + options, + ); + if ( + !execution.ok || + state !== "unavailable" || + operation !== "analyze_function" + ) + return execution; + const dossier = functionDossierSchema.parse(execution.value.result); + return ok({ + ...execution.value, + result: { + ...dossier, + native_value_flow: { + available: false, + reason: "Fixture has no value flow.", + limitations: [], + }, + }, + }); + }, + close: async () => ok(null), + }), + }; + const session = createTestBinarySession(provider); + const { client } = await createApplicationMcpHarness({ + session, + schemaValidator: schemaValidation, + serverOptions: { + environment: { + ...process.env, + REA_MCP_INPUT_SCHEMA_PROFILE: profile, + REA_MCP_OUTPUT_SCHEMA_PROFILE: profile, + }, + }, + }); + const call = async (name: string, args: Record) => { + const schema = await advertisedMcpToolSchemas( + client, + name, + schemaValidation.assertions, + ); + const reply = await client.callTool( + { name, arguments: args }, + { toolDefinition: schema.toolDefinition }, + ); + expect(reply.isError, JSON.stringify(reply)).not.toBe(true); + expect( + schema.ajv.validate(schema.outputSchema, reply.structuredContent), + JSON.stringify(schema.ajv.errors), + ).toBe(true); + return reply.structuredContent; + }; + await call("open_binary", { path: target, format: "dos-com" }); + const status = (await call("binary_session", { detail: "summary" })) as { + result: { + tool_availability: { + groups: Array<{ + names: string[]; + available: boolean; + value_flow_support?: { status: string; provider_id: string }; + remediation: string | null; + }>; + }; + }; + }; + const traceStatus = status.result.tool_availability.groups.find((g) => + g.names.includes("trace_native_values"), + ); + expect(traceStatus).toMatchObject({ + available: false, + value_flow_support: { status: state, provider_id: "fixture" }, + remediation: expect.any(String), + }); + if (state === "unavailable") + expect(traceStatus?.remediation).toContain("Fixture has no value flow."); + else + expect(traceStatus?.remediation).toContain("resolve_native_call_targets"); + const trace = parseEvidence( + await call("trace_native_values", { procedure: "0x1000", max_depth: 0 }), + ); + const value = trace.normalized_result as { + total_nodes: number; + unknowns: Array<{ reason: string }>; + }; + if (state === "unavailable") { + expect(value.total_nodes).toBe(0); + expect(value.unknowns).toContainEqual( + expect.objectContaining({ reason: "Fixture has no value flow." }), + ); + } else { + expect(value.total_nodes).toBeGreaterThan(0); + expect( + value.unknowns.some((unknown) => + unknown.reason.includes("resolve_native_call_targets"), + ), + ).toBe(true); + } + }, +); diff --git a/tests/boundary/providers/kuna/kunaProvider.test.ts b/tests/boundary/providers/kuna/kunaProvider.test.ts index ca008ad64b..1666b12088 100644 --- a/tests/boundary/providers/kuna/kunaProvider.test.ts +++ b/tests/boundary/providers/kuna/kunaProvider.test.ts @@ -20,7 +20,7 @@ import { OwnedFileHandle } from "../../../../src/filesystem/OwnedFileHandle.js"; import { AnalysisProviderRegistry } from "../../../../src/application/binary/AnalysisProviderRegistry.js"; import { composeBinarySession } from "../../../../src/application/binary/BinarySessionComposition.js"; import { projectAnalysisError } from "../../../../src/domain/analysisErrorProjection.js"; -import { KUNA_NATIVE_VALUE_FLOW_UNAVAILABLE } from "../../../../src/kuna/KunaSessionClient.js"; +import { KUNA_VALUE_FLOW_UNAVAILABLE } from "../../../../src/kuna/KunaProviderCapabilities.js"; import { KunaProvider } from "../../../../src/kuna/KunaProvider.js"; import { KUNA_FUNCTION_TEXT_BYTES } from "../../../../src/kuna/KunaLimits.js"; import { KunaProjectCache } from "../../../../src/kuna/KunaProjectCache.js"; @@ -524,7 +524,7 @@ it("builds a dossier with text and call relationships, leaving unsupported facet assembly: ["main: ; 0x1000", " 00001000: c3 RET"], native_value_flow: { available: false, - reason: KUNA_NATIVE_VALUE_FLOW_UNAVAILABLE, + reason: KUNA_VALUE_FLOW_UNAVAILABLE, }, facet_availability: { pseudocode: { available: true },