cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/kotlin/companion-scopes.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markCompanionScope = markCompanionScope;
+exports.isCompanionScope = isCompanionScope;
+exports.getCompanionScopesForFile = getCompanionScopesForFile;
+exports.clearCompanionScopes = clearCompanionScopes;
+/**
+ * Per-file set of `ScopeId`s that came from a `companion_object` AST node
+ * (issue #1756 / U4 remediation).
+ *
+ * Populated during `emitKotlinScopeCaptures` from the `@scope.companion`
+ * marker capture (see `query.ts`) and consumed by
+ * `populateCompanionMembersOnEnclosingClass` in `owners.ts` to decide
+ * whether to promote a class scope's methods onto its enclosing class.
+ *
+ * The previous `ownedDefs.some(isClassLike)` heuristic in `owners.ts`
+ * silently misclassified two shapes as "regular classes":
+ *   - named companions (`companion object Helper { ... }`) — the `Helper`
+ *     `type_identifier` registered as a class-like def on the companion
+ *     scope, hiding the companion-ness from the heuristic; AND
+ *   - companions containing nested classes (`companion object { class
+ *     Token; fun create() }`) — the nested class def lived on the
+ *     companion scope, again hiding it from the heuristic.
+ *
+ * The marker capture lifts that distinction up to the parser layer
+ * where it is unambiguous (any `companion_object` AST node is a
+ * companion, regardless of what it contains).
+ *
+ * Parallels the C-language pattern in `c/static-linkage.ts`: per-file
+ * `Map<filePath, Set<key>>` side-channel for language-specific def /
+ * scope metadata that does not belong on the shared `Scope` /
+ * `SymbolDefinition` types.
+ *
+ * NOTE: module-level state. `clearCompanionScopes()` is called once per
+ * workspace pass from `kotlinScopeResolver.loadResolutionConfig`, which
+ * the scope-resolution orchestrator awaits before extracting any
+ * `ParsedFile`s for this language (see `pipeline/phase.ts` and the
+ * mirror pattern in `c/scope-resolver.ts` — `clearStaticNames()`). This
+ * keeps server-mode and multi-repo-in-one-process callers safe from
+ * unbounded memory growth and from stale companion-scope ids from a
+ * previous workspace's files. Tests that exercise the captures /
+ * owners modules directly may still need to call `clearCompanionScopes`
+ * themselves (see `test/unit/kotlin-static-marker.test.ts`).
+ */
+const companionScopesByFile = new Map();
+/** Record a scope id as a companion-object scope for the given file. */
+function markCompanionScope(filePath, scopeId) {
+    let scopes = companionScopesByFile.get(filePath);
+    if (scopes === undefined) {
+        scopes = new Set();
+        companionScopesByFile.set(filePath, scopes);
+    }
+    scopes.add(scopeId);
+}
+/** Check whether `scopeId` belongs to a companion-object scope in `filePath`. */
+function isCompanionScope(filePath, scopeId) {
+    return companionScopesByFile.get(filePath)?.has(scopeId) ?? false;
+}
+/**
+ * Snapshot the companion-object scope ids recorded for `filePath` as a plain
+ * array (for the worker→main capture side-channel, #1983). Returns an empty
+ * array when the file recorded no companion scopes. See
+ * `capture-side-channel.ts`.
+ */
+function getCompanionScopesForFile(filePath) {
+    const scopes = companionScopesByFile.get(filePath);
+    return scopes === undefined ? [] : [...scopes];
+}
+/** Clear all tracked companion scopes (for testing). */
+function clearCompanionScopes() {
+    companionScopesByFile.clear();
+}

