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

package/dist/core/ingestion/languages/java/record-components.d.ts

@@ -0,0 +1,14 @@
+import { type CaptureMatch } from '../../../../_shared/index.js';
+import type { CaptureMap } from '../../language-provider.js';
+import type { MethodExtractor } from '../../method-types.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+/** Java records synthesize one public, zero-argument accessor per component. */
+export declare const javaRecordMethodExtractor: MethodExtractor;
+/** Scope declarations matching the structure-phase synthetic accessor nodes. */
+export declare function synthesizeJavaRecordComponentAccessorCaptures(rootNode: SyntaxNode): CaptureMatch[];
+/**
+ * The structure query sees every record component. Suppress that synthetic
+ * definition when the record body provides the canonical zero-argument
+ * accessor explicitly, leaving the explicit method as the single authority.
+ */
+export declare function shouldSkipJavaRecordComponentDefinition(captureMap: CaptureMap): boolean;

package/dist/core/ingestion/languages/java/record-components.js

@@ -0,0 +1,185 @@
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createMethodExtractor } from '../../method-extractors/generic.js';
+import { javaMethodConfig } from '../../method-extractors/configs/jvm.js';
+import { extractAnnotations } from '../../field-extractors/configs/helpers.js';
+import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+const javaExplicitMethodExtractor = createMethodExtractor(javaMethodConfig);
+function recordComponents(recordNode) {
+    const parameters = recordNode.childForFieldName('parameters');
+    if (parameters === null)
+        return [];
+    return parameters.namedChildren.filter((node) => node !== null && (node.type === 'formal_parameter' || node.type === 'spread_parameter'));
+}
+/**
+ * A record component is named by a real `identifier` and nothing else.
+ *
+ * Two node shapes reach this that are not one, and both would mint a graph node
+ * for source that does not compile:
+ *
+ *  - `record M(int x, y) {}` — a dropped type. tree-sitter recovers by
+ *    synthesizing `name: (MISSING identifier)`, a zero-width node whose text is
+ *    `''`. It still satisfies the query's `name: (identifier)`, so testing the
+ *    node TYPE alone does not reject it.
+ *  - `record R(int _) {}` — the grammar declares both `formal_parameter.name`
+ *    and `variable_declarator.name` as `identifier | underscore_pattern`, and
+ *    `_` parses with no error at all. `_` is illegal as a component name, and
+ *    admitting it here while the query rejects it is what let the structure and
+ *    scope paths disagree.
+ *
+ * Same degenerate-node shape as `javaBaseLookupNameNode` in captures.ts (#2935).
+ */
+function isRecordComponentName(node) {
+    return (node !== null &&
+        node !== undefined &&
+        node.type === 'identifier' &&
+        !node.isMissing &&
+        node.text.length > 0);
+}
+function recordComponentNameNode(component) {
+    const name = component.type === 'formal_parameter'
+        ? component.childForFieldName('name')
+        : (component.namedChildren
+            .find((node) => node?.type === 'variable_declarator')
+            ?.childForFieldName('name') ?? null);
+    return isRecordComponentName(name) ? name : null;
+}
+/**
+ * Memoised per record node. `shouldSkipJavaRecordComponentDefinition` is called
+ * once per component capture, so recomputing this would rescan the whole record
+ * body per component — O(components x body members) for a single record. The
+ * scope-capture path hoists the call out of its own loop instead; this cache is
+ * what gives the structure path the same cost. Keyed weakly on the AST node, so
+ * it drops with the tree at the end of the file's parse.
+ */
+const explicitZeroArgAccessorNamesCache = new WeakMap();
+function explicitZeroArgAccessorNames(recordNode) {
+    const memoized = explicitZeroArgAccessorNamesCache.get(recordNode);
+    if (memoized !== undefined)
+        return memoized;
+    const names = computeExplicitZeroArgAccessorNames(recordNode);
+    explicitZeroArgAccessorNamesCache.set(recordNode, names);
+    return names;
+}
+function computeExplicitZeroArgAccessorNames(recordNode) {
+    const names = new Set();
+    const body = recordNode.childForFieldName('body');
+    if (body === null)
+        return names;
+    for (const node of body.namedChildren) {
+        if (node === null || node.type !== 'method_declaration')
+            continue;
+        const name = node.childForFieldName('name')?.text;
+        const parameters = node.childForFieldName('parameters');
+        const parameterCount = parameters?.namedChildren.filter((parameter) => parameter !== null &&
+            (parameter.type === 'formal_parameter' || parameter.type === 'spread_parameter')).length ?? 0;
+        if (name !== undefined && parameterCount === 0)
+            names.add(name);
+    }
+    return names;
+}
+function recordComponentReturnType(component) {
+    const typeNode = component.childForFieldName('type') ??
+        (component.type === 'spread_parameter'
+            ? component.namedChildren.find((node) => node?.type !== 'modifiers' && node?.type !== 'variable_declarator')
+            : undefined);
+    const type = typeNode?.text;
+    if (type === undefined)
+        return null;
+    return component.type === 'spread_parameter' ? `${type}[]` : type;
+}
+function implicitAccessorInfo(component, context) {
+    const name = recordComponentNameNode(component)?.text;
+    if (name === undefined)
+        return null;
+    return {
+        name,
+        receiverType: null,
+        returnType: recordComponentReturnType(component),
+        parameters: [],
+        visibility: 'public',
+        isStatic: false,
+        isAbstract: false,
+        isFinal: false,
+        // JLS 8.10.3 / 9.7.4: a component annotation reaches the generated accessor
+        // when its @Target admits METHOD (or TYPE_USE, in the return-type position).
+        // ponytail: over-approximate — we propagate every component annotation,
+        // because @Target lives in another file and parsing is per-file, so the
+        // target set is not knowable here. Nothing reads Method annotations today:
+        // `annotations` is not a column in METHOD_SCHEMA/FUNCTION_SCHEMA
+        // (src/core/lbug/schema.ts), so it lives only in the in-memory graph for one
+        // analyze run, and the sole in-memory reader (springDiFieldMatcher) is gated
+        // to `Property` nodes. If that column is ever added, revisit this: the set
+        // would then become an agent-visible claim that may over-state the target.
+        annotations: extractAnnotations(component, 'modifiers'),
+        sourceFile: context.filePath,
+        line: component.startPosition.row + 1,
+        column: component.startPosition.column,
+    };
+}
+/** Java records synthesize one public, zero-argument accessor per component. */
+export const javaRecordMethodExtractor = {
+    ...javaExplicitMethodExtractor,
+    language: SupportedLanguages.Java,
+    extract(node, context) {
+        const extracted = javaExplicitMethodExtractor.extract(node, context);
+        if (extracted === null || node.type !== 'record_declaration')
+            return extracted;
+        const explicitAccessors = explicitZeroArgAccessorNames(node);
+        const implicitAccessors = recordComponents(node)
+            .filter((component) => {
+            const name = recordComponentNameNode(component)?.text;
+            return name !== undefined && !explicitAccessors.has(name);
+        })
+            .map((component) => implicitAccessorInfo(component, context))
+            .filter((method) => method !== null);
+        return { ...extracted, methods: [...extracted.methods, ...implicitAccessors] };
+    },
+};
+/** Scope declarations matching the structure-phase synthetic accessor nodes. */
+export function synthesizeJavaRecordComponentAccessorCaptures(rootNode) {
+    const captures = [];
+    for (const recordNode of rootNode.descendantsOfType('record_declaration')) {
+        const explicitAccessors = explicitZeroArgAccessorNames(recordNode);
+        for (const component of recordComponents(recordNode)) {
+            const nameNode = recordComponentNameNode(component);
+            const returnType = recordComponentReturnType(component);
+            if (nameNode === null || returnType === null || explicitAccessors.has(nameNode.text))
+                continue;
+            captures.push({
+                '@scope.function': nodeToCapture('@scope.function', component),
+            });
+            captures.push({
+                '@declaration.method': nodeToCapture('@declaration.method', component),
+                '@declaration.name': nodeToCapture('@declaration.name', nameNode),
+                '@declaration.parameter-count': syntheticCapture('@declaration.parameter-count', component, '0'),
+                '@declaration.required-parameter-count': syntheticCapture('@declaration.required-parameter-count', component, '0'),
+                '@declaration.return-type': syntheticCapture('@declaration.return-type', component, returnType),
+            });
+        }
+    }
+    return captures;
+}
+/**
+ * The structure query sees every record component. Suppress that synthetic
+ * definition when the record body provides the canonical zero-argument
+ * accessor explicitly, leaving the explicit method as the single authority.
+ */
+export function shouldSkipJavaRecordComponentDefinition(captureMap) {
+    const component = captureMap['definition.method'];
+    if (component?.type !== 'formal_parameter' && component?.type !== 'spread_parameter') {
+        return false;
+    }
+    const parameters = component.parent;
+    const recordNode = parameters?.parent;
+    if (parameters?.type !== 'formal_parameters' || recordNode?.type !== 'record_declaration') {
+        return false;
+    }
+    // Same predicate the scope path applies, so the two can never disagree about
+    // which components have an accessor. The query's `name: (identifier)` is
+    // satisfied by tree-sitter's zero-width MISSING recovery token, so the
+    // structure path has to re-check what the query cannot express.
+    const nameNode = captureMap['name'];
+    if (!isRecordComponentName(nameNode))
+        return true;
+    return explicitZeroArgAccessorNames(recordNode).has(nameNode.text);
+}

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

