gitnexus 1.6.11-rc.21 → 1.6.11-rc.23

package/dist/core/ingestion/language-provider.d.ts

@@ -20,7 +20,7 @@ import type { VariableExtractor } from './variable-types.js';
 import type { ImportResolverFn } from './import-resolvers/types.js';
 import type { SyntaxNode } from './utils/ast-helpers.js';
 import type { CfgVisitor } from './cfg/types.js';
-import type { NodeLabel } from '../../_shared/index.js';
+import type { GraphNode, NodeLabel } from '../../_shared/index.js';
 import type { ExtractedRoute } from './route-extractors/laravel.js';
 import type { SharedSpringType } from './route-extractors/spring-shared.js';
 import type { ModuleConstants, Operand, RepoConstants } from './route-extractors/constant-resolver.js';
@@ -31,11 +31,27 @@ export type CaptureMap = Record<string, SyntaxNode | undefined>;
 export interface DefinitionPropertiesContext {
     readonly nodeLabel: NodeLabel;
     readonly nodeName: string;
+    readonly filePath: string;
     readonly definitionNode: SyntaxNode;
     readonly parsedImports: readonly ParsedImport[];
     readonly isExported: boolean;
 }
 export type DefinitionPropertiesExtractor = (context: DefinitionPropertiesContext) => Readonly<Record<string, unknown>> | undefined;
+export interface RuntimeCallableIdentity {
+    readonly name: string;
+    readonly descriptorParameterTypes: readonly string[] | undefined;
+}
+/**
+ * Optional language-owned bridge from runtime/compiler symbol identities to
+ * source graph symbols. Framework importers use this instead of naming
+ * languages or reproducing compiler conventions in shared ingestion code.
+ */
+export interface RuntimeSymbolStrategy {
+    /** Runtime owner names that may contain this callable/property. */
+    readonly callableOwnerAliases?: (node: GraphNode, owner: GraphNode | undefined) => readonly string[];
+    /** Whether a runtime callable identity can conservatively identify a node. */
+    readonly matchesCallable: (node: GraphNode, runtime: RuntimeCallableIdentity) => boolean;
+}
 /** Run optional provider enrichment without allowing one hook failure to drop
  * the rest of the worker's language batch. */
 export declare function runDefinitionPropertiesExtractor(extractor: DefinitionPropertiesExtractor, context: DefinitionPropertiesContext, onError: (error: unknown) => void): Readonly<Record<string, unknown>> | undefined;
