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

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

@@ -0,0 +1,197 @@
+import { logger } from '../../../logger.js';
+import { isClassLike } from '../../scope-resolution/scope/walkers.js';
+/** Packages larger than this get no implicit sibling visibility at all — every
+ *  file in them is marked incomplete. `GITNEXUS_MAX_INJECTED_SIBLINGS` bounds
+ *  injection *within* a package and does not lift this skip. */
+const MAX_PACKAGE_FILES = 500;
+const DEFAULT_MAX_INJECTED_SIBLINGS = 200;
+function getMaxInjectedSiblings() {
+    const raw = process.env.GITNEXUS_MAX_INJECTED_SIBLINGS;
+    if (raw === undefined || raw === '')
+        return DEFAULT_MAX_INJECTED_SIBLINGS;
+    const parsed = Number(raw);
+    return Number.isInteger(parsed) && parsed >= 0 ? parsed : DEFAULT_MAX_INJECTED_SIBLINGS;
+}
+export function createJvmPackageSiblingVisibility(options) {
+    const incompleteFiles = new Set();
+    function populateNamespaceSiblings(parsedFiles, indexes, ctx) {
+        incompleteFiles.clear();
+        const buckets = new Map();
+        const unknownPackageFiles = new Set();
+        const parsedPaths = new Set(parsedFiles.map((parsed) => parsed.filePath));
+        // A file that failed scope extraction has no ParsedFile or side-channel,
+        // but it may still declare a shadowing type in any package. Keep its source
+        // path in the uncertainty set without re-parsing it on the main thread.
+        for (const filePath of ctx.fileContents.keys()) {
+            if (!parsedPaths.has(filePath))
+                unknownPackageFiles.add(filePath);
+        }
+        for (const parsed of parsedFiles) {
+            const packageFact = options.getPackageFact(parsed.filePath);
+            if (!ctx.fileContents.has(parsed.filePath) || packageFact?.status !== 'known') {
+                incompleteFiles.add(parsed.filePath);
+                unknownPackageFiles.add(parsed.filePath);
+                continue;
+            }
+            const packageName = packageFact.packageName;
+            const bucket = buckets.get(packageName) ?? { parsed: [], moduleScopes: [] };
+            buckets.set(packageName, bucket);
+            bucket.parsed.push(parsed);
+            const moduleScope = parsed.scopes.find((scope) => scope.kind === 'Module');
+            if (moduleScope !== undefined) {
+                bucket.moduleScopes.push({ filePath: parsed.filePath, scope: moduleScope });
+            }
+        }
+        // A file whose package cannot be proven may shadow a wildcard-imported
+        // type in any package. Conservatively disable wildcard attribution for the
+        // language workspace while leaving explicit/FQN imports available.
+        if (unknownPackageFiles.size > 0) {
+            for (const parsed of parsedFiles)
+                incompleteFiles.add(parsed.filePath);
+            logger.warn(`[${options.languageLabel}-package-siblings] ${unknownPackageFiles.size} file(s) lacked reliable package facts; wildcard attribution disabled for this language workspace`);
+        }
+        const augmentations = indexes.bindingAugmentations;
+        const maxInjectedSiblings = getMaxInjectedSiblings();
+        let truncatedFiles = 0;
+        for (const bucket of buckets.values()) {
+            if (bucket.moduleScopes.length < 2)
+                continue;
+            if (bucket.moduleScopes.length > MAX_PACKAGE_FILES) {
+                for (const parsed of bucket.parsed)
+                    incompleteFiles.add(parsed.filePath);
+                logger.warn(`[${options.languageLabel}-package-siblings] skipping package with ${bucket.moduleScopes.length} files (cap=${MAX_PACKAGE_FILES}); same-package implicit visibility disabled for this package`);
+                continue;
+            }
+            const classDefs = [];
+            for (const parsed of bucket.parsed) {
+                const moduleScopeId = parsed.scopes.find((scope) => scope.kind === 'Module')?.id;
+                for (const scope of parsed.scopes) {
+                    if (scope.kind !== 'Class' || scope.parent !== moduleScopeId)
+                        continue;
+                    const def = scope.ownedDefs.find((candidate) => isClassLike(candidate.type));
+                    if (def !== undefined)
+                        classDefs.push({ def, filePath: parsed.filePath });
+                }
+            }
+            // Per-bucket lookups: the per-file loop below is O(files²) over these,
+            // so split each path into segments once here instead of re-splitting it
+            // on every pairwise proximity comparison, and address siblings by path
+            // so a truncated scope can merge its bounded set without rescanning the
+            // whole package.
+            const segmentsByPath = new Map();
+            const moduleScopeByPath = new Map();
+            const parsedByPath = new Map();
+            for (const parsed of bucket.parsed) {
+                segmentsByPath.set(parsed.filePath, pathSegments(parsed.filePath));
+                parsedByPath.set(parsed.filePath, parsed);
+            }
+            for (const sibling of bucket.moduleScopes)
+                moduleScopeByPath.set(sibling.filePath, sibling);
+            const allSiblingPaths = [...parsedByPath.keys()];
+            for (const { filePath, scope } of bucket.moduleScopes) {
+                let scopeAug = augmentations.get(scope.id);
+                if (scopeAug === undefined) {
+                    scopeAug = new Map();
+                    augmentations.set(scope.id, scopeAug);
+                }
+                const ownSegments = segmentsByPath.get(filePath) ?? pathSegments(filePath);
+                const proximityCache = new Map();
+                const candidates = classDefs.filter((candidate) => candidate.filePath !== filePath);
+                for (const candidate of candidates) {
+                    if (!proximityCache.has(candidate.filePath)) {
+                        proximityCache.set(candidate.filePath, sharedSegmentCount(segmentsByPath.get(candidate.filePath) ?? [], ownSegments));
+                    }
+                }
+                // Nearest-first by shared path prefix. Ties (the common case in a flat
+                // package, where every sibling shares the same directory) keep the
+                // walker's traversal order, so the retained set is deterministic but
+                // arbitrary among equally-near candidates — which is why truncation
+                // marks the file incomplete below rather than being treated as exact.
+                candidates.sort((a, b) => (proximityCache.get(b.filePath) ?? 0) - (proximityCache.get(a.filePath) ?? 0));
+                const injectedIds = new Set();
+                const injectedPaths = new Set();
+                let truncated = false;
+                for (const { def, filePath: defPath } of candidates) {
+                    if (injectedIds.has(def.nodeId) || def.qualifiedName === undefined)
+                        continue;
+                    if (maxInjectedSiblings > 0 && injectedIds.size >= maxInjectedSiblings) {
+                        truncated = true;
+                        break;
+                    }
+                    injectedIds.add(def.nodeId);
+                    injectedPaths.add(defPath);
+                    const simpleName = def.qualifiedName.includes('.')
+                        ? def.qualifiedName.slice(def.qualifiedName.lastIndexOf('.') + 1)
+                        : def.qualifiedName;
+                    const bindings = scopeAug.get(simpleName) ?? [];
+                    if (!scopeAug.has(simpleName))
+                        scopeAug.set(simpleName, bindings);
+                    bindings.push({ def, origin: 'namespace' });
+                }
+                if (truncated) {
+                    // Sibling visibility for this file is now partial, and downstream
+                    // Spring attribution treats a complete flag as "this package's names
+                    // are fully known". Marking it incomplete keeps wildcard attribution
+                    // conservative instead of silently resolving against a truncated set.
+                    incompleteFiles.add(filePath);
+                    truncatedFiles++;
+                }
+                // Keep the two halves of "what this file can see" in agreement: when
+                // the cap truncated the binding set, merge type bindings from the same
+                // bounded sibling set only — and iterate that set directly, so the cap
+                // bounds the merge work too instead of just filtering a full scan. An
+                // untruncated scope merges every sibling as before, including ones that
+                // contribute no class-like def.
+                const typeBindings = scope.typeBindings;
+                const mergePaths = truncated ? injectedPaths : allSiblingPaths;
+                // Module scopes first, then class scopes: module-level bindings win on
+                // a name collision, which the two-pass order (not file order) encodes.
+                for (const siblingPath of mergePaths) {
+                    if (siblingPath === filePath)
+                        continue;
+                    const sibling = moduleScopeByPath.get(siblingPath);
+                    if (sibling === undefined)
+                        continue;
+                    for (const [name, ref] of sibling.scope.typeBindings) {
+                        if (!typeBindings.has(name))
+                            typeBindings.set(name, ref);
+                    }
+                }
+                for (const siblingPath of mergePaths) {
+                    if (siblingPath === filePath)
+                        continue;
+                    const sibling = parsedByPath.get(siblingPath);
+                    if (sibling === undefined)
+                        continue;
+                    for (const siblingScope of sibling.scopes) {
+                        if (siblingScope.kind !== 'Class')
+                            continue;
+                        for (const [name, ref] of siblingScope.typeBindings) {
+                            if (ref.source !== 'self' && !typeBindings.has(name))
+                                typeBindings.set(name, ref);
+                        }
+                    }
+                }
+            }
+        }
+        if (truncatedFiles > 0) {
+            logger.warn(`[${options.languageLabel}-package-siblings] sibling injection truncated at ${maxInjectedSiblings} per file for ${truncatedFiles} file(s); wildcard attribution disabled for those files (raise or unset GITNEXUS_MAX_INJECTED_SIBLINGS to widen, 0 for unbounded)`);
+        }
+    }
+    return {
+        populateNamespaceSiblings,
+        isVisibilityIncomplete: (filePath) => incompleteFiles.has(filePath),
+    };
+}
+function pathSegments(filePath) {
+    return filePath.replace(/\\/g, '/').split('/');
+}
+function sharedSegmentCount(aSegments, bSegments) {
+    let index = 0;
+    while (index < aSegments.length &&
+        index < bSegments.length &&
+        aSegments[index] === bSegments[index]) {
+        index++;
+    }
+    return index;
+}

