gitnexus 1.6.10-rc.97 → 1.6.10-rc.98

package/dist/_shared/graph/types.d.ts

@@ -55,14 +55,14 @@ export type NodeProperties = {
     [key: string]: unknown;
 };
 export type RelationshipType = 'CONTAINS' | 'CALLS' | 'INHERITS' | 'METHOD_OVERRIDES' | 'METHOD_IMPLEMENTS' | 'IMPORTS' | 'USES' | 'DEFINES' | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' | 'HAS_METHOD' | 'HAS_PROPERTY' | 'ACCESSES' | 'MEMBER_OF' | 'STEP_IN_PROCESS' | 'HANDLES_ROUTE' | 'FETCHES' | 'HANDLES_TOOL' | 'ENTRY_POINT_OF' | 'WRAPS' | 'QUERIES'
-/** Dependency-injection edge: a consumer class receives every implementer
- *  of interface `T` via a container-injected collection-typed field
- *  (`List<T>`, `Set<T>`, `Collection<T>`, or `Map<K,T>`). Precondition: the
- *  field carries an injection annotation recognized by a per-language
- *  matcher registered in `di-extractors/` (Java/Spring today: `@Autowired`
- *  or `@Inject`; `@Resource` is excluded — by-name-first semantics).
- *  Source = the consumer Class node (the one owning the field).
- *  Target = an implementing Class node.
+/** Dependency-injection edge: a consumer class receives a likely provider
+ *  through constructor, field, method, or collection injection. A
+ *  per-language resolver identifies the site and provider metadata; the
+ *  shared DI phase uses type heritage, qualifier names, and preferred
+ *  provider markers to resolve it. Ambiguous single injection is represented
+ *  by multiple lower-confidence edges instead of a fabricated exact target.
+ *  Source = the consumer Class node (the one owning the injection site).
+ *  Target = a concrete provider Class node.
  *  Framework specifics live in the `reason` payload (e.g.
  *  `Spring DI: @Autowired List<T>`), not in this type contract.
  *  Lets Cypher queries trace which beans the container injects into a given

package/dist/core/ingestion/di-extractors/index.d.ts

@@ -1,47 +1,59 @@
 /**
- * Per-language DI field-matcher registry — the lookup the generic `di`
- * pipeline phase uses to decide whether a `Property` node is a
- * dependency-injection fan-out candidate.
+ * Per-language DI resolver registry — the lookup the generic `di` pipeline
+ * phase uses to discover injection sites and provider metadata on graph nodes.
  *
  * Mirrors `scope-resolution/pipeline/registry.ts` (`SCOPE_RESOLVERS`): a
- * single-valued `ReadonlyMap<SupportedLanguages, DiFieldMatcher>` consumed by
+ * single-valued `ReadonlyMap<SupportedLanguages, DiResolver>` consumed by
  * a framework-neutral phase, so no language or framework names leak into
- * shared pipeline code. Adding a framework is two lines: implement a
- * `DiFieldMatcher` in `di-extractors/<framework>.ts` and register it here.
+ * shared pipeline code. Adding a framework means implementing a `DiResolver`
+ * in `di-extractors/<framework>.ts` and registering it here.
  *
- * Scope honesty: matchers are per-language *field-injection* matchers.
- * Constructor injection (the dominant modern Spring idiom) lives on
- * Method/parameter nodes and would require widening the phase's routing —
- * deliberately out of scope (see the plan's Deferred work). The registry is
- * single-valued per language, matching the `SCOPE_RESOLVERS` shape; widen the
- * value type to arrays only when a second same-language framework actually
- * lands (a one-line type change then).
+ * The registry is single-valued per language, matching the `SCOPE_RESOLVERS`
+ * shape; widen the value type to arrays only when a second same-language
+ * framework actually lands. Java and Kotlin share Spring's attached metadata
+ * contract while retaining language-specific syntax capture.
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import type { GraphNode } from '../../../_shared/index.js';
-/** A successful DI field match, produced by a per-language matcher. */
-export interface DiFieldMatch {
-    /** The element type name `T` — the injected bean interface. */
-    elementTypeName: string;
+/** A successful injection-site match, produced by a per-language resolver. */
+export interface DiInjectionMatch {
+    /** The requested dependency type name. */
+    targetTypeName: string;
+    /** A collection receives every matching provider; a single site may need
+     *  framework-specific named/preferred-provider disambiguation. */
+    cardinality: 'single' | 'collection';
+    /** Statically known provider name requested at the injection site. The
+     *  resolver owns the human-readable explanation of that selection. */
+    namedSelection?: {
+        name: string;
+        reason: string;
+    };
     /** Human-readable edge reason. Framework specifics (names, idioms,
      *  collection wrapper, gating annotation) live in this payload so the
      *  shared `di` phase stays framework-neutral. */
     reason: string;
 }
-/**
- * A per-language field-injection matcher: given a `Property` node, return the
- * parsed DI match or `null` when the field is not container-injected. The
- * matcher receives the whole node (not pre-plucked fields) so the shared
- * phase stays ignorant of which properties matter.
- */
-export type DiFieldMatcher = (node: GraphNode) => DiFieldMatch | null;
+/** Provider metadata used by the shared resolver without naming a framework. */
+export interface DiProviderMatch {
+    /** Provider names and aliases that can satisfy a named injection. */
+    names: readonly string[];
+    /** Present when the framework marks this as its preferred candidate. The
+     *  value is appended to the emitted edge reason when it disambiguates. */
+    preferenceReason?: string;
+}
+/** Per-language DI behavior. Matchers receive whole nodes so the shared phase
+ * remains ignorant of language/framework-specific property shapes. */
+export interface DiResolver {
+    matchInjectionSites(node: GraphNode): readonly DiInjectionMatch[];
+    matchProvider(node: GraphNode): DiProviderMatch | null;
+}
 /**
  * Type guard narrowing an arbitrary graph `language` string to
- * `SupportedLanguages`, so `DI_MATCHERS.get()` needs no cast.
+ * `SupportedLanguages`, so `DI_RESOLVERS.get()` needs no cast.
  */
 export declare function isSupportedLanguage(value: string): value is SupportedLanguages;
-/** Map of `SupportedLanguages` → `DiFieldMatcher`. The `di` phase routes each
- *  `Property` node here by `node.properties.language`; no entry ⇒ the node is
+/** Map of `SupportedLanguages` → `DiResolver`. The `di` phase routes each
+ *  graph node here by `node.properties.language`; no entry ⇒ the node is
  *  skipped. This is the single source of truth for which languages (and,
  *  transitively, frameworks) produce INJECTS edges. */
-export declare const DI_MATCHERS: ReadonlyMap<SupportedLanguages, DiFieldMatcher>;
+export declare const DI_RESOLVERS: ReadonlyMap<SupportedLanguages, DiResolver>;

package/dist/core/ingestion/di-extractors/index.js

@@ -1,35 +1,34 @@
 /**
- * Per-language DI field-matcher registry — the lookup the generic `di`
- * pipeline phase uses to decide whether a `Property` node is a
- * dependency-injection fan-out candidate.
+ * Per-language DI resolver registry — the lookup the generic `di` pipeline
+ * phase uses to discover injection sites and provider metadata on graph nodes.
  *
  * Mirrors `scope-resolution/pipeline/registry.ts` (`SCOPE_RESOLVERS`): a
- * single-valued `ReadonlyMap<SupportedLanguages, DiFieldMatcher>` consumed by
+ * single-valued `ReadonlyMap<SupportedLanguages, DiResolver>` consumed by
  * a framework-neutral phase, so no language or framework names leak into
- * shared pipeline code. Adding a framework is two lines: implement a
- * `DiFieldMatcher` in `di-extractors/<framework>.ts` and register it here.
+ * shared pipeline code. Adding a framework means implementing a `DiResolver`
+ * in `di-extractors/<framework>.ts` and registering it here.
  *
- * Scope honesty: matchers are per-language *field-injection* matchers.
- * Constructor injection (the dominant modern Spring idiom) lives on
- * Method/parameter nodes and would require widening the phase's routing —
- * deliberately out of scope (see the plan's Deferred work). The registry is
- * single-valued per language, matching the `SCOPE_RESOLVERS` shape; widen the
- * value type to arrays only when a second same-language framework actually
- * lands (a one-line type change then).
+ * The registry is single-valued per language, matching the `SCOPE_RESOLVERS`
+ * shape; widen the value type to arrays only when a second same-language
+ * framework actually lands. Java and Kotlin share Spring's attached metadata
+ * contract while retaining language-specific syntax capture.
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
-import { springDiFieldMatcher } from './spring.js';
+import { springDiResolver } from './spring.js';
 /** All `SupportedLanguages` string values, for narrowing raw graph strings. */
 const SUPPORTED_LANGUAGE_VALUES = new Set(Object.values(SupportedLanguages));
 /**
  * Type guard narrowing an arbitrary graph `language` string to
- * `SupportedLanguages`, so `DI_MATCHERS.get()` needs no cast.
+ * `SupportedLanguages`, so `DI_RESOLVERS.get()` needs no cast.
  */
 export function isSupportedLanguage(value) {
     return SUPPORTED_LANGUAGE_VALUES.has(value);
 }
-/** Map of `SupportedLanguages` → `DiFieldMatcher`. The `di` phase routes each
- *  `Property` node here by `node.properties.language`; no entry ⇒ the node is
+/** Map of `SupportedLanguages` → `DiResolver`. The `di` phase routes each
+ *  graph node here by `node.properties.language`; no entry ⇒ the node is
  *  skipped. This is the single source of truth for which languages (and,
  *  transitively, frameworks) produce INJECTS edges. */
-export const DI_MATCHERS = new Map([[SupportedLanguages.Java, springDiFieldMatcher]]);
+export const DI_RESOLVERS = new Map([
+    [SupportedLanguages.Java, springDiResolver],
+    [SupportedLanguages.Kotlin, springDiResolver],
+]);

package/dist/core/ingestion/di-extractors/spring.d.ts

@@ -51,11 +51,22 @@
  *   between `<` and the element) are NOT stripped and fail closed —
  *   acceptable.
  *
