gitnexus 1.6.11-rc.29 → 1.6.11-rc.30

package/dist/core/ingestion/frameworks/spring/argument-facts.d.ts

@@ -0,0 +1,80 @@
+/**
+ * One argument of a Spring annotation or of a messaging-template call, captured
+ * exactly as it is written in source.
+ *
+ * Capture-time facts are deliberately UNRESOLVED. When these facts are produced
+ * the file's imports are not finalized, constants declared in sibling files do
+ * not exist yet, and no configuration source has been read — so a captured
+ * `text` may be a string literal, a constant reference (`Destinations.ORDERS`),
+ * a property placeholder (`"${app.orders.topic}"`), or an arbitrary expression.
+ * Turning any of those into an address is a separate, later phase; nothing here
+ * may call a resolver.
+ *
+ * NOT the same thing as `SpringAnnotationArgument` in `annotation-arguments.ts`,
+ * and the two are deliberately not merged:
+ *
+ *  - Source. This fact is built from AST nodes while the tree is in hand;
+ *    `parseSpringAnnotationArguments` re-parses an annotation's `text` much
+ *    later, from a string, with a hand-written delimiter scanner.
+ *  - Failure. The text parser returns `null` when its scanner cannot balance
+ *    the input, and a caller must decide what that means. There is no such
+ *    state here: the grammar has already decided where each argument begins
+ *    and ends.
+ *  - Absence. The text parser answers `[]` both for `@Scheduled` and for
+ *    `@Scheduled()`, because a string cannot tell "no list" from "empty list"
+ *    without re-deriving it. Capture keeps the two apart — absent versus `[]` —
+ *    so downstream code can rely on the distinction wherever arguments were
+ *    read at all. A capture that reads them for only some of its facts says so
+ *    on its own `args` field.
+ *  - Scope. This fact also describes CALL arguments (`template.send(topic, p)`),
+ *    which the annotation parser has no notion of.
+ *
+ * Collapsing them would mean giving the text parser a failure mode it cannot
+ * produce, or taking the three-state distinction away from capture.
+ */
+export interface SpringArgumentFact {
+    /**
+     * Argument name for a named argument, absent for a positional one.
+     *
+     * Both forms occur, and where the destination sits differs by construct. An
+     * annotation names it (`@KafkaListener(topics = ...)` versus
+     * `@RabbitListener(queues = ...)`). A call normally gives it by position
+     * (`kafkaTemplate.send(topic, payload)`) — always so in Java, which has no
+     * named arguments — but a Kotlin call may name its arguments whenever the
+     * callee is itself declared in Kotlin, and then the key is captured too.
+     */
+    readonly name?: string;
+    /**
+     * Argument value in its source spelling — quotes, braces and casts intact,
+     * nothing resolved — after `normalizeSpringFactText`. That pass trims the
+     * text and collapses whitespace around the dots of a multi-line expression,
+     * so one destination written two ways yields one fact. It is the only
+     * rewrite; see the function for why formatting must not reach the data.
+     */
+    readonly text: string;
+}
+/**
+ * Join an expression that the source wrapped across lines, so that one
+ * expression has one spelling no matter where it was written.
+ *
+ * A receiver chain written as `outer\n    .inner\n    .kafkaTemplate`, and an
+ * argument written as `Destinations\n    .ORDERS`, are the same expressions as
+ * their single-line spellings. Raw node text would carry the newline and the
+ * ENCLOSING BLOCK's indentation across the worker boundary, so the same
+ * expression at two nesting depths — or in a CRLF checkout — would not compare
+ * equal downstream. Receivers and arguments get the identical treatment on
+ * purpose: an inconsistent rule inside one fact is a trap for the phase that
+ * has to match a publish against a subscription.
+ *
+ * Only a run of whitespace that CONTAINS A NEWLINE and sits next to a dot is
+ * removed, and only OUTSIDE a string literal. Single-line spacing is left
+ * alone, so `registry.get("a . b").template` keeps its argument exactly as
+ * written; literal-awareness extends that to Java text blocks and Kotlin raw
+ * strings, whose embedded newlines are part of the value and must survive
+ * (`"""line-a\n.line-b"""` is not the same string as `"""line-a.line-b"""`).
+ *
+ * Wraps that are not adjacent to a dot (`"a" +\n  "b"`) are left as written:
+ * normalizing them would have to reason about operators, and the same
+ * conservatism already applies to receivers.
+ */
+export declare function normalizeSpringFactText(text: string): string;

package/dist/core/ingestion/frameworks/spring/argument-facts.js

