gitnexus 1.6.11-rc.8 → 1.6.11

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

@@ -44,13 +44,19 @@ const classAnnotations = createClassAnnotationFactStore();
 const springAopFacts = new Map();
 const springConditionalFacts = new Map();
 const springDiFacts = new Map();
+const springDynamicLookupFacts = new Map();
 const springNonHttpHandlerFacts = new Map();
+const springConfigConsumerFacts = new Map();
+const springMessageProducerFacts = new Map();
 export function clearKotlinClassAnnotationFacts() {
     classAnnotations.clear();
     springAopFacts.clear();
     springConditionalFacts.clear();
     springDiFacts.clear();
+    springDynamicLookupFacts.clear();
     springNonHttpHandlerFacts.clear();
+    springConfigConsumerFacts.clear();
+    springMessageProducerFacts.clear();
 }
 export function setKotlinSpringAopFacts(filePath, facts) {
     if (facts.length === 0)
@@ -85,6 +91,15 @@ export function setKotlinSpringDiFacts(filePath, facts) {
 export function getKotlinSpringDiFacts(filePath) {
     return springDiFacts.get(filePath) ?? [];
 }
+export function setKotlinSpringDynamicLookupFacts(filePath, facts) {
+    if (facts.length === 0)
+        springDynamicLookupFacts.delete(filePath);
+    else
+        springDynamicLookupFacts.set(filePath, facts);
+}
+export function getKotlinSpringDynamicLookupFacts(filePath) {
+    return springDynamicLookupFacts.get(filePath) ?? [];
+}
 export function setKotlinSpringNonHttpHandlerFacts(filePath, facts) {
     if (facts.length === 0)
         springNonHttpHandlerFacts.delete(filePath);
@@ -94,6 +109,24 @@ export function setKotlinSpringNonHttpHandlerFacts(filePath, facts) {
 export function getKotlinSpringNonHttpHandlerFacts(filePath) {
     return springNonHttpHandlerFacts.get(filePath) ?? [];
 }
+export function setKotlinSpringConfigConsumerFacts(filePath, facts) {
+    if (facts.length === 0)
+        springConfigConsumerFacts.delete(filePath);
+    else
+        springConfigConsumerFacts.set(filePath, facts);
+}
+export function getKotlinSpringConfigConsumerFacts(filePath) {
+    return springConfigConsumerFacts.get(filePath) ?? [];
+}
+export function setKotlinSpringMessageProducerFacts(filePath, facts) {
+    if (facts.length === 0)
+        springMessageProducerFacts.delete(filePath);
+    else
+        springMessageProducerFacts.set(filePath, facts);
+}
+export function getKotlinSpringMessageProducerFacts(filePath) {
+    return springMessageProducerFacts.get(filePath) ?? [];
+}
 /**
  * `LanguageProvider.collectCaptureSideChannel` implementation for Kotlin.
  * Returns `undefined` when this file recorded no side-channel state at all, so
@@ -105,14 +138,20 @@ export function collectKotlinCaptureSideChannel(filePath) {
     const aopFacts = springAopFacts.get(filePath) ?? [];
     const conditionFacts = springConditionalFacts.get(filePath) ?? [];
     const diFacts = springDiFacts.get(filePath) ?? [];
+    const dynamicLookupFacts = springDynamicLookupFacts.get(filePath) ?? [];
     const nonHttpHandlerFacts = springNonHttpHandlerFacts.get(filePath) ?? [];
+    const configConsumerFacts = springConfigConsumerFacts.get(filePath) ?? [];
+    const messageProducerFacts = springMessageProducerFacts.get(filePath) ?? [];
     const packageFact = getKotlinPackageFact(filePath);
     if (companionScopes.length === 0 &&
         annotationFacts.length === 0 &&
         aopFacts.length === 0 &&
         conditionFacts.length === 0 &&
         diFacts.length === 0 &&
+        dynamicLookupFacts.length === 0 &&
         nonHttpHandlerFacts.length === 0 &&
+        configConsumerFacts.length === 0 &&
+        messageProducerFacts.length === 0 &&
         packageFact === undefined) {
         return undefined;
     }
@@ -124,7 +163,12 @@ export function collectKotlinCaptureSideChannel(filePath) {
         ...(aopFacts.length > 0 ? { springAopFacts: aopFacts } : {}),
         ...(conditionFacts.length > 0 ? { springConditionalFacts: conditionFacts } : {}),
         ...(diFacts.length > 0 ? { springDiFacts: diFacts } : {}),
+        ...(dynamicLookupFacts.length > 0 ? { springDynamicLookupFacts: dynamicLookupFacts } : {}),
         ...(nonHttpHandlerFacts.length > 0 ? { springNonHttpHandlerFacts: nonHttpHandlerFacts } : {}),
+        ...(configConsumerFacts.length > 0 ? { springConfigConsumerFacts: configConsumerFacts } : {}),
+        ...(messageProducerFacts.length > 0
+            ? { springMessageProducerFacts: messageProducerFacts }
+            : {}),
     };
 }
 /**
@@ -147,7 +191,10 @@ export function applyKotlinCaptureSideChannel(parsed) {
         setKotlinSpringAopFacts(parsed.filePath, []);
         setKotlinSpringConditionalFacts(parsed.filePath, []);
         setKotlinSpringDiFacts(parsed.filePath, []);
+        setKotlinSpringDynamicLookupFacts(parsed.filePath, []);
         setKotlinSpringNonHttpHandlerFacts(parsed.filePath, []);
+        setKotlinSpringConfigConsumerFacts(parsed.filePath, []);
+        setKotlinSpringMessageProducerFacts(parsed.filePath, []);
         setKotlinPackageFact(parsed.filePath, UNKNOWN_JVM_PACKAGE_FACT);
         return;
     }
@@ -158,6 +205,9 @@ export function applyKotlinCaptureSideChannel(parsed) {
     setKotlinSpringAopFacts(parsed.filePath, Array.isArray(data.springAopFacts) ? data.springAopFacts : []);
     setKotlinSpringConditionalFacts(parsed.filePath, Array.isArray(data.springConditionalFacts) ? data.springConditionalFacts : []);
     setKotlinSpringDiFacts(parsed.filePath, Array.isArray(data.springDiFacts) ? data.springDiFacts : []);
+    setKotlinSpringDynamicLookupFacts(parsed.filePath, Array.isArray(data.springDynamicLookupFacts) ? data.springDynamicLookupFacts : []);
     setKotlinSpringNonHttpHandlerFacts(parsed.filePath, Array.isArray(data.springNonHttpHandlerFacts) ? data.springNonHttpHandlerFacts : []);
+    setKotlinSpringConfigConsumerFacts(parsed.filePath, Array.isArray(data.springConfigConsumerFacts) ? data.springConfigConsumerFacts : []);
+    setKotlinSpringMessageProducerFacts(parsed.filePath, Array.isArray(data.springMessageProducerFacts) ? data.springMessageProducerFacts : []);
     setKotlinPackageFact(parsed.filePath, isJvmPackageFact(data.packageFact) ? data.packageFact : UNKNOWN_JVM_PACKAGE_FACT);
 }

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

@@ -10,10 +10,14 @@ import { normalizeKotlinType } from './interpret.js';
 import { synthesizeKotlinReceiverBinding } from './receiver-binding.js';
 import { getKotlinParser, getKotlinScopeQuery } from './query.js';
 import { markCompanionScope } from './companion-scopes.js';
-import { setKotlinClassAnnotationFacts, setKotlinSpringAopFacts, setKotlinSpringConditionalFacts, setKotlinSpringDiFacts, setKotlinSpringNonHttpHandlerFacts, } from './capture-side-channel.js';
+import { setKotlinClassAnnotationFacts, setKotlinSpringAopFacts, setKotlinSpringConditionalFacts, setKotlinSpringDiFacts, setKotlinSpringDynamicLookupFacts, setKotlinSpringMessageProducerFacts, setKotlinSpringNonHttpHandlerFacts, setKotlinSpringConfigConsumerFacts, } from './capture-side-channel.js';
 import { captureKotlinPackageFact } from './package-facts.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { synthesizeLombokAccessorCaptures } from './lombok-synthesizer.js';
 import { captureKotlinSpringDiClassFact } from './spring-di.js';
+import { captureKotlinSpringConfigConsumerFacts } from './spring-config-bindings.js';
+import { captureKotlinSpringDynamicLookupFact } from './spring-dynamic-lookup.js';
+import { captureKotlinSpringMessageProducerFact } from './spring-message-producers.js';
 import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
 import { captureKotlinSpringAopFacts } from './spring-aop.js';
 import { captureKotlinSpringConditionalFacts, } from './spring-conditionals.js';
@@ -75,6 +79,9 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     const springNonHttpHandlerFacts = [];
     const springNonHttpHandlerTypeNodeIds = new Set();
     const springDiClassNodeIds = new Set();
+    const springDynamicLookupFacts = [];
+    const springMessageProducerFacts = [];
+    const springMemberCallNodeIds = new Set();
     const returnTypes = collectKotlinReturnTypeTexts(tree.rootNode);
     out.push(...synthesizeKotlinLocalAssignmentBindings(tree.rootNode, returnTypes));
     out.push(...synthesizeKotlinLoopBindings(tree.rootNode, returnTypes));
@@ -97,6 +104,18 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
         }
         if (Object.keys(grouped).length === 0)
             continue;
+        // 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(groupedNodes['@reference.call.member'], 'call_expression');
+        if (memberCallNode !== null && !springMemberCallNodeIds.has(memberCallNode.id)) {
+            springMemberCallNodeIds.add(memberCallNode.id);
+            const lookupFact = captureKotlinSpringDynamicLookupFact(memberCallNode, filePath);
+            if (lookupFact !== null)
+                springDynamicLookupFacts.push(lookupFact);
+            const producerFact = captureKotlinSpringMessageProducerFact(memberCallNode, filePath);
+            if (producerFact !== null)
+                springMessageProducerFacts.push(producerFact);
+        }
         // tree-sitter-kotlin represents both classes and interfaces with
         // `class_declaration`; `object_declaration` is the separate object form.
         const springAopTypeNode = [
@@ -279,7 +298,11 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     setKotlinSpringAopFacts(filePath, springAopFacts);
     setKotlinSpringConditionalFacts(filePath, springConditionalFacts);
     setKotlinSpringDiFacts(filePath, springDiFacts);
+    setKotlinSpringDynamicLookupFacts(filePath, springDynamicLookupFacts);
     setKotlinSpringNonHttpHandlerFacts(filePath, springNonHttpHandlerFacts);
+    setKotlinSpringConfigConsumerFacts(filePath, captureKotlinSpringConfigConsumerFacts(tree.rootNode, filePath));
+    setKotlinSpringMessageProducerFacts(filePath, springMessageProducerFacts);
+    out.push(...synthesizeLombokAccessorCaptures(tree.rootNode));
     out.push(...synthesizeCallableFlowCaptures(tree.rootNode, KOTLIN_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }

package/dist/core/ingestion/languages/kotlin/lombok-synthesizer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Kotlin accessor synthesizer (same provider-hook role as Java Lombok).
+ *
+ * kotlinc emits JavaBeans getters/setters for `val`/`var` properties. Those
+ * methods are absent from the tree-sitter AST, so Java (and Kotlin) calls
+ * like `user.getName()` miss CALLS edges. Planning is Kotlin-specific;
+ * naming and Method emission share `jvm/beanspec` + `jvm/accessor-synthesis`.
+ *
+ * ## Supported subset (v1)
+ * - Class / data class / object / companion / interface `val`/`var` properties
+ *   (interface accessors without a custom body are abstract JVM methods).
+ * - Primary-constructor `val`/`var` class parameters.
+ * - Names beginning with `is` + a non-lowercase character keep that getter name; all other
+ *   properties, including `Boolean`, use `get`.
+ * - Custom `get()`/`set()` bodies still emit their JVM accessor Methods.
+ * - Explicit `fun getX` / `@JvmField` / `const` skip synthesis.
+ * - `@JvmName`-renamed accessors are suppressed until custom-name emission lands.
+ * Unsupported: `@JvmStatic` renaming, file-facade top-level properties.
+ */
+import type Parser from 'tree-sitter';
+import type { CaptureMatch } from '../../../../_shared/index.js';
+import { type SyntheticAccessorResult } from '../jvm/accessor-synthesis.js';
+export declare function kotlinGetterName(propertyName: string): string;
+export declare function kotlinSetterName(propertyName: string): string;
+export declare function synthesizeLombokAccessors(tree: Parser.Tree, filePath: string, classOwnersById: ReadonlyMap<number, string>): SyntheticAccessorResult;
+export declare function synthesizeLombokAccessorCaptures(rootNode: Parser.SyntaxNode): CaptureMatch[];

package/dist/core/ingestion/languages/kotlin/lombok-synthesizer.js

@@ -0,0 +1,417 @@
+import { booleanIsPrefixBase, jvmGetterName, jvmSetterName } from '../jvm/beanspec.js';
+import { createExistingMethodIndex, createJvmAccessorSynthesis, hasExistingMethod, jvmTypeSimpleName, rememberExistingMethod, } from '../jvm/accessor-synthesis.js';
+const KOTLIN_TYPE_DECLS = new Set(['class_declaration', 'object_declaration', 'companion_object']);
+function capitalizeAscii(name) {
+    const first = name.charAt(0);
+    return first >= 'a' && first <= 'z'
+        ? String.fromCharCode(first.charCodeAt(0) - 32) + name.slice(1)
+        : name;
+}
+export function kotlinGetterName(propertyName) {
+    return jvmGetterName(propertyName, booleanIsPrefixBase(propertyName, true) !== null, capitalizeAscii);
+}
+export function kotlinSetterName(propertyName) {
+    return jvmSetterName(propertyName, true, capitalizeAscii);
+}
+function collectKotlinImports(root) {
+    const byLocalName = new Map();
+    const shadowedSimpleNames = new Set();
+    for (const child of root.children) {
+        if (child.type !== 'class_declaration')
+            continue;
+        const name = jvmTypeSimpleName(child);
+        if (name)
+            shadowedSimpleNames.add(name);
+    }
+    const importList = root.children.find((child) => child.type === 'import_list');
+    for (const child of importList?.children ?? []) {
+        if (child.type !== 'import_header')
+            continue;
+        const text = child.text
+            .replace(/^import\s+/, '')
+            .replace(/\/\*[\s\S]*?\*\//g, '')
+            .trim();
+        const [pathText, aliasText] = text.split(/\s+as\s+/, 2);
+        const importPath = pathText?.replace(/\s+/g, '');
+        if (!importPath || importPath.endsWith('.*'))
+            continue;
+        const localName = aliasText?.trim() || importPath.split('.').pop();
+        if (localName)
+            byLocalName.set(localName, importPath);
+    }
+    return { byLocalName, shadowedSimpleNames };
+}
+function annotationUserTypeText(annotation) {
+    const constructor = annotation.namedChildren.find((c) => c.type === 'constructor_invocation');
+    const userType = constructor?.namedChildren.find((c) => c.type === 'user_type') ??
+        annotation.namedChildren.find((c) => c.type === 'user_type');
+    return userType?.text ?? '';
+}
+function isKotlinJvmAnnotation(annotation, name, imports) {
+    const typeText = annotationUserTypeText(annotation);
+    const canonical = `kotlin.jvm.${name}`;
+    if (typeText.includes('.'))
+        return typeText === canonical;
+    const imported = imports.byLocalName.get(typeText);
+    if (imported !== undefined)
+        return imported === canonical;
+    if (imports.shadowedSimpleNames.has(typeText))
+        return false;
+    return typeText === name;
+}
+function kotlinVisibility(modifiers) {
+    if (!modifiers)
+        return 'public';
+    for (const child of modifiers.namedChildren) {
+        if (child.type !== 'visibility_modifier')
+            continue;
+        if (child.text === 'private')
+            return 'private';
+        if (child.text === 'protected')
+            return 'protected';
+        if (child.text === 'internal')
+            return 'package';
+    }
+    return 'public';
+}
+function hasJvmField(node, imports) {
+    const mods = node.children.find((c) => c.type === 'modifiers');
+    return (mods?.namedChildren.some((child) => child.type === 'annotation' && isKotlinJvmAnnotation(child, 'JvmField', imports)) === true);
+}
+function hasConst(node) {
+    const mods = node.children.find((c) => c.type === 'modifiers');
+    if (mods?.namedChildren.some((child) => child.type === 'property_modifier' && child.text === 'const')) {
+        return true;
+    }
+    return node.namedChildren.some((child) => child.type === 'const');
+}
+function isVarBinding(node) {
+    const kind = node.children.find((c) => c.type === 'binding_pattern_kind');
+    const text = kind?.text;
+    if (text === 'var')
+        return true;
+    if (text === 'val')
+        return false;
+    return null;
+}
+function inferredInitializerType(node) {
+    switch (node.type) {
+        case 'string_literal':
+        case 'line_string_literal':
+        case 'multi_line_string_literal':
+            return 'String';
+        case 'character_literal':
+            return 'Char';
+        case 'boolean_literal':
+        case 'true':
+        case 'false':
+            return 'Boolean';
+        case 'long_literal':
+            return 'Long';
+        case 'unsigned_literal':
+            return /l$/i.test(node.text) ? 'ULong' : 'UInt';
+        case 'integer_literal':
+        case 'decimal_integer_literal':
+        case 'hex_integer_literal':
+        case 'octal_integer_literal':
+        case 'binary_integer_literal':
+            return 'Int';
+        case 'real_literal':
+        case 'decimal_floating_point_literal':
+            return /f$/i.test(node.text) ? 'Float' : 'Double';
+        case 'prefix_expression': {
+            const operand = node.namedChildren.at(-1);
+            return operand ? inferredInitializerType(operand) : undefined;
+        }
+        case 'call_expression': {
+            const callee = node.namedChildren.find((child) => child.type === 'simple_identifier');
+            if (!callee)
+                return undefined;
+            const first = callee.text.charAt(0);
+            return first !== '' && first === first.toUpperCase() ? callee.text : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function propertyTypeText(node) {
+    const declarator = node.type === 'class_parameter'
+        ? node
+        : (node.children.find((c) => c.type === 'variable_declaration') ?? node);
+    const colon = declarator.children.find((c) => c.type === ':');
+    let typeNode = colon?.nextNamedSibling ?? null;
+    while (typeNode?.type === 'type_modifiers')
+        typeNode = typeNode.nextNamedSibling;
+    if (typeNode)
+        return typeNode.text;
+    const initializer = node.namedChildren.find((child) => child.id !== declarator.id &&
+        child.type !== 'binding_pattern_kind' &&
+        child.type !== 'modifiers');
+    return initializer ? (inferredInitializerType(initializer) ?? 'unknown') : 'unknown';
+}
+function propertyNameNode(node) {
+    if (node.type === 'class_parameter') {
+        return node.children.find((c) => c.type === 'simple_identifier') ?? null;
+    }
+    const decl = node.children.find((c) => c.type === 'variable_declaration');
+    if (decl) {
+        return decl.children.find((c) => c.type === 'simple_identifier') ?? null;
+    }
+    return node.children.find((c) => c.type === 'simple_identifier') ?? null;
+}
+function accessorMetadata(prop, propertyVisibility, imports) {
+    let getter = propertyVisibility;
+    let setter = propertyVisibility;
+    let skipGetter = false;
+    let skipSetter = false;
+    const propertyModifiers = prop.children.find((c) => c.type === 'modifiers');
+    for (const annotation of propertyModifiers?.namedChildren ?? []) {
+        if (annotation.type !== 'annotation' ||
+            !isKotlinJvmAnnotation(annotation, 'JvmName', imports)) {
+            continue;
+        }
+        const target = annotation.children.find((c) => c.type === 'use_site_target')?.text;
+        if (target === 'get:')
+            skipGetter = true;
+        if (target === 'set:')
+            skipSetter = true;
+    }
+    const apply = (node) => {
+        const modifiers = node.children.find((c) => c.type === 'modifiers');
+        if (!modifiers)
+            return;
+        if (node.type === 'getter')
+            getter = kotlinVisibility(modifiers);
+        if (node.type === 'setter')
+            setter = kotlinVisibility(modifiers);
+        if (modifiers.namedChildren.some((annotation) => isKotlinJvmAnnotation(annotation, 'JvmName', imports))) {
+            if (node.type === 'getter')
+                skipGetter = true;
+            if (node.type === 'setter')
+                skipSetter = true;
+        }
+    };
+    for (const child of prop.children) {
+        if (child.type === 'getter' || child.type === 'setter')
+            apply(child);
+    }
+    let sib = prop.nextNamedSibling;
+    while (sib && (sib.type === 'getter' || sib.type === 'setter')) {
+        apply(sib);
+        sib = sib.nextNamedSibling;
+    }
+    return {
+        getterVisibility: getter,
+        setterVisibility: setter,
+        skipGetter,
+        skipSetter,
+    };
+}
+function hasKotlinAccessorBody(prop, kind) {
+    const hasBody = (node) => node.type === kind && node.children.some((child) => child.type === 'function_body');
+    if (prop.children.some(hasBody))
+        return true;
+    let sib = prop.nextNamedSibling;
+    while (sib && (sib.type === 'getter' || sib.type === 'setter')) {
+        if (hasBody(sib))
+            return true;
+        sib = sib.nextNamedSibling;
+    }
+    return false;
+}
+function functionName(node) {
+    return node.children.find((c) => c.type === 'simple_identifier')?.text;
+}
+function functionArity(node) {
+    const params = node.children.find((c) => c.type === 'function_value_parameters');
+    let arity = node.childForFieldName('receiver') !== null ||
+        node.namedChildren.some((child) => child.type === 'receiver_type')
+        ? 1
+        : 0;
+    const modifiers = node.children.find((child) => child.type === 'modifiers');
+    if (modifiers?.namedChildren.some((child) => child.type === 'function_modifier' && child.text === 'suspend')) {
+        arity += 1;
+    }
+    for (const child of params?.namedChildren ?? []) {
+        if (child.type === 'parameter' || child.type === 'parameter_with_optional_type')
+            arity += 1;
+    }
+    return arity;
+}
+function collectExistingMethods(...bodies) {
+    const index = createExistingMethodIndex('exact');
+    for (const body of bodies) {
+        if (!body)
+            continue;
+        for (const child of body.children) {
+            if (child.type !== 'function_declaration')
+                continue;
+            const name = functionName(child);
+            if (!name)
+                continue;
+            rememberExistingMethod(index, name, functionArity(child));
+        }
+    }
+    return index;
+}
+function toKtProperty(child, imports) {
+    const isVar = isVarBinding(child);
+    if (isVar === null)
+        return null;
+    if (hasJvmField(child, imports) || hasConst(child))
+        return null;
+    const nameNode = propertyNameNode(child);
+    if (!nameNode)
+        return null;
+    const mods = child.children.find((c) => c.type === 'modifiers');
+    const visibility = kotlinVisibility(mods);
+    const accessor = accessorMetadata(child, visibility, imports);
+    return {
+        name: nameNode.text,
+        type: propertyTypeText(child),
+        isVar,
+        skipGetter: accessor.skipGetter,
+        skipSetter: accessor.skipSetter,
+        getterVisibility: accessor.getterVisibility,
+        setterVisibility: accessor.setterVisibility,
+        startLine: child.startPosition.row + 1,
+        endLine: child.endPosition.row + 1,
+        propertyNode: child,
+        declaratorNode: nameNode,
+    };
+}
+function collectTypedProperties(parent, type, imports) {
+    if (!parent)
+        return [];
+    const out = [];
+    for (const child of parent.namedChildren) {
+        if (child.type !== type)
+            continue;
+        const prop = toKtProperty(child, imports);
+        if (prop)
+            out.push(prop);
+    }
+    return out;
+}
+function findKtClasses(root, imports) {
+    const classes = [];
+    const graphOwnerNode = (node) => {
+        if (node.type !== 'companion_object')
+            return node;
+        if (jvmTypeSimpleName(node))
+            return node;
+        let current = node.parent;
+        while (current && !KOTLIN_TYPE_DECLS.has(current.type))
+            current = current.parent;
+        return current ?? node;
+    };
+    const walk = (node) => {
+        if (KOTLIN_TYPE_DECLS.has(node.type)) {
+            const ownerNode = graphOwnerNode(node);
+            const name = jvmTypeSimpleName(ownerNode) ?? '';
+            const ctor = node.children.find((c) => c.type === 'primary_constructor') ?? null;
+            const body = node.children.find((c) => c.type === 'class_body') ?? null;
+            if (name) {
+                const properties = [
+                    ...collectTypedProperties(ctor, 'class_parameter', imports),
+                    ...collectTypedProperties(body, 'property_declaration', imports),
+                ];
+                if (properties.length > 0) {
+                    const ownerBody = ownerNode.id === node.id
+                        ? null
+                        : (ownerNode.children.find((child) => child.type === 'class_body') ?? null);
+                    classes.push({
+                        node: ownerNode,
+                        name,
+                        isStatic: node.type === 'companion_object',
+                        isInterface: node.children.some((child) => child.type === 'interface'),
+                        wasHoisted: ownerNode.id !== node.id,
+                        properties,
+                        existingMethods: collectExistingMethods(body, ownerBody),
+                    });
+                }
+            }
+            if (body) {
+                for (const child of body.namedChildren) {
+                    if (KOTLIN_TYPE_DECLS.has(child.type))
+                        walk(child);
+                }
+            }
+            return;
+        }
+        for (const child of node.namedChildren)
+            walk(child);
+    };
+    walk(root);
+    return classes;
+}
+function planAccessors(cls) {
+    const planned = [];
+    for (const prop of cls.properties) {
+        const gName = kotlinGetterName(prop.name);
+        if (!prop.skipGetter && !hasExistingMethod(cls.existingMethods, gName, 0)) {
+            planned.push({
+                kind: 'getter',
+                name: gName,
+                returnType: prop.type,
+                parameterTypes: [],
+                visibility: prop.getterVisibility,
+                isStatic: cls.isStatic,
+                isAbstract: cls.isInterface && !hasKotlinAccessorBody(prop.propertyNode, 'getter'),
+                startLine: prop.startLine,
+                endLine: prop.endLine,
+                declaratorNode: prop.declaratorNode,
+            });
+        }
+        if (prop.isVar && !prop.skipSetter) {
+            const sName = kotlinSetterName(prop.name);
+            if (!hasExistingMethod(cls.existingMethods, sName, 1)) {
+                planned.push({
+                    kind: 'setter',
+                    name: sName,
+                    returnType: 'void',
+                    parameterTypes: [prop.type],
+                    visibility: prop.setterVisibility,
+                    isStatic: cls.isStatic,
+                    isAbstract: cls.isInterface && !hasKotlinAccessorBody(prop.propertyNode, 'setter'),
+                    startLine: prop.startLine,
+                    endLine: prop.endLine,
+                    declaratorNode: prop.declaratorNode,
+                });
+            }
+        }
+    }
+    return planned;
+}
+function planKotlinAccessorOwners(rootNode) {
+    const owners = [];
+    const imports = collectKotlinImports(rootNode);
+    for (const cls of findKtClasses(rootNode, imports)) {
+        const accessors = planAccessors(cls);
+        const existingIndex = cls.wasHoisted
+            ? owners.findIndex((owner) => owner.node.id === cls.node.id)
+            : -1;
+        const existing = existingIndex >= 0 ? owners[existingIndex] : undefined;
+        if (existing) {
+            owners[existingIndex] = {
+                ...existing,
+                accessors: [...existing.accessors, ...accessors],
+            };
+        }
+        else {
+            owners.push({ node: cls.node, name: cls.name, accessors });
+        }
+    }
+    return owners;
+}
+const lombokAccessorSynthesis = createJvmAccessorSynthesis({
+    language: 'kotlin',
+    synthetic: 'kotlin-jvm',
+    planOwners: planKotlinAccessorOwners,
+});
+export function synthesizeLombokAccessors(tree, filePath, classOwnersById) {
+    return lombokAccessorSynthesis.synthesize(tree, filePath, classOwnersById);
+}
+export function synthesizeLombokAccessorCaptures(rootNode) {
+    return lombokAccessorSynthesis.captures(rootNode);
+}

package/dist/core/ingestion/languages/kotlin/scope-resolver.js

@@ -15,6 +15,8 @@ import { clearKotlinPackageFacts } from './package-facts.js';
 import { attachKotlinSpringDiMetadata } from './spring-di.js';
 import { attachKotlinSpringConditionalMetadata } from './spring-conditionals.js';
 import { attachKotlinSpringNonHttpHandlerMetadata } from './spring-non-http-handlers.js';
+import { attachKotlinSpringConfigBindings } from './spring-config-bindings.js';
+import { attachKotlinSpringDynamicLookup } from './spring-dynamic-lookup.js';
 /**
  * Kotlin scope resolver for RFC #909 Ring 3.
  *
@@ -121,6 +123,8 @@ export const kotlinScopeResolver = {
         attachKotlinSpringConditionalMetadata(graph, parsedFiles, nodeLookup, indexes);
         attachKotlinSpringDiMetadata(graph, parsedFiles, nodeLookup, indexes);
         attachKotlinSpringNonHttpHandlerMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachKotlinSpringDynamicLookup(graph, parsedFiles, nodeLookup, indexes);
+        attachKotlinSpringConfigBindings(graph, parsedFiles, nodeLookup, indexes);
     },
 };
 /**

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

@@ -0,0 +1,4 @@
+import type { DefinitionPropertiesContext, RuntimeSymbolStrategy } from '../../language-provider.js';
+/** Transient graph metadata used only by the same analysis run's runtime import. */
+export declare function extractKotlinRuntimeSymbolProperties(context: DefinitionPropertiesContext): Readonly<Record<string, unknown>> | undefined;
+export declare const kotlinRuntimeSymbolStrategy: RuntimeSymbolStrategy;