- * Registered under `SupportedLanguages.Java` in `./index.ts` (`DI_MATCHERS`);
- * language routing is the registry's job, so the matcher itself never reads
- * `node.properties.language`.
+ * Registered for Java and Kotlin in `./index.ts` (`DI_RESOLVERS`); language
+ * routing is the registry's job, so the matcher itself never reads
+ * `node.properties.language`. Kotlin's AST-backed class metadata is the
+ * primary path because Kotlin Property extraction intentionally exposes less
+ * annotation/type syntax than Java's legacy field contract.
  */
-import type { DiFieldMatcher } from './index.js';
+import type { GraphNode } from '../../../_shared/index.js';
+import type { DiResolver } from './index.js';
+/** Ephemeral Class-node property populated by Java's post-resolution Spring
+ * metadata hook. It is consumed in the same pipeline run before persistence. */
+export declare const SPRING_DI_INJECTION_SITES_PROPERTY = "springDiInjectionSites";
+/** Ephemeral Class-node property carrying Spring bean names / @Primary. */
+export declare const SPRING_DI_PROVIDER_PROPERTY = "springDiProvider";
+/** Marker placed on Property nodes whose richer AST-backed field fact was
+ * attached to the owning Class, suppressing the legacy collection fallback. */
+export declare const SPRING_DI_CAPTURED_FIELD_PROPERTY = "springDiCapturedField";
 /**
  * Parse a Spring DI collection field's raw declared type (verbatim source
  * text, generics preserved) and return the injected bean type name.
@@ -73,10 +84,21 @@ export declare function parseSpringCollectionType(rawDeclaredType: string): {
     collectionType: string;
     elementTypeName: string;
 } | null;
+/** Parse either a supported collect-all type or a standard single bean type. */
+export declare function parseSpringInjectionType(rawDeclaredType: string): {
+    targetTypeName: string;
+    cardinality: 'single' | 'collection';
+    displayType: string;
+} | null;
 /**
  * Match a `Property` node against Spring's collection-injection shape.
  *
  * Returns the parsed match (with a Spring-specific human-readable `reason`
  * payload) or `null` when the field is not container-injected.
  */