@@ -0,0 +1,85 @@
+/**
+ * Join an expression that the source wrapped across lines, so that one
+ * expression has one spelling no matter where it was written.
+ *
+ * A receiver chain written as `outer\n    .inner\n    .kafkaTemplate`, and an
+ * argument written as `Destinations\n    .ORDERS`, are the same expressions as
+ * their single-line spellings. Raw node text would carry the newline and the
+ * ENCLOSING BLOCK's indentation across the worker boundary, so the same
+ * expression at two nesting depths — or in a CRLF checkout — would not compare
+ * equal downstream. Receivers and arguments get the identical treatment on
+ * purpose: an inconsistent rule inside one fact is a trap for the phase that
+ * has to match a publish against a subscription.
+ *
+ * Only a run of whitespace that CONTAINS A NEWLINE and sits next to a dot is
+ * removed, and only OUTSIDE a string literal. Single-line spacing is left
+ * alone, so `registry.get("a . b").template` keeps its argument exactly as
+ * written; literal-awareness extends that to Java text blocks and Kotlin raw
+ * strings, whose embedded newlines are part of the value and must survive
+ * (`"""line-a\n.line-b"""` is not the same string as `"""line-a.line-b"""`).
+ *
+ * Wraps that are not adjacent to a dot (`"a" +\n  "b"`) are left as written:
+ * normalizing them would have to reason about operators, and the same
+ * conservatism already applies to receivers.
+ */
+export function normalizeSpringFactText(text) {
+    const trimmed = text.trim();
+    // Fast path: the overwhelming majority of captured text is single-line.
+    if (!trimmed.includes('\n') && !trimmed.includes('\r'))
+        return trimmed;
+    let out = '';
+    let index = 0;
+    let quote = null;
+    while (index < trimmed.length) {
+        const char = trimmed[index];
+        if (quote === '"""') {
+            if (trimmed.startsWith('"""', index)) {
+                out += '"""';
+                index += 3;
+                quote = null;
+                continue;
+            }
+            out += char;
+            index += 1;
+            continue;
+        }
+        if (quote !== null) {
+            // A backslash escape is copied whole so that `"\\"` ends the literal and
+            // `"\""` does not.
+            if (char === '\\' && index + 1 < trimmed.length) {
+                out += trimmed.slice(index, index + 2);
+                index += 2;
+                continue;
+            }
+            if (char === quote)
+                quote = null;
+            out += char;
+            index += 1;
+            continue;
+        }
+        if (trimmed.startsWith('"""', index)) {
+            quote = '"""';
+            out += '"""';
+            index += 3;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            out += char;
+            index += 1;
+            continue;
+        }
+        if (char === '.' || /\s/.test(char)) {
+            const separator = /^\s*\.\s*/.exec(trimmed.slice(index));
+            if (separator !== null) {
+                const matched = separator[0];
+                out += matched.includes('\n') ? '.' : matched;
+                index += matched.length;
+                continue;
+            }
+        }
+        out += char;
+        index += 1;
+    }
+    return out;
+}

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