package/dist/core/ingestion/languages/kotlin/capture-side-channel.d.ts

@@ -7,6 +7,12 @@
  *   - `companionScopesByFile`  (companion-scopes.ts) — the `ScopeId`s that came
  *     from a `companion_object` AST node, recorded via `markCompanionScope`
  *     from the `@scope.companion` marker capture.
+ *   - Spring Bean class-annotation facts collected during the same scope-query
+ *     traversal, consumed only after imports and package visibility finalize.
+ *   - Spring DI class facts (constructor/property/method injection syntax),
+ *     resolved and attached only after imports finalize.
+ *   - A JVM package fact read from the already-parsed root, so package-sibling
+ *     visibility never re-parses Kotlin source on the main thread.
  *
  * On the worker path that map is filled in the WORKER process and lost across
  * the worker→main MessageChannel (and the disk-backed parsedfile-store),
@@ -25,10 +31,18 @@
  * The single generic `ParsedFile.captureSideChannel` field is shared with C++,
  * which is safe because each file is one language (a `.kt` file uses the kotlin
  * provider, a `.cpp` file the cpp provider). The payload is self-describing
- * (`{ kind: 'kotlin', companionScopes }`) so `applyKotlinCaptureSideChannel`
- * only restores kotlin state and ignores a foreign-shaped snapshot.
+ * (`{ kind: 'kotlin', companionScopes, packageFact, classAnnotations,
+ * springDiFacts }`) so
+ * `applyKotlinCaptureSideChannel` only restores kotlin state and ignores a
+ * foreign-shaped snapshot.
  */
 import type { ParsedFile, ScopeId } from '../../../../_shared/index.js';