-export declare const springDiFieldMatcher: DiFieldMatcher;
+export declare const springDiFieldMatcher: (node: GraphNode) => {
+    elementTypeName: string;
+    reason: string;
+} | null;
+/** JVM/Spring resolver registered behind the framework-neutral DI seam. */
+export declare const springDiResolver: DiResolver;

package/dist/core/ingestion/di-extractors/spring.js

@@ -51,9 +51,11 @@
  *   between `<` and the element) are NOT stripped and fail closed —
  *   acceptable.
  *
- * Registered under `SupportedLanguages.Java` in `./index.ts` (`DI_MATCHERS`);
- * language routing is the registry's job, so the matcher itself never reads
- * `node.properties.language`.
+ * Registered for Java and Kotlin in `./index.ts` (`DI_RESOLVERS`); language
+ * routing is the registry's job, so the matcher itself never reads
+ * `node.properties.language`. Kotlin's AST-backed class metadata is the
+ * primary path because Kotlin Property extraction intentionally exposes less
+ * annotation/type syntax than Java's legacy field contract.
  */
 import { isDev } from '../utils/env.js';
 import { logger } from '../../logger.js';
@@ -76,6 +78,14 @@ const WILDCARD_SUPER_PREFIX = '? super ';
  *  parser accepts. Everything else (wildcards, arrays, comments, stray
  *  punctuation) fails closed. */
 const JAVA_TYPE_NAME_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*$/;