@@ -0,0 +1,78 @@
+import type { Range, ScopeId } from '../../../../_shared/index.js';
+import type { SpringArgumentFact } from './argument-facts.js';
+/**
+ * Outbound side of Spring messaging: the template calls that publish to a
+ * broker destination, mirroring the inbound `@KafkaListener` / `@RabbitListener`
+ * family already recognized in `non-http-handlers.ts`.
+ *
+ * Recognition is purely syntactic and happens while the language's own scope
+ * query already has the call node in hand. The receiver's declared type is NOT
+ * consulted: at capture time the field may be inherited, injected from another
+ * file, or typed through an import that is not finalized yet. Matching on the
+ * receiver's simple name instead keeps the capture cheap and resolver-free; a
+ * later phase that owns type information can refine or discard a fact.
+ */
+export type SpringMessageProducerTemplate = 'kafka' | 'rabbit' | 'jms' | 'stream-bridge';
+/**
+ * Cheap pre-filter usable before any receiver text is materialized. Both
+ * languages visit every member call, so the common case must cost one set
+ * lookup on the method name.
+ */
+export declare function isSpringMessageProducerMethod(methodName: string): boolean;
+/**
+ * Classify a `receiver.method(...)` call as a messaging producer, or `null`.
+ *
+ * `receiverName` is the receiver expression as written; only its last
+ * dot-separated segment participates, so `this.kafkaTemplate` and
+ * `outer.inner.kafkaTemplate` match while `templates.get("k")` does not.
+ *
+ * The PLAIN_IDENTIFIER gate runs BEFORE the fold and is load-bearing, because
+ * the last-dot split is textual: in `config.get("a.kafkaTemplate")` it yields
+ * `kafkaTemplate")`, which folds to something a name match would accept. Only
+ * an identifier survives the gate, which is also what rejects `templates["k"]`,
+ * `getTemplate()`, and a receiver whose dot is separated by a comment.
+ *
+ * The folded segment then matches case-insensitively when it CONTAINS the
+ * template type name, so every convention a template bean is really declared
+ * with is recognized — decorated by prefix (`orderKafkaTemplate`), by suffix
+ * (`kafkaTemplateDlq`, `kafkaTemplateV2`, `rabbitTemplate1`), or written as a
+ * constant (`KAFKA_TEMPLATE`, `STREAM_BRIDGE`). A suffix-only rule accepted
+ * one of those and silently dropped the rest, which are exactly the publishes
+ * this capture exists to find. A receiver named only `template` still does not
+ * match: without type information that would attribute any `send` in the
+ * repository to Kafka.
+ *
+ * The bare type name (`KafkaTemplate.send(...)`) contains itself and so is
+ * accepted. That is left as it is: the match is by NAME, a name equal to the
+ * type is the strongest evidence the rule has, and a later phase that owns type
+ * information can discard a static-looking receiver.
+ *
+ * A substring rule also lets ONE receiver satisfy TWO signatures, which a
+ * suffix rule could not: `KafkaTemplate` and `StreamBridge` both publish
+ * through `send`, and `RabbitTemplate` and `JmsTemplate` both through
+ * `convertAndSend`, so `streamBridgeKafkaTemplate.send(...)` matches two
+ * templates at once. Such a receiver yields NO fact. Nothing here can break the
+ * tie honestly: the receiver's TYPE is deliberately not resolved, and the name
+ * is not ranked evidence — neither the longest match, nor the last one, nor the
+ * order of this list says whether that bean is a KafkaTemplate fronted by a
+ * stream binding or a StreamBridge named after the broker behind it. Returning
+ * the first match published an arbitrary choice as a definite broker
+ * attribution, the one outcome a consumer cannot tell from a fact. Silence
+ * costs a rare publish and stays recoverable by a phase that owns types.
+ */
+export declare function springMessageProducerTemplateOf(receiverName: string, methodName: string): SpringMessageProducerTemplate | null;
+export interface SpringMessageProducerFact {
+    /** Callable that performs the publish; the enclosing method or function. */
+    readonly ownerScopeId: ScopeId;
+    readonly ownerRange: Range;
+    readonly template: SpringMessageProducerTemplate;
+    /** Receiver expression as written, for example `this.orderKafkaTemplate`. */
+    readonly receiverName: string;
+    readonly methodName: string;
+    /**
+     * Call arguments in source order, or absent when the call site has no
+     * argument list at all (a Kotlin trailing-lambda call). An empty array means
+     * an empty argument list was written — a different fact from no list.
+     */
+    readonly args?: readonly SpringArgumentFact[];
+}

package/dist/core/ingestion/frameworks/spring/message-producers.js

