gitnexus 1.6.11-rc.20 → 1.6.11-rc.22

package/dist/core/group/extractors/http-patterns/java.js

@@ -2,7 +2,7 @@ import Java from 'tree-sitter-java';
 import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-sitter-scanner.js';
 import { springAnnotationHttpMethods, intersectSpringHttpMethods, isRouteMemberKey, findEnclosingClass, joinPath, } from '../../../ingestion/route-extractors/spring-shared.js';
 import { REST_TEMPLATE_TO_HTTP, WEB_CLIENT_SHORT_TO_HTTP, WEB_CLIENT_LONG_VERB_RE, EXCHANGE_ANNOTATION_TO_HTTP, parseRequestLine, pushPrefix, scanSpringInheritanceProject, OPENFEIGN_FRAMEWORK, HTTP_INTERFACE_FRAMEWORK, FEIGN_CONFIDENCE, REQUEST_LINE_CONFIDENCE, EXCHANGE_CONFIDENCE, } from './spring-consumer-shared.js';
-import { extractJavaModuleConstants, foldJavaOperands, isJavaConstantFile, parseJavaConstOperands, } from '../../../ingestion/route-extractors/java-const-resolver.js';
+import { expandJavaWildcardStaticImports, extractJavaModuleConstants, foldJavaOperands, isJavaConstantFile, parseJavaConstOperands, prepareJavaRouteConstants, } from '../../../ingestion/route-extractors/java-const-resolver.js';
 import { extractStaticPathExpression, inferOkHttpMethod, inferHttpClientMethod, okHttpUrlRootsAtBuilder, httpClientUriRootsAtNewBuilder, httpClientChainHasUriCall, } from './java-static-path.js';
 /**
  * Java HTTP plugin. Handles:
@@ -789,7 +789,10 @@ export const JAVA_HTTP_PLUGIN = {
                 if (!tree)
                     continue;
                 const mc = extractJavaModuleConstants(tree);
-                if (mc.literals.size > 0 || mc.exprs.size > 0 || mc.imports.size > 0) {
+                if (mc.literals.size > 0 ||
+                    mc.exprs.size > 0 ||
+                    mc.imports.size > 0 ||
+                    (mc.wildcardImports?.length ?? 0) > 0) {
                     constants.set(rel, mc);
                 }
             }
@@ -800,7 +803,14 @@ export const JAVA_HTTP_PLUGIN = {
                 continue;
             }
         }
-        return { constants };
+        // On-demand static imports (`import static a.b.C.*`) were recorded as
+        // pending class FQNs during extraction; materialize their bare-name
+        // bindings now that the whole map exists. A wildcard's target is itself
+        // a constants file, so it is necessarily a map entry — anything else
+        // degrades to the fold's skip floor. In-place: each entry is owned by
+        // this map, and every file is expanded exactly once.
+        const constantIndex = prepareJavaRouteConstants(constants);
+        return { constants, constantIndex };
     },
     scan(tree, repoContext, fileRel) {
         const out = [];
@@ -832,8 +842,12 @@ export const JAVA_HTTP_PLUGIN = {
                 return foldConstants;
             try {
                 const mc = extractJavaModuleConstants(tree);
-                if (mc.imports.size > 0) {
+                // A file carrying ONLY wildcard static imports has an empty import
+                // table pre-expansion — overlay it too, then materialize the promised
+                // bindings against the repo map before it becomes a fold target.
+                if (mc.imports.size > 0 || (mc.wildcardImports?.length ?? 0) > 0) {
                     const merged = new Map(javaCtx.constants);
+                    expandJavaWildcardStaticImports(mc, fileRel, merged, javaCtx.constantIndex);
                     merged.set(fileRel, mc);
                     foldConstants = merged;
                 }

package/dist/core/group/extractors/http-patterns/kotlin.js

@@ -1260,6 +1260,7 @@ function buildKotlinPlugin(language) {
                     if (mc.literals.size > 0 ||
                         mc.exprs.size > 0 ||
                         mc.imports.size > 0 ||
+                        (mc.wildcardImports?.length ?? 0) > 0 ||
                         unfoldableDeclarationsOf(mc).size > 0) {
                         // POSIX key (see `normalizeRel`); `readFile` above got the raw `rel`.
                         constants.set(normalizeRel(rel), mc);
@@ -1303,6 +1304,7 @@ function buildKotlinPlugin(language) {
                     if (mc.literals.size > 0 ||
                         mc.exprs.size > 0 ||
                         mc.imports.size > 0 ||
+                        (mc.wildcardImports?.length ?? 0) > 0 ||
                         unfoldableDeclarationsOf(mc).size > 0) {
                         foldIndex = overlayKotlinConstantIndex(kotlinCtx.index, fileKey, mc);
                     }

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

@@ -372,6 +372,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 +732,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.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';
@@ -202,11 +202,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/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/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
@@ -136,6 +137,7 @@
 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 +164,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 +293,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.

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

@@ -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
@@ -134,7 +135,8 @@
  * point at, and no change here is needed.
  */
 import { unquoteSpringLiteral } from './spring-shared.js';