@@ -125,6 +141,12 @@ interface LanguageProviderConfig {
      * Default: undefined (no preprocessing — `file.content` is parsed verbatim).
      */
     readonly preprocessSource?: (sourceText: string, filePath: string) => string;
+    /**
+     * Runtime/compiler identity reconciliation for framework metadata. The
+     * central importer owns ambiguity handling; providers only supply aliases
+     * and language-specific callable compatibility.
+     */
+    readonly runtimeSymbolStrategy?: RuntimeSymbolStrategy;
     /** Type extraction: declarations, initializers, for-loop bindings */
     readonly typeConfig: LanguageTypeConfig;
     /** Export detection: is this AST node a public/exported symbol? */
@@ -372,6 +394,15 @@ interface LanguageProviderConfig {
      * {@link extractModuleConstants} accepts.
      */
     readonly moduleConstantHeuristic?: (content: string) => boolean;
+    /**
+     * Prepare this language's harvested constants once the complete repo map is
+     * available and before route operands are folded. The parse phase passes only
+     * entries owned by this provider, so implementations can build one reusable
+     * language-specific index and may materialize deferred bindings in place.
+     *
+     * Default: undefined (the harvested constants are already fold-ready).
+     */
+    readonly prepareRouteConstants?: (repo: RepoConstants) => void;
     /**
      * Fold one file's non-literal route-path operand list
      * (`routePathExpr`/`routePathOperands` of an `ExtractedDecoratorRoute`)
@@ -723,6 +754,12 @@ export interface LanguageProvider extends Omit<LanguageProviderConfig, 'mroStrat
     /** Check if a name is a built-in/stdlib function that should be filtered from the call graph. */
     readonly isBuiltInName: (name: string) => boolean;
 }
+/**
+ * Run each provider's repo-constant preparation hook once over only the files
+ * that provider owns. Values are shared with `repo`, so in-place preparation
+ * is visible to the subsequent fold without copying the complete map.
+ */
+export declare function prepareRouteConstantsByProvider(repo: RepoConstants, providerForFile: (filePath: string) => Pick<LanguageProvider, 'prepareRouteConstants'> | null): void;
 /** Define a language provider — required fields must be supplied, optional fields get sensible defaults. */
 export declare function defineLanguage(config: LanguageProviderConfig): LanguageProvider;
 export {};

package/dist/core/ingestion/language-provider.js

@@ -45,6 +45,28 @@ export function shouldHarvestModuleConstants(provider, content) {
         return false;
     return !provider.moduleConstantHeuristic || provider.moduleConstantHeuristic(content);
 }
+/**
+ * Run each provider's repo-constant preparation hook once over only the files
+ * that provider owns. Values are shared with `repo`, so in-place preparation
+ * is visible to the subsequent fold without copying the complete map.
+ */
+export function prepareRouteConstantsByProvider(repo, providerForFile) {
+    const slices = new Map();
+    for (const [filePath, constants] of repo) {
+        const provider = providerForFile(filePath);
+        if (!provider?.prepareRouteConstants)
+            continue;
+        let slice = slices.get(provider);
+        if (!slice) {
+            slice = new Map();
+            slices.set(provider, slice);
+        }
+        slice.set(filePath, constants);
+    }
+    for (const [provider, slice] of slices) {
+        provider.prepareRouteConstants?.(slice);
+    }
+}
 const DEFAULTS = {
     mroStrategy: 'first-wins',
 };

package/dist/core/ingestion/languages/java/spring-actuator.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeSymbolStrategy } from '../../language-provider.js';
+export declare const javaRuntimeSymbolStrategy: RuntimeSymbolStrategy;

package/dist/core/ingestion/languages/java/spring-actuator.js

@@ -0,0 +1,62 @@
+const JVM_PRIMITIVES = {
+    B: 'byte',
+    C: 'char',
+    D: 'double',
+    F: 'float',
+    I: 'int',
+    J: 'long',
+    S: 'short',
+    Z: 'boolean',
+};
+function normalizedType(value, runtime) {
+    let erased = value.trim();
+    let arrayDimensions = 0;
+    if (erased.endsWith('...')) {
+        arrayDimensions++;
+        erased = erased.slice(0, -3);
+    }
+    while (erased.endsWith('[]')) {
+        arrayDimensions++;
+        erased = erased.slice(0, -2);
+    }
+    erased = erased.replace(/<.*>$/, '').replaceAll('$', '.').replaceAll('/', '.');
+    const simple = erased.slice(erased.lastIndexOf('.') + 1);
+    const base = runtime ? (JVM_PRIMITIVES[simple] ?? simple) : simple;
+    return `${base}${'[]'.repeat(arrayDimensions)}`;
+}
+function sourceTypeIsUnknown(value) {
+    const type = normalizedType(value, false).replace(/(?:\[\])+$/, '');
+    return type === '?' || /^[A-Z]$/.test(type);
+}
+function matchesJavaCallable(node, runtime) {
+    if (node.label !== 'Method' || node.properties.name !== runtime.name)
+        return false;
+    const descriptorTypes = runtime.descriptorParameterTypes;
+    if (descriptorTypes === undefined)
+        return true;
+    const parameterCount = node.properties.parameterCount;
+    if (typeof parameterCount === 'number' && parameterCount !== descriptorTypes.length)
+        return false;
+    const sourceTypes = node.properties.parameterTypes;
+    if (!Array.isArray(sourceTypes) ||
+        sourceTypes.length !== descriptorTypes.length ||
+        !sourceTypes.every((type) => typeof type === 'string')) {
+        return true;
+    }
+    return sourceTypes.every((sourceType, index) => {
+        if (sourceTypeIsUnknown(sourceType))
+            return true;
+        const source = normalizedType(sourceType, false);
+        const descriptor = normalizedType(descriptorTypes[index] ?? '', true);
+        if (source === descriptor)
+            return true;
+        // Java parser metadata currently drops the ellipsis from varargs and also
+        // leaves parameterCount open-ended. Only in that shape may T match JVM T[].
+        return (typeof parameterCount !== 'number' &&
+            descriptor.endsWith('[]') &&
+            source === descriptor.slice(0, -2));
+    });
+}
+export const javaRuntimeSymbolStrategy = {
+    matchesCallable: matchesJavaCallable,
+};

