gitnexus 1.6.11-rc.21 → 1.6.11-rc.22

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/mcp/local/local-backend.js

@@ -6783,6 +6783,17 @@ export class LocalBackend {
                 target: params.target,
                 direction: params.direction,
             };
+            // Forward the target-selector params like the trace branch above.
+            // @group impact used to drop target_uid/file_path/kind here, so a name
+            // shared by same-named Api/Impl/Controller layers resolved ambiguously
+            // in the member repo and the documented "re-call with target_uid"
+            // disambiguation loop (impact tool schema) never worked in group mode.
+            if (typeof params.target_uid === 'string')
+                impactArgs.target_uid = params.target_uid;
+            if (typeof params.file_path === 'string')
+                impactArgs.file_path = params.file_path;
+            if (typeof params.kind === 'string')
+                impactArgs.kind = params.kind;
             if (params.maxDepth !== undefined)
                 impactArgs.maxDepth = params.maxDepth;
             if (params.crossDepth !== undefined)