gitnexus 1.6.10-rc.21 → 1.6.10-rc.211

package/dist/core/ingestion/languages/kotlin/import-target.js

@@ -1,132 +1,29 @@
+/**
+ * Adapter from `(ParsedImport, WorkspaceIndex)` to Kotlin declared-package
+ * resolution. Package facts and module bindings are already present on the
+ * parsed workspace, so this performs no source I/O and no path inference.
+ */
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
+import { getKotlinPackageFact } from './package-facts.js';
+import { buildKotlinPackageIndex, resolveKotlinModule, } from './module-resolution.js';
+const getKotlinPackageIndex = perFileSet((parsedFiles) => buildKotlinPackageIndex(parsedFiles, getKotlinPackageFact));
 export function resolveKotlinImportTarget(parsedImport, workspaceIndex) {
-    const ctx = workspaceIndex;
-    if (ctx === undefined ||
-        typeof ctx.fromFile !== 'string' ||
-        !(ctx.allFilePaths instanceof Set)) {
-        return null;
-    }
-    if (parsedImport.kind === 'dynamic-unresolved')
+    const ctx = narrowContext(workspaceIndex);
+    if (ctx === null || parsedImport.kind === 'dynamic-unresolved')
         return null;
     if (parsedImport.targetRaw === null || parsedImport.targetRaw === '')
         return null;
-    const target = parsedImport.targetRaw.endsWith('.*')
-        ? parsedImport.targetRaw.slice(0, -2)
-        : parsedImport.targetRaw;
-    const pathLike = target.replace(/\./g, '/');
-    // Resolution tiers, most-specific first:
-    //  1. The full `pathLike` matches a `.kt`/`.kts` file directly
-    //     (`import util.User` → `util/User.kt`).
-    //  2. Stripped (last-segment removed) `pathLike` matches a file
-    //     directly (`import util.OneArg.writeAudit` → `util/OneArg.kt`,
-    //     a class-or-object holding `writeAudit`).
-    //  3. Stripped `pathLike` matches a *package directory* — fan out to
-    //     every `.kt`/`.kts` file inside it (`import models.getRepo` →
-    //     `[models/User.kt, models/Repo.kt]`). The finalize pass walks
-    //     each candidate and picks the one whose `localDefs` actually
-    //     export the imported name (#1759).
-    //  4. Progressive prefix strip for deeper namespace aliases that
-    //     don't map 1:1 to directories.
-    const stripped = pathLike.split('/').slice(0, -1).join('/');
-    return (findKotlinFile(ctx.allFilePaths, pathLike) ??
-        findKotlinExactOrSuffix(ctx.allFilePaths, stripped) ??
-        findKotlinPackageFiles(ctx.allFilePaths, stripped) ??
-        findByProgressivePrefixStrip(ctx.allFilePaths, pathLike));
-}
-function findKotlinFile(allFilePaths, pathLike) {
-    return (findKotlinExactOrSuffix(allFilePaths, pathLike) ??
-        findKotlinDirectoryChild(allFilePaths, pathLike));
-}
-/** Exact (`file === pathLike+ext`) or suffix (`file ends with /pathLike+ext`)
- *  match — does NOT fall back to picking an arbitrary file inside a
- *  `pathLike/` directory. Used by the stripped-path tier in
- *  `resolveKotlinImportTarget` so a package import like `models.getRepo`
- *  delegates to `findKotlinPackageFiles` (multi-file fan-out) instead of
- *  silently committing to the first directory child. */
-function findKotlinExactOrSuffix(allFilePaths, pathLike) {
-    if (pathLike === '')
-        return null;
-    const extensions = ['.kt', '.kts'];
-    const suffix = `/${pathLike}`;
-    let suffixFile = null;
-    for (const raw of allFilePaths) {
-        const file = raw.replace(/\\/g, '/');
-        if (!extensions.some((ext) => file.endsWith(ext)))
-            continue;
-        for (const ext of extensions) {
-            if (file === `${pathLike}${ext}`)
-                return raw;
-            if (suffixFile === null && file.endsWith(`${suffix}${ext}`))
-                suffixFile = raw;
-        }
-    }
-    return suffixFile;
-}
-/** First directory child of `pathLike/` — preserves the legacy single-
- *  file fallback for cases where `pathLike` itself is an unqualified
- *  package reference (rare in real Kotlin code; some fixtures rely on
- *  it). Multi-file package fan-out goes through
- *  `findKotlinPackageFiles` instead. */
-function findKotlinDirectoryChild(allFilePaths, pathLike) {
-    if (pathLike === '')
+    const parsedFiles = ctx.parsedFiles;
+    if (parsedFiles === undefined || parsedFiles.length === 0)
         return null;
-    const extensions = ['.kt', '.kts'];
-    const dirPrefix = `${pathLike}/`;
-    const suffixDirPrefix = `/${dirPrefix}`;
-    for (const raw of allFilePaths) {
-        const file = raw.replace(/\\/g, '/');
-        if (!extensions.some((ext) => file.endsWith(ext)))
-            continue;
-        const atRoot = file.startsWith(dirPrefix);
-        const atNested = file.includes(suffixDirPrefix);
-        if (!atRoot && !atNested)
-            continue;
-        const idx = atRoot ? 0 : file.indexOf(suffixDirPrefix) + 1;
-        const after = file.slice(idx + dirPrefix.length);
-        if (after.length > 0 && !after.includes('/'))
-            return raw;
-    }
-    return null;
+    return resolveKotlinModule(parsedImport.targetRaw, getKotlinPackageIndex(parsedFiles));
 }
