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

package/dist/core/ingestion/frameworks/spring/bean-candidates.js

@@ -0,0 +1,182 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
+import { isClassLike, lookupBindingsAt } from '../../scope-resolution/scope/walkers.js';
+import { SPRING_BEAN_STEREOTYPES } from './bean-catalog.js';
+/** Per-language store for capture facts that cross the worker boundary. */
+export function createClassAnnotationFactStore() {
+    const factsByFile = new Map();
+    return {
+        clear: () => factsByFile.clear(),
+        set: (filePath, facts) => {
+            if (facts.length === 0)
+                factsByFile.delete(filePath);
+            else
+                factsByFile.set(filePath, facts);
+        },
+        get: (filePath) => factsByFile.get(filePath) ?? [],
+    };
+}
+/** Record one annotation from the language's existing scope-query traversal. */
+export function recordClassAnnotationCapture(facts, filePath, classCapture, annotationName) {
+    const classScopeId = makeScopeId({ filePath, range: classCapture.range, kind: 'Class' });
+    const names = facts.get(classScopeId) ?? new Set();
+    names.add(annotationName.trim());
+    facts.set(classScopeId, names);
+}
+export function materializeClassAnnotationFacts(facts) {
+    return [...facts].map(([classScopeId, annotationNames]) => ({
+        classScopeId,
+        annotationNames: [...annotationNames],
+    }));
+}
+function simpleNameOf(def) {
+    const qualifiedName = def.qualifiedName;
+    if (qualifiedName === undefined)
+        return undefined;
+    const separator = qualifiedName.lastIndexOf('.');
+    return separator === -1 ? qualifiedName : qualifiedName.slice(separator + 1);
+}
+function buildOwnedTypeNamesByOwner(indexes) {
+    const namesByOwner = new Map();
+    for (const def of indexes.defs.byId.values()) {
+        if (def.ownerId === undefined)
+            continue;
+        if (!isClassLike(def.type) && def.type !== 'Annotation')
+            continue;
+        const simpleName = simpleNameOf(def);
+        if (simpleName === undefined)
+            continue;
+        const names = namesByOwner.get(def.ownerId) ?? new Set();
+        names.add(simpleName);
+        namesByOwner.set(def.ownerId, names);
+    }
+    return namesByOwner;
+}
+function hasLexicalTypeDeclaration(startScope, simpleName, indexes) {
+    let scopeId = startScope;
+    const visited = new Set();
+    while (scopeId !== null && !visited.has(scopeId)) {
+        visited.add(scopeId);
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope === undefined)
+            return false;
+        const locals = scope.bindings.get(simpleName);
+        if (locals?.some(({ def }) => isClassLike(def.type) || def.type === 'Annotation'))
+            return true;
+        scopeId = scope.parent;
+    }
+    return false;
+}
+function explicitImportTargets(parsed, simpleName) {
+    const targets = new Set();
+    for (const entry of parsed.parsedImports) {
+        if (entry.kind !== 'named' && entry.kind !== 'alias')
+            continue;
+        if (entry.localName !== simpleName)
+            continue;
+        targets.add(entry.targetRaw);
+    }
+    return targets;
+}
+function hasInheritedTypeDeclaration(startScope, simpleName, indexes, ownedTypeNamesByOwner) {
+    let scopeId = startScope;
+    const visited = new Set();
+    while (scopeId !== null && !visited.has(scopeId)) {
+        visited.add(scopeId);
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope === undefined)
+            return false;
+        if (scope.kind === 'Class') {
+            const classDef = scope.ownedDefs.find((def) => isClassLike(def.type));
+            if (classDef !== undefined) {
+                for (const ancestorId of indexes.methodDispatch.mroFor(classDef.nodeId)) {
+                    if (ownedTypeNamesByOwner.get(ancestorId)?.has(simpleName) === true)
+                        return true;
+                }
+            }
+        }
+        scopeId = scope.parent;
+    }
+    return false;
+}
+function hasVisibleTypeBinding(startScope, simpleName, indexes) {
+    let scopeId = startScope;
+    const visited = new Set();
+    while (scopeId !== null && !visited.has(scopeId)) {
+        visited.add(scopeId);
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope === undefined)
+            return false;
+        const visible = lookupBindingsAt(scopeId, simpleName, indexes);
+        if (visible.some(({ def }) => isClassLike(def.type) || def.type === 'Annotation'))
+            return true;
+        scopeId = scope.parent;
+    }
+    return false;
+}
+function wildcardImportTarget(parsed, simpleName, recognizedAnnotations) {
+    const wildcardPackages = new Set(parsed.parsedImports
+        .filter((entry) => entry.kind === 'wildcard')
+        .map((entry) => entry.targetRaw.replace(/\.\*$/, '')));
+    if (wildcardPackages.size !== 1)
+        return undefined;
+    const [packageName] = wildcardPackages;
+    const target = `${packageName}.${simpleName}`;
+    return recognizedAnnotations.has(target) ? target : undefined;
+}
+/** Build a scope-aware Spring annotation resolver shared by framework hooks. */
+export function createSpringAnnotationNameResolver(indexes) {
+    const ownedTypeNamesByOwner = buildOwnedTypeNamesByOwner(indexes);
+    return (rawName, parsed, enclosingScope, recognizedAnnotations, isPackageVisibilityIncomplete) => {
+        if (rawName.includes('.')) {
+            return recognizedAnnotations.has(rawName) ? rawName : undefined;
+        }
+        if (hasLexicalTypeDeclaration(enclosingScope, rawName, indexes))
+            return undefined;
+        if (hasInheritedTypeDeclaration(enclosingScope, rawName, indexes, ownedTypeNamesByOwner)) {
+            return undefined;
+        }
+        const explicitImports = explicitImportTargets(parsed, rawName);
+        if (explicitImports.size > 0) {
+            if (explicitImports.size !== 1)
+                return undefined;
+            const [imported] = explicitImports;
+            return recognizedAnnotations.has(imported) ? imported : undefined;
+        }
+        const wildcardTarget = wildcardImportTarget(parsed, rawName, recognizedAnnotations);
+        if (wildcardTarget === undefined || isPackageVisibilityIncomplete)
+            return undefined;
+        return hasVisibleTypeBinding(enclosingScope, rawName, indexes) ? undefined : wildcardTarget;
+    };
+}
+/** Build a language hook that enriches Class nodes after scope resolution. */
+export function createSpringBeanCandidateAttacher(adapter) {
+    return (graph, parsedFiles, nodeLookup, indexes) => {
+        const resolveSpringAnnotation = createSpringAnnotationNameResolver(indexes);
+        for (const parsed of parsedFiles) {
+            for (const fact of adapter.getClassAnnotationFacts(parsed.filePath)) {
+                const classScope = indexes.scopeTree.getScope(fact.classScopeId);
+                if (classScope === undefined || classScope.kind !== 'Class')
+                    continue;
+                const classDef = classScope.ownedDefs.find((def) => def.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 recognized = new Set();
+                for (const rawName of fact.annotationNames) {
+                    const annotation = resolveSpringAnnotation(rawName, parsed, classScope.parent, SPRING_BEAN_STEREOTYPES, adapter.isPackageVisibilityIncomplete(parsed.filePath));
+                    if (annotation !== undefined)
+                        recognized.add(annotation);
+                }
+                if (recognized.size === 1) {
+                    classNode.properties.frameworkAnnotations = [...recognized];
+                }
+            }
+        }
+    };
+}

package/dist/core/ingestion/frameworks/spring/bean-catalog.d.ts

@@ -0,0 +1,12 @@
+export interface SpringBeanMetadata {
+    framework: 'spring';
+    role: string;
+    annotation: string;
+}
+export interface SpringBeanStereotype {
+    role: string;
+}
+export declare const SPRING_BEAN_STEREOTYPES: Map<string, SpringBeanStereotype>;
+export declare function deriveSpringBeanMetadata(frameworkAnnotations: readonly string[]): SpringBeanMetadata | undefined;
+/** Whether a source change can alter Spring Bean candidate metadata. */
+export declare function isSpringBeanCandidateSourceFile(filePath: string): boolean;

package/dist/core/ingestion/frameworks/spring/bean-catalog.js

@@ -0,0 +1,27 @@
+export const SPRING_BEAN_STEREOTYPES = new Map([
+    ['org.springframework.stereotype.Component', { role: 'component' }],
+    ['org.springframework.stereotype.Service', { role: 'service' }],
+    ['org.springframework.stereotype.Repository', { role: 'repository' }],
+    ['org.springframework.stereotype.Controller', { role: 'controller' }],
+    ['org.springframework.web.bind.annotation.RestController', { role: 'rest-controller' }],
+    ['org.springframework.context.annotation.Configuration', { role: 'configuration' }],
+    ['org.springframework.boot.autoconfigure.AutoConfiguration', { role: 'auto-configuration' }],
+]);
+export function deriveSpringBeanMetadata(frameworkAnnotations) {
+    const recognized = [
+        ...new Set(frameworkAnnotations.filter((annotation) => SPRING_BEAN_STEREOTYPES.has(annotation))),
+    ];
+    if (recognized.length !== 1)
+        return undefined;
+    const annotation = recognized[0];
+    const stereotype = SPRING_BEAN_STEREOTYPES.get(annotation);
+    if (!stereotype)
+        return undefined;
+    return { framework: 'spring', role: stereotype.role, annotation };
+}
+const SPRING_BEAN_SOURCE_EXTENSIONS = ['.java', '.kt', '.kts'];
+/** Whether a source change can alter Spring Bean candidate metadata. */
+export function isSpringBeanCandidateSourceFile(filePath) {
+    const normalized = filePath.toLowerCase();
+    return SPRING_BEAN_SOURCE_EXTENSIONS.some((extension) => normalized.endsWith(extension));
+}

package/dist/core/ingestion/frameworks/spring/bean-factories.d.ts

@@ -0,0 +1,33 @@
+import type { GraphRelationship, ScopeId } from '../../../../_shared/index.js';
+import type { SpringDiAnnotationFact, SpringDiDependencyFact } from './di-metadata.js';
+export declare const SPRING_BEAN_ANNOTATION = "org.springframework.context.annotation.Bean";
+export declare const SPRING_BEAN_DECLARATION_ID_PREFIX = "CodeElement:spring-bean:";
+export declare const SPRING_BEAN_FACTORY_REASON_PREFIX = "spring-bean-factory:";
+export interface SpringBeanFactoryMethodFact<Annotation extends SpringDiAnnotationFact = SpringDiAnnotationFact> {
+    readonly callableScopeId: ScopeId;
+    readonly methodName: string;
+    readonly returnType?: string;
+    readonly annotations: readonly Annotation[];
+    readonly dependencies: readonly SpringDiDependencyFact<Annotation>[];
+}
+export interface SpringBeanFactoryDeclaration {
+    readonly names: readonly string[];
+    readonly namesKnown: boolean;
+    readonly providedType?: string;
+}
+export interface SpringBeanFactoryMetadata {
+    readonly framework: 'spring';
+    readonly role: 'factory-method';
+    readonly annotation: typeof SPRING_BEAN_ANNOTATION;
+    readonly names: readonly string[];
+    readonly providedType?: string;
+}
+export declare function hasSpringBeanFactorySyntax(annotations: readonly Pick<SpringDiAnnotationFact, 'name'>[]): boolean;
+/** Resolve statically readable Bean names; dynamic constants remain explicitly unknown. */
+export declare function springBeanNames(annotationText: string, defaultMethodName: string): {
+    readonly names: readonly string[];
+    readonly namesKnown: boolean;
+};
+export declare function encodeSpringBeanFactoryReason(declaration: SpringBeanFactoryDeclaration): string;
+export declare function decodeSpringBeanFactoryReason(reason: unknown): SpringBeanFactoryMetadata | undefined;
+export declare function isSpringBeanFactoryDeclaration(relationship: Pick<GraphRelationship, 'type' | 'reason'>): boolean;

package/dist/core/ingestion/frameworks/spring/bean-factories.js

@@ -0,0 +1,65 @@
+import { parseSpringAnnotationArguments, parseStaticStringValues } from './annotation-arguments.js';
+export const SPRING_BEAN_ANNOTATION = 'org.springframework.context.annotation.Bean';
+export const SPRING_BEAN_DECLARATION_ID_PREFIX = 'CodeElement:spring-bean:';
+export const SPRING_BEAN_FACTORY_REASON_PREFIX = 'spring-bean-factory:';
+function simpleName(name) {
+    const separator = name.lastIndexOf('.');
+    return separator === -1 ? name : name.slice(separator + 1);
+}
+export function hasSpringBeanFactorySyntax(annotations) {
+    return annotations.some((annotation) => simpleName(annotation.name) === 'Bean');
+}
+/** Resolve statically readable Bean names; dynamic constants remain explicitly unknown. */
+export function springBeanNames(annotationText, defaultMethodName) {
+    const argumentsList = parseSpringAnnotationArguments(annotationText);
+    if (argumentsList === null)
+        return { names: [], namesKnown: false };
+    const nameArguments = argumentsList.filter((argument) => argument.name === undefined || argument.name === 'name' || argument.name === 'value');
+    if (nameArguments.length === 0)
+        return { names: [defaultMethodName], namesKnown: true };
+    const names = new Set();
+    for (const argument of nameArguments) {
+        const values = parseStaticStringValues(argument.value);
+        if (values === null)
+            return { names: [], namesKnown: false };
+        for (const value of values) {
+            if (value.length > 0)
+                names.add(value);
+        }
+    }
+    return {
+        names: names.size === 0 ? [defaultMethodName] : [...names],
+        namesKnown: true,
+    };
+}
+export function encodeSpringBeanFactoryReason(declaration) {
+    return `${SPRING_BEAN_FACTORY_REASON_PREFIX}${JSON.stringify(declaration)}`;
+}
+export function decodeSpringBeanFactoryReason(reason) {
+    if (typeof reason !== 'string' || !reason.startsWith(SPRING_BEAN_FACTORY_REASON_PREFIX)) {
+        return undefined;
+    }
+    try {
+        const value = JSON.parse(reason.slice(SPRING_BEAN_FACTORY_REASON_PREFIX.length));
+        if (!Array.isArray(value.names) ||
+            !value.names.every((name) => typeof name === 'string') ||
+            typeof value.namesKnown !== 'boolean' ||
+            (value.providedType !== undefined && typeof value.providedType !== 'string')) {
+            return undefined;
+        }
+        return {
+            framework: 'spring',
+            role: 'factory-method',
+            annotation: SPRING_BEAN_ANNOTATION,
+            names: value.names,
+            ...(value.providedType === undefined ? {} : { providedType: value.providedType }),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function isSpringBeanFactoryDeclaration(relationship) {
+    return (relationship.type === 'DECLARES' &&
+        relationship.reason.startsWith(SPRING_BEAN_FACTORY_REASON_PREFIX));
+}

package/dist/core/ingestion/frameworks/spring/conditionals.d.ts

@@ -0,0 +1,25 @@
+import type { ParsedFile, ScopeId } from '../../../../_shared/index.js';
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+export interface SpringConditionalAnnotationFact {
+    readonly name: string;
+    readonly text: string;
+    readonly line: number;
+}
+export interface SpringConditionalOwnerFact<Annotation extends SpringConditionalAnnotationFact = SpringConditionalAnnotationFact> {
+    readonly ownerScopeId: ScopeId;
+    readonly ownerKind: 'class' | 'callable';
+    readonly annotations: readonly Annotation[];
+}
+export interface SpringConditionalMetadataAdapter<Annotation extends SpringConditionalAnnotationFact> {
+    getFacts(filePath: string): readonly SpringConditionalOwnerFact<Annotation>[];
+    isPackageVisibilityIncomplete(filePath: string): boolean;
+}
+export declare function hasSpringConditionalRelevantAnnotation(annotations: readonly Pick<SpringConditionalAnnotationFact, 'name'>[]): boolean;
+/**
+ * Build a post-resolution Spring conditional attacher shared by language
+ * adapters. Adapters capture syntax and package-visibility facts; this module
+ * owns framework annotation semantics and graph representation.
+ */
+export declare function createSpringConditionalMetadataAttacher<Annotation extends SpringConditionalAnnotationFact>(adapter: SpringConditionalMetadataAdapter<Annotation>): (graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, indexes: ScopeResolutionIndexes) => void;

package/dist/core/ingestion/frameworks/spring/conditionals.js

@@ -0,0 +1,319 @@
+import { generateId } from '../../../../lib/utils.js';
+import { resolveCallerGraphId, resolveDefGraphId, } from '../../scope-resolution/graph-bridge/ids.js';
+import { stripBidiAndZeroWidth } from '../../utils/ast-helpers.js';
+import { createSpringAnnotationNameResolver } from './bean-candidates.js';
+import { SPRING_CONFIG_DESCRIPTION } from './config-bindings.js';
+const PROFILE_ANNOTATION = 'org.springframework.context.annotation.Profile';
+const CONDITIONAL_ANNOTATION = 'org.springframework.context.annotation.Conditional';
+const AUTO_CONFIGURATION_ANNOTATION = 'org.springframework.boot.autoconfigure.AutoConfiguration';
+const BOOT_CONDITIONAL_ANNOTATIONS = [
+    'ConditionalOnBean',
+    'ConditionalOnBooleanProperty',
+    'ConditionalOnClass',
+    'ConditionalOnCloudPlatform',
+    'ConditionalOnExpression',
+    'ConditionalOnJava',
+    'ConditionalOnJndi',
+    'ConditionalOnMissingBean',
+    'ConditionalOnMissingClass',
+    'ConditionalOnNotWebApplication',
+    'ConditionalOnProperty',
+    'ConditionalOnResource',
+    'ConditionalOnSingleCandidate',
+    'ConditionalOnThreading',
+    'ConditionalOnWarDeployment',
+    'ConditionalOnWebApplication',
+];
+const CONDITIONAL_ANNOTATIONS = new Set([
+    PROFILE_ANNOTATION,
+    CONDITIONAL_ANNOTATION,
+    ...BOOT_CONDITIONAL_ANNOTATIONS.map((name) => `org.springframework.boot.autoconfigure.condition.${name}`),
+]);
+const PROPERTY_CONDITIONAL_ANNOTATIONS = new Set([
+    'org.springframework.boot.autoconfigure.condition.ConditionalOnProperty',
+    'org.springframework.boot.autoconfigure.condition.ConditionalOnBooleanProperty',
+]);
+const RESOLVABLE_SPRING_CONDITIONAL_ANNOTATIONS = new Set([
+    ...CONDITIONAL_ANNOTATIONS,
+    AUTO_CONFIGURATION_ANNOTATION,
+]);
+const CAPTURE_RELEVANT_SIMPLE_NAMES = new Set([
+    'Profile',
+    'Conditional',
+    'AutoConfiguration',
+    ...BOOT_CONDITIONAL_ANNOTATIONS,
+]);
+function simpleName(name) {
+    const separator = name.lastIndexOf('.');
+    return separator === -1 ? name : name.slice(separator + 1);
+}
+export function hasSpringConditionalRelevantAnnotation(annotations) {
+    return annotations.some((annotation) => CAPTURE_RELEVANT_SIMPLE_NAMES.has(simpleName(annotation.name)));
+}
+function annotationArguments(text) {
+    const start = text.indexOf('(');
+    const end = text.lastIndexOf(')');
+    if (start === -1 || end <= start)
+        return undefined;
+    const args = text.slice(start + 1, end).trim();
+    return args.length === 0 ? undefined : args;
+}
+function splitTopLevelArguments(value) {
+    const parts = [];
+    let start = 0;
+    let quote = null;
+    let escaped = false;
+    let round = 0;
+    let square = 0;
+    let curly = 0;
+    for (let index = 0; index < value.length; index++) {
+        const char = value.charAt(index);
+        if (quote !== null) {
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === '(')
+            round++;
+        else if (char === ')')
+            round = Math.max(0, round - 1);
+        else if (char === '[')
+            square++;
+        else if (char === ']')
+            square = Math.max(0, square - 1);
+        else if (char === '{')
+            curly++;
+        else if (char === '}')
+            curly = Math.max(0, curly - 1);
+        else if (char === ',' && round === 0 && square === 0 && curly === 0) {
+            parts.push(value.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    parts.push(value.slice(start).trim());
+    return parts.filter((part) => part.length > 0);
+}
+function parseArguments(text) {
+    const positional = [];
+    const named = new Map();
+    const args = annotationArguments(text);
+    if (args === undefined)
+        return { positional, named };
+    for (const part of splitTopLevelArguments(args)) {
+        const assignment = /^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*([\s\S]+)$/.exec(part);
+        if (assignment === null)
+            positional.push(part);
+        else {
+            const [, name, value] = assignment;
+            if (name !== undefined && value !== undefined)
+                named.set(name, value.trim());
+        }
+    }
+    return { positional, named };
+}
+function decodeStaticString(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function staticStrings(value) {
+    if (value === undefined)
+        return [];
+    const values = [];
+    for (let index = 0; index < value.length;) {
+        if (value.startsWith('"""', index)) {
+            const end = value.indexOf('"""', index + 3);
+            if (end === -1)
+                break;
+            const decoded = value.slice(index + 3, end);
+            if (!decoded.includes('${'))
+                values.push(decoded);
+            index = end + 3;
+            continue;
+        }
+        if (value.charAt(index) !== '"') {
+            index++;
+            continue;
+        }
+        let end = index + 1;
+        let escaped = false;
+        for (; end < value.length; end++) {
+            const char = value.charAt(end);
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === '"')
+                break;
+        }
+        if (end >= value.length)
+            break;
+        const decoded = decodeStaticString(value.slice(index, end + 1));
+        if (decoded !== undefined)
+            values.push(decoded);
+        index = end + 1;
+    }
+    return values;
+}
+function propertyConditionKeys(annotationText) {
+    const args = parseArguments(annotationText);
+    const prefix = staticStrings(args.named.get('prefix'))[0]?.trim().replace(/\.+$/, '') ?? '';
+    const names = staticStrings(args.named.get('name') ??
+        args.named.get('value') ??
+        (args.positional.length > 0 ? args.positional.join(',') : undefined));
+    return [
+        ...new Set(names
+            .map((name) => name.replace(/^\.+/, '').trim())
+            .filter((name) => name.length > 0)
+            .map((name) => (prefix.length > 0 ? `${prefix}.${name}` : name))),
+    ];
+}
+function conditionDescription(resolvedName, annotationText) {
+    const args = annotationArguments(annotationText);
+    const renderedArgs = args === undefined ? '' : `(${args.replace(/\s+/g, ' ').trim().slice(0, 1000)})`;
+    return stripBidiAndZeroWidth(`Spring condition @${simpleName(resolvedName)}${renderedArgs}; activation unknown`);
+}
+function ownerGraphNode(fact, indexes, nodeLookup, graph) {
+    const ownerScope = indexes.scopeTree.getScope(fact.ownerScopeId);
+    if (ownerScope === undefined)
+        return undefined;
+    let ownerId;
+    if (fact.ownerKind === 'class') {
+        const classDef = ownerScope.ownedDefs.find((definition) => definition.type === 'Class' || definition.type === 'Record');
+        if (classDef !== undefined) {
+            ownerId = resolveDefGraphId(classDef.filePath, classDef, nodeLookup);
+        }
+    }
+    else {
+        ownerId = resolveCallerGraphId(fact.ownerScopeId, indexes, nodeLookup, {
+            startLine: fact.annotations[0]?.line ?? ownerScope.range.startLine,
+            startCol: 0,
+        });
+    }
+    if (ownerId === undefined)
+        return undefined;
+    const owner = graph.getNode(ownerId);
+    if (owner === undefined || owner.label === 'File')
+        return undefined;
+    return owner;
+}
+function addConditionNode(graph, owner, annotation, resolvedName) {
+    const description = conditionDescription(resolvedName, annotation.text);
+    const nodeId = generateId('Annotation', `spring-condition:${owner.id}:${annotation.line}:${resolvedName}:${description}`);
+    const conditionNode = {
+        id: nodeId,
+        label: 'Annotation',
+        properties: {
+            name: `@${simpleName(resolvedName)}`,
+            filePath: owner.properties.filePath,
+            startLine: annotation.line,
+            endLine: annotation.line,
+            description,
+        },
+    };
+    graph.addNode(conditionNode);
+    const fileId = generateId('File', owner.properties.filePath);
+    if (graph.getNode(fileId) !== undefined) {
+        graph.addRelationship({
+            id: generateId('DEFINES', `${fileId}->${nodeId}`),
+            sourceId: fileId,
+            targetId: nodeId,
+            type: 'DEFINES',
+            confidence: 1,
+            reason: 'spring-condition:annotation',
+        });
+    }
+    return conditionNode;
+}
+function addConditionalRelationship(graph, owner, target, annotation, resolvedName, detail) {
+    const reason = stripBidiAndZeroWidth([`spring-condition:@${simpleName(resolvedName)}`, detail, 'activation=unknown']
+        .filter((part) => part !== undefined && part.length > 0)
+        .join(' '));
+    graph.addRelationship({
+        id: generateId('CONDITIONAL_ON', `${owner.id}->${target.id}:${annotation.line}:${resolvedName}:${detail ?? ''}`),
+        sourceId: owner.id,
+        targetId: target.id,
+        type: 'CONDITIONAL_ON',
+        confidence: 1,
+        reason,
+    });
+}
+const configNodesByGraph = new WeakMap();
+function configNodesByKey(graph) {
+    const cached = configNodesByGraph.get(graph);
+    if (cached !== undefined)
+        return cached;
+    const byKey = new Map();
+    for (const node of graph.iterNodes()) {
+        if (node.label !== 'Property' ||
+            typeof node.properties.description !== 'string' ||
+            !node.properties.description.startsWith(SPRING_CONFIG_DESCRIPTION)) {
+            continue;
+        }
+        const key = String(node.properties.name);
+        const bucket = byKey.get(key) ?? [];
+        bucket.push(node);
+        byKey.set(key, bucket);
+    }
+    configNodesByGraph.set(graph, byKey);
+    return byKey;
+}
+/**
+ * Build a post-resolution Spring conditional attacher shared by language
+ * adapters. Adapters capture syntax and package-visibility facts; this module
+ * owns framework annotation semantics and graph representation.
+ */
+export function createSpringConditionalMetadataAttacher(adapter) {
+    return (graph, parsedFiles, nodeLookup, indexes) => {
+        const resolveAnnotation = createSpringAnnotationNameResolver(indexes);
+        let propertyNodes;
+        for (const parsed of parsedFiles) {
+            const incomplete = adapter.isPackageVisibilityIncomplete(parsed.filePath);
+            const resolvedAnnotations = new Map();
+            for (const fact of adapter.getFacts(parsed.filePath)) {
+                const owner = ownerGraphNode(fact, indexes, nodeLookup, graph);
+                const ownerScope = indexes.scopeTree.getScope(fact.ownerScopeId);
+                if (owner === undefined || ownerScope === undefined)
+                    continue;
+                for (const annotation of fact.annotations) {
+                    const cacheKey = `${ownerScope.parent ?? '<root>'}\0${annotation.name}`;
+                    let resolved = resolvedAnnotations.get(cacheKey);
+                    if (!resolvedAnnotations.has(cacheKey)) {
+                        resolved = resolveAnnotation(annotation.name, parsed, ownerScope.parent, RESOLVABLE_SPRING_CONDITIONAL_ANNOTATIONS, incomplete);
+                        resolvedAnnotations.set(cacheKey, resolved);
+                    }
+                    if (resolved === undefined)
+                        continue;
+                    if (!CONDITIONAL_ANNOTATIONS.has(resolved))
+                        continue;
+                    if (PROPERTY_CONDITIONAL_ANNOTATIONS.has(resolved)) {
+                        const keys = propertyConditionKeys(annotation.text);
+                        propertyNodes ??= configNodesByKey(graph);
+                        let matched = false;
+                        for (const key of keys) {
+                            for (const property of propertyNodes.get(key) ?? []) {
+                                matched = true;
+                                addConditionalRelationship(graph, owner, property, annotation, resolved, `key=${key}`);
+                            }
+                        }
+                        if (matched)
+                            continue;
+                    }
+                    const conditionNode = addConditionNode(graph, owner, annotation, resolved);
+                    addConditionalRelationship(graph, owner, conditionNode, annotation, resolved);
+                }
+            }
+        }
+    };
+}