@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-scala-analyzer-TSTW27J6.js

@@ -0,0 +1,3293 @@
+import {
+  findDeclaringParent
+} from "./chunk-OWISBAOF.js";
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.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-scala-analyzer.ts
+var COMPOUND_ASSIGN_OPS = /* @__PURE__ */ new Set(["+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=", ">>>="]);
+function scalaOperatorIsAssignment(op) {
+  if (!op || !op.endsWith("=")) return false;
+  if (COMPOUND_ASSIGN_OPS.has(op)) return true;
+  if (op.endsWith("==") || op.endsWith("<=") || op.endsWith(">=")) return false;
+  if (op.includes("=:=") || op.includes("<:<")) return false;
+  if (op === "=>" || op === "<-" || op === "<:" || op === ">:" || op === "=:") return false;
+  return true;
+}
+function stripScalaQuoting(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 sigHasTypeVar(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 isSelfOverride(declaring, ownerName) {
+  return !!declaring && !!ownerName && declaring === ownerName;
+}
+var SCALA_JVM_PLATFORM_ROOTS = /* @__PURE__ */ new Set(["java", "javax", "sun"]);
+var SCALA_CLAIM_KEYS_ON_EDGE = [
+  "localBinding",
+  "remoteRef",
+  "importProjectFile",
+  "languageNamespace",
+  "sourcePathClaim",
+  "importOutsideProject",
+  "baseBeyondRunScope",
+  "isExternal",
+  "isExternalTarget",
+  "isStdlib",
+  "stdlibModule",
+  "isExternalBase",
+  "external",
+  "externalRef"
+];
+var SCALA_RESERVED = /* @__PURE__ */ new Set([
+  "abstract",
+  "case",
+  "catch",
+  "class",
+  "def",
+  "do",
+  "else",
+  "extends",
+  "false",
+  "final",
+  "finally",
+  "for",
+  "if",
+  "implicit",
+  "import",
+  "lazy",
+  "macro",
+  "match",
+  "new",
+  "null",
+  "object",
+  "override",
+  "package",
+  "private",
+  "protected",
+  "return",
+  "sealed",
+  "super",
+  "this",
+  "throw",
+  "trait",
+  "true",
+  "try",
+  "type",
+  "val",
+  "var",
+  "while",
+  "with",
+  "yield",
+  // Scala 3 reserved additions
+  "given",
+  "enum",
+  "export"
+]);
+function isKeywordUsedAsName(name) {
+  return SCALA_RESERVED.has(name);
+}
+var RealScalaAnalyzer = class _RealScalaAnalyzer {
+  // S1.21: stable per-file counter for anonymous given names (see handleGiven).
+  // Reset at the top of every analyze() so each file counts from 1.
+  givenCounter = 0;
+  // M60: per-file anonymous-CLASS name disambiguation, same contract as
+  // givenCounter above. `anonymous_<SuperName>` is only unique within its supertype,
+  // and a file routinely declares several anonymous classes of the SAME supertype.
+  // Measured on the full scala3 corpus: 3,330 anonymous symbols across 1,503 files,
+  // of which **402 files declare a DUPLICATE name** (517 collisions).
+  //
+  // The cost was not cosmetic. `CheckCaptures.scala` declares FOUR distinct
+  // `anonymous_TypeTraverser` classes (lines 161, 363, 384, 2308), and all their
+  // members were published under ONE owner: 8 contains rows drawn from 4 different
+  // classes, 7 of them attributed to the wrong one, with `traverse` appearing four
+  // times under the same owner and collapsing to a single row after the harness's
+  // (label, target) dedupe. One node where the source has four.
+  //
+  // The FIRST occurrence keeps the bare name, so every existing pin on
+  // `anonymous_Runnable -> run` still holds; later ones take `#2`, `#3`, ... in
+  // source order, which is rename-stable under upstream line insertions the same way
+  // given_N is.
+  anonNameUse = /* @__PURE__ */ new Map();
+  analyze(rootNode, content, filePath, context) {
+    const symbols = [];
+    const imports = [];
+    const relationships = [];
+    const exports = [];
+    this.givenCounter = 0;
+    this.anonNameUse = /* @__PURE__ */ new Map();
+    const patternsObj = {};
+    const frameworksObj = {};
+    let hasTypes = false;
+    let cyclomaticComplexity = 0;
+    const metadata = {
+      linesOfCode: 0,
+      complexity: 0,
+      architecturalScore: 85,
+      codeQuality: "excellent",
+      hasTypeInference: false,
+      hasFrameworkIntelligence: true,
+      analysisVersion: "scala-2.0",
+      detectedFrameworks: [],
+      patterns: []
+    };
+    if (!rootNode) {
+      return {
+        symbols,
+        imports,
+        relationships,
+        exports,
+        metadata,
+        errors: []
+      };
+    }
+    if (rootNode.hasError) {
+      let reportedNodes = 0;
+      const errStack = [rootNode];
+      while (errStack.length > 0) {
+        const n = errStack.pop();
+        if (n.type === "ERROR" || n.isMissing) {
+          reportedNodes++;
+          if (!metadata.errors) metadata.errors = [];
+          metadata.errors.push({
+            message: `Syntax ${n.type} detected. The Brain Engine is bypassing this broken node.`,
+            range: {
+              startLine: n.startPosition.row + 1,
+              startColumn: n.startPosition.column + 1,
+              endLine: n.endPosition.row + 1,
+              endColumn: n.endPosition.column + 1,
+              startIndex: n.startIndex,
+              endIndex: n.endIndex
+            },
+            severity: "warning"
+          });
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const child = n.namedChild(i);
+          if (child) errStack.push(child);
+        }
+      }
+      if (reportedNodes === 0) {
+        if (!metadata.errors) metadata.errors = [];
+        metadata.errors.push({
+          message: "Syntax error detected. The parser flagged this file (rootNode.hasError) but recovered no ERROR or MISSING node to name, so no specific node is bypassed.",
+          range: {
+            startLine: 1,
+            startColumn: 1,
+            endLine: 1,
+            endColumn: 1,
+            startIndex: 0,
+            endIndex: 0
+          },
+          severity: "warning"
+        });
+      }
+    }
+    let loc = 1;
+    for (let i = 0; i < content.length; i++) {
+      if (content[i] === "\n") loc++;
+    }
+    metadata.linesOfCode = loc;
+    const typeIndex = /* @__PURE__ */ new Map();
+    const typeIndexByKind = /* @__PURE__ */ new Map();
+    const typesByKindPos = /* @__PURE__ */ new Map();
+    const kindKey = (name, kind) => `${kind}:${name}`;
+    const indexType = (s) => {
+      if (!typeIndex.has(s.name)) typeIndex.set(s.name, s);
+      const kk = kindKey(s.name, s.kind);
+      if (!typeIndexByKind.has(kk)) typeIndexByKind.set(kk, s);
+      let arr = typesByKindPos.get(kk);
+      if (!arr) {
+        arr = [];
+        typesByKindPos.set(kk, arr);
+      }
+      arr.push(s);
+    };
+    const resolveOwner = (s) => {
+      if (s.ownerKind) {
+        const kk = kindKey(s.ownerName ?? "", s.ownerKind);
+        const exact = typeIndexByKind.get(kk);
+        if (exact) {
+          const all = typesByKindPos.get(kk);
+          if (!all || all.length < 2) return exact;
+          const line = s.range?.startLine ?? 0;
+          for (const cand of all) {
+            const st = cand.range?.startLine ?? 0;
+            const en = cand.range?.endLine ?? st;
+            if (line >= st && line <= en) return cand;
+          }
+          return exact;
+        }
+      }
+      return typeIndex.get(s.ownerName ?? "");
+    };
+    const stack = [{ node: rootNode, parent: null }];
+    while (stack.length > 0) {
+      const popped = stack.pop();
+      if (!popped) continue;
+      const { node, parent } = popped;
+      let currentParent = parent;
+      if (node.type === "package_clause") {
+        const pkgId = this.findChild(node, "package_identifier");
+        const pkgChildren = [];
+        const walkPkg = (n) => {
+          if (n.type === "identifier") pkgChildren.push(n.text);
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const ch = n.namedChild(i);
+            if (ch) walkPkg(ch);
+          }
+        };
+        if (pkgId) walkPkg(pkgId);
+        if (pkgChildren.length > 0) {
+          metadata.packageName = pkgChildren.join(".");
+          patternsObj["Packages"] = true;
+        }
+      } else if (node.type === "class_definition") {
+        const cls = this.handleClass(node, symbols, relationships, exports, patternsObj, parent);
+        if (cls) {
+          currentParent = cls;
+          indexType(cls);
+        }
+      } else if (node.type === "object_definition") {
+        const obj = this.handleObject(node, symbols, relationships, exports, patternsObj, parent);
+        if (obj) {
+          currentParent = obj;
+          indexType(obj);
+        }
+      } else if (node.type === "trait_definition") {
+        const tr = this.handleTrait(node, symbols, relationships, exports, patternsObj, parent);
+        if (tr) {
+          currentParent = tr;
+          indexType(tr);
+        }
+      } else if (node.type === "function_definition" || node.type === "function_declaration") {
+        const fn = this.handleFunction(node, symbols, relationships, exports, patternsObj, parent);
+        if (fn) currentParent = fn;
+      } else if (node.type === "val_definition" || node.type === "var_definition" || node.type === "val_declaration" || node.type === "var_declaration") {
+        this.handleVariable(node, symbols, exports, parent);
+      } else if (node.type === "type_definition") {
+        this.handleTypeAlias(node, symbols, parent, exports);
+      } else if (node.type === "import_declaration") {
+        this.handleImport(node, imports);
+      } else if (node.type === "enum_definition") {
+        const en = this.handleEnum(node, symbols, relationships, exports, patternsObj, parent);
+        if (en) {
+          currentParent = en;
+          indexType(en);
+        }
+      } else if (node.type === "given_definition") {
+        const g = this.handleGiven(node, symbols, relationships, exports, patternsObj, parent);
+        if (g) {
+          currentParent = g;
+          indexType(g);
+        }
+      } else if (node.type === "extension_definition") {
+        patternsObj["Extension Methods (Scala 3)"] = true;
+      } else if (node.type === "export_declaration") {
+        patternsObj["Exports (Scala 3)"] = true;
+        this.handleExportClause(node, relationships, currentParent);
+      } else if (node.type === "match_expression") {
+        patternsObj["Case Classes & Pattern Matching"] = true;
+      } else if (node.type === "for_expression") {
+        patternsObj["For Comprehensions"] = true;
+      } else if (node.type === "type_identifier" || node.type === "type") {
+        hasTypes = true;
+      } else if (node.type === "annotation") {
+        const short = this.annotationShortName(node);
+        if (short === "Test" || short === "main") patternsObj["Annotations"] = true;
+        if (short === "BeanProperty") patternsObj["Java Interop"] = true;
+        if (short === "tailrec") patternsObj["Tail Recursion"] = true;
+        if (short === "specialized") patternsObj["Specialized Generics"] = true;
+      } else if (node.type === "catch_clause") {
+        patternsObj["Error Handling"] = true;
+      } else if (node.type === "lambda_expression") {
+        patternsObj["Lambdas"] = true;
+      } else if (node.type === "self_type") {
+        patternsObj["Self Types"] = true;
+      } else if (node.type === "context_bound") {
+        patternsObj["Type Classes (Context Bounds)"] = true;
+      } else if (node.type === "infix_expression" || node.type === "infix_type") {
+        patternsObj["Infix Notation"] = true;
+      } else if (node.type === "interpolated_string_expression" || node.type === "interpolated_string") {
+        patternsObj["String Interpolation"] = true;
+      } else if (node.type === "derives_clause") {
+        patternsObj["Derives (Typeclass Derivation)"] = true;
+      } else if (node.type === "package_object") {
+        patternsObj["Package Objects"] = true;
+      } else if (node.type === "throw_expression" || node.type === "throw") {
+        const thrown = node.namedChild(0);
+        if (thrown) {
+          let target;
+          if (thrown.type === "instance_expression") {
+            const typeNode = thrown.namedChild(0);
+            if (typeNode) {
+              target = typeNode.type === "generic_type" ? typeNode.namedChild(0)?.text ?? typeNode.text : typeNode.text;
+            }
+          } else if (thrown.type === "identifier") {
+            target = thrown.text;
+          } else if (thrown.type === "call_expression") {
+            const callee = thrown.childForFieldName("function");
+            if (callee) {
+              const kids = [];
+              for (let i = 0; i < callee.namedChildCount; i++) {
+                const c = callee.namedChild(i);
+                if (c && c.type === "identifier") kids.push(c.text);
+              }
+              target = kids.length > 0 ? kids[kids.length - 1] : callee.text.split("[")[0];
+            }
+          } else if (thrown.type === "field_expression") {
+            target = thrown.text;
+          }
+          if (target) {
+            relationships.push({
+              // S1.7: ONE top-level sentinel — throws join calls/refs on
+              // "(script)" (was "global", the third disconnected root node).
+              source: parent?.name || "(script)",
+              target,
+              type: ASTEngine.RelationshipType.References,
+              // S1.4 (M49 #715): explicit confidence — undefined is treated
+              // as 1 by the classifier but filtered inconsistently by
+              // downstream >= 0.7 consumers. A throw target is structural.
+              confidence: 0.95,
+              // M59 (#825): the throw target is named at the throw expression.
+              line_number: (thrown ?? node).startPosition.row + 1,
+              metadata: { scalaSpecific: true, isThrow: true, relationshipType: "throw_target" }
+            });
+          }
+        }
+      } else if (node.type === "opaque_modifier") {
+        patternsObj["Opaque Types (Scala 3)"] = true;
+      } else if (node.type === "inline_modifier" || node.type === "transparent_modifier") {
+        patternsObj["Inline Methods (Scala 3)"] = true;
+      } else if (node.type === "using") {
+        patternsObj["Using Clauses (Scala 3)"] = true;
+      } else if (node.type === "implicit") {
+        patternsObj["Implicit Parameters & Conversions"] = true;
+      } else if (node.type === "lazy") {
+        patternsObj["Lazy Initialization"] = true;
+      } else if (node.type === "override") {
+        patternsObj["Override/Polymorphism"] = true;
+      }
+      if (node.type === "call_expression") {
+        this.handleCall(node, relationships, patternsObj, parent);
+      } else if (node.type === "instance_expression") {
+        this.handleInstantiation(node, relationships, parent);
+        const templateBody = this.findChild(node, "template_body");
+        if (templateBody) {
+          const typeNode = node.namedChild(0);
+          const superName = this.stripTypeArgs(this.scalaAnonymousSupertypeName(typeNode));
+          const anonBase = superName ? `anonymous_${superName}` : "anonymous_object";
+          const seen = this.anonNameUse.get(anonBase) ?? 0;
+          this.anonNameUse.set(anonBase, seen + 1);
+          const anonName = seen === 0 ? anonBase : `${anonBase}#${seen + 1}`;
+          const anonSym = {
+            name: anonName,
+            kind: ASTEngine.SymbolKind.Class,
+            range: {
+              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
+            },
+            visibility: "public",
+            ownerName: parent?.name,
+            ownerKind: parent?.kind,
+            metadata: { isAnonymousObject: true, superTypes: superName ? [superName] : [], scalaSpecific: true }
+          };
+          symbols.push(anonSym);
+          indexType(anonSym);
+          currentParent = anonSym;
+        }
+      }
+      if (node.type === "if_expression" || node.type === "while_expression" || node.type === "do_while_expression" || node.type === "for_expression") {
+        cyclomaticComplexity++;
+      } else if (node.type === "case_clause") {
+        cyclomaticComplexity++;
+      } else if (node.type === "infix_expression") {
+        const op = node.childForFieldName("operator")?.text;
+        if (op === "&&" || op === "||") cyclomaticComplexity++;
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) {
+          stack.push({ node: child, parent: currentParent });
+        }
+      }
+    }
+    this.detectFrameworks(imports, frameworksObj);
+    this.detectCompanionObjects(symbols, patternsObj);
+    metadata.hasTypeInference = hasTypes;
+    metadata.complexity = cyclomaticComplexity + 1;
+    metadata.cyclomaticComplexity = cyclomaticComplexity + 1;
+    for (const fw in frameworksObj) metadata.detectedFrameworks.push(fw);
+    for (const pat in patternsObj) metadata.patterns.push(pat);
+    {
+      const extByOwnerName = /* @__PURE__ */ new Map();
+      for (const s of symbols) {
+        const recv = s.metadata?.extensionReceiver;
+        if (!recv) continue;
+        const own = s.ownerName ?? "";
+        let byName = extByOwnerName.get(own);
+        if (!byName) {
+          byName = /* @__PURE__ */ new Map();
+          extByOwnerName.set(own, byName);
+        }
+        const list = byName.get(s.name);
+        if (list) list.push(s);
+        else byName.set(s.name, [s]);
+      }
+      const receiverLeaf = (t) => {
+        let s = t;
+        const cut = s.indexOf("[");
+        if (cut > 0) s = s.slice(0, cut);
+        const dot = s.lastIndexOf(".");
+        if (dot >= 0) s = s.slice(dot + 1);
+        return s.trim();
+      };
+      for (const byName of extByOwnerName.values()) {
+        for (const group of byName.values()) {
+          if (group.length < 2) continue;
+          const receivers = new Set(group.map((s) => String(s.metadata.extensionReceiver)));
+          if (receivers.size < 2) continue;
+          for (const s of group) {
+            const leaf = receiverLeaf(String(s.metadata.extensionReceiver));
+            const renamed = leaf.length > 0 ? `${s.name}@${leaf}` : `${s.name}@ext${group.indexOf(s) + 1}`;
+            for (const r of relationships) {
+              if (r.metadata?.relationshipType !== "scala_extension_method") continue;
+              if (r.source !== s.name) continue;
+              if (r.target !== s.metadata.extensionReceiver) continue;
+              r.source = renamed;
+            }
+            s.name = renamed;
+            s.id = s.ownerName ? `${s.ownerName}.${renamed}` : renamed;
+          }
+        }
+      }
+    }
+    const sigText = (m) => "(" + (m.parameters ?? []).map((p) => this.compactType(p.type || "unknown")).join(",") + ")";
+    const hasTypeVar = (sig) => sigHasTypeVar(sig);
+    const methodSigsByOwner = /* @__PURE__ */ new Map();
+    const nonPrivateMethodsByOwner = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      if (s.kind !== ASTEngine.SymbolKind.Method || !s.ownerName || s.visibility === "private") continue;
+      let byName = nonPrivateMethodsByOwner.get(s.ownerName);
+      if (!byName) {
+        byName = /* @__PURE__ */ new Map();
+        nonPrivateMethodsByOwner.set(s.ownerName, byName);
+      }
+      let arr = byName.get(s.name);
+      if (!arr) {
+        arr = [];
+        byName.set(s.name, arr);
+      }
+      arr.push(s);
+    }
+    const sigTextElided = (m) => {
+      const ps = m.parameters ?? [];
+      let end = ps.length;
+      while (end > 0 && ps[end - 1].isImplicit) end--;
+      return sigText({ ...m, parameters: ps.slice(0, end) });
+    };
+    for (const s of symbols) {
+      if (s.kind !== ASTEngine.SymbolKind.Method || !s.ownerName || s.metadata?.isPhantom) continue;
+      let byName = methodSigsByOwner.get(s.ownerName);
+      if (!byName) {
+        byName = /* @__PURE__ */ new Map();
+        methodSigsByOwner.set(s.ownerName, byName);
+      }
+      let sigs = byName.get(s.name);
+      if (!sigs) {
+        sigs = /* @__PURE__ */ new Set();
+        byName.set(s.name, sigs);
+      }
+      sigs.add(sigText(s));
+      sigs.add(sigTextElided(s));
+    }
+    const findDeclaringAncestor = (s) => {
+      const ownerSym = resolveOwner(s);
+      if (!ownerSym) return null;
+      const sig = sigText(s);
+      const seen = /* @__PURE__ */ new Set();
+      const queue = [...ownerSym.metadata?.superTypes ?? []];
+      while (queue.length > 0) {
+        const parent = queue.shift();
+        if (seen.has(parent)) continue;
+        seen.add(parent);
+        const parentMethods = methodSigsByOwner.get(parent);
+        const parentSigs = parentMethods?.get(s.name);
+        const ownerMethods = nonPrivateMethodsByOwner.get(parent)?.get(s.name) ?? [];
+        if (parentSigs?.has(sig)) {
+          const nonPrivate = ownerMethods.some((bm) => sigText(bm) === sig || sigTextElided(bm) === sig);
+          if (nonPrivate) return parent;
+        }
+        if (!parentSigs?.has(sig) && parentSigs && parentSigs.size > 0 && ([...parentSigs].some(hasTypeVar) || hasTypeVar(sig))) {
+          if (ownerMethods.length > 0) return parent;
+        }
+        const pSym = typeIndex.get(parent);
+        if (pSym?.metadata?.superTypes) {
+          for (const p of pSym.metadata.superTypes) queue.push(p);
+        }
+      }
+      return null;
+    };
+    for (const s of symbols) {
+      const _owner = s.ownerName;
+      if (_owner) {
+        relationships.push({
+          source: _owner,
+          target: s.name,
+          type: ASTEngine.RelationshipType.Contains,
+          confidence: 1,
+          // M59 (#825): a containment edge has no "call site", but it does have
+          // a navigable site — the member's own declaration line. Taken from the
+          // symbol's range rather than a syntax node because this loop runs over
+          // the symbol table, and omitted entirely when the symbol has no range
+          // (never written as 0 — #820).
+          ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+          metadata: { isContained: true }
+        });
+      }
+      if (s.kind === ASTEngine.SymbolKind.Method && s.ownerName && !s.metadata?.isPhantom && s.metadata?.isOverride) {
+        const declaringInFile = findDeclaringAncestor(s);
+        if (declaringInFile && !isSelfOverride(declaringInFile, s.ownerName)) {
+          relationships.push({
+            source: `${s.ownerName}.${s.name}`,
+            target: `${declaringInFile}.${s.name}`,
+            type: ASTEngine.RelationshipType.Overrides,
+            confidence: 1,
+            // M59 (#825): the override occurs at the OVERRIDING declaration, so
+            // the line is the overriding method's own — not the base's.
+            ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+            // S1.3 (M49 #715): override edges carry the parameter signature
+            // payload — the source/target keep the family convention
+            // (Owner.name → Parent.name), but the SIG travels in metadata so
+            // overloads foo(Int)/foo(String) are distinguishable downstream.
+            metadata: { isOverride: true, overrideParent: declaringInFile, reasonCode: "exact-in-file", overrideSig: sigText(s) }
+          });
+          continue;
+        }
+        const ownerSym = resolveOwner(s);
+        const parents = ownerSym?.metadata?.superTypes ?? [];
+        let overrideParent = parents.length > 0 ? parents[0] : "";
+        let confidence = 0.5;
+        let reasonCode = "first-supertype-guess";
+        if (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";
+          }
+        }
+        if (overrideParent && !isSelfOverride(overrideParent, s.ownerName)) {
+          relationships.push({
+            source: `${s.ownerName}.${s.name}`,
+            target: `${overrideParent}.${s.name}`,
+            type: ASTEngine.RelationshipType.Overrides,
+            confidence,
+            ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+            metadata: { isOverride: true, overrideParent, reasonCode, overrideSig: sigText(s) }
+          });
+        }
+      }
+    }
+    for (const s of symbols) {
+      if (s.kind !== ASTEngine.SymbolKind.Method || !s.ownerName) continue;
+      if (s.metadata?.isPhantom || s.metadata?.isOverride || s.visibility === "private") continue;
+      const declaringInFile = findDeclaringAncestor(s);
+      if (declaringInFile && !isSelfOverride(declaringInFile, s.ownerName)) {
+        relationships.push({
+          source: `${s.ownerName}.${s.name}`,
+          target: `${declaringInFile}.${s.name}`,
+          type: ASTEngine.RelationshipType.Overrides,
+          confidence: 1,
+          ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+          metadata: { isOverride: true, implicitOverride: true, overrideParent: declaringInFile, reasonCode: "exact-in-file", overrideSig: sigText(s) }
+        });
+      }
+    }
+    for (const imp of imports) {
+      if (!imp.module || imp.module.length === 0) continue;
+      relationships.push({
+        // Import references are sourced at "root".
+        //
+        // This reverses S1.7, which moved imports from "root" onto "(script)" so that
+        // the whole top level would share ONE sentinel. That unification is real, but this
+        // lane's hand-audited truth is sourced at "root" -- all six `references` rows it
+        // expects cite an import and every one of them reads
+        //     root -> com.example.base.BaseService   (import com.example.base.BaseService)
+        //     root -> a.b                             (import a.b.{C, D => Renamed})
+        //     root -> x.y.Z                           (import x.y.Z as W -- full module path)
+        // so the choice of label is part of the contract the differential checks, and
+        // "(script)" made every one of them an unmatched false negative.
+        //
+        // It also removes the rewrite below: an import referenced FROM the file's primary
+        // type (`UserService -> com.example.base.BaseService`) was neither "root" nor
+        // "(script)", so it was a false positive as well. Truth expects the import at the
+        // file level, not attributed to whichever type happens to be declared first.
+        //
+        // RESOLVED 2026-10-02 during branch consolidation: the pinned hand-audited truth
+        // at validation/m12/ground-truth/scala.json carries all six `references` rows with
+        // sourceId "root" (verified by direct query), and that truth file is identical on
+        // both sides of this merge. The evidence therefore decides: "root" is correct and
+        // the local S1.7 "(script)" sentinel would have failed all six.
+        source: "root",
+        target: imp.module || "",
+        type: ASTEngine.RelationshipType.References,
+        confidence: 0.9,
+        // M59 (#825): an import reference occurs where its TARGET is written —
+        // the module's last segment (handleImport records that line), falling
+        // back to the statement's start. Omitted, never zeroed, when neither is
+        // known (#820).
+        ...imp.moduleLine || imp.range?.startLine ? { line_number: imp.moduleLine || imp.range.startLine } : {},
+        metadata: { isImportDep: true }
+      });
+    }
+    for (const imp of imports) {
+      if (!imp.module || imp.module.length === 0) continue;
+      const excluded = /* @__PURE__ */ new Set();
+      for (const sp of imp.specifiers ?? []) if (sp?.excluded && typeof sp.imported === "string") excluded.add(sp.imported);
+      const impMeta = imp.metadata ?? {};
+      const groupList = Array.isArray(impMeta.importGroups) && impMeta.importGroups.length > 0 ? impMeta.importGroups : [{ prefix: imp.module, names: (imp.items ?? []).filter((s) => typeof s === "string" && s.length > 0) }];
+      const targets = [];
+      for (const g of groupList) {
+        const base = typeof g?.prefix === "string" ? g.prefix : "";
+        if (base.length === 0) continue;
+        const names = (Array.isArray(g?.names) ? g.names : []).filter((n) => typeof n === "string" && n.length > 0 && n !== "*" && !excluded.has(n));
+        if (names.length === 0) {
+          targets.push(base);
+          continue;
+        }
+        const alreadyFull = names.every((n) => base.endsWith(`.${n}`) || base === n);
+        if (alreadyFull) targets.push(base);
+        else for (const n of names) targets.push(`${base}.${n}`);
+      }
+      const emittedHere = /* @__PURE__ */ new Set();
+      for (const t of targets) {
+        if (t.length === 0 || emittedHere.has(t)) continue;
+        emittedHere.add(t);
+        relationships.push({
+          source: "(file)",
+          target: t,
+          type: ASTEngine.RelationshipType.Imports,
+          confidence: 1,
+          ...imp.range?.startLine ? { line_number: imp.range.startLine } : {},
+          // `isImport` is what script/m14/completeness-inventory.ts section B reads
+          // to pin the kind, so the label is claimed twice over — by the enum and
+          // by the marker — exactly as the go lane's edge does.
+          metadata: { isImport: true, isScalaImport: true, packageName: t }
+        });
+      }
+    }
+    const publishedExports = /* @__PURE__ */ new Set();
+    for (const e of exports) {
+      if (!e.name || publishedExports.has(e.name)) continue;
+      publishedExports.add(e.name);
+      relationships.push({
+        source: "(file)",
+        target: e.name,
+        type: ASTEngine.RelationshipType.Exports,
+        confidence: 1,
+        ...e.range?.startLine ? { line_number: e.range.startLine } : {},
+        metadata: { isScalaExport: true, exportKind: String(e.kind ?? "") }
+      });
+    }
+    this.collectScalaReExports(rootNode, relationships);
+    this.emitExportSurface(rootNode, exports, relationships);
+    this.collectDeclaredTypeRefs(rootNode, relationships, symbols);
+    this.collectExpressionUses(rootNode, relationships);
+    this.classifyEvidenceTier(relationships);
+    this.certifyJvmPlatformTargets(rootNode, relationships, symbols);
+    return {
+      symbols,
+      relationships,
+      imports,
+      exports,
+      metadata,
+      errors: metadata.errors || []
+    };
+  }
+  /**
+   * The MODULE a Scala file belongs to: its full package path.
+   *
+   * Read from the `package_clause` nodes themselves rather than from
+   * `metadata.packageName`, which the walk overwrites per clause. Scala writes a
+   * package header two ways and this corpus uses the chained one exclusively:
+   *
+   *     package scala.tools.nsc        <- one dotted clause
+   *     package typechecker             <- a second clause CHAINED onto it
+   *
+   * The full path is the two joined with "."; a single braced clause
+   * (`package a.b { … }`) needs no join. Measured on 600 corpus files
+   * (script/m14/tmp/scala-package-identity.mts): 599 files chained-only, 1
+   * mixed, 0 braced-only, and `metadata.packageName` equals the FULL path in
+   * only the 292 single-clause files — on the other 308 it holds the last
+   * fragment (`typechecker`, `nsc`), which is not a package any reference site
+   * spells.
+   *
+   * Only TOP-LEVEL clauses are joined. A clause nested in a braced block is
+   * already written as its full path (`package reflect { … }` inside
+   * `package scala { … }` still spells `scala.reflect`), and joining it again
+   * would double the prefix.
+   *
+   * FILE_MODULE is the fallback for a file with no package clause at all — the
+   * default package, where the compilation unit IS the module. It is a sentinel
+   * and not a symbol, declared as such: zig's `(file)` and this lane's own
+   * `(script)`/`root` sentinels are the same kind of thing, and the alternative
+   * — publishing an empty source — is the defect the M60/SDJ-11 work removed.
+   */
+  static FILE_MODULE = "(file)";
+  scalaModuleName(rootNode) {
+    const parts = [];
+    for (let i = 0; i < rootNode.namedChildCount; i++) {
+      const c = rootNode.namedChild(i);
+      if (!c || c.type !== "package_clause") continue;
+      let id = null;
+      for (let j = 0; j < c.namedChildCount; j++) {
+        const x = c.namedChild(j);
+        if (x && x.type === "package_identifier") {
+          id = x;
+          break;
+        }
+      }
+      if (!id) continue;
+      const segs = [];
+      const collect = (n) => {
+        if (n.type === "identifier") segs.push(n.text);
+        for (let k = 0; k < n.namedChildCount; k++) {
+          const y = n.namedChild(k);
+          if (y) collect(y);
+        }
+      };
+      collect(id);
+      const seg = segs.join(".");
+      if (seg.length > 0) parts.push(stripScalaQuoting(seg));
+    }
+    if (parts.length === 0) return _RealScalaAnalyzer.FILE_MODULE;
+    return parts.join(".");
+  }
+  /**
+   * `exports` — this module's public surface, as relationships.
+   *
+   * Two producers, one dedupe (see the call site for the measurement behind
+   * both):
+   *
+   *   A. IMPLICIT, from the `ExportInfo[]` the walk already builds: every public
+   *      TOP-LEVEL class/trait/object/enum/function/val/var/named-given. The
+   *      array is the lane's existing definition of the surface — it is what the
+   *      fixture gate's F3 export-uniqueness check reads — so the edges are
+   *      derived from it rather than from a second, divergent rule that could
+   *      drift from it.
+   *
+   *   B. EXPLICIT, from Scala 3 `export_declaration`. The exported NAME is the
+   *      leaf that is actually introduced here: a selector, or the final segment
+   *      of a plain path. Two forms publish NO edge and the reason is the
+   *      language's, not caution:
+   *
+   *        `export a.b.*`      re-exports an unknown set of names — the clause
+   *                           names a set, not a name, so an edge per member
+   *                           would mean inventing members this file never
+   *                           writes.
+   *        `export a.b.given`  re-exports the GIVEN INSTANCES resolved for
+   *                           `a.b`'s type — a set defined by implicit
+   *                           resolution in another compilation unit.
+   *
+   *      Both are recorded in the edge metadata (`exportForm`) rather than
+   *      dropped, so a reader can see that the file re-exports a wildcard and
+   *      that the analyzer declines to enumerate it.
+   *
+   * `confidence: 1.0` and `evidenceClass: structural` (the tier classifier
+   * already routes `exports` there): the edge is read off a declaration, and
+   * nothing about it is inferred.
+   */
+  emitExportSurface(rootNode, exports, relationships) {
+    const moduleName = this.scalaModuleName(rootNode);
+    const surfaceIndexes = /* @__PURE__ */ new Set();
+    const SURFACE_DECLS = /* @__PURE__ */ new Set([
+      "class_definition",
+      "trait_definition",
+      "object_definition",
+      "enum_definition",
+      "val_definition",
+      "var_definition",
+      "val_declaration",
+      "var_declaration",
+      "function_definition",
+      "given_definition"
+    ]);
+    const collectSurface = (scope) => {
+      for (let i = 0; i < scope.namedChildCount; i++) {
+        const c = scope.namedChild(i);
+        if (!c) continue;
+        if (SURFACE_DECLS.has(c.type)) {
+          surfaceIndexes.add(this.declarationLineNode(c).startIndex);
+          continue;
+        }
+        if (c.type === "package_clause" || c.type === "package_object") {
+          for (let j = 0; j < c.namedChildCount; j++) {
+            const b = c.namedChild(j);
+            if (b && (b.type === "block" || b.type === "template_body")) collectSurface(b);
+          }
+        }
+      }
+    };
+    collectSurface(rootNode);
+    const seen = /* @__PURE__ */ new Set();
+    const surfaceChannelDuplicated = moduleName === _RealScalaAnalyzer.FILE_MODULE;
+    const key = (name) => `${moduleName} ${name}`;
+    for (const e of exports) {
+      if (surfaceChannelDuplicated) continue;
+      const name = stripScalaQuoting(String(e.name ?? ""));
+      if (name.length === 0) continue;
+      if (e.range?.startIndex !== void 0 && !surfaceIndexes.has(e.range.startIndex)) continue;
+      if (seen.has(key(name))) continue;
+      seen.add(key(name));
+      relationships.push({
+        source: moduleName,
+        target: name,
+        type: ASTEngine.RelationshipType.Exports,
+        confidence: 1,
+        // M59 (#825): the surface is declared where the name is declared.
+        ...e.range?.startLine ? { line_number: e.range.startLine } : {},
+        metadata: {
+          exportForm: "public-top-level-declaration",
+          symbolKind: String(e.kind ?? "")
+        }
+      });
+    }
+    const visit = (n) => {
+      if (n.type === "export_declaration") {
+        for (const t of this.scalaExportClauseTargets(n)) {
+          const k = key(t.name);
+          if (seen.has(k)) continue;
+          seen.add(k);
+          relationships.push({
+            source: moduleName,
+            target: t.name,
+            type: ASTEngine.RelationshipType.Exports,
+            confidence: 1,
+            line_number: n.startPosition.row + 1,
+            metadata: { exportForm: t.form }
+          });
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) visit(c);
+      }
+    };
+    visit(rootNode);
+  }
+  /**
+   * The names one Scala 3 `export` clause introduces into this file, read from
+   * the grammar's own node types (probe:
+   * script/m14/tmp/scala-scala3-export-clause.mts dumps all six forms):
+   *
+   *   export a.b.c              -> export_declaration > identifier "." identifier
+   *                                  "." identifier            => leaf `c`
+   *   export a.b.{c, d}         -> namespace_selectors > identifier   => `c`, `d`
+   *   export a.b.{c => d, e}    -> namespace_selectors > arrow_renamed_identifier
+   *                                  > identifier "=>" identifier      => `d`
+   *                                  (the name INTRODUCED here is `d`; `c` is
+   *                                  only reachable under it)
+   *   export a.b.{given C}      -> namespace_selectors > given type_identifier
+   *                                  => `C`
+   *   export a.b.*              -> namespace_wildcard           => no name to publish
+   *   export a.b.given          -> namespace_wildcard `given`   => no name to publish
+   *
+   * Each entry carries the FORM it came from, so the edge metadata says which
+   * spelling produced the name.
+   */
+  scalaExportClauseTargets(node) {
+    const out = [];
+    const path = [];
+    let wildcard = false;
+    let sawSelectors = false;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "identifier") {
+        path.push(c.text);
+        continue;
+      }
+      if (c.type === "namespace_selectors") {
+        sawSelectors = true;
+        for (let j = 0; j < c.namedChildCount; j++) {
+          const s = c.namedChild(j);
+          if (!s) continue;
+          if (s.type === "identifier") {
+            out.push({ name: stripScalaQuoting(s.text), form: "scala3-export-selector" });
+          } else if (s.type === "arrow_renamed_identifier") {
+            let last = null;
+            for (let k = 0; k < s.namedChildCount; k++) {
+              const id = s.namedChild(k);
+              if (id && id.type === "identifier") last = id.text;
+            }
+            if (last) out.push({ name: stripScalaQuoting(last), form: "scala3-export-renamed-selector" });
+          } else if (s.type === "type_identifier") {
+            out.push({ name: stripScalaQuoting(s.text), form: "scala3-export-given-selector" });
+          } else if (s.type === "generic_type") {
+            out.push({ name: this.scalaTypeHeadName(s), form: "scala3-export-given-selector" });
+          }
+        }
+        continue;
+      }
+      if (c.type === "namespace_wildcard") {
+        wildcard = true;
+      }
+    }
+    if (out.length === 0 && !wildcard && !sawSelectors && path.length > 0) {
+      out.push({ name: stripScalaQuoting(path[path.length - 1]), form: "scala3-export-clause" });
+    }
+    return out.filter((t) => t.name.length > 0);
+  }
+  detectFrameworks(imports, frameworksObj) {
+    for (let i = 0; i < imports.length; i++) {
+      const source = imports[i].module;
+      if (!source) continue;
+      if (source.indexOf("play.api") !== -1) frameworksObj["Play Framework"] = true;
+      if (source.indexOf("akka") !== -1) frameworksObj["Akka"] = true;
+      if (source.indexOf("org.apache.spark") !== -1) frameworksObj["Apache Spark"] = true;
+      const isRoot = (root) => source === root || source.startsWith(root + ".");
+      if (isRoot("cats")) frameworksObj["Cats Effect"] = true;
+      if (isRoot("zio")) frameworksObj["ZIO"] = true;
+      if (isRoot("org.http4s")) frameworksObj["http4s"] = true;
+      if (isRoot("slick") || isRoot("org.slick")) frameworksObj["Slick"] = true;
+      if (isRoot("fs2")) frameworksObj["FS2"] = true;
+      if (isRoot("org.scalatest")) frameworksObj["ScalaTest"] = true;
+      if (isRoot("org.springframework.boot")) frameworksObj["Spring Boot"] = true;
+      if (isRoot("org.springframework")) frameworksObj["Spring Framework"] = true;
+      if (isRoot("com.fasterxml.jackson")) frameworksObj["Jackson"] = true;
+      if (isRoot("com.github.plokhotnyuk.jsoniter_scala")) frameworksObj["jsoniter-scala"] = true;
+      if (isRoot("com.softwaremill.sttp")) frameworksObj["sttp"] = true;
+    }
+  }
+  detectCompanionObjects(symbols, patternsObj) {
+    const classNames = {};
+    const objectNames = {};
+    for (let i = 0; i < symbols.length; i++) {
+      const sym = symbols[i];
+      if (sym.kind === ASTEngine.SymbolKind.Class || sym.metadata?.isTrait) {
+        classNames[sym.name] = true;
+      } else if (sym.metadata?.isObject) {
+        objectNames[sym.name] = true;
+      }
+    }
+    for (let i = 0; i < symbols.length; i++) {
+      const sym = symbols[i];
+      if ((sym.kind === ASTEngine.SymbolKind.Class || sym.metadata?.isTrait) && objectNames[sym.name]) {
+        if (!sym.metadata) sym.metadata = {};
+        sym.metadata.hasCompanionObject = true;
+        patternsObj["Companion Objects"] = true;
+      } else if (sym.metadata?.isObject && classNames[sym.name]) {
+        if (!sym.metadata) sym.metadata = {};
+        sym.metadata.isCompanionObject = true;
+        patternsObj["Companion Objects"] = true;
+      }
+      if (sym.metadata?.isCaseClass) {
+        if (!sym.metadata) sym.metadata = {};
+        sym.metadata.hasCompanionObject = true;
+      }
+    }
+  }
+  extractIdentifier(node, field) {
+    const child = node.childForFieldName(field);
+    if (child) return child.text;
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && c.isNamed && (c.type === "identifier" || c.type === "type_identifier")) {
+        return c.text;
+      }
+    }
+    return null;
+  }
+  /** Collect modifiers (sealed/abstract/final/case/implicit/override/etc). */
+  collectModifiers(node) {
+    const mods = /* @__PURE__ */ new Set();
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (!c) continue;
+      if (c.type === "modifiers") {
+        for (let j = 0; j < c.childCount; j++) {
+          const m = c.child(j);
+          if (m) mods.add(m.type);
+        }
+      } else {
+        mods.add(c.type);
+      }
+    }
+    return mods;
+  }
+  /**
+   * SCD5: the short name of ONE annotation node (@Deprecated →
+   * "Deprecated", @org.x.Transactional → "Transactional"). The walk calls
+   * this on the annotation node itself; collectAnnotations (below) reuses it
+   * for every annotation child of a definition.
+   */
+  annotationShortName(ann) {
+    for (let k = 0; k < ann.namedChildCount; k++) {
+      const nc = ann.namedChild(k);
+      if (nc && (nc.type === "identifier" || nc.type === "type_identifier" || nc.type === "stable_type_identifier")) {
+        const text = nc.text;
+        const dot = text.lastIndexOf(".");
+        return dot === -1 ? text : text.slice(dot + 1);
+      }
+    }
+    return null;
+  }
+  /**
+   * Annotation short names from a definition's modifiers (@Deprecated →
+   * "Deprecated", @org.x.Transactional → "Transactional"). Previously
+   * annotations were consumed only as pattern-flag substrings and symbols
+   * carried no decorator data at all, unlike every sibling analyzer.
+   */
+  collectAnnotations(node) {
+    const out = [];
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (!c) continue;
+      if (c.type !== "annotation" && c.type !== "modifiers") continue;
+      const container = c.type === "annotation" ? null : c;
+      const sources = container ? [container] : [c];
+      for (const src of sources) {
+        for (let j = 0; j < src.childCount; j++) {
+          const ann = container ? src.child(j) : src;
+          if (!ann || ann.type !== "annotation") continue;
+          const short = this.annotationShortName(ann);
+          if (short) out.push(short);
+          if (!container) break;
+        }
+      }
+    }
+    return out;
+  }
+  /**
+   * M59 (#825): the node whose START is the declaration's own line.
+   *
+   * tree-sitter-scala gives a definition the line of its LEADING ANNOTATION —
+   * measured, not assumed: for
+   *
+   *     @tailrec                  ← row 4
+   *     def loop(n: Int): Int =   ← row 5
+   *
+   * the `function_definition` node starts at row 4 while its `name` field is at
+   * row 5. Stamping the node's start put the `contains` edge (and the symbol's
+   * own line) on the annotation, so the line no longer contained the declared
+   * name — 4 of 13 remaining scala oracle failures on a 60-file sample, and the
+   * shape that would otherwise be copied by java/kotlin/groovy.
+   *
+   * An annotation is a modifier: it decorates the declaration, it is not where
+   * the declaration is written. Skipping leading annotations (and `modifiers`
+   * wrappers) gives the declaration keyword line, which is what a tool must
+   * point at and what the tier contract can check against the source.
+   *
+   * COMMENTS are skipped for the same reason, and that is not hypothetical —
+   * measured on cats-effect's QueueBenchmark.scala, where
+   *
+   *     @Param(Array("32768")) // must be a power of 2
+   *     var size: Int = _
+   *
+   * gives `var_definition` the named children `annotation, comment, identifier,
+   * type_identifier, wildcard`: skipping only the annotation selected the
+   * trailing COMMENT, so the symbol and its `contains` edge landed on the
+   * annotation's line (47, column 26) instead of the declaration's (48, column
+   * 6). A comment is text ABOUT the declaration, never the declaration.
+   */
+  declarationLineNode(node) {
+    const nameNode = node.childForFieldName?.("name");
+    if (nameNode) return nameNode;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "annotation" || c.type === "modifiers" || c.type === "opaque_modifier" || c.type === "inline_modifier") continue;
+      if (c.type === "comment" || c.type === "block_comment") continue;
+      return c;
+    }
+    return node;
+  }
+  getVisibility(node) {
+    let modifiersNode = null;
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && c.type === "modifiers") {
+        modifiersNode = c;
+        break;
+      }
+    }
+    if (modifiersNode) {
+      for (let i = 0; i < modifiersNode.childCount; i++) {
+        const mod = modifiersNode.child(i);
+        if (mod && mod.type === "access_modifier") {
+          if (mod.text.includes("[")) return "package";
+          const inner = mod.child(0);
+          if (inner && (inner.type === "private" || inner.type === "protected")) return inner.type;
+        }
+        if (mod && (mod.type === "private" || mod.type === "protected")) return mod.type;
+      }
+    }
+    return "public";
+  }
+  isPublic(node) {
+    return this.getVisibility(node) === "public";
+  }
+  isCaseClass(node) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && c.type === "case") return true;
+    }
+    return false;
+  }
+  /**
+   * ScalaDoc extraction: a multiline_comment starting with '/**' immediately
+   * preceding the declaration (previous sibling). Mirrors the kotlin KDoc
+   * approach; previously scala symbols carried NO comments at all.
+   */
+  extractScalaDoc(node) {
+    const sibling = node.previousNamedSibling;
+    if (sibling && sibling.type === "block_comment" && sibling.text.startsWith("/**")) return sibling.text;
+    return void 0;
+  }
+  /**
+   * Generic type-parameter extraction from type_parameters nodes
+   * (`class Store[T]`, `def map[R](...)`). Previously scala symbols carried
+   * NO generic information at all - silent absence (M14 #383 fix).
+   */
+  extractScalaTypeParameters(node) {
+    const tpNode = node.namedChildren.find((c) => c.type === "type_parameters");
+    if (!tpNode) return [];
+    const out = [];
+    for (let i = 0; i < tpNode.namedChildCount; i++) {
+      const c = tpNode.namedChild(i);
+      if (c && this.isTypeishNodeName(c.type)) {
+        out.push(c.text.trim());
+      }
+    }
+    return out;
+  }
+  buildScalaCallPath(fnNode) {
+    const parts = [];
+    let cur = fnNode;
+    while (cur) {
+      if (cur.type === "field_expression") {
+        parts.unshift(cur.namedChild(cur.namedChildCount - 1)?.text ?? "");
+        cur = cur.namedChild(0);
+      } else if (cur.type === "call_expression") {
+        cur = cur.namedChild(0);
+      } else {
+        parts.unshift(cur.text);
+        break;
+      }
+    }
+    return parts.filter(Boolean).join(".");
+  }
+  /**
+   * Per-function cyclomatic complexity (1 + decision points) - java/kotlin
+   * parity (M14 #301 prerequisite).
+   */
+  calculateScalaFunctionComplexity(node) {
+    let complexity = 1;
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "if_expression" || n.type === "while_expression" || n.type === "do_while_expression" || n.type === "for_expression") {
+        complexity++;
+      } else if (n.type === "case_clause") {
+        complexity++;
+      } else if (n.type === "infix_expression") {
+        const op = n.childForFieldName("operator")?.text;
+        if (op === "&&" || op === "||") complexity++;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return complexity;
+  }
+  /**
+   * 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.
+   */
+  /**
+   * Declared-type reference graph (M14). References edges from the enclosing
+   * function/class to every named type in a declaration position. Scala's
+   * @throws[IO] annotation parses as generic_type("throws", [IO]) — the
+   * "throws" name is skipped, its arguments become throws_type edges.
+   */
+  collectDeclaredTypeRefs(rootNode, relationships, declaredSymbols = []) {
+    const emitted = /* @__PURE__ */ new Set();
+    const declaredNames = /* @__PURE__ */ new Set();
+    for (const s of declaredSymbols) if (s?.name) declaredNames.add(stripScalaQuoting(String(s.name)));
+    const collectTypeNames = (n, out) => {
+      const push = (name0) => {
+        const name = stripScalaQuoting(name0);
+        if (!name || name === "throws") return;
+        if (out.some((x) => x.name === name)) return;
+        out.push({ name, line: n.startPosition.row + 1 });
+      };
+      if (n.type === "type_identifier") {
+        if (this.isScalaPlaceholderFragment(n)) return;
+        const bare = stripScalaQuoting(n.text);
+        if ((bare === "?" || bare === "_") && !declaredNames.has(bare)) return;
+        push(n.text);
+        return;
+      }
+      if (n.type === "stable_type_identifier") {
+        push(n.text);
+        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.type === "function_definition" || start.type === "function_declaration" ? start : start.parent;
+      while (p) {
+        if (p.type === "function_definition" || p.type === "function_declaration") {
+          const name = this.scalaDeclaredNameOf(p);
+          if (name) return name;
+        }
+        if (p.type === "class_definition" || p.type === "object_definition" || p.type === "trait_definition" || p.type === "enum_definition") {
+          const name = this.scalaDeclaredNameOf(p);
+          if (name) return name;
+        }
+        p = p.parent;
+      }
+      return "(script)";
+    };
+    const emit = (decl, roots, kind, relType = "declared_type", sourceOverride, leafOnly = false) => {
+      const source = sourceOverride ?? resolveSource(decl);
+      for (const r of roots) {
+        if (!r) continue;
+        const names = [];
+        collectTypeNames(r, names);
+        for (const { name: raw, line: nameLine } of names) {
+          const t = leafOnly ? raw.includes(".") ? raw.slice(raw.lastIndexOf(".") + 1) : raw : raw;
+          if (!t) continue;
+          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,
+            // M59 (#825): a type reference occurs where the type is NAMED, so
+            // the line is the type node's own — this one site covers
+            // declared_type / return_type / pattern_type / type_alias /
+            // cast_target / instanceof_check / given_type / tuple_type /
+            // annotation_type, which together were 1,129 line-less edges on a
+            // 60-file scala sample. Note what it is NOT: the declaration's line.
+            // `def f: Map[K, V]` written over several lines references Map on
+            // the line Map is written on. `nameLine` (not `r`'s start) is what
+            // makes that true when the type expression itself is multi-line.
+            line_number: nameLine,
+            metadata: { relationshipType: relType, declaredOn: decl.type }
+          });
+        }
+      }
+    };
+    const walk = (n) => {
+      switch (n.type) {
+        case "given_definition": {
+          const roots = [];
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c && this.isTypePositionNode(c.type)) roots.push(c);
+          }
+          if (roots.length) emit(n, roots, "given_definition", "given_type");
+          break;
+        }
+        case "class_parameter":
+        case "parameter": {
+          emit(n, [n], n.type);
+          break;
+        }
+        case "val_definition":
+        case "var_definition":
+        case "val_declaration":
+        case "var_declaration": {
+          const roots = [];
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c && this.isTypePositionNode(c.type)) roots.push(c);
+          }
+          if (roots.length) emit(n, roots, n.type);
+          break;
+        }
+        case "annotation": {
+          const gt = this.findChild(n, "generic_type");
+          if (gt && gt.namedChild(0)?.text === "throws") {
+            const argsNode = this.findChild(gt, "type_arguments");
+            if (argsNode) emit(n, [argsNode], "throws_annotation", "throws_type");
+          }
+          break;
+        }
+        case "function_definition":
+        case "function_declaration": {
+          let sawParams = false;
+          const hasParamsClause = !!this.findChild(n, "parameters");
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (!c) continue;
+            if (c.type === "parameters") {
+              sawParams = true;
+              continue;
+            }
+            if (c.type === "generic_type" || c.type === "type_identifier" || c.type === "function_type" || c.type === "tuple_type" || c.type === "stable_type_identifier") {
+              if (!sawParams && c.namedChild(0)?.text === "throws") {
+                const argsNode = this.findChild(c, "type_arguments");
+                if (argsNode) emit(n, [argsNode], "throws_annotation", "throws_type");
+                continue;
+              }
+              emit(n, [c], c.type === "tuple_type" ? "tuple_type" : sawParams || !hasParamsClause ? "return_type" : "annotation_type", sawParams || !hasParamsClause ? "return_type" : "declared_type");
+            }
+          }
+          break;
+        }
+        case "call_expression": {
+          const fn = n.childForFieldName?.("function");
+          const fnText = fn ? fn.text : "";
+          if (fnText.endsWith("asInstanceOf") || fnText.endsWith("isInstanceOf")) {
+            const args = n.childForFieldName?.("arguments") || this.findChild(n, "type_arguments");
+            if (args) emit(n, [args], fnText.endsWith("asInstanceOf") ? "cast_target" : "instanceof_check");
+          }
+          break;
+        }
+        case "generic_function": {
+          const fe = this.findChild(n, "field_expression");
+          const tail = fe ? fe.namedChild(fe.namedChildCount - 1)?.text ?? "" : "";
+          if (tail === "asInstanceOf" || tail === "isInstanceOf") {
+            const args = this.findChild(n, "type_arguments");
+            if (args) emit(n, [args], tail === "asInstanceOf" ? "cast_target" : "instanceof_check", tail === "asInstanceOf" ? "cast_target" : "instanceof_check");
+          }
+          break;
+        }
+        case "typed_pattern": {
+          const last = n.namedChild(n.namedChildCount - 1);
+          if (last) emit(n, [last], "typed_pattern", "pattern_type");
+          break;
+        }
+        case "case_class_pattern": {
+          const first = n.namedChild(0);
+          if (first) emit(n, [first], "case_class_pattern", "pattern_type");
+          break;
+        }
+        case "derives_clause": {
+          emit(n, [n], "derives_clause", "derives_type", void 0, true);
+          break;
+        }
+        case "type_definition": {
+          const tName = this.findChild(n, "type_identifier") ?? this.findChild(n, "identifier");
+          if (tName) {
+            const rhs = [];
+            for (let i = 0; i < n.namedChildCount; i++) {
+              const c = n.namedChild(i);
+              if (c && c !== tName && c.type !== "type_parameters") rhs.push(c);
+            }
+            emit(n, rhs, "type_definition", "type_alias", tName.text);
+          }
+          break;
+        }
+        case "self_type": {
+          const last = n.namedChild(n.namedChildCount - 1);
+          if (last) emit(n, [last], "self_type", "self_type");
+          const required = this.selfTypeRequiredTypeNames(n);
+          if (required.length > 0) {
+            const src = resolveSource(n);
+            for (const { name: rname, line: rline } of required) {
+              if (!rname) continue;
+              const leaf = rname.includes(".") ? rname.slice(rname.lastIndexOf(".") + 1) : rname;
+              if (rname === src || leaf === src) continue;
+              const ikey = `implements|${src}|${rname}`;
+              if (emitted.has(ikey)) continue;
+              emitted.add(ikey);
+              relationships.push({
+                source: src,
+                target: rname,
+                type: ASTEngine.RelationshipType.Implements,
+                // S1.4: an explicit conformance requirement is 1.0 — the construct says so.
+                confidence: 1,
+                // M59 (#825): the NAME's own line, not the declaration's.
+                line_number: rline,
+                metadata: { relationshipType: "self_type", isSelfType: true }
+              });
+            }
+          }
+          break;
+        }
+        case "field_expression": {
+          const isCallFn = n.parent && n.parent.type === "call_expression" && n.parent.childForFieldName?.("function")?.id === n.id;
+          if (!isCallFn) {
+            const recv = this.leftmostIdentifier(n);
+            if (recv && recv.text.length > 0 && recv.text.charCodeAt(0) >= 65 && recv.text.charCodeAt(0) <= 90) {
+              const source = resolveSource(n);
+              const key = `${source}|${recv.text}|field_expression`;
+              if (!emitted.has(key)) {
+                emitted.add(key);
+                relationships.push({
+                  source,
+                  target: recv.text,
+                  type: ASTEngine.RelationshipType.References,
+                  confidence: 0.95,
+                  // M59 (#825): the referenced type is named by the receiver.
+                  line_number: recv.startPosition.row + 1,
+                  metadata: { relationshipType: "method_value", declaredOn: "field_expression" }
+                });
+              }
+            }
+          }
+          break;
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c);
+      }
+    };
+    walk(rootNode);
+  }
+  /**
+   * M14 #419 G4/G8: expression-level Uses edges.
+   * - interpolated_string_expression > interpolation: s"hi $name" USES the
+   *   interpolated identifier (simple $name form — the direct identifier
+   *   child). The ${expr} block form is expression-use territory (scala
+   *   emits no expression-level uses by design — D1/D3 boundary).
+   * - field_expression (non-call position): h.value reads/writes and nullary
+   *   access xs.length USE the receiver — scala had no field-access uses
+   *   collector (only extension methods emitted Uses), the family gap vs
+   *   java/groovy/kotlin. Receiver-only: never guess method-vs-field (D3
+   *   ruling). Call positions (xs.map(...)) are skipped — the call edge
+   *   carries them; capitalized receivers (Foo.bar) are References (G3,
+   *   collectDeclaredTypeRefs). Deduped per (source, target).
+   */
+  collectExpressionUses(rootNode, relationships) {
+    const emitted = /* @__PURE__ */ new Set();
+    const resolveSource = (start) => {
+      let p = start && (start.type === "function_definition" || start.type === "function_declaration") ? start : start ? start.parent : null;
+      while (p) {
+        if (p.type === "function_definition" || p.type === "function_declaration") {
+          const name = this.scalaDeclaredNameOf(p);
+          if (name) return name;
+        }
+        if (p.type === "class_definition" || p.type === "object_definition" || p.type === "trait_definition" || p.type === "enum_definition") {
+          const name = this.scalaDeclaredNameOf(p);
+          if (name) return name;
+        }
+        p = p.parent;
+      }
+      return "(script)";
+    };
+    const emitUse = (n, target, nameNode) => {
+      if (!target) return;
+      if (target === "_") return;
+      const p = n.parent;
+      const isCompoundAssign = p !== null && p.type === "infix_expression" && scalaOperatorIsAssignment(p.childForFieldName?.("operator")?.text ?? p.namedChild(1)?.text ?? "");
+      const lhs = p && (p.type === "assignment_expression" || isCompoundAssign) ? p.namedChild(0) : null;
+      if (lhs && lhs.startIndex === n.startIndex && lhs.endIndex === n.endIndex) return;
+      const source = resolveSource(n.parent);
+      const key = `${source}|${target}|uses`;
+      if (emitted.has(key)) return;
+      emitted.add(key);
+      relationships.push({
+        source,
+        target,
+        type: ASTEngine.RelationshipType.Uses,
+        // M59 (#825): a read happens where the NAME is written, so the line
+        // comes from the name node — not from `n`, which for a field access is
+        // the receiver and would hand a multi-line chain the line it opened on
+        // (the same defect class fixed for calls above). `n` is the fallback
+        // only when no name node was passed.
+        line_number: (nameNode ?? n).startPosition.row + 1,
+        confidence: 0.9,
+        metadata: { relationshipType: "expression_use" }
+      });
+    };
+    const walk = (n) => {
+      if (n.type === "interpolation") {
+        const id = n.namedChild(0);
+        if (id && id.type === "identifier" && !isKeywordUsedAsName(id.text) && id.text !== "_") emitUse(n, id.text, id);
+      } else if (n.type === "field_expression") {
+        const isCallFn = n.parent && n.parent.type === "call_expression" && n.parent.childForFieldName?.("function")?.id === n.id;
+        if (!isCallFn) {
+          const recv = this.leftmostIdentifier(n);
+          const isSelfReceiver = recv !== null && (recv.text === "this" || recv.text === "super");
+          if (isSelfReceiver) {
+            const leaf = n.childForFieldName?.("field");
+            if (leaf && leaf.text.length > 0) emitUse(n, stripScalaQuoting(leaf.text), leaf);
+          } else if (recv && recv.text.length > 0 && !(recv.text.charCodeAt(0) >= 65 && recv.text.charCodeAt(0) <= 90)) {
+            emitUse(n, stripScalaQuoting(recv.text), recv);
+          }
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c);
+      }
+    };
+    walk(rootNode);
+  }
+  /**
+   * SCALA 3 RE-EXPORT CLAUSES — `export a.b.{x, y}`, `export a.b.*`,
+   * `export a.b.{x => y}`.
+   *
+   * This is NOT the export convention. A public top-level declaration is this
+   * file's OWN API; a re-export clause names something the file does not define
+   * and makes it reachable under this package — a different fact, and the only
+   * one of the two that is a DEPENDENCY in the graph's sense (it points at
+   * another compilation unit's name).
+   *
+   * Node shape, measured (script/m14/tmp/scala-probe-export.ts):
+   *   export a.b.{x, y}   -> (export_declaration path: (identifier) path: (identifier)
+   *                                     (namespace_selectors (identifier) (identifier)))
+   *   export a.b.*        -> (export_declaration path: … path: … (namespace_wildcard))
+   *   export a.b.{x => y} -> (export_declaration … (namespace_selectors (arrow_renamed_identifier
+   *                                                             name: (identifier) alias: (identifier))))
+   *
+   * The pinned grammar parses ONLY this standalone form. `export class Alpha`,
+   * `export object Beta`, `export type Foo = Int` and `export def f(..)` all
+   * produce an ERROR node, so the export MODIFIER spelling of the language does
+   * not reach this analyzer at all — a separate limitation, recorded in the lane
+   * doc, because a construct the grammar drops cannot be read by any walker over
+   * it. (dotty's own sources use no re-export clause: 0 occurrences over 9,353
+   * files. The emission is here because the CORPUS is one repository and the
+   * construct is real — "the corpus does not use it" is not "the language cannot
+   * express it", which is the distinction the ontology gate's json `exports`
+   * note exists to enforce.)
+   *
+   * The target is the FULL re-exported path (`a.b.x`), not the bare selector,
+   * because the clause's meaning is "this package now offers the name a.b.x";
+   * publishing `x` alone would name a symbol the file neither declares nor
+   * imports. That is the same `lastSegment` exception the derives-clause already
+   * makes (emit()'s `leafOnly`, G6), stated for the same reason: a re-export is
+   * written as a path.
+   */
+  collectScalaReExports(rootNode, relationships) {
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "export_declaration") {
+        const parts = [];
+        let wildcard = false;
+        for (let i = 0; i < n.childCount; i++) {
+          const c = n.child(i);
+          if (!c) continue;
+          if (c.type === "identifier") parts.push(stripScalaQuoting(c.text));
+          else if (c.type === "namespace_wildcard") wildcard = true;
+          else if (c.type === "namespace_selectors") {
+            for (let j = 0; j < c.childCount; j++) {
+              const sel = c.child(j);
+              if (!sel) continue;
+              if (sel.type === "identifier") parts.push(stripScalaQuoting(sel.text));
+              else if (sel.type === "arrow_renamed_identifier") {
+                const nm = sel.childForFieldName?.("name") ?? sel.namedChild(0);
+                if (nm) parts.push(stripScalaQuoting(nm.text));
+              }
+            }
+          }
+        }
+        if (parts.length === 0) continue;
+        const target = parts.join(".");
+        relationships.push({
+          source: "(file)",
+          target,
+          type: ASTEngine.RelationshipType.Exports,
+          confidence: 1,
+          line_number: n.startPosition.row + 1,
+          metadata: { isScalaExport: true, isScalaReExport: true, wildcard }
+        });
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  /**
+   * CERTIFY THE JVM PLATFORM TARGETS — one pass over the finished edge list, additive.
+   *
+   * The claim, the list and the measurements behind it are on `SCALA_JVM_PLATFORM_ROOTS` above. This
+   * method is the mechanism; these are the four guards, each one forced by a measured case rather than
+   * by taste:
+   *
+   *   1. **DOTTED ONLY.** A bare target is refused even when it IS a platform word, because a scala
+   *      file can and does declare that name (`class java`, `val java`). 14 of the 117 candidate edges
+   *      in the measured population are a bare `java` read; every one of them is refused here.
+   *   2. **NOT A NAME THIS FILE DECLARES.** The same guard zig uses, and the second line of defence
+   *      behind guard 4.
+   *   3. **NO SECOND CLAIM.** An edge already certified by another mechanism keeps it.
+   *   4. **NOT IN A FILE THAT WRITES IN A PLATFORM NAMESPACE.** `scala3/tests/pos/t8367.scala` declares
+   *      `package java.lang` and a `class Throwable` in it; a file whose own module leads with a
+   *      platform root is writing IN the namespace, so nothing it names is certified.
+   *
+   * RETURNS the number of edges certified, so a caller can print it — the count is not asserted here
+   * because the analyzer publishes no file-level metadata key for it (adding one would change a payload
+   * every fixture reader sees, for a number the gate already reports).
+   */
+  certifyJvmPlatformTargets(rootNode, relationships, symbols) {
+    const moduleName = this.scalaModuleName(rootNode);
+    const headDot = moduleName.indexOf(".");
+    const ownModuleHead = moduleName === _RealScalaAnalyzer.FILE_MODULE ? "" : headDot < 0 ? moduleName : moduleName.slice(0, headDot);
+    if (SCALA_JVM_PLATFORM_ROOTS.has(ownModuleHead)) return 0;
+    const declaredHere = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if (s.name) declaredHere.add(String(s.name));
+      const q = s.qualifiedName;
+      if (typeof q === "string" && q.length > 0) declaredHere.add(q);
+    }
+    let certified = 0;
+    for (const rel of relationships) {
+      const md = rel.metadata;
+      if (!md || typeof md !== "object") continue;
+      let claimed = false;
+      for (const k of SCALA_CLAIM_KEYS_ON_EDGE) {
+        if (md[k] !== void 0) {
+          claimed = true;
+          break;
+        }
+      }
+      if (claimed) continue;
+      const target = String(rel.target ?? "");
+      const dot = target.indexOf(".");
+      if (dot <= 0) continue;
+      if (declaredHere.has(target)) continue;
+      if (!SCALA_JVM_PLATFORM_ROOTS.has(target.slice(0, dot))) continue;
+      md.languageNamespace = [...SCALA_JVM_PLATFORM_ROOTS];
+      certified++;
+    }
+    return certified;
+  }
+  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 = "structural";
+        continue;
+      }
+      if (t === "imports") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = md.isImportDep ? "import_based" : "reference_qualified";
+        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 = conf >= 0.9 ? "structural" : "usage_contextual";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  createSymbol(name, kind, node, parent, extraMetadata = {}) {
+    name = stripScalaQuoting(name);
+    const decorators = this.collectAnnotations(node);
+    const kdoc = this.extractScalaDoc(node);
+    const decl = this.declarationLineNode(node);
+    return {
+      name,
+      kind,
+      range: {
+        startLine: decl.startPosition.row + 1,
+        startColumn: decl.startPosition.column + 1,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column + 1,
+        startIndex: decl.startIndex,
+        endIndex: node.endIndex
+      },
+      id: `${parent ? parent.id + "." : ""}${name}`,
+      parent: parent ? parent.name : void 0,
+      ownerName: parent ? parent.name : void 0,
+      // ScalaD-G (M37.21 #610, scala3 Setup.scala): companion objects share
+      // the class NAME (object Setup + class Setup) and the override post-pass
+      // looks up the OWNER in a name-keyed typeIndex — without ownerKind the
+      // module shadowed the class and its superTypes were unreachable (BFS
+      // died at hop 0, Setup.isPreCC -> SetupAPI.isPreCC never emitted).
+      // Stamp ownerKind at walk time so the post-pass routes lookups to the
+      // same-kind index entry.
+      ownerKind: parent ? parent.kind : void 0,
+      visibility: this.getVisibility(node),
+      parameters: extraMetadata.parameters,
+      returnType: extraMetadata.returnType,
+      decorators,
+      comments: kdoc ? [kdoc] : [],
+      // Hoisted top-level per family contract: the DB ingester reads
+      // symbol.complexity (|| 1) for gravity scoring — leaving it only in
+      // metadata left every scala symbol at complexity 1 in the index.
+      complexity: extraMetadata.complexity,
+      metadata: { ...extraMetadata, annotations: decorators }
+    };
+  }
+  // ==========================================================================
+  // ZERO-REGEX STRING HELPERS (M49 JVM-closure wave, user directive: analyzers
+  // carry no regex unless a text micro-parse genuinely requires it).
+  //
+  // Each helper replaces a former regex literal with a char-scan whose
+  // equivalence is provable by string algebra, recorded here per the
+  // closure-audit rule that equivalence claims carry their own proof:
+  //
+  // - stripBracketGroups ≡ replace(/\[[^\[\]]*\]/g, ""), FAITHFULLY:
+  //     the regex matches `[` + a run containing NO `[` and NO `]` + `]`.
+  //     At each `[` the scan looks for the FIRST `]`; if any `[` occurs
+  //     before it, the match at this position fails (regex would advance)
+  //     and the `[` is emitted verbatim. A bare `>` or `<` is NEVER
+  //     consumed — measured on cats-effect `ParallelF[Id, *] ~> Id` where
+  //     a depth-scanner prototype dropped the `>` of `~>` (fabricated
+  //     `(ParallelF ~ Id)` targets, caught by the corpus differential).
+  // - stripAngleGroups ≡ replace(/<[^<>]*>/g, ""), same first-delimiter
+  //     discipline for `<`/`>`; `~>` survives because a `>` with no
+  //     preceding unmatched `<` is copied through.
+  // - stripTypeArgs ≡ bracket pass THEN angle pass (the original chained
+  //     replaces ran left-to-right in that order), then trim. Callers
+  //     loop to a fixpoint for nested groups, as before.
+  // - compactType ≡ replace(/\s+/g, ""): `\s+` is a maximal whitespace
+  //     run; the scan copies non-space chars and skips runs — identical
+  //     output for every input (whitespace = Unicode space class per
+  //     JS \s; the scan uses the same set via c===" "||\t||\n||\r||\f||\v).
+  // - isTypeishNodeName ≡ /identifier|type_identifier|_parameter$/.test
+  //     (unanchored) and ≡ /_type$|type_identifier/.test: `includes(sub)`
+  //     ≡ unanchored literal alternation; suffix tests use endsWith.
+  // - isTypePositionNode ≡ (/type$|_type$/.test(t) || t==="type_identifier"
+  //     || t==="stable_type_identifier" || t==="generic_type"):
+  //     /type$|_type$/ over a node-type string ≡ endsWith("type") because
+  //     _type$ is subsumed by type$ (any string ending in "_type" ends
+  //     in "type") — the disjunction is exactly endsWith("type").
+  // =========================================================================
+  stripBracketGroups(s) {
+    let out = "";
+    for (let i = 0; i < s.length; i++) {
+      if (s[i] !== "[") {
+        out += s[i];
+        continue;
+      }
+      let j = i + 1;
+      let nested = false;
+      while (j < s.length && s[j] !== "]") {
+        if (s[j] === "[") {
+          nested = true;
+          break;
+        }
+        j++;
+      }
+      if (j < s.length && !nested) {
+        i = j;
+        continue;
+      }
+      out += s[i];
+    }
+    return out;
+  }
+  stripAngleGroups(s) {
+    let out = "";
+    for (let i = 0; i < s.length; i++) {
+      if (s[i] !== "<") {
+        out += s[i];
+        continue;
+      }
+      let j = i + 1;
+      let nested = false;
+      while (j < s.length && s[j] !== ">") {
+        if (s[j] === "<") {
+          nested = true;
+          break;
+        }
+        j++;
+      }
+      if (j < s.length && !nested) {
+        i = j;
+        continue;
+      }
+      out += s[i];
+    }
+    return out;
+  }
+  /**
+   * M60 (#924, scala E): the HEAD TYPE NAME of a type node — never the node's source
+   * text. `new ScalaRandom[F](Applicative[F].pure(new JavaSecureRandom())) with
+   * SecureRandom[F] {}` is an instance_expression whose type is a compound_type: a
+   * whole EXPRESSION (constructor arguments included) whose NAME is the head type
+   * constructor. The generic_type path already collapsed to the head; this applies the
+   * same collapse to every type shape, descending the head position (compound base →
+   * applied constructor → generic type) and falling back to the old text behaviour only
+   * when the shape is none of those. Measured: SecureRandomCompanionPlatform.scala:70,
+   * node shape in script/m14/tmp/c924-scala-val-shape.ts.
+   */
+  scalaTypeHeadName(typeNode) {
+    let n = typeNode;
+    for (let guard = 0; n && guard < 8; guard++) {
+      if (n.type === "type_identifier") return n.text;
+      if (n.type === "compound_type") n = n.childForFieldName("base") ?? n.namedChild(0);
+      else if (n.type === "applied_constructor_type") n = n.namedChild(0);
+      else if (n.type === "generic_type") n = n.namedChild(0);
+      else break;
+    }
+    return this.stripTypeArgs(typeNode.text);
+  }
+  /**
+   * M60/S3: the SUPER TYPE NAME for an ANONYMOUS class — structurally walked, and
+   * "" when no type name is reachable.
+   *
+   * This exists beside scalaTypeHeadName rather than replacing it because the two
+   * answer different questions. scalaTypeHeadName names an INSTANTIATION target,
+   * where the node's own text is the honest type (`new (IO ~> F) {}` really does
+   * instantiate the natural-transformation type `(IO ~> F)`), and that label is
+   * audited. An ANONYMOUS CLASS's name is SYNTHETIC — the analyzer's own rule,
+   * stated at its emission site, is "a SYNTHETIC name must be canonical - never
+   * source text" (#924) — and scalaTypeHeadName's text fallback violates it: for
+   * a type shape the walk does not recognise it returns `stripTypeArgs(text)`.
+   *
+   * Measured on both corpora (script/m14/tmp/scala-garbage-names.ts, 400 files
+   * each) — `anonymous_<source text>` symbols, whose name is no declared name in
+   * their own file:
+   *
+   *   cats-effect 20 of 291, of which 18 are a natural-transformation supertype
+   *     `new (IO ~> F) { ... }` -> `anonymous_(IO ~> F)` (LiftIO.scala:36,
+   *     Async.scala:199, Resource.scala:244/580/997/1123, pure.scala x5, ...)
+   *   scala3 15 of 191, of which 2 are a MULTI-LINE body published as a NAME:
+   *     `anonymous_:\n      private var cur = Env.this\n      def hasNext = ...`
+   *     (CheckCaptures.scala:77, CapturedVars.scala:114)
+   *
+   * The shapes that must still resolve, probed before this was written rather
+   * than guessed (script/m14/tmp/scala-snip.ts /tmp/anon.txt):
+   *
+   *   new Runnable {}                     -> instance_expression > type_identifier
+   *   new java.util.Comparator[String] {} -> generic_type > stable_type_identifier
+   *                                          > stable_identifier(id,id) + type_identifier
+   *   new Console.MapKConsole[Int] {}      -> generic_type > stable_type_identifier
+   *                                          > identifier + type_identifier
+   *   new ScalaRandom[F](a) with Sec[F] {} -> compound_type > base >
+   *                                          applied_constructor_type > generic_type
+   *
+   * A qualified name is its leading identifiers joined by "." plus the final
+   * type_identifier — which is what the text happened to be, now for a reason.
+   */
+  scalaAnonymousSupertypeName(typeNode) {
+    if (!typeNode) return "";
+    const walk = (n, guard) => {
+      if (!n || guard > 8) return "";
+      switch (n.type) {
+        case "type_identifier":
+          return n.text;
+        case "compound_type": {
+          const base = n.childForFieldName("base");
+          return walk(base ?? n.namedChild(0), guard + 1);
+        }
+        case "applied_constructor_type":
+        case "generic_type":
+          return walk(n.namedChild(0), guard + 1);
+        case "stable_type_identifier": {
+          const segs = [];
+          const collectStable = (t, guard2) => {
+            if (guard2 > 8) return;
+            for (let i = 0; i < t.namedChildCount; i++) {
+              const c = t.namedChild(i);
+              if (!c || c.type === "type_identifier") continue;
+              if (c.type === "stable_identifier") collectStable(c, guard2 + 1);
+              else if (c.type === "identifier") segs.push(c.text);
+            }
+          };
+          collectStable(n, 0);
+          let last = "";
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c && c.type === "type_identifier") last = c.text;
+          }
+          if (!last) return "";
+          return segs.length > 0 ? `${segs.join(".")}.${last}` : last;
+        }
+        default:
+          return "";
+      }
+    };
+    return walk(typeNode, 0);
+  }
+  stripTypeArgs(s) {
+    return this.stripAngleGroups(this.stripBracketGroups(s)).trim();
+  }
+  compactType(s) {
+    let out = "";
+    for (let i = 0; i < s.length; i++) {
+      const c = s[i];
+      if (c === " " || c === "	" || c === "\n" || c === "\r" || c === "\f" || c === "\v") continue;
+      out += c;
+    }
+    let seg = "";
+    let sawDot = false;
+    for (let i = 0; i < out.length; i++) {
+      const c = out[i];
+      if (c === ".") {
+        sawDot = true;
+        seg = "";
+        continue;
+      }
+      seg += c;
+    }
+    return sawDot ? seg : out;
+  }
+  /** ≡ /identifier|type_identifier|_parameter$/.test(t): unanchored "identifier" ≡ includes (type_identifier is subsumed by it). NO _type disjunct — deliberately narrower than isExtensionReceiverTypeNode. */
+  isTypeishNodeName(t) {
+    return t.includes("identifier") || t.endsWith("_parameter");
+  }
+  /** ≡ /_type$|type_identifier/.test(t): suffix or the exact node type — NOT the bare-identifier disjunct of isTypeishNodeName. */
+  isExtensionReceiverTypeNode(t) {
+    return t.endsWith("_type") || t.includes("type_identifier");
+  }
+  /** ≡ /type$|_type$/.test(t) || t === "type_identifier" || t === "stable_type_identifier" (generic_type variant adds itself). */
+  isTypePositionNode(t) {
+    return t.endsWith("type") || t === "type_identifier" || t === "stable_type_identifier";
+  }
+  /**
+   * Is this `type_identifier` part of a Scala 3 PLACEHOLDER rather than a type
+   * name?
+   *
+   * The grammar splits `-_` / `+_` / `-_*` into the operator character as a
+   * `type_identifier` and the wildcard as a NEIGHBOUR TOKEN — but not always as
+   * a sibling, which is why a first version of this guard (next SIBLING only)
+   * suppressed 2 of the 6 corpus sites and left 4 published. Both shapes are
+   * measured, on `scala/wildcard-is-not-a-name` line 12 and on the two corpus
+   * files:
+   *
+   *   vararg: -_*        infix_type          -> type_identifier "-" + identifier "_" + type_identifier "*"
+   *   byname: => -_      lazy_parameter_type -> type_identifier "-", and the `_`
+   *                      lands as an ERROR SIBLING OF THE PARAMETER, one level up
+   *
+   * So the test is on the ADJACENT TOKEN in source order, found by walking to
+   * the parent for as long as the node is the last child. A placeholder's
+   * `_` is what follows the operator and what precedes the `*`, so the test is
+   * "the next token is a wildcard, or the previous token is `_`".
+   *
+   * What this deliberately does NOT decide: a `?` wildcard (`def f(x: List[?])`)
+   * parses as a BARE `type_identifier "?"` with no wildcard neighbour, so it is
+   * indistinguishable here from the legal Scala 3 type name `?` (`type ?[A]`,
+   * test/files/neg/qmark-deprecated.scala). Deciding it needs the file's
+   * declared-type table, which this collector does not hold; it is recorded as
+   * an open item in the lane doc rather than guessed at.
+   */
+  isScalaPlaceholderFragment(n) {
+    if (n.type !== "type_identifier") return false;
+    let cur = n;
+    while (cur) {
+      const p = cur.parent;
+      if (!p) break;
+      let sawNext = false;
+      for (let i = 0; i < p.childCount; i++) {
+        const c = p.child(i);
+        if (!c) continue;
+        if (c.id === cur.id) {
+          const next = p.child(i + 1);
+          if (next) {
+            sawNext = true;
+            if (next.text === "_" || next.text === "?") return true;
+          }
+          break;
+        }
+      }
+      if (sawNext) break;
+      cur = p;
+    }
+    cur = n;
+    while (cur) {
+      const p = cur.parent;
+      if (!p) break;
+      let sawPrev = false;
+      for (let i = p.childCount - 1; i >= 0; i--) {
+        const c = p.child(i);
+        if (!c) continue;
+        if (c.id === cur.id) {
+          const prev = p.child(i - 1);
+          if (prev) {
+            sawPrev = true;
+            if (prev.text === "_") return true;
+          }
+          break;
+        }
+      }
+      if (sawPrev) break;
+      cur = p;
+    }
+    return false;
+  }
+  /**
+   * THE SELF-TYPE'S REQUIRED TYPE — the names a self type REQUIRES.
+   *
+   * ★ WHY THIS IS A DEDICATED READER AND NOT `collectTypeNames`. Two shapes need a decision the
+   *   generic reader does not make, and both are MEASURED over the admitted population
+   *   (validation/m14/measurements/scala-construct-census.json, 1,017 self_type sites in 636 files):
+   *
+   *   1. `singleton_type` — `this: IO.type =>` — spells its target as an `identifier` child
+   *      (`N:identifier A:. A:type`), and the generic reader only pushes `type_identifier` and
+   *      `stable_type_identifier`, so it would publish NOTHING for the 154 singleton sites.
+   *      The target of a singleton type is the MODULE's name, and that is the name the row needs.
+   *   2. `type_arguments` — `this: xs.Cap[A] =>` — the `[A]` is a type PARAMETER of the required
+   *      type, NOT a second conformance requirement. The generic reader recurses into it and
+   *      would publish `A` as a conformance target, which is a fabrication: `A` is bound by the
+   *      required type, not required BY the declaring type.
+   *
+   * ★ AND THE POSITION IS FOUND BY THE ":" TOKEN, NOT BY INDEX. The grammar spells a self type
+   *   `<self-name> [":" <type>] "=>"`, and a trailing block comment is a NAMED child too — the
+   *   measured shape `identifier | block_comment | : | type_identifier | block_comment | =>`
+   *   would make "the second named child" the comment.
+   *
+   * ★ AND A `self =>` WITH NO ":" IS NOT A CONFORMANCE. It binds a self NAME and requires
+   *   nothing: the measured shapes are 344 `identifier =>` and 2 `wildcard =>` against 671 that
+   *   carry a type, so this reader returns nothing for them and the `implements` row is not
+   *   published — a self name is not a conformance requirement.
+   *
+   * ★ AND A `structural_type` REQUIRED TYPE NAMES NO CONFORMANCE TARGET: `this: { def f: Int } =>`
+   *   (4 sites) describes a shape, and the members inside it are not types the declaring type
+   *   conforms to. It is refused rather than mined for a name.
+   */
+  selfTypeRequiredTypeNames(st) {
+    const out = [];
+    let colon = -1;
+    for (let i = 0; i < st.childCount; i++) {
+      const c = st.child(i);
+      if (c && !c.isNamed && c.type === ":") {
+        colon = i;
+        break;
+      }
+    }
+    if (colon < 0) return out;
+    let req = null;
+    for (let i = colon + 1; i < st.childCount; i++) {
+      const c = st.child(i);
+      if (!c || !c.isNamed) continue;
+      if (c.type === "block_comment" || c.type === "comment") continue;
+      req = c;
+      break;
+    }
+    if (!req) return out;
+    if (req.type === "structural_type") return out;
+    if (req.type === "singleton_type") {
+      for (let i = 0; i < req.namedChildCount; i++) {
+        const c = req.namedChild(i);
+        if (c && (c.type === "identifier" || c.type === "stable_identifier" || c.type === "stable_type_identifier")) {
+          const nm = stripScalaQuoting(c.text);
+          if (nm) out.push({ name: nm, line: c.startPosition.row + 1 });
+          return out;
+        }
+      }
+      return out;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const walk = (n) => {
+      if (n.type === "type_arguments" || n.type === "wildcard") return;
+      if (n.type === "type_identifier" || n.type === "stable_type_identifier") {
+        const nm = stripScalaQuoting(n.text);
+        if (nm && !seen.has(nm)) {
+          seen.add(nm);
+          out.push({ name: nm, line: n.startPosition.row + 1 });
+        }
+        return;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c);
+      }
+    };
+    walk(req);
+    return out;
+  }
+  /** Extract supertypes from an extends_clause (direct type children in v0.26.2). */
+  /**
+   * M59 (#825): each supertype name is paired with the LINE IT IS WRITTEN ON.
+   *
+   * Scala writes the parents of a long inheritance list one per line:
+   *
+   *     trait IterableLike[+A]
+   *       extends FromIterable          ← 106
+   *          with IterableOps[A]        ← 107
+   *          with IterablePolyTransforms[A]   ← 108
+   *
+   * Stamping the clause's start line put IterableOps/PolyTransforms on 106, a
+   * line they are not written on — 8 of 8 remaining scala oracle failures at the
+   * 300-file scale, including the `trait T1 extends { ... } with Base` form where
+   * the parent appears AFTER an early-init block. Same defect family as the call
+   * site (`#825` half one) and the declared-type reference: the line belongs to
+   * the NAME, never to the construct containing it.
+   */
+  extractSupertypes(extendsClause) {
+    const out = [];
+    const push = (name, n) => {
+      if (!name) return;
+      if (out.some((x) => x.name === name)) return;
+      out.push({ name, line: n.startPosition.row + 1 });
+    };
+    for (let i = 0; i < extendsClause.childCount; i++) {
+      const c = extendsClause.child(i);
+      if (!c || !c.isNamed) continue;
+      if (c.type === "type_identifier" || c.type === "identifier") {
+        push(c.text, c);
+      } else if (c.type === "stable_type_identifier") {
+        push(c.text, c);
+      } else if (c.type === "generic_type") {
+        let pushed = false;
+        for (let j = 0; j < c.childCount; j++) {
+          const ch = c.child(j);
+          if (ch && ch.type === "stable_type_identifier") {
+            push(ch.text, ch);
+            pushed = true;
+            break;
+          }
+        }
+        if (!pushed) {
+          for (let j = 0; j < c.childCount; j++) {
+            const ch = c.child(j);
+            if (ch && ch.type === "type_identifier") {
+              push(ch.text, ch);
+              break;
+            }
+          }
+        }
+      } else if (c.type === "compound_type") {
+        for (let j = 0; j < c.namedChildCount; j++) {
+          const ch = c.namedChild(j);
+          if (ch && (ch.type === "type_identifier" || ch.type === "generic_type" || ch.type === "annotated_type")) {
+            if (ch.type === "type_identifier") push(ch.text, ch);
+            else if (ch.type === "annotated_type") {
+              const base = this.annotatedTypeBase(ch);
+              if (base) push(base.name, base.node);
+            } else {
+              const inner = this.extractSupertypes(ch);
+              if (inner.length > 0) push(inner[0].name, ch);
+              else push(ch.text, ch);
+            }
+          }
+        }
+      } else if (c.type === "annotated_type") {
+        const base = this.annotatedTypeBase(c);
+        if (base) push(base.name, base.node);
+      }
+    }
+    return out;
+  }
+  /**
+   * ★ THE BASE TYPE UNDER AN ANNOTATION. `annotated_type` holds the TYPE and then the `annotation`,
+   *   so the base is its first named child — and it is the base that names the supertype.
+   *
+   *   The shape is measured from the pinned build, not assumed: `annotated_type` ->
+   *   (`type_identifier` | `generic_type` | `stable_type_identifier`) + `annotation`.
+   */
+  // SCALA-ANN-SUPERTYPE-BLOCK-C:BEGIN
+  annotatedTypeBase(n) {
+    for (let j = 0; j < n.namedChildCount; j++) {
+      const ch = n.namedChild(j);
+      if (!ch) continue;
+      if (ch.type === "type_identifier" || ch.type === "identifier" || ch.type === "stable_type_identifier") {
+        return { name: ch.text, node: ch };
+      }
+      if (ch.type === "generic_type") {
+        for (let k = 0; k < ch.childCount; k++) {
+          const g = ch.child(k);
+          if (g && g.type === "stable_type_identifier") return { name: g.text, node: g };
+        }
+        for (let k = 0; k < ch.childCount; k++) {
+          const g = ch.child(k);
+          if (g && g.type === "type_identifier") return { name: g.text, node: g };
+        }
+        return null;
+      }
+    }
+    return null;
+  }
+  // SCALA-ANN-SUPERTYPE-BLOCK-C:END
+  handleClass(node, symbols, relationships, exports, patternsObj, parent) {
+    const name = this.extractIdentifier(node, "name");
+    if (!name) return null;
+    const mods = this.collectModifiers(node);
+    const isCase = this.isCaseClass(node);
+    const isSealed = mods.has("sealed");
+    const isAbstract = mods.has("abstract");
+    const isFinal = mods.has("final");
+    const isImplicit = mods.has("implicit");
+    const classParamsNode = this.findChild(node, "class_parameters");
+    const constructorParams = [];
+    if (classParamsNode) {
+      const ownerName = stripScalaQuoting(name);
+      const idStub = { id: ownerName, name: ownerName };
+      const ctor = this.createSymbol("constructor", ASTEngine.SymbolKind.Constructor, classParamsNode, idStub, {
+        type: "constructor",
+        ownerName,
+        ownerKind: ASTEngine.SymbolKind.Class,
+        scalaSpecific: true
+      });
+      ctor.ownerName = ownerName;
+      const ctorParams = [];
+      symbols.push(ctor);
+      for (let i = 0; i < classParamsNode.namedChildCount; i++) {
+        const cp = classParamsNode.namedChild(i);
+        if (cp?.type !== "class_parameter") continue;
+        const pName = cp.childForFieldName("name")?.text;
+        if (!pName) continue;
+        constructorParams.push(pName);
+        const paramType = cp.childForFieldName("type")?.text;
+        if (paramType) ctorParams.push({ name: pName, type: paramType, isImplicit: false });
+        const pMods = this.collectModifiers(cp);
+        const isVal = pMods.has("val");
+        const isVar = pMods.has("var");
+        if (isVal || isVar || isCase) {
+          const prop = this.createSymbol(pName, ASTEngine.SymbolKind.Property, cp, idStub, {
+            type: isVar ? "var" : "val",
+            isConstructorProperty: true,
+            ownerName,
+            ownerKind: ASTEngine.SymbolKind.Class,
+            isCaseClassParam: isCase
+          });
+          prop.ownerName = ownerName;
+          symbols.push(prop);
+        }
+      }
+      if (ctorParams.length > 0) ctor.parameters = ctorParams;
+    }
+    if (isSealed) patternsObj["Sealed Types"] = true;
+    const symbol = this.createSymbol(name, ASTEngine.SymbolKind.Class, node, parent, {
+      type: "class",
+      isObject: false,
+      isCaseClass: isCase,
+      isSealed,
+      isAbstract,
+      isFinal,
+      isImplicit,
+      constructorParams: constructorParams.length > 0 ? constructorParams : void 0
+    });
+    symbols.push(symbol);
+    if (isImplicit) patternsObj["Implicit Classes (Extension Methods)"] = true;
+    if (this.isPublic(node) && !parent) {
+      exports.push({
+        // `symbol.name`, not the raw `name`: createSymbol strips quoting syntax,
+        // so the array used to publish `` `strip margin` `` where the symbol was
+        // `strip margin` — one public surface with two spellings of every
+        // backticked name in it. Measured on scala/scala (package.scala:40,
+        // `implicit val `strip margin``), and the `exports` RELATIONSHIP derives
+        // from this array, so the two spellings would have met in the graph.
+        name: symbol.name,
+        kind: ASTEngine.SymbolKind.Class,
+        range: symbol.range
+      });
+    }
+    const typeParams = this.extractScalaTypeParameters(node);
+    if (typeParams.length > 0) {
+      symbol.genericParameters = typeParams;
+      symbol.metadata.typeParameters = typeParams;
+    }
+    const extendsClause = this.findChild(node, "extends_clause");
+    if (extendsClause) {
+      const supertypes = this.extractSupertypes(extendsClause);
+      symbol.metadata.superTypes = supertypes.map((s) => s.name);
+      for (let i = 0; i < supertypes.length; i++) {
+        relationships.push({
+          source: symbol.name,
+          target: supertypes[i].name,
+          // FLEET MIXIN RULING (2026-10-19, Lead): position 0 is the single
+          // supertype `extends`; positions >=1 are MIXIN COMPOSITION and publish
+          // `mixes_in`, the canonical value for `class A with M` / Ruby
+          // `include/extend/prepend` / Dart `with`. They are NOT `implements`
+          // conformance (the implements value is ruled NOT-APPLICABLE for scala;
+          // the false-negative-if-conformance-without-composition falsifier is in
+          // the lane's SCALA-CENSUS.md). This shape is the same for the
+          // object handler below.
+          type: i === 0 ? ASTEngine.RelationshipType.Extends : ASTEngine.RelationshipType.MixesIn,
+          // S1.4: explicit structural confidence (1.0) — undefined is
+          // classifier-defaulted today but downstream >= 0.7 filters read
+          // the field directly.
+          confidence: 1,
+          // M59 (#825): the parent's OWN line, not the clause's.
+          line_number: supertypes[i].line,
+          metadata: { isTrait: i > 0 }
+        });
+      }
+    }
+    return symbol;
+  }
+  handleObject(node, symbols, relationships, exports, patternsObj, parent) {
+    const name = this.extractIdentifier(node, "name");
+    if (!name) return null;
+    const mods = this.collectModifiers(node);
+    const isCase = this.isCaseClass(node);
+    const isSealed = mods.has("sealed");
+    const symbol = this.createSymbol(name, ASTEngine.SymbolKind.Module, node, parent, {
+      type: "object",
+      isObject: true,
+      isCaseObject: isCase,
+      isSealed,
+      scalaSpecific: true,
+      isStatic: true
+    });
+    symbol.isStatic = true;
+    symbols.push(symbol);
+    if (this.isPublic(node) && !parent && !exports.some((e) => e.name === symbol.name)) {
+      exports.push({
+        name: symbol.name,
+        kind: ASTEngine.SymbolKind.Module,
+        range: symbol.range
+      });
+    }
+    const typeParams = this.extractScalaTypeParameters(node);
+    if (typeParams.length > 0) {
+      symbol.genericParameters = typeParams;
+      symbol.metadata.typeParameters = typeParams;
+    }
+    const extendsClause = this.findChild(node, "extends_clause");
+    if (extendsClause) {
+      const supertypes = this.extractSupertypes(extendsClause);
+      symbol.metadata.superTypes = supertypes.map((s) => s.name);
+      for (let i = 0; i < supertypes.length; i++) {
+        relationships.push({
+          source: symbol.name,
+          target: supertypes[i].name,
+          // FLEET MIXIN RULING (2026-10-19, Lead): position 0 is the single
+          // supertype `extends`; positions >=1 are MIXIN COMPOSITION and publish
+          // `mixes_in`, the canonical value for `class A with M` / Ruby
+          // `include/extend/prepend` / Dart `with`. They are NOT `implements`
+          // conformance (the implements value is ruled NOT-APPLICABLE for scala;
+          // the false-negative-if-conformance-without-composition falsifier is in
+          // the lane's SCALA-CENSUS.md). This shape is the same for the
+          // object handler below.
+          type: i === 0 ? ASTEngine.RelationshipType.Extends : ASTEngine.RelationshipType.MixesIn,
+          confidence: 1,
+          line_number: extendsClause.startPosition.row + 1,
+          metadata: { isTrait: i > 0 }
+        });
+      }
+    }
+    return symbol;
+  }
+  handleTrait(node, symbols, relationships, exports, patternsObj, parent) {
+    const name = this.extractIdentifier(node, "name");
+    if (!name) return null;
+    const mods = this.collectModifiers(node);
+    const isSealed = mods.has("sealed");
+    if (isSealed) patternsObj["Sealed Types"] = true;
+    const symbol = this.createSymbol(name, ASTEngine.SymbolKind.Interface, node, parent, {
+      type: "trait",
+      isTrait: true,
+      scalaSpecific: true,
+      isSealed
+    });
+    symbols.push(symbol);
+    if (this.isPublic(node) && !parent) {
+      exports.push({
+        name: symbol.name,
+        kind: ASTEngine.SymbolKind.Interface,
+        range: symbol.range
+      });
+    }
+    const typeParams = this.extractScalaTypeParameters(node);
+    if (typeParams.length > 0) {
+      symbol.genericParameters = typeParams;
+      symbol.metadata.typeParameters = typeParams;
+    }
+    const extendsClause = this.findChild(node, "extends_clause");
+    if (extendsClause) {
+      const supertypes = this.extractSupertypes(extendsClause);
+      symbol.metadata.superTypes = supertypes.map((s) => s.name);
+      for (let i = 0; i < supertypes.length; i++) {
+        relationships.push({
+          source: symbol.name,
+          target: supertypes[i].name,
+          // FLEET MIXIN RULING (2026-10-19): a trait's own supertype list is
+          // the same composition construct — position 0 stays `extends`, every
+          // further trait in the list is `mixes_in` (it is not interface
+          // conformance; implements is ruled NOT-APPLICABLE for scala).
+          type: i === 0 ? ASTEngine.RelationshipType.Extends : ASTEngine.RelationshipType.MixesIn,
+          confidence: 1,
+          // M59 (#825): the parent's OWN line, not the clause's.
+          line_number: supertypes[i].line,
+          metadata: { isTrait: i > 0 }
+        });
+      }
+    }
+    return symbol;
+  }
+  handleEnum(node, symbols, relationships, exports, patternsObj, parent) {
+    const name = this.extractIdentifier(node, "name");
+    if (!name) return null;
+    const symbol = this.createSymbol(name, ASTEngine.SymbolKind.Enum, node, parent, { type: "enum", scala3: true });
+    symbols.push(symbol);
+    patternsObj["Scala 3 Enums"] = true;
+    if (this.isPublic(node) && !parent) {
+      exports.push({ name: symbol.name, kind: ASTEngine.SymbolKind.Enum, range: symbol.range });
+    }
+    const enumExtends = this.findChild(node, "extends_clause");
+    if (enumExtends) {
+      const supertypes = this.extractSupertypes(enumExtends);
+      symbol.metadata.superTypes = supertypes.map((s) => s.name);
+      for (let i = 0; i < supertypes.length; i++) {
+        const st = supertypes[i];
+        relationships.push({
+          source: name,
+          target: st.name,
+          // FLEET MIXIN RULING (2026-10-19): same extends_clause composition
+          // construct — first supertype extends, further ones mixes_in.
+          type: i === 0 ? ASTEngine.RelationshipType.Extends : ASTEngine.RelationshipType.MixesIn,
+          confidence: 1,
+          // M59 (#825): the parent's OWN line, not the clause's.
+          line_number: st.line,
+          metadata: { isTrait: true }
+        });
+      }
+    }
+    const enumParamsNode = this.findChild(node, "class_parameters");
+    if (enumParamsNode) {
+      const ownerName = stripScalaQuoting(name);
+      const idStub = { id: ownerName, name: ownerName };
+      const ctor = this.createSymbol("constructor", ASTEngine.SymbolKind.Constructor, enumParamsNode, idStub, {
+        type: "constructor",
+        ownerName,
+        ownerKind: ASTEngine.SymbolKind.Enum,
+        scalaSpecific: true
+      });
+      ctor.ownerName = ownerName;
+      const ctorParams = [];
+      symbols.push(ctor);
+      for (let i = 0; i < enumParamsNode.namedChildCount; i++) {
+        const cp = enumParamsNode.namedChild(i);
+        if (cp?.type !== "class_parameter") continue;
+        const pName = cp.childForFieldName("name")?.text;
+        if (!pName) continue;
+        const paramType = cp.childForFieldName("type")?.text;
+        if (paramType) ctorParams.push({ name: pName, type: paramType, isImplicit: false });
+        const pMods = this.collectModifiers(cp);
+        const isVal = pMods.has("val");
+        const isVar = pMods.has("var");
+        if (isVal || isVar) {
+          const prop = this.createSymbol(pName, ASTEngine.SymbolKind.Property, cp, idStub, {
+            type: isVar ? "var" : "val",
+            isConstructorProperty: true,
+            ownerName,
+            ownerKind: ASTEngine.SymbolKind.Enum
+          });
+          prop.ownerName = ownerName;
+          symbols.push(prop);
+        }
+      }
+      if (ctorParams.length > 0) ctor.parameters = ctorParams;
+    }
+    const walkEnumBody = (n) => {
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (!c) continue;
+        if (c.type === "simple_enum_case" || c.type === "full_enum_case") {
+          const caseName = this.findChildIdentifier(c);
+          if (caseName) {
+            const member = this.createSymbol(caseName, ASTEngine.SymbolKind.EnumMember, c, symbol, {
+              type: "enum_case",
+              // stripped, like every other ownerName (see handleClass): a case
+              // declared ``case `type` `` must not source its `contains` edge
+              // from a spelling the symbol index does not hold.
+              ownerName: stripScalaQuoting(name),
+              ownerKind: ASTEngine.SymbolKind.Enum,
+              scala3: true
+            });
+            member.ownerName = stripScalaQuoting(name);
+            symbols.push(member);
+          }
+        } else {
+          walkEnumBody(c);
+        }
+      }
+    };
+    const enumBody = this.findChild(node, "enum_body");
+    if (enumBody) walkEnumBody(enumBody);
+    return symbol;
+  }
+  handleTypeAlias(node, symbols, parent, exports) {
+    const name = this.extractIdentifier(node, "name");
+    if (!name) return;
+    const symbol = this.createSymbol(name, ASTEngine.SymbolKind.Type, node, parent, { isTypeAlias: true });
+    symbols.push(symbol);
+    if (this.isPublic(node) && !parent) exports.push({ name, kind: ASTEngine.SymbolKind.Type, range: symbol.range });
+  }
+  // ───────────────────────────────────────────────────────────────────────
+  // Scala 3 EXPORT CLAUSE -> `exports` relationships.
+  //
+  // The lane handover recorded `exports` as silent and the census measured the
+  // construct present: `export_declaration` — 277 nodes in 158 files of the
+  // 18,965-file population (script/m14/tmp/scala3-ontology-census.ts), e.g.
+  // compiler/src/dotty/tools/dotc/core/Flags.scala, library/src/scala/
+  // NamedTuple.scala. So this is a GAP, not an absence, and a prose ruling
+  // ("Scala has no export construct") would have been wrong on 277 measured
+  // nodes — the ontology gate's founding premise.
+  //
+  // THE RECONSTRUCTION, and why child position cannot do it. The natural first
+  // rule — "everything before the last named child is the qualifier, the last
+  // named child is the selection" — is wrong on real corpus shapes, measured in
+  // script/m14/tmp/scala3-export-reconstruct-census.mts:
+  //
+  //   * `export toppingPrice.apply, crustPrice.apply, crustPrice.unlift`
+  //     (tests/neg/i20511-1.scala) parses with SIX `field: path` children and
+  //     NO selection node at all. The positional rule reads the qualifier as
+  //     "toppingPrice.apply.crustPrice.apply.crustPrice" — three unrelated
+  //     exportees fused into one nonsense path. The FIELD is what separates
+  //     them: a `,` terminates the exportee and the path children after it
+  //     begin the next one.
+  //   * the anonymous `.` between path segments does NOT consistently carry
+  //     `field: path` (it does between two path segments, it does NOT before a
+  //     selection node), so it has to be skipped by node type, not by field.
+  //
+  // With that, the rule reconstructs 277 of 277 declarations and produces 280
+  // exportees. The first version of the rule reconstructed 90 of 277; the
+  // 187 it missed were all wildcards and selector lists, which is why the
+  // coverage number is printed rather than asserted.
+  //
+  // WHAT AN EDGE IS. A Scala 3 export clause re-publishes members of another
+  // object under the enclosing declaration's own name. So the edge reads
+  //     <enclosing declaration>  exports  <exported name>
+  // which is the same shape makefile/python/zig emit (module -> name) and the
+  // shape parallel-indexer's file-level `exports` section expects. The
+  // QUALIFIER is carried in metadata rather than glued into the target: it is
+  // the SOURCE path of the member, not part of the name the export publishes,
+  // and gluing it would produce targets no symbol in the graph is named by.
+  //
+  // CONFIDENCE. 1.0 on a NAMED exportee: the name is written in the clause, so
+  // there is nothing inferred. A wildcard exportee (`export X._`, 133 of the
+  // 277 declarations) names no member, so an edge naming one would be
+  // fabricated; it is published at 0.7 with `reasonCode: "export-wildcard"` and
+  // an `isWildcard` flag, which makes it countable as a heuristic per
+  // M14-HONESTY-CONTRACT §4 rather than silently indistinguishable from the
+  // named ones.
+  //
+  // ENDPOINT RESOLUTION. The source is the enclosing declaration's name, which
+  // is a symbol the same walk publishes, so it resolves. The target is a member
+  // name that is usually NOT a symbol in this file (it lives on the qualifier's
+  // object), so it resolves externally or not at all — which is the same
+  // position every `references` import edge is already in, and is why the
+  // qualifier goes in metadata where a consumer can still find it.
+  handleExportClause(node, relationships, parent) {
+    const SELECTION_TYPES = /* @__PURE__ */ new Set(["namespace_selectors", "namespace_wildcard", "as_renamed_identifier"]);
+    const exportees = [];
+    let pathParts = [];
+    let pathNodes = [];
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (!c) return;
+      const t = c.type;
+      const field = node.fieldNameForChild(i) ?? "";
+      if (t === "export") continue;
+      if (t === ",") {
+        if (pathParts.length === 0) continue;
+        const leaf = pathParts.pop();
+        const leafNode = pathNodes.pop() ?? c;
+        exportees.push({ prefix: pathParts, selKind: "identifier", src: leafNode, names: [leaf] });
+        pathParts = [];
+        pathNodes = [];
+        continue;
+      }
+      if (t === ".") continue;
+      if (c.isNamed && t === "block_comment") continue;
+      if (c.isNamed && SELECTION_TYPES.has(t)) {
+        if (field !== "") continue;
+        if (t === "namespace_wildcard") {
+          exportees.push({ prefix: pathParts.slice(), selKind: t, src: c, names: [] });
+        } else if (t === "namespace_selectors") {
+          const picked = [];
+          let innerWildcard = false;
+          for (let j = 0; j < c.namedChildCount; j++) {
+            const s = c.namedChild(j);
+            if (!s || s.isNamed && s.type === "block_comment") continue;
+            if (s.type === "namespace_wildcard") {
+              innerWildcard = true;
+              continue;
+            }
+            const nm = this.exportSelectorName(s);
+            if (nm === null) continue;
+            const alias = this.exportSelectorAlias(s);
+            picked.push({ name: nm, node: s, ...alias && alias !== "*" ? { exportedAs: alias } : {} });
+          }
+          for (const pk of picked) {
+            exportees.push({ prefix: pathParts.slice(), selKind: t, src: pk.node, names: [pk.name], ...pk.exportedAs ? { exportedAs: pk.exportedAs } : {} });
+          }
+          if (innerWildcard && pathParts.length > 0) {
+            exportees.push({ prefix: pathParts.slice(), selKind: "namespace_wildcard", src: c, names: [] });
+          }
+        } else {
+          const srcNode = c.namedChild(0);
+          const srcName = srcNode ? this.exportSelectorName(srcNode) : null;
+          if (srcName !== null) {
+            const alias = this.exportSelectorAlias(c);
+            exportees.push({ prefix: pathParts.slice(), selKind: t, src: srcNode ?? c, names: [srcName], ...alias && alias !== "*" ? { exportedAs: alias } : {} });
+          }
+        }
+        pathParts = [];
+        pathNodes = [];
+        continue;
+      }
+      if (field === "path") {
+        if (c.isNamed) {
+          pathParts.push(c.text);
+          pathNodes.push(c);
+        }
+        continue;
+      }
+      return;
+    }
+    if (pathParts.length > 0) {
+      const leaf = pathParts.pop();
+      const leafNode = pathNodes.pop() ?? node;
+      exportees.push({ prefix: pathParts, selKind: "identifier", src: leafNode, names: [leaf] });
+    }
+    if (exportees.length === 0) return;
+    const source = parent?.name ?? _RealScalaAnalyzer.FILE_MODULE;
+    const seen = /* @__PURE__ */ new Set();
+    for (const e of exportees) {
+      const qualifier = e.prefix.join(".");
+      if (e.names.length === 0) {
+        if (qualifier.length === 0) continue;
+        const key = `${source}|${qualifier}|*`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        relationships.push({
+          source,
+          target: qualifier,
+          type: ASTEngine.RelationshipType.Exports,
+          confidence: 0.7,
+          line_number: e.src.startPosition.row + 1,
+          metadata: { isExportClause: true, isWildcard: true, reasonCode: "export-wildcard", exportKind: "all_members", evidenceClass: "structural" }
+        });
+        continue;
+      }
+      for (const nm of e.names) {
+        const published = e.exportedAs ?? nm;
+        const target = stripScalaQuoting(published);
+        if (target.length === 0 || target === "throws") continue;
+        if (target === "_" || target === "*" || target === "unknown" || target === "?") continue;
+        const key = `${source}|${target}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        relationships.push({
+          source,
+          target,
+          type: ASTEngine.RelationshipType.Exports,
+          confidence: 1,
+          // M59 (#825): the exported name is written in the clause, so the line
+          // is where that NAME is written — the selector's own line inside a
+          // selector list, the leaf segment's own line for `export a.b`, and
+          // never the declaration's first line.
+          line_number: e.src.startPosition.row + 1,
+          metadata: {
+            isExportClause: true,
+            exportKind: e.exportedAs ? "renamed" : "named",
+            ...qualifier.length > 0 ? { exportFrom: qualifier } : {},
+            ...e.exportedAs ? { exportedAs: stripScalaQuoting(e.exportedAs) } : {},
+            evidenceClass: "structural"
+          }
+        });
+      }
+    }
+  }
+  /** The RENAMING alias one selector publishes, or null when it does not
+   *  rename. `x as y` / `x => y` publish `y`; `x as _` / `x => _` publish `x`,
+   *  which is why `_` and `*` are never returned as an alias. */
+  exportSelectorAlias(sel) {
+    const t = sel.type;
+    if (t !== "as_renamed_identifier" && t !== "arrow_renamed_identifier") return null;
+    if (sel.namedChildCount < 2) return null;
+    const last = sel.namedChild(sel.namedChildCount - 1);
+    if (!last) return null;
+    const txt = last.text;
+    if (txt === "_" || txt === "*") return null;
+    return this.exportSelectorName(last);
+  }
+  /** The member name ONE selector contributes, or null when it contributes
+   *  none. `as`/`=>` forms contribute their SOURCE name; the alias is read
+   *  separately so the caller can record the rename. */
+  exportSelectorName(sel) {
+    const t = sel.type;
+    if (t === "identifier" || t === "operator_identifier" || t === "type_identifier") return sel.text;
+    if (t === "generic_type") {
+      const head = sel.namedChild(0);
+      return head ? this.exportSelectorName(head) : null;
+    }
+    if (t === "as_renamed_identifier" || t === "arrow_renamed_identifier") {
+      const src = sel.namedChild(0);
+      return src ? this.exportSelectorName(src) : null;
+    }
+    if (t === "namespace_wildcard") return "*";
+    return null;
+  }
+  handleGiven(node, symbols, relationships, exports, patternsObj, parent) {
+    patternsObj["Given/Using (Scala 3)"] = true;
+    patternsObj["Contextual Abstractions"] = true;
+    const explicitName = node.childForFieldName("name")?.text ?? null;
+    if (!explicitName) this.givenCounter += 1;
+    const name = explicitName || `given_${this.givenCounter}`;
+    const symbol = this.createSymbol(name, ASTEngine.SymbolKind.Constant, node, parent, {
+      type: "given",
+      isGiven: true,
+      scala3: true,
+      anonymous: !explicitName
+    });
+    symbols.push(symbol);
+    if (explicitName && this.isPublic(node) && !parent) {
+      exports.push({ name: symbol.name, kind: ASTEngine.SymbolKind.Constant, range: symbol.range });
+    }
+    return symbol;
+  }
+  handleFunction(node, symbols, relationships, exports, patternsObj, parent) {
+    const name = this.extractIdentifier(node, "name");
+    let extensionReceiverType;
+    let extensionReceiverTypeNode = null;
+    {
+      let anc = node.parent;
+      while (anc) {
+        if (anc.type === "extension_definition") {
+          for (let i = 0; i < anc.namedChildCount; i++) {
+            const pc = anc.namedChild(i);
+            if (!pc || pc.type !== "parameters") continue;
+            if (pc.namedChildCount > 0 && pc.namedChild(0)) {
+              const p0 = pc.namedChild(0);
+              for (let j = 0; j < p0.namedChildCount; j++) {
+                const tc = p0.namedChild(j);
+                if (tc && this.isExtensionReceiverTypeNode(tc.type)) {
+                  const t = tc.text;
+                  extensionReceiverType = t.endsWith("?") ? t.slice(0, -1) : t;
+                  extensionReceiverTypeNode = tc;
+                  break;
+                }
+              }
+            }
+            break;
+          }
+          break;
+        }
+        if (anc.type === "class_definition" || anc.type === "trait_definition" || anc.type === "object_definition") break;
+        anc = anc.parent;
+      }
+    }
+    if (!name) return null;
+    if (name === "this" && parent && (parent.kind === ASTEngine.SymbolKind.Class || parent.kind === ASTEngine.SymbolKind.Module)) {
+      let ctor;
+      for (const s of symbols) {
+        if (s.ownerName === parent.name && s.kind === ASTEngine.SymbolKind.Constructor && s.name === "constructor") {
+          ctor = s;
+          break;
+        }
+      }
+      if (ctor) {
+        const existing = new Set((ctor.parameters ?? []).map((p) => `${p.name}:${p.type}`));
+        const ps = ctor.parameters ?? (ctor.parameters = []);
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const pn = node.namedChild(i);
+          if (!pn || pn.type !== "parameters") continue;
+          for (let j = 0; j < pn.namedChildCount; j++) {
+            const p = pn.namedChild(j);
+            if (!p || p.type !== "parameter") continue;
+            const pname = p.childForFieldName("name")?.text || "";
+            const ptype = p.childForFieldName("type")?.text || "";
+            const key = `${pname}:${ptype}`;
+            if (existing.has(key)) continue;
+            existing.add(key);
+            ps.push({ name: pname, type: ptype, isImplicit: false });
+          }
+        }
+      }
+      patternsObj["Auxiliary Constructors"] = true;
+      return parent;
+    }
+    const isMethod = parent && (parent.metadata?.type === "class" || parent.metadata?.type === "trait" || parent.metadata?.type === "object" || parent.kind === ASTEngine.SymbolKind.Class || parent.kind === ASTEngine.SymbolKind.Interface || parent.kind === ASTEngine.SymbolKind.Module);
+    const mods = this.collectModifiers(node);
+    const isAbstract = node.type === "function_declaration" || mods.has("abstract");
+    const isOverride = mods.has("override");
+    const isImplicit = mods.has("implicit");
+    const isInline = mods.has("inline_modifier") || mods.has("transparent_modifier");
+    const parameters = [];
+    let returnType = void 0;
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === "parameters") {
+        let hasImplicit = false;
+        for (let j = 0; j < child.childCount; j++) {
+          const paramChild = child.child(j);
+          if (paramChild && (paramChild.type === "implicit" || paramChild.type === "using")) {
+            hasImplicit = true;
+            break;
+          }
+        }
+        for (let j = 0; j < child.namedChildCount; j++) {
+          const paramNode = child.namedChild(j);
+          if (!paramNode) continue;
+          if (paramNode.type === "parameter") {
+            const paramName = paramNode.childForFieldName("name")?.text || "";
+            const paramType = paramNode.childForFieldName("type")?.text || "";
+            parameters.push({
+              name: paramName,
+              type: paramType,
+              isImplicit: hasImplicit
+            });
+            continue;
+          }
+          const isTypeNode = paramNode.type.endsWith("_type") || paramNode.type.includes("type_identifier");
+          if (isTypeNode) {
+            parameters.push({ name: "", type: String(paramNode.text), isImplicit: true });
+          }
+        }
+      }
+    }
+    const returnTypeNode = node.childForFieldName("return_type") || node.childForFieldName("type");
+    if (returnTypeNode) {
+      returnType = returnTypeNode.text;
+    }
+    const isEnumMethod = parent?.kind === ASTEngine.SymbolKind.Enum || parent?.metadata?.type === "enum";
+    const methodKind = isMethod || isEnumMethod ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Function;
+    const symbol = this.createSymbol(
+      name,
+      methodKind,
+      node,
+      parent,
+      {
+        type: "function",
+        parameters: parameters.length > 0 ? parameters : void 0,
+        returnType,
+        isAbstract,
+        isOverride,
+        isImplicit,
+        isInline,
+        // Scala 3 extension methods: the receiver lives on the enclosing
+        // extension_definition's parameters, NOT on the function node, and
+        // the wrapper never becomes a parent symbol. Detect via ancestors.
+        isExtension: !!extensionReceiverType,
+        // M60/SDJ-9: the receiver is SEMANTIC — a Scala 3 extension method is
+        // in scope only for its receiver type — and it was recorded NOWHERE.
+        // Two `isPackage` methods, one on AbstractFile and one on JFile,
+        // published byte-identical symbols: same id (`FileUtils.isPackage`),
+        // same kind, same owner, no field to tell them apart. Storing the
+        // receiver is pure information gain and is what lets the identity pass
+        // below separate them.
+        extensionReceiver: extensionReceiverType,
+        complexity: this.calculateScalaFunctionComplexity(node)
+      }
+    );
+    symbols.push(symbol);
+    const fnTypeParams = this.extractScalaTypeParameters(node);
+    if (fnTypeParams.length > 0) {
+      symbol.genericParameters = fnTypeParams;
+      symbol.metadata.typeParameters = fnTypeParams;
+    }
+    if (extensionReceiverType) {
+      relationships.push({
+        source: name,
+        target: extensionReceiverType,
+        type: ASTEngine.RelationshipType.Uses,
+        confidence: 0.9,
+        // M59 (#825): the line belongs to the NAME — the receiver TYPE node,
+        // not the method that uses it. `extension (x: Bla)` on its own line
+        // puts `Bla` there; the method body follows below.
+        line_number: (extensionReceiverTypeNode ?? node).startPosition.row + 1,
+        metadata: { relationshipType: "scala_extension_method", isExtension: true }
+      });
+    }
+    if (this.isPublic(node) && methodKind === ASTEngine.SymbolKind.Function && !parent) {
+      exports.push({
+        name: symbol.name,
+        kind: ASTEngine.SymbolKind.Function,
+        range: symbol.range
+      });
+    }
+    if (name === "apply") patternsObj["Factory Pattern (apply)"] = true;
+    if (name === "unapply" || name === "unapplySeq") patternsObj["Extractor Pattern (unapply)"] = true;
+    return symbol;
+  }
+  handleVariable(node, symbols, exports, parent) {
+    let ancestor = node.parent;
+    while (ancestor) {
+      if (ancestor.type === "function_definition" || ancestor.type === "function_declaration" || ancestor.type === "lambda_expression" || ancestor.type === "block" && ancestor.parent?.type === "function_definition") {
+        return;
+      }
+      if (ancestor.type === "class_definition" || ancestor.type === "trait_definition" || ancestor.type === "object_definition" || ancestor.type === "enum_definition" || // M49/M37 #866: `template_body` is the body of an anonymous class
+      // (`new Runnable { val field = target() }`). A val/var written
+      // directly in it is a MEMBER of that type, not a local of the method
+      // the literal happens to sit in — so the boundary check comes first,
+      // exactly like the three named type forms above. Pre-fix the scan
+      // walked past the body, reached the enclosing `def`, and dropped the
+      // member entirely (java/groovy emit `property field
+      // owner=anonymous_Runnable`). The body's PARENT must be the
+      // instance_expression, otherwise this is a named/anonymous class body
+      // handled by the branches above.
+      ancestor.type === "template_body" && ancestor.parent?.type === "instance_expression") {
+        break;
+      }
+      ancestor = ancestor.parent;
+    }
+    let patternNode = node.childForFieldName("pattern");
+    if (!patternNode) {
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && child.isNamed && child.type === "identifier") {
+          patternNode = child;
+          break;
+        }
+      }
+    }
+    if (!patternNode) return;
+    if (patternNode.type === "tuple_pattern") return;
+    if (patternNode.text === "this") return;
+    if (patternNode.type !== "identifier" && patternNode.type !== "identifiers" && patternNode.type !== "operator_identifier") return;
+    const kind = node.type === "val_definition" || node.type === "val_declaration" ? ASTEngine.SymbolKind.Constant : ASTEngine.SymbolKind.Variable;
+    const declared = [];
+    if (patternNode.type === "identifiers") {
+      for (let i = 0; i < patternNode.childCount; i++) {
+        const child = patternNode.child(i);
+        if (child && child.isNamed && child.type === "identifier") declared.push(child.text);
+      }
+    }
+    if (declared.length === 0) declared.push(patternNode.text);
+    for (const name of declared) {
+      const symbol = this.createSymbol(name, kind, node, parent, { type: node.type, isAbstract: node.type === "val_declaration" || node.type === "var_declaration" });
+      symbols.push(symbol);
+      if (this.isPublic(node) && !parent) {
+        exports.push({
+          name: symbol.name,
+          kind,
+          range: symbol.range
+        });
+      }
+    }
+  }
+  handleInstantiation(node, relationships, parent) {
+    const sourceName = parent?.name ?? "(script)";
+    const typeNode = node.namedChild(0);
+    if (!typeNode) return;
+    let typeName = this.scalaTypeHeadName(typeNode);
+    let prevTypeName;
+    do {
+      prevTypeName = typeName;
+      typeName = this.stripTypeArgs(typeName);
+    } while (typeName !== prevTypeName);
+    if (typeName && typeName !== "unknown") {
+      relationships.push({
+        source: sourceName,
+        target: typeName,
+        type: ASTEngine.RelationshipType.Instantiates,
+        confidence: 0.9,
+        line_number: typeNode.startPosition.row + 1,
+        metadata: { isInstantiation: true }
+      });
+    }
+  }
+  handleCall(node, relationships, patternsObj, parent) {
+    const fnNode = node.childForFieldName("function");
+    if (fnNode) {
+      if (fnNode.text.startsWith("'") || fnNode.text.startsWith("`")) return;
+      if (parent && fnNode.type !== "call_expression") {
+        if (!parent.qualified_calls) parent.qualified_calls = [];
+        parent.qualified_calls.push(this.buildScalaCallPath(fnNode));
+      }
+      if (fnNode.type === "call_expression") return;
+      const CALLEE_NAME_SHAPES = /* @__PURE__ */ new Set([
+        "identifier",
+        "field_expression",
+        "generic_function",
+        "operator_identifier",
+        "type_identifier",
+        "stable_type_identifier"
+      ]);
+      if (!CALLEE_NAME_SHAPES.has(fnNode.type)) return;
+      let calledName = "";
+      let isQualified = false;
+      let calleeNode = null;
+      if (fnNode.type === "generic_function") {
+        const leaves = [];
+        const findLeaves = (nn) => {
+          if (nn.type === "identifier") {
+            leaves.push(nn);
+            return;
+          }
+          if (nn.type === "type_arguments") return;
+          for (let i = 0; i < nn.namedChildCount; i++) {
+            const c = nn.namedChild(i);
+            if (c) findLeaves(c);
+          }
+        };
+        findLeaves(fnNode);
+        if (leaves.length > 0) {
+          calleeNode = leaves[leaves.length - 1];
+          calledName = calleeNode.text;
+          isQualified = leaves.length > 1;
+        }
+      } else {
+        calledName = fnNode.text;
+        calleeNode = fnNode;
+        isQualified = fnNode.type === "field_expression";
+        if (isQualified) {
+          const leaves = [];
+          for (let i = 0; i < fnNode.namedChildCount; i++) {
+            const c = fnNode.namedChild(i);
+            if (c && (c.type === "identifier" || c.type === "operator_identifier")) leaves.push(c);
+          }
+          if (leaves.length > 0) {
+            calleeNode = leaves[leaves.length - 1];
+            calledName = calleeNode.text;
+          }
+        }
+      }
+      const calleeLine = (calleeNode ?? node).startPosition.row + 1;
+      const sourceName = parent?.name ?? "(script)";
+      if (calledName === "this") return;
+      if (calledName) {
+        const first = calledName.charCodeAt(0);
+        const isCapitalized = first >= 65 && first <= 90;
+        let prevCalled;
+        do {
+          prevCalled = calledName;
+          calledName = this.stripBracketGroups(calledName).trim();
+        } while (calledName !== prevCalled);
+        if (isCapitalized && !isQualified) {
+          relationships.push({
+            source: sourceName,
+            target: calledName,
+            type: ASTEngine.RelationshipType.Instantiates,
+            // S1.4: explicit heuristic confidence — a bare PascalCase call is
+            // a companion-apply GUESS (documented 0.7 contract), never an
+            // implicit-1.0 structural edge.
+            confidence: 0.7,
+            line_number: calleeLine,
+            metadata: { isInstantiation: true }
+          });
+        } else {
+          relationships.push({
+            source: sourceName,
+            target: calledName,
+            type: ASTEngine.RelationshipType.Calls,
+            // S1.4: method calls carry the documented 0.9 confidence (docs
+            // promise 0.9 for calls; the classifier reads it explicitly).
+            confidence: 0.9,
+            line_number: calleeLine,
+            metadata: {}
+          });
+        }
+        if (["map", "filter", "flatMap", "foreach", "fold", "reduce", "collect"].includes(calledName)) {
+          patternsObj["Higher-Order Functions"] = true;
+          patternsObj["Functional Programming"] = true;
+        }
+      }
+    }
+  }
+  handleImport(node, imports) {
+    if (node.type !== "import_declaration") return;
+    const parts = [];
+    const selectors = [];
+    const groups = [];
+    let groupParts = [];
+    let moduleLine = node.startPosition.row + 1;
+    const part = (text) => stripScalaQuoting(text);
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === "identifier" || child.type === ".") {
+        if (child.type === "identifier") {
+          parts.push(part(child.text));
+          groupParts.push(part(child.text));
+          moduleLine = child.startPosition.row + 1;
+        }
+      } else if (child.type === ",") {
+        const completed = groupParts.join(".");
+        if (completed.length > 0) groups.push({ prefix: completed, names: [] });
+        groupParts = [];
+      } else if (child.type === "namespace_wildcard") {
+        selectors.push({ local: "*", imported: "*" });
+        const gprefix = groupParts.join(".");
+        if (gprefix.length > 0) groups.push({ prefix: gprefix, names: [] });
+        groupParts = [];
+      } else if (child.type === "namespace_selectors") {
+        const groupPrefix = groupParts.join(".");
+        const groupNames = [];
+        for (let j = 0; j < child.childCount; j++) {
+          const sel = child.child(j);
+          if (!sel) continue;
+          if (sel.type === "identifier") {
+            groupNames.push(part(sel.text));
+            selectors.push({ local: sel.text, imported: sel.text });
+          } else if (sel.type === "arrow_renamed_identifier") {
+            const imported = sel.namedChild(0);
+            const local = sel.namedChild(1);
+            if (imported && local) {
+              const isExclusion = local.type === "wildcard" || local.text === "_";
+              parts.push(part(imported.text));
+              moduleLine = imported.startPosition.row + 1;
+              if (!isExclusion) groupNames.push(part(imported.text));
+              selectors.push({ local: isExclusion ? "_" : local.text, imported: imported.text, excluded: isExclusion });
+            }
+          }
+        }
+        if (groupPrefix.length > 0) groups.push({ prefix: groupPrefix, names: groupNames });
+        groupParts = [];
+      } else if (child.type === "as_renamed_identifier") {
+        const original = child.namedChild(0);
+        const alias = child.namedChild(1);
+        if (original && original.type === "identifier") {
+          parts.push(part(original.text));
+          groupParts.push(part(original.text));
+          moduleLine = original.startPosition.row + 1;
+          selectors.push({ local: alias && alias.type === "identifier" ? alias.text : original.text, imported: original.text });
+          const gprefix = groupParts.join(".");
+          if (gprefix.length > 0) groups.push({ prefix: gprefix, names: [] });
+          groupParts = [];
+        }
+      }
+    }
+    const tailPrefix = groupParts.join(".");
+    if (tailPrefix.length > 0) groups.push({ prefix: tailPrefix, names: [] });
+    const pathStr = parts.join(".");
+    if (selectors.length === 0 && pathStr.length > 0) {
+      const idx = pathStr.lastIndexOf(".");
+      const last = idx >= 0 ? pathStr.substring(idx + 1) : pathStr;
+      if (last.length > 0) selectors.push({ local: last, imported: last });
+    }
+    imports.push({
+      module: pathStr,
+      // M59 (#825): the line the module's last segment is written on (see above).
+      moduleLine,
+      // S1.25 (M49 #715): family consumers read `items` (engine.ts
+      // ImportInfo.items: string[]) — scala was the ONLY family member
+      // populating the legacy `specifiers` shape, so downstream import
+      // listing silently showed nothing for scala. Both shapes are filled:
+      // items = imported names, specifiers kept for any legacy reader.
+      items: selectors.map((s) => s.imported),
+      specifiers: selectors,
+      // Read by the `imports` edge builder; see handleImport's comment on why the
+      // dependency edges and the module path are computed from different bases.
+      ...groups.length > 0 ? { metadata: { importGroups: groups } } : {},
+      range: {
+        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
+      }
+    });
+  }
+  /**
+   * M14 #419 G3/G8: the LEFTMOST identifier of a field_expression — for
+   * a.b.c that is a (recursing through nested field_expressions); package
+   * paths (com.foo.bar) yield com, so capitalized-receiver detection is
+   * safe against package-qualified members.
+   */
+  leftmostIdentifier(node) {
+    if (node.type === "identifier") return node;
+    const first = node.namedChild(0);
+    return first ? this.leftmostIdentifier(first) : null;
+  }
+  /**
+   * The DECLARED NAME of a definition, read from its `name:` FIELD.
+   *
+   * M60/S8: this replaces "first child of type identifier", which is wrong for
+   * an operator-named method. `def <&[B](that: IO[B]): IO[A]` carries its name
+   * as an `operator_identifier`, so the first `identifier` child is the TYPE
+   * PARAMETER `B` — and `resolveSource` then attributed every reference inside
+   * that method to a type parameter named `B`. Two failures in one: the edge's
+   * source is a binding rather than a declaration, and because the edge dedupe
+   * key is (source, target, kind), every operator-named method in a file
+   * collapses onto ONE bogus source, so the edge COUNT drops too.
+   *
+   * Measured on cats-effect/core/shared/src/main/scala/cats/effect/IO.scala,
+   * where the operators `<*`, `<&`, `*>`, `>>`, `!>`, `&>` are the only sources
+   * the derived truth attributes references to and the analyzer does not: 26
+   * rows on the whole cats-effect corpus, and the whole of a 60-file rotation
+   * read clean because the draw did not include this file.
+   *
+   * The lane's comparison matches on (label, target), so it cannot see a wrong
+   * SOURCE at all — which is why this survived the `uses` audit at 100% too:
+   * collectExpressionUses carries the same resolveSource.
+   */
+  scalaDeclaredNameOf(node) {
+    const f = node.childForFieldName?.("name");
+    if (f) return f.text === "this" ? null : stripScalaQuoting(f.text);
+    const i = this.findChild(node, "identifier")?.text;
+    if (i === void 0) return null;
+    return i === "this" ? null : stripScalaQuoting(i);
+  }
+  findChild(node, type) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && c.type === type) return c;
+    }
+    return null;
+  }
+  /**
+   * The declared name of a node that carries it as a bare `identifier` child —
+   * an enum case (`case Red`, `case B(val x: Int) extends E`). Its `name:` field
+   * would serve too, but the grammar's enum-case shape is the one place a
+   * first-identifier scan and the field agree, and this helper is NOT safe for a
+   * `given`: an anonymous given has no `name:` field and its BODY can be a bare
+   * identifier, so the scan returns the given's VALUE. handleGiven reads the
+   * field for that reason (M60/S6).
+   */
+  findChildIdentifier(node) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && c.isNamed && c.type === "identifier") return c.text;
+    }
+    return null;
+  }
+};
+export {
+  RealScalaAnalyzer
+};