gitnexus 1.6.9 → 1.6.10-aptos.0

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

@@ -0,0 +1,40 @@
+export const UNKNOWN_JVM_PACKAGE_FACT = Object.freeze({ status: 'unknown' });
+/** Validate a package fact restored from an opaque worker payload. */
+export function isJvmPackageFact(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const fact = value;
+    return (fact.status === 'unknown' || (fact.status === 'known' && typeof fact.packageName === 'string'));
+}
+/**
+ * Create one language-local package fact store.
+ *
+ * Package facts are captured while the language's scope extractor already
+ * owns a tree-sitter Tree, then serialized through ParsedFile's side-channel.
+ * Resolution hooks consume only this plain data and never parse source again.
+ */
+export function createJvmPackageFactStore(options) {
+    const factsByFile = new Map();
+    return {
+        clear: () => factsByFile.clear(),
+        capture: (filePath, root) => factsByFile.set(filePath, extractJvmPackageFact(root, options)),
+        set: (filePath, fact) => factsByFile.set(filePath, fact),
+        get: (filePath) => factsByFile.get(filePath),
+    };
+}
+export function extractJvmPackageFact(root, options) {
+    const packageNode = root.namedChildren.find((child) => child.type === options.packageNodeType);
+    if (packageNode === undefined) {
+        // A syntax error elsewhere in a default-package file does not make its
+        // package ambiguous. Only a top-level ERROR that contains the reserved
+        // package keyword is evidence of a malformed package header.
+        const malformedHeader = root.namedChildren.some((child) => child.type === 'ERROR' && /\bpackage\b/.test(child.text));
+        return malformedHeader ? UNKNOWN_JVM_PACKAGE_FACT : { status: 'known', packageName: '' };
+    }
+    const nameNode = packageNode.namedChildren.find((child) => options.packageNameNodeTypes.includes(child.type));
+    const packageName = nameNode?.text.trim();
+    if (packageNode.hasError || packageName === undefined || packageName.length === 0) {
+        return UNKNOWN_JVM_PACKAGE_FACT;
+    }
+    return { status: 'known', packageName };
+}

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

@@ -0,0 +1,14 @@
+import type { ParsedFile } from '../../../../_shared/index.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import type { JvmPackageFact } from './package-facts.js';
+export interface JvmPackageSiblingOptions {
+    readonly languageLabel: string;
+    readonly getPackageFact: (filePath: string) => JvmPackageFact | undefined;
+}
+export interface JvmPackageSiblingVisibility {
+    readonly populateNamespaceSiblings: (parsedFiles: readonly ParsedFile[], indexes: ScopeResolutionIndexes, ctx: {
+        readonly fileContents: ReadonlyMap<string, string>;
+    }) => void;
+    readonly isVisibilityIncomplete: (filePath: string) => boolean;
+}
+export declare function createJvmPackageSiblingVisibility(options: JvmPackageSiblingOptions): JvmPackageSiblingVisibility;

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