@@ -0,0 +1,90 @@
+const PRODUCER_SIGNATURES = [
+    { template: 'kafka', typeName: 'KafkaTemplate', methodName: 'send' },
+    { template: 'rabbit', typeName: 'RabbitTemplate', methodName: 'convertAndSend' },
+    { template: 'jms', typeName: 'JmsTemplate', methodName: 'convertAndSend' },
+    { template: 'stream-bridge', typeName: 'StreamBridge', methodName: 'send' },
+];
+const PRODUCER_METHOD_NAMES = new Set(PRODUCER_SIGNATURES.map((signature) => signature.methodName));
+/** A receiver we can attribute; `templates["k"]` or `getTemplate()` cannot be. */
+const PLAIN_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+ * Fold a receiver's simple name to the form the type-name match runs against.
+ *
+ * `_` and `$` are word separators in the spellings this has to accept, not part
+ * of the words: `KAFKA_TEMPLATE` and `kafka_template` are the same bean name as
+ * `kafkaTemplate`, written to the constant and snake conventions. Digits stay,
+ * because they are part of a name (`kafkaTemplate2`), never a separator.
+ */
+function foldReceiverName(receiverSimpleName) {
+    return receiverSimpleName.replace(/[_$]/g, '').toLowerCase();
+}
+/**
+ * Cheap pre-filter usable before any receiver text is materialized. Both
+ * languages visit every member call, so the common case must cost one set
+ * lookup on the method name.
+ */
+export function isSpringMessageProducerMethod(methodName) {
+    return PRODUCER_METHOD_NAMES.has(methodName);
+}
+/**
+ * Classify a `receiver.method(...)` call as a messaging producer, or `null`.
+ *
+ * `receiverName` is the receiver expression as written; only its last
+ * dot-separated segment participates, so `this.kafkaTemplate` and
+ * `outer.inner.kafkaTemplate` match while `templates.get("k")` does not.
+ *
+ * The PLAIN_IDENTIFIER gate runs BEFORE the fold and is load-bearing, because
+ * the last-dot split is textual: in `config.get("a.kafkaTemplate")` it yields
+ * `kafkaTemplate")`, which folds to something a name match would accept. Only
+ * an identifier survives the gate, which is also what rejects `templates["k"]`,
+ * `getTemplate()`, and a receiver whose dot is separated by a comment.
+ *
+ * The folded segment then matches case-insensitively when it CONTAINS the
+ * template type name, so every convention a template bean is really declared
+ * with is recognized — decorated by prefix (`orderKafkaTemplate`), by suffix
+ * (`kafkaTemplateDlq`, `kafkaTemplateV2`, `rabbitTemplate1`), or written as a
+ * constant (`KAFKA_TEMPLATE`, `STREAM_BRIDGE`). A suffix-only rule accepted
+ * one of those and silently dropped the rest, which are exactly the publishes
+ * this capture exists to find. A receiver named only `template` still does not
+ * match: without type information that would attribute any `send` in the
+ * repository to Kafka.
+ *
+ * The bare type name (`KafkaTemplate.send(...)`) contains itself and so is
+ * accepted. That is left as it is: the match is by NAME, a name equal to the
+ * type is the strongest evidence the rule has, and a later phase that owns type
+ * information can discard a static-looking receiver.
+ *
+ * A substring rule also lets ONE receiver satisfy TWO signatures, which a
+ * suffix rule could not: `KafkaTemplate` and `StreamBridge` both publish
+ * through `send`, and `RabbitTemplate` and `JmsTemplate` both through
+ * `convertAndSend`, so `streamBridgeKafkaTemplate.send(...)` matches two
+ * templates at once. Such a receiver yields NO fact. Nothing here can break the
+ * tie honestly: the receiver's TYPE is deliberately not resolved, and the name
+ * is not ranked evidence — neither the longest match, nor the last one, nor the
+ * order of this list says whether that bean is a KafkaTemplate fronted by a
+ * stream binding or a StreamBridge named after the broker behind it. Returning
+ * the first match published an arbitrary choice as a definite broker
+ * attribution, the one outcome a consumer cannot tell from a fact. Silence
+ * costs a rare publish and stays recoverable by a phase that owns types.
+ */
+export function springMessageProducerTemplateOf(receiverName, methodName) {
+    if (!isSpringMessageProducerMethod(methodName))
+        return null;
+    const receiverSimpleName = receiverName.slice(receiverName.lastIndexOf('.') + 1).trim();
+    if (!PLAIN_IDENTIFIER.test(receiverSimpleName))
+        return null;
+    const folded = foldReceiverName(receiverSimpleName);
+    let matched = null;
+    for (const signature of PRODUCER_SIGNATURES) {
+        if (signature.methodName !== methodName)
+            continue;
+        if (!folded.includes(signature.typeName.toLowerCase()))
+            continue;
+        // A second match makes the receiver ambiguous; see above for why it is not
+        // resolved by preferring one of them.
+        if (matched !== null)
+            return null;
+        matched = signature.template;
+    }
+    return matched;
+}

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