-/**
- * Return every `.kt`/`.kts` file inside the package directory `dirPath`
- * (e.g. `models` → `['models/User.kt', 'models/Repo.kt']`). Used as a
- * fallback when an import like `models.getRepo` does not resolve to a
- * file named after the symbol — in Kotlin the symbol can live in any
- * file inside the package directory. The finalize pass walks each
- * candidate and picks the one whose `localDefs` actually export the
- * imported name (#1759).
- */
-function findKotlinPackageFiles(allFilePaths, dirPath) {
-    if (dirPath === '')
+function narrowContext(workspaceIndex) {
+    const ctx = workspaceIndex;
+    if (ctx === undefined ||
+        typeof ctx.fromFile !== 'string' ||
+        !(ctx.allFilePaths instanceof Set)) {
         return null;
-    const extensions = ['.kt', '.kts'];
-    const dirPrefix = `${dirPath}/`;
-    const suffixDirPrefix = `/${dirPrefix}`;
-    const out = [];
-    for (const raw of allFilePaths) {
-        const file = raw.replace(/\\/g, '/');
-        if (!extensions.some((ext) => file.endsWith(ext)))
-            continue;
-        const atRoot = file.startsWith(dirPrefix);
-        const atNested = file.includes(suffixDirPrefix);
-        if (!atRoot && !atNested)
-            continue;
-        const idx = atRoot ? 0 : file.indexOf(suffixDirPrefix) + 1;
-        const after = file.slice(idx + dirPrefix.length);
-        // Direct children only — `models/sub/Util.kt` is a different package
-        // (`models.sub`) and must not be merged with `models`.
-        if (after.length === 0 || after.includes('/'))
-            continue;
-        out.push(raw);
-    }
-    return out.length === 0 ? null : out;
-}
-function findByProgressivePrefixStrip(allFilePaths, pathLike) {
-    const segments = pathLike.split('/').filter(Boolean);
-    for (let skip = 1; skip < segments.length; skip++) {
-        const found = findKotlinFile(allFilePaths, segments.slice(skip).join('/'));
-        if (found !== null)
-            return found;
     }
-    return null;
+    return ctx;
 }

package/dist/core/ingestion/languages/kotlin/index.d.ts

@@ -4,6 +4,7 @@ export { getKotlinCaptureCacheStats, resetKotlinCaptureCacheStats } from './cach
 export { interpretKotlinImport, interpretKotlinTypeBinding } from './interpret.js';
 export { kotlinArityCompatibility } from './arity.js';
 export { resolveKotlinImportTarget, type KotlinResolveContext } from './import-target.js';
+export { buildKotlinPackageIndex, resolveKotlinModule, type KotlinPackageIndex, } from './module-resolution.js';
 export { kotlinMergeBindings } from './merge-bindings.js';
 export { populateKotlinOwners } from './owners.js';
 export { kotlinBindingScopeFor, kotlinImportOwningScope, kotlinReceiverBinding, } from './simple-hooks.js';

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

@@ -4,6 +4,7 @@ export { getKotlinCaptureCacheStats, resetKotlinCaptureCacheStats } from './cach
 export { interpretKotlinImport, interpretKotlinTypeBinding } from './interpret.js';
 export { kotlinArityCompatibility } from './arity.js';
 export { resolveKotlinImportTarget } from './import-target.js';
+export { buildKotlinPackageIndex, resolveKotlinModule, } from './module-resolution.js';
 export { kotlinMergeBindings } from './merge-bindings.js';
 export { populateKotlinOwners } from './owners.js';
 export { kotlinBindingScopeFor, kotlinImportOwningScope, kotlinReceiverBinding, } from './simple-hooks.js';

package/dist/core/ingestion/languages/kotlin/module-resolution.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Kotlin import resolution against declared packages and module exports (#2960).
+ *
+ * Kotlin source layout is conventional, not semantic: a file may declare any
+ * package from any directory, and a top-level class, function or property need
+ * not match the file name. Resolution therefore uses the package fact captured
+ * during parsing plus the file's module-scope bindings. It never guesses from a
+ * coincidental path suffix.
+ */
+import type { ParsedFile } from '../../../../_shared/index.js';
+import type { JvmPackageFact } from '../jvm/package-facts.js';
+export interface KotlinPackageIndex {
+    /** Declared package -> top-level exported name -> files declaring that name. */
+    readonly declarationsByPackage: ReadonlyMap<string, ReadonlyMap<string, readonly string[]>>;
+    /** Declared package -> every file declaring it, for wildcard imports. */
+    readonly filesByPackage: ReadonlyMap<string, readonly string[]>;
+    /** Files whose package header could not be interpreted conservatively. */
+    readonly unreadablePackageFiles: number;
+}
+export declare function buildKotlinPackageIndex(parsedFiles: readonly ParsedFile[], packageOf: (filePath: string) => JvmPackageFact | undefined): KotlinPackageIndex;
+/** Resolve a Kotlin import to the file(s) its declarations name. */
+export declare function resolveKotlinModule(targetRaw: string, index: KotlinPackageIndex): string | readonly string[] | null;

package/dist/core/ingestion/languages/kotlin/module-resolution.js

@@ -0,0 +1,108 @@
+/**
+ * Kotlin import resolution against declared packages and module exports (#2960).
+ *
+ * Kotlin source layout is conventional, not semantic: a file may declare any
+ * package from any directory, and a top-level class, function or property need
+ * not match the file name. Resolution therefore uses the package fact captured
+ * during parsing plus the file's module-scope bindings. It never guesses from a
+ * coincidental path suffix.
+ */
+const EMPTY_INDEX = {
+    declarationsByPackage: new Map(),
+    filesByPackage: new Map(),
+    unreadablePackageFiles: 0,
+};
+export function buildKotlinPackageIndex(parsedFiles, packageOf) {
+    if (parsedFiles.length === 0)
+        return EMPTY_INDEX;
+    const declarationsByPackage = new Map();
+    const filesByPackage = new Map();
+    let unreadablePackageFiles = 0;
+    for (const parsed of parsedFiles) {
+        const fact = packageOf(parsed.filePath);
+        if (fact === undefined)
+            continue;
+        if (fact.status !== 'known') {
+            unreadablePackageFiles++;
+            continue;
+        }
+        const packageName = fact.packageName;
+        const packageFiles = filesByPackage.get(packageName);
+        if (packageFiles === undefined)
+            filesByPackage.set(packageName, [parsed.filePath]);
+        else
+            packageFiles.push(parsed.filePath);
+        const moduleScope = parsed.scopes.find((scope) => scope.id === parsed.moduleScope && scope.kind === 'Module') ??
+            parsed.scopes.find((scope) => scope.kind === 'Module');
+        if (moduleScope === undefined)
+            continue;
+        let declarations = declarationsByPackage.get(packageName);
+        if (declarations === undefined) {
+            declarations = new Map();
+            declarationsByPackage.set(packageName, declarations);
+        }
+        for (const [name, refs] of moduleScope.bindings) {
+            if (name === '' ||
+                !refs.some((ref) => ref.origin === 'local' && ref.def.filePath === parsed.filePath)) {
+                continue;
+            }
+            const files = declarations.get(name);
+            if (files === undefined)
+                declarations.set(name, [parsed.filePath]);
+            else if (!files.includes(parsed.filePath))
+                files.push(parsed.filePath);
+        }
+    }
+    return { declarationsByPackage, filesByPackage, unreadablePackageFiles };
+}
+/** Resolve a Kotlin import to the file(s) its declarations name. */
+export function resolveKotlinModule(targetRaw, index) {
+    if (targetRaw === '')
+        return null;
+    if (targetRaw.endsWith('.*')) {
+        const stem = targetRaw.slice(0, -2);
+        if (stem === '')
+            return null;
+        const packageFiles = index.filesByPackage.get(stem);
+        if (packageFiles !== undefined)
+            return packageFiles;
+        // Kotlin also permits star imports from a class or object. Resolve the
+        // owning top-level declaration, while keeping an undeclared package null.
+        return resolveTopLevelDeclaration(stem, index);
+    }
+    return resolveTopLevelDeclaration(targetRaw, index);
+}
+function resolveTopLevelDeclaration(qualifiedName, index) {
+    const parts = qualifiedName.split('.').filter((part) => part !== '');
+    if (parts.length === 0)
+        return null;
+    // A bare name can refer to the special root package. It is still backed by
+    // package and binding evidence; no path fallback is involved.
+    if (parts.length === 1) {
+        const name = parts[0];
+        return name === undefined
+            ? null
+            : declarationFiles(index.declarationsByPackage.get('')?.get(name));
+    }
+    for (let split = parts.length - 1; split >= 1; split--) {
+        const packageName = parts.slice(0, split).join('.');
+        const declarations = index.declarationsByPackage.get(packageName);
+        if (declarations === undefined)
+            continue;
+        const declarationName = parts[split];
+        if (declarationName === undefined)
+            continue;
+        const files = declarations.get(declarationName);
+        if (files === undefined)
+            continue;
+        return declarationFiles(files);
+    }
+    return null;
+}
+function declarationFiles(files) {
+    if (files === undefined || files.length === 0)
+        return null;
+    // Kotlin permits overloaded top-level callables across files. Preserve the
+    // complete candidate set instead of choosing one by parse order.
+    return files.length === 1 ? (files[0] ?? null) : files;
+}

package/dist/core/ingestion/languages/kotlin/package-facts.d.ts

@@ -0,0 +1,5 @@
+import { type JvmPackageFact, type JvmPackageSyntaxNode } from '../jvm/package-facts.js';
+export declare const clearKotlinPackageFacts: () => void;
+export declare const captureKotlinPackageFact: (filePath: string, root: JvmPackageSyntaxNode) => void;
+export declare const setKotlinPackageFact: (filePath: string, fact: JvmPackageFact) => void;
+export declare const getKotlinPackageFact: (filePath: string) => JvmPackageFact | undefined;

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

@@ -0,0 +1,9 @@
+import { createJvmPackageFactStore, } from '../jvm/package-facts.js';
+const kotlinPackageFacts = createJvmPackageFactStore({
+    packageNodeType: 'package_header',
+    packageNameNodeTypes: ['identifier'],
+});
+export const clearKotlinPackageFacts = () => kotlinPackageFacts.clear();
+export const captureKotlinPackageFact = (filePath, root) => kotlinPackageFacts.capture(filePath, root);
+export const setKotlinPackageFact = (filePath, fact) => kotlinPackageFacts.set(filePath, fact);
+export const getKotlinPackageFact = (filePath) => kotlinPackageFacts.get(filePath);

package/dist/core/ingestion/languages/kotlin/package-siblings.d.ts

@@ -0,0 +1,4 @@
+export declare const populateKotlinPackageSiblings: (parsedFiles: readonly import('../../../../_shared/index.js').ParsedFile[], indexes: import("../../model/scope-resolution-indexes.js").ScopeResolutionIndexes, ctx: {
+    readonly fileContents: ReadonlyMap<string, string>;
+}) => void;
+export declare const isKotlinPackageSiblingVisibilityIncomplete: (filePath: string) => boolean;

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

@@ -0,0 +1,8 @@
+import { createJvmPackageSiblingVisibility } from '../jvm/package-siblings.js';
+import { getKotlinPackageFact } from './package-facts.js';
+const kotlinPackageSiblingVisibility = createJvmPackageSiblingVisibility({
+    languageLabel: 'kotlin',
+    getPackageFact: getKotlinPackageFact,
+});
+export const populateKotlinPackageSiblings = kotlinPackageSiblingVisibility.populateNamespaceSiblings;
+export const isKotlinPackageSiblingVisibilityIncomplete = kotlinPackageSiblingVisibility.isVisibilityIncomplete;

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

@@ -15,6 +15,12 @@ const KOTLIN_SCOPE_QUERY = `
 (class_declaration) @scope.class
 (object_declaration) @scope.class
 (companion_object) @scope.class
+;; Anonymous object expression: \`val h = object { fun fetch() {} }\`
+;; (distinct from the named \`object_declaration\`/\`companion_object\` above).
+;; Without its own scope, a method's auto-hoist (scope-extractor.ts) has
+;; nowhere to stop and leaks the name past the literal into the enclosing
+;; scope -- the same failure mode fixed for TS/JS object literals (#2545).
+(object_literal) @scope.class
 (function_declaration) @scope.function
 
 ;; Secondary-constructor body scope (issue #1919 review CF1). A
@@ -74,13 +80,22 @@ const KOTLIN_SCOPE_QUERY = `
 (lambda_literal) @scope.block
 
 ;; Declarations — types
+;; The Kotlin grammar puts NO named fields on \`class_declaration\`, so the
+;; parameter list is matched positionally as an optional unnamed child, exactly
+;; as the name already is.
+;;
+;; Only the INLINE bound (\`<T : Repo>\`) is read. A \`where T : Repo\` clause is a
+;; separate \`type_constraints\` sibling and is left alone, so its bound reads as
+;; absent — "unknown", not "unbounded".
 (class_declaration
   "interface"
-  (type_identifier) @declaration.name) @declaration.interface
+  (type_identifier) @declaration.name
+  (type_parameters)? @declaration.type-parameters) @declaration.interface
 
 (class_declaration
   "class"
-  (type_identifier) @declaration.name) @declaration.class
+  (type_identifier) @declaration.name
+  (type_parameters)? @declaration.type-parameters) @declaration.class
 
 (object_declaration
   (type_identifier) @declaration.name) @declaration.class
@@ -91,10 +106,40 @@ const KOTLIN_SCOPE_QUERY = `
 (type_alias
   (type_identifier) @declaration.name) @declaration.type_alias
 
+;; Class annotation syntax is carried to post-resolution enrichment. Keeping
+;; this in the existing scope query avoids a second AST traversal. Eligibility
+;; filtering (class vs interface/enum/annotation class) happens in captures.ts.
+(class_declaration
+  (modifiers
+    [
+      (annotation
+        (user_type) @class-annotation.name)
+      (annotation
+        (constructor_invocation
+          (user_type) @class-annotation.name))
+    ])) @class-annotation.class
+
 ;; Declarations — functions / methods / properties
+;;
+;; A generic FUNCTION's parameters are read for the same reason a generic type's
+;; are (#2912 review): \`fun <T> runAny(v: Validator<T>)\` writes a receiver whose
+;; argument is a type VARIABLE, and a pass that cannot tell that from a concrete
+;; type prunes every implementor from the call's dispatch fan-out.
 (function_declaration
+  (type_parameters)? @declaration.type-parameters
   (simple_identifier) @declaration.name) @declaration.function
 
+;; Lambda bound to a val/var: val handler = { x: Int -> target(x) }
+;; Anchor discipline (same contract as javascript/query.ts): @declaration.function
+;; sits on the INNER lambda_literal, NOT on the property_declaration wrapper, so
+;; anchor.range aligns with the (lambda_literal) @scope.block range. That
+;; alignment is what lets pickCallerCallableDef accept a Block-kind scope as a
+;; callable boundary: the scope IS the callable's body. The lambda stays
+;; @scope.block deliberately (#1757 smart casts) — do NOT re-kind it.
+(property_declaration
+  (variable_declaration (simple_identifier) @declaration.name)
+  (lambda_literal) @declaration.function)
+
 (property_declaration
   (variable_declaration
     (simple_identifier) @declaration.name)) @declaration.property

package/dist/core/ingestion/languages/kotlin/scope-resolver.js

@@ -2,11 +2,19 @@ import { SupportedLanguages } from '../../../../_shared/index.js';
 import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
 import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
 import { isClassLike } from '../../scope-resolution/scope/walkers.js';
+import { indexOnlyElementType } from '../../type-extractors/shared.js';
 import { kotlinProvider } from '../kotlin.js';
 import { kotlinArityCompatibility, kotlinMergeBindings, populateKotlinOwners, resolveKotlinImportTarget, } from './index.js';
 import { clearCompanionScopes } from './companion-scopes.js';
-import { applyKotlinCaptureSideChannel } from './capture-side-channel.js';
+import { applyKotlinCaptureSideChannel, clearKotlinClassAnnotationFacts, } from './capture-side-channel.js';
 import { isKotlinStaticOnly } from './owners.js';
+import { populateKotlinPackageSiblings } from './package-siblings.js';
+import { attachKotlinSpringBeanCandidateMetadata } from './spring-bean-metadata.js';
+import { attachKotlinSpringAopMetadata } from './spring-aop.js';
+import { clearKotlinPackageFacts } from './package-facts.js';
+import { attachKotlinSpringDiMetadata } from './spring-di.js';
+import { attachKotlinSpringConditionalMetadata } from './spring-conditionals.js';
+import { attachKotlinSpringNonHttpHandlerMetadata } from './spring-non-http-handlers.js';
 /**
  * Kotlin scope resolver for RFC #909 Ring 3.
  *
@@ -57,10 +65,16 @@ export const kotlinScopeResolver = {
         // `undefined` because Kotlin has no external resolution config
         // to load.
         clearCompanionScopes();
+        clearKotlinClassAnnotationFacts();
+        clearKotlinPackageFacts();
         return undefined;
     },
-    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
-        const ws = { fromFile, allFilePaths };
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths, _resolutionConfig, context) => {
+        const ws = {
+            fromFile,
+            allFilePaths,
+            parsedFiles: context?.parsedFiles,
+        };
         return resolveKotlinImportTarget({ kind: 'named', localName: '_', importedName: '_', targetRaw }, ws);
     },
     mergeBindings: (existing, incoming) => [...kotlinMergeBindings([...existing, ...incoming])],
@@ -84,11 +98,30 @@ export const kotlinScopeResolver = {
     applyCaptureSideChannel: applyKotlinCaptureSideChannel,
     populateOwners: (parsed) => populateKotlinOwners(parsed),
     isSuperReceiver: (text) => text.trim() === 'super',
+    // Subscript route only — Kotlin's collection views (`.values`, `.keys`) are
+    // properties on the stdlib types, resolved by the ordinary member walk rather
+    // than by unwrapping a generic here.
+    //
+    // Fed the annotation AS WRITTEN (`List<User>`, `Map<String, User>`), which
+    // `normalizeKotlinType` had already reduced to `User`. `undefined` means "not
+    // a container", so an `operator fun get` class does not fold `cache[k]` onto
+    // `Cache` itself.
+    elementTypeOf: indexOnlyElementType,
     isStaticOnly: isKotlinStaticOnly,
     fieldFallbackOnMethodLookup: false,
     propagatesReturnTypesAcrossImports: true,
     collapseMemberCallsByCallerTarget: false,
     hoistTypeBindingsToModule: true,
+    freeCallsRequireInstanceOwnership: true,
+    postExtractSourceTextPolicy: 'uncached-files',
+    populateNamespaceSiblings: populateKotlinPackageSiblings,
+    emitPostResolutionEdges: (graph, parsedFiles, nodeLookup, indexes) => {
+        attachKotlinSpringBeanCandidateMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachKotlinSpringAopMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachKotlinSpringConditionalMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachKotlinSpringDiMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachKotlinSpringNonHttpHandlerMetadata(graph, parsedFiles, nodeLookup, indexes);
+    },
 };
 /**
  * Kotlin MRO builder — extends `defaultLinearize` (EXTENDS-only) with

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

@@ -0,0 +1,12 @@
+import { type SpringAopOwnerFact } from '../../frameworks/spring/aop.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+import { type KotlinAnnotationSyntaxFact } from './spring-di.js';
+export type KotlinSpringAopAnnotationFact = KotlinAnnotationSyntaxFact;
+export type KotlinSpringAopFact = SpringAopOwnerFact<KotlinSpringAopAnnotationFact>;
+/**
+ * Capture Spring AOP syntax from the class node already surfaced by Kotlin's
+ * scope query. The shared layer resolves annotations and rejects non-default
+ * use-site targets after imports and package visibility have finalized.
+ */
+export declare function captureKotlinSpringAopFacts(classNode: SyntaxNode, filePath: string): KotlinSpringAopFact[];
+export declare const attachKotlinSpringAopMetadata: (graph: import("../../../graph/types.js").KnowledgeGraph, parsedFiles: readonly import('../../../../_shared/index.js').ParsedFile[], nodeLookup: import("../../scope-resolution/graph-bridge/node-lookup.js").GraphNodeLookup, indexes: import("../../model/scope-resolution-indexes.js").ScopeResolutionIndexes) => void;

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

@@ -0,0 +1,64 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { createSpringAopMetadataAttacher, } from '../../frameworks/spring/aop.js';
+import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { getKotlinSpringAopFacts } from './capture-side-channel.js';
+import { isKotlinPackageSiblingVisibilityIncomplete } from './package-siblings.js';
+import { kotlinSpringAnnotationFacts } from './spring-di.js';
+function scopeId(filePath, node, kind) {
+    return makeScopeId({
+        filePath,
+        range: nodeToCapture('@spring-aop.owner', node).range,
+        kind,
+    });
+}
+function ownerRange(node) {
+    return nodeToCapture('@spring-aop.owner', node).range;
+}
+/**
+ * Capture Spring AOP syntax from the class node already surfaced by Kotlin's
+ * scope query. The shared layer resolves annotations and rejects non-default
+ * use-site targets after imports and package visibility have finalized.
+ */
+export function captureKotlinSpringAopFacts(classNode, filePath) {
+    const facts = [];
+    const classAnnotations = kotlinSpringAnnotationFacts(classNode);
+    const singletonInstance = classNode.type === 'object_declaration' || classNode.type === 'companion_object';
+    // Kotlin import aliases can give a Spring annotation any local simple name.
+    // Capture annotated owners conservatively, then let the post-import shared
+    // resolver keep only recognized Spring AOP annotations. Objects also retain
+    // an empty owner fact so the shared phase can distinguish their singleton
+    // instance members from true static methods without naming Kotlin.
+    if (classAnnotations.length > 0 || singletonInstance) {
+        facts.push({
+            ownerScopeId: scopeId(filePath, classNode, 'Class'),
+            ownerKind: 'class',
+            ownerFilePath: filePath,
+            ownerRange: ownerRange(classNode),
+            ...(singletonInstance ? { singletonInstance: true } : {}),
+            annotations: classAnnotations,
+        });
+    }
+    const body = classNode.namedChildren.find((child) => child.type === 'class_body');
+    if (body === undefined)
+        return facts;
+    for (const member of body.namedChildren) {
+        if (member.type !== 'function_declaration')
+            continue;
+        const annotations = kotlinSpringAnnotationFacts(member);
+        if (annotations.length === 0)
+            continue;
+        facts.push({
+            ownerScopeId: scopeId(filePath, member, 'Function'),
+            ownerKind: 'callable',
+            ownerFilePath: filePath,
+            ownerRange: ownerRange(member),
+            ...(singletonInstance ? { singletonInstance: true } : {}),
+            annotations,
+        });
+    }
+    return facts;
+}
+export const attachKotlinSpringAopMetadata = createSpringAopMetadataAttacher({
+    getFacts: getKotlinSpringAopFacts,
+    isPackageVisibilityIncomplete: isKotlinPackageSiblingVisibilityIncomplete,
+});

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

@@ -0,0 +1,2 @@
+/** Kotlin wiring for the language-neutral Spring candidate engine. */
+export declare const attachKotlinSpringBeanCandidateMetadata: (graph: import("../../../graph/types.js").KnowledgeGraph, parsedFiles: readonly import('../../../../_shared/index.js').ParsedFile[], nodeLookup: import("../../scope-resolution/graph-bridge/node-lookup.js").GraphNodeLookup, indexes: import("../../model/scope-resolution-indexes.js").ScopeResolutionIndexes) => void;

package/dist/core/ingestion/languages/kotlin/spring-bean-metadata.js

@@ -0,0 +1,8 @@
+import { createSpringBeanCandidateAttacher } from '../../frameworks/spring/bean-candidates.js';
+import { getKotlinClassAnnotationFacts } from './capture-side-channel.js';
+import { isKotlinPackageSiblingVisibilityIncomplete } from './package-siblings.js';
+/** Kotlin wiring for the language-neutral Spring candidate engine. */
+export const attachKotlinSpringBeanCandidateMetadata = createSpringBeanCandidateAttacher({
+    getClassAnnotationFacts: getKotlinClassAnnotationFacts,
+    isPackageVisibilityIncomplete: isKotlinPackageSiblingVisibilityIncomplete,
+});

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

@@ -0,0 +1,12 @@
+import { type SpringConditionalOwnerFact } from '../../frameworks/spring/conditionals.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+import { type KotlinAnnotationSyntaxFact } from './spring-di.js';
+export type KotlinSpringConditionalAnnotationFact = KotlinAnnotationSyntaxFact;
+export type KotlinSpringConditionalFact = SpringConditionalOwnerFact<KotlinSpringConditionalAnnotationFact>;
+/**
+ * Capture Kotlin condition syntax from the class node already surfaced by the
+ * scope query. Kotlin syntax stays local; shared Spring semantics are attached
+ * after resolution.
+ */
+export declare function captureKotlinSpringConditionalFacts(classNode: SyntaxNode, filePath: string): KotlinSpringConditionalFact[];
+export declare const attachKotlinSpringConditionalMetadata: (graph: import("../../../graph/types.js").KnowledgeGraph, parsedFiles: readonly import('../../../../_shared/index.js').ParsedFile[], nodeLookup: import("../../scope-resolution/graph-bridge/node-lookup.js").GraphNodeLookup, indexes: import("../../model/scope-resolution-indexes.js").ScopeResolutionIndexes) => void;

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

@@ -0,0 +1,49 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { createSpringConditionalMetadataAttacher, hasSpringConditionalRelevantAnnotation, } from '../../frameworks/spring/conditionals.js';
+import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { getKotlinSpringConditionalFacts } from './capture-side-channel.js';
+import { isKotlinPackageSiblingVisibilityIncomplete } from './package-siblings.js';
+import { kotlinSpringAnnotationFacts } from './spring-di.js';
+function scopeId(filePath, node, kind) {
+    return makeScopeId({
+        filePath,
+        range: nodeToCapture('@spring-condition.owner', node).range,
+        kind,
+    });
+}
+/**
+ * Capture Kotlin condition syntax from the class node already surfaced by the
+ * scope query. Kotlin syntax stays local; shared Spring semantics are attached
+ * after resolution.
+ */
+export function captureKotlinSpringConditionalFacts(classNode, filePath) {
+    const facts = [];
+    const classAnnotations = kotlinSpringAnnotationFacts(classNode);
+    if (hasSpringConditionalRelevantAnnotation(classAnnotations)) {
+        facts.push({
+            ownerScopeId: scopeId(filePath, classNode, 'Class'),
+            ownerKind: 'class',
+            annotations: classAnnotations,
+        });
+    }
+    const body = classNode.namedChildren.find((child) => child.type === 'class_body');
+    if (body === undefined)
+        return facts;
+    for (const member of body.namedChildren) {
+        if (member.type !== 'function_declaration')
+            continue;
+        const annotations = kotlinSpringAnnotationFacts(member);
+        if (!hasSpringConditionalRelevantAnnotation(annotations))
+            continue;
+        facts.push({
+            ownerScopeId: scopeId(filePath, member, 'Function'),
+            ownerKind: 'callable',
+            annotations,
+        });
+    }
+    return facts;
+}
+export const attachKotlinSpringConditionalMetadata = createSpringConditionalMetadataAttacher({
+    getFacts: getKotlinSpringConditionalFacts,
+    isPackageVisibilityIncomplete: isKotlinPackageSiblingVisibilityIncomplete,
+});