gitnexus 1.6.11-rc.8 → 1.6.11

package/dist/core/ingestion/pipeline.d.ts

@@ -25,6 +25,34 @@ export interface PipelineOptions {
      * to retain those nodes under `skipGraphPhases`.
      */
     skipGraphPhases?: boolean;
+    /**
+     * Skip only Leiden community detection and process/flow extraction (#3016).
+     * MRO/DI still run. Used on warm incremental analyze so persisted
+     * Community/Process rows can be kept instead of wipe+rewrite.
+     */
+    skipDerivedGraphPhases?: boolean;
+    /**
+     * Explicit local Spring Boot Actuator snapshot input. Accepts a directory
+     * containing endpoint-named JSON files or a JSON bundle keyed by endpoint.
+     * Undefined keeps runtime enrichment completely disabled.
+     */
+    springActuatorPath?: string;
+    /** Repo-relative Actuator inputs retained only for a cleanup scan. */
+    springActuatorScanExclusions?: readonly string[];
+    /**
+     * Explicit local AsyncAPI 3.x document input, read by the `springDestinations`
+     * phase. Accepts a directory of documents or a single document; the path is
+     * resolved against the repository root, so a committed `docs/asyncapi` and an
+     * absolute cache populated out of band are equally natural. Undefined keeps
+     * specification reading completely disabled.
+     *
+     * There is deliberately no glob-based auto-discovery to go with it. Scanning
+     * a repository for anything that parses as a document would make every
+     * existing index grow destination nodes on its next run without an operator
+     * having decided anything — the same reason new contract extractors ship
+     * opt-in rather than on.
+     */
+    asyncApiSpecPath?: string;
     /** Per-advice Spring AOP candidate inspection cap. `0` disables this cap. */
     springAopMaxCandidateInspectionsPerAdvice?: number;
     /** Aggregate Spring AOP candidate inspection cap for one analysis. `0` disables this cap. */
@@ -226,7 +254,8 @@ export interface PipelineOptions {
  * Phase dependency graph:
  *
  *   scan → structure → [springConfig, markdown, cobol] → parse → [routes, tools, orm]
- *     → crossFile → scopeResolution → [springAutoConfiguration, springAop] → pruneLocalSymbols
+ *     → crossFile → scopeResolution → [springAutoConfiguration, springAop,
+ *       springDestinations] → pruneLocalSymbols
  *     → mro → springAopInheritance → di → communities → processes
  *
  * To add a new phase: create a file in pipeline-phases/, export the phase

package/dist/core/ingestion/pipeline.js

@@ -16,7 +16,7 @@
  */
 import { createKnowledgeGraph } from '../graph/graph.js';
 import { GraphEmitSink } from '../lbug/graph-emit-sink.js';
-import { runPipeline, getPhaseOutput, scanPhase, structurePhase, markdownPhase, cobolPhase, parsePhase, routesPhase, toolsPhase, ormPhase, crossFilePhase, scopeResolutionPhase, springConfigPhase, springAutoConfigurationPhase, springAopPhase, springAopInheritancePhase, pruneLocalSymbolsPhase, taintSummariesPhase, callSummariesPhase, mroPhase, diPhase, communitiesPhase, processesPhase, PhaseRegistry, } from './pipeline-phases/index.js';
+import { runPipeline, getPhaseOutput, scanPhase, structurePhase, markdownPhase, cobolPhase, parsePhase, routesPhase, toolsPhase, ormPhase, crossFilePhase, scopeResolutionPhase, springConfigPhase, springAutoConfigurationPhase, springAopPhase, springDestinationsPhase, springAopInheritancePhase, pruneLocalSymbolsPhase, taintSummariesPhase, callSummariesPhase, mroPhase, diPhase, communitiesPhase, processesPhase, PhaseRegistry, } from './pipeline-phases/index.js';
 // ── Phase registry ─────────────────────────────────────────────────────────
 /**
  * All pipeline phases with their dependency relationships.
@@ -24,7 +24,8 @@ import { runPipeline, getPhaseOutput, scanPhase, structurePhase, markdownPhase,
  * Phase dependency graph:
  *
  *   scan → structure → [springConfig, markdown, cobol] → parse → [routes, tools, orm]
- *     → crossFile → scopeResolution → [springAutoConfiguration, springAop] → pruneLocalSymbols
+ *     → crossFile → scopeResolution → [springAutoConfiguration, springAop,
+ *       springDestinations] → pruneLocalSymbols
  *     → mro → springAopInheritance → di → communities → processes
  *
  * To add a new phase: create a file in pipeline-phases/, export the phase
@@ -52,6 +53,11 @@ export function buildPhaseList(options) {
         .register(scopeResolutionPhase)
         .register(springAutoConfigurationPhase)
         .register(springAopPhase)
+        // Async messaging overlay. Must follow scopeResolution twice over: the
+        // owner Method/Function nodes have to exist, and each provider's
+        // `applyCaptureSideChannel` has to have restored the messaging facts onto
+        // the main thread. It also reads the Property nodes springConfig emits.
+        .register(springDestinationsPhase)
         .register(pruneLocalSymbolsPhase)
         // M4 (#2084): interprocedural taint fixpoint — the first real opt-in
         // pdg-gated phase. Off ⇒ absent ⇒ byte-identical graph. No always-on
@@ -61,8 +67,12 @@ export function buildPhaseList(options) {
         .register(mroPhase, { enabledWhen: (o) => !o.skipGraphPhases })
         .register(springAopInheritancePhase, { enabledWhen: (o) => !o.skipGraphPhases })
         .register(diPhase, { enabledWhen: (o) => !o.skipGraphPhases })
-        .register(communitiesPhase, { enabledWhen: (o) => !o.skipGraphPhases })
-        .register(processesPhase, { enabledWhen: (o) => !o.skipGraphPhases })
+        .register(communitiesPhase, {
+        enabledWhen: (o) => !o.skipGraphPhases && o.skipDerivedGraphPhases !== true,
+    })
+        .register(processesPhase, {
+        enabledWhen: (o) => !o.skipGraphPhases && o.skipDerivedGraphPhases !== true,
+    })
         // Normalize a missing options object once here so phase predicates above
         // take a required PipelineOptions and need no `?.` guard (#2080 review S1).
         .build(options ?? {}));
@@ -91,17 +101,18 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         graphEmitSink = new GraphEmitSink(graph, options.graphEmitCsvDir);
     }
     const phases = buildPhaseList(options);
+    const ctx = {
+        repoPath,
+        graph: graphEmitSink ?? graph,
+        onProgress,
+        options,
+        pipelineStart,
+        graphEmit: graphEmitSink,
+    };
     let graphEmitManifest;
     let results;
     try {
-        results = await runPipeline(phases, {
-            repoPath,
-            graph: graphEmitSink ?? graph,
-            onProgress,
-            options,
-            pipelineStart,
-            graphEmit: graphEmitSink,
-        });
+        results = await runPipeline(phases, ctx);
         graphEmitManifest = graphEmitSink?.finalize();
     }
     finally {
@@ -109,7 +120,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         graphEmitSink?.close();
     }
     // Extract final results for the PipelineResult contract
-    const { totalFiles, usedWorkerPool, reparsedFileCount, unavailableScopeLanguageFiles } = getPhaseOutput(results, 'parse');
+    const { totalFiles, usedWorkerPool, reparsedFileCount, parseCacheHitFileCount, unavailableScopeLanguageFiles, } = getPhaseOutput(results, 'parse');
     let communityResult;
     let processResult;
     const scopeResolutionOutput = getPhaseOutput(results, 'scopeResolution');
@@ -140,7 +151,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             nodesCreated: graph.nodeCount,
         },
     });
-    return {
+    const result = {
         // The RAW graph, deliberately — NOT `graphEmitSink`. Phases above received
         // the sink so their reads are complete, but `loadGraphToLbug` feeds this to
         // `streamAllCSVsToDisk`, and the sink's complete iterator would then emit
@@ -157,9 +168,36 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         undecidedSatisfaction,
         usedWorkerPool,
         reparsedFileCount,
+        parseCacheHitFileCount,
         scopeExtractionFailures,
         unavailableScopeLanguageFiles,
         pdgEmitManifest,
         propertyInference,
     };
+    // #3016: hand back a way to run the derived phases `skipDerivedGraphPhases`
+    // held back. Which phases those are is answered by re-asking the registry
+    // with only that flag cleared — the one form of the question that stays
+    // correct when a different predicate (`skipGraphPhases`) also disables them,
+    // since then they are absent for a reason a deferred run cannot fix and the
+    // filter yields nothing. The sink guard mirrors the `graph` note above: a
+    // streaming run is a full rebuild, which never sets the skip flag, so an
+    // active sink here means the two got combined by mistake — and deferred
+    // phases writing into a finalized sink would emit past its manifest.
+    const deferredDerivedPhases = options?.skipDerivedGraphPhases === true && graphEmitSink === undefined
+        ? buildPhaseList({ ...options, skipDerivedGraphPhases: false }).filter((p) => (p.name === 'communities' || p.name === 'processes') && !results.has(p.name))
+        : [];
+    if (deferredDerivedPhases.length > 0) {
+        result.runDeferredDerivedPhases = async () => {
+            const derived = await runPipeline(deferredDerivedPhases, ctx, results);
+            // Presence-checked for the same reason as the block above: a phase the
+            // registry filtered out is absent, and `getPhaseOutput` throws on absent.
+            if (derived.has('communities')) {
+                result.communityResult = getPhaseOutput(derived, 'communities').communityResult;
+            }
+            if (derived.has('processes')) {
+                result.processResult = getPhaseOutput(derived, 'processes').processResult;
+            }
+        };
+    }
+    return result;
 };

package/dist/core/ingestion/resolve-references.js

@@ -252,6 +252,11 @@ function buildReference(site, top) {
         toDef: top.def.nodeId,
         atRange: site.atRange,
         kind: site.kind,
+        // The call form survives resolution so the graph bridge can mark
+        // construction sites (`callForm: 'constructor'`) on the CALLS edge it
+        // emits — a `Reference` otherwise keeps only the resolved def.
+        ...(site.kind === 'call' && site.callForm !== undefined ? { callForm: site.callForm } : {}),
+        ...(site.kind === 'call' && site.staticGated === true ? { staticGated: true } : {}),
         confidence: top.confidence,
         evidence: top.evidence,
     };

package/dist/core/ingestion/route-extractors/constant-resolver.d.ts

@@ -62,7 +62,23 @@ export interface ModuleConstants {
     readonly literals: Map<string, string>;
     readonly exprs: Map<string, readonly Operand[]>;
     readonly imports: Map<string, ImportBinding>;
+    /**
+     * On-demand (wildcard) import specifiers whose bound member names could not
+     * be enumerated at extract time — Java `import static a.b.C.*;`, Python
+     * `from m import *`. The agnostic fold never reads this (it has no way to
+     * enumerate a target module's exports); a language binding materializes the
+     * promised bindings from a repo-wide map after extraction — see
+     * `expandJavaWildcardStaticImports` in the Java binding — so they resolve
+     * through the plain `imports` path with no special cases in the fold.
+     */
+    readonly wildcardImports?: readonly string[];
 }
+/**
+ * Declaration keys a language extractor found but could not fold. Java and
+ * Kotlin both use this metadata to keep lower-priority imports from replacing
+ * a real local declaration; other producers simply return the empty set.
+ */
+export declare function unfoldableDeclarationsOf(mc: ModuleConstants | undefined): ReadonlySet<string>;
 /** Repo-wide map: unique file key (e.g. `app/constants.py`) → that file's
  * {@link ModuleConstants}. */
 export type RepoConstants = ReadonlyMap<string, ModuleConstants>;

package/dist/core/ingestion/route-extractors/constant-resolver.js

@@ -32,6 +32,16 @@ const MAX_RESOLVE_DEPTH = 8;
  * so we floor to `null` (skip) instead (#2393). The depth cap bounds recursion but
  * NOT output size, which grows multiplicatively; this bounds the output. */
 export const MAX_FOLD_LENGTH = 8192;
+const NO_UNFOLDABLE_DECLARATIONS = new Set();
+/**
+ * Declaration keys a language extractor found but could not fold. Java and
+ * Kotlin both use this metadata to keep lower-priority imports from replacing
+ * a real local declaration; other producers simply return the empty set.
+ */
+export function unfoldableDeclarationsOf(mc) {
+    const declarations = mc?.unfoldableDeclarations;
+    return declarations instanceof Set ? declarations : NO_UNFOLDABLE_DECLARATIONS;
+}
 /**
  * Fold an operand list to its concatenated literal, or `null` if any operand is
  * unresolvable (an unknown name, a non-string term, a cycle, or a depth overrun).

package/dist/core/ingestion/route-extractors/java-const-resolver.d.ts

@@ -42,6 +42,10 @@
 import type Parser from 'tree-sitter';
 import { type ImportResolver, type ModuleConstants, type Operand, type RepoConstants } from './constant-resolver.js';
 export type { ImportBinding, ModuleConstants, Operand, RepoConstants, } from './constant-resolver.js';
+export interface JavaModuleConstants extends ModuleConstants {
+    /** Declaration keys whose initializer exists but cannot be folded. */
+    readonly unfoldableDeclarations: ReadonlySet<string>;
+}
 export declare function isJavaConstantFile(source: string): boolean;
 /**
  * The Java {@link ImportResolver}: map a fully-qualified import specifier to
@@ -96,7 +100,7 @@ export declare function parseJavaConstOperands(node: Parser.SyntaxNode | null |
  * Last-wins in source order; a non-foldable rebind (`X = compute()`) drops X
  * to unresolvable rather than keeping a stale literal.
  */
-export declare function extractJavaModuleConstants(tree: Parser.Tree): ModuleConstants;
+export declare function extractJavaModuleConstants(tree: Parser.Tree): JavaModuleConstants;
 /**
  * Resolve a single Java constant referenced in `fileKey` to its literal string
  * value, folding `+` concatenation and following import chains via
@@ -112,3 +116,25 @@ export declare function resolveJavaConstant(fileKey: string, name: string, repo:
  * `fileKey`, or null when any piece is unresolvable (skip floor).
  */
 export declare function foldJavaOperands(fileKey: string, operands: readonly Operand[], repo: RepoConstants): string | null;
+/**
+ * Constant-defining file keys used by Java import resolution.
+ *
+ * Build once per repo pass. Recomputing this set for every wildcard-importing
+ * controller makes expansion quadratic in controller count.
+ */
+export declare function buildJavaConstantKeys(repo: RepoConstants): ReadonlySet<string>;
+export interface JavaConstantIndex {
+    readonly keys: ReadonlySet<string>;
+    /** Every resolvable path suffix as a dotted module name; null means ambiguous. */
+    readonly byModule: ReadonlyMap<string, string | null>;
+    /** Direct members by constant-defining file, built once for all importers. */
+    readonly membersByFile: ReadonlyMap<string, ReadonlySet<string>>;
+}
+/**
+ * Build all Java import suffixes once, turning repeated wildcard target lookup
+ * from O(importers × constant files) into O(path segments + importers).
+ */
+export declare function buildJavaConstantIndex(repo: RepoConstants): JavaConstantIndex;
+export declare function expandJavaWildcardStaticImports(mc: ModuleConstants, _fileKey: string, repo: RepoConstants, index?: JavaConstantIndex): ModuleConstants;
+/** Prepare every Java constants entry with one shared suffix index. */
+export declare function prepareJavaRouteConstants(repo: RepoConstants): JavaConstantIndex;

package/dist/core/ingestion/route-extractors/java-const-resolver.js

@@ -40,7 +40,7 @@
  * the import is ambiguous and returns null (skip floor), never a wrong path.
  */
 import { unquoteSpringLiteral } from './spring-shared.js';
-import { MAX_FOLD_LENGTH, } from './constant-resolver.js';
+import { MAX_FOLD_LENGTH, unfoldableDeclarationsOf, } from './constant-resolver.js';
 /**
  * Cheap content gate: can this Java file DEFINE a string constant that a route
  * annotation might reference?
@@ -121,10 +121,15 @@ export const resolveJavaImport = (_importingFileKey, moduleSpec, repoKeys) => {
     // trimming the last segment when the direct hit fails covers both shapes.
     const asPath = moduleSpec.replace(/\./g, '/');
     const classFile = `${asPath}.java`;
+    // Compare in POSIX space: on Windows the repo keys can carry backslash
+    // separators, which would otherwise never match a '/'-joined class file
+    // (observed as 675 calls with zero hits on a backslash-keyed repo).
+    const toPosix = (p) => p.replace(/\\/g, '/');
     // Exact package-path suffix match, unique or nothing.
     let hit = null;
     for (const key of repoKeys) {
-        if (key === classFile || key.endsWith(`/${classFile}`)) {
+        const posixKey = toPosix(key);
+        if (posixKey === classFile || posixKey.endsWith(`/${classFile}`)) {
             if (hit !== null)
                 return null; // 2+ modules carry this FQN — unresolvable
             hit = key;
@@ -251,25 +256,48 @@ export function extractJavaModuleConstants(tree) {
     const literals = new Map();
     const exprs = new Map();
     const imports = new Map();
+    const unfoldableDeclarations = new Set();
+    // On-demand static imports (`import static a.b.C.*`) — expanded post-map
+    // by expandJavaWildcardStaticImports below.
+    const wildcardImports = [];
     // Pass 1: imports (both shapes).
     const walkImports = (node) => {
         if (node.type === 'import_declaration') {
             // import a.b.C;  |  import static a.b.C;  |  import static a.b.C.F;
+            // import static a.b.C.*;  — asterisk is a sibling of scoped_identifier
+            // (tree-sitter-java), not the last path segment. Same detection as
+            // import-decomposer.ts (`static-wildcard`).
             const isStatic = node.children.some((c) => c.type === 'static' && c.text === 'static');
-            const scoped = node.children.find((c) => c.type === 'scoped_identifier');
+            const isWildcard = node.children.some((c) => c.type === 'asterisk');
+            const scoped = node.children.find((c) => c.type === 'scoped_identifier') ??
+                node.children.find((c) => c.type === 'identifier');
             if (scoped) {
                 const text = scoped.text;
-                const lastDot = text.lastIndexOf('.');
-                const fqn = text.slice(0, lastDot);
-                const name = text.slice(lastDot + 1);
-                if (isStatic) {
-                    // import static a.b.C.F → local F from module a.b.C, original F.
-                    imports.set(name, { module: fqn, originalName: name });
+                if (isStatic && isWildcard) {
+                    // Class FQN only — members are materialized post-map.
+                    if (text.length > 0 && !wildcardImports.includes(text)) {
+                        wildcardImports.push(text);
+                    }
                 }
                 else {
-                    // import a.b.C → module IS the class FQN; originalName is the class
-                    // simple name. resolveJavaImport maps `a.b.C` → `a/b/C.java`.
-                    imports.set(name, { module: text, originalName: name });
+                    const lastDot = text.lastIndexOf('.');
+                    const fqn = text.slice(0, lastDot);
+                    const name = text.slice(lastDot + 1);
+                    if (isStatic) {
+                        // Preserve the declaring type in the target lookup. Constants from
+                        // multiple types share one file-level map, so a bare `F` could
+                        // otherwise resolve to a sibling type's flattened field.
+                        const declaringClass = fqn.slice(fqn.lastIndexOf('.') + 1);
+                        imports.set(name, {
+                            module: fqn,
+                            originalName: `${declaringClass}.${name}`,
+                        });
+                    }
+                    else {
+                        // import a.b.C → module IS the class FQN; originalName is the class
+                        // simple name. resolveJavaImport maps `a.b.C` → `a/b/C.java`.
+                        imports.set(name, { module: text, originalName: name });
+                    }
                 }
             }
         }
@@ -328,6 +356,7 @@ export function extractJavaModuleConstants(tree) {
                 if (operands === null) {
                     literals.delete(name);
                     exprs.delete(name);
+                    unfoldableDeclarations.add(name);
                     // …and the static IMPORT of the same simple name. A local
                     // `static final String` shadows `import static a.b.C.PATH` inside
                     // that class (JLS 6.4.1), so the correct answer for a non-foldable
@@ -348,9 +377,13 @@ export function extractJavaModuleConstants(tree) {
                     if (qname) {
                         literals.delete(qname);
                         exprs.delete(qname);
+                        unfoldableDeclarations.add(qname);
                     }
                     continue;
                 }
+                unfoldableDeclarations.delete(name);
+                if (qname)
+                    unfoldableDeclarations.delete(qname);
                 const literalValue = operands.length === 1 && operands[0].kind === 'literal'
                     ? operands[0].value
                     : null;
@@ -419,7 +452,13 @@ export function extractJavaModuleConstants(tree) {
         }
     };
     walkTypes(tree.rootNode, false);
-    return { literals, exprs, imports: imports };
+    return {
+        literals,
+        exprs,
+        imports: imports,
+        wildcardImports,
+        unfoldableDeclarations,
+    };
 }
 function newFoldState(repo) {
     const constantKeys = new Set();
@@ -524,6 +563,8 @@ function computeJavaFold(fileKey, name, state, depth) {
     const expr = mc.exprs.get(name);
     if (expr !== undefined)
         return foldOperands(fileKey, expr, state, depth + 1);
+    if (unfoldableDeclarationsOf(mc).has(name))
+        return null;
     const imp = mc.imports.get(name);
     if (imp !== undefined) {
         const targetFile = resolveJavaImport(fileKey, imp.module, constantKeys);
@@ -567,3 +608,110 @@ export function foldJavaOperands(fileKey, operands, repo) {
     const out = foldOperands(fileKey, operands, newFoldState(repo), 0);
     return out === '' ? null : out;
 }
+/**
+ * Constant-defining file keys used by Java import resolution.
+ *
+ * Build once per repo pass. Recomputing this set for every wildcard-importing
+ * controller makes expansion quadratic in controller count.
+ */
+export function buildJavaConstantKeys(repo) {
+    const repoKeys = new Set();
+    for (const [key, target] of repo) {
+        if (target.literals.size > 0 || target.exprs.size > 0)
+            repoKeys.add(key);
+    }
+    return repoKeys;
+}
+/** Direct static members owned by `classSimple`, excluding nested-type members. */
+function directJavaMembers(target, classSimple) {
+    const members = new Set();
+    const prefix = `${classSimple}.`;
+    for (const map of [target.literals, target.exprs]) {
+        for (const key of map.keys()) {
+            if (!key.startsWith(prefix))
+                continue;
+            const member = key.slice(prefix.length);
+            if (member.length > 0 && !member.includes('.'))
+                members.add(member);
+        }
+    }
+    return members;
+}
+/**
+ * Build all Java import suffixes once, turning repeated wildcard target lookup
+ * from O(importers × constant files) into O(path segments + importers).
+ */
+export function buildJavaConstantIndex(repo) {
+    const keys = buildJavaConstantKeys(repo);
+    const byModule = new Map();
+    const membersByFile = new Map();
+    for (const key of keys) {
+        const normalized = key.replace(/\\/g, '/').replace(/^\.\//, '');
+        if (!normalized.endsWith('.java'))
+            continue;
+        const segments = normalized.slice(0, -'.java'.length).split('/');
+        const classSimple = segments[segments.length - 1];
+        const constants = repo.get(key);
+        if (constants)
+            membersByFile.set(key, directJavaMembers(constants, classSimple));
+        for (let start = 0; start < segments.length; start++) {
+            const moduleName = segments.slice(start).join('.');
+            const existing = byModule.get(moduleName);
+            if (existing === undefined)
+                byModule.set(moduleName, key);
+            else if (existing !== key)
+                byModule.set(moduleName, null);
+        }
+    }
+    return { keys, byModule, membersByFile };
+}
+export function expandJavaWildcardStaticImports(mc, _fileKey, repo, index = buildJavaConstantIndex(repo)) {
+    const wildcards = mc.wildcardImports;
+    if (!wildcards || wildcards.length === 0)
+        return mc;
+    // Resolve targets against constant-DEFINING files only. Ingestion's harvest
+    // also admits import-only files; measuring uniqueness over every key made
+    // a duplicate empty FQN floor ingestion to skip while group still folded
+    // (#2980 R4).
+    const explicitImports = new Set(mc.imports.keys());
+    const pending = new Map();
+    for (const fqn of wildcards) {
+        const targetKey = index.byModule.get(fqn) ?? null;
+        if (targetKey === null)
+            continue;
+        const classSimple = fqn.slice(fqn.lastIndexOf('.') + 1);
+        const members = index.membersByFile.get(targetKey);
+        if (!members)
+            continue;
+        for (const name of members) {
+            // Same-file declarations and explicit imports have higher precedence
+            // than on-demand imports. An unfoldable declaration must remain a skip,
+            // not be resurrected from a wildcard target.
+            if (mc.literals.has(name) ||
+                mc.exprs.has(name) ||
+                unfoldableDeclarationsOf(mc).has(name) ||
+                explicitImports.has(name)) {
+                continue;
+            }
+            const binding = { module: fqn, originalName: `${classSimple}.${name}` };
+            const previous = pending.get(name);
+            if (previous === undefined)
+                pending.set(name, binding);
+            else if (previous !== null && previous.module !== fqn)
+                pending.set(name, null);
+        }
+    }
+    for (const [name, binding] of pending) {
+        if (binding !== null)
+            mc.imports.set(name, binding);
+    }
+    return mc;
+}
+/** Prepare every Java constants entry with one shared suffix index. */
+export function prepareJavaRouteConstants(repo) {
+    const index = buildJavaConstantIndex(repo);
+    for (const [fileKey, mc] of repo) {
+        expandJavaWildcardStaticImports(mc, fileKey, repo, index);
+    }
+    return index;
+}

package/dist/core/ingestion/route-extractors/kotlin-const-resolver.d.ts

@@ -95,6 +95,7 @@
  *   @PostMapping(ApiPaths.ORDERS)                      // qualified
  *   @PostMapping(com.example.app.api.ApiPaths.ORDERS)  // FQN-qualified
  *   @PostMapping(ORDERS)                               // single-name import
+ *   @PostMapping(ORDERS) after import com.example.api.* // package-star import
  *   @PostMapping(ApiPaths.BASE + "/orders")            // inline concat
  *
  * Which ANNOTATIONS count as routes is a separate question this module has no
@@ -122,20 +123,16 @@
  *
  * WHERE THIS IS WIRED. Java reaches its binding from BOTH layers: the group
  * extractor (`group/extractors/http-patterns/java.ts`) and the ingestion
- * provider (`languages/java.ts`, via `extractModuleConstants` +
- * `foldRoutePathOperands`). Kotlin is wired into the GROUP layer only, because
- * the ingestion fold in `pipeline-phases/parse-impl.ts` runs exclusively over
- * `decoratorRoutes` — and `languages/kotlin.ts` declares no
- * `extractDecoratorRoutes`, since the ingestion Spring extractor (`spring.ts`)
- * is bound to `tree-sitter-java` and its node types. Declaring the constant
- * hooks on the Kotlin provider today would harvest a map on every Kotlin file
- * that nothing consumes. An ingestion-side Kotlin route extractor is the
- * prerequisite; when it lands, this binding is what its provider hooks should
- * point at, and no change here is needed.
+ * provider (`languages/java.ts`). Kotlin now does the same: the group extractor
+ * (`group/extractors/http-patterns/kotlin.ts`) plus `languages/kotlin.ts`
+ * (`extractDecoratorRoutes`, `extractModuleConstants`, `foldRoutePathOperands`).
+ * The dedicated ingestion walker is `route-extractors/kotlin-spring.ts`; it
+ * does not reuse Java `spring.ts`.
  */
 import type Parser from 'tree-sitter';
 import { type ModuleConstants, type Operand, type RepoConstants } from './constant-resolver.js';
 export type { ImportBinding, ModuleConstants, Operand, RepoConstants, } from './constant-resolver.js';
+export { unfoldableDeclarationsOf } from './constant-resolver.js';
 /**
  * What {@link extractKotlinModuleConstants} returns: the agnostic
  * {@link ModuleConstants} plus the one piece of per-file metadata JVM import
@@ -162,12 +159,9 @@ export interface KotlinModuleConstants extends ModuleConstants {
     readonly packageName: string;
     /** Declaration keys whose initializer cannot be folded. */
     readonly unfoldableDeclarations: ReadonlySet<string>;
+    /** Top-level properties and types that shadow lower-priority star imports. */
+    readonly topLevelDeclarations: ReadonlySet<string>;
 }
-/**
- * Kotlin declaration keys known to exist but not fold, or an empty set when
- * `mc` came from another language binding.
- */
-export declare function unfoldableDeclarationsOf(mc: ModuleConstants | undefined): ReadonlySet<string>;
 /**
  * The name a backtick-quoted Kotlin identifier denotes: `` `api` `` → `api`.
  *
@@ -294,9 +288,9 @@ export declare function resolveKotlinImportWithIndex(rawModuleSpec: string, inde
  */
 export declare function parseKotlinConstOperands(node: Parser.SyntaxNode | null | undefined, depth?: number): Operand[] | null;
 /**
- * Extract the declared package, file-level string constants and import bindings
- * of one parsed Kotlin file into the {@link KotlinModuleConstants} shape the
- * resolver consumes.
+ * Extract the declared package, file-level string constants, named imports and
+ * package-star import scopes of one parsed Kotlin file into the
+ * {@link KotlinModuleConstants} shape the resolver consumes.
  *
  * Constants come from the three carriers Kotlin allows a caller to reach without
  * an instance: file top level, `object` members, and `companion object` members.