gitnexus 1.6.11-rc.8 → 1.6.11

package/dist/core/ingestion/languages/kotlin/spring-actuator.js

@@ -0,0 +1,172 @@
+import path from 'node:path';
+const RUNTIME_OWNER_ALIASES = 'runtimeOwnerAliases';
+const RUNTIME_CALLABLE_ALIASES = 'runtimeCallableAliases';
+const KOTLIN_SUSPEND = 'kotlinSuspend';
+const fileFacadeMetadataCache = new WeakMap();
+function rootNode(node) {
+    let current = node;
+    while (current.parent)
+        current = current.parent;
+    return current;
+}
+function packageName(root) {
+    const header = root.namedChildren.find((child) => child.type === 'package_header');
+    return header?.text.replace(/^package\s+/, '').trim() ?? '';
+}
+function qualify(packageNameValue, simpleName) {
+    return packageNameValue.length === 0 ? simpleName : `${packageNameValue}.${simpleName}`;
+}
+function standardFacadeName(filePath) {
+    const stem = path.basename(filePath).replace(/\.(?:kt|kts)$/i, '');
+    return `${stem.charAt(0).toUpperCase()}${stem.slice(1)}Kt`;
+}
+function jvmNameIdentifiers(imports, allowUnqualified) {
+    const names = new Set(['kotlin.jvm.JvmName']);
+    if (allowUnqualified)
+        names.add('JvmName');
+    for (const parsedImport of imports) {
+        if (parsedImport.kind !== 'named' && parsedImport.kind !== 'alias')
+            continue;
+        if (parsedImport.importedName !== 'JvmName')
+            continue;
+        const target = parsedImport.targetRaw.replace(/\\/g, '/');
+        if (target === 'kotlin.jvm' || target === 'kotlin.jvm.JvmName') {
+            names.add(parsedImport.localName);
+        }
+    }
+    return [...names];
+}
+function annotationJvmName(source, target = '', imports = [], allowUnqualified = true) {
+    const names = jvmNameIdentifiers(imports, allowUnqualified);
+    if (names.length === 0)
+        return undefined;
+    const escapedTarget = target.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const prefix = target.length === 0 ? '' : `${escapedTarget}:`;
+    const namePattern = [...names]
+        .map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+        .join('|');
+    return new RegExp(`@${prefix}(?:${namePattern})\\s*\\(\\s*["']([^"']+)["']\\s*\\)`).exec(source)?.[1];
+}
+function fileFacadeMetadata(root, imports, allowUnqualified) {
+    const cached = fileFacadeMetadataCache.get(root);
+    if (cached !== undefined)
+        return cached;
+    const metadata = {
+        packageName: packageName(root),
+        customFacade: annotationJvmName(root.text, 'file', imports, allowUnqualified),
+    };
+    fileFacadeMetadataCache.set(root, metadata);
+    return metadata;
+}
+function hasEnclosingType(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.type === 'class_declaration' ||
+            current.type === 'object_declaration' ||
+            current.type === 'companion_object') {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+/** Transient graph metadata used only by the same analysis run's runtime import. */
+export function extractKotlinRuntimeSymbolProperties(context) {
+    const properties = {};
+    const source = context.definitionNode.text;
+    const root = rootNode(context.definitionNode);
+    const allowUnqualifiedJvmName = !/\bannotation\s+class\s+JvmName\b/.test(root.text);
+    if ((context.nodeLabel === 'Function' || context.nodeLabel === 'Method') &&
+        context.definitionNode.type === 'function_declaration') {
+        if (/\bsuspend\b/.test(source.slice(0, source.indexOf('fun') + 3))) {
+            properties[KOTLIN_SUSPEND] = true;
+        }
+        const callableJvmName = annotationJvmName(source, '', context.parsedImports, allowUnqualifiedJvmName);
+        if (callableJvmName !== undefined) {
+            properties[RUNTIME_CALLABLE_ALIASES] = [callableJvmName];
+        }
+        if (!hasEnclosingType(context.definitionNode)) {
+            const facade = fileFacadeMetadata(root, context.parsedImports, allowUnqualifiedJvmName);
+            properties[RUNTIME_OWNER_ALIASES] = [
+                qualify(facade.packageName, facade.customFacade ?? standardFacadeName(context.filePath)),
+            ];
+        }
+    }
+    else if (context.nodeLabel === 'Property') {
+        const getterJvmName = annotationJvmName(source, 'get', context.parsedImports, allowUnqualifiedJvmName);
+        if (getterJvmName !== undefined) {
+            properties[RUNTIME_CALLABLE_ALIASES] = [getterJvmName];
+        }
+        if (!hasEnclosingType(context.definitionNode)) {
+            const facade = fileFacadeMetadata(root, context.parsedImports, allowUnqualifiedJvmName);
+            properties[RUNTIME_OWNER_ALIASES] = [
+                qualify(facade.packageName, facade.customFacade ?? standardFacadeName(context.filePath)),
+            ];
+        }
+    }
+    return Object.keys(properties).length === 0 ? undefined : properties;
+}
+function stringArrayProperty(node, property) {
+    const value = node.properties[property];
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === 'string')
+        : [];
+}
+function callableNames(node) {
+    return [String(node.properties.name), ...stringArrayProperty(node, RUNTIME_CALLABLE_ALIASES)];
+}
+function propertyGetterNames(node) {
+    const name = String(node.properties.name);
+    const capitalized = `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+    return [
+        name.startsWith('is') && name.length > 2 && /[A-Z]/.test(name.charAt(2))
+            ? name
+            : `get${capitalized}`,
+        ...stringArrayProperty(node, RUNTIME_CALLABLE_ALIASES),
+    ];
+}
+function sourceCallableName(runtimeName) {
+    return runtimeName.endsWith('$default') ? runtimeName.slice(0, -'$default'.length) : runtimeName;
+}
+function matchesKotlinCallable(node, runtime) {
+    // Kotlin property declarations and their synthesized JVM accessor Methods
+    // coexist in the graph. Bind runtime getters to the source Property so the
+    // synthetic accessor cannot turn an otherwise exact match into ambiguity.
+    if (node.properties.synthetic === 'kotlin-jvm')
+        return false;
+    const runtimeName = sourceCallableName(runtime.name);
+    if (node.label === 'Property') {
+        const names = propertyGetterNames(node);
+        if (!names.includes(runtime.name) && !names.includes(runtimeName))
+            return false;
+    }
+    else if (!callableNames(node).includes(runtimeName)) {
+        return false;
+    }
+    const parameterCount = node.properties.parameterCount;
+    const descriptorTypes = runtime.descriptorParameterTypes;
+    if (typeof parameterCount !== 'number' ||
+        descriptorTypes === undefined ||
+        runtime.name.endsWith('$default')) {
+        return true;
+    }
+    if (parameterCount === descriptorTypes.length)
+        return true;
+    return (node.properties[KOTLIN_SUSPEND] === true &&
+        parameterCount + 1 === descriptorTypes.length &&
+        descriptorTypes.at(-1) === 'kotlin/coroutines/Continuation');
+}
+export const kotlinRuntimeSymbolStrategy = {
+    callableOwnerAliases(node, owner) {
+        const aliases = [...stringArrayProperty(node, RUNTIME_OWNER_ALIASES)];
+        const ownerName = owner?.properties.qualifiedName;
+        if (typeof ownerName === 'string') {
+            aliases.push(ownerName);
+            if (node.properties.isStatic === true && !ownerName.endsWith('.Companion')) {
+                aliases.push(`${ownerName}.Companion`);
+            }
+        }
+        return aliases;
+    },
+    matchesCallable: matchesKotlinCallable,
+};

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

@@ -0,0 +1,18 @@
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import { type ParsedFile, type ScopeId } from '../../../../_shared/index.js';
+import { type SpringConfigConsumer } from '../../frameworks/spring/config-bindings.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+export interface KotlinSpringConfigConsumerFact {
+    readonly consumer: SpringConfigConsumer;
+    readonly annotationName: string;
+    readonly classScopeId: ScopeId;
+}
+/** Collect config facts from the Kotlin parser's existing AST (no reparse). */
+export declare function captureKotlinSpringConfigConsumerFacts(root: SyntaxNode, filePath: string): KotlinSpringConfigConsumerFact[];
+/** Parse Kotlin consumers for focused unit tests; production reuses the worker AST. */
+export declare function extractKotlinSpringConfigConsumers(source: string): SpringConfigConsumer[];
+export declare function extractKotlinSpringConfigConsumerFacts(source: string): KotlinSpringConfigConsumerFact[];
+/** Kotlin ScopeResolver post-resolution hook for Spring configuration consumers. */
+export declare function attachKotlinSpringConfigBindings(graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], _nodeLookup: GraphNodeLookup, indexes: ScopeResolutionIndexes): void;

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

@@ -0,0 +1,411 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { bindSpringConfigConsumers, } from '../../frameworks/spring/config-bindings.js';
+import { createSpringAnnotationNameResolver } from '../../frameworks/spring/bean-candidates.js';
+import { parseSpringAnnotationArguments, parseStaticStringLiteral, } from '../../frameworks/spring/annotation-arguments.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { getKotlinParser } from './query.js';
+import { getKotlinSpringConfigConsumerFacts } from './capture-side-channel.js';
+import { isKotlinPackageSiblingVisibilityIncomplete } from './package-siblings.js';
+const VALUE_ANNOTATION = 'org.springframework.beans.factory.annotation.Value';
+const CONFIGURATION_PROPERTIES_ANNOTATION = 'org.springframework.boot.context.properties.ConfigurationProperties';
+const VALUE_SIMPLE = 'Value';
+const CONFIGURATION_PROPERTIES_SIMPLE = 'ConfigurationProperties';
+const SKIP_USE_SITES = new Set(['get', 'property', 'file']);
+const BIND_USE_SITES = new Set(['field', 'set', 'param']);
+const OWNER_TYPES = new Set(['class_declaration', 'object_declaration', 'companion_object']);
+const INTERPOLATION_TYPES = new Set([
+    'interpolated_identifier',
+    'interpolated_expression',
+    'interpolation_expression_start',
+]);
+const STRING_LITERAL_TYPES = new Set(['string_literal', 'character_literal']);
+function firstDescendantOfType(node, type) {
+    const stack = [...node.namedChildren].reverse();
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+            continue;
+        if (current.type === type)
+            return current;
+        for (let index = current.namedChildren.length - 1; index >= 0; index--) {
+            const child = current.namedChildren[index];
+            if (child !== undefined)
+                stack.push(child);
+        }
+    }
+    return undefined;
+}
+function ownerName(declaration) {
+    if (declaration.type === 'companion_object') {
+        const named = declaration.namedChildren.find((child) => child.type === 'type_identifier');
+        return named?.text.trim() || 'Companion';
+    }
+    return (declaration.namedChildren.find((child) => child.type === 'type_identifier')?.text.trim() ??
+        declaration.namedChildren.find((child) => child.type === 'simple_identifier')?.text.trim());
+}
+function enclosingOwner(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (OWNER_TYPES.has(current.type))
+            return current;
+        current = current.parent;
+    }
+    return undefined;
+}
+function classScopeId(filePath, declaration) {
+    return makeScopeId({
+        filePath,
+        range: nodeToCapture('@scope.class', declaration).range,
+        kind: 'Class',
+    });
+}
+function collectKotlinImports(root) {
+    const exact = new Map();
+    const wildcard = new Set();
+    const localTypes = new Map();
+    for (const header of root.descendantsOfType('import_header')) {
+        const text = header.text.replace(/^import\s+/, '').trim();
+        const aliasMatch = text.match(/^([\w.]+)\s+as\s+(\w+)\s*$/);
+        if (aliasMatch !== null) {
+            exact.set(aliasMatch[2], aliasMatch[1]);
+            continue;
+        }
+        if (text.endsWith('.*'))
+            wildcard.add(text.slice(0, -2));
+        else {
+            const simple = text.slice(text.lastIndexOf('.') + 1);
+            if (simple.length > 0)
+                exact.set(simple, text);
+        }
+    }
+    for (const type of ['class_declaration', 'object_declaration']) {
+        for (const declaration of root.descendantsOfType(type)) {
+            const name = ownerName(declaration);
+            if (name) {
+                const declarations = localTypes.get(name) ?? [];
+                declarations.push(declaration);
+                localTypes.set(name, declarations);
+            }
+        }
+    }
+    return { exact, wildcard, localTypes };
+}
+function annotationFromNode(annotation) {
+    const nameNode = firstDescendantOfType(annotation, 'user_type') ??
+        firstDescendantOfType(annotation, 'type_identifier') ??
+        firstDescendantOfType(annotation, 'simple_identifier');
+    if (nameNode === undefined)
+        return null;
+    const useSiteTarget = annotation.namedChildren
+        .find((child) => child.type === 'use_site_target')
+        ?.text.replace(/:\s*$/, '')
+        .trim();
+    return {
+        name: nameNode.text.trim(),
+        node: annotation,
+        ...(useSiteTarget === undefined || useSiteTarget.length === 0 ? {} : { useSiteTarget }),
+    };
+}
+function annotationsOn(node) {
+    const annotations = [];
+    for (const child of node.namedChildren) {
+        if (child.type === 'annotation') {
+            const fact = annotationFromNode(child);
+            if (fact !== null)
+                annotations.push(fact);
+            continue;
+        }
+        if (child.type !== 'modifiers' && child.type !== 'parameter_modifiers')
+            continue;
+        for (const nested of child.namedChildren) {
+            if (nested.type !== 'annotation')
+                continue;
+            const fact = annotationFromNode(nested);
+            if (fact !== null)
+                annotations.push(fact);
+        }
+    }
+    return annotations;
+}
+function simpleName(rawName) {
+    const parts = rawName.split('.');
+    return parts[parts.length - 1] ?? rawName;
+}
+function importedAs(imports, simple, fqn, wildcardPackage) {
+    if (imports.exact.get(simple) === fqn)
+        return true;
+    // An explicit import wins over a star import in Kotlin, so a conflicting
+    // binding for the same simple name rules the Spring annotation out even when
+    // its package is wildcard-imported.
+    return imports.exact.get(simple) === undefined && imports.wildcard.has(wildcardPackage);
+}
+function hasVisibleLocalType(imports, simple, annotation) {
+    for (const declaration of imports.localTypes.get(simple) ?? []) {
+        const declarationOwner = enclosingOwner(declaration);
+        if (declarationOwner === undefined)
+            return true;
+        let current = annotation;
+        while (current !== null) {
+            if (current.id === declarationOwner.id)
+                return true;
+            current = current.parent;
+        }
+    }
+    return false;
+}
+const SIMPLE_CONFIG_ANNOTATIONS = [
+    {
+        simple: VALUE_SIMPLE,
+        kind: 'value',
+        fqn: VALUE_ANNOTATION,
+        wildcardPackage: 'org.springframework.beans.factory.annotation',
+    },
+    {
+        simple: CONFIGURATION_PROPERTIES_SIMPLE,
+        kind: 'configuration-properties',
+        fqn: CONFIGURATION_PROPERTIES_ANNOTATION,
+        wildcardPackage: 'org.springframework.boot.context.properties',
+    },
+];
+function configAnnotationKind(annotation, imports) {
+    const rawName = annotation.name;
+    if (rawName === VALUE_ANNOTATION)
+        return 'value';
+    if (rawName === CONFIGURATION_PROPERTIES_ANNOTATION)
+        return 'configuration-properties';
+    const simple = simpleName(rawName);
+    const aliased = imports.exact.get(simple);
+    if (aliased === VALUE_ANNOTATION)
+        return 'value';
+    if (aliased === CONFIGURATION_PROPERTIES_ANNOTATION)
+        return 'configuration-properties';
+    for (const candidate of SIMPLE_CONFIG_ANNOTATIONS) {
+        if (simple !== candidate.simple)
+            continue;
+        if (hasVisibleLocalType(imports, simple, annotation.node) && !imports.exact.has(simple)) {
+            return null;
+        }
+        return importedAs(imports, simple, candidate.fqn, candidate.wildcardPackage)
+            ? candidate.kind
+            : null;
+    }
+    return null;
+}
+function hasInterpolation(annotation) {
+    const stack = [...annotation.namedChildren];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+            continue;
+        if (INTERPOLATION_TYPES.has(current.type))
+            return true;
+        stack.push(...current.namedChildren);
+    }
+    return false;
+}
+function decodeKotlinStringLiteral(literal) {
+    const raw = literal.startsWith('"""') && literal.endsWith('"""');
+    const delimiterLength = raw ? 3 : 1;
+    if (literal.length < delimiterLength * 2)
+        return null;
+    const body = literal.slice(delimiterLength, -delimiterLength);
+    if (!raw && /(?<!\\)\$\{/.test(body))
+        return null;
+    if (raw)
+        return body;
+    return body
+        .replace(/\\u([0-9a-fA-F]{4})/g, (_match, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
+        .replace(/\\(["'\\$btnfr])/g, (_match, escaped) => {
+        const controls = {
+            b: '\b',
+            t: '\t',
+            n: '\n',
+            f: '\f',
+            r: '\r',
+            $: '$',
+        };
+        return controls[escaped] ?? escaped;
+    });
+}
+function kotlinStringLiterals(annotation) {
+    const literals = [];
+    const stack = [...annotation.namedChildren];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+            continue;
+        if (STRING_LITERAL_TYPES.has(current.type)) {
+            const decoded = decodeKotlinStringLiteral(current.text);
+            if (decoded !== null)
+                literals.push(decoded);
+            continue;
+        }
+        stack.push(...current.namedChildren);
+    }
+    return literals;
+}
+function parseValuePlaceholderKeys(annotation) {
+    if (hasInterpolation(annotation))
+        return [];
+    const keys = new Set();
+    for (const literal of kotlinStringLiterals(annotation)) {
+        for (const match of literal.matchAll(/\$\{([^{}]+)\}/g)) {
+            const key = match[1].split(':', 1)[0].trim();
+            if (/^[A-Za-z0-9_.-]+$/.test(key))
+                keys.add(key);
+        }
+    }
+    return [...keys];
+}
+function parseConfigurationPropertiesPrefix(annotation) {
+    if (hasInterpolation(annotation))
+        return null;
+    const argumentsList = parseSpringAnnotationArguments(annotation.text);
+    if (argumentsList !== null) {
+        const named = argumentsList.filter((argument) => argument.name === 'prefix' || argument.name === 'value');
+        const positional = argumentsList.filter((argument) => argument.name === undefined);
+        const chosen = named.length === 1 ? named[0] : named.length === 0 ? positional[0] : undefined;
+        if (chosen !== undefined) {
+            const decoded = parseStaticStringLiteral(chosen.value);
+            if (decoded === null)
+                return null;
+            const prefix = decoded.replace(/^\.+|\.+$/g, '');
+            if (/^[A-Za-z0-9_.-]+$/.test(prefix))
+                return prefix;
+            return null;
+        }
+        if (argumentsList.length > 0)
+            return null;
+    }
+    const literals = kotlinStringLiterals(annotation);
+    if (literals.length !== 1)
+        return null;
+    const prefix = literals[0].trim().replace(/^\.+|\.+$/g, '');
+    return /^[A-Za-z0-9_.-]+$/.test(prefix) ? prefix : null;
+}
+function allowedUseSite(useSiteTarget) {
+    if (useSiteTarget === undefined)
+        return true;
+    if (SKIP_USE_SITES.has(useSiteTarget))
+        return false;
+    return BIND_USE_SITES.has(useSiteTarget);
+}
+function hasBindingPattern(parameter) {
+    return parameter.namedChildren.some((child) => child.type === 'binding_pattern_kind');
+}
+function propertyName(node) {
+    if (node.type === 'class_parameter') {
+        return node.namedChildren.find((child) => child.type === 'simple_identifier')?.text.trim();
+    }
+    const variable = node.namedChildren.find((child) => child.type === 'variable_declaration');
+    return variable?.namedChildren.find((child) => child.type === 'simple_identifier')?.text.trim();
+}
+function underFileAnnotation(node) {
+    let current = node;
+    while (current !== null) {
+        if (current.type === 'file_annotation')
+            return true;
+        current = current.parent;
+    }
+    return false;
+}
+function pushValueFacts(facts, member, filePath, imports) {
+    if (underFileAnnotation(member))
+        return;
+    const owner = enclosingOwner(member);
+    if (owner === undefined)
+        return;
+    const fieldName = propertyName(member);
+    if (fieldName === undefined)
+        return;
+    for (const annotation of annotationsOn(member)) {
+        if (!allowedUseSite(annotation.useSiteTarget))
+            continue;
+        if (configAnnotationKind(annotation, imports) !== 'value')
+            continue;
+        const keys = parseValuePlaceholderKeys(annotation.node);
+        if (keys.length === 0)
+            continue;
+        facts.push({
+            consumer: {
+                kind: 'value',
+                fieldName,
+                line: member.startPosition.row + 1,
+                keys,
+            },
+            annotationName: annotation.name,
+            classScopeId: classScopeId(filePath, owner),
+        });
+    }
+}
+/** Collect config facts from the Kotlin parser's existing AST (no reparse). */
+export function captureKotlinSpringConfigConsumerFacts(root, filePath) {
+    const imports = collectKotlinImports(root);
+    const facts = [];
+    for (const property of root.descendantsOfType('property_declaration')) {
+        pushValueFacts(facts, property, filePath, imports);
+    }
+    for (const parameter of root.descendantsOfType('class_parameter')) {
+        if (!hasBindingPattern(parameter))
+            continue;
+        pushValueFacts(facts, parameter, filePath, imports);
+    }
+    for (const type of ['class_declaration', 'object_declaration']) {
+        for (const declaration of root.descendantsOfType(type)) {
+            const className = ownerName(declaration);
+            if (className === undefined)
+                continue;
+            for (const annotation of annotationsOn(declaration)) {
+                if (configAnnotationKind(annotation, imports) !== 'configuration-properties') {
+                    continue;
+                }
+                const prefix = parseConfigurationPropertiesPrefix(annotation.node);
+                if (prefix === null)
+                    continue;
+                facts.push({
+                    consumer: {
+                        kind: 'configuration-properties',
+                        className,
+                        line: declaration.startPosition.row + 1,
+                        prefix,
+                    },
+                    annotationName: annotation.name,
+                    classScopeId: classScopeId(filePath, declaration),
+                });
+            }
+        }
+    }
+    return facts;
+}
+/** Parse Kotlin consumers for focused unit tests; production reuses the worker AST. */
+export function extractKotlinSpringConfigConsumers(source) {
+    const tree = parseSourceSafe(getKotlinParser(), source);
+    return captureKotlinSpringConfigConsumerFacts(tree.rootNode, '<memory>').map((fact) => fact.consumer);
+}
+export function extractKotlinSpringConfigConsumerFacts(source) {
+    const tree = parseSourceSafe(getKotlinParser(), source);
+    return captureKotlinSpringConfigConsumerFacts(tree.rootNode, '<memory>');
+}
+/** Kotlin ScopeResolver post-resolution hook for Spring configuration consumers. */
+export function attachKotlinSpringConfigBindings(graph, parsedFiles, _nodeLookup, indexes) {
+    const resolveAnnotation = createSpringAnnotationNameResolver(indexes);
+    const recognizedAnnotations = new Set([VALUE_ANNOTATION, CONFIGURATION_PROPERTIES_ANNOTATION]);
+    const batches = [];
+    for (const parsed of parsedFiles) {
+        const consumers = [];
+        for (const fact of getKotlinSpringConfigConsumerFacts(parsed.filePath)) {
+            const classScope = indexes.scopeTree.getScope(fact.classScopeId);
+            if (classScope === undefined || classScope.kind !== 'Class')
+                continue;
+            const expectedAnnotation = fact.consumer.kind === 'value' ? VALUE_ANNOTATION : CONFIGURATION_PROPERTIES_ANNOTATION;
+            const enclosingScope = fact.consumer.kind === 'value' ? classScope.id : classScope.parent;
+            const resolved = resolveAnnotation(fact.annotationName, parsed, enclosingScope, recognizedAnnotations, isKotlinPackageSiblingVisibilityIncomplete(parsed.filePath));
+            if (resolved === expectedAnnotation)
+                consumers.push(fact.consumer);
+        }
+        if (consumers.length > 0)
+            batches.push({ filePath: parsed.filePath, consumers });
+    }
+    bindSpringConfigConsumers(graph, batches);
+}

package/dist/core/ingestion/languages/kotlin/spring-di.d.ts

@@ -1,14 +1,64 @@
+import { type SpringArgumentFact } from '../../frameworks/spring/argument-facts.js';
 import { type SpringDiAnnotationFact, type SpringDiClassFact, type SpringDiDependencyFact, type SpringDiInjectionSiteFact } from '../../frameworks/spring/di-metadata.js';
 import { type SyntaxNode } from '../../utils/ast-helpers.js';
 export interface KotlinAnnotationSyntaxFact extends SpringDiAnnotationFact {
     readonly useSiteTarget?: string;
     readonly line: number;
+    /** Present only for callers that opt in via `kotlinSpringAnnotationFacts`. */
+    readonly args?: readonly SpringArgumentFact[];
+}
+/**
+ * Options for `kotlinSpringAnnotationFacts`.
+ *
+ * The STRUCTURED arguments are opt-in because DI captures every annotated
+ * constructor parameter, property, and function in the repository, and none of
+ * its consumers reads them. Note what this does and does not save: every fact
+ * already carries `text`, the annotation's full source, so the argument TEXT
+ * crosses the worker boundary either way. What the opt-in avoids is a second,
+ * parsed copy of that same text on facts that would never look at it.
+ */
+export interface KotlinSpringAnnotationFactOptions {
+    readonly includeArguments?: boolean;
 }
 export type KotlinSpringDependencyFact = SpringDiDependencyFact<KotlinAnnotationSyntaxFact>;
 type KotlinSpringInjectionSiteKind = 'property' | 'constructor' | 'method';
 export type KotlinSpringInjectionSiteFact = SpringDiInjectionSiteFact<KotlinAnnotationSyntaxFact, KotlinSpringInjectionSiteKind>;
 export type KotlinSpringDiClassFact = SpringDiClassFact<KotlinAnnotationSyntaxFact, KotlinSpringInjectionSiteKind>;
-export declare function kotlinSpringAnnotationFacts(node: SyntaxNode): KotlinAnnotationSyntaxFact[];
+/**
+ * Kotlin writes annotation arguments and call arguments with the same
+ * `value_arguments` node, so one reader serves `@KafkaListener(topics = [...])`
+ * and `kafkaTemplate.send(topic, payload)`.
+ *
+ * A named argument keeps its key; everything else — positional values, spreads,
+ * collection literals, and interpolated strings — is kept as raw text, because
+ * evaluating it would be resolution.
+ *
+ * Returns `null` for a list tree-sitter had to recover, and the callers decide
+ * what that means: a producer call drops the whole fact, since it has no state
+ * for "published somewhere unreadable", while an annotation reports no
+ * arguments and collapses into the marker form. Both answers say "nothing here
+ * to resolve", which is true; a fabricated value would send a consumer
+ * somewhere real and wrong.
+ *
+ * The check lives HERE, not only in the callers. This function is exported and
+ * already has a caller in another module, so a guard that every future caller
+ * has to remember is the same fragility this change set exists to remove —
+ * `null` makes the decision unavoidable at the type level. Per-argument
+ * re-checks are still pointless: `hasError` propagates from any argument up to
+ * the list, so a branch behind this one could never fire.
+ *
+ * A named argument is identified by the `=` TOKEN, and the two-child shape is
+ * only a corroborating detail. Today nothing well formed reaches two children
+ * without an `=`: an annotated positional argument such as
+ * `@Suppress("UNCHECKED_CAST") "orders"` arrives as ONE `prefix_expression`, not
+ * as two children, so the token test is currently redundant. It is kept as the
+ * leading condition anyway, because the failure it prevents is asymmetric —
+ * dropping it would let any future two-child positional shape be reported under
+ * an argument key the source never wrote, which is the failure mode this whole
+ * change set is about.
+ */
+export declare function kotlinValueArgumentFacts(valueArguments: SyntaxNode): SpringArgumentFact[] | null;
+export declare function kotlinSpringAnnotationFacts(node: SyntaxNode, options?: KotlinSpringAnnotationFactOptions): KotlinAnnotationSyntaxFact[];
 /**
  * Capture one class already surfaced by Kotlin's scope query. Kotlin-specific
  * syntax is normalized here while import/FQN semantics remain deferred until