gitnexus 1.6.11-rc.8 → 1.6.11

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

@@ -1,8 +1,9 @@
 import { makeScopeId } from '../../../../_shared/index.js';
 import { parseSpringInjectionType } from '../../di-extractors/spring.js';
+import { normalizeSpringFactText, } from '../../frameworks/spring/argument-facts.js';
 import { createSpringDiMetadataAttacher, hasSpringDiRelevantAnnotation, hasSpringStereotypeSyntax, } from '../../frameworks/spring/di-metadata.js';
 import { hasSpringBeanFactorySyntax, } from '../../frameworks/spring/bean-factories.js';
-import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { hasRecoveredSyntax, nodeToCapture } from '../../utils/ast-helpers.js';
 import { getKotlinSpringDiFacts } from './capture-side-channel.js';
 import { isKotlinPackageSiblingVisibilityIncomplete } from './package-siblings.js';
 const KOTLIN_TYPE_NODES = new Set(['user_type', 'nullable_type', 'function_type']);
@@ -22,7 +23,84 @@ function firstDescendantOfType(node, type) {
     }
     return undefined;
 }
-function annotationFact(annotation) {
+const KOTLIN_COMMENT_NODE_TYPES = new Set(['line_comment', 'multiline_comment']);
+/**
+ * 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 function kotlinValueArgumentFacts(valueArguments) {
+    if (hasRecoveredSyntax(valueArguments))
+        return null;
+    const args = [];
+    for (const argument of valueArguments.namedChildren) {
+        if (argument.type !== 'value_argument')
+            continue;
+        const parts = argument.namedChildren.filter((child) => !KOTLIN_COMMENT_NODE_TYPES.has(child.type));
+        const named = argument.children.some((child) => child.type === '=');
+        const name = parts[0];
+        const value = parts[1];
+        if (named && parts.length === 2 && name !== undefined && value !== undefined) {
+            args.push({ name: name.text.trim(), text: normalizeSpringFactText(value.text) });
+            continue;
+        }
+        args.push({ text: normalizeSpringFactText(argument.text) });
+    }
+    return args;
+}
+/**
+ * Arguments of one annotation, or `undefined` when it was written without an
+ * argument list (`@Scheduled`); `@Scheduled()` yields `[]` instead.
+ *
+ * Only the annotation's FIRST `user_type` / `constructor_invocation` child is
+ * read, which is the same element `annotationFact` names. That matters for the
+ * multi-annotation form `@field:[Alpha Beta("x")]`, where naively taking the
+ * first constructor invocation would hand Beta's arguments to Alpha.
+ *
+ * An argument list that did not parse also yields `undefined`, collapsing into
+ * the marker-annotation case on purpose: both say there is nothing readable to
+ * resolve, while the recovered tree would offer values nobody wrote.
+ */
+function kotlinAnnotationArgumentFacts(annotation) {
+    const named = annotation.namedChildren.find((child) => child.type === 'user_type' || child.type === 'constructor_invocation');
+    if (named === undefined || named.type !== 'constructor_invocation')
+        return undefined;
+    const valueArguments = named.namedChildren.find((child) => child.type === 'value_arguments');
+    if (valueArguments === undefined)
+        return undefined;
+    // `null` here means recovered syntax; an annotation answers that by reporting
+    // no arguments at all, which is the marker-annotation form.
+    return kotlinValueArgumentFacts(valueArguments) ?? undefined;
+}
+function annotationFact(annotation, options) {
     const nameNode = firstDescendantOfType(annotation, 'user_type');
     if (nameNode === undefined)
         return null;
@@ -30,30 +108,32 @@ function annotationFact(annotation) {
         .find((child) => child.type === 'use_site_target')
         ?.text.replace(/:\s*$/, '')
         .trim();
+    const args = options.includeArguments === true ? kotlinAnnotationArgumentFacts(annotation) : undefined;
     return {
         name: nameNode.text.trim(),
         text: annotation.text.trim(),
         line: annotation.startPosition.row + 1,
         ...(useSiteTarget === undefined || useSiteTarget.length === 0 ? {} : { useSiteTarget }),
+        ...(args === undefined ? {} : { args }),
     };
 }
-function annotationsFromModifierContainer(node) {
+function annotationsFromModifierContainer(node, options = {}) {
     const facts = [];
     for (const child of node.namedChildren) {
         if (child.type !== 'annotation')
             continue;
-        const fact = annotationFact(child);
+        const fact = annotationFact(child, options);
         if (fact !== null)
             facts.push(fact);
     }
     return facts;
 }
-export function kotlinSpringAnnotationFacts(node) {
+export function kotlinSpringAnnotationFacts(node, options = {}) {
     const facts = [];
     for (const child of node.namedChildren) {
         if (child.type !== 'modifiers' && child.type !== 'parameter_modifiers')
             continue;
-        facts.push(...annotationsFromModifierContainer(child));
+        facts.push(...annotationsFromModifierContainer(child, options));
     }
     return facts;
 }

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

@@ -0,0 +1,8 @@
+import { type SpringDynamicLookupFact } from '../../frameworks/spring/dynamic-lookups.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+/** Capture real Kotlin calls using `Type::class` or `Type::class.java`. */
+export declare function captureKotlinSpringDynamicLookupFact(node: SyntaxNode, filePath: string): SpringDynamicLookupFact | null;
+/** Standalone extractor for focused tests; production reuses scope-query call nodes. */
+export declare function captureKotlinSpringDynamicLookupFacts(rootNode: SyntaxNode, filePath: string): SpringDynamicLookupFact[];
+/** Attach Kotlin lookup facts for later resolution by the shared DI phase. */
+export declare const attachKotlinSpringDynamicLookup: (graph: import("../../../graph/types.js").KnowledgeGraph, parsedFiles: readonly import('../../../../_shared/index.js').ParsedFile[], nodeLookup: import("../../scope-resolution/graph-bridge/node-lookup.js").GraphNodeLookup, indexes: import("../../model/scope-resolution-indexes.js").ScopeResolutionIndexes) => void;

package/dist/core/ingestion/languages/kotlin/spring-dynamic-lookup.js

@@ -0,0 +1,77 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { createSpringDynamicLookupMetadataAttacher, springDynamicLookupCardinality, } from '../../frameworks/spring/dynamic-lookups.js';
+import { findAncestorBeforeBoundary, nodeToCapture, } from '../../utils/ast-helpers.js';
+import { getKotlinSpringDynamicLookupFacts } from './capture-side-channel.js';
+// Kotlin emits graph callables for functions and secondary constructors.
+// `init {}` / primary-constructor bodies have no independent callable node, so
+// attributing their lookups to the enclosing Class would violate graph semantics.
+const CALLABLE_NODE_TYPES = new Set(['function_declaration', 'secondary_constructor']);
+const NO_CALLABLE_BOUNDARIES = new Set();
+const KOTLIN_CLASS_LITERAL = /^([A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*)::class(?:\.java)?$/;
+function navigationParts(node) {
+    if (node.type !== 'navigation_expression')
+        return null;
+    const text = node.text.trim();
+    const separator = text.lastIndexOf('.');
+    if (separator <= 0 || separator === text.length - 1)
+        return null;
+    return {
+        receiverName: text.slice(0, separator),
+        methodName: text.slice(separator + 1),
+    };
+}
+function singleClassLiteralArgument(node) {
+    const suffix = node.namedChildren.find((child) => child.type === 'call_suffix');
+    const argumentsNode = suffix?.namedChildren.find((child) => child.type === 'value_arguments');
+    if (argumentsNode === undefined)
+        return null;
+    const argumentsWithoutComments = argumentsNode.namedChildren.filter((child) => child.type !== 'line_comment' && child.type !== 'multiline_comment');
+    if (argumentsWithoutComments.length !== 1)
+        return null;
+    const value = argumentsWithoutComments[0];
+    if (value?.type !== 'value_argument' || value.namedChildCount !== 1)
+        return null;
+    return value.namedChild(0)?.text.trim().match(KOTLIN_CLASS_LITERAL)?.[1] ?? null;
+}
+/** Capture real Kotlin calls using `Type::class` or `Type::class.java`. */
+export function captureKotlinSpringDynamicLookupFact(node, filePath) {
+    if (node.type !== 'call_expression')
+        return null;
+    const callee = node.namedChildren.find((child) => child.type === 'navigation_expression');
+    if (callee === undefined)
+        return null;
+    const parts = navigationParts(callee);
+    if (parts === null)
+        return null;
+    if (springDynamicLookupCardinality(parts.receiverName, parts.methodName) === null)
+        return null;
+    const targetTypeName = singleClassLiteralArgument(node);
+    if (targetTypeName === null)
+        return null;
+    const owner = findAncestorBeforeBoundary(node, CALLABLE_NODE_TYPES, NO_CALLABLE_BOUNDARIES);
+    if (owner === null)
+        return null;
+    const ownerCapture = nodeToCapture('@spring-dynamic-lookup.owner', owner);
+    return {
+        ownerScopeId: makeScopeId({
+            filePath,
+            range: ownerCapture.range,
+            kind: 'Function',
+        }),
+        ownerRange: ownerCapture.range,
+        receiverName: parts.receiverName,
+        methodName: parts.methodName,
+        targetTypeName,
+    };
+}
+/** Standalone extractor for focused tests; production reuses scope-query call nodes. */
+export function captureKotlinSpringDynamicLookupFacts(rootNode, filePath) {
+    return rootNode
+        .descendantsOfType('call_expression')
+        .map((node) => captureKotlinSpringDynamicLookupFact(node, filePath))
+        .filter((fact) => fact !== null);
+}
+/** Attach Kotlin lookup facts for later resolution by the shared DI phase. */
+export const attachKotlinSpringDynamicLookup = createSpringDynamicLookupMetadataAttacher({
+    getFacts: getKotlinSpringDynamicLookupFacts,
+});

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

@@ -0,0 +1,17 @@
+import { type SpringMessageProducerFact } from '../../frameworks/spring/message-producers.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+/**
+ * Capture one messaging-template publish from a Kotlin call already surfaced by
+ * the scope query, without resolving the destination it names.
+ *
+ * The destination argument may be a literal, a reference to a constant that
+ * lives in another file, or a `${...}` placeholder resolved from configuration;
+ * all three are recorded as written and left to a later phase.
+ *
+ * A call whose argument list did not parse yields NO fact, for the reason given
+ * on the Java side: error recovery guesses argument boundaries, and this fact
+ * has no way to say "published somewhere unreadable".
+ */
+export declare function captureKotlinSpringMessageProducerFact(node: SyntaxNode, filePath: string): SpringMessageProducerFact | null;
+/** Standalone extractor for focused tests; production reuses scope-query call nodes. */
+export declare function captureKotlinSpringMessageProducerFacts(rootNode: SyntaxNode, filePath: string): SpringMessageProducerFact[];

package/dist/core/ingestion/languages/kotlin/spring-message-producers.js

@@ -0,0 +1,119 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { normalizeSpringFactText } from '../../frameworks/spring/argument-facts.js';
+import { isSpringMessageProducerMethod, springMessageProducerTemplateOf, } from '../../frameworks/spring/message-producers.js';
+import { findAncestorBeforeBoundary, nodeToCapture, } from '../../utils/ast-helpers.js';
+import { kotlinValueArgumentFacts } from './spring-di.js';
+// Kotlin emits graph callables for functions and secondary constructors.
+// `init {}` / primary-constructor bodies have no independent callable node, so
+// attributing their publishes to the enclosing Class would violate graph
+// semantics.
+const CALLABLE_NODE_TYPES = new Set(['function_declaration', 'secondary_constructor']);
+/**
+ * A class body ends the search, so the rule above holds at every depth.
+ *
+ * Without it the walk passes THROUGH the body of a class or object declared
+ * inside a function, and the publish in that body's property initializer — which
+ * likewise has no callable of its own — is attributed to the enclosing function
+ * instead of being dropped the way its top-level twin is.
+ */
+const TYPE_BODY_BOUNDARIES = new Set(['class_body', 'enum_class_body']);
+/**
+ * Strip null-assertion operators from a receiver.
+ *
+ * `?.` carries its marker on the navigation suffix, which the structural split
+ * already discards, but `!!` wraps the receiver in a `postfix_expression` whose
+ * text ends in the operator — enough to make `kafkaTemplate!!` fail the
+ * receiver-name check and lose a publish. Unwrapping is limited to `!!`
+ * because `counter++` produces the same node shape and is not a receiver name.
+ */
+function withoutNullAssertions(receiver) {
+    let current = receiver;
+    while (current.type === 'postfix_expression') {
+        const operand = current.namedChildren[0];
+        if (operand === undefined)
+            return current;
+        const onlyNullAssertions = current.children.every((child) => child.id === operand.id || child.type === '!!');
+        if (!onlyNullAssertions)
+            return current;
+        current = operand;
+    }
+    return current;
+}
+/**
+ * Split `receiver.method` structurally rather than by text.
+ *
+ * Text splitting would leave the safe-call marker on the receiver
+ * (`kafkaTemplate?` for `kafkaTemplate?.send(...)`).
+ */
+function navigationParts(callee) {
+    if (callee.type !== 'navigation_expression')
+        return null;
+    const suffix = callee.namedChildren.find((child) => child.type === 'navigation_suffix');
+    const receiver = callee.namedChildren.find((child) => child.type !== 'navigation_suffix');
+    if (suffix === undefined || receiver === undefined)
+        return null;
+    const methodName = suffix.namedChildren
+        .find((child) => child.type === 'simple_identifier')
+        ?.text.trim();
+    if (methodName === undefined)
+        return null;
+    return {
+        receiverName: normalizeSpringFactText(withoutNullAssertions(receiver).text),
+        methodName,
+    };
+}
+/**
+ * Capture one messaging-template publish from a Kotlin call already surfaced by
+ * the scope query, without resolving the destination it names.
+ *
+ * The destination argument may be a literal, a reference to a constant that
+ * lives in another file, or a `${...}` placeholder resolved from configuration;
+ * all three are recorded as written and left to a later phase.
+ *
+ * A call whose argument list did not parse yields NO fact, for the reason given
+ * on the Java side: error recovery guesses argument boundaries, and this fact
+ * has no way to say "published somewhere unreadable".
+ */
+export function captureKotlinSpringMessageProducerFact(node, filePath) {
+    if (node.type !== 'call_expression')
+        return null;
+    const callee = node.namedChildren[0];
+    if (callee === undefined)
+        return null;
+    const parts = navigationParts(callee);
+    if (parts === null || !isSpringMessageProducerMethod(parts.methodName))
+        return null;
+    const template = springMessageProducerTemplateOf(parts.receiverName, parts.methodName);
+    if (template === null)
+        return null;
+    const callSuffix = node.namedChildren.find((child) => child.type === 'call_suffix');
+    // A trailing-lambda call (`send { ... }`) has no argument list at all, which
+    // is a different fact from an empty one (`send()`).
+    const valueArguments = callSuffix?.namedChildren.find((child) => child.type === 'value_arguments');
+    // `null` from the reader means tree-sitter had to recover the list. A publish
+    // fact exists to carry a destination and has no state for "published
+    // somewhere unreadable", so the whole fact is withheld rather than reported
+    // with arguments the source never wrote.
+    const args = valueArguments === undefined ? undefined : kotlinValueArgumentFacts(valueArguments);
+    if (args === null)
+        return null;
+    const owner = findAncestorBeforeBoundary(node, CALLABLE_NODE_TYPES, TYPE_BODY_BOUNDARIES);
+    if (owner === null)
+        return null;
+    const ownerCapture = nodeToCapture('@spring-message-producer.owner', owner);
+    return {
+        ownerScopeId: makeScopeId({ filePath, range: ownerCapture.range, kind: 'Function' }),
+        ownerRange: ownerCapture.range,
+        template,
+        receiverName: parts.receiverName,
+        methodName: parts.methodName,
+        ...(args === undefined ? {} : { args }),
+    };
+}
+/** Standalone extractor for focused tests; production reuses scope-query call nodes. */
+export function captureKotlinSpringMessageProducerFacts(rootNode, filePath) {
+    return rootNode
+        .descendantsOfType('call_expression')
+        .map((node) => captureKotlinSpringMessageProducerFact(node, filePath))
+        .filter((fact) => fact !== null);
+}

package/dist/core/ingestion/languages/kotlin/spring-non-http-handlers.d.ts

@@ -5,6 +5,22 @@ export type KotlinSpringNonHttpHandlerFact = SpringNonHttpHandlerFact<SpringNonH
  * Capture annotated callables conservatively. A simple-name prefilter would
  * discard Kotlin aliases (for example, `EventListener as SpringEvent`) before
  * the post-import resolver can map the local name back to its annotation FQN.
+ *
+ * That conservatism applies to the CALLABLE — every annotated function still
+ * produces a fact, whatever its annotations are named. It does NOT have to
+ * apply to the arguments: reading them unconditionally charged every
+ * `@Transactional` and `@Deprecated` in a repository for data no consumer
+ * reads, and unlike the callable itself an argument list can be fetched on
+ * evidence. Arguments are therefore read in a second pass, for callables that
+ * either carry a handler annotation under its own name or use a local name this
+ * file aliased to one — the same two-pass shape as Java, with the alias set
+ * standing in for the name prefilter Kotlin cannot use.
+ *
+ * Measured on 200 annotated NON-handler functions in one file: the side-channel
+ * payload was 41069 bytes before arguments existed, 78797 with them read
+ * unconditionally, and 41069 again with this pass — byte for byte what it cost
+ * before the feature. The 200-handler equivalent pays 58649, which is the
+ * argument text the consumer asked for.
  */
 export declare function captureKotlinSpringNonHttpHandlerFacts(classNode: SyntaxNode, filePath: string): KotlinSpringNonHttpHandlerFact[];
 export declare const attachKotlinSpringNonHttpHandlerMetadata: (graph: import("../../../graph/types.js").KnowledgeGraph, parsedFiles: readonly import('../../../../_shared/index.js').ParsedFile[], nodeLookup: import("../../scope-resolution/graph-bridge/node-lookup.js").GraphNodeLookup, indexes: import("../../model/scope-resolution-indexes.js").ScopeResolutionIndexes) => void;

package/dist/core/ingestion/languages/kotlin/spring-non-http-handlers.js

@@ -1,23 +1,97 @@
 import { makeScopeId } from '../../../../_shared/index.js';
-import { createSpringNonHttpHandlerMetadataAttacher, } from '../../frameworks/spring/non-http-handlers.js';
+import { createSpringNonHttpHandlerMetadataAttacher, hasSpringNonHttpHandlerRelevantAnnotation, } from '../../frameworks/spring/non-http-handlers.js';
 import { nodeToCapture } from '../../utils/ast-helpers.js';
 import { getKotlinSpringNonHttpHandlerFacts } from './capture-side-channel.js';
 import { isKotlinPackageSiblingVisibilityIncomplete } from './package-siblings.js';
 import { kotlinSpringAnnotationFacts } from './spring-di.js';
+/**
+ * Local names that reach a handler annotation only through an import alias.
+ *
+ * `import ...event.EventListener as SpringEvent` makes `@SpringEvent` a handler
+ * annotation whose simple name matches nothing, which is why the CALLABLE
+ * capture below has no name prefilter. The alias is not a mystery at capture
+ * time, though: the import header states both the local name and the FQN it
+ * stands for, so the same relevance predicate that Java uses on the annotation
+ * name can be applied to the IMPORTED name and the answer carried back to the
+ * alias. That recovers a name-based decision without discarding aliases.
+ *
+ * Only aliases are collected. A plain or wildcard import leaves the annotation
+ * written under its own simple name, which the direct check already sees.
+ */
+function aliasedHandlerAnnotationNames(classNode) {
+    let root = classNode;
+    while (root.parent !== null)
+        root = root.parent;
+    const headers = [];
+    for (const child of root.namedChildren) {
+        if (child.type === 'import_header')
+            headers.push(child);
+        else if (child.type === 'import_list') {
+            for (const header of child.namedChildren) {
+                if (header.type === 'import_header')
+                    headers.push(header);
+            }
+        }
+    }
+    const aliases = new Set();
+    for (const header of headers) {
+        const alias = header.namedChildren
+            .find((child) => child.type === 'import_alias')
+            ?.namedChildren.find((child) => child.type === 'type_identifier')
+            ?.text.trim();
+        if (alias === undefined || alias.length === 0)
+            continue;
+        const imported = header.namedChildren.find((child) => child.type === 'identifier')?.text.trim();
+        if (imported === undefined || imported.length === 0)
+            continue;
+        if (hasSpringNonHttpHandlerRelevantAnnotation([{ name: imported }]))
+            aliases.add(alias);
+    }
+    return aliases;
+}
 /**
  * Capture annotated callables conservatively. A simple-name prefilter would
  * discard Kotlin aliases (for example, `EventListener as SpringEvent`) before
  * the post-import resolver can map the local name back to its annotation FQN.
+ *
+ * That conservatism applies to the CALLABLE — every annotated function still
+ * produces a fact, whatever its annotations are named. It does NOT have to
+ * apply to the arguments: reading them unconditionally charged every
+ * `@Transactional` and `@Deprecated` in a repository for data no consumer
+ * reads, and unlike the callable itself an argument list can be fetched on
+ * evidence. Arguments are therefore read in a second pass, for callables that
+ * either carry a handler annotation under its own name or use a local name this
+ * file aliased to one — the same two-pass shape as Java, with the alias set
+ * standing in for the name prefilter Kotlin cannot use.
+ *
+ * Measured on 200 annotated NON-handler functions in one file: the side-channel
+ * payload was 41069 bytes before arguments existed, 78797 with them read
+ * unconditionally, and 41069 again with this pass — byte for byte what it cost
+ * before the feature. The 200-handler equivalent pays 58649, which is the
+ * argument text the consumer asked for.
  */
 export function captureKotlinSpringNonHttpHandlerFacts(classNode, filePath) {
     const facts = [];
     const body = classNode.namedChildren.find((child) => child.type === 'class_body' || child.type === 'enum_class_body');
     if (body === undefined)
         return facts;
+    // Read the import headers at most once per class, and only when some callable
+    // actually fails the direct name check.
+    let aliasedHandlerNames;
     for (const member of body.namedChildren) {
         if (member.type !== 'function_declaration')
             continue;
-        const annotations = kotlinSpringAnnotationFacts(member);
+        const named = kotlinSpringAnnotationFacts(member);
+        if (named.length === 0)
+            continue;
+        let readArguments = hasSpringNonHttpHandlerRelevantAnnotation(named);
+        if (!readArguments) {
+            aliasedHandlerNames ??= aliasedHandlerAnnotationNames(classNode);
+            readArguments = named.some((annotation) => aliasedHandlerNames?.has(annotation.name) === true);
+        }
+        const annotations = readArguments
+            ? kotlinSpringAnnotationFacts(member, { includeArguments: true })
+            : named;
         if (annotations.length === 0)
             continue;
         const ownerRange = nodeToCapture('@spring-non-http-handler.owner', member).range;
@@ -30,6 +104,7 @@ export function captureKotlinSpringNonHttpHandlerFacts(classNode, filePath) {
                 ...(annotation.useSiteTarget === undefined
                     ? {}
                     : { useSiteTarget: annotation.useSiteTarget }),
+                ...(annotation.args === undefined ? {} : { args: annotation.args }),
             })),
         });
     }

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

@@ -21,6 +21,7 @@ import { KOTLIN_QUERIES } from '../tree-sitter-queries.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { kotlinCallConfig } from '../call-extractors/configs/jvm.js';
 import { createKotlinCfgVisitor } from '../cfg/visitors/kotlin.js';
+import { getKotlinSpringMessageProducerFacts, getKotlinSpringNonHttpHandlerFacts, } from './kotlin/capture-side-channel.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { kotlinConfig } from '../field-extractors/configs/jvm.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
@@ -28,6 +29,10 @@ import { kotlinMethodConfig } from '../method-extractors/configs/jvm.js';
 import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { kotlinVariableConfig } from '../variable-extractors/configs/jvm.js';
 import { collectKotlinCaptureSideChannel, emitKotlinScopeCaptures, interpretKotlinImport, interpretKotlinTypeBinding, kotlinArityCompatibility, kotlinBindingScopeFor, kotlinImportOwningScope, kotlinMergeBindings, kotlinReceiverBinding, } from './kotlin/index.js';
+import { synthesizeLombokAccessors } from './kotlin/lombok-synthesizer.js';
+import { extractKotlinRuntimeSymbolProperties, kotlinRuntimeSymbolStrategy, } from './kotlin/spring-actuator.js';
+import { extractKotlinSpringRoutes } from '../route-extractors/kotlin-spring.js';
+import { extractKotlinModuleConstants, foldKotlinOperands, } from '../route-extractors/kotlin-const-resolver.js';
 /** Check if a Kotlin function_declaration capture is inside a class_body (i.e., a method).
  *  Kotlin grammar uses function_declaration for both top-level functions and class methods.
  *  Returns true when the captured definition node has a class_body ancestor. */
@@ -156,6 +161,8 @@ export const kotlinProvider = defineLanguage({
     builtInNames: BUILT_INS,
     // ── KDoc → description (issue #2270) ──
     descriptionExtractor: createLeadingDocDescriptionExtractor(),
+    definitionPropertiesExtractor: extractKotlinRuntimeSymbolProperties,
+    runtimeSymbolStrategy: kotlinRuntimeSymbolStrategy,
     labelOverride: (functionNode, defaultLabel) => {
         if (defaultLabel !== 'Function')
             return defaultLabel;
@@ -183,4 +190,21 @@ export const kotlinProvider = defineLanguage({
     mergeBindings: (_scope, bindings) => kotlinMergeBindings(bindings),
     receiverBinding: kotlinReceiverBinding,
     arityCompatibility: kotlinArityCompatibility,
+    synthesizeStructureMembers: synthesizeLombokAccessors,
+    // ── Spring decorator routes + composed path constants (#3130) ──
+    extractDecoratorRoutes: extractKotlinSpringRoutes,
+    extractModuleConstants: extractKotlinModuleConstants,
+    foldRoutePathOperands: foldKotlinOperands,
+    // Async messaging facts for the `springDestinations` phase. Both stores are
+    // repopulated on the main thread by `applyKotlinCaptureSideChannel`, so this
+    // answers for cache hits and misses alike.
+    getSpringMessagingFacts: (filePath) => ({
+        handlers: getKotlinSpringNonHttpHandlerFacts(filePath),
+        producers: getKotlinSpringMessageProducerFacts(filePath),
+    }),
+    // Kotlin string literals interpolate: `"orders-$env"` and `"orders-${env}"`
+    // are string templates, and a Spring property placeholder has to escape the
+    // dollar (`"\${app.topic}"`). Destination resolution needs this to keep a
+    // runtime template out of the address namespace.
+    interpolatesStringLiterals: true,
 });

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

@@ -29,6 +29,7 @@ import { emitPythonScopeCaptures, pythonFunctionDefinitionLabel, interpretPython
 import { extractDjangoRoutes } from '../route-extractors/django.js';
 import { discoverDjangoRootUrls } from '../route-extractors/django-root-discovery.js';
 import { extractPythonModuleConstants } from '../route-extractors/python-const-resolver.js';
+import { pythonDecoratorRouteHandlerName } from '../route-extractors/python-decorator-handler.js';
 const BUILT_INS = new Set([
     'print',
     'len',
@@ -120,6 +121,7 @@ export const pythonProvider = defineLanguage({
     // and extraction resolve any repo-relative file regardless of parse chunking.
     discoverRootRouteFiles: (files, contentMap, reader) => discoverDjangoRootUrls(files, contentMap, reader),
     extractRoutes: (tree, filePath, reader, parser) => parser ? extractDjangoRoutes(tree, filePath, parser, reader) : [],
+    decoratorRouteHandlerName: pythonDecoratorRouteHandlerName,
     labelOverride: pythonFunctionDefinitionLabel,
     // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
     // Python is the first migration. See ./python/index.ts for the

package/dist/core/ingestion/languages/rust/query.js

@@ -35,14 +35,14 @@ const RUST_SCOPE_QUERY = `
   type_parameters: (type_parameters)? @declaration.type-parameters) @declaration.enum
 
 ;; Declarations — union
-;; Deliberately tagged @declaration.struct (→ Struct label), NOT a
-;; @declaration.union: every registry-primary resolution gate —
-;; isLinkableLabel (node-lookup.ts), CALLABLE_OR_TYPE_LIKE
-;; (finalize-algorithm.ts), ClassLikeNodeLabel (class-types.ts) — includes
-;; Struct but EXCLUDES Union, so a Union-labeled node would be an
-;; unresolvable orphan. A Rust union is a type whose literal is a real
-;; constructor, so Struct is both the resolvable and the semantically
-;; honest label here. #1934 F71.
+;; Tagged @declaration.struct (→ Struct label), NOT @declaration.union.
+;; Historically forced: the registry-primary gates (isLinkableLabel,
+;; CALLABLE_OR_TYPE_LIKE, ClassLikeNodeLabel) excluded Union, so a
+;; Union-labeled node was an unresolvable orphan (#1934 F71). Zig support
+;; widened all three for its union(enum) containers, so the label is now
+;; resolvable — Struct is kept here on the semantic argument alone (a Rust
+;; union is a type whose literal is a real constructor) and to leave the
+;; graph node ids of existing Rust indexes unchanged.
 (union_item
   name: (type_identifier) @declaration.name
   type_parameters: (type_parameters)? @declaration.type-parameters) @declaration.struct