gitnexus 1.6.9 → 1.6.10-aptos.0

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

@@ -0,0 +1,9 @@
+import { createJvmPackageFactStore, } from '../jvm/package-facts.js';
+const javaPackageFacts = createJvmPackageFactStore({
+    packageNodeType: 'package_declaration',
+    packageNameNodeTypes: ['scoped_identifier', 'identifier'],
+});
+export const clearJavaPackageFacts = () => javaPackageFacts.clear();
+export const captureJavaPackageFact = (filePath, root) => javaPackageFacts.capture(filePath, root);
+export const setJavaPackageFact = (filePath, fact) => javaPackageFacts.set(filePath, fact);
+export const getJavaPackageFact = (filePath) => javaPackageFacts.get(filePath);

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

@@ -1,17 +1,4 @@
-/**
- * Java package-scope implicit visibility.
- *
- * Classes in the same Java package see each other without explicit
- * `import` statements.  This hook groups files by `package` declaration,
- * then injects cross-file class defs into each file's module-scope
- * `bindingAugmentations` and mirrors type-bindings across same-package
- * files — the Java equivalent of C#'s `populateNamespaceSiblings`.
- */
-import type { ParsedFile } from '../../../../_shared/index.js';
-import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
-export declare function populateJavaPackageSiblings(parsedFiles: readonly ParsedFile[], indexes: ScopeResolutionIndexes, ctx: {
+export declare const populateJavaPackageSiblings: (parsedFiles: readonly import('../../../../_shared/index.js').ParsedFile[], indexes: import("../../model/scope-resolution-indexes.js").ScopeResolutionIndexes, ctx: {
     readonly fileContents: ReadonlyMap<string, string>;
-    readonly treeCache?: {
-        get(filePath: string): unknown;
-    };
-}): void;
+}) => void;
+export declare const isJavaPackageSiblingVisibilityIncomplete: (filePath: string) => boolean;

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