package/dist/core/code/engine/core/ingestion/languages/kotlin/import-decomposer.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitKotlinImportHeader = splitKotlinImportHeader;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+function splitKotlinImportHeader(importNode) {
+    if (importNode.type !== 'import_header')
+        return null;
+    const spec = parseKotlinImport(importNode);
+    if (spec === null)
+        return null;
+    const out = {
+        '@import.statement': (0, ast_helpers_js_1.nodeToCapture)('@import.statement', importNode),
+        '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', spec.atNode, spec.kind),
+        '@import.source': (0, ast_helpers_js_1.syntheticCapture)('@import.source', spec.atNode, spec.source),
+        '@import.name': (0, ast_helpers_js_1.syntheticCapture)('@import.name', spec.atNode, spec.name),
+    };
+    if (spec.alias !== undefined) {
+        out['@import.alias'] = (0, ast_helpers_js_1.syntheticCapture)('@import.alias', spec.atNode, spec.alias);
+    }
+    return out;
+}
+function parseKotlinImport(node) {
+    const identifier = node.namedChildren.find((child) => child.type === 'identifier');
+    if (identifier === undefined)
+        return null;
+    const source = identifier.text.trim();
+    if (source.length === 0)
+        return null;
+    const hasWildcard = node.namedChildren.some((child) => child.type === 'wildcard_import');
+    if (hasWildcard) {
+        return { kind: 'wildcard', source, name: '*', atNode: node };
+    }
+    const aliasNode = node.namedChildren.find((child) => child.type === 'import_alias');
+    const alias = aliasNode?.namedChildren.find((child) => child.type === 'type_identifier')?.text;
+    const importedName = source.split('.').pop() ?? source;
+    if (alias !== undefined && alias.length > 0) {
+        return { kind: 'alias', source, name: importedName, alias, atNode: node };
+    }
+    return { kind: 'named', source, name: importedName, atNode: node };
+}