@@ -13,26 +13,59 @@ 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 { attachJavaSpringAopMetadata } from './spring-aop.js';
+import { attachJavaSpringConfigBindings } from './spring-config-bindings.js';
+import { attachJavaSpringConditionalMetadata } from './spring-conditionals.js';
+import { attachJavaSpringDiMetadata } from './spring-di.js';
+import { attachJavaSpringNonHttpHandlerMetadata } from './spring-non-http-handlers.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',
-    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
-        const ws = { fromFile, allFilePaths };
+    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, _resolutionConfig, context) => {
+        // `context.parsedFiles` is the whole input now: a Java import names a type
+        // in a DECLARED package, and the declarations live on those files (#2953).
+        const ws = { fromFile, allFilePaths, parsedFiles: context?.parsedFiles };
         return resolveJavaImportTarget({ kind: 'named', localName: '_', importedName: '_', targetRaw }, ws);
     },
     mergeBindings: (existing, incoming) => [...javaMergeBindings([...existing, ...incoming])],
     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);
+        attachJavaSpringAopMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachJavaSpringConditionalMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachJavaSpringDiMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachJavaSpringNonHttpHandlerMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachJavaSpringConfigBindings(graph, parsedFiles, nodeLookup, indexes, ctx);
+    },
 };
 export { javaScopeResolver };
 function populateJavaCrossFileReturnTypes(parsedFiles, indexes) {

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

@@ -0,0 +1,12 @@
+import { type SpringAopOwnerFact } from '../../frameworks/spring/aop.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+import { type JavaAnnotationSyntaxFact } from './spring-di.js';
+export type JavaSpringAopAnnotationFact = JavaAnnotationSyntaxFact;
+export type JavaSpringAopFact = SpringAopOwnerFact<JavaSpringAopAnnotationFact>;
+/**
+ * Capture Spring AOP syntax while Java's existing class traversal already has
+ * the AST node in hand. Import/FQN resolution and pointcut matching remain in
+ * the shared post-resolution layer.
+ */
+export declare function captureJavaSpringAopFacts(classNode: SyntaxNode, filePath: string): JavaSpringAopFact[];
+export declare const attachJavaSpringAopMetadata: (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-aop.js

@@ -0,0 +1,49 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { createSpringAopMetadataAttacher, hasSpringAopRelevantAnnotation, } from '../../frameworks/spring/aop.js';
+import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { getJavaSpringAopFacts } from './capture-side-channel.js';
+import { isJavaPackageSiblingVisibilityIncomplete } from './package-siblings.js';
+import { javaSpringAnnotationFacts } from './spring-di.js';
+function scopeId(filePath, node, kind) {
+    return makeScopeId({
+        filePath,
+        range: nodeToCapture('@spring-aop.owner', node).range,
+        kind,
+    });
+}
+/**
+ * Capture Spring AOP syntax while Java's existing class traversal already has
+ * the AST node in hand. Import/FQN resolution and pointcut matching remain in
+ * the shared post-resolution layer.
+ */
+export function captureJavaSpringAopFacts(classNode, filePath) {
+    const facts = [];
+    const classAnnotations = javaSpringAnnotationFacts(classNode);
+    if (hasSpringAopRelevantAnnotation(classAnnotations)) {
+        facts.push({
+            ownerScopeId: scopeId(filePath, classNode, 'Class'),
+            ownerKind: 'class',
+            annotations: classAnnotations,
+        });
+    }
+    const body = classNode.childForFieldName('body');
+    if (body === null)
+        return facts;
+    for (const member of body.namedChildren) {
+        if (member.type !== 'method_declaration')
+            continue;
+        const annotations = javaSpringAnnotationFacts(member);
+        if (!hasSpringAopRelevantAnnotation(annotations))
+            continue;
+        facts.push({
+            ownerScopeId: scopeId(filePath, member, 'Function'),
+            ownerKind: 'callable',
+            annotations,
+        });
+    }
+    return facts;
+}
+export const attachJavaSpringAopMetadata = createSpringAopMetadataAttacher({
+    getFacts: getJavaSpringAopFacts,
+    isPackageVisibilityIncomplete: isJavaPackageSiblingVisibilityIncomplete,
+});

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-conditionals.d.ts

@@ -0,0 +1,11 @@
+import { type SpringConditionalOwnerFact } from '../../frameworks/spring/conditionals.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+import { type JavaAnnotationSyntaxFact } from './spring-di.js';
+export type JavaSpringConditionalAnnotationFact = JavaAnnotationSyntaxFact;
+export type JavaSpringConditionalFact = SpringConditionalOwnerFact<JavaSpringConditionalAnnotationFact>;
+/**
+ * Capture Spring condition syntax while Java's existing class traversal already
+ * has the AST node in hand. Framework/FQN semantics are resolved later.
+ */
+export declare function captureJavaSpringConditionalFacts(classNode: SyntaxNode, filePath: string): JavaSpringConditionalFact[];
+export declare const attachJavaSpringConditionalMetadata: (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-conditionals.js

@@ -0,0 +1,48 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { createSpringConditionalMetadataAttacher, hasSpringConditionalRelevantAnnotation, } from '../../frameworks/spring/conditionals.js';
+import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { getJavaSpringConditionalFacts } from './capture-side-channel.js';
+import { isJavaPackageSiblingVisibilityIncomplete } from './package-siblings.js';
+import { javaSpringAnnotationFacts } from './spring-di.js';
+function scopeId(filePath, node, kind) {
+    return makeScopeId({
+        filePath,
+        range: nodeToCapture('@spring-condition.owner', node).range,
+        kind,
+    });
+}
+/**
+ * Capture Spring condition syntax while Java's existing class traversal already
+ * has the AST node in hand. Framework/FQN semantics are resolved later.
+ */
+export function captureJavaSpringConditionalFacts(classNode, filePath) {
+    const facts = [];
+    const classAnnotations = javaSpringAnnotationFacts(classNode);
+    if (hasSpringConditionalRelevantAnnotation(classAnnotations)) {
+        facts.push({
+            ownerScopeId: scopeId(filePath, classNode, 'Class'),
+            ownerKind: 'class',
+            annotations: classAnnotations,
+        });
+    }
+    const body = classNode.childForFieldName('body');
+    if (body === null)
+        return facts;
+    for (const member of body.namedChildren) {
+        if (member.type !== 'method_declaration')
+            continue;
+        const annotations = javaSpringAnnotationFacts(member);
+        if (!hasSpringConditionalRelevantAnnotation(annotations))
+            continue;
+        facts.push({
+            ownerScopeId: scopeId(filePath, member, 'Function'),
+            ownerKind: 'callable',
+            annotations,
+        });
+    }
+    return facts;
+}
+export const attachJavaSpringConditionalMetadata = createSpringConditionalMetadataAttacher({
+    getFacts: getJavaSpringConditionalFacts,
+    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);
+}