+import { type ClassAnnotationFact } from '../../frameworks/spring/bean-candidates.js';
+import { type JvmPackageFact } from '../jvm/package-facts.js';
+import type { KotlinSpringAopFact } from './spring-aop.js';
+import type { KotlinSpringConditionalFact } from './spring-conditionals.js';
+import type { KotlinSpringDiClassFact } from './spring-di.js';
+import type { KotlinSpringNonHttpHandlerFact } from './spring-non-http-handlers.js';
 /**
  * Plain JSON-serializable snapshot of the per-file Kotlin capture-time
  * side-channel. Carried opaquely on `ParsedFile.captureSideChannel`. The
@@ -39,10 +53,33 @@ export interface KotlinCaptureSideChannel {
     readonly kind: 'kotlin';
     /** Companion-object scope ids recorded for this file. */
     readonly companionScopes: readonly ScopeId[];
+    /** Package visibility captured from the existing Kotlin AST. */
+    readonly packageFact: JvmPackageFact;
+    /** Class annotation syntax collected by the existing scope traversal. */
+    readonly classAnnotations: readonly ClassAnnotationFact[];
+    /** Spring proxy/advice syntax captured per class or callable owner. */
+    readonly springAopFacts?: readonly KotlinSpringAopFact[];
+    /** Profile, conditional, and auto-configuration syntax captured per owner. */
+    readonly springConditionalFacts?: readonly KotlinSpringConditionalFact[];
+    /** Constructor, property, and method injection syntax captured per class. */
+    readonly springDiFacts?: readonly KotlinSpringDiClassFact[];
+    /** Scheduled, event, messaging, and managed-job handler syntax captured per callable. */
+    readonly springNonHttpHandlerFacts?: readonly KotlinSpringNonHttpHandlerFact[];
 }