package/dist/core/code/engine/core/ingestion/languages/kotlin/import-target.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveKotlinImportTarget = resolveKotlinImportTarget;
+function resolveKotlinImportTarget(parsedImport, workspaceIndex) {
+    const ctx = workspaceIndex;
+    if (ctx === undefined ||
+        typeof ctx.fromFile !== 'string' ||
+        !(ctx.allFilePaths instanceof Set)) {
+        return null;
+    }
+    if (parsedImport.kind === 'dynamic-unresolved')
+        return null;
+    if (parsedImport.targetRaw === null || parsedImport.targetRaw === '')
+        return null;
+    const target = parsedImport.targetRaw.endsWith('.*')
+        ? parsedImport.targetRaw.slice(0, -2)
+        : parsedImport.targetRaw;
+    const pathLike = target.replace(/\./g, '/');
+    // Resolution tiers, most-specific first:
+    //  1. The full `pathLike` matches a `.kt`/`.kts` file directly
+    //     (`import util.User` → `util/User.kt`).
+    //  2. Stripped (last-segment removed) `pathLike` matches a file
+    //     directly (`import util.OneArg.writeAudit` → `util/OneArg.kt`,
+    //     a class-or-object holding `writeAudit`).
+    //  3. Stripped `pathLike` matches a *package directory* — fan out to
+    //     every `.kt`/`.kts` file inside it (`import models.getRepo` →
+    //     `[models/User.kt, models/Repo.kt]`). The finalize pass walks
+    //     each candidate and picks the one whose `localDefs` actually
+    //     export the imported name (#1759).
+    //  4. Progressive prefix strip for deeper namespace aliases that
+    //     don't map 1:1 to directories.
+    const stripped = pathLike.split('/').slice(0, -1).join('/');
+    return (findKotlinFile(ctx.allFilePaths, pathLike) ??
+        findKotlinExactOrSuffix(ctx.allFilePaths, stripped) ??
+        findKotlinPackageFiles(ctx.allFilePaths, stripped) ??
+        findByProgressivePrefixStrip(ctx.allFilePaths, pathLike));
+}
+function findKotlinFile(allFilePaths, pathLike) {
+    return (findKotlinExactOrSuffix(allFilePaths, pathLike) ??
+        findKotlinDirectoryChild(allFilePaths, pathLike));
+}
+/** Exact (`file === pathLike+ext`) or suffix (`file ends with /pathLike+ext`)
+ *  match — does NOT fall back to picking an arbitrary file inside a
+ *  `pathLike/` directory. Used by the stripped-path tier in
+ *  `resolveKotlinImportTarget` so a package import like `models.getRepo`
+ *  delegates to `findKotlinPackageFiles` (multi-file fan-out) instead of
+ *  silently committing to the first directory child. */
+function findKotlinExactOrSuffix(allFilePaths, pathLike) {
+    if (pathLike === '')
+        return null;
+    const extensions = ['.kt', '.kts'];
+    const suffix = `/${pathLike}`;
+    let suffixFile = null;
+    for (const raw of allFilePaths) {
+        const file = raw.replace(/\\/g, '/');
+        if (!extensions.some((ext) => file.endsWith(ext)))
+            continue;
+        for (const ext of extensions) {
+            if (file === `${pathLike}${ext}`)
+                return raw;
+            if (suffixFile === null && file.endsWith(`${suffix}${ext}`))
+                suffixFile = raw;
+        }
+    }
+    return suffixFile;
+}
+/** First directory child of `pathLike/` — preserves the legacy single-
+ *  file fallback for cases where `pathLike` itself is an unqualified
+ *  package reference (rare in real Kotlin code; some fixtures rely on
+ *  it). Multi-file package fan-out goes through
+ *  `findKotlinPackageFiles` instead. */
+function findKotlinDirectoryChild(allFilePaths, pathLike) {
+    if (pathLike === '')
+        return null;
+    const extensions = ['.kt', '.kts'];
+    const dirPrefix = `${pathLike}/`;
+    const suffixDirPrefix = `/${dirPrefix}`;
+    for (const raw of allFilePaths) {
+        const file = raw.replace(/\\/g, '/');
+        if (!extensions.some((ext) => file.endsWith(ext)))
+            continue;
+        const atRoot = file.startsWith(dirPrefix);
+        const atNested = file.includes(suffixDirPrefix);
+        if (!atRoot && !atNested)
+            continue;
+        const idx = atRoot ? 0 : file.indexOf(suffixDirPrefix) + 1;
+        const after = file.slice(idx + dirPrefix.length);
+        if (after.length > 0 && !after.includes('/'))
+            return raw;
+    }
+    return null;
+}
+/**
+ * Return every `.kt`/`.kts` file inside the package directory `dirPath`
+ * (e.g. `models` → `['models/User.kt', 'models/Repo.kt']`). Used as a
+ * fallback when an import like `models.getRepo` does not resolve to a
+ * file named after the symbol — in Kotlin the symbol can live in any
+ * file inside the package directory. The finalize pass walks each
+ * candidate and picks the one whose `localDefs` actually export the
+ * imported name (#1759).
+ */
+function findKotlinPackageFiles(allFilePaths, dirPath) {
+    if (dirPath === '')
+        return null;
+    const extensions = ['.kt', '.kts'];
+    const dirPrefix = `${dirPath}/`;
+    const suffixDirPrefix = `/${dirPrefix}`;
+    const out = [];
+    for (const raw of allFilePaths) {
+        const file = raw.replace(/\\/g, '/');
+        if (!extensions.some((ext) => file.endsWith(ext)))
+            continue;
+        const atRoot = file.startsWith(dirPrefix);
+        const atNested = file.includes(suffixDirPrefix);
+        if (!atRoot && !atNested)
+            continue;
+        const idx = atRoot ? 0 : file.indexOf(suffixDirPrefix) + 1;
+        const after = file.slice(idx + dirPrefix.length);
+        // Direct children only — `models/sub/Util.kt` is a different package
+        // (`models.sub`) and must not be merged with `models`.
+        if (after.length === 0 || after.includes('/'))
+            continue;
+        out.push(raw);
+    }
+    return out.length === 0 ? null : out;
+}
+function findByProgressivePrefixStrip(allFilePaths, pathLike) {
+    const segments = pathLike.split('/').filter(Boolean);
+    for (let skip = 1; skip < segments.length; skip++) {
+        const found = findKotlinFile(allFilePaths, segments.slice(skip).join('/'));
+        if (found !== null)
+            return found;
+    }
+    return null;
+}