+/** Ephemeral Class-node property populated by Java's post-resolution Spring
+ * metadata hook. It is consumed in the same pipeline run before persistence. */
+export const SPRING_DI_INJECTION_SITES_PROPERTY = 'springDiInjectionSites';
+/** Ephemeral Class-node property carrying Spring bean names / @Primary. */
+export const SPRING_DI_PROVIDER_PROPERTY = 'springDiProvider';
+/** Marker placed on Property nodes whose richer AST-backed field fact was
+ * attached to the owning Class, suppressing the legacy collection fallback. */
+export const SPRING_DI_CAPTURED_FIELD_PROPERTY = 'springDiCapturedField';
 /**
  * Split a generic-argument list on TOP-LEVEL commas only, tracking `<`/`>`
  * bracket depth so nested generics (e.g. the `Pair<A,B>` key in
@@ -179,6 +189,21 @@ export function parseSpringCollectionType(rawDeclaredType) {
         return null;
     return { collectionType: wrapper, elementTypeName };
 }
+/** Parse either a supported collect-all type or a standard single bean type. */
+export function parseSpringInjectionType(rawDeclaredType) {
+    const collection = parseSpringCollectionType(rawDeclaredType);
+    if (collection !== null) {
+        return {
+            targetTypeName: collection.elementTypeName,
+            cardinality: 'collection',
+            displayType: `${collection.collectionType}<${collection.elementTypeName}>`,
+        };
+    }
+    const normalized = rawDeclaredType.replace(/\s+/g, '').trim();
+    if (!JAVA_TYPE_NAME_PATTERN.test(normalized))
+        return null;
+    return { targetTypeName: normalized, cardinality: 'single', displayType: normalized };
+}
 /**
  * Match a `Property` node against Spring's collection-injection shape.
  *
@@ -218,3 +243,55 @@ export const springDiFieldMatcher = (node) => {
         reason: `Spring DI: ${matchedAnnotation} ${parsed.collectionType}<${parsed.elementTypeName}>`,
     };
 };
+function isInjectionMatch(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const match = value;
+    const namedSelection = match.namedSelection;
+    return (typeof match.targetTypeName === 'string' &&
+        (match.cardinality === 'single' || match.cardinality === 'collection') &&
+        typeof match.reason === 'string' &&
+        (namedSelection === undefined ||
+            (typeof namedSelection === 'object' &&
+                namedSelection !== null &&
+                typeof namedSelection.name === 'string' &&
+                typeof namedSelection.reason === 'string')));
+}
+function isProviderMatch(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const provider = value;
+    return (Array.isArray(provider.names) &&
+        provider.names.every((name) => typeof name === 'string') &&
+        (provider.preferenceReason === undefined || typeof provider.preferenceReason === 'string'));
+}
+/** JVM/Spring resolver registered behind the framework-neutral DI seam. */
+export const springDiResolver = {
+    matchInjectionSites(node) {
+        const matches = [];
+        // Preserve the existing Property-node collection contract for hand-built
+        // graphs and for compatibility with pre-#2414 extraction fixtures.
+        if (node.label === 'Property' && node.properties[SPRING_DI_CAPTURED_FIELD_PROPERTY] !== true) {
+            const field = springDiFieldMatcher(node);
+            if (field !== null) {
+                matches.push({
+                    targetTypeName: field.elementTypeName,
+                    cardinality: 'collection',
+                    reason: field.reason,
+                });
+            }
+        }
+        const attached = node.properties[SPRING_DI_INJECTION_SITES_PROPERTY];
+        if (Array.isArray(attached)) {
+            for (const candidate of attached) {
+                if (isInjectionMatch(candidate))
+                    matches.push(candidate);
+            }
+        }
+        return matches;
+    },
+    matchProvider(node) {
+        const attached = node.properties[SPRING_DI_PROVIDER_PROPERTY];
+        return isProviderMatch(attached) ? attached : null;
+    },
+};

