@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/real-kotlin-analyzer-GRAYCWW2.js

@@ -0,0 +1,3956 @@
+import {
+  findDeclaringParent
+} from "./chunk-OWISBAOF.js";
+import {
+  ASTEngine
+} from "./chunk-V44PGPA6.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-kotlin-analyzer.ts
+function stringIncludes(str, val) {
+  if (!str) return false;
+  return str.indexOf(val) !== -1;
+}
+function someSymbol(arr, predicate) {
+  if (!arr) return false;
+  for (let i = 0; i < arr.length; i++) {
+    if (predicate(arr[i])) return true;
+  }
+  return false;
+}
+function stripKotlinQuoting(text) {
+  if (!text.includes("`")) return text;
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text.charCodeAt(i) === 96) {
+      const close = text.indexOf("`", i + 1);
+      if (close === -1) {
+        out += text.slice(i);
+        break;
+      }
+      out += text.slice(i + 1, close);
+      i = close + 1;
+    } else {
+      out += text[i];
+      i++;
+    }
+  }
+  return out;
+}
+function kotlinSigHasTypeVar(sig) {
+  const n = sig.length;
+  let i = 0;
+  while (i < n) {
+    const c = sig[i];
+    if (c === "(" || c === "," || c === ":" || c === "|" || c === "[" || c === "<" || c === "&" || i === 0) {
+      let j = i;
+      while (j < n && (sig[j] === "(" || sig[j] === "[" || sig[j] === " " || sig[j] === ":" || sig[j] === ",")) j++;
+      if (j < n && sig[j] >= "A" && sig[j] <= "Z") {
+        let end = j + 1;
+        while (end < n && (sig[end] >= "A" && sig[end] <= "Z" || sig[end] >= "a" && sig[end] <= "z" || sig[end] >= "0" && sig[end] <= "9" || sig[end] === "_")) end++;
+        if (end === j + 1) return true;
+        i = end;
+        continue;
+      }
+      i = j > i ? j : i + 1;
+      continue;
+    }
+    i++;
+  }
+  return false;
+}
+function kotlinCompilationUnitName(filePath) {
+  if (!filePath) return "";
+  let norm = "";
+  for (let i = 0; i < filePath.length; i++) {
+    const c = filePath[i];
+    norm += c === "\\" ? "/" : c;
+  }
+  const base = norm.slice(norm.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  const stem = dot > 0 ? base.slice(0, dot) : base;
+  return stem ? stripKotlinQuoting(stem) : "";
+}
+var KOTLIN_EXTERNAL_IMPORT_ROOTS = [
+  "java.",
+  "javax.",
+  "jakarta.",
+  "jdk.",
+  "sun.",
+  "com.sun.",
+  "kotlin.",
+  "android.",
+  "androidx."
+];
+var RealKotlinAnalyzer = class _RealKotlinAnalyzer {
+  findChildByType(node, types) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c) {
+        for (let j = 0; j < types.length; j++) {
+          if (types[j] === c.type) return c;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Is this candidate TYPE name actually a Kotlin keyword the recovery handed us?
+   *
+   * MEASURED DEFECT (kotlin corpus, 405-file census). IntelliJ context-parameter
+   * test markup breaks a class header so badly that the real name ends up INSIDE
+   * an ERROR node while the constructor keyword is serialised as a direct
+   * `type_identifier` child of the class_declaration:
+   *
+   *   analysis/low-level-api-fir/testData/lazyResolve/errors/
+   *     constructorDuplicatedContextParameter.kt
+   *   `class Foo { context(c<caret>: Int) context(c: String) constructor() }`
+   *
+   *   class_declaration
+   *     class (anon)
+   *     ERROR                      <- contains simple_identifier "Foo"
+   *       simple_identifier "Foo"
+   *       ...
+   *     type_identifier "constructor"   <- the KEYWORD, a direct named child
+   *     primary_constructor "()"
+   *
+   * A first-name-child scan therefore published a CLASS named `constructor` for a
+   * file that declares `Foo`, and the census then found `exports (file) ->
+   * constructor` and `contains constructor -> constructor` rows pointing at it.
+   *
+   * The rejection is TYPE-DECLARATION-ONLY on purpose: `constructor` is a SOFT
+   * keyword in Kotlin, and `fun constructor()` is legal — the corpus has one
+   * (compiler/psi/psi-impl/testData/psi/secondaryConstructors/basic.kt declares
+   * both `constructor() {}` and `@constructor fun constructor() {}` inside class
+   * A). Applying this to functions would delete a real declaration. No Kotlin
+   * TYPE may be named with any token below, which is what makes the list safe
+   * here: they are declaration keywords, and the recovery only ever offers one
+   * where a name belongs.
+   */
+  static KOTLIN_TYPE_NAME_KEYWORDS = /* @__PURE__ */ new Set([
+    "class",
+    "interface",
+    "object",
+    "fun",
+    "val",
+    "var",
+    "constructor",
+    "companion",
+    "enum",
+    "annotation",
+    "typealias",
+    "init"
+  ]);
+  isKotlinTypeNameKeyword(text) {
+    return _RealKotlinAnalyzer.KOTLIN_TYPE_NAME_KEYWORDS.has(text);
+  }
+  /**
+   * The NAME node of a declaration, or null when the declaration has none.
+   *
+   * `findChildByType` returns the first child whose TYPE matches, and a
+   * zero-length node matches. Tree-sitter produces exactly that under
+   * ERROR recovery, and Kotlin's corpus carries the recovery in real files, not
+   * only in broken ones — measured on the kotlin corpus (script/m14/kotlin-census.ts,
+   * stride 40, 405 files admitted), two declarations published an EMPTY name:
+   *
+   *   analysis/analysis-api/testData/.../ambiguouslyInheritedGeneric.kt
+   *     `abstract class <caret>Child : A<String>, B<CharSequence>`
+   *     -> source_file child is a class_declaration whose only name-bearing child
+   *        is a ZERO-LENGTH simple_identifier, so `className` was "".
+   *   analysis/low-level-api-fir/testData/.../memberPropertyWithTypeInDelegateScript.kts
+   *     `fun <expr>doSmth</expr>(i: String) = 4`
+   *     -> same shape, an empty-name function symbol owned by class A.
+   *
+   * An empty name is not a name. It became a symbol row with `name = ""`, and
+   * because the same "" flowed into the derivations that read `ownerName` /
+   * `cls.name`, it also became FIVE EDGES THAT NAMED NOBODY: 2 `implements` and
+   * 3 `references` rows whose `source` is the empty string. Those rows reach
+   * `brain_relationship` with `source_symbol_id = NULL` and `source_external = ''`
+   * — an edge that asserts a relationship and identifies no participant.
+   *
+   * The fix is ABSENCE, not a placeholder (standing rule R7, ledger.json): the
+   * declaration is not published, and the file's ParseError already reports the
+   * ERROR node's line, so the malformed syntax is disclosed rather than
+   * silently renamed. Reading the ERROR node's own text instead would recover
+   * the name `Child` — deliberately not done: a name read out of an error
+   * recovery is a guess about what the author meant, and publishing it at the
+   * confidence of a real declaration is the same defect one node over.
+   *
+   * The scan is over NAMED children in child order, exactly like
+   * findChildByType, and only skips zero-length matches — so a declaration
+   * whose name node is present but empty is dropped while every other
+   * declaration's resolution is unchanged.
+   */
+  static NAME_NODE_TYPES = /* @__PURE__ */ new Set(["simple_identifier", "type_identifier"]);
+  findNameNode(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (!_RealKotlinAnalyzer.NAME_NODE_TYPES.has(c.type)) {
+        if (c.type === "variable_declaration") {
+          const inner = this.findNameNode(c);
+          if (inner) return inner;
+        }
+        continue;
+      }
+      if (c.text.length === 0) continue;
+      return c;
+    }
+    return null;
+  }
+  /**
+   * An endpoint is publishable when it names something. R7 forbids naming a
+   * symbol with a placeholder literal, and an empty string is the same failure
+   * with the placeholder removed: the row exists and identifies no participant.
+   *
+   * `unknown` is NOT special-cased here, and the reason is measured rather than
+   * stylistic: `unknown` is a legal Kotlin identifier, and the corpus declares
+   * one. `localClassWithUnresolvedSuperType.kt` contains
+   * `override fun unknown() {}` and calls `Bar().unknown()`, so the `unknown`
+   * endpoint on those two edges is a REAL member that really is called. A gate
+   * that convicted it would be wrong, and a gate with false positives gets
+   * disabled — so the rule stays on emptiness, which has no such collision.
+   */
+  static publishableEndpoint(name) {
+    if (typeof name !== "string") return null;
+    return name.length === 0 ? null : name;
+  }
+  /**
+   * THE KOTLIN PLATFORM'S OWN TYPE NAMES — the DEFAULT-IMPORTED set, as a CLOSED LIST.
+   *
+   * ## What this answers, and what it deliberately does not
+   *
+   * A bare `String`, `Int`, `List`, `Unit`, `Throwable` target names a declaration in
+   * `kotlin.*` (or one of the other default-imported packages: kotlin.collections,
+   * kotlin.text, kotlin.ranges, kotlin.sequences, kotlin.annotation, kotlin.comparisons,
+   * kotlin.io) — NOT a declaration in the project. MEASURED over this lane's 400-file gate
+   * population (2,067-file corpus, 6 projects), the unresolved edges whose target is one of
+   * these spellings number 2,936: 2,734 `references`, 172 `instantiates`, 27 `extends`,
+   * 3 `implements`. The top spellings are `String` 685, `Boolean` 332, `Int` 316, `Any` 315,
+   * `List` 269, `Unit` 238, `Long` 136, `Result` 96, `Throwable` 91, `Map` 68, `Double` 48,
+   * `Pair` 45, `Function` 40, `Array` 30. This is the largest ANALYZER-facing cause in the
+   * lane's residual; the largest cause overall (6,753 `calls` edges) is the 400-file stride
+   * hiding a declaration that does exist — an instrument artifact, not an analyzer defect.
+   *
+   * The membership test is DECIDABLE from a closed list, which is why it may be claimed at
+   * all: there is no lookup and no corpus fact behind it — a bare identifier of one of these
+   * spellings that is not this file's own is the platform's declaration of that name. The
+   * model is graphql's closed built-in scalar set.
+   *
+   * ## The three guards, each one measured rather than assumed
+   *
+   * 1. BARE SPELLINGS ONLY. A DOTTED target is not marked, and the reason is a measurement of
+   *    the arbiter's own classifier: `incoming-rule.ts` `pathLikeTarget` reads a dotted target
+   *    whose last segment is a source-file extension as a PATH, so `kotlin.js` would land in
+   *    `externalUnverified` (`ext?`) — a claim no check can reach, which blocks a PASS instead
+   *    of earning one. The dotted language-FQN channel (1,667 further edges: `kotlin.test` 228,
+   *    `kotlin.coroutines` 141, `java.util.concurrent` 66, `java.util` 60, `kotlin.time` 33,
+   *    `java.util.UUID` 18 …) is therefore PRICED AND LEFT, not guessed at.
+   * 2. NOT A NAME THIS FILE COULD MEAN ITSELF. The corpus refutes the naive version: Exposed
+   *    declares `org.jetbrains.exposed.v1.core.Sequence` and `...core.Function`, and
+   *    kotlinx-coroutines declares package `kotlin.coroutines.jvm.internal` — so a bare
+   *    `Sequence` in an Exposed file that imports the project's own `Sequence` is NOT the
+   *    platform's type, and marking it would assert something false about what the edge means.
+   *    The marker is attached only where the file neither declares that name nor imports a
+   *    declaration whose simple name or alias is that name. Both lists are already in hand at
+   *    the point of the check — no new walk, no new parse. MEASURED: 40 edges vetoed.
+   * 3. A WILDCARD IMPORT VETOES EVERY BARE NAME. `MariaDBDialect.kt` carries
+   *    `import org.jetbrains.exposed.v1.core.*` and writes `nextVal(seq: Sequence, …)`; an
+   *    explicit star import beats the DEFAULT star import in Kotlin, so that `Sequence` is
+   *    Exposed's own class. What a wildcard names cannot be enumerated from this file, so the
+   *    file claims nothing. MEASURED: 1,518 candidate edges vetoed (54% of the naive 2,936);
+   *    the 1,386 that remain are the change's whole yield.
+   *
+   * ## Why the marker is safe wherever it is attached
+   *
+   * The arbiter reads an external claim ONLY where the target names nothing in the project
+   * (`classifyEdge`, the `decls === 0` branch): on an edge whose target IS a project
+   * declaration the marker is inert, so it can never hide a resolution and never turn one into
+   * a gap. On a bare target the claim is verified by looking the target up and finding
+   * nothing — which is exactly the state in which it is read.
+   *
+   * TWO SPELLINGS ARE EXCLUDED, AND THE EXCLUSION IS A MEASUREMENT RATHER THAN A TASTE:
+   * `Sequence` and `Function` are default-imported (`kotlin.sequences.Sequence`, `kotlin.Function`)
+   * and this corpus declares both UNDER ITS OWN PACKAGE (`org.jetbrains.exposed.v1.core`). A
+   * same-package declaration needs NO import, so no per-file guard can see it: in the 400-file
+   * draw the marker was attached to `Alias.kt:139` — `object : Function<T>(columnType)`, which is
+   * Exposed's own class — and a false external is the one defect this programme has reverted a fix
+   * over (hcl's 29, protobuf's 37). Excluding the two spellings costs exactly TWO edges of the
+   * 1,388 (one of them that false one) and removes the only measured instance; the hazard CLASS
+   * remains declarable — a name redeclared in the same package of an unseen file — and for these
+   * 53 spellings a scan of all 2,346 `.kt`/`.kts` files found no other instance.
+   */
+  static KOTLIN_DEFAULT_IMPORTED_TYPES = /* @__PURE__ */ new Set([
+    // kotlin.*  (NOTE: `Function` is deliberately absent — see the exclusion note above.)
+    "Any",
+    "Nothing",
+    "Unit",
+    "Boolean",
+    "Byte",
+    "Char",
+    "Double",
+    "Float",
+    "Int",
+    "Long",
+    "Short",
+    "String",
+    "Array",
+    "CharSequence",
+    "Comparable",
+    "Enum",
+    "Lazy",
+    "Pair",
+    "Triple",
+    "Result",
+    "Throwable",
+    "Exception",
+    "Error",
+    "RuntimeException",
+    "IllegalArgumentException",
+    "IllegalStateException",
+    "UnsupportedOperationException",
+    "IndexOutOfBoundsException",
+    "ArithmeticException",
+    "ClassCastException",
+    "NullPointerException",
+    "NoSuchElementException",
+    "NumberFormatException",
+    "ConcurrentModificationException",
+    "Number",
+    "Annotation",
+    "Deprecated",
+    "Suppress",
+    "OptIn",
+    "Comparator",
+    "UInt",
+    "ULong",
+    "UByte",
+    "UShort",
+    // kotlin.collections.*
+    "Iterable",
+    "MutableIterable",
+    "Iterator",
+    "MutableIterator",
+    "ListIterator",
+    "Collection",
+    "MutableCollection",
+    "List",
+    "MutableList",
+    "Set",
+    "MutableSet",
+    "Map",
+    "MutableMap",
+    "ArrayList",
+    "HashMap",
+    "HashSet",
+    "LinkedHashMap",
+    "LinkedHashSet",
+    "ArrayDeque",
+    // kotlin.text.* / kotlin.ranges.*  (NOTE: `Sequence` is deliberately absent — same reason.)
+    "StringBuilder",
+    "Regex",
+    "MatchResult",
+    "IntRange",
+    "LongRange",
+    "CharRange",
+    "ClosedRange"
+  ]);
+  /**
+   * ATTACH THE PLATFORM MARKER — one pass over the finished edge list, so a new emission site
+   * cannot forget it (the defect class that produced this lane's two import shapes).
+   *
+   * `isStdlib` is the spelling the arbiter already recognises as an external claim
+   * (`incoming-rule.ts` `EXTERNAL_KEYS`), and no kotlin edge carried it before this change, so
+   * the column it feeds read 0 for this lane while these edges were counted as silent holes.
+   * Nothing else about an edge is touched: target, source, line and every pre-existing
+   * metadata key are byte-identical.
+   */
+  markPlatformTargets(relationships, symbols, imports) {
+    let hasWildcardImport = false;
+    const fileOwned = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      const n = s?.name;
+      if (typeof n === "string" && n.length > 0) fileOwned.add(n);
+    }
+    for (const imp of imports) {
+      const mod = imp?.module;
+      if (typeof mod !== "string" || mod.length === 0) continue;
+      if (mod.endsWith("*") || imp?.isNamespaceImport === true) {
+        hasWildcardImport = true;
+        continue;
+      }
+      const dot = mod.lastIndexOf(".");
+      const leaf = dot >= 0 ? mod.slice(dot + 1) : mod;
+      if (leaf.length > 0) fileOwned.add(leaf);
+      if (typeof imp.alias === "string" && imp.alias.length > 0) fileOwned.add(imp.alias);
+    }
+    if (hasWildcardImport) return;
+    for (const rel of relationships) {
+      const t = rel.type;
+      if (t !== ASTEngine.RelationshipType.References && t !== ASTEngine.RelationshipType.Instantiates && t !== ASTEngine.RelationshipType.Extends && t !== ASTEngine.RelationshipType.Implements) continue;
+      const target = rel.target;
+      if (typeof target !== "string") continue;
+      if (!_RealKotlinAnalyzer.KOTLIN_DEFAULT_IMPORTED_TYPES.has(target)) continue;
+      if (fileOwned.has(target)) continue;
+      const md = rel.metadata;
+      if (!md || typeof md !== "object") continue;
+      if (md.isStdlib === true) continue;
+      md.isStdlib = true;
+    }
+  }
+  analyze(rootNode, content, filePath, context) {
+    const ctx = {
+      content,
+      currentFile: filePath,
+      packageStack: [],
+      classStack: []
+    };
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    const importClaimEnabled = process.env.BB_KOTLIN_IMPORT_CLAIM === "1";
+    if (rootNode.hasError) {
+      const collectErrors = (node) => {
+        if (node.type === "ERROR" || node.type === "MISSING") {
+          errors.push({
+            message: `Syntax ${node.type} detected. The Brain Engine is bypassing this broken node.`,
+            // 1-based rows/columns, consistent with nodeToRange and every
+            // other analyzer (was 0-based: error locations off-by-one).
+            range: {
+              startLine: node.startPosition.row + 1,
+              startColumn: node.startPosition.column + 1,
+              endLine: node.endPosition.row + 1,
+              endColumn: node.endPosition.column + 1
+            },
+            severity: `warning`
+          });
+        }
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child) collectErrors(child);
+        }
+      };
+      collectErrors(rootNode);
+    }
+    this.extractSymbolsWithScoping(rootNode, ctx, symbols, content, void 0, relationships);
+    this.analyzeRelationships(rootNode, relationships, symbols, ctx);
+    this.processImportsExports(rootNode, imports, exports, relationships, symbols, ctx);
+    const frameworks = this.detectKotlinFrameworks(content, symbols, imports);
+    const patterns = this.detectKotlinPatterns(symbols, relationships, content, rootNode);
+    this.injectPhantomSymbols(rootNode, symbols, frameworks, ctx);
+    try {
+      const extractKotlinCalls = (n) => {
+        const resolveCallSource = (start) => {
+          let p = start;
+          while (p) {
+            if (p.type === "secondary_constructor" || p.type === "primary_constructor") {
+              return this.kotlinConstructorOwnerName(p) ?? "";
+            }
+            if (p.type === "object_literal") {
+              return this.anonymousObjectName(p);
+            }
+            if (p.type === "function_declaration" || p.type === "class_declaration" || p.type === "object_declaration") {
+              const nameNode = this.findNameNode(p);
+              if (nameNode) return nameNode.text;
+            }
+            const topLevelProp = this.kotlinTopLevelPropertyName(p);
+            if (topLevelProp) return topLevelProp;
+            p = p.parent;
+          }
+          return "Global";
+        };
+        if (this.isKotlinContextParameterHeader(n)) return;
+        if (n.type === "call_expression") {
+          const callExpr = this.buildKotlinCallExpression(n);
+          const targetName = callExpr;
+          const leaf = targetName.split(".").pop() || targetName;
+          const isQualified = targetName.includes(".");
+          const isStdlib = this.kotlinStdlibExact.has(targetName) || !isQualified && this.kotlinStdlibExact.has(leaf);
+          if (targetName && targetName !== "print" && targetName !== "println" && !isStdlib) {
+            const sourceName = resolveCallSource(n.parent);
+            const endpointsName = _RealKotlinAnalyzer.publishableEndpoint(leaf) !== null && _RealKotlinAnalyzer.publishableEndpoint(sourceName) !== null;
+            if (endpointsName) {
+              const isPascal = leaf.length > 0 && leaf[0] >= "A" && leaf[0] <= "Z";
+              if (isPascal && !isQualified) {
+                relationships.push({
+                  source: sourceName,
+                  target: leaf,
+                  type: ASTEngine.RelationshipType.Instantiates,
+                  confidence: 0.7,
+                  // (#825): the constructed type is named by the callee leaf.
+                  ...this.lineField(this.calleeLeafNode(n, leaf), n),
+                  metadata: { kotlinSpecific: true, isInstantiation: true }
+                });
+              } else {
+                relationships.push({
+                  source: sourceName,
+                  target: leaf,
+                  type: ASTEngine.RelationshipType.Calls,
+                  confidence: 0.7,
+                  // (#825): the call is written at the callee leaf.
+                  ...this.lineField(this.calleeLeafNode(n, leaf), n),
+                  metadata: {
+                    kotlinSpecific: true,
+                    // cut-1 claim eligibility: only a RECEIVER-LESS call can be the imported binding itself
+                    // (a receiver-carrying call's target is a member leaf, not the bound name).
+                    ...importClaimEnabled && !isQualified ? { kotlinBareCallee: true } : {}
+                  }
+                });
+              }
+            }
+          }
+        } else if (n.type === "constructor_delegation_call") {
+          const text = n.text.trim();
+          const sourceName = resolveCallSource(n.parent);
+          let target = "super";
+          if (text.startsWith("this")) target = "this";
+          if (!_RealKotlinAnalyzer.publishableEndpoint(sourceName)) {
+          } else relationships.push({
+            source: sourceName,
+            target,
+            type: ASTEngine.RelationshipType.Calls,
+            confidence: 1,
+            // (#825): `super(...)`/`this(...)` are unnamed keyword children,
+            // so the delegation node's own line is the site that carries it.
+            line_number: n.startPosition.row + 1,
+            metadata: {
+              relationshipType: "constructor_invocation",
+              constructorReceiver: target,
+              callExpression: text
+            }
+          });
+        }
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const child = n.namedChild(i);
+          if (child) extractKotlinCalls(child);
+        }
+      };
+      extractKotlinCalls(rootNode);
+    } catch (e) {
+    }
+    try {
+      this.extractDeclaredTypeRefs(rootNode, relationships);
+      this.collectExpressionUses(rootNode, relationships, symbols);
+    } catch (e) {
+    }
+    const typeIndex = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      if (s.kind === ASTEngine.SymbolKind.Class || s.kind === ASTEngine.SymbolKind.Interface || s.kind === ASTEngine.SymbolKind.Enum) {
+        if (!typeIndex.has(s.name)) typeIndex.set(s.name, s);
+      }
+    }
+    const declSigs = /* @__PURE__ */ new Map();
+    for (const t of symbols) {
+      if (t.kind !== ASTEngine.SymbolKind.Method || !t.ownerName || t.metadata?.isPhantom) continue;
+      let nameMap = declSigs.get(t.ownerName);
+      if (!nameMap) {
+        nameMap = /* @__PURE__ */ new Map();
+        declSigs.set(t.ownerName, nameMap);
+      }
+      let set = nameMap.get(t.name);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        nameMap.set(t.name, set);
+      }
+      const tSig = "(" + (t.parameters ?? []).map((p) => p.type ?? "").join(",") + ")";
+      set.add(tSig);
+    }
+    const propSigs = /* @__PURE__ */ new Map();
+    for (const t of symbols) {
+      if (t.kind !== ASTEngine.SymbolKind.Property || !t.ownerName || t.metadata?.isPhantom) continue;
+      let nameMap = propSigs.get(t.ownerName);
+      if (!nameMap) {
+        nameMap = /* @__PURE__ */ new Map();
+        propSigs.set(t.ownerName, nameMap);
+      }
+      let set = nameMap.get(t.name);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        nameMap.set(t.name, set);
+      }
+      set.add("(" + (t.returnType ?? "") + ")");
+    }
+    for (const s of symbols) {
+      const _owner = s.ownerName;
+      if (_owner) {
+        const isSynthetic = s.metadata?.isPhantom === true;
+        relationships.push({
+          source: _owner,
+          target: s.name,
+          type: ASTEngine.RelationshipType.Contains,
+          // K1 (M60 kotlin deep review, 2026-09-27): a SYNTHESIZED member's
+          // name is written nowhere in the file. `data class C(val a: Int)`
+          // produces component1 / copy / equals / hashCode / toString, and the
+          // code above already knows it — `isSynthetic` is computed, and the
+          // LINE is correctly omitted for exactly this reason. The confidence
+          // was the one field left claiming otherwise.
+          //
+          // This is the same defect the java pass closed as JD-J13, verbatim in
+          // shape: an inference published at maximum confidence, on a branch
+          // that already carries the knowledge it is wrong about. Probed here:
+          //
+          //     data class C(val a: Int)
+          //       C->a           conf=1.0  line=1     (declared — correct)
+          //       C->component1  conf=1.0  line=-     (synthesized)
+          //       C->copy        conf=1.0  line=-     (synthesized)
+          //       C->equals      conf=1.0  line=-     (synthesized)
+          //       C->hashCode    conf=1.0  line=-     (synthesized)
+          //       C->toString    conf=1.0  line=-     (synthesized)
+          //
+          // Five of six containment edges name a method with no declaration, at
+          // maximum confidence, while the one real member sits beside them at the
+          // same confidence with a real line. A consumer cannot tell them apart
+          // without knowing the `isPhantom` convention.
+          //
+          // Fixed the way java's JD-J13 was: keep the edge (the containment is
+          // real and useful — `C.component1` does exist), mark it, and demote
+          // below the 0.7 fabrication threshold so it reads as declared
+          // suspicion and a consumer can filter on it.
+          confidence: isSynthetic ? 0.6 : 1,
+          ...!isSynthetic && s.range?.startLine ? { line_number: s.range.startLine } : {},
+          metadata: { isContained: true, ...isSynthetic ? { inferred: true } : {} }
+        });
+      }
+      const overrideKind = s.kind === ASTEngine.SymbolKind.Method ? "method" : s.kind === ASTEngine.SymbolKind.Property ? "property" : "";
+      if (overrideKind !== "" && s.ownerName && !s.metadata?.isPhantom && s.metadata?.modifiers?.includes?.("override")) {
+        const isMethodOverride = overrideKind === "method";
+        const ownerSym = typeIndex.get(s.ownerName);
+        const parents = ownerSym?.metadata?.superTypes ?? [];
+        const overrideSig = isMethodOverride ? "(" + (s.parameters ?? []).map((p) => p.type ?? "").join(",") + ")" : "(" + (s.returnType ?? "") + ")";
+        let overrideParent = parents.length > 0 ? parents[0] : "";
+        let confidence = 0.5;
+        let reasonCode = "first-supertype-guess";
+        let evidence = "inferred";
+        if (parents.length > 0) {
+          const declared = (typeName) => {
+            const nameMap = (isMethodOverride ? declSigs : propSigs).get(typeName);
+            if (!nameMap) return false;
+            const sigs = nameMap.get(s.name);
+            if (!sigs || sigs.size === 0) return false;
+            if (overrideSig && sigs.has(overrideSig)) return true;
+            const hasTypeVar = (sig) => kotlinSigHasTypeVar(sig);
+            if (!overrideSig) return true;
+            for (const s2 of sigs) if (hasTypeVar(s2) || hasTypeVar(overrideSig)) return true;
+            return false;
+          };
+          const queue = [...parents];
+          const seen = /* @__PURE__ */ new Set();
+          let depth = 0;
+          while (queue.length > 0 && depth < 10) {
+            depth++;
+            const parent = queue.shift();
+            if (seen.has(parent)) continue;
+            seen.add(parent);
+            if (declared(parent)) {
+              overrideParent = parent;
+              confidence = 0.9;
+              reasonCode = "in-file-verified";
+              evidence = "structural";
+              break;
+            }
+            const gp = typeIndex.get(parent)?.metadata?.superTypes ?? [];
+            for (const g of gp) if (!seen.has(g)) queue.push(g);
+          }
+        }
+        if (isMethodOverride && context?.overrideCompanion && parents.length > 0) {
+          const declaring = findDeclaringParent(
+            s.name,
+            parents,
+            context.overrideCompanion,
+            (t) => typeIndex.get(t)?.metadata?.superTypes ?? []
+          );
+          if (declaring) {
+            overrideParent = declaring;
+            confidence = 0.9;
+            reasonCode = "companion-index";
+            evidence = "structural";
+          }
+        }
+        if (overrideParent) {
+          relationships.push({
+            source: `${s.ownerName}.${s.name}`,
+            target: `${overrideParent}.${s.name}`,
+            type: ASTEngine.RelationshipType.Overrides,
+            confidence,
+            // (#825): the override occurs at the OVERRIDING declaration.
+            ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+            metadata: {
+              isOverride: true,
+              overrideParent,
+              reasonCode,
+              evidenceClass: evidence,
+              overrideSig,
+              overrideMemberKind: overrideKind
+            }
+          });
+        }
+      }
+    }
+    const compilationUnit = kotlinCompilationUnitName(filePath);
+    for (const imp of imports) {
+      if (!_RealKotlinAnalyzer.publishableEndpoint(imp.module)) continue;
+      relationships.push({
+        source: "root",
+        target: imp.module,
+        type: ASTEngine.RelationshipType.References,
+        confidence: 0.9,
+        // (#825): the imported module is named on the import statement.
+        ...imp.range?.startLine ? { line_number: imp.range.startLine } : {},
+        metadata: { isImportDep: true }
+      });
+    }
+    this.canonicalizePublishedNames(symbols, relationships);
+    const primaryType = this.primaryTopLevelType(symbols);
+    if (primaryType) {
+      for (const rel of relationships) {
+        if (rel.type === ASTEngine.RelationshipType.References && rel.source === "root") {
+          rel.source = primaryType.name;
+        }
+      }
+    } else if (compilationUnit) {
+      for (const rel of relationships) {
+        if (rel.type === ASTEngine.RelationshipType.References && rel.source === "root") {
+          rel.source = compilationUnit;
+        }
+      }
+    }
+    const exportedSymbols = [];
+    for (let i = 0; i < symbols.length; i++) {
+      const s = symbols[i];
+      if (s.metadata?.isPhantom || s.metadata?.isAnonymousObject) continue;
+      if (s.metadata?.isFileLevelDeclaration !== true) continue;
+      if (s.visibility !== "public" && s.visibility !== void 0) continue;
+      if (s.ownerName) continue;
+      if (!_RealKotlinAnalyzer.publishableEndpoint(s.name)) continue;
+      const mods = s.metadata?.modifiers ?? [];
+      const explicitPublic = mods.indexOf("public") >= 0;
+      exportedSymbols.push({
+        name: s.name,
+        kind: s.kind,
+        range: s.range,
+        visibility: s.visibility || "public",
+        via: explicitPublic ? "explicit-public" : "default-public"
+      });
+    }
+    const unitIdentity = this.primaryTopLevelType(symbols);
+    const fileLevelSource = unitIdentity ? "(file)" : kotlinCompilationUnitName(filePath) || "(file)";
+    for (const e of exportedSymbols) {
+      exports.push({ name: e.name, kind: e.kind, range: e.range, visibility: e.visibility });
+      relationships.push({
+        source: fileLevelSource,
+        target: e.name,
+        type: ASTEngine.RelationshipType.Exports,
+        confidence: 1,
+        // (#825): the exported declaration's own line — the same site rule
+        // go's exports emitter uses (real-go-analyzer.ts:463).
+        ...e.range?.startLine ? { line_number: e.range.startLine } : {},
+        metadata: {
+          kotlinSpecific: true,
+          // Which fact put this name on the file's surface: the modifier that is
+          // written, or Kotlin's public-by-default rule. A reader can tell an
+          // explicit `public` from an implicit one without re-parsing.
+          via: e.via,
+          visibility: e.visibility,
+          symbolKind: String(e.kind),
+          // M60/#910: the source is the FILE, not a symbol.
+          fileLevel: true
+        }
+      });
+    }
+    this.classifyEvidenceTier(relationships);
+    this.markPlatformTargets(relationships, symbols, imports);
+    if (importClaimEnabled) {
+      this.attachKotlinImportedBindingClaims(relationships, symbols, imports);
+    }
+    return {
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        complexity: this.calculateRealComplexity(symbols, relationships),
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity: this.calculateCyclomaticComplexity(rootNode),
+        framework: frameworks[0],
+        // Primary framework
+        patterns,
+        // Kotlin intelligence metadata
+        detectedFrameworks: frameworks,
+        frameworkPatterns: this.getKotlinFrameworkPatterns(frameworks, symbols),
+        architecturalInsights: this.generateArchitecturalInsights(symbols, relationships),
+        architecturalScore: this.calculateArchitecturalScore(symbols, relationships, patterns),
+        codeQuality: this.assessKotlinCodeQuality(symbols, relationships, patterns),
+        hasTypeInference: true,
+        hasFrameworkIntelligence: true,
+        // ABSENT when the file has a module identity, a COUNT when it does not:
+        // a zero would be a claim that the count was measured to be zero, while
+        // an absent field is an unknown. See the unit-identity note above.
+        ...unitIdentity ? {} : { exportsWithheldNoModuleIdentity: exportedSymbols.length },
+        analysisVersion: "3.0.0-infallible-brain"
+      }
+    };
+  }
+  /**
+   * PHASE 1: Real Kotlin Symbol Extraction with Scoping
+   * Understands Kotlin semantics: classes, data classes, sealed classes, objects, functions
+   */
+  injectPhantomSymbols(rootNode, symbols, frameworks, ctx) {
+    for (let i = 0; i < symbols.length; i++) {
+      const symbol = symbols[i];
+      let hasData = false;
+      const symModifiers = symbol.metadata?.modifiers ?? [];
+      for (let j = 0; j < symModifiers.length; j++) {
+        if (symModifiers[j] === "data") {
+          hasData = true;
+          break;
+        }
+      }
+      if (symbol.kind === ASTEngine.SymbolKind.Class && hasData) {
+        const properties = [];
+        for (let j = 0; j < symbols.length; j++) {
+          const s = symbols[j];
+          if (s.ownerName === symbol.name && s.kind === ASTEngine.SymbolKind.Property && s.metadata?.isConstructorProperty === true) properties.push(s);
+        }
+        for (let index = 0; index < properties.length; index++) {
+          const prop = properties[index];
+          symbols.push({
+            name: `component${index + 1}`,
+            kind: ASTEngine.SymbolKind.Method,
+            scope: symbol.name,
+            ownerName: symbol.name,
+            modifiers: ["phantom", "data_class_generated", "operator"],
+            range: symbol.range,
+            parameters: [],
+            returnType: prop.returnType || prop.type || "Any",
+            metadata: { isPhantom: true }
+          });
+        }
+        const copyParams = [];
+        for (let j = 0; j < properties.length; j++) {
+          copyParams.push({ name: properties[j].name, type: properties[j].returnType || properties[j].type || "Any" });
+        }
+        symbols.push({
+          name: "copy",
+          kind: ASTEngine.SymbolKind.Method,
+          scope: symbol.name,
+          // (#825): ownerName is what makes the member CONTAINED by its class
+          // — the injector set it for componentN but not for copy/equals/hashCode/
+          // toString, so `contains Money -> copy` never existed while
+          // `contains Money -> component1` did. Same class, same synthesis route,
+          // opposite outcomes on a real corpus file (measured on
+          // JsonTestsData.kt: 7 componentN containment edges, 0 for the other four
+          // members). java's phantoms (lombok/Spring-Data, processPhantomSymbols)
+          // have always carried ownerName.
+          ownerName: symbol.name,
+          modifiers: ["phantom", "data_class_generated"],
+          range: symbol.range,
+          parameters: copyParams,
+          returnType: symbol.name,
+          metadata: { isPhantom: true }
+        });
+        const stdMethods = [
+          { name: "equals", type: "Boolean", params: [{ name: "other", type: "Any?" }] },
+          { name: "hashCode", type: "Int", params: [] },
+          { name: "toString", type: "String", params: [] }
+        ];
+        for (let j = 0; j < stdMethods.length; j++) {
+          const method = stdMethods[j];
+          symbols.push({
+            name: method.name,
+            kind: ASTEngine.SymbolKind.Method,
+            scope: symbol.name,
+            // Same ownerName gap as `copy` above (#825): without it these
+            // three generated overrides were the only members of the data class
+            // with no containment edge at all.
+            ownerName: symbol.name,
+            modifiers: ["phantom", "data_class_generated", "override"],
+            range: symbol.range,
+            parameters: method.params,
+            returnType: method.type,
+            metadata: { isPhantom: true }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * The TYPE that owns a constructor, by name — for attributing edges written
+   * inside one.
+   *
+   * MEASURED DEFECT this closes (kotlin corpus, 405-file census,
+   * script/m14/kotlin-census.ts). The M14 #419 K11 rule is "constructor and init
+   * calls attribute to the CLASS NAME", and it was implemented as
+   * `cls = node.parent; findNameNode(cls)`. That is TRUE for a
+   * `primary_constructor` — its parent IS the class_declaration — and FALSE for a
+   * `secondary_constructor`, whose parent is the `class_body`. So every
+   * `secondary_constructor` in the corpus fell through to the literal fallback
+   * and published `parentClass || "constructor"`: 60 edges across 405 files
+   * (37 calls, 13 uses, 4 instantiates, 3 exports targets, 2 references, 1
+   * contains) attributed to or naming a symbol spelled `constructor`, which no
+   * Kotlin source can declare. The rule was documented as closed and was half
+   * implemented.
+   *
+   * One walk fixes both shapes: skip the `class_body` and take the nearest
+   * enclosing type declaration's name. Returns undefined when there is none (an
+   * ERROR-recovered declaration whose name node is zero-length — see
+   * findNameNode), and the callers then publish nothing rather than a
+   * placeholder (R7).
+   */
+  kotlinConstructorOwnerName(node) {
+    let p = node.parent;
+    while (p) {
+      if (p.type === "class_declaration" || p.type === "object_declaration") {
+        const n = this.findNameNode(p);
+        if (!n || this.isKotlinTypeNameKeyword(n.text)) return void 0;
+        return n.text;
+      }
+      if (p.type === "source_file") break;
+      p = p.parent;
+    }
+    return void 0;
+  }
+  extractSymbolsWithScoping(node, ctx, symbols, content, parentClass, relationships) {
+    const stack = [{ n: node, pClass: parentClass }];
+    while (stack.length > 0) {
+      const entry = stack.pop();
+      if (entry.isPop) {
+        if (entry.name) {
+          ctx.classStack.pop();
+        }
+        continue;
+      }
+      const n = entry.n;
+      const pClass = entry.pClass;
+      let nextParentClass = pClass;
+      let pushedName = void 0;
+      const symbolsBefore = symbols.length;
+      const atFileLevel = n.parent?.type === "source_file";
+      switch (n.type) {
+        case "function_declaration":
+          {
+            const pt = n.parent?.type;
+            const isMemberPosition = pt === "class_body" || pt === "enum_class_body";
+            this.extractFunction(n, symbols, ctx, isMemberPosition ? pClass : void 0);
+          }
+          break;
+        case "class_declaration": {
+          const isInterface = someSymbol(n.children, (c) => c?.type === "interface");
+          const isEnum = someSymbol(n.children, (c) => c?.type === "enum");
+          const cNameNode = this.findNameNode(n);
+          const cName = cNameNode && !this.isKotlinTypeNameKeyword(cNameNode.text) ? cNameNode.text : void 0;
+          if (cName) {
+            ctx.classStack.push(cName);
+            pushedName = cName;
+            nextParentClass = cName;
+          }
+          {
+            const pt = n.parent?.type;
+            const isMemberPosition = pt === "class_body" || pt === "enum_class_body";
+            const ownerForDecl = isMemberPosition ? pClass : void 0;
+            if (isInterface) {
+              this.extractInterface(n, symbols, ctx, ownerForDecl);
+            } else if (isEnum) {
+              this.extractEnumClass(n, symbols, ctx, ownerForDecl);
+            } else {
+              this.extractClass(n, symbols, ctx, ownerForDecl);
+            }
+          }
+          break;
+        }
+        case "object_declaration": {
+          const oNameNode = this.findNameNode(n);
+          const oName = oNameNode && !this.isKotlinTypeNameKeyword(oNameNode.text) ? oNameNode.text : void 0;
+          if (oName) {
+            ctx.classStack.push(oName);
+            pushedName = oName;
+            nextParentClass = oName;
+          }
+          {
+            const pt = n.parent?.type;
+            const isMemberPosition = pt === "class_body" || pt === "enum_class_body";
+            this.extractObject(n, symbols, ctx, isMemberPosition ? pClass : void 0);
+          }
+          break;
+        }
+        case "property_declaration":
+          if (this.isKotlinLocalDeclaration(n)) break;
+          {
+            const pt = n.parent?.type;
+            const isMemberPosition = pt === "class_body" || pt === "enum_class_body";
+            this.extractProperty(n, symbols, ctx, isMemberPosition ? pClass : void 0, relationships);
+          }
+          break;
+        case "primary_constructor":
+        case "constructor_declaration":
+        case "secondary_constructor":
+          this.extractConstructor(n, symbols, ctx, pClass);
+          break;
+        case "package_header":
+          this.extractPackage(n, ctx);
+          break;
+        case "import_header":
+          this.extractImport(n, ctx);
+          break;
+        case "annotation":
+          this.extractAnnotation(n, symbols, ctx);
+          break;
+        case "type_alias": {
+          const pt = n.parent?.type;
+          const isMemberPosition = pt === "class_body" || pt === "enum_class_body" || pt === "source_file";
+          const tName = this.findNameNode(n);
+          if (tName) {
+            const tModifiers = this.extractModifiers(n, ctx);
+            symbols.push({
+              name: tName.text,
+              kind: ASTEngine.SymbolKind.Type,
+              range: this.symbolRange(n),
+              scope: this.currentScope(ctx),
+              visibility: this.determineVisibility(tModifiers, ctx),
+              // M60 M3 (master review): same owner rule, same sweep. A type
+              // alias is a MEMBER of a class exactly when it is declared in that
+              // class's body. One declared inside a function is local to it, and
+              // the class does not contain it:
+              //
+              //   class Host3 { fun f() { typealias T = Int; val x: T = 1 } }
+              //   published: T[owner=Host3], contains Host3->T
+              //
+              // This is the same phantom containment as aa6a2beb's init-block
+              // local and the local-class fix, in the one remaining ungated
+              // extractor call site. Found by enumerating every site that passes
+              // a parentClass, not by looking for this shape.
+              ownerName: isMemberPosition ? pClass : void 0,
+              ownerKind: isMemberPosition && pClass ? ASTEngine.SymbolKind.Class : void 0,
+              decorators: this.extractAnnotations(n, ctx),
+              metadata: {
+                modifiers: tModifiers,
+                annotations: this.extractAnnotations(n, ctx).map((a) => this.kotlinShortAnnotationName(a)),
+                isTypeAlias: true,
+                kotlinSpecific: true
+              }
+            });
+          }
+          break;
+        }
+        case "object_literal": {
+          const deleg = this.findChildByType(n, ["delegation_specifier"]);
+          let superName;
+          if (deleg) {
+            const findType = (node2) => {
+              if (node2.type === "type_identifier") return node2;
+              for (let i = 0; i < node2.namedChildCount; i++) {
+                const c = node2.namedChild(i);
+                if (c) {
+                  const r = findType(c);
+                  if (r) return r;
+                }
+              }
+              return null;
+            };
+            const tId = findType(deleg);
+            if (tId) superName = tId.text;
+          }
+          const anonName = this.anonymousObjectName(n);
+          const anonOwner = this.anonymousObjectOwner(n, pClass);
+          ctx.classStack.push(anonName);
+          pushedName = anonName;
+          nextParentClass = anonName;
+          symbols.push({
+            name: anonName,
+            kind: ASTEngine.SymbolKind.Class,
+            range: this.symbolRange(n),
+            scope: this.currentScope(ctx),
+            visibility: this.determineVisibility(this.extractModifiers(n, ctx), ctx),
+            ownerName: anonOwner.name,
+            ownerKind: anonOwner.kind,
+            decorators: this.extractAnnotations(n, ctx),
+            metadata: {
+              modifiers: [],
+              annotations: this.extractAnnotations(n, ctx).map((a) => this.kotlinShortAnnotationName(a)),
+              isObject: true,
+              isAnonymousObject: true,
+              superTypes: superName ? [superName] : [],
+              superTypesAreConstructorCalls: superName ? [false] : [],
+              kotlinSpecific: true
+            }
+          });
+          break;
+        }
+      }
+      if (atFileLevel) {
+        for (let i = symbolsBefore; i < symbols.length; i++) {
+          const sym = symbols[i];
+          sym.metadata = { ...sym.metadata ?? {}, isFileLevelDeclaration: true };
+        }
+      }
+      if (pushedName) {
+        stack.push({ n, isPop: true, name: pushedName });
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) {
+          stack.push({ n: child, pClass: nextParentClass });
+        }
+      }
+    }
+  }
+  /**
+   * Extract Kotlin function with extension functions and suspend functions
+   */
+  extractFunction(node, symbols, ctx, parentClass) {
+    const nameNode = this.findNameNode(node);
+    if (!nameNode) return;
+    const functionName = nameNode.text;
+    const qualifiedName = this.buildQualifiedName(functionName, ctx, parentClass);
+    const modifiers = this.extractModifiers(node, ctx);
+    const parameters = this.extractKotlinParameters(node, ctx);
+    const returnType = this.extractReturnType(node, ctx);
+    const receiverType = this.extractReceiverType(node, ctx);
+    const qualifiedCalls = this.findKotlinFunctionCalls(node, ctx);
+    const annotations = this.extractAnnotations(node, ctx);
+    const kdoc = this.extractKDocComment(node, ctx);
+    const visibility = this.determineVisibility(modifiers, ctx);
+    let isInline = false, isInfix = false, isOperator = false, isSuspend = false;
+    for (let i = 0; i < modifiers.length; i++) {
+      if (modifiers[i] === "inline") isInline = true;
+      else if (modifiers[i] === "infix") isInfix = true;
+      else if (modifiers[i] === "operator") isOperator = true;
+      else if (modifiers[i] === "suspend") isSuspend = true;
+    }
+    const isExtension = !!receiverType;
+    const apiContract = this.extractKotlinApiContract(node, ctx);
+    const apiContractPath = apiContract.path;
+    const apiMethod = apiContract.method;
+    const fnTypeParameters = this.extractTypeParameters(node, ctx);
+    const symbol = {
+      name: functionName,
+      kind: parentClass ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Function,
+      range: this.symbolRange(node),
+      scope: this.currentScope(ctx),
+      visibility,
+      isAsync: isSuspend,
+      parameters,
+      returnType,
+      decorators: annotations,
+      // Top-level per family contract: the DB ingester reads
+      // symbol.complexity (|| 1) for gravity scoring — metadata-only values
+      // left every kotlin symbol at complexity 1 in the index.
+      complexity: this.calculateFunctionComplexity(node, ctx),
+      comments: kdoc ? [kdoc] : [],
+      qualified_calls: qualifiedCalls,
+      apiContractPath,
+      genericParameters: fnTypeParameters.length > 0 ? fnTypeParameters : void 0,
+      ownerName: parentClass,
+      ownerKind: parentClass ? ASTEngine.SymbolKind.Class : void 0,
+      metadata: {
+        modifiers,
+        annotations: annotations.map((a) => this.kotlinShortAnnotationName(a)),
+        receiverType,
+        apiMethod,
+        isInline,
+        isInfix,
+        isOperator,
+        isSuspend,
+        isExtension,
+        complexity: this.calculateFunctionComplexity(node, ctx),
+        parameterCount: parameters.length,
+        hasKDoc: !!kdoc,
+        ...fnTypeParameters.length > 0 ? { typeParameters: fnTypeParameters } : {},
+        kotlinSpecific: true
+      }
+    };
+    symbols.push(symbol);
+  }
+  /**
+   * Spring mapping annotation extraction. Returns the route PATH ONLY and
+   * the HTTP method separately: brain_symbol.api_contract_path is an exact
+   * match key shared across languages (doc-engine queries
+   * s.api_contract_path=?), so embedding "GET " into it breaks every
+   * cross-language route join against analyzers that store bare paths.
+   */
+  extractKotlinApiContract(node, ctx) {
+    const MAPPINGS = ["@GetMapping", "@PostMapping", "@PutMapping", "@DeleteMapping", "@PatchMapping", "@RequestMapping"];
+    const candidates = [];
+    const modifiersNode = this.findChildByType(node, ["modifiers"]);
+    if (modifiersNode) {
+      const stack = [modifiersNode];
+      while (stack.length > 0) {
+        const n = stack.pop();
+        if (n.type === "annotation") candidates.push({ text: n.text, args: this.getValueArguments(n) });
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) stack.push(c);
+        }
+      }
+      if (candidates.length === 0 && modifiersNode.text.includes("Mapping")) {
+        candidates.push({ text: modifiersNode.text });
+      }
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const mod = node.namedChild(i);
+      if (mod?.type === "annotation") candidates.push({ text: mod.text, args: this.getValueArguments(mod) });
+    }
+    for (const { text, args } of candidates) {
+      const shortName = this.kotlinShortAnnotationName(text);
+      const mapping = MAPPINGS.find((m) => shortName === m.slice(1));
+      if (!mapping) continue;
+      const method = mapping.slice(1).replace("Mapping", "").toUpperCase();
+      let path = "/";
+      if (args && args.namedChildCount > 0) {
+        let methodStr = "ANY";
+        const paths = [];
+        for (let j = 0; j < args.namedChildCount; j++) {
+          const arg = args.namedChild(j);
+          if (!arg || arg.type !== "value_argument") continue;
+          let name = "";
+          let expr = null;
+          for (let k = 0; k < arg.namedChildCount; k++) {
+            const c = arg.namedChild(k);
+            if (!c) continue;
+            if (c.type === "simple_identifier" && !expr) name = c.text;
+            else if (!expr) expr = c;
+          }
+          const isRequestMethod = name === "method" || !name && stringIncludes(arg.text, "method");
+          if (isRequestMethod) {
+            const segs = arg.text.split(".");
+            if (segs.length > 1) methodStr = segs[segs.length - 1].toUpperCase();
+            continue;
+          }
+          if (name && name !== "value" && name !== "path") continue;
+          if (!expr) continue;
+          if (expr.type === "string_literal") {
+            paths.push(expr.text.split('"').join(""));
+          } else if (expr.type === "collection_literal") {
+            for (let k = 0; k < expr.namedChildCount; k++) {
+              const e = expr.namedChild(k);
+              if (e?.type === "string_literal") paths.push(e.text.split('"').join(""));
+            }
+          } else if (expr.type === "call_expression") {
+            for (let k = 0; k < expr.namedChildCount; k++) {
+              const inner = expr.namedChild(k);
+              if (inner?.type !== "call_suffix") continue;
+              for (let m2 = 0; m2 < inner.namedChildCount; m2++) {
+                const va = inner.namedChild(m2);
+                if (va?.type !== "value_arguments") continue;
+                for (let m3 = 0; m3 < va.namedChildCount; m3++) {
+                  const e = va.namedChild(m3);
+                  if (e?.type === "string_literal") paths.push(e.text.split('"').join(""));
+                }
+              }
+            }
+          }
+        }
+        if (paths.length > 0) path = paths[0];
+        if (methodStr !== "ANY") {
+          return { path, method: methodStr };
+        }
+        return { path, method };
+      }
+      const afterName = text.slice(mapping.length);
+      const firstQuote = afterName.indexOf('"');
+      if (firstQuote !== -1) {
+        const close = afterName.indexOf('"', firstQuote + 1);
+        if (close !== -1) path = afterName.slice(firstQuote + 1, close);
+      }
+      if (mapping !== "@RequestMapping") return { path, method };
+      const rmIdx = afterName.indexOf("RequestMethod.");
+      if (rmIdx !== -1) {
+        let end = rmIdx + "RequestMethod.".length;
+        while (end < afterName.length) {
+          const ch = afterName[end];
+          const isAlpha = ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z";
+          if (!isAlpha) break;
+          end++;
+        }
+        const mname = afterName.slice(rmIdx + "RequestMethod.".length, end);
+        if (mname) return { path, method: mname.toUpperCase() };
+      }
+      return { path, method: "ANY" };
+    }
+    return {};
+  }
+  /**
+   * Extract Kotlin class with data classes, sealed classes, and inner classes
+   */
+  extractClass(node, symbols, ctx, parentClass) {
+    const nameNode = this.findNameNode(node);
+    if (!nameNode) return;
+    if (this.isKotlinTypeNameKeyword(nameNode.text)) return;
+    const className = nameNode.text;
+    const qualifiedName = this.buildQualifiedName(className, ctx, parentClass);
+    const modifiers = this.extractModifiers(node, ctx);
+    const superTypes = this.extractSuperTypes(node, ctx);
+    const superTypeKinds = this.extractSuperTypesWithKinds(node);
+    const typeParameters = this.extractTypeParameters(node, ctx);
+    const annotations = this.extractAnnotations(node, ctx);
+    const kdoc = this.extractKDocComment(node, ctx);
+    const visibility = this.determineVisibility(modifiers, ctx);
+    let isData = false, isSealed = false, isAbstract = false, isInner = false, isOpen = false;
+    for (let i = 0; i < modifiers.length; i++) {
+      if (modifiers[i] === "data") isData = true;
+      else if (modifiers[i] === "sealed") isSealed = true;
+      else if (modifiers[i] === "abstract") isAbstract = true;
+      else if (modifiers[i] === "inner") isInner = true;
+      else if (modifiers[i] === "open") isOpen = true;
+    }
+    const symbol = {
+      name: className,
+      kind: ASTEngine.SymbolKind.Class,
+      range: this.symbolRange(node),
+      // Scope = package + enclosing types, EXCLUDING this class's own name,
+      // so a class is never a container of itself.
+      scope: this.enclosingScope(ctx),
+      visibility,
+      isAbstract,
+      ownerName: parentClass,
+      ownerKind: parentClass ? ASTEngine.SymbolKind.Class : void 0,
+      decorators: annotations,
+      comments: kdoc ? [kdoc] : [],
+      metadata: {
+        modifiers,
+        // Short annotation names (last dotted segment) so framework pattern
+        // detection matches fully-qualified annotations exactly like bare ones.
+        annotations: annotations.map((a) => this.kotlinShortAnnotationName(a)),
+        superTypes,
+        superTypesAreConstructorCalls: superTypeKinds.map((s) => s.isConstructorCall),
+        // (#825): parallel line array — one line per supertype, in the
+        // same order. Heritage edges take their line from here, not from the
+        // class header (which names only the first supertype).
+        superTypeLines: superTypeKinds.map((s) => s.line),
+        inheritance: superTypes,
+        typeParameters,
+        isData,
+        isDataClass: isData,
+        isSealed,
+        isInner,
+        isOpen,
+        methodCount: this.countMethods(node, ctx),
+        propertyCount: this.countProperties(node, ctx),
+        hasCompanionObject: this.hasCompanionObject(node, ctx),
+        kotlinSpecific: true
+      }
+    };
+    symbols.push(symbol);
+  }
+  /**
+   * Extract Kotlin object (singleton)
+   */
+  extractObject(node, symbols, ctx, parentClass) {
+    const nameNode = this.findNameNode(node);
+    if (!nameNode) return;
+    if (this.isKotlinTypeNameKeyword(nameNode.text)) return;
+    const objectName = nameNode.text;
+    const modifiers = this.extractModifiers(node, ctx);
+    const superTypes = this.extractSuperTypes(node, ctx);
+    const superTypeKinds = this.extractSuperTypesWithKinds(node);
+    const annotations = this.extractAnnotations(node, ctx);
+    const symbol = {
+      name: objectName,
+      kind: ASTEngine.SymbolKind.Class,
+      // Using Class for objects
+      range: this.symbolRange(node),
+      scope: this.enclosingScope(ctx),
+      visibility: this.determineVisibility(modifiers, ctx),
+      ownerName: parentClass,
+      ownerKind: parentClass ? ASTEngine.SymbolKind.Class : void 0,
+      decorators: annotations,
+      metadata: {
+        modifiers,
+        annotations: annotations.map((a) => this.kotlinShortAnnotationName(a)),
+        superTypes,
+        superTypesAreConstructorCalls: superTypeKinds.map((s) => s.isConstructorCall),
+        // (#825): parallel line array — one line per supertype.
+        superTypeLines: superTypeKinds.map((s) => s.line),
+        isObject: true,
+        isCompanionObject: (() => {
+          for (let i = 0; i < modifiers.length; i++) if (modifiers[i] === "companion") return true;
+          return false;
+        })(),
+        kotlinSpecific: true
+      }
+    };
+    symbols.push(symbol);
+  }
+  /**
+   * M49/M37 #867: the DECLARATION that owns an anonymous type — the innermost
+   * enclosing `function_declaration` when the literal sits inside one, and the
+   * enclosing class (`pClass`) otherwise.
+   *
+   * Ruled language-wide (not just here): `ownerName` = innermost enclosing
+   * declaration. Three of the four JVM analyzers already did that before this
+   * ruling — java's own source comment claimed to "mirror the kotlin family
+   * convention exactly" while its code used the enclosing declaration, so the
+   * comment and the majority disagreed and kotlin was the outlier. Lambdas and
+   * `init` blocks are not declarations: a literal inside one is still owned by
+   * the enclosing function/class, matching java (which pushes no context for a
+   * lambda either).
+   */
+  anonymousObjectOwner(node, pClass) {
+    let ancestor = node.parent;
+    while (ancestor && ancestor.type !== "source_file") {
+      if (ancestor.type === "function_declaration") {
+        const nameNode = this.findNameNode(ancestor);
+        if (nameNode) return { name: nameNode.text, kind: ASTEngine.SymbolKind.Method };
+        break;
+      }
+      if (ancestor.type === "class_declaration" || ancestor.type === "object_declaration") break;
+      ancestor = ancestor.parent;
+    }
+    return { name: pClass, kind: pClass ? ASTEngine.SymbolKind.Class : void 0 };
+  }
+  /**
+   * M49/M37 #866: the name an anonymous object's members — and the calls made
+   * from them — attribute to. ONE derivation, shared by the symbol emitter and
+   * the call-source resolver, so a field symbol and its initialiser call can
+   * never disagree about which type they belong to (java/groovy convention:
+   * `anonymous_<SuperName>`).
+   */
+  anonymousObjectName(node) {
+    const deleg = this.findChildByType(node, ["delegation_specifier"]);
+    let superName;
+    if (deleg) {
+      const findType = (n) => {
+        if (n.type === "type_identifier") return n;
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) {
+            const r = findType(c);
+            if (r) return r;
+          }
+        }
+        return null;
+      };
+      const tId = findType(deleg);
+      if (tId) superName = tId.text;
+    }
+    return superName ? `anonymous_${superName}` : "anonymous_object";
+  }
+  /**
+   * Extract Kotlin property with getters/setters and delegation
+   */
+  extractProperty(node, symbols, ctx, parentClass, relationships) {
+    let ancestor = node.parent;
+    while (ancestor && ancestor.type !== "class_declaration" && ancestor.type !== "object_declaration" && ancestor.type !== "object_literal" && ancestor.type !== "source_file") {
+      if (ancestor.type === "function_declaration") return;
+      ancestor = ancestor.parent;
+    }
+    const declarationNode = this.findChildByType(node, ["variable_declaration"]);
+    const nameNode = declarationNode ? this.findNameNode(declarationNode) : this.findNameNode(node);
+    if (!nameNode) return;
+    const propertyName = nameNode.text;
+    const modifiers = this.extractModifiers(node, ctx);
+    const propertyType = this.extractPropertyType(node, ctx);
+    const annotations = this.extractAnnotations(node, ctx);
+    const isVal = this.isValProperty(node);
+    const isVar = this.isVarProperty(node);
+    let isLateInit = false, isConst = false;
+    for (let i = 0; i < modifiers.length; i++) {
+      if (modifiers[i] === "lateinit") isLateInit = true;
+      if (modifiers[i] === "const") isConst = true;
+    }
+    const hasDelegate = this.hasDelegate(node);
+    let extensionReceiver;
+    let extensionReceiverNode;
+    {
+      let receiverNode = node.childForFieldName("receiver");
+      for (let i = 0; receiverNode == null && i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c?.type === "simple_identifier") break;
+        if (c?.type === "receiver_type" || c?.type === "user_type" || c?.type === "nullable_type" || c?.type === "type_identifier") {
+          receiverNode = c;
+          break;
+        }
+      }
+      if (receiverNode) {
+        const t = receiverNode.text;
+        extensionReceiver = t.endsWith("?") ? t.slice(0, -1) : t;
+        extensionReceiverNode = receiverNode;
+      }
+    }
+    const symbol = {
+      name: propertyName,
+      kind: ASTEngine.SymbolKind.Property,
+      range: this.symbolRange(node),
+      scope: this.currentScope(ctx),
+      visibility: this.determineVisibility(modifiers, ctx),
+      decorators: annotations,
+      returnType: propertyType,
+      ownerName: parentClass,
+      ownerKind: parentClass ? ASTEngine.SymbolKind.Class : void 0,
+      metadata: {
+        modifiers,
+        annotations: annotations.map((a) => this.kotlinShortAnnotationName(a)),
+        propertyType,
+        isVal,
+        isVar,
+        isLateInit,
+        isConst,
+        hasDelegate,
+        hasCustomGetter: this.hasCustomGetter(node),
+        hasCustomSetter: this.hasCustomSetter(node),
+        ...extensionReceiver ? { isExtension: true, extensionReceiver } : {},
+        kotlinSpecific: true
+      }
+    };
+    symbols.push(symbol);
+    if (extensionReceiver && relationships) {
+      relationships.push({
+        source: propertyName,
+        target: extensionReceiver,
+        type: ASTEngine.RelationshipType.Uses,
+        confidence: 0.9,
+        // (#825): the receiver type is named by its receiver node.
+        ...this.lineField(extensionReceiverNode, node),
+        metadata: {
+          relationshipType: "kotlin_extension_property",
+          isExtension: true
+        }
+      });
+    }
+  }
+  /**
+   * Kotlin-specific framework detection
+   */
+  detectKotlinFrameworks(content, symbols, imports) {
+    const frameworks = {};
+    const hasImport = (pkg) => {
+      for (let i = 0; i < imports.length; i++) {
+        const mod = imports[i].module;
+        if (mod && (mod.startsWith(pkg) || mod === pkg)) return true;
+      }
+      return false;
+    };
+    if (hasImport("org.springframework") || hasImport("org.springframework.boot")) {
+      frameworks["Spring Boot"] = true;
+      frameworks["Spring Framework"] = true;
+    }
+    if (hasImport("io.ktor")) frameworks["Ktor"] = true;
+    if (hasImport("io.micronaut")) frameworks["Micronaut"] = true;
+    if (hasImport("io.reactivex.rxjava2") || hasImport("io.reactivex.rxjava3")) frameworks["RxJava"] = true;
+    if (hasImport("org.hibernate") || hasImport("javax.persistence") || hasImport("jakarta.persistence"))
+      frameworks["Hibernate / JPA"] = true;
+    if (hasImport("kotlinx.coroutines")) frameworks["Kotlin Coroutines"] = true;
+    if (hasImport("org.junit") || hasImport("kotlin.test")) frameworks["JUnit"] = true;
+    if (hasImport("io.mockk") || hasImport("org.mockito")) frameworks["Mocking Framework"] = true;
+    if (hasImport("androidx.compose")) frameworks["Jetpack Compose"] = true;
+    if (hasImport("android.app") || hasImport("androidx")) frameworks["Android SDK"] = true;
+    const annotationNames = /* @__PURE__ */ new Set();
+    for (let i = 0; i < symbols.length; i++) {
+      const anns = symbols[i].metadata?.annotations ?? [];
+      for (let j = 0; j < anns.length; j++) annotationNames.add(anns[j]);
+    }
+    const hasAnnotation = (...names) => names.some((n) => annotationNames.has(n));
+    if (hasAnnotation("Service", "RestController", "Controller", "Repository", "Component", "SpringBootApplication")) {
+      frameworks["Spring Boot"] = true;
+      frameworks["Spring Framework"] = true;
+    }
+    if (hasAnnotation("Entity", "Table")) frameworks["Hibernate / JPA"] = true;
+    if (hasAnnotation("Dao", "Database")) frameworks["Room"] = true;
+    if (hasAnnotation("Composable")) frameworks["Jetpack Compose"] = true;
+    if (hasAnnotation("Test", "RunWith", "ExtendWith")) frameworks["JUnit"] = true;
+    const result = [];
+    for (const key in frameworks) {
+      if (Object.prototype.hasOwnProperty.call(frameworks, key)) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+  /**
+   * Detect Kotlin-specific patterns
+   */
+  detectKotlinPatterns(symbols, relationships, content, rootNode) {
+    const patterns = [];
+    let hasData = false, hasSealed = false, hasExtension = false, hasSuspend = false, hasDelegate = false, hasCompanion = false, hasOperator = false;
+    for (let i = 0; i < symbols.length; i++) {
+      const s = symbols[i];
+      if (s.metadata?.isData) hasData = true;
+      if (s.metadata?.isSealed) hasSealed = true;
+      if (s.metadata?.isExtension) hasExtension = true;
+      if (s.metadata?.isSuspend) hasSuspend = true;
+      if (s.metadata?.hasDelegate) hasDelegate = true;
+      if (s.metadata?.hasCompanionObject || s.metadata?.isCompanionObject) hasCompanion = true;
+      if (s.metadata?.isOperator) hasOperator = true;
+    }
+    if (hasData) patterns.push("Data Classes");
+    if (hasSealed) patterns.push("Sealed Classes");
+    if (hasExtension) patterns.push("Extension Functions");
+    if (hasSuspend) patterns.push("Coroutines");
+    const astHas = /* @__PURE__ */ new Map();
+    const scanAst = (n) => {
+      switch (n.type) {
+        case "check_expression":
+          astHas.set("is", true);
+          break;
+        case "elvis_expression":
+          astHas.set("elvis", true);
+          break;
+        case "lambda_literal":
+        case "anonymous_function":
+          astHas.set("lambda", true);
+          break;
+      }
+      if (n.type === "navigation_expression") {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          if (n.namedChild(i)?.type === "quest") astHas.set("nullsafe", true);
+        }
+      }
+      if (n.type === "postfix_expression" && n.text.endsWith("!!")) astHas.set("notnull", true);
+      if (n.type === "delegation_specifier" && stringIncludes(n.text, " by ")) astHas.set("by", true);
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) scanAst(c);
+      }
+    };
+    if (rootNode) scanAst(rootNode);
+    if (astHas.get("nullsafe") || astHas.get("notnull") || astHas.get("elvis")) patterns.push("Null Safety");
+    if (astHas.get("is")) patterns.push("Smart Casts");
+    if (astHas.get("lambda")) patterns.push("Higher-Order Functions");
+    if (hasDelegate || astHas.get("by")) {
+      patterns.push("Delegation");
+      patterns.push("Property Delegation");
+    }
+    if (stringIncludes(content, "buildString {")) patterns.push("DSL Patterns");
+    if (stringIncludes(content, "@GetMapping") || stringIncludes(content, "@PostMapping") || stringIncludes(content, "@RequestMapping")) patterns.push("REST API");
+    if (hasCompanion) patterns.push("Companion Objects");
+    if (hasOperator) patterns.push("Operator Overloading");
+    return patterns;
+  }
+  extractKotlinParameters(node, ctx) {
+    const parameters = [];
+    let paramsNode = this.findChildByType(node, ["function_value_parameters"]);
+    if (!paramsNode) return parameters;
+    const kids = [];
+    for (let i = 0; i < paramsNode.namedChildCount; i++) {
+      const c = paramsNode.namedChild(i);
+      if (c) kids.push(c);
+    }
+    for (let i = 0; i < kids.length; i++) {
+      const paramNode = kids[i];
+      if (paramNode.type !== "parameter") continue;
+      const next = kids[i + 1];
+      const defaultNode = next && next.type !== "parameter" ? next : null;
+      const nameNode = this.findNameNode(paramNode);
+      const typeNode = this.findChildByType(paramNode, ["user_type", "nullable_type", "type_identifier"]);
+      if (nameNode && nameNode.text.length > 0) {
+        parameters.push({
+          name: nameNode.text,
+          type: typeNode ? this.cleanKotlinType(typeNode.text) : void 0,
+          isOptional: !!defaultNode,
+          defaultValue: defaultNode ? defaultNode.text : void 0
+        });
+      }
+    }
+    return parameters;
+  }
+  buildQualifiedName(name, ctx, parentClass) {
+    const scope = parentClass || this.currentScope(ctx);
+    return scope ? `${scope}.${name}` : name;
+  }
+  currentScope(ctx) {
+    return [...ctx.packageStack, ...ctx.classStack].join(".");
+  }
+  /**
+   * Scope of a type declaration = package + ENCLOSING types, excluding the
+   * declaration's own name (which has already been pushed onto classStack by
+   * the time the extractor runs). A container must never contain itself.
+   */
+  enclosingScope(ctx) {
+    const enclosing = ctx.classStack.slice(0, ctx.classStack.length - 1);
+    return [...ctx.packageStack, ...enclosing].join(".");
+  }
+  /**
+   * M14 #299 - evidence-tier classification for EVERY emitted relationship.
+   * Tiers: structural (grammar clauses, conf 1.0) | usage_contextual (calls,
+   * field access, companion-apply idioms) | import_based | reference_qualified
+   * | inferred (sub-1.0 resolutions). Applied centrally at end of analyze()
+   * so no emission site can forget it.
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.evidenceClass) continue;
+      const t = String(r.type ?? r.relationshipType ?? "");
+      const conf = typeof r.confidence === "number" ? r.confidence : 1;
+      if (t === "contains" || t === "exports") {
+        md.evidenceClass = md.relationshipType === "compose_ui_tree" ? "heuristic" : "structural";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = md.isImport || md.isImportDep ? "import_based" : "reference_qualified";
+        continue;
+      }
+      if (t === "imports") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "extends" || t === "implements") {
+        md.evidenceClass = conf >= 1 ? "structural" : "inferred";
+        continue;
+      }
+      if (t === "overrides") {
+        md.evidenceClass = conf >= 1 ? "structural" : conf >= 0.85 ? "usage_contextual" : "inferred";
+        continue;
+      }
+      if (t === "instantiates") {
+        md.evidenceClass = md.isNew || conf >= 0.9 ? "structural" : "usage_contextual";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  /**
+   * (#825): the `line_number` field for a relationship, taken from the node
+   * that CARRIES THE NAME the edge is about. java and scala settled this rule
+   * (the line belongs to the name, never to the construct that contains it) and
+   * kotlin shares their node shapes, so it is the same contract, ported.
+   *
+   * Returns nothing at all when no node is available — never 0: #820/#821, a
+   * stored 0 is a claim that the relationship occurs on line 0.
+   */
+  lineField(nameNode, fallback) {
+    const n = nameNode ?? fallback;
+    return n ? { line_number: n.startPosition.row + 1 } : {};
+  }
+  /**
+   * Is this `call_expression` a KOTLIN 2.2 CONTEXT-PARAMETER HEADER rather than a
+   * call?
+   *
+   * `context(session: FirSession)` is a DECLARATION FORM with no node of its own
+   * in this grammar, so it arrives as an ordinary call and was published as one:
+   * `calls[Global -> context]` at 0.7 for every header — a real statement
+   * attributed to a symbol no kotlin file declares. Measured on a 400-file
+   * stratified draw of the pinned fixture corpus (kotlin@9b80c8ff): 20 headers in 4
+   * files, 28 of the sample's 524 `Global` call edges (the other 496 are Gradle
+   * `.kts` script statements, which have no owner either).
+   *
+   * The guard tests for an ERROR inside the `call_suffix`, NOT for the name
+   * `context` alone, and that distinction is the whole rule: a `value_argument`
+   * cannot carry an annotation, so the parameter list does not parse (the dumped
+   * tree ends `ERROR ": FirSession"`), while a real `context(session)`
+   * INVOCATION parses cleanly. `context` is a SOFT keyword — `fun context(x: Int)`
+   * is a legal declaration and a call to it is a real call — so a name-only test
+   * would delete live edges, which `kotlin/context-parameters` pins against.
+   */
+  /**
+   * Is this declaration LOCAL — written inside a BODY rather than in a class body
+   * or at file level?
+   *
+   * The test walks up to the nearest enclosing position and answers at the FIRST
+   * of them: a body (`function_body`, `lambda_literal`, `anonymous_function`) is
+   * a local; a declaration position (`class_body`, `enum_class_body`,
+   * `source_file`) is not. `anonymous_initializer` is treated as a declaration
+   * position on purpose — an `init` block's locals are M60 K2's ruling, not this
+   * one, and folding them in here would move a pin that already exists.
+   *
+   * This is deliberately ancestry-only: the same question "is this declaration
+   * only reachable from inside a body" is what `kotlinDeclarationPlacement`
+   * answers for the exports surface, and that helper is line-keyed because it
+   * works on symbol ranges after the tree is gone. Both exist because they run at
+   * different stages; a declaration that is local by ancestry is local by line.
+   */
+  /**
+   * The file's module identity: its first TOP-LEVEL TYPE, or null.
+   *
+   * One predicate, three readers (the `references` source rewrite, the `imports`
+   * source, and the `exports` unit source) so the three cannot disagree about
+   * which name stands for the compilation unit — the failure mode that made the
+   * old file emit one `exports` edge sourced at the package, a second at `(file)`
+   * and a third spelling in the fixtures.
+   *
+   * A top-level type is a class/interface/enum with no owner, which excludes a
+   * nested type, a member, a top-level function and a top-level property. Phantom
+   * symbols (data-class generated members) and anonymous objects are excluded
+   * explicitly: neither can be named by an import.
+   */
+  primaryTopLevelType(symbols) {
+    return symbols.find((s) => {
+      if (s.ownerName) return false;
+      if (s.metadata?.isPhantom || s.metadata?.isAnonymousObject) return false;
+      return s.kind === ASTEngine.SymbolKind.Class || s.kind === ASTEngine.SymbolKind.Interface || s.kind === ASTEngine.SymbolKind.Enum;
+    }) ?? null;
+  }
+  isKotlinLocalDeclaration(node) {
+    let p = node.parent;
+    while (p) {
+      const t = p.type;
+      if (t === "class_body" || t === "enum_class_body" || t === "source_file" || t === "anonymous_initializer") return false;
+      if (t === "function_body" || t === "lambda_literal" || t === "anonymous_function") return true;
+      p = p.parent;
+    }
+    return false;
+  }
+  isKotlinContextParameterHeader(node) {
+    const nameChild = node.namedChild(0);
+    if (!nameChild || nameChild.type !== "simple_identifier" || nameChild.text !== "context") return false;
+    const suffix = this.findChildByType(node, ["call_suffix"]);
+    return !!suffix && suffix.hasError;
+  }
+  /**
+   * (#825): the node that NAMES a kotlin call.
+   *
+   * Measured from the pinned wasm rather than assumed: a kotlin
+   * `call_expression`'s named children are `navigation_expression` and
+   * `call_suffix`, and the navigation expression SPANS the receiver — for
+   * `s\n .trim()\n .toUpperCase()` the node opens on line 5 while
+   * `.toUpperCase()` (the name, and the `()` that follows it) is written on 7.
+   * The last identifier inside the navigation expression is the callee leaf,
+   * which is where the call is written.
+   */
+  calleeLeafNode(callNode, leafText) {
+    const nav = callNode.namedChild(0);
+    if (!nav) return null;
+    let last = null;
+    let legacyLast = null;
+    let leafHit = null;
+    const visit = (n, recordLeaf) => {
+      if (n.type === "simple_identifier" || n.type === "type_identifier") {
+        last = n;
+        if (recordLeaf && leafText !== void 0 && n.text === leafText) leafHit = n;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) visit(c, recordLeaf);
+      }
+    };
+    visit(nav, true);
+    legacyLast = last;
+    if (!leafHit && leafText !== void 0) visit(callNode, true);
+    if (!leafHit && leafText !== void 0) {
+      const navChild = this.findChildByType(callNode, ["navigation_expression"]);
+      if (navChild && navChild.id !== nav.id) visit(navChild, true);
+    }
+    return leafHit ?? legacyLast ?? last ?? nav;
+  }
+  /**
+   * (#825): the node whose start is the DECLARATION's own line.
+   *
+   * An annotation is a modifier — `@Test`/`@Bean` decorate the declaration, they
+   * are not where it is written. Measured on the 40-file kotlin oracle sample:
+   * with the node's own start, `contains` and `overrides` edges landed on the
+   * ANNOTATION line for every annotated member (102 of the sample's 241
+   * inconsistent claims started at an `@Test`/`@Bean` line). java measured the
+   * same defect at 27% of its symbols and scala settled the contract; kotlin
+   * inherits one rule, not a third variant.
+   *
+   * The symbol range and the edges that name it move together, so a symbol and
+   * its `contains`/`overrides` lines can never disagree.
+   */
+  declarationLineNode(node) {
+    const name = this.findNameNode(node);
+    if (name) return name;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "modifiers" || c.type === "annotation") continue;
+      if (c.type === "line_comment" || c.type === "multiline_comment") continue;
+      return c;
+    }
+    return node;
+  }
+  /** The range of a SYMBOL: annotations skipped (see declarationLineNode). */
+  symbolRange(node) {
+    const decl = this.declarationLineNode(node);
+    const base = this.nodeToRange(node);
+    return {
+      ...base,
+      startLine: decl.startPosition.row + 1,
+      startColumn: decl.startPosition.column + 1,
+      startIndex: decl.startIndex
+    };
+  }
+  nodeToRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+  // Additional helper methods (stubs for now)...
+  /**
+   * Kotlin Interface Extraction
+   */
+  extractInterface(node, symbols, ctx, parentClass) {
+    const nameNode = this.findNameNode(node);
+    if (!nameNode) return;
+    if (this.isKotlinTypeNameKeyword(nameNode.text)) return;
+    const interfaceName = nameNode.text;
+    const modifiers = this.extractModifiers(node, ctx);
+    const superTypes = this.extractSuperTypes(node, ctx);
+    const superTypeKinds = this.extractSuperTypesWithKinds(node);
+    const typeParameters = this.extractTypeParameters(node, ctx);
+    const annotations = this.extractAnnotations(node, ctx);
+    const symbol = {
+      name: interfaceName,
+      kind: ASTEngine.SymbolKind.Interface,
+      range: this.symbolRange(node),
+      scope: this.enclosingScope(ctx),
+      visibility: this.determineVisibility(modifiers, ctx),
+      isAbstract: true,
+      // All interfaces are abstract
+      ownerName: parentClass,
+      ownerKind: parentClass ? ASTEngine.SymbolKind.Class : void 0,
+      decorators: annotations,
+      metadata: {
+        modifiers,
+        annotations: annotations.map((a) => this.kotlinShortAnnotationName(a)),
+        superTypes,
+        superTypesAreConstructorCalls: superTypeKinds.map((s) => s.isConstructorCall),
+        // (#825): parallel line array — one line per supertype, in the
+        // same order. Heritage edges take their line from here, not from the
+        // class header (which names only the first supertype).
+        superTypeLines: superTypeKinds.map((s) => s.line),
+        inheritance: superTypes,
+        typeParameters,
+        methodCount: this.countMethods(node, ctx),
+        isKotlinInterface: true,
+        kotlinSpecific: true
+      }
+    };
+    symbols.push(symbol);
+  }
+  /**
+   * Kotlin Enum Class Extraction
+   */
+  extractEnumClass(node, symbols, ctx, parentClass) {
+    const nameNode = this.findNameNode(node);
+    if (!nameNode) return;
+    if (this.isKotlinTypeNameKeyword(nameNode.text)) return;
+    const enumName = nameNode.text;
+    const modifiers = this.extractModifiers(node, ctx);
+    const annotations = this.extractAnnotations(node, ctx);
+    const enumValues = this.extractKotlinEnumValues(node);
+    const superTypes = this.extractSuperTypes(node, ctx);
+    const superTypeKinds = this.extractSuperTypesWithKinds(node);
+    const symbol = {
+      name: enumName,
+      kind: ASTEngine.SymbolKind.Enum,
+      range: this.symbolRange(node),
+      scope: this.enclosingScope(ctx),
+      visibility: this.determineVisibility(modifiers, ctx),
+      ownerName: parentClass,
+      ownerKind: parentClass ? ASTEngine.SymbolKind.Class : void 0,
+      decorators: annotations,
+      metadata: {
+        modifiers,
+        annotations: annotations.map((a) => this.kotlinShortAnnotationName(a)),
+        superTypes,
+        superTypesAreConstructorCalls: superTypeKinds.map((s) => s.isConstructorCall),
+        // (#825): parallel line array — one line per supertype.
+        superTypeLines: superTypeKinds.map((s) => s.line),
+        enumValues,
+        valueCount: enumValues.length,
+        hasEnumMethods: this.countMethods(node, ctx) > 0,
+        isKotlinEnum: true,
+        kotlinSpecific: true
+      }
+    };
+    symbols.push(symbol);
+    const enumBody = this.findChildByType(node, ["enum_class_body", "class_body"]);
+    const entryNodes = [];
+    if (enumBody) {
+      for (let i = 0; i < enumBody.namedChildCount; i++) {
+        const c = enumBody.namedChild(i);
+        if (c?.type === "enum_entry") entryNodes.push(c);
+      }
+    }
+    for (let i = 0; i < enumValues.length; i++) {
+      const enumValue = enumValues[i];
+      const entryNode = entryNodes[i] ?? node;
+      symbols.push({
+        name: enumValue,
+        kind: ASTEngine.SymbolKind.EnumMember,
+        range: this.symbolRange(entryNode),
+        scope: this.currentScope(ctx),
+        visibility: "public",
+        ownerName: enumName,
+        ownerKind: ASTEngine.SymbolKind.Enum,
+        metadata: {
+          isEnumValue: true,
+          kotlinSpecific: true
+        }
+      });
+    }
+  }
+  /**
+   * Kotlin Constructor Extraction
+   */
+  extractConstructor(node, symbols, ctx, parentClass) {
+    const parameters = this.extractKotlinParameters(node, ctx);
+    const modifiers = this.extractModifiers(node, ctx);
+    const annotations = this.extractAnnotations(node, ctx);
+    const isPrimaryConstructor = node.type === "primary_constructor";
+    const constructorProperties = [];
+    if (isPrimaryConstructor) {
+      parameters.length = 0;
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const paramNode = node.namedChild(i);
+        if (paramNode && paramNode.type === "class_parameter") {
+          const nameNode = this.findNameNode(paramNode);
+          const typeNode = this.findChildByType(paramNode, ["user_type", "nullable_type", "type_identifier"]);
+          let exists = false;
+          if (nameNode && nameNode.text.length > 0) {
+            for (let j = 0; j < parameters.length; j++) {
+              if (parameters[j].name === nameNode.text) {
+                exists = true;
+                break;
+              }
+            }
+          }
+          if (nameNode && !exists) {
+            parameters.push({
+              name: nameNode.text,
+              type: typeNode ? this.cleanKotlinType(typeNode.text) : "Any"
+            });
+          }
+          const bindingKind = this.findChildByType(paramNode, ["binding_pattern_kind"]);
+          if (bindingKind && (bindingKind.text === "val" || bindingKind.text === "var")) {
+            constructorProperties.push(paramNode);
+          }
+        }
+      }
+    }
+    let hasDefaults = false;
+    for (let i = 0; i < parameters.length; i++) {
+      if (parameters[i].defaultValue !== void 0) {
+        hasDefaults = true;
+        break;
+      }
+    }
+    if (!_RealKotlinAnalyzer.publishableEndpoint(parentClass)) return;
+    const constructorName = parentClass;
+    let ctorDeclNode = node;
+    let ancestor = node.parent;
+    while (ancestor && ancestor.type === "class_body") ancestor = ancestor.parent;
+    if (ancestor && (ancestor.type === "class_declaration" || ancestor.type === "object_declaration")) ctorDeclNode = ancestor;
+    const symbol = {
+      name: constructorName,
+      kind: ASTEngine.SymbolKind.Constructor,
+      range: this.symbolRange(ctorDeclNode),
+      scope: this.currentScope(ctx),
+      visibility: this.determineVisibility(modifiers, ctx),
+      parameters,
+      decorators: annotations,
+      ownerName: parentClass,
+      ownerKind: parentClass ? ASTEngine.SymbolKind.Class : void 0,
+      metadata: {
+        modifiers,
+        annotations: annotations.map((a) => this.kotlinShortAnnotationName(a)),
+        isPrimaryConstructor,
+        parameterCount: parameters.length,
+        hasDefaultParameters: hasDefaults,
+        kotlinSpecific: true
+      }
+    };
+    symbols.push(symbol);
+    if (parentClass) {
+      for (let i = 0; i < constructorProperties.length; i++) {
+        const paramNode = constructorProperties[i];
+        const nameNode = this.findNameNode(paramNode);
+        const typeNode = this.findChildByType(paramNode, ["user_type", "nullable_type", "type_identifier"]);
+        const bindingKind = this.findChildByType(paramNode, ["binding_pattern_kind"]);
+        if (!nameNode || !bindingKind) continue;
+        symbols.push({
+          name: nameNode.text,
+          kind: ASTEngine.SymbolKind.Property,
+          range: this.symbolRange(paramNode),
+          scope: this.currentScope(ctx),
+          visibility: this.determineVisibility(this.extractModifiers(paramNode, ctx), ctx),
+          ownerName: parentClass,
+          ownerKind: ASTEngine.SymbolKind.Class,
+          returnType: typeNode ? this.cleanKotlinType(typeNode.text) : void 0,
+          metadata: {
+            isVal: bindingKind.text === "val",
+            isVar: bindingKind.text === "var",
+            isConstructorProperty: true,
+            kotlinSpecific: true
+          }
+        });
+      }
+    }
+  }
+  /**
+   * Kotlin Package Extraction
+   */
+  extractPackage(node, ctx) {
+    const packageNameNode = this.findChildByType(node, ["identifier", "simple_identifier", "type_identifier"]);
+    if (packageNameNode) {
+      const packageName = packageNameNode.text;
+      ctx.packageStack = packageName.split(".");
+    }
+  }
+  /**
+   * Kotlin Import Extraction
+   */
+  extractImport(node, ctx) {
+    void ctx;
+  }
+  /**
+   * Kotlin Annotation Extraction
+   */
+  extractAnnotation(node, symbols, ctx) {
+    void symbols;
+    void ctx;
+  }
+  /**
+   * Kotlin Modifier Extraction
+   */
+  extractModifiers(node, ctx) {
+    const modifiers = [];
+    const modifiersNode = this.findChildByType(node, ["modifiers"]);
+    if (modifiersNode) {
+      for (let j = 0; j < modifiersNode.namedChildCount; j++) {
+        const modifier = modifiersNode.namedChild(j);
+        if (modifier && modifier.type !== "annotation") {
+          modifiers.push(modifier.text.trim());
+        }
+      }
+    }
+    return modifiers;
+  }
+  /**
+   * Kotlin Return Type Extraction
+   */
+  extractReturnType(node, ctx) {
+    const typeNode = this.findChildByType(node, ["user_type", "nullable_type", "function_type", "type_identifier"]);
+    if (typeNode) {
+      return this.cleanKotlinType(typeNode.text);
+    }
+    const functionBody = this.findChildByType(node, ["function_body"]);
+    if (functionBody && !functionBody.text.startsWith("{")) {
+      return void 0;
+    }
+    return "Unit";
+  }
+  /**
+   * Kotlin Receiver Type Extraction (for extension functions)
+   */
+  extractReceiverType(node, ctx) {
+    const fieldReceiver = node.childForFieldName("receiver");
+    if (fieldReceiver) return this.cleanKotlinType(fieldReceiver.text);
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c?.type === "simple_identifier") break;
+      if (c?.type === "receiver_type" || c?.type === "user_type" || c?.type === "nullable_type" || c?.type === "type_identifier") {
+        return this.cleanKotlinType(c.text);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Kotlin Function Call Detection
+   * Analyzes Kotlin method calls, extension functions, and Android/Spring patterns
+   */
+  findKotlinFunctionCalls(node, ctx) {
+    const calls = [];
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (this.isKotlinContextParameterHeader(n)) continue;
+      if (n.type === "call_expression") {
+        const callName = this.buildKotlinCallExpression(n);
+        if (callName && !this.isKotlinBuiltin(callName)) {
+          calls.push(callName);
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return calls;
+  }
+  /**
+   * Kotlin Annotations Extraction (multiple)
+   */
+  extractAnnotations(node, ctx) {
+    const annotations = [];
+    const modifiers = this.extractModifiers(node, ctx);
+    if (modifiers.includes("expect")) annotations.push("@expect");
+    if (modifiers.includes("actual")) annotations.push("@actual");
+    const collect = (n) => {
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c && c.type === "annotation") {
+          annotations.push(c.text.startsWith("@") ? c.text.slice(1) : c.text);
+        }
+      }
+    };
+    if (node) {
+      collect(node);
+      const modifiersNode = this.findChildByType(node, ["modifiers"]);
+      if (modifiersNode) collect(modifiersNode);
+    }
+    return annotations;
+  }
+  /**
+   * Kotlin KDoc Comment Extraction
+   */
+  extractKDocComment(node, ctx) {
+    const parent = node.parent;
+    if (!parent) return void 0;
+    let selfIdx = -1;
+    for (let i = 0; i < parent.namedChildCount; i++) {
+      const c = parent.namedChild(i);
+      if (c && c.startIndex === node.startIndex && c.endIndex === node.endIndex) {
+        selfIdx = i;
+        break;
+      }
+    }
+    for (let i = selfIdx - 1; i >= 0; i--) {
+      const sibling = parent.namedChild(i);
+      if (!sibling) continue;
+      if ((sibling.type === "multiline_comment" || sibling.type === "line_comment") && sibling.text.startsWith("/**")) {
+        return sibling.text;
+      }
+      break;
+    }
+    return void 0;
+  }
+  /**
+   * Kotlin Visibility Determination
+   */
+  determineVisibility(modifiers, ctx) {
+    for (let i = 0; i < modifiers.length; i++) {
+      const mod = modifiers[i];
+      if (mod === "private") return "private";
+      if (mod === "protected") return "protected";
+      if (mod === "internal") return "internal";
+    }
+    return "public";
+  }
+  /**
+   * Kotlin Function Complexity Calculation
+   */
+  calculateFunctionComplexity(node, ctx) {
+    let complexity = 1;
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "if_expression" || n.type === "when_entry" || // per-case, matching java/TS switch_case granularity
+      n.type === "for_statement" || n.type === "while_statement" || n.type === "do_while_statement" || n.type === "catch_block" || n.type === "elvis_expression") {
+        complexity++;
+      } else if (n.type === "conjunction_expression" || n.type === "disjunction_expression") {
+        complexity++;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return complexity;
+  }
+  /**
+   * Kotlin Super Types Extraction
+   */
+  /**
+   * Extract the clean base type name of every supertype. A delegation_specifier
+   * contains either a user_type directly (Repository<User>) or a
+   * constructor_invocation (BaseService<User>()) wrapping one. The base name
+   * strips type arguments and nullability so relationship targets are valid
+   * symbol leaves (pool-worker's noise filter rejects targets containing <>).
+   */
+  extractSuperTypes(node, ctx) {
+    return this.extractSuperTypesWithKinds(node).map((s) => s.name);
+  }
+  /**
+   * Kotlin semantics (Kotlin docs, Inheritance): a supertype written with a
+   * constructor invocation `Base()` is an extended CLASS; a bare type `Repo`
+   * is an IMPLEMENTED interface. Position alone is wrong - a class whose
+   * first (or only) supertype is an interface was labelled extends.
+   *
+   * (#825): each entry also carries the line the SUPERtype is NAMED on.
+   * A kotlin supertype list wraps (`class A :\n    B(),\n    C`), so the
+   * class header's line names only the first entry. Same rule as java's
+   * `extractJavaInheritance` and scala's `extractSupertypes`.
+   */
+  extractSuperTypesWithKinds(node) {
+    const out = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c?.type === "delegation_specifier") {
+        const invocation = this.findChildByType(c, ["constructor_invocation"]);
+        let userType = this.findChildByType(c, ["user_type"]);
+        if (!userType && invocation) userType = this.findChildByType(invocation, ["user_type"]);
+        if (userType) {
+          out.push({
+            name: this.cleanKotlinBaseType(userType.text),
+            isConstructorCall: !!invocation,
+            line: userType.startPosition.row + 1
+          });
+        }
+      }
+    }
+    return out;
+  }
+  /**
+   * Reduce a (possibly generic/nullable) type to its base name:
+   * "BaseService<User>" → "BaseService", "User?" → "User",
+   * "Map<String, List<Int>>" → "Map".
+   */
+  cleanKotlinBaseType(typeText) {
+    let t = typeText;
+    while (t.endsWith("?")) t = t.slice(0, -1);
+    const lt = t.indexOf("<");
+    if (lt !== -1) t = t.slice(0, lt);
+    return t.trim();
+  }
+  /**
+   * Kotlin Type Parameters Extraction
+   */
+  /**
+   * Positional `value_arguments` lookup. The pinned kotlin wasm exposes only
+   * four fields (receiver/alternative/condition/consequence — verified
+   * 2026-09-16), none of which is `value_arguments`, so this helper remains the
+   * mechanism for annotation/route argument extraction (M14.1). The earlier
+   * "fieldCount=0" claim in this comment was stale: the 1852ea1 rebuild added
+   * field info, but only `receiver` among the fields this analyzer would want.
+   */
+  getValueArguments(node) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (!c) continue;
+        if (c.type === "value_arguments") return c;
+        stack.push(c);
+      }
+    }
+    return void 0;
+  }
+  // KAD-MR3 K13 (M49.K1): getCallFunctionName, extractKotlinAnnotationArguments
+  // and extractKotlinAnnotationTarget were dead (grep-proven zero call sites) —
+  // deleted. extractKotlinAnnotationArguments's arg-walk lives on in the
+  // E6 route extractor as a real consumer.
+  extractTypeParameters(node, ctx) {
+    const typeParameters = [];
+    const typeParamList = this.findChildByType(node, ["type_parameters"]);
+    if (typeParamList) {
+      for (let i = 0; i < typeParamList.namedChildCount; i++) {
+        const typeParam = typeParamList.namedChild(i);
+        if (typeParam?.type === "type_parameter") {
+          const paramName = typeParam.namedChildren.find(
+            (c) => c.type === "simple_identifier" || c.type === "type_identifier"
+          )?.text;
+          if (paramName) {
+            typeParameters.push(paramName);
+          }
+        }
+      }
+    }
+    return typeParameters;
+  }
+  /**
+   * Kotlin Method Counting — DIRECT members only.
+   * KAD-MR3 K14 (M49.K1): the subtree-wide count misattributed nested
+   * structure — a nested class's members inflated the OUTER class's counts
+   * (class Outer { class Nested { fun nm() } } reported methodCount=2 for
+   * Outer). Probed containers: class/object bodies are class_body, enum
+   * members live in enum_class_body.
+   */
+  countMethods(node, ctx) {
+    let count = 0;
+    for (const bt of ["class_body", "enum_class_body"]) {
+      const body = this.findChildByType(node, [bt]);
+      if (!body) continue;
+      for (let i = 0; i < body.namedChildCount; i++) {
+        const m = body.namedChild(i);
+        if (m?.type === "function_declaration") count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Kotlin Property Counting — DIRECT members only (KAD-MR3 K14, see
+   * countMethods). Companion-object properties belong to the companion, not
+   * the outer class.
+   */
+  countProperties(node, ctx) {
+    let count = 0;
+    for (const bt of ["class_body", "enum_class_body"]) {
+      const body = this.findChildByType(node, [bt]);
+      if (!body) continue;
+      for (let i = 0; i < body.namedChildCount; i++) {
+        const m = body.namedChild(i);
+        if (m?.type === "property_declaration") count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Kotlin Companion Object Detection — DIRECT member of THIS type only
+   * (KAD-MR3 K14: the subtree-wide scan credited a nested class's companion
+   * to the outer class).
+   */
+  hasCompanionObject(node, ctx) {
+    for (const bt of ["class_body", "enum_class_body"]) {
+      const body = this.findChildByType(node, [bt]);
+      if (!body) continue;
+      for (let i = 0; i < body.namedChildCount; i++) {
+        const m = body.namedChild(i);
+        if (m?.type !== "companion_object" && m?.type !== "object_declaration") continue;
+        if (m.type === "companion_object") return true;
+        const modifiers = this.extractModifiers(m, ctx);
+        for (let j = 0; j < modifiers.length; j++) {
+          if (modifiers[j] === "companion") return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Kotlin Property Type Extraction
+   */
+  extractPropertyType(node, ctx) {
+    const declarationNode = this.findChildByType(node, ["variable_declaration"]);
+    const typeNode = this.findChildByType(node, ["user_type", "nullable_type", "function_type", "type_identifier"]) || (declarationNode ? this.findChildByType(declarationNode, ["user_type", "nullable_type", "function_type", "type_identifier"]) : null);
+    if (typeNode) {
+      return this.cleanKotlinType(typeNode.text);
+    }
+    const LITERAL_TYPES = ["integer_literal", "real_literal", "string_literal", "character_literal", "boolean_literal", "call_expression"];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && LITERAL_TYPES.indexOf(c.type) !== -1) {
+        return this.inferKotlinTypeFromInitializer(c);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Kotlin Val Property Detection
+   */
+  isValProperty(node) {
+    const binding = this.findChildByType(node, ["binding_pattern_kind"]);
+    if (binding) return binding.text === "val";
+    return stringIncludes(node.text, "val ") && !stringIncludes(node.text, "var ");
+  }
+  /**
+   * Kotlin Var Property Detection
+   */
+  isVarProperty(node) {
+    const binding = this.findChildByType(node, ["binding_pattern_kind"]);
+    if (binding) return binding.text === "var";
+    return stringIncludes(node.text, "var ");
+  }
+  /**
+   * Kotlin Property Delegation Detection
+   */
+  hasDelegate(node) {
+    return !!this.findChildByType(node, ["property_delegate"]);
+  }
+  /**
+   * Kotlin Custom Getter Detection
+   */
+  hasCustomGetter(node) {
+    return this.hasPropertyAccessor(node, "getter");
+  }
+  /**
+   * Kotlin accessor run: the pinned grammar emits accessors as SIBLINGS of
+   * property_declaration (class_body > [property_declaration, getter,
+   * setter]) — probe-verified, and the run is CONTIGUOUS (a setter follows
+   * the getter, not the declaration). Text matching fabricated both ("get()")
+   * hit `val t = m.get()` (a plain call named get); "set("+"value") hit
+   * `val u = s.set(1, value)`). Span-locate the declaration among its
+   * parent's children, then walk the contiguous accessor run that follows.
+   */
+  hasPropertyAccessor(node, accessorType) {
+    const parent = node.parent;
+    if (!parent) return false;
+    for (let i = 0; i < parent.namedChildCount; i++) {
+      const c = parent.namedChild(i);
+      if (c && c.startIndex === node.startIndex && c.endIndex === node.endIndex) {
+        for (let j = i + 1; j < parent.namedChildCount; j++) {
+          const sib = parent.namedChild(j);
+          if (sib?.type === "getter" || sib?.type === "setter") {
+            if (sib.type === accessorType) return true;
+            continue;
+          }
+          break;
+        }
+        return false;
+      }
+    }
+    return false;
+  }
+  /**
+   * Kotlin Custom Setter Detection
+   */
+  hasCustomSetter(node) {
+    return this.hasPropertyAccessor(node, "setter");
+  }
+  // ======================== ADDITIONAL KOTLIN HELPER METHODS ========================
+  /**
+   * Declared-type reference graph (M14). Emits References edges from the
+   * enclosing function/class to every named type used in a declaration
+   * position. Exact-triple dedupe guards against nested-declaration overlap
+   * (e.g. lambda params inside a property initializer).
+   */
+  extractDeclaredTypeRefs(rootNode, relationships) {
+    const emitted = /* @__PURE__ */ new Set();
+    const collectTypeNames = (n, out) => {
+      if (n.type === "type_identifier") {
+        if (n.text.length === 0) return;
+        if (!out.some((x) => x.name === n.text)) out.push({ name: n.text, line: n.startPosition.row + 1 });
+        return;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) collectTypeNames(c, out);
+      }
+    };
+    const resolveSource = (start) => {
+      let p = start;
+      while (p) {
+        if (p.type === "function_declaration" || p.type === "class_declaration" || p.type === "object_declaration") {
+          const name = this.findNameNode(p);
+          if (name) return name.text;
+        }
+        const topLevelProp = this.kotlinTopLevelPropertyName(p);
+        if (topLevelProp) return topLevelProp;
+        p = p.parent;
+      }
+      return "Global";
+    };
+    const emit = (decl, typeRoots, kind, relType = "declared_type", sourceOverride) => {
+      const source = sourceOverride ?? resolveSource(decl);
+      for (const tr of typeRoots) {
+        if (!tr) continue;
+        const names = [];
+        collectTypeNames(tr, names);
+        for (const { name: t, line } of names) {
+          const key = `${source}|${t}|${kind}`;
+          if (emitted.has(key)) continue;
+          emitted.add(key);
+          relationships.push({
+            source,
+            target: t,
+            type: ASTEngine.RelationshipType.References,
+            confidence: 0.95,
+            // (#825): the line the referenced TYPE is named on.
+            line_number: line,
+            metadata: { relationshipType: relType, declaredOn: decl.type }
+          });
+        }
+      }
+    };
+    const walk = (n) => {
+      switch (n.type) {
+        case "class_parameter":
+        case "parameter": {
+          emit(n, [n], n.type);
+          break;
+        }
+        case "variable_declaration": {
+          emit(n, [n], "variable_declaration");
+          break;
+        }
+        case "as_expression":
+        case "check_expression": {
+          if (n.namedChildCount >= 2) {
+            const right = n.namedChild(n.namedChildCount - 1);
+            emit(n, [right], n.type, n.type);
+          }
+          break;
+        }
+        case "callable_reference": {
+          const tId = this.findNameNode(n);
+          if (tId) emit(n, [tId], "callable_reference", "callable_reference");
+          break;
+        }
+        case "type_alias": {
+          const tName = this.findNameNode(n);
+          if (tName) {
+            const rhs = [];
+            for (let i = 0; i < n.namedChildCount; i++) {
+              const c = n.namedChild(i);
+              if (c && c.type !== "type_identifier" && c.type !== "type_parameters") rhs.push(c);
+            }
+            emit(n, rhs, "type_alias", "type_alias", tName.text);
+          }
+          break;
+        }
+        case "object_literal": {
+          const deleg = this.findChildByType(n, ["delegation_specifier"]);
+          if (deleg) emit(n, [deleg], "object_literal", "object_literal");
+          break;
+        }
+        case "function_declaration": {
+          let sawParams = false;
+          let sawName = false;
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (!c) continue;
+            if (c.type === "function_value_parameters") {
+              sawParams = true;
+              continue;
+            }
+            if (c.type === "simple_identifier" || c.type === "type_identifier") {
+              if (!sawName && !sawParams && !c.text.startsWith("`")) {
+                if (i > 0 && n.namedChild(i - 1)?.type === "user_type") {
+                  emit(n, [c], "receiver_type");
+                }
+                sawName = true;
+                continue;
+              }
+              continue;
+            }
+            if (c.type === "receiver_type" || c.type === "user_type" || c.type === "nullable_type" || c.type === "function_type") {
+              if (!sawName && !sawParams) {
+                emit(n, [c], "receiver_type");
+                sawName = true;
+              } else if (sawParams) {
+                emit(n, [c], "return_type", "return_type");
+                break;
+              }
+            }
+          }
+          break;
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c);
+      }
+    };
+    walk(rootNode);
+  }
+  /**
+   * M14 #419 K1/K4: expression-level Uses edges.
+   * - indexing_expression / directly_assignable_expression (with an
+   *   indexing_suffix child): `xs[i]` reads and writes USE the indexed
+   *   expression — previously only contains edges were emitted, so the array
+   *   reference was invisible to the use graph.
+   * - interpolated_identifier: "hi $name" string templates USE the
+   *   referenced identifier. Kotlin's grammar produces a real template node
+   *   (unlike groovy's opaque GStrings — the groovy S1 ruling), so the read
+   *   is visible and must be captured.
+   * - CONV-K-1 (#740): BARE and DOTTED member reads. Property reads are the
+   *   most common read form in kotlin and produced NOTHING — `return x` and
+   *   `return this.x` both emitted zero uses (probe-confirmed live), while
+   *   only the indexing (K1) and template (K4) forms were ever claimed. Gate
+   *   A: the name must resolve to a DECLARED MEMBER of the enclosing type.
+   *   Gate B (CGD15): a name the enclosing function/lambda binds as a
+   *   parameter or local is not a member read — without it `val x = 9` inside
+   *   a method fabricates uses(method -> x) on a property it only shadows.
+   *   Both gates are the real work; the emission is a line.
+   * Deduped per (source, target) so repeated indexing in one function emits
+   * one honest edge, not a fan of identical edges.
+   */
+  collectExpressionUses(rootNode, relationships, symbols) {
+    const emitted = /* @__PURE__ */ new Set();
+    const membersByOwner = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      if (!s.ownerName) continue;
+      if (s.kind === ASTEngine.SymbolKind.Constructor || s.kind === ASTEngine.SymbolKind.Module) continue;
+      let set = membersByOwner.get(s.ownerName);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        membersByOwner.set(s.ownerName, set);
+      }
+      set.add(s.name);
+    }
+    const resolveSource = (start) => {
+      let p = start;
+      while (p) {
+        if (p.type === "secondary_constructor" || p.type === "primary_constructor") {
+          return this.kotlinConstructorOwnerName(p) ?? "";
+        }
+        if (p.type === "function_declaration" || p.type === "class_declaration" || p.type === "object_declaration") {
+          const name = this.findNameNode(p);
+          if (name) return name.text;
+        }
+        const topLevelProp = this.kotlinTopLevelPropertyName(p);
+        if (topLevelProp) return topLevelProp;
+        p = p.parent;
+      }
+      return "Global";
+    };
+    const emitUse = (n, target) => {
+      if (!_RealKotlinAnalyzer.publishableEndpoint(target)) return;
+      const source = resolveSource(n.parent);
+      if (!_RealKotlinAnalyzer.publishableEndpoint(source)) return;
+      const key = `${source}|${target}|uses`;
+      if (emitted.has(key)) return;
+      emitted.add(key);
+      relationships.push({
+        source,
+        target,
+        type: ASTEngine.RelationshipType.Uses,
+        confidence: 0.9,
+        // (#825): a read happens where the name is written. `n` is the
+        // expression the walk found, which is the site that carries it.
+        line_number: n.startPosition.row + 1,
+        metadata: { relationshipType: "expression_use" }
+      });
+    };
+    const resolveOwner = (start) => {
+      let p = start;
+      while (p) {
+        if (p.type === "class_declaration" || p.type === "object_declaration") {
+          const nm = this.findNameNode(p);
+          return nm ? nm.text : null;
+        }
+        p = p.parent;
+      }
+      return null;
+    };
+    const boundCache = /* @__PURE__ */ new Map();
+    const boundOf = (scope) => {
+      const hit = boundCache.get(scope.id);
+      if (hit) return hit;
+      const out = /* @__PURE__ */ new Set();
+      const w = [scope];
+      while (w.length > 0) {
+        const m = w.pop();
+        if (m.type === "simple_identifier") {
+          const pt = m.parent?.type ?? "";
+          if (pt === "parameter" || pt === "class_parameter" || pt === "variable_declaration") {
+            out.add(m.text);
+          }
+        }
+        for (let i = m.namedChildCount - 1; i >= 0; i--) {
+          const c = m.namedChild(i);
+          if (c) w.push(c);
+        }
+      }
+      boundCache.set(scope.id, out);
+      return out;
+    };
+    const isLocallyBound = (n, name) => {
+      let p = n.parent;
+      while (p) {
+        if (p.type === "function_declaration" || p.type === "lambda_literal" || p.type === "primary_constructor" || p.type === "secondary_constructor") {
+          if (boundOf(p).has(name)) return true;
+        }
+        if (p.type === "class_declaration" || p.type === "object_declaration") break;
+        p = p.parent;
+      }
+      return false;
+    };
+    const isWriteLhs = (n) => {
+      let a = n.parent;
+      while (a && (a.type === "directly_assignable_expression" || a.type === "navigation_expression" || a.type === "navigation_suffix")) a = a.parent;
+      if (a && a.type === "assignment") {
+        const lhs = a.namedChild(0);
+        return !!lhs && lhs.startIndex <= n.startIndex && lhs.endIndex >= n.endIndex;
+      }
+      return false;
+    };
+    const NOT_A_READ = /* @__PURE__ */ new Set([
+      "parameter",
+      "class_parameter",
+      "variable_declaration",
+      "type_identifier",
+      "user_type",
+      "nullable_type",
+      "import_header",
+      "package_header",
+      "function_declaration",
+      "class_declaration",
+      "object_declaration",
+      "property_declaration",
+      "value_parameter"
+    ]);
+    const emitMemberRead = (n, target) => {
+      if (!_RealKotlinAnalyzer.publishableEndpoint(target)) return;
+      const source = resolveSource(n.parent);
+      if (!_RealKotlinAnalyzer.publishableEndpoint(source)) return;
+      const key = `${source}|${target}|uses`;
+      if (emitted.has(key)) return;
+      emitted.add(key);
+      relationships.push({
+        source,
+        target,
+        type: ASTEngine.RelationshipType.Uses,
+        confidence: 0.6,
+        // (#825): a bare member read IS its identifier node.
+        line_number: n.startPosition.row + 1,
+        metadata: { isBareRead: true, relationshipType: "expression_use" }
+      });
+    };
+    const walk = (n) => {
+      if (n.type === "indexing_expression" || n.type === "directly_assignable_expression") {
+        const recv = n.namedChild(0);
+        let hasIndexing = false;
+        for (let i = 0; i < n.namedChildCount; i++) {
+          if (n.namedChild(i)?.type === "indexing_suffix") {
+            hasIndexing = true;
+            break;
+          }
+        }
+        const parent = n.parent;
+        const lhs = parent && parent.type === "assignment" ? parent.namedChild(0) : null;
+        const isWrite = !!lhs && lhs.startIndex === n.startIndex && lhs.endIndex === n.endIndex;
+        if (recv && hasIndexing && !isWrite) {
+          const receiverPath = this.kotlinIdentifierPath(recv);
+          if (receiverPath) emitUse(n, receiverPath);
+          else if (this.kotlinNameShapedText(recv.text)) emitUse(n, recv.text);
+        }
+      } else if (n.type === "interpolated_identifier") {
+        emitUse(n, n.text);
+      } else if (n.type === "simple_identifier") {
+        const txt = n.text;
+        const pt = n.parent?.type ?? "";
+        const owner = resolveOwner(n.parent);
+        const isMember = !!owner && (membersByOwner.get(owner)?.has(txt) ?? false);
+        if (!NOT_A_READ.has(pt) && pt !== "call_expression" && !isWriteLhs(n) && !isLocallyBound(n, txt) && isMember) {
+          emitMemberRead(n, txt);
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c);
+      }
+    };
+    walk(rootNode);
+  }
+  /**
+   * Kotlin Call Expression Builder
+   */
+  /**
+   * M60 (#924, kotlin half): canonicalize the PUBLISHED name surface.
+   *
+   * Kotlin has no symbol factory (symbols are pushed inline by the extractors),
+   * so the strip cannot be applied at construction the way swift's createSymbol
+   * does it; it is applied here, at the publish boundary — after every analysis
+   * pass and before exports/imports are derived from these same objects, so all
+   * published spellings agree with each other (a `contains` target still equals
+   * the symbol name it points at) and with what a reference can spell.
+   *
+   * Internal keys are deliberately NOT rewritten past this point: the analysis
+   * resolves references in the source's own spelling (a kotlin reference to a
+   * quoted name is itself quoted), so the quoted form is the correct lookup key
+   * inside the analysis and the stripped form is the correct published name.
+   */
+  canonicalizePublishedNames(symbols, relationships) {
+    for (const s of symbols) {
+      if (typeof s.name === "string") s.name = stripKotlinQuoting(s.name);
+      if (typeof s.ownerName === "string") s.ownerName = stripKotlinQuoting(s.ownerName);
+      if (typeof s.id === "string") s.id = stripKotlinQuoting(s.id);
+    }
+    for (const r of relationships) {
+      if (typeof r.source === "string") r.source = stripKotlinQuoting(r.source);
+      if (typeof r.target === "string") r.target = stripKotlinQuoting(r.target);
+    }
+  }
+  buildKotlinCallExpression(node) {
+    switch (node.type) {
+      case "simple_identifier":
+      case "identifier":
+        return node.text;
+      case "navigation_expression":
+        return this.buildKotlinNavigationExpression(node);
+      case "call_expression": {
+        const nav = this.findChildByType(node, ["navigation_expression"]);
+        if (nav) return this.buildKotlinNavigationExpression(nav);
+        const functionName = this.findChildByType(node, ["simple_identifier", "identifier"]);
+        return functionName ? functionName.text : node.text.split("(")[0];
+      }
+      default:
+        return node.text;
+    }
+  }
+  /**
+   * Kotlin Navigation Expression Builder (for method calls)
+   */
+  /**
+   * M60 (#924, kotlin E half): the NAME of an expression, when it has one.
+   *
+   * The uses walk published an indexing receiver's raw TEXT, so a read of
+   * `dest.selectAll().where { dest.id eq 1 }.single()[dest.id]` was published as
+   * that whole expression — arguments, lambda body and brackets included. Every
+   * one of the 27 such strings the census collected on kotlin is an indexing
+   * receiver (script/m14/tmp/c924-name-surface-probe.ts). A name is the chain of
+   * IDENTIFIERS along the callee/receiver spine; arguments and lambda bodies are
+   * never part of it. Returns undefined when the spine carries no identifier, and
+   * the caller then decides by the old text's SHAPE (see kotlinNameShapedText).
+   */
+  kotlinIdentifierPath(node) {
+    if (!node) return void 0;
+    switch (node.type) {
+      case "simple_identifier":
+      case "identifier":
+      case "type_identifier":
+        return stripKotlinQuoting(node.text);
+      case "navigation_expression": {
+        const receiver = node.namedChild(0);
+        let selector = node.namedChild(node.namedChildCount - 1);
+        if (!receiver || !selector) return void 0;
+        if (selector.type === "navigation_suffix") {
+          const inner = selector.namedChild(selector.namedChildCount - 1);
+          if (!inner) return void 0;
+          selector = inner;
+        }
+        const rt = this.kotlinIdentifierPath(receiver);
+        const st = this.kotlinIdentifierPath(selector);
+        return rt && st ? `${rt}.${st}` : void 0;
+      }
+      case "call_expression":
+      case "indexing_expression":
+        return this.kotlinIdentifierPath(node.namedChild(0));
+      default:
+        return void 0;
+    }
+  }
+  /**
+   * M60 (#924, kotlin E half): is this published TEXT itself name-shaped? A name
+   * carries no argument, lambda, index or separator punctuation — the same rule
+   * the census's E class measures. Used only as a FALLBACK: a receiver whose spine
+   * has no identifier (`this`, a type parameter, a quoted name) keeps its old
+   * spelling rather than losing the edge, because those spellings are names and
+   * the defect being fixed is an EXPRESSION published as one.
+   */
+  kotlinNameShapedText(text) {
+    if (!text) return false;
+    if (text.includes("\n")) return false;
+    for (const ch of ["(", ")", "{", "}", "[", "]", ","]) {
+      if (text.includes(ch)) return false;
+    }
+    return text.trim() === text;
+  }
+  buildKotlinNavigationExpression(node) {
+    const receiver = node.namedChild(0);
+    let selector = node.namedChild(node.namedChildCount - 1);
+    if (!receiver || !selector) return node.text;
+    if (selector.type === "navigation_suffix") {
+      const inner = selector.namedChild(selector.namedChildCount - 1);
+      if (!inner) return node.text;
+      selector = inner;
+    }
+    const receiverText = receiver.type === "navigation_expression" ? this.buildKotlinNavigationExpression(receiver) : receiver.type === "call_expression" ? this.buildKotlinCallExpression(receiver) : receiver.text;
+    return `${receiverText}.${selector.text}`;
+  }
+  /**
+   * Check if function call is Kotlin builtin
+   */
+  /**
+   * Stdlib check for qualified_calls. EXACT matching only - the previous
+   * substring loop classified any user call whose name merely CONTAINED a
+   * builtin word (getUserById -> "get", runMigration -> "run") as stdlib,
+   * silently emptying symbol.qualified_calls (M14.1 fix). Qualified calls are
+   * suppressed only by full-name match or stdlib package prefix; unqualified
+   * calls by exact leaf against the stdlib set + scope-function extras.
+   */
+  isKotlinBuiltin(call) {
+    if (!call) return false;
+    for (const prefix of _RealKotlinAnalyzer.stdlibPackagePrefixes) {
+      if (call.startsWith(prefix)) return true;
+    }
+    if (this.kotlinStdlibExact.has(call)) return true;
+    if (!call.includes(".")) {
+      return _RealKotlinAnalyzer.kotlinBuiltinExtras.has(call);
+    }
+    return false;
+  }
+  static stdlibPackagePrefixes = [
+    "kotlin.",
+    "kotlinx.",
+    "java.",
+    "javax.",
+    "android.",
+    "androidx."
+  ];
+  static kotlinBuiltinExtras = /* @__PURE__ */ new Set([
+    "println",
+    "print",
+    "readLine",
+    "require",
+    "check",
+    "error",
+    "let",
+    "run",
+    "with",
+    "apply",
+    "also",
+    "takeIf",
+    "takeUnless",
+    "toString",
+    "equals",
+    "hashCode",
+    "copy",
+    "componentN",
+    "repeat",
+    "uppercase",
+    "lowercase",
+    "trim",
+    "mutableMapOf",
+    "mapOf",
+    "mutableListOf",
+    "listOf",
+    "setOf",
+    "mutableSetOf",
+    "arrayOf",
+    "emptyList",
+    "emptyMap",
+    "emptySet"
+  ]);
+  /**
+   * Exact stdlib names used by the call-graph filter (leaf-level). Operators
+   * like plus/minus/times are deliberately excluded so in-file operator
+   * overloads produce real Calls edges.
+   */
+  kotlinStdlibExact = /* @__PURE__ */ new Set([
+    "println",
+    "print",
+    "readLine",
+    "require",
+    "check",
+    "error",
+    "let",
+    "run",
+    "with",
+    "apply",
+    "also",
+    "takeIf",
+    "takeUnless",
+    "toString",
+    "equals",
+    "hashCode",
+    "copy",
+    "componentN",
+    "mutableMapOf",
+    "mapOf",
+    "mutableListOf",
+    "listOf",
+    "setOf",
+    "mutableSetOf",
+    "arrayOf",
+    "emptyList",
+    "emptyMap",
+    "emptySet",
+    "repeat",
+    "uppercase",
+    "lowercase",
+    "trim",
+    "startsWith",
+    "endsWith",
+    "contains",
+    "substring",
+    "map",
+    "filter",
+    "reduce",
+    "fold",
+    "forEach",
+    "sorted",
+    "sortedBy",
+    "distinct",
+    "first",
+    "last",
+    "add",
+    "remove",
+    "size",
+    "isEmpty",
+    "isNotEmpty",
+    "put",
+    "get",
+    "getOrElse",
+    "getOrDefault",
+    "any",
+    "all",
+    "none",
+    "count",
+    "sum",
+    "max",
+    "min",
+    "take",
+    "drop"
+  ]);
+  /**
+   * Kotlin Annotation Name Extraction
+   */
+  getKotlinAnnotationName(node) {
+    const direct = this.findNameNode(node);
+    if (direct) return `@${direct.text}`;
+    const userType = this.findChildByType(node, ["user_type"]);
+    if (userType) {
+      let last = null;
+      for (let i = 0; i < userType.namedChildCount; i++) {
+        const c = userType.namedChild(i);
+        if (c && (c.type === "type_identifier" || c.type === "simple_identifier")) last = c;
+      }
+      if (last) return `@${last.text}`;
+    }
+    return void 0;
+  }
+  /**
+   * Reduce raw annotation text to its short name: "@org.x.GetMapping(\"/u\")"
+   * → "GetMapping". Decorators keep the raw source text; anything comparing
+   * annotation NAMES must compare through this normalization.
+   */
+  kotlinShortAnnotationName(raw) {
+    let t = raw.startsWith("@") ? raw.slice(1) : raw;
+    const paren = t.indexOf("(");
+    if (paren !== -1) t = t.slice(0, paren);
+    const dot = t.lastIndexOf(".");
+    return dot === -1 ? t : t.slice(dot + 1);
+  }
+  /**
+   * Kotlin Annotation Arguments Extraction
+   */
+  extractKotlinAnnotationArguments(node) {
+    const args = [];
+    const argsNode = this.getValueArguments(node);
+    if (argsNode) {
+      for (let i = 0; i < argsNode.namedChildCount; i++) {
+        const arg = argsNode.namedChild(i);
+        if (arg) {
+          args.push(arg.text);
+        }
+      }
+    }
+    return args;
+  }
+  /**
+   * Kotlin Annotation Target Extraction
+   */
+  extractKotlinAnnotationTarget(node) {
+    const targetNode = this.findChildByType(node, ["use_site_target"]);
+    if (targetNode) {
+      const text = targetNode.text;
+      return text.endsWith(":") ? text.slice(0, -1) : text;
+    }
+    return void 0;
+  }
+  /**
+   * Kotlin Type Cleaning
+   */
+  cleanKotlinType(typeText) {
+    const parts = typeText.split(" ");
+    const validParts = [];
+    for (let i = 0; i < parts.length; i++) {
+      if (parts[i]) validParts.push(parts[i]);
+    }
+    return validParts.join(" ").replace("??", "?").replace("? ?", "?").trim();
+  }
+  /**
+   * Kotlin Type Inference from Initializer
+   */
+  /**
+   * Infer the type of a property from its initializer using the initializer
+   * NODE TYPE — never by regex-testing its text. Kotlin literal nodes carry
+   * their kind in the grammar: integer_literal, real_literal, float_literal,
+   * string_literal, character_literal, boolean_literal, call_expression.
+   */
+  inferKotlinTypeFromInitializer(initNode) {
+    const text = initNode.text.trim();
+    switch (initNode.type) {
+      case "integer_literal":
+        return text.endsWith("L") ? "Long" : "Int";
+      case "real_literal":
+        return text.endsWith("f") || text.endsWith("F") ? "Float" : "Double";
+      case "float_literal":
+        return "Float";
+      case "string_literal":
+        return "String";
+      case "character_literal":
+        return "Char";
+      case "boolean_literal":
+        return "Boolean";
+      case "call_expression": {
+        const callee = this.buildKotlinCallExpression(initNode);
+        const name = callee.split(".").pop() || callee;
+        if (name === "listOf" || name === "emptyList") return "List<*>";
+        if (name === "mutableListOf") return "MutableList<*>";
+        if (name === "setOf" || name === "emptySet") return "Set<*>";
+        if (name === "mapOf" || name === "emptyMap") return "Map<*, *>";
+        if (name === "arrayOf") return "Array<*>";
+        return name;
+      }
+      default:
+        return "Any";
+    }
+  }
+  /**
+   * Kotlin Enum Values Extraction
+   */
+  extractKotlinEnumValues(node) {
+    const values = [];
+    const enumBody = this.findChildByType(node, ["enum_class_body", "class_body"]);
+    if (!enumBody) return values;
+    for (let i = 0; i < enumBody.namedChildCount; i++) {
+      const child = enumBody.namedChild(i);
+      if (child?.type === "enum_entry") {
+        const nameNode = this.findNameNode(child);
+        if (nameNode) {
+          values.push(nameNode.text);
+        }
+      }
+    }
+    return values;
+  }
+  calculateRealComplexity(symbols, relationships) {
+    return symbols.length + relationships.length;
+  }
+  calculateCyclomaticComplexity(node) {
+    let complexity = 1;
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      switch (n.type) {
+        case "if_expression":
+        // else_clause deliberately NOT counted: an `else` is not an
+        // independent decision (family contract). Counting both if and
+        // else double-counted every if/else.
+        case "for_statement":
+        case "while_statement":
+        case "do_while_statement":
+        case "when_entry":
+        case "catch_block":
+        case "elvis_expression":
+          complexity++;
+          break;
+        case "conjunction_expression":
+        case "disjunction_expression":
+          complexity++;
+          break;
+        case "lambda_literal":
+          break;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return complexity;
+  }
+  /**
+   * (#825): `{name, node}` pairs, not bare names.
+   *
+   * The compose containment edges are derived from the CALLS inside a
+   * `@Composable` body, and their target is the called name — so the line must
+   * come from the call node that carries it. Returning the node is the cheapest
+   * way to keep that true as the walk changes; the previous string-only return
+   * left those edges with no line at all (unknown, which is honest but useless).
+   */
+  extractFunctionCalls(node) {
+    const calls = [];
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (this.isKotlinContextParameterHeader(n)) continue;
+      if (n.type === "call_expression") {
+        const full = this.buildKotlinCallExpression(n);
+        calls.push({ name: full.split(".").pop() || full, node: this.calleeLeafNode(n) ?? n });
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return calls;
+  }
+  analyzeRelationships(node, relationships, symbols, ctx) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "function_declaration") {
+        let receiverNode = void 0;
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c?.type === "simple_identifier") break;
+          if (c?.type === "receiver_type" || c?.type === "user_type" || c?.type === "nullable_type" || c?.type === "type_identifier") {
+            receiverNode = c;
+            break;
+          }
+        }
+        const nameNode = this.findNameNode(n);
+        if (receiverNode && nameNode) {
+          const receiverType = receiverNode.text.endsWith("?") ? receiverNode.text.slice(0, -1) : receiverNode.text;
+          relationships.push({
+            source: nameNode.text,
+            target: receiverType,
+            type: ASTEngine.RelationshipType.Uses,
+            confidence: 0.9,
+            // (#825): the receiver type is named by its receiver node.
+            ...this.lineField(receiverNode, n),
+            metadata: {
+              relationshipType: "kotlin_extension_function",
+              isExtension: true
+            }
+          });
+        }
+        const isComposable = this.extractAnnotations(n, ctx).some((a) => this.kotlinShortAnnotationName(a) === "Composable");
+        if (isComposable && nameNode) {
+          const bodyNode = this.findChildByType(n, ["function_body", "class_body"]);
+          if (bodyNode) {
+            const bodyCalls = this.extractFunctionCalls(bodyNode);
+            for (let i = 0; i < bodyCalls.length; i++) {
+              const call = bodyCalls[i].name;
+              if (call.length > 0 && call[0] >= "A" && call[0] <= "Z") {
+                relationships.push({
+                  source: nameNode.text,
+                  target: call,
+                  // (#825): the UI component is named at its call site.
+                  line_number: bodyCalls[i].node.startPosition.row + 1,
+                  type: ASTEngine.RelationshipType.Contains,
+                  confidence: 0.8,
+                  metadata: {
+                    relationshipType: "compose_ui_tree",
+                    isUiComponent: true,
+                    // KAD-MR3 K18/K4 (M49.K1): a PascalCase-name heuristic is
+                    // NOT verified containment — the tier classifier stamped
+                    // every contains edge "structural" (probe: Intent(...)
+                    // identical to Text(...)). Honest label: heuristic — same
+                    // tier as a 0.5 override guess. The compose edge keeps
+                    // its 0.8 (patterns.ts filters >=0.7), but consumers can
+                    // now distinguish it from verified containment.
+                    evidenceClass: "heuristic"
+                  }
+                });
+              }
+            }
+          }
+        }
+        if (isComposable && nameNode) {
+          const renderBody = this.findChildByType(n, ["function_body"]);
+          if (renderBody) {
+            const composableNames = /* @__PURE__ */ new Set();
+            for (let si = 0; si < symbols.length; si++) {
+              const sym = symbols[si];
+              const symAnns = sym.metadata?.annotations;
+              if (!Array.isArray(symAnns) || symAnns.indexOf("Composable") < 0) continue;
+              if (sym.name === nameNode.text) continue;
+              if (sym.kind !== ASTEngine.SymbolKind.Function && sym.kind !== ASTEngine.SymbolKind.Method) continue;
+              composableNames.add(sym.name);
+            }
+            if (composableNames.size > 0) {
+              const renderCalls = this.extractFunctionCalls(renderBody);
+              for (let ri = 0; ri < renderCalls.length; ri++) {
+                if (!composableNames.has(renderCalls[ri].name)) continue;
+                relationships.push({
+                  source: nameNode.text,
+                  target: renderCalls[ri].name,
+                  // The rendered component is named at its call site.
+                  line_number: renderCalls[ri].node.startPosition.row + 1,
+                  type: ASTEngine.RelationshipType.Renders,
+                  confidence: 0.9,
+                  metadata: {
+                    relationshipType: "compose_render",
+                    isComposableMarker: true,
+                    isComponentCall: true,
+                    // The marker on the source and the target's OWN declaration are both
+                    // read from the tree — structural, unlike the PascalCase heuristic above.
+                    evidenceClass: "structural"
+                  }
+                });
+              }
+            }
+          }
+        }
+      }
+      if (n.type === "call_expression") {
+        const full = this.buildKotlinCallExpression(n);
+        const callName = full.split(".").pop() || "";
+        if (callName === "launch" || callName === "async" || callName === "withContext") {
+          let parentFunc = n.parent;
+          while (parentFunc && parentFunc?.type !== "function_declaration") {
+            parentFunc = parentFunc.parent;
+          }
+          if (parentFunc) {
+            const parentName = this.findNameNode(parentFunc)?.text;
+            if (parentName) {
+              relationships.push({
+                source: parentName,
+                target: callName,
+                type: ASTEngine.RelationshipType.Uses,
+                confidence: 1,
+                // (#825): the dispatcher is named at the call itself.
+                ...this.lineField(this.calleeLeafNode(n, callName), n),
+                metadata: {
+                  relationshipType: "coroutine_dispatch",
+                  isAsync: true
+                }
+              });
+            }
+          }
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    for (let i = 0; i < symbols.length; i++) {
+      const cls = symbols[i];
+      if (cls.kind === ASTEngine.SymbolKind.Class || cls.kind === ASTEngine.SymbolKind.Interface || cls.kind === ASTEngine.SymbolKind.Enum) {
+        if (cls.metadata?.isAnonymousObject) continue;
+        if (cls.metadata?.superTypes) {
+          const ctorCalls = cls.metadata?.superTypesAreConstructorCalls;
+          const superLines = cls.metadata?.superTypeLines;
+          for (let j = 0; j < cls.metadata.superTypes.length; j++) {
+            const isExtends = cls.kind === ASTEngine.SymbolKind.Interface || ctorCalls?.[j] === true;
+            if (!_RealKotlinAnalyzer.publishableEndpoint(cls.name)) continue;
+            if (!_RealKotlinAnalyzer.publishableEndpoint(cls.metadata.superTypes[j])) continue;
+            relationships.push({
+              source: cls.name,
+              target: cls.metadata.superTypes[j],
+              type: isExtends ? ASTEngine.RelationshipType.Extends : ASTEngine.RelationshipType.Implements,
+              confidence: 1,
+              ...typeof superLines?.[j] === "number" ? { line_number: superLines[j] } : {},
+              metadata: { relationshipType: isExtends ? "kotlin_extends" : "kotlin_implements" }
+            });
+          }
+        }
+      }
+    }
+  }
+  /**
+   * The name of a node that is a TOP-LEVEL property declaration, or undefined.
+   *
+   * ONTOLOGY (kotlin, 2026-10-03) — the `Global` fallback, and why it fires on
+   * ordinary, well-formed kotlin.
+   *
+   * The three attribution resolvers (`resolveCallSource` for `calls` /
+   * `instantiates`, `extractDeclaredTypeRefs.resolveSource` for the declared-type
+   * `references` graph, and the `uses` resolver) all walk up the parent chain
+   * looking for a declaration to own the edge, and all three listed the same
+   * three node types:
+   *
+   *     function_declaration | class_declaration | object_declaration
+   *
+   * `property_declaration` was missing from all three. So every edge written
+   * inside a TOP-LEVEL property's own type clause or initializer had no
+   * declaration to stop at, the walk reached `source_file`, and the fallback
+   * returned the literal `"Global"` — a symbol name that appears nowhere in
+   * kotlin and in no file of the corpus.
+   *
+   * MEASURED, by script/m14/kotlin-r7-endpoint-probe.ts on a 1,200-file
+   * every-Nth draw of the pinned fixture corpus (kotlin@9b80c8ff): 1,290 `Global`
+   * sources in files the analyzer reported as CLEAN, i.e. where the grammar had
+   * no trouble at all and the fallback was standing in for nothing. Two real
+   * files, both ordinary shipped `.kt`:
+   *
+   *   CommonJsAndWasmArgumentProviders.kt:101
+   *     private val testBaseDir: Path = Paths.get("").toAbsolutePath()
+   *                                    ^^^^^^^^^^^^^ call sourced to Global
+   *   KaFirSymbol.kt:65
+   *     private val FirBasedSymbol<*>.realPsi: PsiElement?
+   *                                       ^^^^^^^^^^^ declared_type ref sourced to Global
+   *
+   * WHY ONLY WHEN `parent.type === "source_file"`, and this is the load-bearing
+   * condition rather than a detail. A property inside a `class_body` is owned by
+   * its CLASS, and the walk reaches the class first, so it never reaches this
+   * branch — which is the existing, fixture-pinned contract ("calls from
+   * class-level contexts (property initializers, init blocks) belong to the
+   * enclosing class", kotlin/init-attribution). Treating every property as a
+   * boundary would move those edges off the class and onto the property, which is
+   * a different and wrong answer. A TOP-LEVEL property has no enclosing class, so
+   * there is nothing else that could own it and it owns itself — and the
+   * analyzer already publishes it as a `Property` symbol with exactly this name,
+   * so the edge's source resolves to a real symbol.
+   *
+   * `type_alias` is deliberately NOT handled here. A top-level typealias declares
+   * no runtime symbol (the specification expands it at compile time), and the
+   * `exports` rule already excludes it for that reason; giving it edges as an
+   * owner would put a name in the graph that no file can navigate to.
+   */
+  kotlinTopLevelPropertyName(node) {
+    if (node.type === "getter" || node.type === "setter") {
+      const parent = node.parent;
+      if (!parent || parent.type !== "source_file") return void 0;
+      let best;
+      for (let i = 0; i < parent.namedChildCount; i++) {
+        const c = parent.namedChild(i);
+        if (!c || c.type !== "property_declaration") continue;
+        if (c.startPosition.row > node.startPosition.row) continue;
+        if (!best || c.startPosition.row > best.startPosition.row) best = c;
+      }
+      return best ? this.kotlinTopLevelPropertyName(best) : void 0;
+    }
+    if (node.type !== "property_declaration") return void 0;
+    if (node.parent?.type !== "source_file") return void 0;
+    const decl = this.findChildByType(node, ["variable_declaration"]);
+    if (!decl) return void 0;
+    return this.findChildByType(decl, ["simple_identifier", "type_identifier"])?.text;
+  }
+  /**
+   * THE IMPORTED-BINDING CLAIM FOR KOTLIN IMPORTS .
+   *
+   * Two halves, both needed because the arbiter verifies one against the other:
+   *  1. EVIDENCE on the imports edge: `metadata.importedBindings = [binding]` + `metadata.module = <the
+   *     module path as written>` for EXTERNAL imports only. The gate builds file -> specifier -> bound
+   *     names from exactly this pair and verifies claims against it.
+   *  2. CLAIM on the use row: `metadata.importedBinding = { specifier, binding }` on a calls row whose
+   *     callee is BARE (no receiver) or a uses row that is a BARE READ (`isBareRead`), whose target IS the
+   *     imported binding and whose file does not declare a shadowing name.
+   *
+   * REFUSALS (each a way the claim could become false, fail-closed):
+   *  - container root NOT in the EXTERNAL allowlist (only JVM/platform-reserved roots are listed; a
+   *    project-local import is project-resolvable and claiming it would launder — that is why the list is
+   *    the reserved vocabulary and not "anything that looks like a package");
+   *  - an on-demand import (`import a.b.*`) binds no name this file states;
+   *  - the FILE declares the name (the declaration shadows the import — the use is not the binding);
+   *  - a receiver-carrying call / field access row (its target is a member leaf, cut 2);
+   *  - a row that already carries a claim.
+   */
+  attachKotlinImportedBindingClaims(relationships, symbols, imports) {
+    const bindings = /* @__PURE__ */ new Map();
+    const isExternal = (module) => {
+      for (const root of KOTLIN_EXTERNAL_IMPORT_ROOTS) if (module === root || module.startsWith(root)) return true;
+      return false;
+    };
+    for (const imp of imports) {
+      const module = String(imp?.module ?? "");
+      if (module.length === 0) continue;
+      if (imp.isNamespaceImport === true) continue;
+      const dot = module.lastIndexOf(".");
+      const leaf = dot > 0 ? module.slice(dot + 1) : module;
+      const binding = String(imp.metadata?.alias ?? imp.alias ?? "") || leaf;
+      if (!binding || binding === "*") continue;
+      if (!isExternal(module)) continue;
+      bindings.set(binding, module);
+    }
+    if (bindings.size === 0) return;
+    for (const r of relationships) {
+      if (String(r.type ?? "") !== "imports") continue;
+      const specifier = String(r.target ?? "");
+      if (!isExternal(specifier)) continue;
+      const dot = specifier.lastIndexOf(".");
+      const leaf = dot > 0 ? specifier.slice(dot + 1) : specifier;
+      let binding = leaf;
+      for (const [b, spec] of bindings) if (spec === specifier) {
+        binding = b;
+        break;
+      }
+      if (!specifier || !binding || binding === "*") continue;
+      const md = r.metadata = r.metadata ?? {};
+      if (md.importedBindings !== void 0) continue;
+      md.importedBindings = [binding];
+      md.module = specifier;
+    }
+    const fileDeclared = /* @__PURE__ */ new Set();
+    for (const sym of symbols) if (sym?.name) fileDeclared.add(sym.name);
+    for (const r of relationships) {
+      const label = String(r.type ?? "");
+      if (label !== "calls" && label !== "uses") continue;
+      const md = r.metadata ?? {};
+      if (md.importedBinding !== void 0) continue;
+      const target = String(r.target ?? "");
+      if (!target || !bindings.has(target)) continue;
+      if (fileDeclared.has(target)) continue;
+      if (label === "calls") {
+        if (md.kotlinBareCallee !== true) continue;
+      } else if (md.isBareRead !== true) {
+        continue;
+      }
+      r.metadata = { ...md, importedBinding: { specifier: bindings.get(target), binding: target } };
+    }
+  }
+  processImportsExports(node, imports, exports, relationships, symbols, ctx) {
+    const stack = [node];
+    const packageName = ctx.packageStack.join(".");
+    const unitIdentityForImports = this.primaryTopLevelType(symbols);
+    const importSource = unitIdentityForImports?.name || kotlinCompilationUnitName(ctx.currentFile) || packageName || "root";
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "import_header") {
+        const pathNode = this.findChildByType(n, ["identifier"]);
+        if (pathNode && pathNode.text.length > 0) {
+          const importPath = pathNode.text;
+          const aliasNode = this.findChildByType(n, ["import_alias"]);
+          const isWildcard = !!this.findChildByType(n, ["wildcard_import"]);
+          const aliasText = aliasNode ? aliasNode.namedChild(aliasNode.namedChildCount - 1)?.text ?? aliasNode.text : void 0;
+          imports.push({
+            module: importPath,
+            items: isWildcard ? ["*"] : [aliasText ?? (importPath.split(".").pop() || importPath)],
+            isDefaultImport: false,
+            isNamespaceImport: isWildcard,
+            range: this.nodeToRange(n),
+            metadata: {
+              isKotlinImport: true,
+              alias: aliasText
+            }
+          });
+          const importShape = isWildcard ? "imported_package_wildcard" : aliasText ? "imported_declaration_aliased" : "imported_declaration";
+          relationships.push({
+            source: importSource,
+            target: importPath,
+            type: ASTEngine.RelationshipType.Imports,
+            confidence: 0.9,
+            // (#825): the imported path is named on the import statement.
+            ...this.lineField(pathNode, n),
+            metadata: {
+              isKotlinImport: true,
+              // `isImport` is the flag the JVM-family evidence classifier keys on
+              // (see classifyEvidenceTier). Without it an `imports` edge would be
+              // filed as `usage_contextual` and be indistinguishable from a
+              // heuristic in a payload.
+              isImport: true,
+              relationshipType: importShape,
+              importShape,
+              isWildcard,
+              // The same fact under the ontology's own spelling
+              // (kotlin/imports-exports-ontology pins `meta.isWildcardImport`),
+              // beside the lane's `isWildcard`: the wildcard form IS the fact
+              // that separates `import a.b.*` from `import a.b.C`, and a consumer
+              // reading either name must not have to guess which one this lane
+              // chose. Emitted only when true — an absent flag is not a false one.
+              ...isWildcard ? { isWildcardImport: true } : {},
+              ...aliasText ? { alias: aliasText } : {},
+              ...packageName ? {} : { rootPackageFile: true },
+              reasonCode: "declared-import-path"
+            }
+          });
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    this.emitKotlinExportRelationships(symbols, relationships, ctx, node);
+  }
+  /**
+   * ONTOLOGY (kotlin, 2026-10-03): the `exports` LABEL — a relationship behind
+   * an export surface that already existed as data.
+   *
+   * BEFORE: the loop in `analyze()` filled `ParseResult.exports` and NONE of its
+   * rows reached a relationship, so the lane published a public-API list and no
+   * graph edge. Measured on 300 tracked files of
+   * the pinned fixture corpus (kotlin@9b80c8ff) before this change: 0 `exports`
+   * edges. On a 1,500-file window the `ExportInfo` list held 2,809 rows and the
+   * relationship list held none.
+   *
+   * THE RULE, and every clause of it is a kotlin language fact:
+   *
+   *   1. TOP-LEVEL ONLY — `!s.ownerName`. A member is reached through its
+   *      container, and membership is already published as `contains`; publishing
+   *      it twice would make `contains` and `exports` two names for one edge.
+   *      Measured on the window: 16,694 nested declarations against 7,554
+   *      top-level ones, so this clause governs the majority of the population.
+   *   2. NOT LEXICALLY LOCAL — see `isKotlinLocalDeclaration`. "No ownerName" is
+   *      NOT the same predicate as "top level": a class or function declared
+   *      inside a function body gets no owner in this analyzer, because
+   *      `isMemberPosition` is only true inside a `class_body`. Measured: 148 of
+   *      2,809 ownerless public symbols on the window are local declarations
+   *      (`KaFirCompilerFacility.kt:467 function register`, `:584 mapModule`,
+   *      `:594 appendDanglingChunk`), and the pre-existing `ExportInfo` loop
+   *      published every one of them. A local function is callable from exactly
+   *      one lexical scope, so an `exports` edge claiming a module publishes it
+   *      would be a fabricated edge in `bb_migrate`.
+   *   3. PUBLIC ONLY — `visibility === "public" || undefined`. Kotlin's default
+   *      visibility is public, `private` is file-scoped and `internal` is
+   *      module-scoped; neither of the latter is reachable by name from another
+   *      module, which is the reachability an `imports` edge asserts from the
+   *      other side. Measured on the window: 1,719 `internal` and 657 `private`
+   *      top-level declarations excluded.
+   *   4. NOT SYNTHESIZED — `!isPhantom && !isAnonymousObject`. A data class's
+   *      `componentN`/`copy`/`equals` are written nowhere; an anonymous object is
+   *      named by no import.
+   *   5. NOT A SCRIPT — a `.kts` file's top-level declarations become members of
+   *      the script's class and are not importable by any other file, so a script
+   *      publishes no API. Measured: 12 script top-level declarations in a
+   *      3,000-file window, all of them also excluded by clause 6.
+   *   6. THE FILE MUST NAME A PACKAGE — the source of the edge IS the package, and
+   *      kotlin's root package has no name to publish it under. THIS IS THE ONE
+   *      CLAUSE THAT IS NOT A LANGUAGE RULE. Kotlin, unlike java (JLS 7.4.2), does
+   *      not forbid importing from the unnamed package, so excluding these claims
+   *      a restriction the language does not make; it is a LIMITATION of the edge
+   *      shape, declared as one, with its cost measured rather than assumed: 693 of
+   *      2,613 top-level ownerless public declarations on the window sit in the
+   *      root package, 3 of them in `.kt` files and the rest in `testData`
+   *      fragments (the corpus is 71% `testData/`). On the production subset
+   *      1,045 of 1,056 files carry a package header and 0 of 1,748 top-level
+   *      public declarations are excluded by this clause. Publishing them under a
+   *      placeholder source instead would put a fabricated symbol name into
+   *      `bb_graph` for a quarter of the population, which is the worse of the
+   *      two failures and is the reason standing rule R7 forbids it.
+   *
+   * Confidence 1.0: the edge is a modifier read plus a position test with no
+   * inference in it, so it is a fact about the source rather than a heuristic.
+   * `evidenceClass` is left to `classifyEvidenceTier`, which already files
+   * `exports` as `structural` — one place, so the two cannot disagree.
+   */
+  emitKotlinExportRelationships(symbols, relationships, ctx, root) {
+    const packageName = ctx.packageStack.join(".");
+    if (!packageName) return;
+    if (ctx.currentFile.toLowerCase().endsWith(".kts")) return;
+    const unitType = this.primaryTopLevelType(symbols);
+    if (!unitType) return;
+    const placement = this.kotlinDeclarationPlacement(root, ctx.content.split("\n").length);
+    for (let i = 0; i < symbols.length; i++) {
+      const s = symbols[i];
+      if (s.metadata?.isPhantom || s.metadata?.isAnonymousObject) continue;
+      if (s.visibility !== "public" && s.visibility !== void 0) continue;
+      if (s.ownerName) continue;
+      if (!s.name) continue;
+      const declLine = s.range?.startLine ?? 0;
+      if (declLine < 1 || declLine >= placement.local.length) continue;
+      if (placement.local[declLine]) continue;
+      if (!placement.top[declLine]) continue;
+      relationships.push({
+        source: unitType.name,
+        target: s.name,
+        type: ASTEngine.RelationshipType.Exports,
+        confidence: 1,
+        // (#825): the exported name is written on the declaration.
+        ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+        metadata: {
+          isKotlinExport: true,
+          relationshipType: "exported_declaration",
+          // The PUBLISHER of this row is the compilation unit, spelled as the
+          // file's top-level type. `moduleIdentity` says which rule chose it, so
+          // a consumer reading three exports spellings in this lane can tell
+          // which one answers which question without matching on the source text.
+          moduleIdentity: "primary-top-level-type",
+          kind: String(s.kind),
+          // `exportKind` is the same fact under the name the ontology fixtures
+          // pin (kotlin/imports-exports-ontology), kept beside `kind` rather than
+          // replacing it: `kind` is the symbol's own predicate and `exportKind`
+          // is what the surface calls it, and a consumer reading either must not
+          // have to guess which spelling this lane chose.
+          exportKind: String(s.kind),
+          visibility: s.visibility || "public",
+          // The join key with `imports`, stated because it is not obvious: an
+          // `exports` edge is `package -> simpleName`, so `source + "." + target`
+          // is exactly the dotted path an `imports` edge targets.
+          dottedName: `${packageName}.${s.name}`
+        }
+      });
+    }
+  }
+  /**
+   * Which start lines carry a TOP-LEVEL declaration, and which carry one nested
+   * inside a body — a function body, a lambda, an initializer, a class body.
+   *
+   * WHY A SEPARATE PASS RATHER THAN A PER-SYMBOL WALK. The rule "no ownerName
+   * means top level" is wrong, and the way it is wrong is that a declaration
+   * inside a function body carries no owner in this analyzer (`isMemberPosition`
+   * is only true inside a `class_body`). Measured on a 1,500-file window: 148 of
+   * 2,809 ownerless public symbols are such local declarations, and the
+   * pre-existing `ExportInfo` loop published every one of them as an export. A
+   * local function is callable from exactly one lexical scope, so publishing it
+   * as module API would be a fabricated edge in `bb_migrate`.
+   *
+   * A per-symbol walk up from the symbol's own line would be an
+   * O(symbols x tree) scan, and this lane's complexity envelope forbids that in a
+   * hot path. So the tree is walked ONCE, carrying a boolean for "am I inside a
+   * body", and the answer is recorded per declaration start line. Each symbol is
+   * then two Set lookups. The walk is iterative, like the rest of this analyzer:
+   * a kotlin file nests deeper than a worker thread's JS stack should be asked
+   * for.
+   *
+   * Two earlier versions of the measuring probe got this wrong in ways that would
+   * have certified a fabricated rule as measured, and both are recorded because
+   * both produced a confident zero:
+   *   - one took the first ancestor whose TEXT contained the symbol's name, which
+   *     is `source_file` for every symbol, so it answered "top level" 64 times out
+   *     of 64;
+   *   - one used tree DEPTH, and `tree-sitter-kotlin` wraps a file in
+   *     `source_file`, so a top-level declaration sits at depth 2 and the probe
+   *     read 0 top-level declarations on a corpus where every file has some.
+   */
+  kotlinDeclarationPlacement(root, lineCount) {
+    const DECL = /* @__PURE__ */ new Set([
+      "class_declaration",
+      "object_declaration",
+      "function_declaration",
+      "property_declaration",
+      "type_alias"
+    ]);
+    const BODY = /* @__PURE__ */ new Set([
+      "function_body",
+      "lambda_literal",
+      "anonymous_initializer",
+      "secondary_constructor",
+      "class_body",
+      "object_literal",
+      "catch_block",
+      "do_while_statement",
+      "while_statement",
+      "for_statement"
+    ]);
+    const rows = Math.max(1, lineCount) + 2;
+    const local = new Uint8Array(rows);
+    const top = new Uint8Array(rows);
+    const nameRow = (n) => {
+      for (let k = 0; k < n.namedChildCount; k++) {
+        const c = n.namedChild(k);
+        if (!c || c.type === "modifiers") continue;
+        if (c.type === "type_identifier" || c.type === "simple_identifier") return c.startPosition.row + 1;
+        if (c.type === "variable_declaration") {
+          for (let m = 0; m < c.namedChildCount; m++) {
+            const g = c.namedChild(m);
+            if (g && g.type === "simple_identifier") return g.startPosition.row + 1;
+          }
+        }
+      }
+      return null;
+    };
+    const stack = [{ n: root, inBody: false }];
+    while (stack.length > 0) {
+      const { n, inBody } = stack.pop();
+      const here = inBody || BODY.has(n.type);
+      if (DECL.has(n.type)) {
+        const startRow = n.startPosition.row + 1;
+        const named = nameRow(n);
+        const endRow = named && named > startRow ? named : startRow;
+        const into = here ? local : top;
+        for (let r = startRow; r <= endRow && r < rows; r++) into[r] = 1;
+      }
+      for (let k = n.namedChildCount - 1; k >= 0; k--) {
+        const c = n.namedChild(k);
+        if (c) stack.push({ n: c, inBody: here });
+      }
+    }
+    return { local, top };
+  }
+  // KAD-MR3 K6 (M49.K1): performKotlinTypeInference was DEAD MACHINERY — it
+  // gated on SymbolKind.Variable, but the extractor emits Property symbols
+  // and no Variable kind, so every branch (is/has→Boolean,
+  // remember/mutableStateOf→MutableState) was unreachable (probe: kinds
+  // [class, method], zero Variables). Deleted rather than fed — fabricating
+  // return types from NAME PREFIXES ("isValid→Boolean") is a guessing
+  // heuristic masquerading as inference. metadata.hasTypeInference stays
+  // (declared-type extraction IS real inference input).
+  getKotlinFrameworkPatterns(frameworks, symbols) {
+    const patterns = [];
+    for (let i = 0; i < frameworks.length; i++) {
+      const fw = frameworks[i];
+      if (fw === "Jetpack Compose") {
+        let hasUI = false, hasState = false;
+        for (let j = 0; j < symbols.length; j++) {
+          const s = symbols[j];
+          if (s.metadata?.annotations) {
+            for (let k = 0; k < s.metadata.annotations.length; k++) {
+              if (s.metadata.annotations[k] === "Composable") hasUI = true;
+            }
+          }
+          if (s.qualified_calls) {
+            for (let k = 0; k < s.qualified_calls.length; k++) {
+              if (s.qualified_calls[k] === "remember" || s.qualified_calls[k] === "mutableStateOf") hasState = true;
+            }
+          }
+        }
+        const fwPatterns = [];
+        if (hasUI) fwPatterns.push("ui_components");
+        if (hasState) fwPatterns.push("state_management");
+        patterns.push({ framework: fw, patterns: fwPatterns });
+      } else if (fw === "Android SDK") {
+        let hasMvvm = false, hasLifecycle = false;
+        for (let j = 0; j < symbols.length; j++) {
+          const s = symbols[j];
+          if (s.metadata?.superTypes) {
+            for (let k = 0; k < s.metadata.superTypes.length; k++) {
+              if (s.metadata.superTypes[k] === "ViewModel") hasMvvm = true;
+              if (s.metadata.superTypes[k] === "Activity" || s.metadata.superTypes[k] === "Fragment") hasLifecycle = true;
+            }
+          }
+        }
+        const fwPatterns = [];
+        if (hasMvvm) fwPatterns.push("mvvm_architecture");
+        if (hasLifecycle) fwPatterns.push("android_lifecycle");
+        patterns.push({ framework: fw, patterns: fwPatterns });
+      } else if (fw === "Room") {
+        let hasEntities = false, hasDaos = false;
+        for (let j = 0; j < symbols.length; j++) {
+          const s = symbols[j];
+          if (s.metadata?.annotations) {
+            for (let k = 0; k < s.metadata.annotations.length; k++) {
+              if (s.metadata.annotations[k] === "Entity") hasEntities = true;
+              if (s.metadata.annotations[k] === "Dao") hasDaos = true;
+            }
+          }
+        }
+        const fwPatterns = [];
+        if (hasEntities) fwPatterns.push("database_entities");
+        if (hasDaos) fwPatterns.push("data_access_objects");
+        patterns.push({ framework: fw, patterns: fwPatterns });
+      } else if (fw === "Spring Boot") {
+        let hasRest = false, hasService = false;
+        for (let j = 0; j < symbols.length; j++) {
+          const s = symbols[j];
+          if (s.metadata?.annotations) {
+            for (let k = 0; k < s.metadata.annotations.length; k++) {
+              if (s.metadata.annotations[k] === "RestController") hasRest = true;
+              if (s.metadata.annotations[k] === "Service") hasService = true;
+            }
+          }
+        }
+        const fwPatterns = [];
+        if (hasRest) fwPatterns.push("rest_controllers");
+        if (hasService) fwPatterns.push("services");
+        patterns.push({ framework: fw, patterns: fwPatterns });
+      }
+    }
+    return patterns;
+  }
+  generateArchitecturalInsights(symbols, relationships) {
+    const insights = [];
+    let viewModelsCount = 0, composablesCount = 0, suspendCount = 0;
+    for (let i = 0; i < symbols.length; i++) {
+      const s = symbols[i];
+      if (s.metadata?.superTypes) {
+        for (let j = 0; j < s.metadata.superTypes.length; j++) {
+          if (s.metadata.superTypes[j] === "ViewModel") viewModelsCount++;
+        }
+      }
+      if (s.metadata?.annotations) {
+        for (let j = 0; j < s.metadata.annotations.length; j++) {
+          if (s.metadata.annotations[j] === "Composable") composablesCount++;
+        }
+      }
+      if (s.metadata?.modifiers) {
+        for (let j = 0; j < s.metadata.modifiers.length; j++) {
+          if (s.metadata.modifiers[j] === "suspend") suspendCount++;
+        }
+      }
+    }
+    if (viewModelsCount > 0) {
+      insights.push({
+        type: "architecture",
+        category: "android_mvvm",
+        message: `Detected ${viewModelsCount} ViewModels, indicating MVVM architecture.`,
+        severity: "info"
+      });
+    }
+    if (composablesCount > 0) {
+      insights.push({
+        type: "ui_framework",
+        category: "compose",
+        message: `Jetpack Compose UI detected with ${composablesCount} composable functions.`,
+        severity: "info"
+      });
+    }
+    if (suspendCount > 0) {
+      insights.push({
+        type: "concurrency",
+        category: "coroutines",
+        message: `Coroutine usage detected with ${suspendCount} suspend functions.`,
+        severity: "info"
+      });
+    }
+    return insights;
+  }
+  calculateArchitecturalScore(symbols, relationships, patterns) {
+    let score = 80;
+    for (let i = 0; i < patterns.length; i++) {
+      if (patterns[i] === "Jetpack Compose") score += 5;
+      if (patterns[i] === "Coroutines") score += 5;
+      if (patterns[i] === "Data Classes") score += 5;
+    }
+    return Math.min(100, score);
+  }
+  assessKotlinCodeQuality(symbols, relationships, patterns) {
+    const score = this.calculateArchitecturalScore(symbols, relationships, patterns);
+    if (score >= 90) return "excellent";
+    if (score >= 80) return "good";
+    if (score >= 60) return "fair";
+    return "poor";
+  }
+};
+export {
+  RealKotlinAnalyzer
+};