+export declare function clearKotlinClassAnnotationFacts(): void;
+export declare function setKotlinSpringAopFacts(filePath: string, facts: readonly KotlinSpringAopFact[]): void;
+export declare function getKotlinSpringAopFacts(filePath: string): readonly KotlinSpringAopFact[];
+export declare function setKotlinClassAnnotationFacts(filePath: string, facts: readonly ClassAnnotationFact[]): void;
+export declare function getKotlinClassAnnotationFacts(filePath: string): readonly ClassAnnotationFact[];
+export declare function setKotlinSpringConditionalFacts(filePath: string, facts: readonly KotlinSpringConditionalFact[]): void;
+export declare function getKotlinSpringConditionalFacts(filePath: string): readonly KotlinSpringConditionalFact[];
+export declare function setKotlinSpringDiFacts(filePath: string, facts: readonly KotlinSpringDiClassFact[]): void;
+export declare function getKotlinSpringDiFacts(filePath: string): readonly KotlinSpringDiClassFact[];
+export declare function setKotlinSpringNonHttpHandlerFacts(filePath: string, facts: readonly KotlinSpringNonHttpHandlerFact[]): void;
+export declare function getKotlinSpringNonHttpHandlerFacts(filePath: string): readonly KotlinSpringNonHttpHandlerFact[];
 /**
  * `LanguageProvider.collectCaptureSideChannel` implementation for Kotlin.
- * Returns `undefined` when this file recorded no companion scopes at all, so
+ * Returns `undefined` when this file recorded no side-channel state at all, so
  * the produced `ParsedFile` carries the field only when there's data to ship.
  */
 export declare function collectKotlinCaptureSideChannel(filePath: string): KotlinCaptureSideChannel | undefined;

package/dist/core/ingestion/languages/kotlin/capture-side-channel.js

@@ -7,6 +7,12 @@
  *   - `companionScopesByFile`  (companion-scopes.ts) — the `ScopeId`s that came
  *     from a `companion_object` AST node, recorded via `markCompanionScope`
  *     from the `@scope.companion` marker capture.
+ *   - Spring Bean class-annotation facts collected during the same scope-query
+ *     traversal, consumed only after imports and package visibility finalize.
+ *   - Spring DI class facts (constructor/property/method injection syntax),
+ *     resolved and attached only after imports finalize.
+ *   - A JVM package fact read from the already-parsed root, so package-sibling
+ *     visibility never re-parses Kotlin source on the main thread.
  *
  * On the worker path that map is filled in the WORKER process and lost across
  * the worker→main MessageChannel (and the disk-backed parsedfile-store),
@@ -25,20 +31,101 @@
  * The single generic `ParsedFile.captureSideChannel` field is shared with C++,
  * which is safe because each file is one language (a `.kt` file uses the kotlin
  * provider, a `.cpp` file the cpp provider). The payload is self-describing