package/dist/core/ingestion/frameworks/spring/di-metadata.d.ts

@@ -0,0 +1,45 @@
+import type { ParsedFile, ScopeId } from '../../../../_shared/index.js';
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import { parseSpringInjectionType } from '../../di-extractors/spring.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+export interface SpringDiAnnotationFact {
+    readonly name: string;
+    readonly text: string;
+}
+export interface SpringDiDependencyFact<Annotation extends SpringDiAnnotationFact> {
+    readonly name: string;
+    readonly rawType: string;
+    readonly annotations: readonly Annotation[];
+}
+export interface SpringDiInjectionSiteFact<Annotation extends SpringDiAnnotationFact, SiteKind extends string> {
+    readonly kind: SiteKind;
+    readonly memberName: string;
+    readonly implicitConstructor: boolean;
+    readonly annotations: readonly Annotation[];
+    readonly dependencies: readonly SpringDiDependencyFact<Annotation>[];
+}
+export interface SpringDiClassFact<Annotation extends SpringDiAnnotationFact, SiteKind extends string> {
+    readonly classScopeId: ScopeId;
+    readonly classAnnotations: readonly Annotation[];
+    readonly injectionSites: readonly SpringDiInjectionSiteFact<Annotation, SiteKind>[];
+}
+export declare function springAnnotationSimpleName(name: string): string;
+export declare function hasSpringDiRelevantAnnotation(annotations: readonly SpringDiAnnotationFact[]): boolean;
+export declare function hasSpringStereotypeSyntax(annotations: readonly SpringDiAnnotationFact[]): boolean;
+type ParsedSpringInjectionType = NonNullable<ReturnType<typeof parseSpringInjectionType>>;
+export interface SpringDiMetadataAdapter<Annotation extends SpringDiAnnotationFact, SiteKind extends string> {
+    getFacts(filePath: string): readonly SpringDiClassFact<Annotation, SiteKind>[];
+    isPackageVisibilityIncomplete(filePath: string): boolean;
+    parseInjectionType(rawType: string): ParsedSpringInjectionType | null;
+    capturedMemberKind: SiteKind;
+    isInjectionAnnotationApplicable?(annotation: Annotation, site: SpringDiInjectionSiteFact<Annotation, SiteKind>): boolean;
+    isQualifierAnnotationApplicable?(annotation: Annotation, site: SpringDiInjectionSiteFact<Annotation, SiteKind>): boolean;
+}
+/**
+ * Build the post-resolution Spring DI metadata hook shared by language adapters.
+ * Language adapters retain syntax capture, type normalization, use-site rules,
+ * and side-channel ownership; this function owns framework semantics only.
+ */
+export declare function createSpringDiMetadataAttacher<Annotation extends SpringDiAnnotationFact, SiteKind extends string>(adapter: SpringDiMetadataAdapter<Annotation, SiteKind>): (graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, indexes: ScopeResolutionIndexes) => void;
+export {};