package/dist/core/code/engine/core/ingestion/languages/kotlin/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kotlinReceiverBinding = exports.kotlinImportOwningScope = exports.kotlinBindingScopeFor = exports.populateKotlinOwners = exports.kotlinMergeBindings = exports.resolveKotlinImportTarget = exports.kotlinArityCompatibility = exports.interpretKotlinTypeBinding = exports.interpretKotlinImport = exports.resetKotlinCaptureCacheStats = exports.getKotlinCaptureCacheStats = exports.applyKotlinCaptureSideChannel = exports.collectKotlinCaptureSideChannel = exports.emitKotlinScopeCaptures = void 0;
+var captures_js_1 = require("./captures.js");
+Object.defineProperty(exports, "emitKotlinScopeCaptures", { enumerable: true, get: function () { return captures_js_1.emitKotlinScopeCaptures; } });
+var capture_side_channel_js_1 = require("./capture-side-channel.js");
+Object.defineProperty(exports, "collectKotlinCaptureSideChannel", { enumerable: true, get: function () { return capture_side_channel_js_1.collectKotlinCaptureSideChannel; } });
+Object.defineProperty(exports, "applyKotlinCaptureSideChannel", { enumerable: true, get: function () { return capture_side_channel_js_1.applyKotlinCaptureSideChannel; } });
+var cache_stats_js_1 = require("./cache-stats.js");
+Object.defineProperty(exports, "getKotlinCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.getKotlinCaptureCacheStats; } });
+Object.defineProperty(exports, "resetKotlinCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.resetKotlinCaptureCacheStats; } });
+var interpret_js_1 = require("./interpret.js");
+Object.defineProperty(exports, "interpretKotlinImport", { enumerable: true, get: function () { return interpret_js_1.interpretKotlinImport; } });
+Object.defineProperty(exports, "interpretKotlinTypeBinding", { enumerable: true, get: function () { return interpret_js_1.interpretKotlinTypeBinding; } });
+var arity_js_1 = require("./arity.js");
+Object.defineProperty(exports, "kotlinArityCompatibility", { enumerable: true, get: function () { return arity_js_1.kotlinArityCompatibility; } });
+var import_target_js_1 = require("./import-target.js");
+Object.defineProperty(exports, "resolveKotlinImportTarget", { enumerable: true, get: function () { return import_target_js_1.resolveKotlinImportTarget; } });
+var merge_bindings_js_1 = require("./merge-bindings.js");
+Object.defineProperty(exports, "kotlinMergeBindings", { enumerable: true, get: function () { return merge_bindings_js_1.kotlinMergeBindings; } });
+var owners_js_1 = require("./owners.js");
+Object.defineProperty(exports, "populateKotlinOwners", { enumerable: true, get: function () { return owners_js_1.populateKotlinOwners; } });
+var simple_hooks_js_1 = require("./simple-hooks.js");
+Object.defineProperty(exports, "kotlinBindingScopeFor", { enumerable: true, get: function () { return simple_hooks_js_1.kotlinBindingScopeFor; } });
+Object.defineProperty(exports, "kotlinImportOwningScope", { enumerable: true, get: function () { return simple_hooks_js_1.kotlinImportOwningScope; } });
+Object.defineProperty(exports, "kotlinReceiverBinding", { enumerable: true, get: function () { return simple_hooks_js_1.kotlinReceiverBinding; } });

package/dist/core/code/engine/core/ingestion/languages/kotlin/interpret.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpretKotlinImport = interpretKotlinImport;
+exports.interpretKotlinTypeBinding = interpretKotlinTypeBinding;
+exports.normalizeKotlinType = normalizeKotlinType;
+function interpretKotlinImport(captures) {
+    const kind = captures['@import.kind']?.text;
+    const source = captures['@import.source']?.text;
+    const name = captures['@import.name']?.text;
+    if (kind === undefined || source === undefined)
+        return null;
+    switch (kind) {
+        case 'named':
+            return {
+                kind: 'named',
+                localName: name ?? source.split('.').pop() ?? source,
+                importedName: name ?? source.split('.').pop() ?? source,
+                targetRaw: source,
+            };
+        case 'alias': {
+            const alias = captures['@import.alias']?.text;
+            if (alias === undefined || name === undefined)
+                return null;
+            return {
+                kind: 'alias',
+                localName: alias,
+                importedName: name,
+                alias,
+                targetRaw: source,
+            };
+        }
+        case 'wildcard':
+            return { kind: 'wildcard', targetRaw: source.endsWith('.*') ? source : `${source}.*` };
+        default:
+            return null;
+    }
+}
+function interpretKotlinTypeBinding(captures) {
+    const nameCap = captures['@type-binding.name'];
+    const typeCap = captures['@type-binding.type'];
+    if (nameCap === undefined || typeCap === undefined)
+        return null;
+    let source = 'annotation';
+    if (captures['@type-binding.self'] !== undefined)
+        source = 'self';
+    else if (captures['@type-binding.parameter'] !== undefined)
+        source = 'parameter-annotation';
+    else if (captures['@type-binding.return'] !== undefined)
+        source = 'return-annotation';
+    else if (captures['@type-binding.constructor'] !== undefined)
+        source = 'constructor-inferred';
+    return {
+        boundName: nameCap.text,
+        rawTypeName: normalizeKotlinType(typeCap.text),
+        source,
+    };
+}
+function normalizeKotlinType(text) {
+    let out = text.trim();
+    while (out.endsWith('?'))
+        out = out.slice(0, -1).trim();
+    const lastDot = out.lastIndexOf('.');
+    if (lastDot >= 0)
+        out = out.slice(lastDot + 1);
+    const collection = out.match(/^(?:List|MutableList|ArrayList|Set|MutableSet|Collection|Iterable|Sequence|Array)<([^,<>]+)>$/);
+    if (collection !== null)
+        return normalizeKotlinType(collection[1]);
+    const map = out.match(/^(?:Map|MutableMap|HashMap|LinkedHashMap)<[^,<>]+,\s*([^,<>]+)>$/);
+    if (map !== null)
+        return normalizeKotlinType(map[1]);
+    const erased = out.match(/^([A-Za-z_][A-Za-z0-9_]*)<.+>$/s);
+    if (erased !== null)
+        return erased[1];
+    return out;
+}

package/dist/core/code/engine/core/ingestion/languages/kotlin/merge-bindings.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kotlinMergeBindings = kotlinMergeBindings;
+function tierOf(binding) {
+    switch (binding.origin) {
+        case 'local':
+            return 0;
+        case 'import':
+        case 'namespace':
+        case 'reexport':
+            return 1;
+        case 'wildcard':
+            return 2;
+        default:
+            return 3;
+    }
+}
+function kotlinMergeBindings(bindings) {
+    if (bindings.length === 0)
+        return bindings;
+    const best = Math.min(...bindings.map(tierOf));
+    const seen = new Map();
+    for (const binding of bindings) {
+        if (tierOf(binding) === best)
+            seen.set(binding.def.nodeId, binding);
+    }
+    return [...seen.values()];
+}

package/dist/core/code/engine/core/ingestion/languages/kotlin/owners.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKotlinStaticOnly = isKotlinStaticOnly;
+exports.populateKotlinOwners = populateKotlinOwners;
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+const companion_scopes_js_1 = require("./companion-scopes.js");
+/** Module-level identity-based marker for companion-promoted Kotlin
+ *  method defs (the "this member can only be dispatched through the
+ *  class name" set). Parallels the C language `static-linkage.ts`
+ *  side-channel pattern but uses a WeakSet because the mark is
+ *  per-def (no per-name keying needed). Eliminates the cast-and-
+ *  mutate pattern the previous marker implementation required,
+ *  removes any serialization-survival risk surface, and keeps the
+ *  Kotlin-specific metadata off the shared `SymbolDefinition` type. */
+const KOTLIN_STATIC_DEFS = new WeakSet();
+function isKotlinStaticOnly(def) {
+    return KOTLIN_STATIC_DEFS.has(def);
+}
+function populateKotlinOwners(parsed) {
+    (0, walkers_js_1.populateClassOwnedMembers)(parsed);
+    populateCompanionMembersOnEnclosingClass(parsed);
+    upgradeClassOwnedFunctionsToMethods(parsed);
+}
+/**
+ * Align scope-resolution `def.type` with the graph's node-label
+ * conventions: a `Function` def that lives inside a class body becomes
+ * a `Method`. The Kotlin extractor labels every `function_declaration`
+ * as `Function`, but the graph parsing-processor emits a `Method`
+ * graph-node label for class members. Without this realignment,
+ * `resolveDefGraphId`'s parameter-typed key lookup (gated on
+ * `def.type === 'Method'`) falls through to the simple-name fallback
+ * for class methods, collapsing same-name same-arity overloads onto
+ * the first-registered node (#1761).
+ *
+ * Only Method-bearing types are touched. Methods have a class owner
+ * (set by `populateClassOwnedMembers`) and a class-qualified name.
+ */
+function upgradeClassOwnedFunctionsToMethods(parsed) {
+    for (const def of parsed.localDefs) {
+        if (def.type !== 'Function')
+            continue;
+        if (def.ownerId === undefined)
+            continue;
+        def.type = 'Method';
+    }
+}
+function populateCompanionMembersOnEnclosingClass(parsed) {
+    const scopesById = new Map();
+    for (const scope of parsed.scopes)
+        scopesById.set(scope.id, scope);
+    for (const scope of parsed.scopes) {
+        if (scope.kind !== 'Function' || scope.parent === null)
+            continue;
+        const parent = scopesById.get(scope.parent);
+        if (parent === undefined || parent.kind !== 'Class')
+            continue;
+        // Identify companion-object scopes via the `@scope.companion` marker
+        // capture (see captures.ts / companion-scopes.ts) rather than via
+        // the old `parent.ownedDefs.some(isClassLike)` heuristic. The
+        // heuristic silently bypassed two real shapes (#1756 / U4):
+        //   - named companions (`companion object Helper { ... }`) — `Helper`
+        //     registered as a class-like def on the companion scope; AND
+        //   - companions containing nested classes (`companion object {
+        //     class Token; fun create() }`) — the nested class lived on
+        //     the companion scope.
+        // Both bypasses left companion methods unpromoted and unmarked,
+        // breaking class-name dispatch (`Outer.create()`) and crossover
+        // suppression (`outer.create()`) for those shapes. The marker
+        // capture lifts the distinction to the parser layer where any
+        // `companion_object` AST node is a companion, full stop.
+        if (!(0, companion_scopes_js_1.isCompanionScope)(parsed.filePath, parent.id))
+            continue;
+        const enclosing = findEnclosingClassWithDef(parent.parent, scopesById);
+        if (enclosing === undefined)
+            continue;
+        for (const def of scope.ownedDefs) {
+            // Class-like defs nested inside the companion's methods (rare —
+            // would be a local class declared inside a fun-body) are not
+            // companion members and must not be promoted. The companion's
+            // direct nested classes live in their OWN scope's ownedDefs
+            // (NOT the function-scope ownedDefs we iterate here), so this
+            // guard is defense-in-depth.
+            if ((0, walkers_js_1.isClassLike)(def.type))
+                continue;
+            // OVERRIDE rather than skip-when-set: for named companions,
+            // `populateClassOwnedMembers` already set `ownerId = Helper`
+            // (the named-companion class-like def). That is the WRONG
+            // owner — companion methods are dispatched through the
+            // enclosing outer class, not through the companion's own
+            // type name. Overwriting restores the intended ownership.
+            def.ownerId = enclosing.nodeId;
+            // Mark as static-only so `ScopeResolver.isStaticOnly` (see
+            // `isKotlinStaticOnly`) can filter these out of instance-receiver
+            // dispatch (#1756). Promoting the companion method onto the
+            // outer class lets `Foo.companionMethod()` resolve via Case 2;
+            // without this marker, `fooInstance.companionMethod()` would
+            // ALSO resolve to it via Case 4, which is incorrect (and a
+            // compile error in real Kotlin).
+            KOTLIN_STATIC_DEFS.add(def);
+            qualify(def, enclosing);
+        }
+    }
+}
+function findEnclosingClassWithDef(start, scopesById) {
+    let current = start;
+    while (current !== null) {
+        const scope = scopesById.get(current);
+        if (scope === undefined)
+            return undefined;
+        if (scope.kind === 'Class') {
+            const classDef = scope.ownedDefs.find((def) => (0, walkers_js_1.isClassLike)(def.type));
+            if (classDef !== undefined)
+                return classDef;
+        }
+        current = scope.parent;
+    }
+    return undefined;
+}
+function qualify(def, owner) {
+    if (def.qualifiedName === undefined)
+        return;
+    if (owner.qualifiedName === undefined || owner.qualifiedName.length === 0)
+        return;
+    // For named companions, `populateClassOwnedMembers` qualified the
+    // def as `Helper.create`. Strip the companion-class prefix and
+    // re-qualify with the outer class so the graph-bridge lookup keys
+    // resolve to `Outer.create` rather than the spurious `Helper.create`.
+    // For unqualified defs (the anonymous-companion path), the simple
+    // name is unchanged — `populateClassOwnedMembers` found no class-like
+    // def in the anonymous companion scope, so the prior pass left the
+    // simple name in place.
+    const simple = def.qualifiedName.split('.').pop() ?? def.qualifiedName;
+    def.qualifiedName = `${owner.qualifiedName}.${simple}`;
+}

package/dist/core/code/engine/core/ingestion/languages/kotlin/package-facts.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKotlinPackageFact = exports.setKotlinPackageFact = exports.captureKotlinPackageFact = exports.clearKotlinPackageFacts = void 0;
+const package_facts_js_1 = require("../jvm/package-facts.js");
+const kotlinPackageFacts = (0, package_facts_js_1.createJvmPackageFactStore)({
+    packageNodeType: 'package_header',
+    packageNameNodeTypes: ['identifier'],
+});
+const clearKotlinPackageFacts = () => kotlinPackageFacts.clear();
+exports.clearKotlinPackageFacts = clearKotlinPackageFacts;
+const captureKotlinPackageFact = (filePath, root) => kotlinPackageFacts.capture(filePath, root);
+exports.captureKotlinPackageFact = captureKotlinPackageFact;
+const setKotlinPackageFact = (filePath, fact) => kotlinPackageFacts.set(filePath, fact);
+exports.setKotlinPackageFact = setKotlinPackageFact;
+const getKotlinPackageFact = (filePath) => kotlinPackageFacts.get(filePath);
+exports.getKotlinPackageFact = getKotlinPackageFact;

package/dist/core/code/engine/core/ingestion/languages/kotlin/package-siblings.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKotlinPackageSiblingVisibilityIncomplete = exports.populateKotlinPackageSiblings = void 0;
+const package_siblings_js_1 = require("../jvm/package-siblings.js");
+const package_facts_js_1 = require("./package-facts.js");
+const kotlinPackageSiblingVisibility = (0, package_siblings_js_1.createJvmPackageSiblingVisibility)({
+    languageLabel: 'kotlin',
+    getPackageFact: package_facts_js_1.getKotlinPackageFact,
+});
+exports.populateKotlinPackageSiblings = kotlinPackageSiblingVisibility.populateNamespaceSiblings;
+exports.isKotlinPackageSiblingVisibilityIncomplete = kotlinPackageSiblingVisibility.isVisibilityIncomplete;