gitnexus 1.6.9 → 1.6.10-aptos.0

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

@@ -35,20 +35,51 @@ import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { encodeMarker } from '../../utils/heritage-marker.js';
 import { DART_BUILT_INS } from './built-ins.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { preprocessDartExtensionTypes } from './extension-type-preprocess.js';
 const FUNCTION_DECL_TAGS = [
     '@declaration.function',
     '@declaration.method',
     '@declaration.constructor',
 ];
+const DART_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['function_signature', 'function_expression']),
+    callNodeTypes: new Set(['selector']),
+    parameterListNodeTypes: new Set(['formal_parameter_list', 'arguments']),
+    parameterNodeTypes: new Set(['formal_parameter']),
+    bindingNodeTypes: new Set(['initialized_variable_definition']),
+    assignmentNodeTypes: new Set(['assignment_expression']),
+    identifierNodeTypes: new Set(['identifier', 'type_identifier']),
+    lexicalFunctionOwner: (node) => dartLexicalFunctionOwner(node),
+    isCallNode: (node) => node.namedChild(0)?.type === 'argument_part',
+    extractCallCallee: (node) => dartCallableCallee(node) ?? undefined,
+    callSiteNode: (node) => dartCallableCallee(node) ?? undefined,
+    callableProtocolMethods: new Set(['call']),
+};
+function dartLexicalFunctionOwner(input) {
+    let node = input;
+    while (node !== null) {
+        if (node.type === 'function_signature' || node.type === 'function_expression')
+            return node;
+        if (node.type === 'function_body') {
+            const signature = node.previousNamedSibling;
+            if (signature?.type === 'function_signature')
+                return signature;
+        }
+        node = node.parent;
+    }
+    return undefined;
+}
 export function emitDartScopeCaptures(sourceText, _filePath, cachedTree) {
+    const parseText = preprocessDartExtensionTypes(sourceText);
     let tree;
     if (cachedTree !== undefined && cachedTree !== null) {
         tree = cachedTree;
         recordCacheHit();
     }
     else {
-        tree = parseSourceSafe(getDartParser(), sourceText, undefined, {
-            bufferSize: getTreeSitterBufferSize(sourceText),
+        tree = parseSourceSafe(getDartParser(), parseText, undefined, {
+            bufferSize: getTreeSitterBufferSize(parseText),
         });
         recordCacheMiss();
     }
@@ -132,9 +163,25 @@ export function emitDartScopeCaptures(sourceText, _filePath, cachedTree) {
             emitHeritage(node, out);
             return;
         }
+        if (node.type === 'extension_declaration') {
+            emitExtensionImplementsHeritage(node, out);
+            return;
+        }
     });
+    out.push(...synthesizeCallableFlowCaptures(root, DART_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
+function dartCallableCallee(selector) {
+    if (selector.namedChild(0)?.type !== 'argument_part')
+        return null;
+    const previous = selector.previousNamedSibling;
+    if (previous?.type === 'identifier')
+        return previous;
+    if (previous?.type !== 'selector')
+        return null;
+    const inner = previous.namedChild(0);
+    return inner !== null && ASSIGNABLE_SELECTORS.has(inner.type) ? selectorName(inner) : null;
+}
 // ─── Function scope synthesis ───────────────────────────────────────────────
 /**
  * The sibling `function_body` of a declaration, or null (abstract/bodyless).
@@ -434,6 +481,47 @@ function emitHeritage(classNode, out) {
         emitHeritageMarkers(interfaces, 'implements', className, out);
     }
 }
+function emitExtensionImplementsHeritage(extensionNode, out) {
+    const nameNode = extensionNode.childForFieldName('name');
+    if (nameNode === null)
+        return;
+    const bodyStart = extensionNode.text.indexOf('{');
+    const header = bodyStart === -1 ? extensionNode.text : extensionNode.text.slice(0, bodyStart);
+    const implementsIndex = header.indexOf('implements');
+    if (implementsIndex === -1)
+        return;
+    const className = nameNode.text;
+    const interfaces = header.slice(implementsIndex + 'implements'.length);
+    for (const rawInterface of splitTopLevelCommaList(interfaces)) {
+        const target = /^[ \t]*([A-Za-z_$][A-Za-z0-9_$]*)/.exec(rawInterface)?.[1];
+        if (target === undefined)
+            continue;
+        const payload = encodeMarker('heritage', ['implements', target, className]);
+        out.push({ '@import.heritage': syntheticCapture('@import.heritage', nameNode, payload) });
+    }
+}
+function splitTopLevelCommaList(text) {
+    const parts = [];
+    let start = 0;
+    let angleDepth = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '<') {
+            angleDepth++;
+            continue;
+        }
+        if (ch === '>' && angleDepth > 0) {
+            angleDepth--;
+            continue;
+        }
+        if (ch === ',' && angleDepth === 0) {
+            parts.push(text.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(text.slice(start));
+    return parts;
+}
 function emitHeritageMarkers(container, kind, className, out) {
     for (let i = 0; i < container.namedChildCount; i++) {
         const c = container.namedChild(i);

package/dist/core/ingestion/languages/dart/extension-type-preprocess.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Rewrites Dart 3.3 `extension type Name(Type value)` headers into ordinary
+ * extension headers before tree-sitter sees the source. The vendored grammar
+ * currently recovers these declarations through an ERROR subtree, while the
+ * existing Dart ingestion path already handles `extension Name on Type`.
+ */
+export declare function preprocessDartExtensionTypes(sourceText: string): string;

package/dist/core/ingestion/languages/dart/extension-type-preprocess.js

@@ -0,0 +1,30 @@
+const DART_EXTENSION_TYPE_HEADER = /\b(extension)([ \t]+type[ \t]+(?:const[ \t]+)?)([A-Za-z_$][A-Za-z0-9_$]*)([ \t]*<[^()\r\n]*>)?([ \t]*)\(([^()\r\n]*)\)/g;
+function representationType(representation) {
+    const trimmed = representation.trim();
+    const match = /^(.*\S)\s+[A-Za-z_$][A-Za-z0-9_$]*$/.exec(trimmed);
+    const typeName = match?.[1]?.trim();
+    return typeName && typeName.length > 0 ? typeName : null;
+}
+/**
+ * Rewrites Dart 3.3 `extension type Name(Type value)` headers into ordinary
+ * extension headers before tree-sitter sees the source. The vendored grammar
+ * currently recovers these declarations through an ERROR subtree, while the
+ * existing Dart ingestion path already handles `extension Name on Type`.
+ */
+export function preprocessDartExtensionTypes(sourceText) {
+    return sourceText.replace(DART_EXTENSION_TYPE_HEADER, (match, extensionKeyword, extensionTypeGap, name, typeParameters, beforeRepresentation, representation) => {
+        const typeName = representationType(representation);
+        if (typeName === null)
+            return match;
+        const representationSpanLength = beforeRepresentation.length + representation.length + 2;
+        const rewrittenRepresentation = ` on ${typeName}`;
+        if (rewrittenRepresentation.length > representationSpanLength)
+            return match;
+        return (extensionKeyword +
+            ' '.repeat(extensionTypeGap.length) +
+            name +
+            (typeParameters ?? '') +
+            rewrittenRepresentation +
+            ' '.repeat(representationSpanLength - rewrittenRepresentation.length));
+    });
+}

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

@@ -29,6 +29,7 @@ import { createCallExtractor } from '../call-extractors/generic.js';
 import { dartCallConfig } from '../call-extractors/configs/dart.js';
 import { emitDartScopeCaptures, interpretDartImport, interpretDartTypeBinding, dartBindingScopeFor, dartImportOwningScope, dartReceiverBinding, dartMergeBindings, dartArityCompatibility, } from './dart/index.js';
 import { DART_BUILT_INS } from './dart/built-ins.js';
+import { preprocessDartExtensionTypes } from './dart/extension-type-preprocess.js';
 /**
  * Resolve the enclosing function from a `function_body` node by looking at its
  * previous sibling.  In Dart's tree-sitter grammar, function_signature and
@@ -100,6 +101,7 @@ export const dartProvider = defineLanguage({
         },
     ],
     treeSitterQueries: DART_QUERIES,
+    preprocessSource: preprocessDartExtensionTypes,
     typeConfig: dartConfig,
     exportChecker: dartExportChecker,
     importResolver: createImportResolver(dartImportConfig),

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

@@ -7,6 +7,39 @@ import { synthesizeGoReceiverBinding } from './receiver-binding.js';
 import { synthesizeGoTypeBindings, extractSimpleTypeNameText } from './type-binding.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+const GO_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['function_declaration', 'method_declaration', 'func_literal']),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['parameter_list', 'argument_list']),
+    parameterNodeTypes: new Set(['parameter_declaration', 'variadic_parameter_declaration']),
+    bindingNodeTypes: new Set(['short_var_declaration', 'var_spec']),
+    assignmentNodeTypes: new Set(['assignment_statement']),
+    identifierNodeTypes: new Set(['identifier', 'field_identifier', 'package_identifier']),
+    // Multi-value forms (`a, b := f, g`) pair LHS/RHS expression_list entries
+    // positionally — the shared field fallback cross-wired first-LHS with
+    // last-RHS and synthesized a garbage comma-joined qualified name (#2522
+    // review). A length mismatch (multi-return call RHS) recognizes the node
+    // but emits nothing.
+    extractAssignment: (node) => {
+        if (node.type !== 'short_var_declaration' && node.type !== 'assignment_statement') {
+            return undefined;
+        }
+        const left = node.childForFieldName('left');
+        const right = node.childForFieldName('right');
+        if (left === null || right === null)
+            return undefined;
+        if (left.type !== 'expression_list' || right.type !== 'expression_list')
+            return undefined;
+        const destinations = left.namedChildren.filter((child) => child !== null);
+        const sources = right.namedChildren.filter((child) => child !== null);
+        if (destinations.length <= 1 && sources.length <= 1)
+            return undefined;
+        if (destinations.length !== sources.length)
+            return [];
+        return destinations.map((destination, index) => ({ destination, source: sources[index] }));
+    },
+};
 export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -136,6 +169,7 @@ export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
         });
     }
     out.push(...synthesizeGoInheritanceReferences(tree.rootNode));
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, GO_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
 /**

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

@@ -26,6 +26,7 @@ export declare const providers: {
     dart: LanguageProvider;
     vue: LanguageProvider;
     cobol: LanguageProvider;
+    move: LanguageProvider;
 };
 /** Get provider by language enum (always succeeds for SupportedLanguages). */
 export declare function getProvider(language: SupportedLanguages): LanguageProvider;

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

@@ -22,6 +22,7 @@ import { swiftProvider } from './swift.js';
 import { dartProvider } from './dart.js';
 import { vueProvider } from './vue.js';
 import { cobolProvider } from './cobol.js';
+import { moveProvider } from './move.js';
 export const providers = {
     [SupportedLanguages.JavaScript]: javascriptProvider,
     [SupportedLanguages.TypeScript]: typescriptProvider,
@@ -39,6 +40,7 @@ export const providers = {
     [SupportedLanguages.Dart]: dartProvider,
     [SupportedLanguages.Vue]: vueProvider,
     [SupportedLanguages.Cobol]: cobolProvider,
+    [SupportedLanguages.Move]: moveProvider,
 };
 /** Get provider by language enum (always succeeds for SupportedLanguages). */
 export function getProvider(language) {

package/dist/core/ingestion/languages/java/analysis-features.d.ts

@@ -0,0 +1,3 @@
+import type { AnalysisFeatureDescriptor } from '../../../analysis-features.js';
+/** Durable completeness contract for Java Spring configuration bindings. */
+export declare const SPRING_CONFIG_BINDINGS_FEATURE: AnalysisFeatureDescriptor;

package/dist/core/ingestion/languages/java/analysis-features.js

@@ -0,0 +1,13 @@
+function isSpringApplicationConfig(filePath) {
+    const base = filePath.replaceAll('\\', '/').split('/').pop() ?? '';
+    return /^application(?:-[^.]+)?\.(?:properties|ya?ml)$/i.test(base);
+}
+/** Durable completeness contract for Java Spring configuration bindings. */
+export const SPRING_CONFIG_BINDINGS_FEATURE = {
+    id: 'spring.config-bindings',
+    version: 1,
+    // Java sources need consumer extraction even without config files (missing
+    // placeholders still get unresolved markers). Config-only repositories also
+    // need a one-time rebuild to backfill language-agnostic Property nodes.
+    appliesTo: (filePaths) => filePaths.some((filePath) => filePath.toLowerCase().endsWith('.java') || isSpringApplicationConfig(filePath)),
+};

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

@@ -0,0 +1,22 @@
+import type { ParsedFile } from '../../../../_shared/index.js';
+import { type ClassAnnotationFact } from '../../frameworks/spring/bean-candidates.js';
+import { type JvmPackageFact } from '../jvm/package-facts.js';
+import type { JavaSpringConfigConsumerFact } from './spring-config-bindings.js';
+export type JavaClassAnnotationFact = ClassAnnotationFact;
+export interface JavaCaptureSideChannel {
+    readonly kind: 'java';
+    readonly packageFact: JvmPackageFact;
+    readonly classAnnotations: readonly JavaClassAnnotationFact[];
+    readonly springConfigConsumers?: readonly JavaSpringConfigConsumerFact[];
+}
+/** Clear facts retained by a prior workspace pass in a long-lived process. */
+export declare function clearJavaClassAnnotationFacts(): void;
+/** Store the annotation syntax collected by Java's existing scope-query traversal. */
+export declare function setJavaClassAnnotationFacts(filePath: string, facts: readonly JavaClassAnnotationFact[]): void;
+export declare function setJavaSpringConfigConsumerFacts(filePath: string, facts: readonly JavaSpringConfigConsumerFact[]): void;
+export declare function getJavaSpringConfigConsumerFacts(filePath: string): readonly JavaSpringConfigConsumerFact[];
+/** Snapshot worker-local Java annotation facts for ParsedFile serialization. */
+export declare function collectJavaCaptureSideChannel(filePath: string): JavaCaptureSideChannel | undefined;
+export declare function getJavaClassAnnotationFacts(filePath: string): readonly JavaClassAnnotationFact[];
+/** Restore worker-collected facts before Java's post-resolution hook runs. */
+export declare function applyJavaCaptureSideChannel(parsed: ParsedFile): void;

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

@@ -0,0 +1,58 @@
+import { createClassAnnotationFactStore, } from '../../frameworks/spring/bean-candidates.js';
+import { isJvmPackageFact, UNKNOWN_JVM_PACKAGE_FACT, } from '../jvm/package-facts.js';
+import { getJavaPackageFact, setJavaPackageFact } from './package-facts.js';
+const classAnnotations = createClassAnnotationFactStore();
+const springConfigConsumers = new Map();
+/** Clear facts retained by a prior workspace pass in a long-lived process. */
+export function clearJavaClassAnnotationFacts() {
+    classAnnotations.clear();
+    springConfigConsumers.clear();
+}
+/** Store the annotation syntax collected by Java's existing scope-query traversal. */
+export function setJavaClassAnnotationFacts(filePath, facts) {
+    classAnnotations.set(filePath, facts);
+}
+export function setJavaSpringConfigConsumerFacts(filePath, facts) {
+    if (facts.length === 0)
+        springConfigConsumers.delete(filePath);
+    else
+        springConfigConsumers.set(filePath, facts);
+}
+export function getJavaSpringConfigConsumerFacts(filePath) {
+    return springConfigConsumers.get(filePath) ?? [];
+}
+/** Snapshot worker-local Java annotation facts for ParsedFile serialization. */
+export function collectJavaCaptureSideChannel(filePath) {
+    const facts = classAnnotations.get(filePath);
+    const configConsumers = springConfigConsumers.get(filePath) ?? [];
+    const packageFact = getJavaPackageFact(filePath);
+    if (facts.length === 0 && configConsumers.length === 0 && packageFact === undefined) {
+        return undefined;
+    }
+    return {
+        kind: 'java',
+        packageFact: packageFact ?? UNKNOWN_JVM_PACKAGE_FACT,
+        classAnnotations: facts,
+        ...(configConsumers.length > 0 ? { springConfigConsumers: configConsumers } : {}),
+    };
+}
+export function getJavaClassAnnotationFacts(filePath) {
+    return classAnnotations.get(filePath);
+}
+/** Restore worker-collected facts before Java's post-resolution hook runs. */
+export function applyJavaCaptureSideChannel(parsed) {
+    const data = parsed.captureSideChannel;
+    if (data === undefined ||
+        data === null ||
+        typeof data !== 'object' ||
+        data.kind !== 'java' ||
+        !Array.isArray(data.classAnnotations)) {
+        setJavaClassAnnotationFacts(parsed.filePath, []);
+        setJavaSpringConfigConsumerFacts(parsed.filePath, []);
+        setJavaPackageFact(parsed.filePath, UNKNOWN_JVM_PACKAGE_FACT);
+        return;
+    }
+    setJavaClassAnnotationFacts(parsed.filePath, data.classAnnotations);
+    setJavaSpringConfigConsumerFacts(parsed.filePath, Array.isArray(data.springConfigConsumers) ? data.springConfigConsumers : []);
+    setJavaPackageFact(parsed.filePath, isJvmPackageFact(data.packageFact) ? data.packageFact : UNKNOWN_JVM_PACKAGE_FACT);
+}

package/dist/core/ingestion/languages/java/captures.d.ts

@@ -11,7 +11,8 @@
  *   3. **Arity metadata** on method/constructor declarations.
  *   4. **Reference arity** on call sites.
  *
- * Pure given the input source text. No I/O, no globals consulted.
+ * The returned captures are deterministic. Class-annotation facts are also
+ * recorded for the worker side-channel consumed after scope resolution.
  */
-import type { CaptureMatch } from '../../../../_shared/index.js';
-export declare function emitJavaScopeCaptures(sourceText: string, _filePath: string, cachedTree?: unknown): readonly CaptureMatch[];
+import { type CaptureMatch } from '../../../../_shared/index.js';
+export declare function emitJavaScopeCaptures(sourceText: string, filePath: string, cachedTree?: unknown): readonly CaptureMatch[];

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

@@ -1,19 +1,5 @@
-/**
- * `emitScopeCaptures` for Java.
- *
- * Drives the Java scope query against tree-sitter-java and groups raw
- * matches into `CaptureMatch[]` for the central extractor. Layers:
- *
- *   1. **Decomposed import declarations** — each `import_declaration`
- *      is re-emitted with `@import.kind/source/name` markers.
- *   2. **Receiver binding synthesis** — `this`/`super` type-bindings
- *      on instance methods.
- *   3. **Arity metadata** on method/constructor declarations.
- *   4. **Reference arity** on call sites.
- *
- * Pure given the input source text. No I/O, no globals consulted.
- */
-import { nodeIfType, nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { materializeClassAnnotationFacts, recordClassAnnotationCapture, } from '../../frameworks/spring/bean-candidates.js';
+import { nodeIfType, nodeToCapture, synthesizeJavaAnonymousClassName, syntheticCapture, } from '../../utils/ast-helpers.js';
 import { splitImportDeclaration } from './import-decomposer.js';
 import { computeJavaArityMetadata } from './arity-metadata.js';
 import { synthesizeJavaReceiverBinding } from './receiver-binding.js';
@@ -21,10 +7,32 @@ import { getJavaParser, getJavaScopeQuery } from './query.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { setJavaClassAnnotationFacts, setJavaSpringConfigConsumerFacts, } from './capture-side-channel.js';
+import { captureJavaPackageFact } from './package-facts.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { captureJavaSpringConfigConsumerFacts } from './spring-config-bindings.js';
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = ['@declaration.method', '@declaration.constructor'];
 /** tree-sitter-java node types that the method extractor accepts. */
 const FUNCTION_NODE_TYPES = ['method_declaration', 'constructor_declaration'];
+const JAVA_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set([...FUNCTION_NODE_TYPES, 'lambda_expression']),
+    callNodeTypes: new Set(['method_invocation']),
+    parameterListNodeTypes: new Set(['formal_parameters', 'argument_list']),
+    parameterNodeTypes: new Set(['formal_parameter', 'spread_parameter', 'receiver_parameter']),
+    bindingNodeTypes: new Set(['variable_declarator']),
+    assignmentNodeTypes: new Set(['assignment_expression']),
+    identifierNodeTypes: new Set(['identifier', 'type_identifier']),
+    callableReferenceNodeTypes: new Set(['method_reference']),
+    // java.util.function SAM names, MINUS 'get' and 'test': those two collide
+    // with ubiquitous non-functional APIs (Map/List/Optional/Future.get,
+    // Predicate-unrelated test methods), emitting a spurious callable-object
+    // invoke fact for every container access (#2522 review). Supplier.get /
+    // Predicate.test dispatch is deliberately traded away until the check can
+    // gate on the receiver's declared type.
+    callableProtocolMethods: new Set(['run', 'apply', 'accept', 'call']),
+    normalizeQualifiedName: (raw) => raw.replaceAll('::', '.'),
+};
 /** Suppress read.member emissions when the field_access is already
  *  covered by a method_invocation (object of a call) or an
  *  assignment_expression (write target). */
@@ -39,7 +47,7 @@ function shouldEmitReadMember(memberNode) {
             return true;
     }
 }
-export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
+export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
         tree = parseSourceSafe(getJavaParser(), sourceText, undefined, {
@@ -50,8 +58,10 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
     else {
         recordCacheHit();
     }
+    captureJavaPackageFact(filePath, tree.rootNode);
     const rawMatches = getJavaScopeQuery().matches(tree.rootNode);
     const out = [];
+    const classAnnotations = new Map();
     for (const m of rawMatches) {
         const grouped = {};
         // Parallel tag -> captured SyntaxNode map. The tree-sitter query already
@@ -70,6 +80,12 @@ export function emitJavaScopeCaptures(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) {
+            recordClassAnnotationCapture(classAnnotations, filePath, annotatedClass, annotationName.text);
+            continue;
+        }
         // Decompose each `import_declaration`. `@import.statement` is captured
         // directly on the `import_declaration` node.
         if (grouped['@import.statement'] !== undefined) {
@@ -95,6 +111,24 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
             grouped['@reference.receiver'] !== undefined) {
             continue;
         }
+        // Normalize a `new`-expression receiver to its constructed type's simple
+        // name: `new Local().inner()` binds the WHOLE `object_creation_expression`
+        // as `@reference.receiver`, so its raw text is `"new Local()"` — a string
+        // that can never match a scope binding, so the compound-receiver resolver
+        // silently falls through to name-only fallback resolution and picks the
+        // wrong same-named method on a collision (#2564). Rewriting the text to
+        // just `Local` lets Case 2 (class-name / static receiver) in
+        // receiver-bound-calls.ts resolve it via its normal MRO walk. Mirrors the
+        // established `normalizePhpReceiver` precedent (php/captures.ts) — a
+        // language-local capture rewrite, no shared-pipeline change.
+        if (grouped['@reference.receiver'] !== undefined) {
+            const receiverNode = nodeIfType(nodeMap['@reference.receiver'], 'object_creation_expression');
+            const typeNode = receiverNode?.childForFieldName('type');
+            const simpleName = typeNode ? javaBaseSimpleNameOf(typeNode) : undefined;
+            if (simpleName !== undefined) {
+                grouped['@reference.receiver'] = syntheticCapture('@reference.receiver', receiverNode, simpleName);
+            }
+        }
         // Filter read.member when it's a child of method_invocation or assignment.
         // `@reference.read.member` is captured directly on the `field_access` node.
         if (grouped['@reference.read.member'] !== undefined) {
@@ -161,12 +195,147 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         out.push(grouped);
     }
+    setJavaClassAnnotationFacts(filePath, materializeClassAnnotationFacts(classAnnotations));
+    setJavaSpringConfigConsumerFacts(filePath, captureJavaSpringConfigConsumerFacts(tree.rootNode, filePath));
     return [
         ...resolveVarTypeBindings(out),
         ...synthesizeJavaInheritanceReferences(tree.rootNode),
         ...synthesizeJavaExplicitConstructorReferences(tree.rootNode),
+        ...synthesizeJavaAnonymousClassDeclarations(tree.rootNode),
+        ...synthesizeCallableFlowCaptures(tree.rootNode, JAVA_CALLABLE_CAPTURE_OPTIONS),
     ];
 }
+/**
+ * Synthesize `@declaration.class` matches for anonymous class bodies
+ * (`new Runnable() { ... }`), named by the same javac-style authority
+ * (`synthesizeJavaAnonymousClassName` → `Worker$N`) the structure phase
+ * uses — the two layers agree by construction (#2550).
+ *
+ * The anchor is the `class_body` node: it shares its range with the
+ * `(object_creation_expression (class_body) @scope.class)` scope rule in
+ * query.ts, so the def is owned by that Class scope's `ownedDefs`
+ * (making `populateClassOwnedMembers` stamp `ownerId` on the anonymous
+ * class's methods) and the name auto-hoists to the enclosing scope —
+ * exactly the binding shape a named class declaration produces.
+ */
+function synthesizeJavaAnonymousClassDeclarations(rootNode) {
+    const out = [];
+    for (const oce of rootNode.descendantsOfType('object_creation_expression')) {
+        const name = synthesizeJavaAnonymousClassName(oce);
+        if (name === undefined)
+            continue;
+        const body = oce.namedChildren.find((c) => c.type === 'class_body');
+        if (body === undefined)
+            continue;
+        out.push({
+            '@declaration.class': nodeToCapture('@declaration.class', body),
+            '@declaration.name': syntheticCapture('@declaration.name', body, name),
+        });
+        // Inheritance: the anonymous class extends/implements its constructed
+        // type. Anchor the `@reference.inherits` on the `class_body` — its
+        // range equals the anonymous Class scope, so the reference site's
+        // enclosing class resolves to the SYNTHESIZED `Worker$N` def (anchoring
+        // on the constructed-type node would sit OUTSIDE the anonymous scope
+        // and mis-attribute the edge to the lexically enclosing class). The
+        // synthetic `@reference.name` carries the base's simple name; a JDK
+        // type with no repo def simply resolves to nothing (no edge). Without
+        // this edge `mroFor(Worker$N)` is empty and the #2550 instance-
+        // ownership gate suppressed TRUE bare calls to inherited methods
+        // inside the anonymous body (empirically caught in review).
+        const constructedType = oce.childForFieldName?.('type');
+        const baseSimpleName = constructedType !== null && constructedType !== undefined
+            ? javaBaseSimpleNameOf(constructedType)
+            : undefined;
+        if (baseSimpleName !== undefined) {
+            out.push({
+                '@reference.inherits': nodeToCapture('@reference.inherits', body),
+                '@reference.name': syntheticCapture('@reference.name', body, baseSimpleName),
+            });
+        }
+        // Receiver typeBinding: `Runnable handler = new Runnable() { ... }`
+        // binds `handler` to the ANONYMOUS class (`Worker$1`), not the declared
+        // interface — the instance is what `handler.run()` dispatches into, and
+        // the declared type is frequently a JDK interface with no repo def.
+        // Appended after the raw matches, so it overwrites the declared-type
+        // binding the `@type-binding.annotation` query rule produced for the
+        // same variable (pass-4 applies bindings in match order; last wins).
+        const declarator = oce.parent;
+        if (declarator !== null && declarator.type === 'variable_declarator') {
+            const varName = declarator.childForFieldName?.('name');
+            const declNode = declarator.parent ?? declarator;
+            if (varName !== null && varName !== undefined) {
+                out.push({
+                    '@type-binding.annotation': nodeToCapture('@type-binding.annotation', declNode),
+                    '@type-binding.name': nodeToCapture('@type-binding.name', varName),
+                    '@type-binding.type': syntheticCapture('@type-binding.type', oce, name),
+                });
+            }
+        }
+    }
+    // Enum constant bodies (`enum E { A { ... } }`) — javac's other
+    // anonymous shape (#2555). Same synthesis, same body anchor; the
+    // constant's class extends its HOST ENUM (javac semantics), so the
+    // inherits reference names the enum — giving `mroFor(E$N) ∋ E` and
+    // keeping bare calls from the body to the enum's own helpers alive
+    // through the ownership gate's MRO arm.
+    for (const constant of rootNode.descendantsOfType('enum_constant')) {
+        const hostEnum = javaEnclosingEnumNameOf(constant);
+        const bodyNode = constant.childForFieldName?.('body');
+        const isBodied = bodyNode !== null && bodyNode !== undefined && bodyNode.type === 'class_body';
+        const bodiedName = synthesizeJavaAnonymousClassName(constant);
+        if (bodiedName !== undefined && isBodied) {
+            out.push({
+                '@declaration.class': nodeToCapture('@declaration.class', bodyNode),
+                '@declaration.name': syntheticCapture('@declaration.name', bodyNode, bodiedName),
+            });
+            if (hostEnum !== undefined) {
+                out.push({
+                    '@reference.inherits': nodeToCapture('@reference.inherits', bodyNode),
+                    '@reference.name': syntheticCapture('@reference.name', bodyNode, hostEnum),
+                });
+            }
+        }
+        // Receiver dispatch (#2561): `E.CONST.method()` resolves through the
+        // generic compound-receiver chain walk, which looks up each dotted
+        // segment via the owning class scope's `typeBindings` map — the same
+        // mechanism a field declaration uses (`private User user;` binds
+        // `user` on the class scope). Binding the constant's own simple name
+        // there — to its synthesized `E$N` class when bodied (MRO includes E,
+        // so members inherited from the enum still resolve), or to the host
+        // enum itself when body-less — makes `E.CONST.method()` resolve with
+        // no changes to the shared receiver-binding machinery.
+        //
+        // A bodied constant binds ONLY to its `E$N` class, never the host enum:
+        // if name synthesis fails on a malformed/error-recovery tree (`bodiedName`
+        // undefined despite a real body), emit nothing rather than silently
+        // misattributing an OVERRIDING constant's receiver to the enum's own
+        // (non-overridden) method — a wrong edge is worse than no edge. Mirrors
+        // the `object_creation_expression` branch, which skips on synthesis
+        // failure. `hostEnum` is used only for genuinely body-less constants.
+        const constantNameNode = constant.childForFieldName?.('name');
+        const constantType = isBodied ? bodiedName : hostEnum;
+        if (constantNameNode !== null && constantNameNode !== undefined && constantType !== undefined) {
+            out.push({
+                '@type-binding.annotation': nodeToCapture('@type-binding.annotation', constant),
+                '@type-binding.name': nodeToCapture('@type-binding.name', constantNameNode),
+                '@type-binding.type': syntheticCapture('@type-binding.type', constant, constantType),
+            });
+        }
+    }
+    return out;
+}
+/** Simple name of the enum_declaration enclosing an enum_constant, or
+ *  undefined (grammar guarantees one exists in well-formed source). */
+function javaEnclosingEnumNameOf(constant) {
+    let cursor = constant.parent;
+    while (cursor !== null) {
+        if (cursor.type === 'enum_declaration') {
+            return cursor.childForFieldName?.('name')?.text ?? undefined;
+        }
+        cursor = cursor.parent;
+    }
+    return undefined;
+}
 /**
  * Synthesize `@reference.call.constructor` captures for explicit constructor
  * invocations — `super(...)` and `this(...)` (F38 #1928). tree-sitter-java
@@ -357,6 +526,13 @@ function emitJavaInheritanceBase(out, base) {
     });
 }
 /** Resolve a Java base-type node to its bare simple-name identifier node. */
+/** Simple name of a constructed/base type node, reusing the same node
+ *  shapes `javaBaseLookupNameNode` handles (`Runnable`, `a.b.Base`,
+ *  `Box<T>`). Returns undefined when the node is none of those. */
+function javaBaseSimpleNameOf(typeNode) {
+    const nameNode = javaBaseLookupNameNode(typeNode);
+    return nameNode === null ? undefined : nameNode.text;
+}
 function javaBaseLookupNameNode(node) {
     switch (node.type) {
         case 'type_identifier':

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

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