@@ -0,0 +1,129 @@
+import { logger } from '../../../logger.js';
+import { isClassLike } from '../../scope-resolution/scope/walkers.js';
+const MAX_PACKAGE_FILES = 500;
+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;
+        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 });
+                }
+            }
+            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 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(candidate.filePath, filePath));
+                    }
+                }
+                candidates.sort((a, b) => (proximityCache.get(b.filePath) ?? 0) - (proximityCache.get(a.filePath) ?? 0));
+                const injectedIds = new Set();
+                for (const { def } of candidates) {
+                    if (injectedIds.has(def.nodeId) || def.qualifiedName === undefined)
+                        continue;
+                    injectedIds.add(def.nodeId);
+                    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' });
+                }
+                const typeBindings = scope.typeBindings;
+                for (const sibling of bucket.moduleScopes) {
+                    if (sibling.filePath === filePath)
+                        continue;
+                    for (const [name, ref] of sibling.scope.typeBindings) {
+                        if (!typeBindings.has(name))
+                            typeBindings.set(name, ref);
+                    }
+                }
+                for (const sibling of bucket.parsed) {
+                    if (sibling.filePath === filePath)
+                        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);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return {
+        populateNamespaceSiblings,
+        isVisibilityIncomplete: (filePath) => incompleteFiles.has(filePath),
+    };
+}
+function sharedSegmentCount(a, b) {
+    const aSegments = a.replace(/\\/g, '/').split('/');
+    const bSegments = b.replace(/\\/g, '/').split('/');
+    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,10 @@
  *   - `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.
+ *   - 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 +29,13 @@
  * 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 }`) 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';
 /**
  * Plain JSON-serializable snapshot of the per-file Kotlin capture-time
  * side-channel. Carried opaquely on `ParsedFile.captureSideChannel`. The
@@ -39,10 +46,17 @@ 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[];
 }
+export declare function clearKotlinClassAnnotationFacts(): void;
+export declare function setKotlinClassAnnotationFacts(filePath: string, facts: readonly ClassAnnotationFact[]): void;
+export declare function getKotlinClassAnnotationFacts(filePath: string): readonly ClassAnnotationFact[];
 /**
  * `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,10 @@
  *   - `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.
+ *   - 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 +29,42 @@
  * 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 }`) 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();
+export function clearKotlinClassAnnotationFacts() {
+    classAnnotations.clear();
+}
+export function setKotlinClassAnnotationFacts(filePath, facts) {
+    classAnnotations.set(filePath, facts);
+}
+export function getKotlinClassAnnotationFacts(filePath) {
+    return classAnnotations.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 packageFact = getKotlinPackageFact(filePath);
+    if (companionScopes.length === 0 && annotationFacts.length === 0 && packageFact === undefined) {
         return undefined;
-    return { kind: 'kotlin', companionScopes };
+    }
+    return {
+        kind: 'kotlin',
+        companionScopes,
+        packageFact: packageFact ?? UNKNOWN_JVM_PACKAGE_FACT,
+        classAnnotations: annotationFacts,
+    };
 }
 /**
  * `ScopeResolver.applyCaptureSideChannel` implementation for Kotlin. Reads the
@@ -50,11 +76,19 @@ 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, []);
+        setKotlinPackageFact(parsed.filePath, UNKNOWN_JVM_PACKAGE_FACT);
         return;
+    }
     for (const scopeId of data.companionScopes) {
         markCompanionScope(parsed.filePath, scopeId);
     }
+    classAnnotations.set(parsed.filePath, data.classAnnotations);
+    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,45 @@ 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 } from './capture-side-channel.js';
+import { captureKotlinPackageFact } from './package-facts.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.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 +60,9 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     else {
         recordKotlinCacheHit();
     }
+    captureKotlinPackageFact(filePath, tree.rootNode);
     const out = [];
+    const classAnnotations = new Map();
     const returnTypes = collectKotlinReturnTypeTexts(tree.rootNode);
     out.push(...synthesizeKotlinLocalAssignmentBindings(tree.rootNode, returnTypes));
     out.push(...synthesizeKotlinLoopBindings(tree.rootNode, returnTypes));
@@ -44,6 +85,15 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
         }
         if (Object.keys(grouped).length === 0)
             continue;
+        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
@@ -176,8 +226,17 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
         if (extensionFallback !== null)
             out.push(extensionFallback);
     }
+    setKotlinClassAnnotationFacts(filePath, materializeClassAnnotationFacts(classAnnotations));
+    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/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
@@ -91,6 +97,19 @@ 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
 (function_declaration
   (simple_identifier) @declaration.name) @declaration.function

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

@@ -5,8 +5,11 @@ import { isClassLike } from '../../scope-resolution/scope/walkers.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 { clearKotlinPackageFacts } from './package-facts.js';
 /**
  * Kotlin scope resolver for RFC #909 Ring 3.
  *
@@ -57,6 +60,8 @@ export const kotlinScopeResolver = {
         // `undefined` because Kotlin has no external resolution config
         // to load.
         clearCompanionScopes();
+        clearKotlinClassAnnotationFacts();
+        clearKotlinPackageFacts();
         return undefined;
     },
     resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
@@ -89,6 +94,9 @@ export const kotlinScopeResolver = {
     propagatesReturnTypesAcrossImports: true,
     collapseMemberCallsByCallerTarget: false,
     hoistTypeBindingsToModule: true,
+    postExtractSourceTextPolicy: 'uncached-files',
+    populateNamespaceSiblings: populateKotlinPackageSiblings,
+    emitPostResolutionEdges: attachKotlinSpringBeanCandidateMetadata,
 };
 /**
  * Kotlin MRO builder — extends `defaultLinearize` (EXTENDS-only) with

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.js

@@ -167,12 +167,11 @@ export const kotlinProvider = defineLanguage({
     emitScopeCaptures: emitKotlinScopeCaptures,
     // ── #2195 PDG layer: Kotlin CFG visitor (vendored grammar) ──
     cfgVisitor: createKotlinCfgVisitor(),
-    // Worker-side: snapshot the module-level companion-scope marks
-    // `emitKotlinScopeCaptures` just populated for this file (`markCompanionScope`
-    // → `companionScopesByFile`) into plain data on `ParsedFile.captureSideChannel`,
-    // so the main thread can restore them via `applyCaptureSideChannel` WITHOUT a
-    // re-parse (#1983). Without this, companion/static dispatch emits no CALLS
-    // edges on the worker path. See `kotlin/capture-side-channel.ts`.
+    // Worker-side: snapshot companion-scope marks, package visibility, and
+    // class-annotation facts `emitKotlinScopeCaptures` just populated into plain
+    // data on `ParsedFile.captureSideChannel`, so the main thread can restore all
+    // three via `applyCaptureSideChannel` WITHOUT a re-parse (#1983). See
+    // `kotlin/capture-side-channel.ts`.
     // `assertCloneable` is a runtime identity; it makes a future non-serializable
     // value in the side-channel payload a compile error here, at the source, rather
     // than a DataCloneError at the worker boundary (#2143).

package/dist/core/ingestion/languages/move.d.ts

@@ -0,0 +1 @@
+export declare const moveProvider: import("../language-provider.js").LanguageProvider;

package/dist/core/ingestion/languages/move.js

@@ -0,0 +1,27 @@
+/**
+ * Move Language Provider (stub).
+ *
+ * Move/Aptos is ingested compiler-first via the move-flow MCP server in the
+ * `moveIngest` phase — GitNexus never tree-sits or regex-scans Move source.
+ * This provider exists only to satisfy the exhaustive `SupportedLanguages`
+ * provider table; it declares no extensions, so `.move` files are never routed
+ * through the generic tree-sitter / scope-resolution pipeline (the `parse`
+ * phase additionally excludes every file ingested by `moveIngest`).
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { defineLanguage } from '../language-provider.js';
+export const moveProvider = defineLanguage({
+    id: SupportedLanguages.Move,
+    parseStrategy: 'standalone',
+    extensions: [], // .move files are handled by the moveIngest phase, not here
+    entryPointPatterns: [],
+    astFrameworkPatterns: [],
+    treeSitterQueries: '',
+    typeConfig: {
+        declarationNodeTypes: new Set(),
+        extractDeclaration: () => null,
+        extractParameter: () => null,
+    },
+    exportChecker: () => false,
+    importResolver: () => null,
+});

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

@@ -38,6 +38,36 @@ import { getPhpParser, getPhpScopeQuery } from './query.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+const PHP_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set([
+        'function_definition',
+        'method_declaration',
+        'anonymous_function',
+        'arrow_function',
+    ]),
+    callNodeTypes: new Set(['function_call_expression']),
+    parameterListNodeTypes: new Set(['formal_parameters', 'arguments']),
+    // tree-sitter-php has no 'optional_parameter' node (defaults ride on
+    // simple_parameter); property promotion is constructor-only and carries no
+    // callable-flow value (#2522 review).
+    parameterNodeTypes: new Set(['simple_parameter', 'variadic_parameter']),
+    bindingNodeTypes: new Set(['assignment_expression']),
+    assignmentNodeTypes: new Set(['assignment_expression']),
+    identifierNodeTypes: new Set(['name', 'qualified_name', 'namespace_name']),
+    functionScopedValueBindings: true,
+    emitCanonicalInvokeReference: true,
+    extractCallableReference: (node) => {
+        if (node.type !== 'function_call_expression')
+            return undefined;
+        const args = node.childForFieldName('arguments');
+        const isFirstClass = args?.namedChildren.some((child) => child !== null && child.type === 'variadic_placeholder') === true;
+        const target = node.childForFieldName('function');
+        if (!isFirstClass || target === null || target.type === 'variable_name')
+            return undefined;
+        return { name: target.text.replace(/^\\+/, ''), anchor: target };
+    },
+};
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = ['@declaration.method', '@declaration.function'];
 /** tree-sitter-php node types that the method extractor accepts. */
