cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/javascript/scope-resolver.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * JavaScript `ScopeResolver` registered in `SCOPE_RESOLVERS` and
+ * consumed by the generic `runScopeResolution` orchestrator
+ * (RFC #909 Ring 3, issue #928).
+ *
+ * Follows the same minimal wiring-only pattern as TypeScript (the third
+ * migration). Per-hook logic lives in sibling modules:
+ *
+ *   - `query.ts`          — JS scope query + parser/query singletons
+ *   - `captures.ts`       — `emitJsScopeCaptures` (JS grammar, CJS, JSDoc)
+ *   - `interpret.ts`      — `interpretJsImport` (delegates to TS interpreter)
+ *   - `simple-hooks.ts`   — `jsBindingScopeFor`, `jsImportOwningScope`,
+ *                           `jsReceiverBinding` (all delegate to TS hooks)
+ *   - `merge-bindings.ts` — `jsMergeBindings` (delegates to TS function)
+ *   - `arity.ts`          — `jsArityCompatibility` (delegates to TS function)
+ *   - `import-target.ts`  — `makeJsResolveImportTarget` (TS resolver, JS extensions)
+ *
+ * See `./index.ts` for the full per-module rationale.
+ *
+ * ## Key differences from TypeScript resolver
+ *
+ *   - `fieldFallbackOnMethodLookup: true` — JavaScript is dynamically typed;
+ *     the field-fallback heuristic is ENABLED (unlike TypeScript, which
+ *     disables it because the type-binding layer is precise).
+ *   - `allowGlobalFreeCallFallback: true` — CJS `require` patterns and
+ *     global helpers (e.g. `process`, `console`) benefit from workspace-
+ *     wide unique-name fallback. TypeScript uses explicit imports.
+ *   - `loadResolutionConfig` is omitted — JavaScript projects don't use
+ *     `tsconfig.json` path aliases in general. `tsconfigPaths: null` is
+ *     threaded through the resolver adapter.
+ *   - `hoistTypeBindingsToModule: true` — JSDoc `@returns {T}` bindings are
+ *     synthesized on the function scope and hoisted, matching TypeScript's
+ *     method return-type hoisting strategy for cross-file chain resolution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javascriptScopeResolver = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const mro_js_1 = require("../../scope-resolution/passes/mro.js");
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+const typescript_js_1 = require("../typescript.js");
+const merge_bindings_js_1 = require("./merge-bindings.js");
+const arity_js_1 = require("./arity.js");
+const import_target_js_1 = require("./import-target.js");
+const javascriptScopeResolver = {
+    // Construction is keyword-prefixed: `new Service(db).doWork()` (#2708).
+    constructionSyntax: { keyword: 'new' },
+    language: index_js_1.SupportedLanguages.JavaScript,
+    languageProvider: typescript_js_1.javascriptProvider,
+    importEdgeReason: 'javascript-scope: import',
+    resolveImportTarget: (0, import_target_js_1.makeJsResolveImportTarget)(),
+    // JavaScript LEGB — same tier ordering as TypeScript; no declaration-
+    // merging across type/value/namespace spaces.
+    mergeBindings: (existing, incoming) => [...(0, merge_bindings_js_1.jsMergeBindings)([...existing, ...incoming])],
+    // Adapter: jsArityCompatibility uses (def, callsite); contract is (callsite, def).
+    arityCompatibility: (callsite, def) => (0, arity_js_1.jsArityCompatibility)(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => (0, mro_js_1.buildMro)(graph, parsedFiles, nodeLookup, mro_js_1.defaultLinearize),
+    populateOwners: (parsed) => (0, walkers_js_1.populateClassOwnedMembers)(parsed),
+    // JavaScript `super` keyword: same pattern as TypeScript.
+    isSuperReceiver: (text) => /^super(\s*\(|\s*\.|\s*\[|\s*$)/.test(text.trim()),
+    // JavaScript is dynamically typed — enable the field-fallback heuristic
+    // so member-call receivers without type annotations can still resolve
+    // through declared class fields (e.g. JSDoc-typed fields).
+    fieldFallbackOnMethodLookup: true,
+    // Return-type propagation (across ESM imports) mirrors TypeScript's
+    // default behavior. JSDoc @returns bindings are hoisted to Module scope
+    // and propagated to importers via the standard mechanism.
+    propagatesReturnTypesAcrossImports: true,
+    // JSDoc @returns bindings are synthesized on the function/method node
+    // and hoisted to Module scope by `jsBindingScopeFor` (identical to the
+    // TypeScript `tsBindingScopeFor` `@type-binding.return` branch).
+    hoistTypeBindingsToModule: true,
+    // CJS-heavy codebases often have utility functions exported without
+    // explicit imports at the call site. Workspace-wide unique-name fallback
+    // recovers these edges.
+    allowGlobalFreeCallFallback: true,
+};
+exports.javascriptScopeResolver = javascriptScopeResolver;

package/dist/core/code/engine/core/ingestion/languages/javascript/simple-hooks.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Simple hooks for the JavaScript scope-resolution provider.
+ *
+ * `jsBindingScopeFor` wraps `tsBindingScopeFor` and adds the JS-only
+ * `@type-binding.class-field` hoisting rule.  The other two hooks
+ * (`jsImportOwningScope`, `jsReceiverBinding`) are identical to their
+ * TypeScript counterparts and are re-exported directly.
+ *
+ * ## Why class-field hoisting lives here (not in `tsBindingScopeFor`)
+ *
+ * `@type-binding.class-field` is emitted exclusively by
+ * `synthesizeConstructorFieldBindings` in `captures.ts`, which is a
+ * JavaScript-only synthesis pass.  TypeScript uses
+ * `@type-binding.parameter-property` for constructor parameter
+ * properties instead.  Keeping the JS-only rule in the JS hook file
+ * prevents language-specific logic from leaking into shared TypeScript
+ * infrastructure (DoD.md §2.2).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsReceiverBinding = exports.jsImportOwningScope = void 0;
+exports.jsBindingScopeFor = jsBindingScopeFor;
+const scope_tree_walk_js_1 = require("../../utils/scope-tree-walk.js");
+const simple_hooks_js_1 = require("../typescript/simple-hooks.js");
+var simple_hooks_js_2 = require("../typescript/simple-hooks.js");
+Object.defineProperty(exports, "jsImportOwningScope", { enumerable: true, get: function () { return simple_hooks_js_2.tsImportOwningScope; } });
+Object.defineProperty(exports, "jsReceiverBinding", { enumerable: true, get: function () { return simple_hooks_js_2.tsReceiverBinding; } });
+/**
+ * Like `tsBindingScopeFor` but additionally hoists
+ * `@type-binding.class-field` captures to the enclosing Class scope.
+ *
+ * `@type-binding.class-field` is anchored inside the constructor body
+ * (by `synthesizeConstructorFieldBindings`) so that `walkToScope` can
+ * walk up from the Function (constructor) scope to the Class scope.
+ * This puts `User.address → Address` in the class's typeBindings so
+ * compound-receiver resolution finds it when resolving
+ * `user.address.save()`.
+ */
+function jsBindingScopeFor(decl, innermost, tree) {
+    if (decl['@type-binding.class-field'] !== undefined) {
+        return (0, scope_tree_walk_js_1.walkToScope)(innermost, tree, 'Class');
+    }
+    return (0, simple_hooks_js_1.tsBindingScopeFor)(decl, innermost, tree);
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNKNOWN_JVM_PACKAGE_FACT = void 0;
+exports.isJvmPackageFact = isJvmPackageFact;
+exports.createJvmPackageFactStore = createJvmPackageFactStore;
+exports.extractJvmPackageFact = extractJvmPackageFact;
+exports.UNKNOWN_JVM_PACKAGE_FACT = Object.freeze({ status: 'unknown' });
+/** Validate a package fact restored from an opaque worker payload. */
+function isJvmPackageFact(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const fact = value;
+    return (fact.status === 'unknown' || (fact.status === 'known' && typeof fact.packageName === 'string'));
+}
+/**
+ * Create one language-local package fact store.
+ *
+ * Package facts are captured while the language's scope extractor already
+ * owns a tree-sitter Tree, then serialized through ParsedFile's side-channel.
+ * Resolution hooks consume only this plain data and never parse source again.
+ */
+function createJvmPackageFactStore(options) {
+    const factsByFile = new Map();
+    return {
+        clear: () => factsByFile.clear(),
+        capture: (filePath, root) => factsByFile.set(filePath, extractJvmPackageFact(root, options)),
+        set: (filePath, fact) => factsByFile.set(filePath, fact),
+        get: (filePath) => factsByFile.get(filePath),
+    };
+}
+function extractJvmPackageFact(root, options) {
+    const packageNode = root.namedChildren.find((child) => child.type === options.packageNodeType);
+    if (packageNode === undefined) {
+        // A syntax error elsewhere in a default-package file does not make its
+        // package ambiguous. Only a top-level ERROR that contains the reserved
+        // package keyword is evidence of a malformed package header.
+        const malformedHeader = root.namedChildren.some((child) => child.type === 'ERROR' && /\bpackage\b/.test(child.text));
+        return malformedHeader ? exports.UNKNOWN_JVM_PACKAGE_FACT : { status: 'known', packageName: '' };
+    }
+    const nameNode = packageNode.namedChildren.find((child) => options.packageNameNodeTypes.includes(child.type));
+    const packageName = nameNode?.text.trim();
+    if (packageNode.hasError || packageName === undefined || packageName.length === 0) {
+        return exports.UNKNOWN_JVM_PACKAGE_FACT;
+    }
+    return { status: 'known', packageName };
+}

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

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJvmPackageSiblingVisibility = createJvmPackageSiblingVisibility;
+const logger_js_1 = require("../../../logger.js");
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+/** Packages larger than this get no implicit sibling visibility at all — every
+ *  file in them is marked incomplete. `CGRAPH_MAX_INJECTED_SIBLINGS` bounds
+ *  injection *within* a package and does not lift this skip. */
+const MAX_PACKAGE_FILES = 500;
+const DEFAULT_MAX_INJECTED_SIBLINGS = 200;
+function getMaxInjectedSiblings() {
+    const raw = process.env.CGRAPH_MAX_INJECTED_SIBLINGS;
+    if (raw === undefined || raw === '')
+        return DEFAULT_MAX_INJECTED_SIBLINGS;
+    const parsed = Number(raw);
+    return Number.isInteger(parsed) && parsed >= 0 ? parsed : DEFAULT_MAX_INJECTED_SIBLINGS;
+}
+function createJvmPackageSiblingVisibility(options) {
+    const incompleteFiles = new Set();
+    function populateNamespaceSiblings(parsedFiles, indexes, ctx) {
+        incompleteFiles.clear();
+        const buckets = new Map();
+        const unknownPackageFiles = new Set();
+        const parsedPaths = new Set(parsedFiles.map((parsed) => parsed.filePath));
+        // A file that failed scope extraction has no ParsedFile or side-channel,
+        // but it may still declare a shadowing type in any package. Keep its source
+        // path in the uncertainty set without re-parsing it on the main thread.
+        for (const filePath of ctx.fileContents.keys()) {
+            if (!parsedPaths.has(filePath))
+                unknownPackageFiles.add(filePath);
+        }
+        for (const parsed of parsedFiles) {
+            const packageFact = options.getPackageFact(parsed.filePath);
+            if (!ctx.fileContents.has(parsed.filePath) || packageFact?.status !== 'known') {
+                incompleteFiles.add(parsed.filePath);
+                unknownPackageFiles.add(parsed.filePath);
+                continue;
+            }
+            const packageName = packageFact.packageName;
+            const bucket = buckets.get(packageName) ?? { parsed: [], moduleScopes: [] };
+            buckets.set(packageName, bucket);
+            bucket.parsed.push(parsed);
+            const moduleScope = parsed.scopes.find((scope) => scope.kind === 'Module');
+            if (moduleScope !== undefined) {
+                bucket.moduleScopes.push({ filePath: parsed.filePath, scope: moduleScope });
+            }
+        }
+        // A file whose package cannot be proven may shadow a wildcard-imported
+        // type in any package. Conservatively disable wildcard attribution for the
+        // language workspace while leaving explicit/FQN imports available.
+        if (unknownPackageFiles.size > 0) {
+            for (const parsed of parsedFiles)
+                incompleteFiles.add(parsed.filePath);
+            logger_js_1.logger.warn(`[${options.languageLabel}-package-siblings] ${unknownPackageFiles.size} file(s) lacked reliable package facts; wildcard attribution disabled for this language workspace`);
+        }
+        const augmentations = indexes.bindingAugmentations;
+        const maxInjectedSiblings = getMaxInjectedSiblings();
+        let truncatedFiles = 0;
+        for (const bucket of buckets.values()) {
+            if (bucket.moduleScopes.length < 2)
+                continue;
+            if (bucket.moduleScopes.length > MAX_PACKAGE_FILES) {
+                for (const parsed of bucket.parsed)
+                    incompleteFiles.add(parsed.filePath);
+                logger_js_1.logger.warn(`[${options.languageLabel}-package-siblings] skipping package with ${bucket.moduleScopes.length} files (cap=${MAX_PACKAGE_FILES}); same-package implicit visibility disabled for this package`);
+                continue;
+            }
+            const classDefs = [];
+            for (const parsed of bucket.parsed) {
+                const moduleScopeId = parsed.scopes.find((scope) => scope.kind === 'Module')?.id;
+                for (const scope of parsed.scopes) {
+                    if (scope.kind !== 'Class' || scope.parent !== moduleScopeId)
+                        continue;
+                    const def = scope.ownedDefs.find((candidate) => (0, walkers_js_1.isClassLike)(candidate.type));
+                    if (def !== undefined)
+                        classDefs.push({ def, filePath: parsed.filePath });
+                }
+            }
+            // Per-bucket lookups: the per-file loop below is O(files²) over these,
+            // so split each path into segments once here instead of re-splitting it
+            // on every pairwise proximity comparison, and address siblings by path
+            // so a truncated scope can merge its bounded set without rescanning the
+            // whole package.
+            const segmentsByPath = new Map();
+            const moduleScopeByPath = new Map();
+            const parsedByPath = new Map();
+            for (const parsed of bucket.parsed) {
+                segmentsByPath.set(parsed.filePath, pathSegments(parsed.filePath));
+                parsedByPath.set(parsed.filePath, parsed);
+            }
+            for (const sibling of bucket.moduleScopes)
+                moduleScopeByPath.set(sibling.filePath, sibling);
+            const allSiblingPaths = [...parsedByPath.keys()];
+            for (const { filePath, scope } of bucket.moduleScopes) {
+                let scopeAug = augmentations.get(scope.id);
+                if (scopeAug === undefined) {
+                    scopeAug = new Map();
+                    augmentations.set(scope.id, scopeAug);
+                }
+                const ownSegments = segmentsByPath.get(filePath) ?? pathSegments(filePath);
+                const proximityCache = new Map();
+                const candidates = classDefs.filter((candidate) => candidate.filePath !== filePath);
+                for (const candidate of candidates) {
+                    if (!proximityCache.has(candidate.filePath)) {
+                        proximityCache.set(candidate.filePath, sharedSegmentCount(segmentsByPath.get(candidate.filePath) ?? [], ownSegments));
+                    }
+                }
+                // Nearest-first by shared path prefix. Ties (the common case in a flat
+                // package, where every sibling shares the same directory) keep the
+                // walker's traversal order, so the retained set is deterministic but
+                // arbitrary among equally-near candidates — which is why truncation
+                // marks the file incomplete below rather than being treated as exact.
+                candidates.sort((a, b) => (proximityCache.get(b.filePath) ?? 0) - (proximityCache.get(a.filePath) ?? 0));
+                const injectedIds = new Set();
+                const injectedPaths = new Set();
+                let truncated = false;
+                for (const { def, filePath: defPath } of candidates) {
+                    if (injectedIds.has(def.nodeId) || def.qualifiedName === undefined)
+                        continue;
+                    if (maxInjectedSiblings > 0 && injectedIds.size >= maxInjectedSiblings) {
+                        truncated = true;
+                        break;
+                    }
+                    injectedIds.add(def.nodeId);
+                    injectedPaths.add(defPath);
+                    const simpleName = def.qualifiedName.includes('.')
+                        ? def.qualifiedName.slice(def.qualifiedName.lastIndexOf('.') + 1)
+                        : def.qualifiedName;
+                    const bindings = scopeAug.get(simpleName) ?? [];
+                    if (!scopeAug.has(simpleName))
+                        scopeAug.set(simpleName, bindings);
+                    bindings.push({ def, origin: 'namespace' });
+                }
+                if (truncated) {
+                    // Sibling visibility for this file is now partial, and downstream
+                    // Spring attribution treats a complete flag as "this package's names
+                    // are fully known". Marking it incomplete keeps wildcard attribution
+                    // conservative instead of silently resolving against a truncated set.
+                    incompleteFiles.add(filePath);
+                    truncatedFiles++;
+                }
+                // Keep the two halves of "what this file can see" in agreement: when
+                // the cap truncated the binding set, merge type bindings from the same
+                // bounded sibling set only — and iterate that set directly, so the cap
+                // bounds the merge work too instead of just filtering a full scan. An
+                // untruncated scope merges every sibling as before, including ones that
+                // contribute no class-like def.
+                const typeBindings = scope.typeBindings;
+                const mergePaths = truncated ? injectedPaths : allSiblingPaths;
+                // Module scopes first, then class scopes: module-level bindings win on
+                // a name collision, which the two-pass order (not file order) encodes.
+                for (const siblingPath of mergePaths) {
+                    if (siblingPath === filePath)
+                        continue;
+                    const sibling = moduleScopeByPath.get(siblingPath);
+                    if (sibling === undefined)
+                        continue;
+                    for (const [name, ref] of sibling.scope.typeBindings) {
+                        if (!typeBindings.has(name))
+                            typeBindings.set(name, ref);
+                    }
+                }
+                for (const siblingPath of mergePaths) {
+                    if (siblingPath === filePath)
+                        continue;
+                    const sibling = parsedByPath.get(siblingPath);
+                    if (sibling === undefined)
+                        continue;
+                    for (const siblingScope of sibling.scopes) {
+                        if (siblingScope.kind !== 'Class')
+                            continue;
+                        for (const [name, ref] of siblingScope.typeBindings) {
+                            if (ref.source !== 'self' && !typeBindings.has(name))
+                                typeBindings.set(name, ref);
+                        }
+                    }
+                }
+            }
+        }
+        if (truncatedFiles > 0) {
+            logger_js_1.logger.warn(`[${options.languageLabel}-package-siblings] sibling injection truncated at ${maxInjectedSiblings} per file for ${truncatedFiles} file(s); wildcard attribution disabled for those files (raise or unset CGRAPH_MAX_INJECTED_SIBLINGS to widen, 0 for unbounded)`);
+        }
+    }
+    return {
+        populateNamespaceSiblings,
+        isVisibilityIncomplete: (filePath) => incompleteFiles.has(filePath),
+    };
+}
+function pathSegments(filePath) {
+    return filePath.replace(/\\/g, '/').split('/');
+}
+function sharedSegmentCount(aSegments, bSegments) {
+    let index = 0;
+    while (index < aSegments.length &&
+        index < bSegments.length &&
+        aSegments[index] === bSegments[index]) {
+        index++;
+    }
+    return index;
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeKotlinArityMetadata = computeKotlinArityMetadata;
+const jvm_js_1 = require("../../method-extractors/configs/jvm.js");
+function computeKotlinArityMetadata(fnNode) {
+    const params = jvm_js_1.kotlinMethodConfig.extractParameters?.(fnNode) ?? [];
+    let hasVararg = false;
+    const parameterTypes = [];
+    for (const param of params) {
+        if (param.isVariadic)
+            hasVararg = true;
+        if (param.type !== null)
+            parameterTypes.push(param.type);
+    }
+    if (hasVararg)
+        parameterTypes.push('vararg');
+    const required = params.filter((p) => !p.isOptional && !p.isVariadic).length;
+    return {
+        parameterCount: hasVararg ? undefined : params.length,
+        requiredParameterCount: required,
+        parameterTypes: parameterTypes.length > 0 ? parameterTypes : undefined,
+    };
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kotlinArityCompatibility = kotlinArityCompatibility;
+function kotlinArityCompatibility(def, callsite) {
+    const min = def.requiredParameterCount;
+    const max = def.parameterCount;
+    if (min === undefined && max === undefined)
+        return 'unknown';
+    const argCount = callsite.arity;
+    if (!Number.isFinite(argCount) || argCount < 0)
+        return 'unknown';
+    const hasVararg = def.parameterTypes?.some((t) => t === 'vararg') ?? false;
+    if (min !== undefined && argCount < min)
+        return 'incompatible';
+    if (max !== undefined && argCount > max && !hasVararg)
+        return 'incompatible';
+    return 'compatible';
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordKotlinCacheHit = recordKotlinCacheHit;
+exports.recordKotlinCacheMiss = recordKotlinCacheMiss;
+exports.getKotlinCaptureCacheStats = getKotlinCaptureCacheStats;
+exports.resetKotlinCaptureCacheStats = resetKotlinCaptureCacheStats;
+let hits = 0;
+let misses = 0;
+function recordKotlinCacheHit() {
+    hits += 1;
+}
+function recordKotlinCacheMiss() {
+    misses += 1;
+}
+function getKotlinCaptureCacheStats() {
+    return { hits, misses };
+}
+function resetKotlinCaptureCacheStats() {
+    hits = 0;
+    misses = 0;
+}

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

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Kotlin capture-time side-channel serialization (#1983).
+ *
+ * `emitKotlinScopeCaptures` populates one MODULE-LEVEL, per-file map as a side
+ * effect that is NOT part of the returned `ParsedFile`'s scopes/defs:
+ *
+ *   - `companionScopesByFile`  (companion-scopes.ts) — the `ScopeId`s that came
+ *     from a `companion_object` AST node, recorded via `markCompanionScope`
+ *     from the `@scope.companion` marker capture.
+ *   - Spring Bean class-annotation facts collected during the same scope-query
+ *     traversal, consumed only after imports and package visibility finalize.
+ *   - Spring DI class facts (constructor/property/method injection syntax),
+ *     resolved and attached only after imports finalize.
+ *   - A JVM package fact read from the already-parsed root, so package-sibling
+ *     visibility never re-parses Kotlin source on the main thread.
+ *
+ * On the worker path that map is filled in the WORKER process and lost across
+ * the worker→main MessageChannel (and the disk-backed parsedfile-store),
+ * because scope-resolution reuses the serialized `ParsedFile` and SKIPS the
+ * main-thread re-extraction (the #1983 fix that avoids a main-thread
+ * tree-sitter re-parse / OOM on huge repos). The main thread then reads the map
+ * empty in `isKotlinStaticOnly` / `populateCompanionMembersOnEnclosingClass`
+ * (owners.ts) — so companion methods aren't identified as static and
+ * companion/static dispatch emits no CALLS edges.
+ *
+ * This module snapshots the per-file slice of that map into a plain,
+ * JSON-serializable object (carried on `ParsedFile.captureSideChannel`) and
+ * restores it on the main thread WITHOUT any parse. It mirrors the C++ pattern
+ * in `cpp/capture-side-channel.ts`.
+ *
+ * The single generic `ParsedFile.captureSideChannel` field is shared with C++,
+ * which is safe because each file is one language (a `.kt` file uses the kotlin
+ * provider, a `.cpp` file the cpp provider). The payload is self-describing
+ * (`{ kind: 'kotlin', companionScopes, packageFact, classAnnotations,
+ * springDiFacts }`) so
+ * `applyKotlinCaptureSideChannel` only restores kotlin state and ignores a
+ * foreign-shaped snapshot.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearKotlinClassAnnotationFacts = clearKotlinClassAnnotationFacts;
+exports.setKotlinSpringAopFacts = setKotlinSpringAopFacts;
+exports.getKotlinSpringAopFacts = getKotlinSpringAopFacts;
+exports.setKotlinClassAnnotationFacts = setKotlinClassAnnotationFacts;
+exports.getKotlinClassAnnotationFacts = getKotlinClassAnnotationFacts;
+exports.setKotlinSpringConditionalFacts = setKotlinSpringConditionalFacts;
+exports.getKotlinSpringConditionalFacts = getKotlinSpringConditionalFacts;
+exports.setKotlinSpringDiFacts = setKotlinSpringDiFacts;
+exports.getKotlinSpringDiFacts = getKotlinSpringDiFacts;
+exports.collectKotlinCaptureSideChannel = collectKotlinCaptureSideChannel;
+exports.applyKotlinCaptureSideChannel = applyKotlinCaptureSideChannel;
+const bean_candidates_js_1 = require("../../frameworks/spring/bean-candidates.js");
+const package_facts_js_1 = require("../jvm/package-facts.js");
+const companion_scopes_js_1 = require("./companion-scopes.js");
+const package_facts_js_2 = require("./package-facts.js");
+const classAnnotations = (0, bean_candidates_js_1.createClassAnnotationFactStore)();
+const springAopFacts = new Map();
+const springConditionalFacts = new Map();
+const springDiFacts = new Map();
+function clearKotlinClassAnnotationFacts() {
+    classAnnotations.clear();
+    springAopFacts.clear();
+    springConditionalFacts.clear();
+    springDiFacts.clear();
+}
+function setKotlinSpringAopFacts(filePath, facts) {
+    if (facts.length === 0)
+        springAopFacts.delete(filePath);
+    else
+        springAopFacts.set(filePath, facts);
+}
+function getKotlinSpringAopFacts(filePath) {
+    return springAopFacts.get(filePath) ?? [];
+}
+function setKotlinClassAnnotationFacts(filePath, facts) {
+    classAnnotations.set(filePath, facts);
+}
+function getKotlinClassAnnotationFacts(filePath) {
+    return classAnnotations.get(filePath);
+}
+function setKotlinSpringConditionalFacts(filePath, facts) {
+    if (facts.length === 0)
+        springConditionalFacts.delete(filePath);
+    else
+        springConditionalFacts.set(filePath, facts);
+}
+function getKotlinSpringConditionalFacts(filePath) {
+    return springConditionalFacts.get(filePath) ?? [];
+}
+function setKotlinSpringDiFacts(filePath, facts) {
+    if (facts.length === 0)
+        springDiFacts.delete(filePath);
+    else
+        springDiFacts.set(filePath, facts);
+}
+function getKotlinSpringDiFacts(filePath) {
+    return springDiFacts.get(filePath) ?? [];
+}
+/**
+ * `LanguageProvider.collectCaptureSideChannel` implementation for Kotlin.
+ * Returns `undefined` when this file recorded no side-channel state at all, so
+ * the produced `ParsedFile` carries the field only when there's data to ship.
+ */
+function collectKotlinCaptureSideChannel(filePath) {
+    const companionScopes = (0, companion_scopes_js_1.getCompanionScopesForFile)(filePath);
+    const annotationFacts = classAnnotations.get(filePath);
+    const aopFacts = springAopFacts.get(filePath) ?? [];
+    const conditionFacts = springConditionalFacts.get(filePath) ?? [];
+    const diFacts = springDiFacts.get(filePath) ?? [];
+    const packageFact = (0, package_facts_js_2.getKotlinPackageFact)(filePath);
+    if (companionScopes.length === 0 &&
+        annotationFacts.length === 0 &&
+        aopFacts.length === 0 &&
+        conditionFacts.length === 0 &&
+        diFacts.length === 0 &&
+        packageFact === undefined) {
+        return undefined;
+    }
+    return {
+        kind: 'kotlin',
+        companionScopes,
+        packageFact: packageFact ?? package_facts_js_1.UNKNOWN_JVM_PACKAGE_FACT,
+        classAnnotations: annotationFacts,
+        ...(aopFacts.length > 0 ? { springAopFacts: aopFacts } : {}),
+        ...(conditionFacts.length > 0 ? { springConditionalFacts: conditionFacts } : {}),
+        ...(diFacts.length > 0 ? { springDiFacts: diFacts } : {}),
+    };
+}
+/**
+ * `ScopeResolver.applyCaptureSideChannel` implementation for Kotlin. Reads the
+ * worker-serialized snapshot from `parsed.captureSideChannel` and re-populates
+ * the module-level companion-scope map via `markCompanionScope`. Tolerant of
+ * `undefined` (file carried no data) and of an unexpected / foreign shape
+ * (defensive — the `kind` tag guards against restoring a non-kotlin payload).
+ * Does NO tree-sitter parse.
+ */
+function applyKotlinCaptureSideChannel(parsed) {
+    const data = parsed.captureSideChannel;
+    if (data === undefined ||
+        data === null ||
+        typeof data !== 'object' ||
+        data.kind !== 'kotlin' ||
+        !Array.isArray(data.companionScopes) ||
+        !Array.isArray(data.classAnnotations)) {
+        classAnnotations.set(parsed.filePath, []);
+        setKotlinSpringAopFacts(parsed.filePath, []);
+        setKotlinSpringConditionalFacts(parsed.filePath, []);
+        setKotlinSpringDiFacts(parsed.filePath, []);
+        (0, package_facts_js_2.setKotlinPackageFact)(parsed.filePath, package_facts_js_1.UNKNOWN_JVM_PACKAGE_FACT);
+        return;
+    }
+    for (const scopeId of data.companionScopes) {
+        (0, companion_scopes_js_1.markCompanionScope)(parsed.filePath, scopeId);
+    }
+    classAnnotations.set(parsed.filePath, data.classAnnotations);
+    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 : []);
+    (0, package_facts_js_2.setKotlinPackageFact)(parsed.filePath, (0, package_facts_js_1.isJvmPackageFact)(data.packageFact) ? data.packageFact : package_facts_js_1.UNKNOWN_JVM_PACKAGE_FACT);
+}