@@ -2,12 +2,41 @@ import type { ParsedFile, Range, 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';
+import type { SpringArgumentFact } from './argument-facts.js';
 export declare const SPRING_NON_HTTP_HANDLER_ENTRY_POINT_MULTIPLIER = 3;
 export type SpringNonHttpHandlerKind = 'scheduled' | 'event' | 'message' | 'xxl-job';
 export interface SpringNonHttpHandlerAnnotationFact {
     readonly name: string;
     /** Kotlin use-site targets describe generated/property elements, not the callable. */
     readonly useSiteTarget?: string;
+    /**
+     * Annotation arguments in source order. An empty array always means an empty
+     * list was written (`@Scheduled()`), which is a different fact from absence —
+     * but absence has TWO causes, and only one of them is a statement about the
+     * source. Either the annotation was written without an argument list
+     * (`@Scheduled`), or arguments were never read for this callable.
+     *
+     * They are read only for a callable that carries a handler annotation. Java
+     * produces facts for no other callable, so there absence does mean "no list
+     * was written". Kotlin also produces a fact for a merely annotated function —
+     * it captures those without a name prefilter so an import alias cannot hide a
+     * handler — and on those facts arguments are absent however the annotation
+     * was written.
+     *
+     * The values keep their source spelling, with one deliberate exception:
+     * `normalizeSpringFactText` trims them and collapses whitespace around the
+     * dots of a multi-line expression, so `Destinations.ORDERS` and the same
+     * reference wrapped across lines produce equal facts. Without that, source
+     * formatting — including the enclosing block's indentation, which is not a
+     * property of the expression at all — would leak into the data and make two
+     * spellings of one destination compare unequal downstream.
+     *
+     * Nothing else is touched. `@KafkaListener(topics = ...)` and
+     * `@RabbitListener(queues = ...)` name the destination differently, and a
+     * destination may be a literal, a constant reference, or a `${...}`
+     * placeholder; resolving any of those belongs to a later phase.
+     */
+    readonly args?: readonly SpringArgumentFact[];
 }
 export interface SpringNonHttpHandlerFact<Annotation extends SpringNonHttpHandlerAnnotationFact = SpringNonHttpHandlerAnnotationFact> {
     readonly ownerScopeId: ScopeId;

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

@@ -6,6 +6,7 @@ import type { JavaSpringAopFact } from './spring-aop.js';
 import type { JavaSpringConditionalFact } from './spring-conditionals.js';
 import type { JavaSpringDiClassFact } from './spring-di.js';
 import type { SpringDynamicLookupFact } from '../../frameworks/spring/dynamic-lookups.js';
+import type { SpringMessageProducerFact } from '../../frameworks/spring/message-producers.js';
 import type { JavaSpringNonHttpHandlerFact } from './spring-non-http-handlers.js';
 export type JavaClassAnnotationFact = ClassAnnotationFact;
 export interface JavaCaptureSideChannel {
@@ -18,6 +19,7 @@ export interface JavaCaptureSideChannel {
     readonly springDiFacts?: readonly JavaSpringDiClassFact[];
     readonly springDynamicLookupFacts?: readonly SpringDynamicLookupFact[];
     readonly springNonHttpHandlerFacts?: readonly JavaSpringNonHttpHandlerFact[];
+    readonly springMessageProducerFacts?: readonly SpringMessageProducerFact[];
 }
 /** Clear facts retained by a prior workspace pass in a long-lived process. */
 export declare function clearJavaClassAnnotationFacts(): void;
@@ -35,6 +37,8 @@ export declare function setJavaSpringDynamicLookupFacts(filePath: string, facts:
 export declare function getJavaSpringDynamicLookupFacts(filePath: string): readonly SpringDynamicLookupFact[];
 export declare function setJavaSpringNonHttpHandlerFacts(filePath: string, facts: readonly JavaSpringNonHttpHandlerFact[]): void;
 export declare function getJavaSpringNonHttpHandlerFacts(filePath: string): readonly JavaSpringNonHttpHandlerFact[];
+export declare function setJavaSpringMessageProducerFacts(filePath: string, facts: readonly SpringMessageProducerFact[]): void;
+export declare function getJavaSpringMessageProducerFacts(filePath: string): readonly SpringMessageProducerFact[];
 /** Snapshot worker-local Java annotation facts for ParsedFile serialization. */
 export declare function collectJavaCaptureSideChannel(filePath: string): JavaCaptureSideChannel | undefined;
 export declare function getJavaClassAnnotationFacts(filePath: string): readonly JavaClassAnnotationFact[];

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

@@ -8,6 +8,7 @@ const springConditionalFacts = new Map();
 const springDiFacts = new Map();
 const springDynamicLookupFacts = new Map();
 const springNonHttpHandlerFacts = new Map();
+const springMessageProducerFacts = new Map();
 /** Clear facts retained by a prior workspace pass in a long-lived process. */
 export function clearJavaClassAnnotationFacts() {
     classAnnotations.clear();
@@ -17,6 +18,7 @@ export function clearJavaClassAnnotationFacts() {
     springDiFacts.clear();
     springDynamicLookupFacts.clear();
     springNonHttpHandlerFacts.clear();
+    springMessageProducerFacts.clear();
 }
 export function setJavaSpringAopFacts(filePath, facts) {
     if (facts.length === 0)
@@ -76,6 +78,15 @@ export function setJavaSpringNonHttpHandlerFacts(filePath, facts) {
 export function getJavaSpringNonHttpHandlerFacts(filePath) {
     return springNonHttpHandlerFacts.get(filePath) ?? [];
 }
+export function setJavaSpringMessageProducerFacts(filePath, facts) {
+    if (facts.length === 0)
+        springMessageProducerFacts.delete(filePath);
+    else
+        springMessageProducerFacts.set(filePath, facts);
+}
+export function getJavaSpringMessageProducerFacts(filePath) {
+    return springMessageProducerFacts.get(filePath) ?? [];
+}
 /** Snapshot worker-local Java annotation facts for ParsedFile serialization. */
 export function collectJavaCaptureSideChannel(filePath) {
     const facts = classAnnotations.get(filePath);
@@ -85,6 +96,7 @@ export function collectJavaCaptureSideChannel(filePath) {
     const diFacts = springDiFacts.get(filePath) ?? [];
     const dynamicLookupFacts = springDynamicLookupFacts.get(filePath) ?? [];
     const nonHttpHandlerFacts = springNonHttpHandlerFacts.get(filePath) ?? [];
+    const messageProducerFacts = springMessageProducerFacts.get(filePath) ?? [];
     const packageFact = getJavaPackageFact(filePath);
     if (facts.length === 0 &&
         aopFacts.length === 0 &&
@@ -93,6 +105,7 @@ export function collectJavaCaptureSideChannel(filePath) {
         diFacts.length === 0 &&
         dynamicLookupFacts.length === 0 &&
         nonHttpHandlerFacts.length === 0 &&
+        messageProducerFacts.length === 0 &&
         packageFact === undefined) {
         return undefined;
     }
@@ -106,6 +119,9 @@ export function collectJavaCaptureSideChannel(filePath) {
         ...(diFacts.length > 0 ? { springDiFacts: diFacts } : {}),
         ...(dynamicLookupFacts.length > 0 ? { springDynamicLookupFacts: dynamicLookupFacts } : {}),
         ...(nonHttpHandlerFacts.length > 0 ? { springNonHttpHandlerFacts: nonHttpHandlerFacts } : {}),
+        ...(messageProducerFacts.length > 0
+            ? { springMessageProducerFacts: messageProducerFacts }
+            : {}),
     };
 }
 export function getJavaClassAnnotationFacts(filePath) {
@@ -126,6 +142,7 @@ export function applyJavaCaptureSideChannel(parsed) {
         setJavaSpringDiFacts(parsed.filePath, []);
         setJavaSpringDynamicLookupFacts(parsed.filePath, []);
         setJavaSpringNonHttpHandlerFacts(parsed.filePath, []);
+        setJavaSpringMessageProducerFacts(parsed.filePath, []);
         setJavaPackageFact(parsed.filePath, UNKNOWN_JVM_PACKAGE_FACT);
         return;
     }
@@ -136,5 +153,6 @@ export function applyJavaCaptureSideChannel(parsed) {
     setJavaSpringDiFacts(parsed.filePath, Array.isArray(data.springDiFacts) ? data.springDiFacts : []);
     setJavaSpringDynamicLookupFacts(parsed.filePath, Array.isArray(data.springDynamicLookupFacts) ? data.springDynamicLookupFacts : []);
     setJavaSpringNonHttpHandlerFacts(parsed.filePath, Array.isArray(data.springNonHttpHandlerFacts) ? data.springNonHttpHandlerFacts : []);
+    setJavaSpringMessageProducerFacts(parsed.filePath, Array.isArray(data.springMessageProducerFacts) ? data.springMessageProducerFacts : []);
     setJavaPackageFact(parsed.filePath, isJvmPackageFact(data.packageFact) ? data.packageFact : UNKNOWN_JVM_PACKAGE_FACT);
 }

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

@@ -7,12 +7,13 @@ import { getJavaParser, getJavaScopeQuery } from './query.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
-import { setJavaClassAnnotationFacts, setJavaSpringAopFacts, setJavaSpringConfigConsumerFacts, setJavaSpringConditionalFacts, setJavaSpringDiFacts, setJavaSpringDynamicLookupFacts, setJavaSpringNonHttpHandlerFacts, } from './capture-side-channel.js';
+import { setJavaClassAnnotationFacts, setJavaSpringAopFacts, setJavaSpringConfigConsumerFacts, setJavaSpringConditionalFacts, setJavaSpringDiFacts, setJavaSpringDynamicLookupFacts, setJavaSpringMessageProducerFacts, setJavaSpringNonHttpHandlerFacts, } from './capture-side-channel.js';
 import { captureJavaPackageFact } from './package-facts.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
 import { captureJavaSpringConfigConsumerFacts } from './spring-config-bindings.js';
 import { captureJavaSpringDiClassFact } from './spring-di.js';
 import { captureJavaSpringDynamicLookupFact } from './spring-dynamic-lookup.js';
+import { captureJavaSpringMessageProducerFact } from './spring-message-producers.js';
 import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
 import { captureJavaSpringAopFacts } from './spring-aop.js';
 import { captureJavaSpringConditionalFacts, } from './spring-conditionals.js';
@@ -101,7 +102,8 @@ export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
     const springNonHttpHandlerFacts = [];
     const springDiClassNodeIds = new Set();
     const springDynamicLookupFacts = [];
-    const springDynamicLookupNodeIds = new Set();
+    const springMessageProducerFacts = [];
+    const springMemberCallNodeIds = new Set();
     for (const m of rawMatches) {
         const grouped = {};
         // Parallel tag -> captured SyntaxNode map. The tree-sitter query already
@@ -120,12 +122,17 @@ export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
         }
         if (Object.keys(grouped).length === 0)
             continue;
-        const dynamicLookupNode = nodeIfType(nodeMap['@reference.call.member'], 'method_invocation');
-        if (dynamicLookupNode !== null && !springDynamicLookupNodeIds.has(dynamicLookupNode.id)) {
-            springDynamicLookupNodeIds.add(dynamicLookupNode.id);
-            const fact = captureJavaSpringDynamicLookupFact(dynamicLookupNode, filePath);
-            if (fact !== null)
-                springDynamicLookupFacts.push(fact);
+        // One visit per member call node: the same invocation can back several
+        // query matches, and both Spring call-shape captures must see it once.
+        const memberCallNode = nodeIfType(nodeMap['@reference.call.member'], 'method_invocation');
+        if (memberCallNode !== null && !springMemberCallNodeIds.has(memberCallNode.id)) {
+            springMemberCallNodeIds.add(memberCallNode.id);
+            const lookupFact = captureJavaSpringDynamicLookupFact(memberCallNode, filePath);
+            if (lookupFact !== null)
+                springDynamicLookupFacts.push(lookupFact);
+            const producerFact = captureJavaSpringMessageProducerFact(memberCallNode, filePath);
+            if (producerFact !== null)
+                springMessageProducerFacts.push(producerFact);
         }
         const springAopTypeNode = [
             nodeIfType(nodeMap['@scope.class'], 'class_declaration'),
@@ -300,6 +307,7 @@ export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
     setJavaSpringDiFacts(filePath, springDiFacts);
     setJavaSpringDynamicLookupFacts(filePath, springDynamicLookupFacts);
     setJavaSpringNonHttpHandlerFacts(filePath, springNonHttpHandlerFacts);
+    setJavaSpringMessageProducerFacts(filePath, springMessageProducerFacts);
     return [
         ...resolveVarTypeBindings(out),
         ...synthesizeJavaInheritanceReferences(tree.rootNode),

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

@@ -1,13 +1,29 @@
 import { type SpringDiAnnotationFact, type SpringDiClassFact, type SpringDiDependencyFact, type SpringDiInjectionSiteFact } from '../../frameworks/spring/di-metadata.js';
+import { type SpringArgumentFact } from '../../frameworks/spring/argument-facts.js';
 import { type SyntaxNode } from '../../utils/ast-helpers.js';
 export interface JavaAnnotationSyntaxFact extends SpringDiAnnotationFact {
     readonly line: number;
+    /** Present only for callers that opt in via `javaSpringAnnotationFacts`. */
+    readonly args?: readonly SpringArgumentFact[];
+}
+/**
+ * Options for `javaSpringAnnotationFacts`.
+ *
+ * The STRUCTURED arguments are opt-in because DI captures every annotated
+ * field, constructor, and method 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 JavaSpringAnnotationFactOptions {
+    readonly includeArguments?: boolean;
 }
 export type JavaSpringDependencyFact = SpringDiDependencyFact<JavaAnnotationSyntaxFact>;
 type JavaSpringInjectionSiteKind = 'field' | 'constructor' | 'method';
 export type JavaSpringInjectionSiteFact = SpringDiInjectionSiteFact<JavaAnnotationSyntaxFact, JavaSpringInjectionSiteKind>;
 export type JavaSpringDiClassFact = SpringDiClassFact<JavaAnnotationSyntaxFact, JavaSpringInjectionSiteKind>;
-export declare function javaSpringAnnotationFacts(node: SyntaxNode): JavaAnnotationSyntaxFact[];
+export declare function javaSpringAnnotationFacts(node: SyntaxNode, options?: JavaSpringAnnotationFactOptions): JavaAnnotationSyntaxFact[];
 /**
  * Capture one class already surfaced by Java's scope query.
  *

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

@@ -1,11 +1,51 @@
 import { makeScopeId } from '../../../../_shared/index.js';
 import { createSpringDiMetadataAttacher, hasSpringDiRelevantAnnotation, hasSpringStereotypeSyntax, } from '../../frameworks/spring/di-metadata.js';
 import { hasSpringBeanFactorySyntax, } from '../../frameworks/spring/bean-factories.js';
+import { normalizeSpringFactText, } from '../../frameworks/spring/argument-facts.js';
 import { parseSpringInjectionType } from '../../di-extractors/spring.js';
-import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { hasRecoveredSyntax, nodeToCapture } from '../../utils/ast-helpers.js';
 import { isJavaPackageSiblingVisibilityIncomplete } from './package-siblings.js';
 import { getJavaSpringDiFacts } from './capture-side-channel.js';
-export function javaSpringAnnotationFacts(node) {
+const JAVA_COMMENT_NODE_TYPES = new Set(['line_comment', 'block_comment']);
+/**
+ * Annotation arguments as written, or `undefined` for a marker annotation.
+ *
+ * `@Scheduled` yields `undefined` (no argument list in the syntax) while
+ * `@Scheduled()` yields `[]` (an empty list was written). Named arguments keep
+ * their key, single-element ones stay positional, and array initializers are
+ * kept as one raw `{...}` text — splitting or dereferencing them would be
+ * resolution, which does not belong at capture time.
+ *
+ * An argument list that did not parse also yields `undefined`. Error recovery
+ * fills gaps with invented nodes — `@KafkaListener(topics = "orders", groupId =`
+ * hands back a `groupId` whose value is a `{}` that nobody wrote — and there is
+ * no fourth state here for "unreadable". Collapsing it into the marker case is
+ * deliberate: both tell a consumer there is nothing here to resolve, which is
+ * true, whereas a fabricated value would send it somewhere real and wrong.
+ */
+function javaAnnotationArgumentFacts(annotation) {
+    const argumentList = annotation.childForFieldName('arguments');
+    if (argumentList === null || hasRecoveredSyntax(argumentList))
+        return undefined;
+    const args = [];
+    for (const child of argumentList.namedChildren) {
+        if (JAVA_COMMENT_NODE_TYPES.has(child.type))
+            continue;
+        if (child.type === 'element_value_pair') {
+            const key = child.childForFieldName('key');
+            const value = child.childForFieldName('value');
+            if (key === null || value === null) {
+                args.push({ text: normalizeSpringFactText(child.text) });
+                continue;
+            }
+            args.push({ name: key.text.trim(), text: normalizeSpringFactText(value.text) });
+            continue;
+        }
+        args.push({ text: normalizeSpringFactText(child.text) });
+    }
+    return args;
+}
+export function javaSpringAnnotationFacts(node, options = {}) {
     const facts = [];
     for (const child of node.namedChildren) {
         if (child.type !== 'modifiers')
@@ -16,10 +56,12 @@ export function javaSpringAnnotationFacts(node) {
             const nameNode = modifier.childForFieldName('name') ?? modifier.firstNamedChild;
             if (nameNode === null)
                 continue;
+            const args = options.includeArguments === true ? javaAnnotationArgumentFacts(modifier) : undefined;
             facts.push({
                 name: nameNode.text.trim(),
                 text: modifier.text.trim(),
                 line: modifier.startPosition.row + 1,
+                ...(args === undefined ? {} : { args }),
             });
         }
     }

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

@@ -0,0 +1,20 @@
+import { type SpringMessageProducerFact } from '../../frameworks/spring/message-producers.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+/**
+ * Capture one messaging-template publish from a Java 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. The fact exists to
+ * carry a destination, and error recovery invents argument boundaries — an
+ * unterminated `send(TOPIC,` absorbs the next declaration's source and offers
+ * it as an argument. There is no state on this fact that means "published
+ * somewhere unreadable", so the choice is between silence and a plausible lie,
+ * and silence is recoverable: the file is re-captured when it parses.
+ */
+export declare function captureJavaSpringMessageProducerFact(node: SyntaxNode, filePath: string): SpringMessageProducerFact | null;
+/** Standalone extractor for focused tests; production reuses scope-query call nodes. */
+export declare function captureJavaSpringMessageProducerFacts(rootNode: SyntaxNode, filePath: string): SpringMessageProducerFact[];