@@ -220,6 +250,15 @@ export function emitPhpScopeCaptures(sourceText, _filePath, cachedTree) {
         // the backing `arguments` node. Mirrors C#'s pattern (csharp/captures.ts
         // lines 149-186). PHP needs this for arity-based dispatch (Cluster H).
         const callTag = ['@reference.call.free', '@reference.call.member', '@reference.call.constructor'].find((t) => grouped[t] !== undefined);
+        if (callTag !== undefined) {
+            const possibleFirstClass = nodeIfType(nodeMap[callTag], 'function_call_expression');
+            const argumentsNode = possibleFirstClass?.childForFieldName('arguments');
+            if (argumentsNode?.namedChildren.some((child) => child !== null && child.type === 'variadic_placeholder') === true) {
+                // PHP 8.1 `target(...)` creates a Closure; it does not invoke target.
+                // Callable-flow synthesis below owns this site as a seed.
+                continue;
+            }
+        }
         if (callTag !== undefined && grouped['@reference.arity'] === undefined) {
             const callNode = nodeIfType(nodeMap[callTag], 'function_call_expression', 'member_call_expression', 'nullsafe_member_call_expression', 'scoped_call_expression', 'object_creation_expression');
             if (callNode !== null) {
@@ -242,6 +281,7 @@ export function emitPhpScopeCaptures(sourceText, _filePath, cachedTree) {
         out.push(grouped);
     }
     out.push(...synthesizePhpInheritanceReferences(tree.rootNode));
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, PHP_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
 // ─── PHP inheritance synthesis ───────────────────────────────────────────────