- * (`{ kind: 'kotlin', companionScopes }`) so `applyKotlinCaptureSideChannel`
- * only restores kotlin state and ignores a foreign-shaped snapshot.
+ * (`{ kind: 'kotlin', companionScopes, packageFact, classAnnotations,
+ * springDiFacts }`) so
+ * `applyKotlinCaptureSideChannel` only restores kotlin state and ignores a
+ * foreign-shaped snapshot.
  */
+import { createClassAnnotationFactStore, } from '../../frameworks/spring/bean-candidates.js';
+import { isJvmPackageFact, UNKNOWN_JVM_PACKAGE_FACT, } from '../jvm/package-facts.js';
 import { getCompanionScopesForFile, markCompanionScope } from './companion-scopes.js';
+import { getKotlinPackageFact, setKotlinPackageFact } from './package-facts.js';
+const classAnnotations = createClassAnnotationFactStore();
+const springAopFacts = new Map();
+const springConditionalFacts = new Map();
+const springDiFacts = new Map();
+const springNonHttpHandlerFacts = new Map();
+export function clearKotlinClassAnnotationFacts() {
+    classAnnotations.clear();
+    springAopFacts.clear();
+    springConditionalFacts.clear();
+    springDiFacts.clear();
+    springNonHttpHandlerFacts.clear();
+}
+export function setKotlinSpringAopFacts(filePath, facts) {
+    if (facts.length === 0)
+        springAopFacts.delete(filePath);
+    else
+        springAopFacts.set(filePath, facts);
+}
+export function getKotlinSpringAopFacts(filePath) {
+    return springAopFacts.get(filePath) ?? [];
+}
+export function setKotlinClassAnnotationFacts(filePath, facts) {
+    classAnnotations.set(filePath, facts);
+}
+export function getKotlinClassAnnotationFacts(filePath) {
+    return classAnnotations.get(filePath);
+}
+export function setKotlinSpringConditionalFacts(filePath, facts) {
+    if (facts.length === 0)
+        springConditionalFacts.delete(filePath);
+    else
+        springConditionalFacts.set(filePath, facts);
+}
+export function getKotlinSpringConditionalFacts(filePath) {
+    return springConditionalFacts.get(filePath) ?? [];
+}
+export function setKotlinSpringDiFacts(filePath, facts) {
+    if (facts.length === 0)
+        springDiFacts.delete(filePath);
+    else
+        springDiFacts.set(filePath, facts);
+}
+export function getKotlinSpringDiFacts(filePath) {
+    return springDiFacts.get(filePath) ?? [];
+}
+export function setKotlinSpringNonHttpHandlerFacts(filePath, facts) {
+    if (facts.length === 0)
+        springNonHttpHandlerFacts.delete(filePath);
+    else
+        springNonHttpHandlerFacts.set(filePath, facts);
+}
+export function getKotlinSpringNonHttpHandlerFacts(filePath) {
+    return springNonHttpHandlerFacts.get(filePath) ?? [];
+}
 /**
  * `LanguageProvider.collectCaptureSideChannel` implementation for Kotlin.
- * Returns `undefined` when this file recorded no companion scopes at all, so
+ * Returns `undefined` when this file recorded no side-channel state at all, so
  * the produced `ParsedFile` carries the field only when there's data to ship.
  */
 export function collectKotlinCaptureSideChannel(filePath) {
     const companionScopes = getCompanionScopesForFile(filePath);
-    if (companionScopes.length === 0)
+    const annotationFacts = classAnnotations.get(filePath);
+    const aopFacts = springAopFacts.get(filePath) ?? [];
+    const conditionFacts = springConditionalFacts.get(filePath) ?? [];
+    const diFacts = springDiFacts.get(filePath) ?? [];
+    const nonHttpHandlerFacts = springNonHttpHandlerFacts.get(filePath) ?? [];
+    const packageFact = getKotlinPackageFact(filePath);
+    if (companionScopes.length === 0 &&
+        annotationFacts.length === 0 &&
+        aopFacts.length === 0 &&
+        conditionFacts.length === 0 &&
+        diFacts.length === 0 &&
+        nonHttpHandlerFacts.length === 0 &&
+        packageFact === undefined) {
         return undefined;
-    return { kind: 'kotlin', companionScopes };
+    }
+    return {
+        kind: 'kotlin',
+        companionScopes,
+        packageFact: packageFact ?? UNKNOWN_JVM_PACKAGE_FACT,
+        classAnnotations: annotationFacts,
+        ...(aopFacts.length > 0 ? { springAopFacts: aopFacts } : {}),
+        ...(conditionFacts.length > 0 ? { springConditionalFacts: conditionFacts } : {}),
+        ...(diFacts.length > 0 ? { springDiFacts: diFacts } : {}),
+        ...(nonHttpHandlerFacts.length > 0 ? { springNonHttpHandlerFacts: nonHttpHandlerFacts } : {}),
+    };
 }
 /**
  * `ScopeResolver.applyCaptureSideChannel` implementation for Kotlin. Reads the
@@ -50,11 +137,27 @@ export function collectKotlinCaptureSideChannel(filePath) {
  */
 export function applyKotlinCaptureSideChannel(parsed) {
     const data = parsed.captureSideChannel;
-    if (data === undefined || data === null || typeof data !== 'object')
-        return;
-    if (data.kind !== 'kotlin' || !Array.isArray(data.companionScopes))
+    if (data === undefined ||
+        data === null ||
+        typeof data !== 'object' ||
+        data.kind !== 'kotlin' ||
+        !Array.isArray(data.companionScopes) ||
+        !Array.isArray(data.classAnnotations)) {
+        classAnnotations.set(parsed.filePath, []);
+        setKotlinSpringAopFacts(parsed.filePath, []);
+        setKotlinSpringConditionalFacts(parsed.filePath, []);
+        setKotlinSpringDiFacts(parsed.filePath, []);
+        setKotlinSpringNonHttpHandlerFacts(parsed.filePath, []);
+        setKotlinPackageFact(parsed.filePath, UNKNOWN_JVM_PACKAGE_FACT);
         return;
+    }
     for (const scopeId of data.companionScopes) {
         markCompanionScope(parsed.filePath, scopeId);
     }
+    classAnnotations.set(parsed.filePath, data.classAnnotations);
+    setKotlinSpringAopFacts(parsed.filePath, Array.isArray(data.springAopFacts) ? data.springAopFacts : []);
+    setKotlinSpringConditionalFacts(parsed.filePath, Array.isArray(data.springConditionalFacts) ? data.springConditionalFacts : []);
+    setKotlinSpringDiFacts(parsed.filePath, Array.isArray(data.springDiFacts) ? data.springDiFacts : []);
+    setKotlinSpringNonHttpHandlerFacts(parsed.filePath, Array.isArray(data.springNonHttpHandlerFacts) ? data.springNonHttpHandlerFacts : []);
+    setKotlinPackageFact(parsed.filePath, isJvmPackageFact(data.packageFact) ? data.packageFact : UNKNOWN_JVM_PACKAGE_FACT);
 }

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