package/dist/core/ingestion/frameworks/spring/di-metadata.js

@@ -0,0 +1,230 @@
+import { SPRING_DI_CAPTURED_FIELD_PROPERTY, SPRING_DI_INJECTION_SITES_PROPERTY, SPRING_DI_PROVIDER_PROPERTY, } from '../../di-extractors/spring.js';
+import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
+import { createSpringAnnotationNameResolver } from './bean-candidates.js';
+import { SPRING_BEAN_STEREOTYPES } from './bean-catalog.js';
+const INJECTION_ANNOTATIONS = new Set([
+    'org.springframework.beans.factory.annotation.Autowired',
+    'jakarta.inject.Inject',
+    'javax.inject.Inject',
+]);
+const QUALIFIER_ANNOTATIONS = new Set([
+    'org.springframework.beans.factory.annotation.Qualifier',
+    'jakarta.inject.Named',
+    'javax.inject.Named',
+]);
+const PRIMARY_ANNOTATIONS = new Set(['org.springframework.context.annotation.Primary']);
+const RESOLVABLE_DI_ANNOTATIONS = new Set([
+    ...SPRING_BEAN_STEREOTYPES.keys(),
+    ...INJECTION_ANNOTATIONS,
+    ...QUALIFIER_ANNOTATIONS,
+    ...PRIMARY_ANNOTATIONS,
+]);
+const CAPTURE_RELEVANT_ANNOTATIONS = new Set([
+    'Autowired',
+    'Inject',
+    'Qualifier',
+    'Named',
+    'Primary',
+    'Component',
+    'Service',
+    'Repository',
+    'Controller',
+    'RestController',
+    'Configuration',
+]);
+const STEREOTYPE_SIMPLE_NAMES = new Set([...SPRING_BEAN_STEREOTYPES.keys()].map((name) => springAnnotationSimpleName(name)));
+export function springAnnotationSimpleName(name) {
+    const separator = name.lastIndexOf('.');
+    return separator === -1 ? name : name.slice(separator + 1);
+}
+export function hasSpringDiRelevantAnnotation(annotations) {
+    return annotations.some((annotation) => CAPTURE_RELEVANT_ANNOTATIONS.has(springAnnotationSimpleName(annotation.name)));
+}
+export function hasSpringStereotypeSyntax(annotations) {
+    return annotations.some((annotation) => STEREOTYPE_SIMPLE_NAMES.has(springAnnotationSimpleName(annotation.name)));
+}
+function staticStringArgument(annotationText) {
+    const args = annotationText.match(/\((.*)\)$/s)?.[1]?.trim();
+    if (args === undefined)
+        return undefined;
+    const value = args.replace(/^value\s*=\s*/, '').trim();
+    const literal = value.match(/^"((?:\\.|[^"\\])*)"$/s);
+    if (literal === null)
+        return undefined;
+    try {
+        return JSON.parse(`"${literal[1]}"`);
+    }
+    catch {
+        return undefined;
+    }
+}
+function defaultBeanName(className) {
+    if (className.length === 0)
+        return className;
+    if (className.length > 1 &&
+        className[0] !== className[0].toLowerCase() &&
+        className[1] !== className[1].toLowerCase()) {
+        return className;
+    }
+    return className[0].toLowerCase() + className.slice(1);
+}
+/**
+ * Build the post-resolution Spring DI metadata hook shared by language adapters.
+ * Language adapters retain syntax capture, type normalization, use-site rules,
+ * and side-channel ownership; this function owns framework semantics only.
+ */
+export function createSpringDiMetadataAttacher(adapter) {
+    return (graph, parsedFiles, nodeLookup, indexes) => {
+        const resolveAnnotation = createSpringAnnotationNameResolver(indexes);
+        for (const parsed of parsedFiles) {
+            const incomplete = adapter.isPackageVisibilityIncomplete(parsed.filePath);
+            for (const fact of adapter.getFacts(parsed.filePath)) {
+                const classScope = indexes.scopeTree.getScope(fact.classScopeId);
+                if (classScope === undefined || classScope.kind !== 'Class')
+                    continue;
+                const classDef = classScope.ownedDefs.find((definition) => definition.type === 'Class');
+                if (classDef === undefined)
+                    continue;
+                const graphId = resolveDefGraphId(parsed.filePath, classDef, nodeLookup);
+                if (graphId === undefined)
+                    continue;
+                const classNode = graph.getNode(graphId);
+                if (classNode === undefined || classNode.label !== 'Class')
+                    continue;
+                const resolvedAnnotations = new Map();
+                const resolveFact = (annotation, enclosingScope = classScope.parent) => {
+                    const cacheKey = `${enclosingScope ?? '<root>'}\0${annotation.name}`;
+                    if (resolvedAnnotations.has(cacheKey))
+                        return resolvedAnnotations.get(cacheKey);
+                    const resolved = resolveAnnotation(annotation.name, parsed, enclosingScope, RESOLVABLE_DI_ANNOTATIONS, incomplete);
+                    resolvedAnnotations.set(cacheKey, resolved);
+                    return resolved;
+                };
+                const frameworkAnnotations = Array.isArray(classNode.properties.frameworkAnnotations)
+                    ? classNode.properties.frameworkAnnotations.filter((annotation) => typeof annotation === 'string')
+                    : [];
+                if (frameworkAnnotations.length > 0) {
+                    const names = new Set();
+                    let explicitBeanName;
+                    let hasDynamicBeanName = false;
+                    let primary = false;
+                    for (const annotation of fact.classAnnotations) {
+                        const resolved = resolveFact(annotation);
+                        if (resolved === undefined)
+                            continue;
+                        if (SPRING_BEAN_STEREOTYPES.has(resolved)) {
+                            const argumentText = annotation.text.match(/\((.*)\)$/s)?.[1]?.trim();
+                            if (argumentText !== undefined && argumentText.length > 0) {
+                                const staticName = staticStringArgument(annotation.text);
+                                if (staticName === undefined)
+                                    hasDynamicBeanName = true;
+                                else if (staticName.length > 0)
+                                    explicitBeanName = staticName;
+                            }
+                        }
+                        if (QUALIFIER_ANNOTATIONS.has(resolved)) {
+                            const qualifier = staticStringArgument(annotation.text);
+                            if (qualifier !== undefined)
+                                names.add(qualifier);
+                        }
+                        if (PRIMARY_ANNOTATIONS.has(resolved))
+                            primary = true;
+                    }
+                    if (explicitBeanName !== undefined)
+                        names.add(explicitBeanName);
+                    else if (!hasDynamicBeanName)
+                        names.add(defaultBeanName(classNode.properties.name));
+                    const provider = {
+                        names: [...names],
+                        ...(primary ? { preferenceReason: 'selected @Primary' } : {}),
+                    };
+                    classNode.properties[SPRING_DI_PROVIDER_PROPERTY] = provider;
+                }
+                const matches = [];
+                const semanticallyOwnedMemberNames = new Set();
+                for (const site of fact.injectionSites) {
+                    let injectionAnnotation;
+                    for (const annotation of site.annotations) {
+                        if (adapter.isInjectionAnnotationApplicable?.(annotation, site) === false)
+                            continue;
+                        const resolved = resolveFact(annotation, classScope.id);
+                        if (resolved !== undefined && INJECTION_ANNOTATIONS.has(resolved)) {
+                            injectionAnnotation = annotation;
+                            break;
+                        }
+                    }
+                    if (injectionAnnotation === undefined) {
+                        if (!site.implicitConstructor || frameworkAnnotations.length === 0)
+                            continue;
+                    }
+                    else if (site.kind === adapter.capturedMemberKind) {
+                        // Claim the member only after its injection annotation resolves to
+                        // a recognized FQN. Ambiguous wildcard imports stay unclaimed so
+                        // the legacy collection matcher can fall back. A dynamic qualifier
+                        // later fails closed, but this path still owns the member and must
+                        // suppress that legacy fallback.
+                        semanticallyOwnedMemberNames.add(site.memberName);
+                    }
+                    for (const dependency of site.dependencies) {
+                        const parsedType = adapter.parseInjectionType(dependency.rawType);
+                        if (parsedType === null)
+                            continue;
+                        let qualifierAnnotation;
+                        for (const annotation of dependency.annotations) {
+                            if (adapter.isQualifierAnnotationApplicable?.(annotation, site) === false)
+                                continue;
+                            const resolved = resolveFact(annotation, classScope.id);
+                            if (resolved !== undefined && QUALIFIER_ANNOTATIONS.has(resolved)) {
+                                qualifierAnnotation = annotation;
+                                break;
+                            }
+                        }
+                        const qualifier = qualifierAnnotation === undefined
+                            ? undefined
+                            : staticStringArgument(qualifierAnnotation.text);
+                        // A present-but-dynamic qualifier is not the same as no qualifier.
+                        // Without its value we cannot choose a provider honestly, so fail
+                        // closed instead of emitting the unqualified candidate set.
+                        if (qualifierAnnotation !== undefined && qualifier === undefined)
+                            continue;
+                        const trigger = injectionAnnotation === undefined
+                            ? 'constructor'
+                            : `@${springAnnotationSimpleName(injectionAnnotation.name)} ${site.kind}`;
+                        const location = site.kind === adapter.capturedMemberKind
+                            ? site.memberName
+                            : `${site.memberName} parameter ${dependency.name}`;
+                        matches.push({
+                            targetTypeName: parsedType.targetTypeName,
+                            cardinality: parsedType.cardinality,
+                            ...(qualifier === undefined
+                                ? {}
+                                : {
+                                    namedSelection: {
+                                        name: qualifier,
+                                        reason: `qualifier "${qualifier}"`,
+                                    },
+                                }),
+                            reason: `Spring DI: ${trigger} ${location}: ${parsedType.displayType}`,
+                        });
+                    }
+                }
+                if (matches.length > 0) {
+                    classNode.properties[SPRING_DI_INJECTION_SITES_PROPERTY] = matches;
+                }
+                for (const memberName of semanticallyOwnedMemberNames) {
+                    for (const { def } of classScope.bindings.get(memberName) ?? []) {
+                        if (def.ownerId !== classDef.nodeId)
+                            continue;
+                        const propertyId = resolveDefGraphId(parsed.filePath, def, nodeLookup);
+                        if (propertyId === undefined)
+                            continue;
+                        const property = graph.getNode(propertyId);
+                        if (property?.label === 'Property') {
+                            property.properties[SPRING_DI_CAPTURED_FIELD_PROPERTY] = true;
+                        }
+                    }
+                }
+            }
+        }
+    };
+}

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

@@ -2,12 +2,14 @@ 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';
+import type { JavaSpringDiClassFact } from './spring-di.js';
 export type JavaClassAnnotationFact = ClassAnnotationFact;
 export interface JavaCaptureSideChannel {
     readonly kind: 'java';
     readonly packageFact: JvmPackageFact;
     readonly classAnnotations: readonly JavaClassAnnotationFact[];
     readonly springConfigConsumers?: readonly JavaSpringConfigConsumerFact[];
+    readonly springDiFacts?: readonly JavaSpringDiClassFact[];
 }
 /** Clear facts retained by a prior workspace pass in a long-lived process. */
 export declare function clearJavaClassAnnotationFacts(): void;
@@ -15,6 +17,8 @@ export declare function clearJavaClassAnnotationFacts(): void;
 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[];
+export declare function setJavaSpringDiFacts(filePath: string, facts: readonly JavaSpringDiClassFact[]): void;
+export declare function getJavaSpringDiFacts(filePath: string): readonly JavaSpringDiClassFact[];
 /** 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[];