-import { MAX_FOLD_LENGTH, } from './constant-resolver.js';
+import { MAX_FOLD_LENGTH, unfoldableDeclarationsOf, } from './constant-resolver.js';
+export { unfoldableDeclarationsOf } from './constant-resolver.js';
 /**
  * The declared `package` of the file `mc` describes, or null when the entry did
  * not come from {@link extractKotlinModuleConstants} and therefore cannot be
@@ -144,14 +146,11 @@ function declaredPackageOf(mc) {
     const declared = mc?.packageName;
     return typeof declared === 'string' ? declared : null;
 }
-const NO_UNFOLDABLE_DECLARATIONS = new Set();
-/**
- * Kotlin declaration keys known to exist but not fold, or an empty set when
- * `mc` came from another language binding.
- */
-export function unfoldableDeclarationsOf(mc) {
-    const declarations = mc?.unfoldableDeclarations;
-    return declarations instanceof Set ? declarations : NO_UNFOLDABLE_DECLARATIONS;
+const NO_TOP_LEVEL_DECLARATIONS = new Set();
+/** Kotlin top-level names known to shadow package-star imports. */
+function topLevelDeclarationsOf(mc) {
+    const declarations = mc?.topLevelDeclarations;
+    return declarations instanceof Set ? declarations : NO_TOP_LEVEL_DECLARATIONS;
 }
 /** Source extensions a Kotlin declaration can live in. */
 const KOTLIN_EXTENSIONS = ['.kt', '.kts'];
@@ -365,6 +364,13 @@ function declaresTopLevelName(mc, name) {
 }
 /** Does this file contribute declarations to Kotlin import ambiguity? */
 function contributesKotlinConstants(mc) {
+    return (mc.literals.size > 0 ||
+        mc.exprs.size > 0 ||
+        unfoldableDeclarationsOf(mc).size > 0 ||
+        topLevelDeclarationsOf(mc).size > 0);
+}
+/** Foldable or explicitly unfoldable constants that must live in index projections. */
+function hasIndexedConstants(mc) {
     return mc.literals.size > 0 || mc.exprs.size > 0 || unfoldableDeclarationsOf(mc).size > 0;
 }
 /** Top-level names declared by one file (`Outer.X` contributes `Outer`). */
@@ -380,6 +386,8 @@ function topLevelDeclarationNames(mc) {
         const dot = key.indexOf('.');
         names.add(dot < 0 ? key : key.slice(0, dot));
     }
+    for (const name of topLevelDeclarationsOf(mc))
+        names.add(name);
     return names;
 }
 /** Every declaration key recorded for a file, foldable or not. */
@@ -428,17 +436,71 @@ export function buildKotlinConstantIndex(repo) {
     }
     return { repo, constantKeys, byPackage: mutablePackages, byFqn };
 }
