gitnexus 1.6.11-rc.8 → 1.6.11

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

@@ -0,0 +1,62 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { createSpringDynamicLookupMetadataAttacher, springDynamicLookupCardinality, } from '../../frameworks/spring/dynamic-lookups.js';
+import { findAncestorBeforeBoundary, nodeToCapture, } from '../../utils/ast-helpers.js';
+import { getJavaSpringDynamicLookupFacts } from './capture-side-channel.js';
+const CALLABLE_NODE_TYPES = new Set([
+    'method_declaration',
+    'constructor_declaration',
+    'compact_constructor_declaration',
+]);
+const NO_CALLABLE_BOUNDARIES = new Set();
+function classLiteralTypeName(argument) {
+    if (argument.type !== 'class_literal' || argument.namedChildCount !== 1)
+        return null;
+    return argument.namedChild(0)?.text.trim() ?? null;
+}
+/** Capture real Java method invocations; comments and literals are never visited as calls. */
+export function captureJavaSpringDynamicLookupFact(node, filePath) {
+    if (node.type !== 'method_invocation')
+        return null;
+    const receiverName = node.childForFieldName('object')?.text.trim();
+    const methodName = node.childForFieldName('name')?.text.trim();
+    const argumentsNode = node.childForFieldName('arguments');
+    if (receiverName === undefined || methodName === undefined || argumentsNode === null)
+        return null;
+    if (springDynamicLookupCardinality(receiverName, methodName) === null)
+        return null;
+    const argumentsWithoutComments = argumentsNode.namedChildren.filter((child) => child.type !== 'line_comment' && child.type !== 'block_comment');
+    if (argumentsWithoutComments.length !== 1)
+        return null;
+    const argument = argumentsWithoutComments[0];
+    if (argument === undefined)
+        return null;
+    const targetTypeName = classLiteralTypeName(argument);
+    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,
+        methodName,
+        targetTypeName,
+    };
+}
+/** Standalone extractor for focused tests; production reuses scope-query call nodes. */
+export function captureJavaSpringDynamicLookupFacts(rootNode, filePath) {
+    return rootNode
+        .descendantsOfType('method_invocation')
+        .map((node) => captureJavaSpringDynamicLookupFact(node, filePath))
+        .filter((fact) => fact !== null);
+}
+/** Attach Java lookup facts for later resolution by the shared DI phase. */
+export const attachJavaSpringDynamicLookup = createSpringDynamicLookupMetadataAttacher({
+    getFacts: getJavaSpringDynamicLookupFacts,
+});

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[];

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

@@ -0,0 +1,83 @@
+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, hasRecoveredSyntax, nodeToCapture, } from '../../utils/ast-helpers.js';
+const CALLABLE_NODE_TYPES = new Set([
+    'method_declaration',
+    'constructor_declaration',
+    'compact_constructor_declaration',
+]);
+/**
+ * A type body ends the search for the publishing callable.
+ *
+ * Without it the ancestor walk passes THROUGH the body of a class declared
+ * inside a method, so a publish in that class's field initializer is attributed
+ * to the enclosing method, which may never run it. The identical construct at
+ * the top level of a class already yields no fact — there is no enclosing
+ * callable to find — and the rule has to read the same at every depth.
+ */
+const TYPE_BODY_BOUNDARIES = new Set([
+    'class_body',
+    'interface_body',
+    'enum_body',
+    'enum_body_declarations',
+    'annotation_type_body',
+]);
+const COMMENT_NODE_TYPES = new Set(['line_comment', 'block_comment']);
+/** Java has no named call arguments, so every argument is captured positionally. */
+function javaCallArgumentFacts(argumentList) {
+    return argumentList.namedChildren
+        .filter((child) => !COMMENT_NODE_TYPES.has(child.type))
+        .map((child) => ({ text: normalizeSpringFactText(child.text) }));
+}
+/**
+ * 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 function captureJavaSpringMessageProducerFact(node, filePath) {
+    if (node.type !== 'method_invocation')
+        return null;
+    const methodName = node.childForFieldName('name')?.text.trim();
+    if (methodName === undefined || !isSpringMessageProducerMethod(methodName))
+        return null;
+    const receiverText = node.childForFieldName('object')?.text;
+    if (receiverText === undefined)
+        return null;
+    const receiverName = normalizeSpringFactText(receiverText);
+    const template = springMessageProducerTemplateOf(receiverName, methodName);
+    if (template === null)
+        return null;
+    const argumentList = node.childForFieldName('arguments');
+    if (argumentList !== null && hasRecoveredSyntax(argumentList))
+        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,
+        methodName,
+        ...(argumentList === null ? {} : { args: javaCallArgumentFacts(argumentList) }),
+    };
+}
+/** Standalone extractor for focused tests; production reuses scope-query call nodes. */
+export function captureJavaSpringMessageProducerFacts(rootNode, filePath) {
+    return rootNode
+        .descendantsOfType('method_invocation')
+        .map((node) => captureJavaSpringMessageProducerFact(node, filePath))
+        .filter((fact) => fact !== null);
+}

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