@@ -1,4 +1,5 @@
 import { makeScopeId } from '../../../../_shared/index.js';
+import { materializeClassAnnotationFacts, recordClassAnnotationCapture, } from '../../frameworks/spring/bean-candidates.js';
 import { nodeIfType, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
@@ -9,7 +10,50 @@ import { normalizeKotlinType } from './interpret.js';
 import { synthesizeKotlinReceiverBinding } from './receiver-binding.js';
 import { getKotlinParser, getKotlinScopeQuery } from './query.js';
 import { markCompanionScope } from './companion-scopes.js';
+import { setKotlinClassAnnotationFacts, setKotlinSpringAopFacts, setKotlinSpringConditionalFacts, setKotlinSpringDiFacts, setKotlinSpringNonHttpHandlerFacts, } from './capture-side-channel.js';
+import { captureKotlinPackageFact } from './package-facts.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { captureKotlinSpringDiClassFact } from './spring-di.js';
+import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
+import { captureKotlinSpringAopFacts } from './spring-aop.js';
+import { captureKotlinSpringConditionalFacts, } from './spring-conditionals.js';
+import { captureKotlinSpringNonHttpHandlerFacts, } from './spring-non-http-handlers.js';
 const FUNCTION_DECL_TAGS = ['@declaration.function'];
+const KOTLIN_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['function_declaration', 'anonymous_function', 'lambda_literal']),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['function_value_parameters', 'value_arguments']),
+    parameterNodeTypes: new Set(['parameter']),
+    bindingNodeTypes: new Set(['property_declaration']),
+    assignmentNodeTypes: new Set(['assignment']),
+    identifierNodeTypes: new Set(['simple_identifier', 'type_identifier']),
+    callableReferenceNodeTypes: new Set(['callable_reference']),
+    callableProtocolMethods: new Set(['invoke']),
+    functionName: (node) => node.namedChildren.find((child) => child !== null && child.type === 'simple_identifier')?.text,
+    extractAssignment: (node) => {
+        // tree-sitter-kotlin's `assignment` node is FIELDLESS (positional
+        // `directly_assignable_expression` then the value), so the shared
+        // field-based fallback returned nothing and nested reassignments
+        // (`chosen = ::target` inside a block) never produced flow facts
+        // (#2522 review, shallow-coverage gap).
+        if (node.type === 'assignment') {
+            const named = node.namedChildren.filter((child) => child !== null);
+            if (named.length < 2)
+                return undefined;
+            return { destination: named[0], source: named[named.length - 1] };
+        }
+        if (node.type !== 'property_declaration')
+            return undefined;
+        if (!node.children.some((child) => child.text === '='))
+            return undefined;
+        const destination = node.namedChildren.find((child) => child !== null && child.type === 'variable_declaration');
+        const source = [...node.namedChildren]
+            .reverse()
+            .find((child) => child !== null && child.id !== destination?.id && child.type !== 'binding_pattern_kind');
+        return destination === undefined || source === undefined ? undefined : { destination, source };
+    },
+    normalizeQualifiedName: (raw) => raw.replaceAll('::', '.'),
+};
 export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -21,7 +65,16 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     else {
         recordKotlinCacheHit();
     }