+/** Read-only one-entry overlay without copying the repo-wide constant map. */
+class KotlinConstantOverlay {
+    base;
+    overlayKey;
+    overlayValue;
+    [Symbol.toStringTag] = 'KotlinConstantOverlay';
+    constructor(base, overlayKey, overlayValue) {
+        this.base = base;
+        this.overlayKey = overlayKey;
+        this.overlayValue = overlayValue;
+    }
+    get size() {
+        return this.base.size + (this.base.has(this.overlayKey) ? 0 : 1);
+    }
+    get(key) {
+        return key === this.overlayKey ? this.overlayValue : this.base.get(key);
+    }
+    has(key) {
+        return key === this.overlayKey || this.base.has(key);
+    }
+    *entries() {
+        let replaced = false;
+        for (const [key, value] of this.base) {
+            if (key === this.overlayKey) {
+                replaced = true;
+                yield [key, this.overlayValue];
+            }
+            else {
+                yield [key, value];
+            }
+        }
+        if (!replaced)
+            yield [this.overlayKey, this.overlayValue];
+    }
+    *keys() {
+        for (const [key] of this.entries())
+            yield key;
+    }
+    *values() {
+        for (const [, value] of this.entries())
+            yield value;
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    forEach(callbackfn, thisArg) {
+        for (const [key, value] of this.entries())
+            callbackfn.call(thisArg, value, key, this);
+    }
+}
 /**
  * Add one scan-time file without rebuilding the base index when it only imports
  * constants. A newly discovered declaration is rare and rebuilds once for that
  * file's scan, never once per route.
  */
 export function overlayKotlinConstantIndex(index, fileKey, mc) {
+    // Same-file shadows are read from `mc` itself. Rebuild only when this key's
+    // constant projections would change; a controller with a class name but no
+    // foldable constants stays on the overlay so scan stays linear.
+    const existing = index.repo.get(fileKey);
+    if (!hasIndexedConstants(mc) && (!existing || !hasIndexedConstants(existing))) {
+        return { ...index, repo: new KotlinConstantOverlay(index.repo, fileKey, mc) };
+    }
     const repo = new Map(index.repo);
-    const replacing = repo.has(fileKey);
     repo.set(fileKey, mc);
-    if (!replacing && !contributesKotlinConstants(mc))
-        return { ...index, repo };
     return buildKotlinConstantIndex(repo);
 }
 /**
@@ -728,9 +790,9 @@ function declaredPackage(root) {
         .join('.');
 }
 /**
- * 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.
@@ -777,20 +839,26 @@ export function extractKotlinModuleConstants(tree) {
     const literals = new Map();
     const exprs = new Map();
     const imports = new Map();
+    const wildcardImports = [];
     const unfoldableDeclarations = new Set();
+    const topLevelDeclarations = new Set();
     // Pass 1: imports.
     const walkImports = (node) => {
         if (node.type === 'import_header') {
-            // `import a.b.*` binds no single name — nothing to key the fold on, and
-            // guessing which package member a bare reference came from is exactly the
-            // wrong answer. Skipped, so such a reference floors to skip.
             const isWildcard = node.children.some((c) => c.type === 'wildcard_import');
             const identifier = node.children.find((c) => c.type === 'identifier');
-            if (!isWildcard && identifier) {
+            if (identifier) {
                 const segments = identifier.namedChildren
                     .filter((c) => c.type === 'simple_identifier')
                     .map((c) => unquoteKotlinIdentifier(c.text));
-                if (segments.length >= 2) {
+                if (isWildcard) {
+                    // Package star (`pkg.*`) or classifier star (`Type.*`). Resolution
+                    // decides which reading the specifier actually names.
+                    const scope = segments.join('.');
+                    if (scope.length > 0 && !wildcardImports.includes(scope))
+                        wildcardImports.push(scope);
+                }
+                else if (segments.length >= 2) {
                     const spec = segments.join('.');
                     const originalName = segments[segments.length - 1];
                     const aliasNode = node.children
@@ -859,6 +927,25 @@ export function extractKotlinModuleConstants(tree) {
     };
     /** Prepend a qualified scope unless it is already the innermost scope. */
     const withScope = (scope, scopes) => scope === null || scopes[0] === scope ? scopes : [scope, ...scopes];
+    // Package-star imports have lower priority than declarations in this file,
+    // including declarations the string-constant extractor intentionally does
+    // not harvest (a `var`, plain class, or unfoldable property). Record their
+    // names separately so a star import cannot turn one of those shadows into a
+    // false route constant.
+    for (const child of tree.rootNode.children ?? []) {
+        if (child.type === 'property_declaration') {
+            const declaration = child.children.find((c) => c.type === 'variable_declaration');
+            const name = declaration?.namedChildren.find((c) => c.type === 'simple_identifier');
+            if (name)
+                topLevelDeclarations.add(unquoteKotlinIdentifier(name.text));
+            continue;
+        }
+        if (child.type === 'object_declaration' || child.type === 'class_declaration') {
+            const name = child.children.find((c) => c.type === 'type_identifier');
+            if (name)
+                topLevelDeclarations.add(unquoteKotlinIdentifier(name.text));
+        }
+    }
     const walkDeclarations = (node, enclosingType, scopes) => {
         for (const child of node.children ?? []) {
             if (child.type === 'object_declaration') {
@@ -958,8 +1045,10 @@ export function extractKotlinModuleConstants(tree) {
         literals,
         exprs,
         imports,
+        wildcardImports,
         packageName: declaredPackage(tree.rootNode),
         unfoldableDeclarations,
+        topLevelDeclarations,
     };
 }
 function newFoldState(repo, index) {
@@ -1032,8 +1121,81 @@ function resolveImportedName(fileKey, imp, state, depth) {
         return null;
     return resolveWithState(owner.fileKey, `${owner.localName}.${imp.originalName}`, state, depth);
 }
+/**
+ * Resolve one name contributed by Kotlin star imports.
+ *
+ * Star imports have lower priority than local declarations and explicit
+ * imports; callers enforce that ordering before reaching this helper. A name
+ * must identify one declaration across every imported scope. Two stars
+ * exporting the same name, a duplicated FQN, or a package and a classifier
+ * that disagree on the target, floor to null rather than guessing.
+ *
+ * A specifier is tried as a package (`import pkg.*`) and as a classifier
+ * (`import Type.*` — object, class, or companion members). Kotlin allows both.
+ */
+function resolveKotlinWildcardImportTarget(mc, name, index) {
+    const scopes = mc.wildcardImports;
+    if (!scopes || scopes.length === 0)
+        return null;
+    let resolved = null;
+    for (const rawScope of scopes) {
+        const scope = unquoteKotlinDottedName(rawScope);
+        const candidates = [];
+        const bucket = index.byPackage.get(scope);
+        if (bucket?.declarers.has(name)) {
+            const fileKey = bucket.declarers.get(name);
+            if (fileKey === null || fileKey === undefined)
+                return null;
+            candidates.push({ fileKey, localName: name });
+        }
+        const owner = index.byFqn.get(scope);
+        if (owner === null)
+            return null;
+        if (owner !== undefined) {
+            const localName = `${owner.localName}.${name}`;
+            const target = index.repo.get(owner.fileKey);
+            if (target &&
+                (target.literals.has(localName) ||
+                    target.exprs.has(localName) ||
+                    unfoldableDeclarationsOf(target).has(localName))) {
+                candidates.push({ fileKey: owner.fileKey, localName });
+            }
+        }
+        for (const candidate of candidates) {
+            if (resolved !== null &&
+                (resolved.fileKey !== candidate.fileKey || resolved.localName !== candidate.localName)) {
+                return null;
+            }
+            resolved = candidate;
+        }
+    }
+    return resolved;
+}
+/**
+ * Resolve a top-level name visible from the importing file's own package.
+ * `undefined` means the package does not declare the name; `null` means it is
+ * ambiguous and must floor rather than fall through to a star import.
+ */
+function resolveKotlinSamePackageTarget(fileKey, name, index) {
+    const packageName = declaredPackageOf(index.repo.get(fileKey));
+    if (packageName === null)
+        return undefined;
+    const bucket = index.byPackage.get(packageName);
+    if (!bucket?.declarers.has(name))
+        return undefined;
+    const declaringFile = bucket.declarers.get(name);
+    if (declaringFile === null || declaringFile === undefined)
+        return null;
+    // Same-file literals, expressions, and shadows are handled before this step.
+    if (declaringFile === fileKey)
+        return undefined;
+    return { fileKey: declaringFile, localName: name };
+}
 function computeKotlinFold(fileKey, name, state, depth) {
     const { repo } = state.index;
+    const mc = repo.get(fileKey);
+    if (!mc)
+        return null;
     // Qualified reference (`ApiPaths.ORDERS`): constants and imports are keyed by
     // their IN-FILE name, so a dotted name never hits directly. Split head.tail,
     // resolve the head through the importing file's type import, then look the
@@ -1056,6 +1218,19 @@ function computeKotlinFold(fileKey, name, state, depth) {
             // uses the declaring type's real name.
             return resolveWithState(target.fileKey, `${target.localName}.${tail}`, state, depth + 1);
         }
+        // A same-file top-level declaration outranks every star import.
+        if (!topLevelDeclarationsOf(mc).has(head)) {
+            const samePackageTarget = resolveKotlinSamePackageTarget(fileKey, head, state.index);
+            if (samePackageTarget === null)
+                return null;
+            if (samePackageTarget !== undefined) {
+                return resolveWithState(samePackageTarget.fileKey, `${samePackageTarget.localName}.${tail}`, state, depth + 1);
+            }
+            const wildcardTarget = resolveKotlinWildcardImportTarget(mc, head, state.index);
+            if (wildcardTarget !== null) {
+                return resolveWithState(wildcardTarget.fileKey, `${wildcardTarget.localName}.${tail}`, state, depth + 1);
+            }
+        }
         // Un-imported qualified name (FQN form `com.example.app.api.ApiPaths.ORDERS`):
         // try the longest dotted prefix that resolves to a file.
         const parts = name.split('.');
@@ -1077,9 +1252,6 @@ function computeKotlinFold(fileKey, name, state, depth) {
     // an operand may itself be a QUALIFIED reference (`X = ApiPaths.Y + "/tail"`)
     // and the core only knows bare names: it would look `ApiPaths.Y` up in maps
     // keyed by simple name, miss, and floor the whole chain to null.
-    const mc = repo.get(fileKey);
-    if (!mc)
-        return null;
     const literal = mc.literals.get(name);
     if (literal !== undefined)
         return literal;
@@ -1089,6 +1261,20 @@ function computeKotlinFold(fileKey, name, state, depth) {
     const imp = mc.imports.get(name);
     if (imp !== undefined)
         return resolveImportedName(fileKey, imp, state, depth + 1);
+    // Any local declaration still shadows a lower-priority package-star import,
+    // including a var/plain type that is absent from the constant maps.
+    if (topLevelDeclarationsOf(mc).has(name) || unfoldableDeclarationsOf(mc).has(name))
+        return null;
+    const samePackageTarget = resolveKotlinSamePackageTarget(fileKey, name, state.index);
+    if (samePackageTarget === null)
+        return null;
+    if (samePackageTarget !== undefined) {
+        return resolveWithState(samePackageTarget.fileKey, samePackageTarget.localName, state, depth + 1);
+    }
+    const wildcardTarget = resolveKotlinWildcardImportTarget(mc, name, state.index);
+    if (wildcardTarget !== null) {
+        return resolveWithState(wildcardTarget.fileKey, wildcardTarget.localName, state, depth + 1);
+    }
     return null;
 }
 /**

package/dist/core/ingestion/workers/parse-worker.js

@@ -2328,7 +2328,10 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         // without booting a worker.
         if (provider.extractModuleConstants && shouldHarvestModuleConstants(provider, parseContent)) {
             const constants = provider.extractModuleConstants(tree);
-            if (constants.literals.size > 0 || constants.exprs.size > 0 || constants.imports.size > 0) {
+            if (constants.literals.size > 0 ||
+                constants.exprs.size > 0 ||
+                constants.imports.size > 0 ||
+                (constants.wildcardImports?.length ?? 0) > 0) {
                 (result.moduleConstants ??= []).push({ filePath: file.path, constants });
             }
         }

package/dist/storage/parse-cache.js

@@ -680,7 +680,14 @@ import { copyV8CacheIfPresent, tryLoadV8Cache, writeV8CacheFile } from './v8-sid
 // cache can replay stale names and declaration metadata.
 // 85 -> 86: Kotlin interface property accessors now record isAbstract on the
 // synthetic Method. A warm v85 cache replays them as concrete.
-const SCHEMA_BUMP = 86;
+// 86 -> 87: ModuleConstants gained wildcardImports (static-import-asterisk
+// materialization) — a warm v86 cache has no wildcard bindings, so folding
+// would skip them and drop wildcard-imported route constants. origin/main at
+// allocation is 86 (#2885).
+// 87 -> 88: Java ModuleConstants now preserves unfoldable declaration names
+// across worker/cache replay so wildcard expansion cannot resurrect an imported
+// member hidden by a local field. A warm v87 cache lacks that shadow metadata.
+const SCHEMA_BUMP = 88;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.11-rc.20",
+  "version": "1.6.11-rc.22",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",