@@ -1,147 +1,8 @@
-/**
- * Java package-scope implicit visibility.
- *
- * Classes in the same Java package see each other without explicit
- * `import` statements.  This hook groups files by `package` declaration,
- * then injects cross-file class defs into each file's module-scope
- * `bindingAugmentations` and mirrors type-bindings across same-package
- * files — the Java equivalent of C#'s `populateNamespaceSiblings`.
- */
-import { isClassLike } from '../../scope-resolution/scope/walkers.js';
-import { getJavaParser } from './query.js';
-import { parseSourceSafe, ParseTimeoutError } from '../../../tree-sitter/safe-parse.js';
-import { logger } from '../../../logger.js';
-function extractPackageName(content, filePath, cachedTree) {
-    let tree = cachedTree;
-    if (tree === undefined) {
-        try {
-            tree = parseSourceSafe(getJavaParser(), content);
-        }
-        catch (err) {
-            if (err instanceof ParseTimeoutError) {
-                // Degrade to "no package" so a single pathological file doesn't abort
-                // same-package sibling injection for the whole run.
-                logger.warn({ file: filePath }, 'java package-siblings: parse timed out, treating as no package');
-                return '';
-            }
-            throw err;
-        }
-    }
-    for (const child of tree.rootNode.namedChildren) {
-        if (child.type === 'package_declaration') {
-            const scoped = child.namedChildren.find((c) => c.type === 'scoped_identifier' || c.type === 'identifier');
-            return scoped?.text ?? '';
-        }
-    }
-    return '';
-}
-export function populateJavaPackageSiblings(parsedFiles, indexes, ctx) {
-    const buckets = new Map();
-    for (const parsed of parsedFiles) {
-        const content = ctx.fileContents.get(parsed.filePath);
-        if (content === undefined)
-            continue;
-        const pkg = extractPackageName(content, parsed.filePath, ctx.treeCache?.get(parsed.filePath));
-        let bucket = buckets.get(pkg);
-        if (bucket === undefined) {
-            bucket = { parsed: [], moduleScopes: [] };
-            buckets.set(pkg, bucket);
-        }
-        bucket.parsed.push(parsed);
-        const ms = parsed.scopes.find((s) => s.kind === 'Module');
-        if (ms !== undefined) {
-            bucket.moduleScopes.push({ filePath: parsed.filePath, scope: ms });
-        }
-    }
-    const augmentations = indexes.bindingAugmentations;
-    const MAX_PACKAGE_FILES = 500;
-    for (const bucket of buckets.values()) {
-        if (bucket.moduleScopes.length < 2)
-            continue;
-        if (bucket.moduleScopes.length > MAX_PACKAGE_FILES) {
-            logger.warn(`[java-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 moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
-            const moduleScopeId = moduleScope?.id;
-            for (const scope of parsed.scopes) {
-                if (scope.kind !== 'Class')
-                    continue;
-                if (scope.parent !== moduleScopeId)
-                    continue;
-                for (const def of scope.ownedDefs) {
-                    if (isClassLike(def.type)) {
-                        classDefs.push({ def, filePath: parsed.filePath });
-                        break;
-                    }
-                }
-            }
-        }
-        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 candidates = classDefs.filter((d) => d.filePath !== filePath);
-            const proximityCache = new Map();
-            for (const c of candidates) {
-                if (!proximityCache.has(c.filePath)) {
-                    proximityCache.set(c.filePath, sharedSegmentCount(c.filePath, filePath));
-                }
-            }
-            const sorted = candidates.sort((a, b) => (proximityCache.get(b.filePath) ?? 0) - (proximityCache.get(a.filePath) ?? 0));
-            const injectedIds = new Set();
-            for (const { def } of sorted) {
-                if (injectedIds.has(def.nodeId))
-                    continue;
-                const qn = def.qualifiedName;
-                if (qn === undefined)
-                    continue;
-                injectedIds.add(def.nodeId);
-                const simpleName = qn.includes('.') ? qn.slice(qn.lastIndexOf('.') + 1) : qn;
-                let list = scopeAug.get(simpleName);
-                if (list === undefined) {
-                    list = [];
-                    scopeAug.set(simpleName, list);
-                }
-                list.push({ def, origin: 'namespace' });
-            }
-            const tb = scope.typeBindings;
-            for (const sibling of bucket.moduleScopes) {
-                if (sibling.filePath === filePath)
-                    continue;
-                for (const [name, ref] of sibling.scope.typeBindings) {
-                    if (tb.has(name))
-                        continue;
-                    tb.set(name, ref);
-                }
-            }
-            for (const sibParsed of bucket.parsed) {
-                if (sibParsed.filePath === filePath)
-                    continue;
-                for (const sibScope of sibParsed.scopes) {
-                    if (sibScope.kind !== 'Class')
-                        continue;
-                    for (const [name, ref] of sibScope.typeBindings) {
-                        if (ref.source === 'self')
-                            continue;
-                        if (tb.has(name))
-                            continue;
-                        tb.set(name, ref);
-                    }
-                }
-            }
-        }
-    }
-}
-function sharedSegmentCount(a, b) {
-    const sa = a.replace(/\\/g, '/').split('/');
-    const sb = b.replace(/\\/g, '/').split('/');
-    let i = 0;
-    while (i < sa.length && i < sb.length && sa[i] === sb[i])
-        i++;
-    return i;
-}
+import { createJvmPackageSiblingVisibility } from '../jvm/package-siblings.js';
+import { getJavaPackageFact } from './package-facts.js';
+const javaPackageSiblingVisibility = createJvmPackageSiblingVisibility({
+    languageLabel: 'java',
+    getPackageFact: getJavaPackageFact,
+});
+export const populateJavaPackageSiblings = javaPackageSiblingVisibility.populateNamespaceSiblings;
+export const isJavaPackageSiblingVisibilityIncomplete = javaPackageSiblingVisibility.isVisibilityIncomplete;

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

@@ -37,6 +37,20 @@ const JAVA_SCOPE_QUERY = `
 (record_declaration) @scope.class
 (annotation_type_declaration) @scope.class
 
+;; Anonymous class body: \`new Runnable() { public void run() {} }\`.
+;; Without its own scope, a method's auto-hoist (scope-extractor.ts) has
+;; nowhere to stop and leaks the name past the anonymous class into the
+;; enclosing scope -- the same failure mode fixed for TS/JS object
+;; literals (#2545).
+(object_creation_expression
+  (class_body) @scope.class)
+
+;; Enum constant body: \`enum E { A { public void hook() {} } }\` --
+;; javac's other anonymous-class shape (E$N), same scope-boundary need
+;; and same class_body anchor (#2555).
+(enum_constant
+  body: (class_body) @scope.class)
+
 (method_declaration) @scope.function
 (constructor_declaration) @scope.function
 
@@ -56,6 +70,15 @@ const JAVA_SCOPE_QUERY = `
 (annotation_type_declaration
   name: (identifier) @declaration.name) @declaration.class
 
+;; Class annotation syntax is carried to post-resolution enrichment. Keeping
+;; this in the existing scope query avoids a second AST build/traversal.
+(class_declaration
+  (modifiers
+    [
+      (marker_annotation name: (_) @class-annotation.name)
+      (annotation name: (_) @class-annotation.name)
+    ])) @class-annotation.class
+
 ;; Declarations — methods / constructors
 (method_declaration
   name: (identifier) @declaration.name) @declaration.method

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

@@ -13,10 +13,22 @@ import { followChainPostFinalize } from '../../scope-resolution/passes/imported-
 import { javaProvider } from '../java.js';
 import { javaArityCompatibility, javaMergeBindings, resolveJavaImportTarget, } from './index.js';
 import { populateJavaPackageSiblings } from './package-siblings.js';
+import { attachSpringBeanCandidateMetadata } from './spring-bean-metadata.js';
+import { attachJavaSpringConfigBindings } from './spring-config-bindings.js';
+import { applyJavaCaptureSideChannel, clearJavaClassAnnotationFacts, } from './capture-side-channel.js';
+import { clearJavaPackageFacts } from './package-facts.js';
 const javaScopeResolver = {
     language: SupportedLanguages.Java,
     languageProvider: javaProvider,
     importEdgeReason: 'java-scope: import',
+    loadResolutionConfig: () => {
+        // Worker capture facts are process-local and outlive a single analysis in
+        // server mode. This hook runs once before each Java workspace pass, before
+        // ParsedFile side channels are restored for the current files.
+        clearJavaClassAnnotationFacts();
+        clearJavaPackageFacts();
+        return undefined;
+    },
     resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
         const ws = { fromFile, allFilePaths };
         return resolveJavaImportTarget({ kind: 'named', localName: '_', importedName: '_', targetRaw }, ws);
@@ -25,14 +37,25 @@ const javaScopeResolver = {
     arityCompatibility: (callsite, def) => javaArityCompatibility(def, callsite),
     buildMro: buildJavaMro,
     populateOwners: (parsed) => populateClassOwnedMembers(parsed),
+    applyCaptureSideChannel: applyJavaCaptureSideChannel,
     isSuperReceiver: (text) => text.trim() === 'super',
     fieldFallbackOnMethodLookup: false,
     propagatesReturnTypesAcrossImports: true,
     collapseMemberCallsByCallerTarget: true,
     hoistTypeBindingsToModule: true,
     stripReceiverCastExpressions: true,
+    // #2550: every Java method belongs to a class instance — a free call may
+    // resolve to a Method only when the caller's enclosing class chain
+    // (self + MRO) contains the method's owner. Closes the finalize-bucket
+    // leak (unqualified `run()` matching an unrelated same-file anonymous
+    // class's method). C# is the intended next adopter.
+    freeCallsRequireInstanceOwnership: true,
     populateNamespaceSiblings: populateJavaPackageSiblings,
     populateRangeBindings: populateJavaCrossFileReturnTypes,
+    emitPostResolutionEdges: (graph, parsedFiles, nodeLookup, indexes, ctx) => {
+        attachSpringBeanCandidateMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachJavaSpringConfigBindings(graph, parsedFiles, nodeLookup, indexes, ctx);
+    },
 };
 export { javaScopeResolver };
 function populateJavaCrossFileReturnTypes(parsedFiles, indexes) {

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

@@ -0,0 +1,2 @@
+/** Java wiring for the language-neutral Spring candidate engine. */
+export declare const attachSpringBeanCandidateMetadata: (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/java/spring-bean-metadata.js

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

package/dist/core/ingestion/languages/java/spring-config-bindings.d.ts

@@ -0,0 +1,23 @@
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import { type ParsedFile, type ScopeId } from '../../../../_shared/index.js';
+import { type SpringConfigConsumer } from '../../frameworks/spring/config-bindings.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+export interface JavaSpringConfigConsumerFact {
+    readonly consumer: SpringConfigConsumer;
+    readonly annotationName: string;
+    readonly classScopeId: ScopeId;
+}
+/** Extract statically readable Spring placeholder keys from a Java annotation. */
+export declare function parseValuePlaceholderKeys(annotation: SyntaxNode): string[];
+/** Extract `prefix`/`value` (or the positional value) from the annotation. */
+export declare function parseConfigurationPropertiesPrefix(annotation: SyntaxNode): string | null;
+/** Collect config facts from the Java parser's existing AST (no reparse). */
+export declare function captureJavaSpringConfigConsumerFacts(root: SyntaxNode, filePath: string): JavaSpringConfigConsumerFact[];
+/** Parse Java consumers for focused unit tests; production reuses the worker AST. */
+export declare function extractJavaSpringConfigConsumers(source: string): SpringConfigConsumer[];
+/** Java ScopeResolver post-resolution hook for Spring configuration consumers. */
+export declare function attachJavaSpringConfigBindings(graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], _nodeLookup: GraphNodeLookup, indexes: ScopeResolutionIndexes, _ctx: {
+    readonly fileContents: ReadonlyMap<string, string>;
+}): void;

package/dist/core/ingestion/languages/java/spring-config-bindings.js

@@ -0,0 +1,215 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { bindSpringConfigConsumers, } from '../../frameworks/spring/config-bindings.js';
+import { createSpringAnnotationNameResolver } from '../../frameworks/spring/bean-candidates.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { getJavaParser } from './query.js';
+import { getJavaSpringConfigConsumerFacts } from './capture-side-channel.js';
+import { isJavaPackageSiblingVisibilityIncomplete } from './package-siblings.js';
+const VALUE_ANNOTATION = 'org.springframework.beans.factory.annotation.Value';
+const CONFIGURATION_PROPERTIES_ANNOTATION = 'org.springframework.boot.context.properties.ConfigurationProperties';
+function collectJavaImports(root) {
+    const exact = new Set();
+    const wildcard = new Set();
+    const localTypes = new Set();
+    for (const node of root.descendantsOfType('import_declaration')) {
+        const imported = node.text
+            .replace(/^\s*import\s+(?:static\s+)?/, '')
+            .replace(/;\s*$/, '')
+            .trim();
+        if (imported.endsWith('.*'))
+            wildcard.add(imported.slice(0, -2));
+        else
+            exact.add(imported);
+    }
+    for (const type of [
+        'class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+        'record_declaration',
+        'annotation_type_declaration',
+    ]) {
+        for (const node of root.descendantsOfType(type)) {
+            const name = node.childForFieldName('name')?.text;
+            if (name)
+                localTypes.add(name);
+        }
+    }
+    return { exact, wildcard, localTypes };
+}
+function annotationsOn(node) {
+    const modifiers = node.namedChildren.find((child) => child.type === 'modifiers');
+    if (modifiers === undefined)
+        return [];
+    const annotations = [];
+    for (const child of modifiers.namedChildren) {
+        if (child.type !== 'annotation' && child.type !== 'marker_annotation')
+            continue;
+        const name = child.childForFieldName('name')?.text ?? child.firstNamedChild?.text;
+        if (name)
+            annotations.push({ name, node: child });
+    }
+    return annotations;
+}
+function resolvesToAnnotation(rawName, canonicalName, imports) {
+    if (rawName.includes('.'))
+        return rawName === canonicalName;
+    if (imports.localTypes.has(rawName))
+        return false;
+    if (imports.exact.has(canonicalName))
+        return true;
+    const packageName = canonicalName.slice(0, canonicalName.lastIndexOf('.'));
+    return imports.wildcard.has(packageName);
+}
+function decodeJavaStringLiteral(literal) {
+    const delimiterLength = literal.startsWith('"""') && literal.endsWith('"""') ? 3 : 1;
+    return literal
+        .slice(delimiterLength, -delimiterLength)
+        .replace(/\\u([0-9a-fA-F]{4})/g, (_match, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
+        .replace(/\\(["'\\btnfr])/g, (_match, escaped) => {
+        const controls = {
+            b: '\b',
+            t: '\t',
+            n: '\n',
+            f: '\f',
+            r: '\r',
+        };
+        return controls[escaped] ?? escaped;
+    });
+}
+function javaStringLiterals(annotation) {
+    return annotation
+        .descendantsOfType('string_literal')
+        .map((literal) => decodeJavaStringLiteral(literal.text));
+}
+/** Extract statically readable Spring placeholder keys from a Java annotation. */
+export function parseValuePlaceholderKeys(annotation) {
+    const keys = new Set();
+    for (const literal of javaStringLiterals(annotation)) {
+        for (const match of literal.matchAll(/\$\{([^{}]+)\}/g)) {
+            const key = match[1].split(':', 1)[0].trim();
+            if (/^[A-Za-z0-9_.-]+$/.test(key))
+                keys.add(key);
+        }
+    }
+    return [...keys];
+}
+/** Extract `prefix`/`value` (or the positional value) from the annotation. */
+export function parseConfigurationPropertiesPrefix(annotation) {
+    const named = annotation.descendantsOfType('element_value_pair').find((pair) => {
+        const key = pair.childForFieldName('key')?.text;
+        return key === 'prefix' || key === 'value';
+    });
+    const namedValue = named?.childForFieldName('value');
+    const argumentsNode = annotation.childForFieldName('arguments');
+    const literalNode = (namedValue?.type === 'string_literal'
+        ? namedValue
+        : namedValue?.descendantsOfType('string_literal')[0]) ??
+        (named === undefined
+            ? argumentsNode?.namedChildren.find((child) => child.type === 'string_literal')
+            : undefined);
+    if (literalNode === undefined)
+        return null;
+    const prefix = decodeJavaStringLiteral(literalNode.text)
+        .trim()
+        .replace(/^\.+|\.+$/g, '');
+    return /^[A-Za-z0-9_.-]+$/.test(prefix) ? prefix : null;
+}
+function classScopeId(filePath, declaration) {
+    return makeScopeId({
+        filePath,
+        range: nodeToCapture('@scope.class', declaration).range,
+        kind: 'Class',
+    });
+}
+function enclosingClass(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === 'class_declaration' || current.type === 'record_declaration') {
+            return current;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+/** Collect config facts from the Java parser's existing AST (no reparse). */
+export function captureJavaSpringConfigConsumerFacts(root, filePath) {
+    const imports = collectJavaImports(root);
+    const facts = [];
+    for (const field of root.descendantsOfType('field_declaration')) {
+        const annotations = annotationsOn(field).filter((annotation) => resolvesToAnnotation(annotation.name, VALUE_ANNOTATION, imports));
+        if (annotations.length === 0)
+            continue;
+        const owner = enclosingClass(field);
+        if (owner === undefined)
+            continue;
+        for (const declarator of field.namedChildren.filter((child) => child.type === 'variable_declarator')) {
+            const fieldName = declarator.childForFieldName('name')?.text;
+            if (!fieldName)
+                continue;
+            for (const annotation of annotations) {
+                const keys = parseValuePlaceholderKeys(annotation.node);
+                if (keys.length > 0) {
+                    facts.push({
+                        consumer: { kind: 'value', fieldName, line: field.startPosition.row + 1, keys },
+                        annotationName: annotation.name,
+                        classScopeId: classScopeId(filePath, owner),
+                    });
+                }
+            }
+        }
+    }
+    for (const type of ['class_declaration', 'record_declaration']) {
+        for (const declaration of root.descendantsOfType(type)) {
+            const className = declaration.childForFieldName('name')?.text;
+            if (!className)
+                continue;
+            for (const annotation of annotationsOn(declaration)) {
+                if (!resolvesToAnnotation(annotation.name, CONFIGURATION_PROPERTIES_ANNOTATION, imports)) {
+                    continue;
+                }
+                const prefix = parseConfigurationPropertiesPrefix(annotation.node);
+                if (prefix !== null) {
+                    facts.push({
+                        consumer: {
+                            kind: 'configuration-properties',
+                            className,
+                            line: declaration.startPosition.row + 1,
+                            prefix,
+                        },
+                        annotationName: annotation.name,
+                        classScopeId: classScopeId(filePath, declaration),
+                    });
+                }
+            }
+        }
+    }
+    return facts;
+}
+/** Parse Java consumers for focused unit tests; production reuses the worker AST. */
+export function extractJavaSpringConfigConsumers(source) {
+    const tree = parseSourceSafe(getJavaParser(), source);
+    return captureJavaSpringConfigConsumerFacts(tree.rootNode, '<memory>').map((fact) => fact.consumer);
+}
+/** Java ScopeResolver post-resolution hook for Spring configuration consumers. */
+export function attachJavaSpringConfigBindings(graph, parsedFiles, _nodeLookup, indexes, _ctx) {
+    const resolveAnnotation = createSpringAnnotationNameResolver(indexes);
+    const recognizedAnnotations = new Set([VALUE_ANNOTATION, CONFIGURATION_PROPERTIES_ANNOTATION]);
+    const batches = [];
+    for (const parsed of parsedFiles) {
+        const consumers = [];
+        for (const fact of getJavaSpringConfigConsumerFacts(parsed.filePath)) {
+            const classScope = indexes.scopeTree.getScope(fact.classScopeId);
+            if (classScope === undefined || classScope.kind !== 'Class')
+                continue;
+            const expectedAnnotation = fact.consumer.kind === 'value' ? VALUE_ANNOTATION : CONFIGURATION_PROPERTIES_ANNOTATION;
+            const enclosingScope = fact.consumer.kind === 'value' ? classScope.id : classScope.parent;
+            const resolved = resolveAnnotation(fact.annotationName, parsed, enclosingScope, recognizedAnnotations, isJavaPackageSiblingVisibilityIncomplete(parsed.filePath));
+            if (resolved === expectedAnnotation)
+                consumers.push(fact.consumer);
+        }
+        if (consumers.length > 0)
+            batches.push({ filePath: parsed.filePath, consumers });
+    }
+    bindSpringConfigConsumers(graph, batches);
+}

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

@@ -26,6 +26,8 @@ import { javaMethodConfig } from '../method-extractors/configs/jvm.js';
 import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { javaVariableConfig } from '../variable-extractors/configs/jvm.js';
 import { createJavaCfgVisitor } from '../cfg/visitors/java.js';
+import { assertCloneable } from '../workers/clone-safety.js';
+import { collectJavaCaptureSideChannel } from './java/capture-side-channel.js';
 import { emitJavaScopeCaptures, interpretJavaImport, interpretJavaTypeBinding, javaBindingScopeFor, javaImportOwningScope, javaMergeBindings, javaReceiverBinding, javaArityCompatibility, resolveJavaImportTarget, } from './java/index.js';
 const orderJavaSameNameTypeCandidates = ({ callSiteFilePath, candidates, }) => {
     if (!callSiteFilePath.endsWith('.java'))
@@ -99,6 +101,7 @@ export const javaProvider = defineLanguage({
     descriptionExtractor: createLeadingDocDescriptionExtractor(),
     // ── RFC #909 Ring 3: scope-based resolution hooks ──
     emitScopeCaptures: emitJavaScopeCaptures,
+    collectCaptureSideChannel: (filePath) => assertCloneable(collectJavaCaptureSideChannel(filePath)),
     // ── PDG: per-function CFG + def/use harvest (#2195 U4) ──
     cfgVisitor: createJavaCfgVisitor(),
     interpretImport: interpretJavaImport,

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

@@ -34,6 +34,7 @@ import { synthesizeTsReceiverBinding } from '../typescript/receiver-binding.js';
 import { isArrayMethodCallbackArrow } from '../typescript/array-callback.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
 import { deriveDefaultExportHocName, isBlockedDefaultExportHoc, isDefaultExportHocFunctionNode, } from '../../ts-js-hoc-utils.js';
 /** JS function-like node types that may carry a synthesized `this` binding.
  *  Kept in sync with the `@scope.function` patterns in `query.ts`. */
@@ -52,6 +53,20 @@ const CALL_TAGS = [
     '@reference.call.member',
     '@reference.call.constructor',
 ];
+const JS_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(FUNCTION_NODE_TYPES),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['formal_parameters', 'arguments']),
+    parameterNodeTypes: new Set(['identifier', 'rest_pattern', 'assignment_pattern']),
+    bindingNodeTypes: new Set(['variable_declarator']),
+    assignmentNodeTypes: new Set(['assignment_expression', 'augmented_assignment_expression']),
+    identifierNodeTypes: new Set([
+        'identifier',
+        'property_identifier',
+        'shorthand_property_identifier_pattern',
+        'private_property_identifier',
+    ]),
+};
 function pickFirstDefined(grouped, tags) {
     for (const tag of tags) {
         const cap = grouped[tag];
@@ -840,5 +855,6 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
     synthesizeForOfMapTupleBindings(tree.rootNode, out);
     synthesizeInstanceofNarrowings(tree.rootNode, out);
     synthesizeJsInheritanceReferences(tree.rootNode, out);
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, JS_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }

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

@@ -66,6 +66,13 @@ const JAVASCRIPT_SCOPE_QUERY = `
 (arrow_function) @scope.function
 (method_definition) @scope.function
 
+;; Object literals get their own scope boundary -- see the matching
+;; comment in typescript/query.ts (#2545/#2551). Prevents a
+;; method_definition/property-arrow's auto-hoist from leaking its name
+;; past the literal into the enclosing scope, and (unlike Block) keeps
+;; sibling properties from seeing each other as bare identifiers.
+(object) @scope.object
+
 ;; Declarations — classes
 (class_declaration
   name: (identifier) @declaration.name) @declaration.class
@@ -457,6 +464,20 @@ const JAVASCRIPT_SCOPE_QUERY = `
 (member_expression
   object: (_) @reference.receiver
   property: (property_identifier) @reference.name) @reference.read.member
+
+;; Value position (#2437): function identifier as object-literal property
+;; value ({ emitScopeCaptures: emitHook }) or shorthand ({ emitHook }).
+;; Resolution is callable-gated (MethodRegistry) and emits a USES reference;
+;; @reference.property-key feeds the property-dispatch pass, which
+;; synthesizes CALLS at x.<key>() sites. Two separate patterns (tree-sitter
+;; 0.21 alternation hazard); destructuring shorthand is
+;; shorthand_property_identifier_pattern and cannot match.
+(pair
+  key: (property_identifier) @reference.property-key
+  value: (identifier) @reference.name @reference.value-ref)
+
+(object
+  (shorthand_property_identifier) @reference.name @reference.property-key @reference.value-ref)
 `;
 /** JSX-only suffix — appended when compiling against the JSX grammar for .jsx files. */
 const JSX_QUERY_SUFFIX = `

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

@@ -0,0 +1,35 @@
+/** Plain-data JVM package fact captured from the language's existing AST. */
+export type JvmPackageFact = {
+    readonly status: 'known';
+    readonly packageName: string;
+} | {
+    readonly status: 'unknown';
+};
+export declare const UNKNOWN_JVM_PACKAGE_FACT: JvmPackageFact;
+export interface JvmPackageSyntaxNode {
+    readonly type: string;
+    readonly text: string;
+    readonly hasError: boolean;
+    readonly namedChildren: readonly JvmPackageSyntaxNode[];
+}
+export interface JvmPackageFactOptions {
+    readonly packageNodeType: string;
+    readonly packageNameNodeTypes: readonly string[];
+}
+export interface JvmPackageFactStore {
+    clear(): void;
+    capture(filePath: string, root: JvmPackageSyntaxNode): void;
+    set(filePath: string, fact: JvmPackageFact): void;
+    get(filePath: string): JvmPackageFact | undefined;
+}
+/** Validate a package fact restored from an opaque worker payload. */
+export declare function isJvmPackageFact(value: unknown): value is JvmPackageFact;
+/**
+ * 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 declare function createJvmPackageFactStore(options: JvmPackageFactOptions): JvmPackageFactStore;
+export declare function extractJvmPackageFact(root: JvmPackageSyntaxNode, options: JvmPackageFactOptions): JvmPackageFact;