+    captureKotlinPackageFact(filePath, tree.rootNode);
     const out = [];
+    const classAnnotations = new Map();
+    const springAopFacts = [];
+    const springAopTypeNodeIds = new Set();
+    const springConditionalFacts = [];
+    const springDiFacts = [];
+    const springNonHttpHandlerFacts = [];
+    const springNonHttpHandlerTypeNodeIds = new Set();
+    const springDiClassNodeIds = new Set();
     const returnTypes = collectKotlinReturnTypeTexts(tree.rootNode);
     out.push(...synthesizeKotlinLocalAssignmentBindings(tree.rootNode, returnTypes));
     out.push(...synthesizeKotlinLoopBindings(tree.rootNode, returnTypes));
@@ -44,6 +97,40 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
         }
         if (Object.keys(grouped).length === 0)
             continue;
+        // tree-sitter-kotlin represents both classes and interfaces with
+        // `class_declaration`; `object_declaration` is the separate object form.
+        const springAopTypeNode = [
+            nodeIfType(groupedNodes['@scope.class'], 'class_declaration'),
+            nodeIfType(groupedNodes['@scope.class'], 'object_declaration'),
+            nodeIfType(groupedNodes['@scope.class'], 'companion_object'),
+        ].find((node) => node !== null);
+        if (springAopTypeNode !== undefined) {
+            if (!springAopTypeNodeIds.has(springAopTypeNode.id)) {
+                springAopTypeNodeIds.add(springAopTypeNode.id);
+                springAopFacts.push(...captureKotlinSpringAopFacts(springAopTypeNode, filePath));
+            }
+            if (!springNonHttpHandlerTypeNodeIds.has(springAopTypeNode.id)) {
+                springNonHttpHandlerTypeNodeIds.add(springAopTypeNode.id);
+                springNonHttpHandlerFacts.push(...captureKotlinSpringNonHttpHandlerFacts(springAopTypeNode, filePath));
+            }
+        }
+        const springDiClassNode = nodeIfType(groupedNodes['@scope.class'], 'class_declaration');
+        if (springDiClassNode !== null && !springDiClassNodeIds.has(springDiClassNode.id)) {
+            springDiClassNodeIds.add(springDiClassNode.id);
+            springConditionalFacts.push(...captureKotlinSpringConditionalFacts(springDiClassNode, filePath));
+            const fact = captureKotlinSpringDiClassFact(springDiClassNode, filePath);
+            if (fact !== null)
+                springDiFacts.push(fact);
+        }
+        const annotatedClass = grouped['@class-annotation.class'];
+        const annotationName = grouped['@class-annotation.name'];
+        if (annotatedClass !== undefined && annotationName !== undefined) {
+            const classNode = nodeIfType(groupedNodes['@class-annotation.class'], 'class_declaration');
+            if (classNode !== null && isKotlinBeanCandidateClass(classNode)) {
+                recordClassAnnotationCapture(classAnnotations, filePath, annotatedClass, annotationName.text);
+            }
+            continue;
+        }
         // Companion-object marker (#1756 / U4). The `@scope.companion`
         // capture is a side-channel marker — it shares its range with the
         // existing `(companion_object) @scope.class` rule, so the Class