@@ -2,6 +2,16 @@ import { type SpringNonHttpHandlerFact } from '../../frameworks/spring/non-http-
 import { type SyntaxNode } from '../../utils/ast-helpers.js';
 import { type JavaAnnotationSyntaxFact } from './spring-di.js';
 export type JavaSpringNonHttpHandlerFact = SpringNonHttpHandlerFact<JavaAnnotationSyntaxFact>;
-/** Capture callable syntax while the Java class AST is already in hand. */
+/**
+ * Capture callable syntax while the Java class AST is already in hand.
+ *
+ * Annotation arguments are read in a second pass, only for callables that
+ * already carry a handler annotation, so the destination-bearing arguments
+ * (`topics`, `queues`, `destination`, `cron`) reach the fact without adding
+ * structured argument text to every annotation in the repository. Java can
+ * decide that on the simple name alone; Kotlin runs the same two passes but
+ * widens the first one with the file's import aliases, because a Kotlin handler
+ * annotation may be written under a name no list can contain.
+ */
 export declare function captureJavaSpringNonHttpHandlerFacts(classNode: SyntaxNode, filePath: string): JavaSpringNonHttpHandlerFact[];
 export declare const attachJavaSpringNonHttpHandlerMetadata: (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/java/spring-non-http-handlers.js

@@ -4,7 +4,17 @@ import { nodeToCapture } from '../../utils/ast-helpers.js';
 import { getJavaSpringNonHttpHandlerFacts } from './capture-side-channel.js';
 import { isJavaPackageSiblingVisibilityIncomplete } from './package-siblings.js';
 import { javaSpringAnnotationFacts } from './spring-di.js';
-/** Capture callable syntax while the Java class AST is already in hand. */
+/**
+ * Capture callable syntax while the Java class AST is already in hand.
+ *
+ * Annotation arguments are read in a second pass, only for callables that
+ * already carry a handler annotation, so the destination-bearing arguments
+ * (`topics`, `queues`, `destination`, `cron`) reach the fact without adding
+ * structured argument text to every annotation in the repository. Java can
+ * decide that on the simple name alone; Kotlin runs the same two passes but
+ * widens the first one with the file's import aliases, because a Kotlin handler
+ * annotation may be written under a name no list can contain.
+ */
 export function captureJavaSpringNonHttpHandlerFacts(classNode, filePath) {
     const facts = [];
     const body = classNode.childForFieldName('body');
@@ -13,9 +23,9 @@ export function captureJavaSpringNonHttpHandlerFacts(classNode, filePath) {
     for (const member of body.namedChildren) {
         if (member.type !== 'method_declaration')
             continue;
-        const annotations = javaSpringAnnotationFacts(member);
-        if (!hasSpringNonHttpHandlerRelevantAnnotation(annotations))
+        if (!hasSpringNonHttpHandlerRelevantAnnotation(javaSpringAnnotationFacts(member)))
             continue;
+        const annotations = javaSpringAnnotationFacts(member, { includeArguments: true });
         const ownerRange = nodeToCapture('@spring-non-http-handler.owner', member).range;
         facts.push({
             ownerScopeId: makeScopeId({ filePath, range: ownerRange, kind: 'Function' }),

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

@@ -13,7 +13,7 @@ import { defineLanguage } from '../language-provider.js';
 import { createLeadingDocDescriptionExtractor } from '../utils/ast-helpers.js';
 import { javaTypeConfig } from '../type-extractors/jvm.js';
 import { extractSpringRoutes, extractSpringTypes } from '../route-extractors/spring.js';
-import { extractJavaModuleConstants, foldJavaOperands, isJavaConstantFile, } from '../route-extractors/java-const-resolver.js';
+import { extractJavaModuleConstants, foldJavaOperands, isJavaConstantFile, prepareJavaRouteConstants, } from '../route-extractors/java-const-resolver.js';
 import { javaExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
 import { javaImportConfig } from '../import-resolvers/configs/jvm.js';
@@ -26,9 +26,11 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { javaVariableConfig } from '../variable-extractors/configs/jvm.js';
 import { createJavaCfgVisitor } from '../cfg/visitors/java.js';
 import { assertCloneable } from '../workers/clone-safety.js';
-import { collectJavaCaptureSideChannel } from './java/capture-side-channel.js';
+import { collectJavaCaptureSideChannel, getJavaSpringMessageProducerFacts, getJavaSpringNonHttpHandlerFacts, } from './java/capture-side-channel.js';
 import { javaRecordMethodExtractor, shouldSkipJavaRecordComponentDefinition, } from './java/record-components.js';
+import { synthesizeLombokAccessors } from './java/lombok-synthesizer.js';
 import { emitJavaScopeCaptures, interpretJavaImport, interpretJavaTypeBinding, javaBindingScopeFor, javaImportOwningScope, javaMergeBindings, javaReceiverBinding, javaArityCompatibility, resolveJavaImportTarget, } from './java/index.js';
+import { javaRuntimeSymbolStrategy } from './java/spring-actuator.js';
 /**
  * Java names the platform owns, matched against a BARE IDENTIFIER — a dropped
  * receiver's chain base (`System` in `System.out.println(...)`) or the bare
@@ -167,6 +169,7 @@ export const javaProvider = defineLanguage({
     shouldSkipDefinitionCapture: shouldSkipJavaRecordComponentDefinition,
     variableExtractor: createVariableExtractor(javaVariableConfig),
     classExtractor: createClassExtractor(javaClassConfig),
+    runtimeSymbolStrategy: javaRuntimeSymbolStrategy,
     // ── Javadoc → description (issue #2270) ──
     descriptionExtractor: createLeadingDocDescriptionExtractor(),
     builtInNames: BUILT_INS,
@@ -187,6 +190,7 @@ export const javaProvider = defineLanguage({
     // ── Route extraction ──
     extractDecoratorRoutes: extractSpringRoutes,
     extractRouteInheritanceTypes: extractSpringTypes,
+    synthesizeStructureMembers: synthesizeLombokAccessors,
     // ── #2980: constant harvest + qualified-ref fold for non-literal mapping
     // paths (`@PostMapping(ApiPaths.SAVE_V1)`) — kept behind provider hooks so
     // the shared ingestion layers stay language-agnostic. The heuristic is
@@ -200,11 +204,17 @@ export const javaProvider = defineLanguage({
     // INTERFACES on this side only, which cost the graph its Route nodes while
     // the group still published the contract).
     moduleConstantHeuristic: (content) => isJavaConstantFile(content) ||
-        // `import com.winning.opt.common.ApiPaths;` — ANY class import can bind a
-        // constant ref (`ApiPaths.X` at an annotation site), so gate on the
-        // general import shape, not on the imported name. Ingestion-only: this
-        // side needs the importing controller's own import table, which the group
-        // side instead derives lazily from the tree it already holds.
-        /\bimport\s+(?:static\s+)?[\w.]+\s*;/.test(content),
+        // Class imports and static (including on-demand) imports can bind a
+        // constant ref. Ordinary `import a.b.*;` is not a Java type import and is
+        // not expanded by extractJavaModuleConstants, so it must not harvest.
+        /\bimport\s+(?:static\s+[\w.]+(?:\.\*)?|[\w.]+)\s*;/.test(content),
+    prepareRouteConstants: prepareJavaRouteConstants,
     foldRoutePathOperands: foldJavaOperands,
+    // Async messaging facts for the `springDestinations` phase. Both stores are
+    // repopulated on the main thread by `applyJavaCaptureSideChannel`, so this
+    // answers for cache hits and misses alike.
+    getSpringMessagingFacts: (filePath) => ({
+        handlers: getJavaSpringNonHttpHandlerFacts(filePath),
+        producers: getJavaSpringMessageProducerFacts(filePath),
+    }),
 });

package/dist/core/ingestion/languages/jvm/accessor-synthesis.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Shared planning orchestration and emission for synthetic JVM accessors.
+ *
+ * Language adapters discover accessor plans. This module owns method-collision
+ * policy, graph emission, and scope captures without naming any language.
+ */
+import type Parser from 'tree-sitter';
+import type { CaptureMatch } from '../../../../_shared/index.js';
+export type SyntheticVisibility = 'public' | 'protected' | 'private' | 'package';
+export type MethodNameMatching = 'exact' | 'case-folded';
+export interface ExistingMethodIndex {
+    readonly matching: MethodNameMatching;
+    readonly aritiesByName: Map<string, Set<number>>;
+    readonly arityRangesByName: Map<string, Array<{
+        min: number;
+        max: number;
+    }>>;
+}
+export declare function createExistingMethodIndex(matching: MethodNameMatching): ExistingMethodIndex;
+export declare function rememberExistingMethod(index: ExistingMethodIndex, name: string, arity: number): void;
+export declare function rememberExistingMethodRange(index: ExistingMethodIndex, name: string, min: number, max: number): void;
+export declare function hasExistingMethod(index: ExistingMethodIndex, name: string, arity: number): boolean;
+export interface SyntheticAccessorSymbol {
+    filePath: string;
+    name: string;
+    nodeId: string;
+    type: 'Method';
+    ownerId: string;
+    qualifiedName: string;
+    parameterCount: number;
+    requiredParameterCount: number;
+    parameterTypes: string[];
+    returnType: string;
+    visibility: SyntheticVisibility;
+    isStatic: boolean;
+    isAbstract: boolean;
+    isFinal: boolean;
+}
+export interface SyntheticAccessorNode {
+    id: string;
+    label: 'Method';
+    properties: {
+        name: string;
+        filePath: string;
+        startLine: number;
+        endLine: number;
+        language: string;
+        isExported: boolean;
+        synthetic: string;
+        visibility: SyntheticVisibility;
+        isStatic: boolean;
+        returnType: string;
+        parameterTypes: string[];
+        parameterCount: number;
+        qualifiedName: string;
+    };
+}
+export interface SyntheticAccessorRelationship {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    type: 'HAS_METHOD';
+    confidence: number;
+    reason: string;
+}
+export interface SyntheticAccessorResult {
+    symbols: SyntheticAccessorSymbol[];
+    nodes: SyntheticAccessorNode[];
+    relationships: SyntheticAccessorRelationship[];
+}
+export interface PlannedJvmAccessor {
+    kind: 'getter' | 'setter';
+    name: string;
+    returnType: string;
+    parameterTypes: string[];
+    visibility: SyntheticVisibility;
+    isStatic: boolean;
+    isAbstract: boolean;
+    startLine: number;
+    endLine: number;
+    declaratorNode: Parser.SyntaxNode;
+}
+export interface PlannedJvmAccessorOwner {
+    node: Parser.SyntaxNode;
+    name: string;
+    accessors: readonly PlannedJvmAccessor[];
+}
+interface JvmAccessorSynthesisConfig {
+    language: string;
+    synthetic: string;
+    planOwners(rootNode: Parser.SyntaxNode): readonly PlannedJvmAccessorOwner[];
+}
+export interface JvmAccessorSynthesis {
+    synthesize(tree: Parser.Tree, filePath: string, classOwnersById: ReadonlyMap<number, string>): SyntheticAccessorResult;
+    captures(rootNode: Parser.SyntaxNode): CaptureMatch[];
+}
+export declare function createJvmAccessorSynthesis(config: JvmAccessorSynthesisConfig): JvmAccessorSynthesis;
+export declare function jvmTypeSimpleName(node: Parser.SyntaxNode): string | undefined;
+export {};

package/dist/core/ingestion/languages/jvm/accessor-synthesis.js

@@ -0,0 +1,173 @@
+import { toZeroBasedLine } from '../../utils/line-base.js';
+export function createExistingMethodIndex(matching) {
+    return { matching, aritiesByName: new Map(), arityRangesByName: new Map() };
+}
+function methodKey(index, name) {
+    return index.matching === 'case-folded' ? name.toLowerCase() : name;
+}
+export function rememberExistingMethod(index, name, arity) {
+    const key = methodKey(index, name);
+    let arities = index.aritiesByName.get(key);
+    if (!arities) {
+        arities = new Set();
+        index.aritiesByName.set(key, arities);
+    }
+    arities.add(arity);
+}
+export function rememberExistingMethodRange(index, name, min, max) {
+    if (min === max) {
+        rememberExistingMethod(index, name, min);
+        return;
+    }
+    const key = methodKey(index, name);
+    const ranges = index.arityRangesByName.get(key) ?? [];
+    ranges.push({ min, max });
+    index.arityRangesByName.set(key, ranges);
+}
+export function hasExistingMethod(index, name, arity) {
+    const key = methodKey(index, name);
+    if (index.aritiesByName.get(key)?.has(arity) === true)
+        return true;
+    return (index.arityRangesByName.get(key)?.some((range) => range.min <= arity && arity <= range.max) ===
+        true);
+}
+export function createJvmAccessorSynthesis(config) {
+    return {
+        synthesize(tree, filePath, classOwnersById) {
+            const result = emptySyntheticAccessorResult();
+            for (const owner of config.planOwners(tree.rootNode)) {
+                const ownerId = classOwnersById.get(owner.node.id);
+                if (!ownerId)
+                    continue;
+                emitPlannedAccessors({
+                    planned: owner.accessors,
+                    filePath,
+                    ownerId,
+                    idPrefix: ownerIdNamePrefix(ownerId, filePath, owner.name),
+                    language: config.language,
+                    synthetic: config.synthetic,
+                    result,
+                });
+            }
+            return result;
+        },
+        captures(rootNode) {
+            return capturesForPlannedAccessors(config.planOwners(rootNode));
+        },
+    };
+}
+function emptySyntheticAccessorResult() {
+    return { symbols: [], nodes: [], relationships: [] };
+}
+function ownerIdNamePrefix(ownerId, filePath, fallback) {
+    const needle = `Class:${filePath}:`;
+    if (ownerId.startsWith(needle))
+        return ownerId.slice(needle.length);
+    const enumNeedle = `Enum:${filePath}:`;
+    if (ownerId.startsWith(enumNeedle))
+        return ownerId.slice(enumNeedle.length);
+    const ifaceNeedle = `Interface:${filePath}:`;
+    if (ownerId.startsWith(ifaceNeedle))
+        return ownerId.slice(ifaceNeedle.length);
+    return fallback;
+}
+export function jvmTypeSimpleName(node) {
+    const named = node.childForFieldName('name')?.text;
+    if (named)
+        return named;
+    for (const child of node.namedChildren) {
+        if (child.type === 'type_identifier' || child.type === 'simple_identifier')
+            return child.text;
+    }
+    return undefined;
+}
+function emitPlannedAccessors(args) {
+    const emittedIds = new Set();
+    for (const acc of args.planned) {
+        const arity = acc.parameterTypes.length;
+        const qualifiedName = `${args.idPrefix}.${acc.name}`;
+        const nodeId = `Method:${args.filePath}:${qualifiedName}#${arity}`;
+        if (emittedIds.has(nodeId))
+            continue;
+        emittedIds.add(nodeId);
+        args.result.nodes.push({
+            id: nodeId,
+            label: 'Method',
+            properties: {
+                name: acc.name,
+                filePath: args.filePath,
+                startLine: toZeroBasedLine(acc.startLine),
+                endLine: toZeroBasedLine(acc.endLine),
+                language: args.language,
+                isExported: false,
+                synthetic: args.synthetic,
+                visibility: acc.visibility,
+                isStatic: acc.isStatic,
+                returnType: acc.returnType,
+                parameterTypes: acc.parameterTypes,
+                parameterCount: arity,
+                qualifiedName,
+            },
+        });
+        args.result.symbols.push({
+            filePath: args.filePath,
+            name: acc.name,
+            nodeId,
+            type: 'Method',
+            ownerId: args.ownerId,
+            qualifiedName,
+            parameterCount: arity,
+            requiredParameterCount: arity,
+            parameterTypes: acc.parameterTypes,
+            returnType: acc.returnType,
+            visibility: acc.visibility,
+            isStatic: acc.isStatic,
+            isAbstract: acc.isAbstract,
+            isFinal: false,
+        });
+        args.result.relationships.push({
+            id: `HAS_METHOD:${args.ownerId}->${nodeId}`,
+            sourceId: args.ownerId,
+            targetId: nodeId,
+            type: 'HAS_METHOD',
+            confidence: 1.0,
+            reason: acc.kind === 'getter' ? `${args.synthetic}-getter` : `${args.synthetic}-setter`,
+        });
+    }
+}
+function accessorCapture(name, acc, text) {
+    const node = acc.declaratorNode;
+    const startLine = node.startPosition.row + 1;
+    const startCol = node.startPosition.column;
+    const endLine = node.endPosition.row + 1;
+    const endCol = acc.kind === 'getter' ? node.endPosition.column : startCol;
+    return { name, range: { startLine, startCol, endLine, endCol }, text };
+}
+function capturesForPlannedAccessors(owners) {
+    const captures = [];
+    for (const owner of owners) {
+        const enclosing = owner.name;
+        const emitted = new Set();
+        for (const acc of owner.accessors) {
+            const arity = String(acc.parameterTypes.length);
+            const qualifiedName = `${enclosing}.${acc.name}`;
+            const identity = `${qualifiedName}#${arity}`;
+            if (emitted.has(identity))
+                continue;
+            emitted.add(identity);
+            captures.push({
+                '@scope.function': accessorCapture('@scope.function', acc, acc.name),
+            });
+            captures.push({
+                '@declaration.method': accessorCapture('@declaration.method', acc, acc.name),
+                '@declaration.name': accessorCapture('@declaration.name', acc, acc.name),
+                '@declaration.qualified_name': accessorCapture('@declaration.qualified_name', acc, qualifiedName),
+                '@declaration.parameter-count': accessorCapture('@declaration.parameter-count', acc, arity),
+                '@declaration.required-parameter-count': accessorCapture('@declaration.required-parameter-count', acc, arity),
+                '@declaration.return-type': accessorCapture('@declaration.return-type', acc, acc.returnType),
+                '@declaration.is-synthetic': accessorCapture('@declaration.is-synthetic', acc, 'true'),
+            });
+        }
+    }
+    return captures;
+}

package/dist/core/ingestion/languages/jvm/beanspec.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Language-neutral JVM JavaBeans naming primitives.
+ *
+ * Language adapters choose whether to invent/preserve an `is` prefix and
+ * which single-character capitalization policy their compiler uses.
+ */
+export declare function capitalizeBeanName(s: string): string;
+/**
+ * Primitive-boolean / Kotlin `is`-prefix fields whose name already starts with
+ * `is` plus a non-lowercase character keep that name for the getter and drop
+ * the `is` prefix for the setter base (`isEnabled` → `isEnabled()` /
+ * `setEnabled(...)`, `is1` → `is1()` / `set1(...)`). Digits and punctuation
+ * count as non-lowercase, matching Lombok `!Character.isLowerCase` and kotlinc.
+ */
+export declare function booleanIsPrefixBase(fieldName: string, useIsPrefix: boolean): string | null;
+export declare function jvmGetterName(fieldName: string, useIsPrefix: boolean, capitalize?: (name: string) => string): string;
+export declare function jvmSetterName(fieldName: string, useIsPrefix: boolean, capitalize?: (name: string) => string): string;

package/dist/core/ingestion/languages/jvm/beanspec.js

@@ -0,0 +1,42 @@
+/**
+ * Language-neutral JVM JavaBeans naming primitives.
+ *
+ * Language adapters choose whether to invent/preserve an `is` prefix and
+ * which single-character capitalization policy their compiler uses.
+ */
+export function capitalizeBeanName(s) {
+    if (s.length === 0)
+        return s;
+    const first = s.charAt(0);
+    const upper = first.toUpperCase();
+    // Java Character case conversion is one UTF-16 code unit. JavaScript
+    // full-case conversion may expand one unit (`ß` → `SS`), which would invent
+    // a method name no JVM compiler emits.
+    return (upper.length === 1 ? upper : first) + s.slice(1);
+}
+/**
+ * Primitive-boolean / Kotlin `is`-prefix fields whose name already starts with
+ * `is` plus a non-lowercase character keep that name for the getter and drop
+ * the `is` prefix for the setter base (`isEnabled` → `isEnabled()` /
+ * `setEnabled(...)`, `is1` → `is1()` / `set1(...)`). Digits and punctuation
+ * count as non-lowercase, matching Lombok `!Character.isLowerCase` and kotlinc.
+ */
+export function booleanIsPrefixBase(fieldName, useIsPrefix) {
+    if (!useIsPrefix || !fieldName.startsWith('is') || fieldName.length < 3)
+        return null;
+    const third = fieldName.charAt(2);
+    return third === third.toUpperCase() ? fieldName.slice(2) : null;
+}
+export function jvmGetterName(fieldName, useIsPrefix, capitalize = capitalizeBeanName) {
+    if (booleanIsPrefixBase(fieldName, useIsPrefix) !== null)
+        return fieldName;
+    if (useIsPrefix)
+        return `is${capitalize(fieldName)}`;
+    return `get${capitalize(fieldName)}`;
+}
+export function jvmSetterName(fieldName, useIsPrefix, capitalize = capitalizeBeanName) {
+    const stripped = booleanIsPrefixBase(fieldName, useIsPrefix);
+    if (stripped !== null)
+        return `set${stripped}`;
+    return `set${capitalize(fieldName)}`;
+}

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

@@ -39,10 +39,13 @@
 import type { ParsedFile, ScopeId } from '../../../../_shared/index.js';
 import { type ClassAnnotationFact } from '../../frameworks/spring/bean-candidates.js';
 import { type JvmPackageFact } from '../jvm/package-facts.js';
+import type { SpringDynamicLookupFact } from '../../frameworks/spring/dynamic-lookups.js';
+import type { SpringMessageProducerFact } from '../../frameworks/spring/message-producers.js';
 import type { KotlinSpringAopFact } from './spring-aop.js';
 import type { KotlinSpringConditionalFact } from './spring-conditionals.js';
 import type { KotlinSpringDiClassFact } from './spring-di.js';
 import type { KotlinSpringNonHttpHandlerFact } from './spring-non-http-handlers.js';
+import type { KotlinSpringConfigConsumerFact } from './spring-config-bindings.js';
 /**
  * Plain JSON-serializable snapshot of the per-file Kotlin capture-time
  * side-channel. Carried opaquely on `ParsedFile.captureSideChannel`. The
@@ -63,8 +66,14 @@ export interface KotlinCaptureSideChannel {
     readonly springConditionalFacts?: readonly KotlinSpringConditionalFact[];
     /** Constructor, property, and method injection syntax captured per class. */
     readonly springDiFacts?: readonly KotlinSpringDiClassFact[];
+    /** Programmatic Spring bean lookups captured per callable. */
+    readonly springDynamicLookupFacts?: readonly SpringDynamicLookupFact[];
     /** Scheduled, event, messaging, and managed-job handler syntax captured per callable. */
     readonly springNonHttpHandlerFacts?: readonly KotlinSpringNonHttpHandlerFact[];
+    /** `@Value` / `@ConfigurationProperties` syntax captured per owner. */
+    readonly springConfigConsumerFacts?: readonly KotlinSpringConfigConsumerFact[];
+    /** Messaging-template publish syntax captured per callable. */
+    readonly springMessageProducerFacts?: readonly SpringMessageProducerFact[];
 }
 export declare function clearKotlinClassAnnotationFacts(): void;
 export declare function setKotlinSpringAopFacts(filePath: string, facts: readonly KotlinSpringAopFact[]): void;
@@ -75,8 +84,14 @@ export declare function setKotlinSpringConditionalFacts(filePath: string, facts:
 export declare function getKotlinSpringConditionalFacts(filePath: string): readonly KotlinSpringConditionalFact[];
 export declare function setKotlinSpringDiFacts(filePath: string, facts: readonly KotlinSpringDiClassFact[]): void;
 export declare function getKotlinSpringDiFacts(filePath: string): readonly KotlinSpringDiClassFact[];
+export declare function setKotlinSpringDynamicLookupFacts(filePath: string, facts: readonly SpringDynamicLookupFact[]): void;
+export declare function getKotlinSpringDynamicLookupFacts(filePath: string): readonly SpringDynamicLookupFact[];
 export declare function setKotlinSpringNonHttpHandlerFacts(filePath: string, facts: readonly KotlinSpringNonHttpHandlerFact[]): void;
 export declare function getKotlinSpringNonHttpHandlerFacts(filePath: string): readonly KotlinSpringNonHttpHandlerFact[];
+export declare function setKotlinSpringConfigConsumerFacts(filePath: string, facts: readonly KotlinSpringConfigConsumerFact[]): void;
+export declare function getKotlinSpringConfigConsumerFacts(filePath: string): readonly KotlinSpringConfigConsumerFact[];
+export declare function setKotlinSpringMessageProducerFacts(filePath: string, facts: readonly SpringMessageProducerFact[]): void;
+export declare function getKotlinSpringMessageProducerFacts(filePath: string): readonly SpringMessageProducerFact[];
 /**
  * `LanguageProvider.collectCaptureSideChannel` implementation for Kotlin.
  * Returns `undefined` when this file recorded no side-channel state at all, so