package/dist/core/ingestion/languages/java.js

@@ -13,7 +13,7 @@ import { defineLanguage } from '../language-provider.js';
 import { createLeadingDocDescriptionExtractor } from '../utils/ast-helpers.js';
 import { javaTypeConfig } from '../type-extractors/jvm.js';
 import { extractSpringRoutes, extractSpringTypes } from '../route-extractors/spring.js';
-import { extractJavaModuleConstants, foldJavaOperands, isJavaConstantFile, } from '../route-extractors/java-const-resolver.js';
+import { extractJavaModuleConstants, foldJavaOperands, isJavaConstantFile, prepareJavaRouteConstants, } from '../route-extractors/java-const-resolver.js';
 import { javaExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
 import { javaImportConfig } from '../import-resolvers/configs/jvm.js';
@@ -30,6 +30,7 @@ import { collectJavaCaptureSideChannel } from './java/capture-side-channel.js';
 import { javaRecordMethodExtractor, shouldSkipJavaRecordComponentDefinition, } from './java/record-components.js';
 import { synthesizeLombokAccessors } from './java/lombok-synthesizer.js';
 import { emitJavaScopeCaptures, interpretJavaImport, interpretJavaTypeBinding, javaBindingScopeFor, javaImportOwningScope, javaMergeBindings, javaReceiverBinding, javaArityCompatibility, resolveJavaImportTarget, } from './java/index.js';
+import { javaRuntimeSymbolStrategy } from './java/spring-actuator.js';
 /**
  * Java names the platform owns, matched against a BARE IDENTIFIER — a dropped
  * receiver's chain base (`System` in `System.out.println(...)`) or the bare
@@ -168,6 +169,7 @@ export const javaProvider = defineLanguage({
     shouldSkipDefinitionCapture: shouldSkipJavaRecordComponentDefinition,
     variableExtractor: createVariableExtractor(javaVariableConfig),
     classExtractor: createClassExtractor(javaClassConfig),
+    runtimeSymbolStrategy: javaRuntimeSymbolStrategy,
     // ── Javadoc → description (issue #2270) ──
     descriptionExtractor: createLeadingDocDescriptionExtractor(),
     builtInNames: BUILT_INS,
@@ -202,11 +204,10 @@ export const javaProvider = defineLanguage({
     // INTERFACES on this side only, which cost the graph its Route nodes while
     // the group still published the contract).
     moduleConstantHeuristic: (content) => isJavaConstantFile(content) ||
-        // `import com.winning.opt.common.ApiPaths;` — ANY class import can bind a
-        // constant ref (`ApiPaths.X` at an annotation site), so gate on the
-        // general import shape, not on the imported name. Ingestion-only: this
-        // side needs the importing controller's own import table, which the group
-        // side instead derives lazily from the tree it already holds.
-        /\bimport\s+(?:static\s+)?[\w.]+\s*;/.test(content),
+        // Class imports and static (including on-demand) imports can bind a
+        // constant ref. Ordinary `import a.b.*;` is not a Java type import and is
+        // not expanded by extractJavaModuleConstants, so it must not harvest.
+        /\bimport\s+(?:static\s+[\w.]+(?:\.\*)?|[\w.]+)\s*;/.test(content),
+    prepareRouteConstants: prepareJavaRouteConstants,
     foldRoutePathOperands: foldJavaOperands,
 });

package/dist/core/ingestion/languages/kotlin/spring-actuator.d.ts

@@ -0,0 +1,4 @@
+import type { DefinitionPropertiesContext, RuntimeSymbolStrategy } from '../../language-provider.js';
+/** Transient graph metadata used only by the same analysis run's runtime import. */
+export declare function extractKotlinRuntimeSymbolProperties(context: DefinitionPropertiesContext): Readonly<Record<string, unknown>> | undefined;
+export declare const kotlinRuntimeSymbolStrategy: RuntimeSymbolStrategy;

package/dist/core/ingestion/languages/kotlin/spring-actuator.js

@@ -0,0 +1,172 @@
+import path from 'node:path';
+const RUNTIME_OWNER_ALIASES = 'runtimeOwnerAliases';
+const RUNTIME_CALLABLE_ALIASES = 'runtimeCallableAliases';
+const KOTLIN_SUSPEND = 'kotlinSuspend';
+const fileFacadeMetadataCache = new WeakMap();
+function rootNode(node) {
+    let current = node;
+    while (current.parent)
+        current = current.parent;
+    return current;
+}
+function packageName(root) {
+    const header = root.namedChildren.find((child) => child.type === 'package_header');
+    return header?.text.replace(/^package\s+/, '').trim() ?? '';
+}
+function qualify(packageNameValue, simpleName) {
+    return packageNameValue.length === 0 ? simpleName : `${packageNameValue}.${simpleName}`;
+}
+function standardFacadeName(filePath) {
+    const stem = path.basename(filePath).replace(/\.(?:kt|kts)$/i, '');
+    return `${stem.charAt(0).toUpperCase()}${stem.slice(1)}Kt`;
+}
+function jvmNameIdentifiers(imports, allowUnqualified) {
+    const names = new Set(['kotlin.jvm.JvmName']);
+    if (allowUnqualified)
+        names.add('JvmName');
+    for (const parsedImport of imports) {
+        if (parsedImport.kind !== 'named' && parsedImport.kind !== 'alias')
+            continue;
+        if (parsedImport.importedName !== 'JvmName')
+            continue;
+        const target = parsedImport.targetRaw.replace(/\\/g, '/');
+        if (target === 'kotlin.jvm' || target === 'kotlin.jvm.JvmName') {
+            names.add(parsedImport.localName);
+        }
+    }
+    return [...names];
+}
+function annotationJvmName(source, target = '', imports = [], allowUnqualified = true) {
+    const names = jvmNameIdentifiers(imports, allowUnqualified);
+    if (names.length === 0)
+        return undefined;
+    const escapedTarget = target.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const prefix = target.length === 0 ? '' : `${escapedTarget}:`;
+    const namePattern = [...names]
+        .map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+        .join('|');
+    return new RegExp(`@${prefix}(?:${namePattern})\\s*\\(\\s*["']([^"']+)["']\\s*\\)`).exec(source)?.[1];
+}
+function fileFacadeMetadata(root, imports, allowUnqualified) {
+    const cached = fileFacadeMetadataCache.get(root);
+    if (cached !== undefined)
+        return cached;
+    const metadata = {
+        packageName: packageName(root),
+        customFacade: annotationJvmName(root.text, 'file', imports, allowUnqualified),
+    };
+    fileFacadeMetadataCache.set(root, metadata);
+    return metadata;
+}
+function hasEnclosingType(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.type === 'class_declaration' ||
+            current.type === 'object_declaration' ||
+            current.type === 'companion_object') {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+/** Transient graph metadata used only by the same analysis run's runtime import. */
+export function extractKotlinRuntimeSymbolProperties(context) {
+    const properties = {};
+    const source = context.definitionNode.text;
+    const root = rootNode(context.definitionNode);
+    const allowUnqualifiedJvmName = !/\bannotation\s+class\s+JvmName\b/.test(root.text);
+    if ((context.nodeLabel === 'Function' || context.nodeLabel === 'Method') &&
+        context.definitionNode.type === 'function_declaration') {
+        if (/\bsuspend\b/.test(source.slice(0, source.indexOf('fun') + 3))) {
+            properties[KOTLIN_SUSPEND] = true;
+        }
+        const callableJvmName = annotationJvmName(source, '', context.parsedImports, allowUnqualifiedJvmName);
+        if (callableJvmName !== undefined) {
+            properties[RUNTIME_CALLABLE_ALIASES] = [callableJvmName];
+        }
+        if (!hasEnclosingType(context.definitionNode)) {
+            const facade = fileFacadeMetadata(root, context.parsedImports, allowUnqualifiedJvmName);
+            properties[RUNTIME_OWNER_ALIASES] = [
+                qualify(facade.packageName, facade.customFacade ?? standardFacadeName(context.filePath)),
+            ];
+        }
+    }
+    else if (context.nodeLabel === 'Property') {
+        const getterJvmName = annotationJvmName(source, 'get', context.parsedImports, allowUnqualifiedJvmName);
+        if (getterJvmName !== undefined) {
+            properties[RUNTIME_CALLABLE_ALIASES] = [getterJvmName];
+        }
+        if (!hasEnclosingType(context.definitionNode)) {
+            const facade = fileFacadeMetadata(root, context.parsedImports, allowUnqualifiedJvmName);
+            properties[RUNTIME_OWNER_ALIASES] = [
+                qualify(facade.packageName, facade.customFacade ?? standardFacadeName(context.filePath)),
+            ];
+        }
+    }
+    return Object.keys(properties).length === 0 ? undefined : properties;
+}
+function stringArrayProperty(node, property) {
+    const value = node.properties[property];
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === 'string')
+        : [];
+}
+function callableNames(node) {
+    return [String(node.properties.name), ...stringArrayProperty(node, RUNTIME_CALLABLE_ALIASES)];
+}
+function propertyGetterNames(node) {
+    const name = String(node.properties.name);
+    const capitalized = `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+    return [
+        name.startsWith('is') && name.length > 2 && /[A-Z]/.test(name.charAt(2))
+            ? name
+            : `get${capitalized}`,
+        ...stringArrayProperty(node, RUNTIME_CALLABLE_ALIASES),
+    ];
+}
+function sourceCallableName(runtimeName) {
+    return runtimeName.endsWith('$default') ? runtimeName.slice(0, -'$default'.length) : runtimeName;
+}
+function matchesKotlinCallable(node, runtime) {
+    // Kotlin property declarations and their synthesized JVM accessor Methods
+    // coexist in the graph. Bind runtime getters to the source Property so the
+    // synthetic accessor cannot turn an otherwise exact match into ambiguity.
+    if (node.properties.synthetic === 'kotlin-jvm')
+        return false;
+    const runtimeName = sourceCallableName(runtime.name);
+    if (node.label === 'Property') {
+        const names = propertyGetterNames(node);
+        if (!names.includes(runtime.name) && !names.includes(runtimeName))
+            return false;
+    }
+    else if (!callableNames(node).includes(runtimeName)) {
+        return false;
+    }
+    const parameterCount = node.properties.parameterCount;
+    const descriptorTypes = runtime.descriptorParameterTypes;
+    if (typeof parameterCount !== 'number' ||
+        descriptorTypes === undefined ||
+        runtime.name.endsWith('$default')) {
+        return true;
+    }
+    if (parameterCount === descriptorTypes.length)
+        return true;
+    return (node.properties[KOTLIN_SUSPEND] === true &&
+        parameterCount + 1 === descriptorTypes.length &&
+        descriptorTypes.at(-1) === 'kotlin/coroutines/Continuation');
+}
+export const kotlinRuntimeSymbolStrategy = {
+    callableOwnerAliases(node, owner) {
+        const aliases = [...stringArrayProperty(node, RUNTIME_OWNER_ALIASES)];
+        const ownerName = owner?.properties.qualifiedName;
+        if (typeof ownerName === 'string') {
+            aliases.push(ownerName);
+            if (node.properties.isStatic === true && !ownerName.endsWith('.Companion')) {
+                aliases.push(`${ownerName}.Companion`);
+            }
+        }
+        return aliases;
+    },
+    matchesCallable: matchesKotlinCallable,
+};

package/dist/core/ingestion/languages/kotlin.js

@@ -29,6 +29,7 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { kotlinVariableConfig } from '../variable-extractors/configs/jvm.js';
 import { collectKotlinCaptureSideChannel, emitKotlinScopeCaptures, interpretKotlinImport, interpretKotlinTypeBinding, kotlinArityCompatibility, kotlinBindingScopeFor, kotlinImportOwningScope, kotlinMergeBindings, kotlinReceiverBinding, } from './kotlin/index.js';
 import { synthesizeLombokAccessors } from './kotlin/lombok-synthesizer.js';
+import { extractKotlinRuntimeSymbolProperties, kotlinRuntimeSymbolStrategy, } from './kotlin/spring-actuator.js';
 /** Check if a Kotlin function_declaration capture is inside a class_body (i.e., a method).
  *  Kotlin grammar uses function_declaration for both top-level functions and class methods.
  *  Returns true when the captured definition node has a class_body ancestor. */
@@ -157,6 +158,8 @@ export const kotlinProvider = defineLanguage({
     builtInNames: BUILT_INS,
     // ── KDoc → description (issue #2270) ──
     descriptionExtractor: createLeadingDocDescriptionExtractor(),
+    definitionPropertiesExtractor: extractKotlinRuntimeSymbolProperties,
+    runtimeSymbolStrategy: kotlinRuntimeSymbolStrategy,
     labelOverride: (functionNode, defaultLabel) => {
         if (defaultLabel !== 'Function')
             return defaultLabel;

package/dist/core/ingestion/pipeline-phases/parse-impl.js

@@ -30,7 +30,8 @@ import { SCOPE_RESOLVERS } from '../scope-resolution/pipeline/registry.js';
 import { DATA_ROUTE_TABLE_SOURCE } from '../route-extractors/data-route-table.js';
 import { createWorkerPool, workerPoolDisabledByEnv, resolveAutoPoolSize, WorkerPoolInitializationError, WorkerPoolDisabledError, } from '../workers/worker-pool.js';
 import { normalizeExtractedRoutePath } from '../route-extractors/route-path.js';
-import { resolveOperands, } from '../route-extractors/python-const-resolver.js';
+import { resolveOperands } from '../route-extractors/python-const-resolver.js';
+import { prepareRouteConstantsByProvider } from '../language-provider.js';
 import { resolveInheritedSpringRoutes, } from '../route-extractors/spring-shared.js';
 import fs from 'node:fs';
 import { effectiveRamBytes, memoryAutopilotDisabled } from '../utils/effective-ram.js';
@@ -1022,6 +1023,10 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
         for (const { filePath, constants } of allModuleConstants) {
             repoConstants.set(filePath, constants);
         }
+        // Let each language prepare only its own constants slice before folding.
+        // This is where deferred wildcard bindings can be materialized once per
+        // provider without naming a language in the shared parse phase.
+        prepareRouteConstantsByProvider(repoConstants, getProviderForFile);
         const resolvedRoutes = [];
         let skipped = 0;
         for (const dr of allDecoratorRoutes) {

package/dist/core/ingestion/pipeline-phases/processes.d.ts

@@ -4,7 +4,8 @@
  * Detects execution flows (processes) and creates Process nodes +
  * STEP_IN_PROCESS edges. Also links Route/Tool nodes to processes.
  *
- * @deps    communities, routes, tools, pruneLocalSymbols, structure, parse
+ * @deps    communities, routes, tools, springAutoConfiguration,
+ *          pruneLocalSymbols, structure, parse
  * @reads   graph (all nodes and relationships), communityResult, routeRegistry,
  *          toolDefs, parse's allFetchCalls + allORMQueries (R3-6 sink sites)
  * @writes  graph (Process nodes, STEP_IN_PROCESS edges, ENTRY_POINT_OF edges)

package/dist/core/ingestion/pipeline-phases/processes.js

@@ -4,7 +4,8 @@
  * Detects execution flows (processes) and creates Process nodes +
  * STEP_IN_PROCESS edges. Also links Route/Tool nodes to processes.
  *
- * @deps    communities, routes, tools, pruneLocalSymbols, structure, parse
+ * @deps    communities, routes, tools, springAutoConfiguration,
+ *          pruneLocalSymbols, structure, parse
  * @reads   graph (all nodes and relationships), communityResult, routeRegistry,
  *          toolDefs, parse's allFetchCalls + allORMQueries (R3-6 sink sites)
  * @writes  graph (Process nodes, STEP_IN_PROCESS edges, ENTRY_POINT_OF edges)
@@ -39,7 +40,15 @@ export const processesPhase = {
     // sinks rather than failing the phase. `pruneLocalSymbols` is declared
     // explicitly so process extraction always reads the trimmed graph even if a
     // future option drops the intervening `mro`/`communities` phases.
-    deps: ['communities', 'routes', 'tools', 'pruneLocalSymbols', 'structure', 'parse'],
+    deps: [
+        'communities',
+        'routes',
+        'tools',
+        'springAutoConfiguration',
+        'pruneLocalSymbols',
+        'structure',
+        'parse',
+    ],
     async execute(ctx, deps) {
         const { totalFiles } = getPhaseOutput(deps, 'structure');
         const { communityResult } = getPhaseOutput(deps, 'communities');
@@ -172,8 +181,34 @@ export const processesPhase = {
                 step: step.step,
             });
         });
+        // The static registry is finalized before Spring runtime enrichment. Merge
+        // runtime-confirmed Route nodes from the graph after the explicit
+        // springAutoConfiguration dependency has completed, so Actuator-only
+        // mappings participate in the same process-linking path.
+        const processRouteRegistry = new Map(routeRegistry);
+        ctx.graph.forEachNode((node) => {
+            if (node.label !== 'Route' ||
+                node.properties.runtimeSource !== 'spring-actuator' ||
+                node.properties.runtimeConfirmed !== true) {
+                return;
+            }
+            const url = typeof node.properties.name === 'string' ? node.properties.name : undefined;
+            const filePath = typeof node.properties.filePath === 'string' ? node.properties.filePath : undefined;
+            const method = typeof node.properties.method === 'string' ? node.properties.method : undefined;
+            if (url === undefined || filePath === undefined)
+                return;
+            const key = routeNodeKey(method, url);
+            if (!processRouteRegistry.has(key)) {
+                processRouteRegistry.set(key, {
+                    filePath,
+                    source: 'spring-actuator-runtime',
+                    url,
+                    ...(method === undefined ? {} : { method }),
+                });
+            }
+        });
         // Link Route and Tool nodes to Processes
-        if (routeRegistry.size > 0 || toolDefs.length > 0) {
+        if (processRouteRegistry.size > 0 || toolDefs.length > 0) {
             // Two-tier route lookup, mirroring the tool tables 10 lines below.
             // Routes whose handler resolved key by `handlerSymbolId` (read from
             // the Route node's graph properties — routes.ts stamps it there) and
@@ -188,7 +223,7 @@ export const processesPhase = {
             // routes phase stamps on the Route node was never consulted.
             const routesByHandlerId = new Map();
             const routesWithoutHandlerByFile = new Map();
-            for (const [, entry] of routeRegistry) {
+            for (const [, entry] of processRouteRegistry) {
                 // Push the Route node identity (`routeNodeKey`), not the bare URL, so the
                 // ENTRY_POINT_OF edge targets the same node id the routes phase created
                 // (#2289: a same-URL GET/POST pair is two distinct Route nodes).

package/dist/core/ingestion/pipeline-phases/scan.js

@@ -10,6 +10,79 @@
  * @output  ScannedFile[], allPaths[], totalFiles
  */
 import { walkRepositoryPaths } from '../filesystem-walker.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const SPRING_ACTUATOR_ENDPOINT_FILES = new Set([
+    'mappings.json',
+    'beans.json',
+    'conditions.json',
+    'configprops.json',
+    'env.json',
+]);
+async function canonicalPath(filePath) {
+    return fs.realpath(filePath).catch(() => path.resolve(filePath));
+}
+async function compileActuatorExclusions(repoPath, inputPaths) {
+    const repo = await canonicalPath(repoPath);
+    const lexicalRepo = path.resolve(repoPath);
+    const compiled = [];
+    const seen = new Set();
+    for (const inputPath of inputPaths) {
+        const lexicalInput = path.resolve(repoPath, inputPath);
+        const lexicalRelative = path.relative(lexicalRepo, lexicalInput);
+        const canonicalInput = await canonicalPath(lexicalInput);
+        const candidateInputs = new Set([canonicalInput]);
+        if (lexicalRelative === '' ||
+            (lexicalRelative !== '..' &&
+                !lexicalRelative.startsWith(`..${path.sep}`) &&
+                !path.isAbsolute(lexicalRelative))) {
+            // Preserve the configured in-repo alias as an exclusion even when its
+            // real target is outside the repository.
+            candidateInputs.add(path.resolve(repo, lexicalRelative));
+        }
+        for (const input of candidateInputs) {
+            const inputRelativeToRepo = path.relative(repo, input);
+            if (inputRelativeToRepo === '') {
+                if (seen.has(''))
+                    continue;
+                seen.add('');
+                compiled.push({ kind: 'repo-root-endpoints' });
+                continue;
+            }
+            if (inputRelativeToRepo === '..' ||
+                inputRelativeToRepo.startsWith(`..${path.sep}`) ||
+                path.isAbsolute(inputRelativeToRepo)) {
+                continue;
+            }
+            if (seen.has(input))
+                continue;
+            seen.add(input);
+            compiled.push({ kind: 'dir', resolved: input });
+        }
+    }
+    return { repo, exclusions: compiled };
+}
+function matchesActuatorExclusion(canonicalRepoPath, filePath, exclusions) {
+    if (exclusions.length === 0)
+        return false;
+    const candidate = path.resolve(canonicalRepoPath, filePath);
+    for (const exclusion of exclusions) {
+        if (exclusion.kind === 'repo-root-endpoints') {
+            const candidateRelativeToRepo = path.relative(canonicalRepoPath, candidate);
+            if (path.dirname(candidateRelativeToRepo) === '.' &&
+                SPRING_ACTUATOR_ENDPOINT_FILES.has(path.basename(candidateRelativeToRepo).toLowerCase())) {
+                return true;
+            }
+            continue;
+        }
+        const relative = path.relative(exclusion.resolved, candidate);
+        if (relative === '' ||
+            (relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative))) {
+            return true;
+        }
+    }
+    return false;
+}
 export const scanPhase = {
     name: 'scan',
     deps: [],
@@ -19,15 +92,20 @@ export const scanPhase = {
             percent: 0,
             message: 'Scanning repository...',
         });
+        const { repo: canonicalRepoPath, exclusions: actuatorExclusions } = await compileActuatorExclusions(ctx.repoPath, [
+            ...(ctx.options?.springActuatorPath === undefined ? [] : [ctx.options.springActuatorPath]),
+            ...(ctx.options?.springActuatorScanExclusions ?? []),
+        ]);
         let scannedFiles;
         try {
             scannedFiles = await walkRepositoryPaths(ctx.repoPath, (current, total, filePath) => {
                 const scanProgress = Math.round((current / total) * 15);
+                const isRuntimeInput = matchesActuatorExclusion(canonicalRepoPath, filePath, actuatorExclusions);
                 ctx.onProgress({
                     phase: 'extracting',
                     percent: scanProgress,
                     message: 'Scanning repository...',
-                    detail: filePath,
+                    ...(isRuntimeInput ? {} : { detail: filePath }),
                     stats: {
                         filesProcessed: current,
                         totalFiles: total,
@@ -45,6 +123,9 @@ export const scanPhase = {
             }
             throw err;
         }
+        if (actuatorExclusions.length > 0) {
+            scannedFiles = scannedFiles.filter((file) => !matchesActuatorExclusion(canonicalRepoPath, file.path, actuatorExclusions));
+        }
         const totalFiles = scannedFiles.length;
         const allPaths = scannedFiles.map((f) => f.path);
         ctx.onProgress({

package/dist/core/ingestion/pipeline-phases/spring-auto-configuration.d.ts

@@ -10,6 +10,7 @@
  * @reads   META-INF/spring.factories and AutoConfiguration.imports
  * @writes  Class nodes and DECLARES edges
  */
+import { type SpringActuatorImportStats } from '../frameworks/spring/actuator-runtime.js';
 import type { PipelinePhase } from './types.js';
 export interface SpringAutoConfigurationEntry {
     readonly className: string;
@@ -24,6 +25,7 @@ export interface SpringAutoConfigurationOutput {
     readonly metadataFiles: number;
     readonly autoConfigurations: number;
     readonly ambiguousAutoConfigurations: number;
+    readonly actuatorRuntime?: SpringActuatorImportStats;
 }
 export declare function classifySpringAutoConfigurationMetadata(filePath: string): SpringAutoConfigurationMetadataFile | null;
 /** Parse Boot 2.7+/3.x one-class-per-line auto-configuration imports. */