@@ -139,6 +226,12 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
             }
         }
         if (grouped['@scope.function'] !== undefined) {
+            // Structural receiver chain for a call whose receiver is itself an
+            // expression, so resolution can type it by folding over structure
+            // instead of re-parsing the receiver's source text. Self-gating: a
+            // non-call match, an absent receiver, or a chain with no nameable base
+            // all leave `grouped` untouched.
+            synthesizeReceiverChainCapture(grouped, groupedNodes['@reference.receiver']);
             out.push(grouped);
             const fnNode = nodeIfType(groupedNodes['@scope.function'], 'function_declaration');
             if (fnNode !== null) {
@@ -171,13 +264,32 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
                 grouped['@reference.parameter-types'] = syntheticCapture('@reference.parameter-types', callNode, JSON.stringify(args.map(inferArgType)));
             }
         }
+        // Structural receiver chain for a call whose receiver is itself an
+        // expression, so resolution can type it by folding over structure
+        // instead of re-parsing the receiver's source text. Self-gating: a
+        // non-call match, an absent receiver, or a chain with no nameable base
+        // all leave `grouped` untouched.
+        synthesizeReceiverChainCapture(grouped, groupedNodes['@reference.receiver']);
         out.push(grouped);
         const extensionFallback = extensionFreeCallFallback(grouped, groupedNodes);
         if (extensionFallback !== null)
             out.push(extensionFallback);
     }
+    setKotlinClassAnnotationFacts(filePath, materializeClassAnnotationFacts(classAnnotations));
+    setKotlinSpringAopFacts(filePath, springAopFacts);
+    setKotlinSpringConditionalFacts(filePath, springConditionalFacts);
+    setKotlinSpringDiFacts(filePath, springDiFacts);
+    setKotlinSpringNonHttpHandlerFacts(filePath, springNonHttpHandlerFacts);
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, KOTLIN_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
+function isKotlinBeanCandidateClass(classNode) {
+    if (classNode.children.some((child) => child.type === 'interface' || child.type === 'enum')) {
+        return false;
+    }
+    const modifiers = classNode.namedChildren.find((child) => child.type === 'modifiers');
+    return !modifiers?.namedChildren.some((child) => child.type === 'class_modifier' && child.text.trim() === 'annotation');
+}
 /**
  * Synthesize `@reference.inherits` captures from Kotlin `class_declaration`
  * delegation specifiers so the registry-primary scope-resolution path emits

package/dist/core/ingestion/languages/kotlin/import-target.d.ts

@@ -1,6 +1,13 @@
-import type { ParsedImport, WorkspaceIndex } from '../../../../_shared/index.js';
+/**
+ * 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 type { ParsedFile, ParsedImport, WorkspaceIndex } from '../../../../_shared/index.js';
 export interface KotlinResolveContext {
     readonly fromFile: string;
     readonly allFilePaths: ReadonlySet<string>;
+    /** Stable parsed-workspace identity supplied by the resolution pass. */
+    readonly parsedFiles?: readonly ParsedFile[];
 }
 export declare function resolveKotlinImportTarget(parsedImport: ParsedImport, workspaceIndex: WorkspaceIndex): string | readonly string[] | null;