@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-julia-analyzer-22CWYQMN.js

@@ -0,0 +1,2085 @@
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import {
+  BINDING_SEP
+} from "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-julia-analyzer.ts
+import { readFileSync } from "fs";
+import * as path from "path";
+var JULIA_PACKAGE_CACHE = /* @__PURE__ */ new Map();
+function projectTomlName(text) {
+  let inTable = false;
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    const t = line.trim();
+    if (!t || t.startsWith("#")) continue;
+    if (t.startsWith("[")) {
+      inTable = true;
+      continue;
+    }
+    if (inTable) continue;
+    const eq = t.indexOf("=");
+    if (eq < 0 || t.slice(0, eq).trim() !== "name") continue;
+    let value = t.slice(eq + 1).trim();
+    if (!value) return "";
+    const quote = value[0];
+    if (quote === '"' || quote === "'") {
+      const close = value.indexOf(quote, 1);
+      return close > 0 ? value.slice(1, close).trim() : "";
+    }
+    const hash = value.indexOf("#");
+    if (hash >= 0) value = value.slice(0, hash);
+    return value.trim();
+  }
+  return "";
+}
+function juliaPackageName(projectRoot) {
+  if (!projectRoot) return "";
+  const hit = JULIA_PACKAGE_CACHE.get(projectRoot);
+  if (hit !== void 0) return hit;
+  let name = "";
+  try {
+    name = projectTomlName(readFileSync(path.join(projectRoot, "Project.toml"), "utf8"));
+  } catch {
+  }
+  JULIA_PACKAGE_CACHE.set(projectRoot, name);
+  return name;
+}
+var TYPE_DECLARATIONS = /* @__PURE__ */ new Set(["abstract_definition", "primitive_definition", "struct_definition"]);
+var GLOBAL_SCOPE = "global";
+var IMPLICIT_OR_CONSTANT = /* @__PURE__ */ new Set([
+  "nothing",
+  "missing",
+  "undef",
+  "ARGS",
+  "ENV",
+  "C_NULL",
+  "stdout",
+  "stderr",
+  "stdin"
+]);
+var SCOPE_TRANSPARENT_MACROS = /* @__PURE__ */ new Set(["eval", "static", "sync", "async", "time"]);
+var SCOPE_INTRODUCING_NODES = /* @__PURE__ */ new Set([
+  "function_definition",
+  "macro_definition",
+  "let_statement",
+  "for_statement",
+  "while_statement",
+  "do_clause",
+  "quote_expression",
+  "quote_statement",
+  "struct_definition",
+  "abstract_definition",
+  "primitive_definition",
+  "arrow_function_expression",
+  "comprehension_expression"
+]);
+function stripSigil(text, sigil) {
+  const t = text.trim();
+  return t.startsWith(sigil) ? t.slice(sigil.length) : t;
+}
+function hasLayout(text) {
+  for (const ch of text) if (ch.trim() === "" || ch === "#") return true;
+  return false;
+}
+function macroNameOf(text) {
+  const t = stripSigil(text, "@");
+  for (let i = 0; i < t.length; i++) {
+    const c = t.charCodeAt(i);
+    if (c === 10 || c === 13 || c === 9 || c === 32) {
+      const first = t.slice(0, i);
+      return hasLayout(first) ? "" : first;
+    }
+  }
+  return hasLayout(t) ? "" : t;
+}
+function collapseSpace(text) {
+  const words = [];
+  let word = "";
+  for (const ch of text) {
+    if (ch.trim() === "") {
+      if (word) {
+        words.push(word);
+        word = "";
+      }
+    } else {
+      word += ch;
+    }
+  }
+  if (word) words.push(word);
+  return words.join(" ");
+}
+var CONDITIONAL_OR_GENERATED = /* @__PURE__ */ new Set([
+  // conditional
+  "if_statement",
+  "else_clause",
+  "elseif_clause",
+  "while_statement",
+  "for_statement",
+  "try_statement",
+  "catch_clause",
+  "finally_clause",
+  "ternary_expression",
+  "macrocall_expression",
+  // generated, not declared here
+  "quote_expression",
+  "quote_statement"
+]);
+var LOCAL_BINDING_SCOPE = /* @__PURE__ */ new Set([
+  "function_definition",
+  "macro_definition",
+  "do_clause",
+  "let_statement",
+  "arrow_function_expression"
+]);
+var RealJuliaAnalyzer = class {
+  /**
+   * Call sites under an `@ccall`, recorded when the macro is visited and consulted when the
+   * nested `call_expression` is emitted. Instance state rather than a local because the macro
+   * case and the call case are different methods, and CLEARED at the top of every `analyze()` so
+   * a reused instance cannot carry one file's C symbols into the next file's graph — which would
+   * mark an unrelated call as foreign and is precisely the kind of cross-file bleed a shared
+   * analyzer instance invites.
+   */
+  foreignMarked = /* @__PURE__ */ new Set();
+  /** Set while the walk is inside a `macro_definition`, whose body is QUOTED code. */
+  inMacroBody = false;
+  /**
+   * `call_expression` nodes that are the LEFT-HAND SIDE of a short-form declaration, i.e.
+   * `f(x) = …` rather than an invocation. Julia writes a function definition with the same node
+   * type as a call, so without this the declaration reads as the function calling itself.
+   * Cleared per `analyze()` for the same reason as `foreignMarked`.
+   */
+  declSites = /* @__PURE__ */ new Set();
+  /**
+   * `type_head` nodes belonging to a type DECLARATION, so a type is not recorded as referencing
+   * itself. Cleared per `analyze()` like the other per-file sets.
+   */
+  typeHeadSites = /* @__PURE__ */ new Set();
+  /**
+   * Declaration nodes that REPLACE an earlier declaration of the same method, keyed by node id.
+   *
+   * COLLECTED IN A PRE-PASS for the same reason `declaredTypes` is: the question "has this exact
+   * method already been defined in this file?" is only answerable once the whole file has been
+   * seen, and answering it during a single walk would classify the FIRST declaration as the
+   * override and leave the second — the one that actually replaces it — unrecorded.
+   *
+   * M60/julia `overrides`. The lane's file header declined this type on the grounds that julia has
+   * multiple dispatch rather than overriding, and the argument is sound for the case it names: two
+   * methods of the same name with DIFFERENT signatures are different methods, both live, and
+   * neither replaces the other. It does not cover the case julia actually has. Julia's method table
+   * holds exactly one entry per (name, signature) tuple, so a second declaration of the SAME pair
+   * REPLACES the first — julia itself says so, printing `WARNING: Method definition f(Int) in
+   * module Main at line 12 overwritten at line 40` under `--warn-overwrite=yes`. That is a
+   * replacement, and it is the only sense in which the language has one, which is the same
+   * criterion the bash lane's `overrides` ruling used to convict this very omission
+   * (`script/m14/ontology-coverage-gate.ts` header, BD8b).
+   *
+   * MEASURED: filled in from `validation/m14/fixtures/julia/census.ts` over the admitted corpus —
+   * see `docs/analyzers/julia.md` for the counts and the probe that produces them.
+   */
+  redefinedAt = /* @__PURE__ */ new Map();
+  /**
+   * The kind of every symbol this file declares, by name. Populated at each `symbols.push`, which is
+   * the single point every declaration in this analyzer goes through, so the table cannot fall behind
+   * the symbol list. Cleared per `analyze()` like the other per-file state.
+   *
+   * It exists for one question: does this file declare `owner` as a module or a type, and `target` as
+   * a method? See `ownsAMethodTable`.
+   */
+  declaredSymbolKinds = /* @__PURE__ */ new Map();
+  /**
+   * THE FOURTH PARAMETER IS NEW, AND ITS ABSENCE WAS A WIRING GAP OF EXACTLY THE KIND THIS PROGRAMME
+   * HAS NOW FOUND THREE TIMES: `engine.ts` passes an `AnalyzeContext` to every analyzer, python's once
+   * stopped at three parameters so the companion "never reached it at all", and this analyzer did the
+   * same — the context was available at every call site and dropped here. It is ADDITIVE: a caller that
+   * passes nothing gets the previous behaviour byte for byte, which is what the five fixtures assert.
+   */
+  analyze(rootNode, content, filePath, context) {
+    this.inMacroBody = false;
+    this.foreignMarked.clear();
+    this.declSites.clear();
+    this.typeHeadSites.clear();
+    this.redefinedAt.clear();
+    this.declaredSymbolKinds.clear();
+    const symbols = [];
+    const pushSym = (s) => {
+      if (s.ownerName && !s.qualifiedName) s.qualifiedName = `${s.ownerName}.${s.name}`;
+      else if (!s.ownerName && !fileDeclaresModule && packageName) s.qualifiedName = `${packageName}.${s.name}`;
+      symbols.push(s);
+      this.declaredSymbolKinds.set(s.name, s.kind);
+    };
+    const memberKey = (owner, name) => owner ? `${owner}.${name}` : name;
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    const frameworks = /* @__PURE__ */ new Set();
+    const declaredTypes = /* @__PURE__ */ new Set();
+    const declaredModules = /* @__PURE__ */ new Set();
+    {
+      const collect = (n) => {
+        if (TYPE_DECLARATIONS.has(n.type)) {
+          const head = this.firstNamedChildOfType(n, "type_head");
+          const name = head ? this.typeHeadName(head) : "";
+          if (name) declaredTypes.add(name);
+        }
+        if (n.type === "module_definition") {
+          const nm = n.childForFieldName("name");
+          const m = nm ? nm.text.trim() : "";
+          if (m) declaredModules.add(m);
+        }
+        for (const c of this.namedChildren(n)) collect(c);
+      };
+      collect(rootNode);
+    }
+    let fileDeclaresModule = false;
+    {
+      const scan = (n) => {
+        if (n.type === "module_definition") fileDeclaresModule = true;
+        for (const c of this.namedChildren(n)) if (!fileDeclaresModule) scan(c);
+      };
+      scan(rootNode);
+    }
+    const packageName = juliaPackageName(context?.projectRoot);
+    const bindingsByScope = /* @__PURE__ */ new Map();
+    {
+      const bindName = (b) => {
+        if (!b) return "";
+        if (b.type === "identifier") return b.text.trim();
+        if (b.type === "typed_expression" || b.type === "unary_typed_expression") {
+          const ks = this.namedChildren(b);
+          if (ks.length < 2) return "";
+          return bindName(ks[0]);
+        }
+        if (b.type === "splat_expression" || b.type === "named_argument") {
+          const inner = this.pos(b, 0);
+          return inner ? bindName(inner) : "";
+        }
+        if (b.type === "juxtaposition_expression" || b.type === "parenthesized_expression") {
+          const inner = this.pos(b, 0);
+          return inner ? bindName(inner) : "";
+        }
+        return "";
+      };
+      const add = (scope, n) => {
+        if (!scope || !n) return;
+        const set = bindingsByScope.get(scope) ?? /* @__PURE__ */ new Set();
+        set.add(n);
+        bindingsByScope.set(scope, set);
+      };
+      const addParams = (call, scope) => {
+        if (!call || !scope) return;
+        const args = this.namedChildren(call).find((c) => c.type === "argument_list");
+        if (!args) return;
+        for (const a of this.namedChildren(args)) add(scope, bindName(a));
+      };
+      const scopeOf = (n) => {
+        if (n.type === "module_definition") {
+          const nn = n.childForFieldName("name");
+          return nn ? nn.text.trim() : "";
+        }
+        if (n.type === "struct_definition" || n.type === "abstract_definition" || n.type === "primitive_definition") {
+          const head = this.firstNamedChildOfType(n, "type_head");
+          return head ? this.typeHeadName(head) : "";
+        }
+        if (n.type === "function_definition" || n.type === "macro_definition") {
+          const sig = this.firstNamedChildOfType(n, "signature");
+          return sig ? this.signatureName(sig) : "";
+        }
+        if (n.type === "assignment") {
+          const lhs = this.pos(n, 0);
+          if (!lhs) return "";
+          const u = this.unwrapWhere(lhs);
+          return u.type === "call_expression" ? this.calleeName(u) ?? "" : "";
+        }
+        return "";
+      };
+      const collect = (n, scope) => {
+        const inner = scopeOf(n) || scope;
+        if (n.type === "signature") {
+          let cur = n;
+          for (let i = 0; i < 4 && cur && cur.type !== "call_expression"; i++) {
+            cur = this.namedChildren(cur).find(
+              (c) => c.type === "call_expression" || c.type === "where_expression" || c.type === "parenthesized_expression"
+            ) ?? null;
+          }
+          addParams(cur && cur.type === "call_expression" ? cur : null, inner);
+        }
+        if (n.type === "assignment") {
+          const lhs = this.pos(n, 0);
+          if (lhs) {
+            const u = this.unwrapWhere(lhs);
+            addParams(u.type === "call_expression" ? u : null, inner);
+          }
+        }
+        for (const c of this.namedChildren(n)) collect(c, inner);
+      };
+      collect(rootNode, "");
+    }
+    {
+      const firstDecl = /* @__PURE__ */ new Map();
+      const scan = (n, scope, scopeAt, localDepth) => {
+        let childScope = scope;
+        let childScopeAt = scopeAt;
+        let childLocal = localDepth;
+        if (TYPE_DECLARATIONS.has(n.type)) {
+          const head = this.firstNamedChildOfType(n, "type_head");
+          const name = head ? this.typeHeadName(head) : "";
+          if (name) {
+            childScope = name;
+            childScopeAt = n.startPosition.row + 1;
+          }
+        } else if (n.type === "module_definition") {
+          const nameNode = n.childForFieldName("name");
+          const name = nameNode ? nameNode.text.trim() : "";
+          if (name) {
+            childScope = name;
+            childScopeAt = n.startPosition.row + 1;
+          }
+        }
+        if (LOCAL_BINDING_SCOPE.has(n.type)) childLocal = localDepth + 1;
+        const site = this.declarationSiteOf(n);
+        if (site && site.name && site.signature && localDepth === 0) {
+          const key = `${childScope}@${childScopeAt}|${site.name}|${site.signature}`;
+          const prior = firstDecl.get(key);
+          const safe = this.isUnconditionalPosition(n);
+          if (prior && prior.safe && safe) {
+            this.redefinedAt.set(n.id, { name: site.name, replacesLine: prior.line, signature: site.signature, scope: childScope });
+          }
+          if (!prior) firstDecl.set(key, { line: n.startPosition.row + 1, safe });
+        }
+        for (const c of this.namedChildren(n)) scan(c, childScope, childScopeAt, childLocal);
+      };
+      scan(rootNode, "", 0, 0);
+    }
+    let activeScope = "";
+    let containerScope = true;
+    let depth = 0;
+    const walkStack = [{ node: rootNode, activeScope: "", containerScope: true, inMacroBody: false, isExit: false }];
+    while (walkStack.length > 0) {
+      const frame = walkStack.pop();
+      const node = frame.node;
+      if (frame.isExit) {
+        depth--;
+        activeScope = frame.activeScope;
+        containerScope = frame.containerScope;
+        this.inMacroBody = frame.inMacroBody;
+        continue;
+      }
+      const scope = frame.activeScope;
+      containerScope = frame.containerScope;
+      const parentContainerScope = containerScope;
+      const parentInMacroBody = this.inMacroBody;
+      switch (node.type) {
+        // ---------------------------------------------------------------- modules
+        case "module_definition": {
+          const nameNode = node.childForFieldName("name");
+          const name = nameNode ? this.nameOf(nameNode) : "";
+          if (name) {
+            pushSym({
+              name,
+              kind: ASTEngine.SymbolKind.Module,
+              range: this.range(node),
+              complexity: this.complexity(node),
+              ownerName: scope || void 0,
+              metadata: { juliaSpecific: true, isBareModule: this.firstNamedChildType(node) === "baremodule" }
+            });
+            if (scope && containerScope) relationships.push(this.rel(scope, ASTEngine.RelationshipType.Contains, memberKey(scope, name), node, 1));
+            activeScope = name;
+            containerScope = true;
+          }
+          break;
+        }
+        // ---------------------------------------------------------------- type declarations
+        case "abstract_definition":
+        case "primitive_definition":
+        case "struct_definition": {
+          const nameNode = this.firstNamedChildOfType(node, "type_head");
+          const headInner = nameNode ? this.pos(nameNode, 0) : null;
+          if (headInner && headInner.type === "interpolation_expression") break;
+          const name = nameNode ? this.typeHeadName(nameNode) : "";
+          if (!name) break;
+          const kind = node.type === "struct_definition" ? ASTEngine.SymbolKind.Class : ASTEngine.SymbolKind.Interface;
+          pushSym({
+            name,
+            kind,
+            range: this.range(node),
+            complexity: this.complexity(node),
+            ownerName: scope || void 0,
+            metadata: { juliaSpecific: true, declarationForm: node.type, isMutable: this.hasToken(node, "mutable") }
+          });
+          declaredTypes.add(name);
+          if (scope && containerScope) relationships.push(this.rel(scope, ASTEngine.RelationshipType.Contains, memberKey(scope, name), node, 1));
+          if (nameNode) this.typeHeadSites.add(nameNode.id);
+          activeScope = name;
+          containerScope = true;
+          for (const sup of this.supertypesOf(node)) {
+            if (sup === name) continue;
+            relationships.push(this.rel(name, ASTEngine.RelationshipType.Extends, sup, node, 1, { juliaSpecific: true, isSubtype: true }));
+          }
+          for (const field of this.structFields(node)) {
+            pushSym({
+              name: field.name,
+              kind: ASTEngine.SymbolKind.Property,
+              range: this.range(field.node),
+              complexity: this.complexity(field.node),
+              ownerName: name,
+              metadata: { juliaSpecific: true, isStructField: true }
+            });
+            relationships.push(this.rel(name, ASTEngine.RelationshipType.Contains, memberKey(name, field.name), field.node, 1));
+          }
+          break;
+        }
+        // ---------------------------------------------------------------- functions
+        case "function_definition":
+        case "macro_definition": {
+          const sig = this.firstNamedChildOfType(node, "signature");
+          const name = sig ? this.signatureName(sig) : "";
+          if (!name) break;
+          if (sig) {
+            let callable = this.pos(sig, 0);
+            for (let i = 0; i < 4 && callable && callable.type !== "call_expression"; i++) {
+              callable = this.pos(callable, 0);
+            }
+            if (callable && callable.type === "call_expression") {
+              this.declSites.add(callable.id);
+              const callee = this.pos(callable, 0);
+              this.typeHeadSites.add(callee ? callee.id : callable.id);
+            }
+          }
+          const isMacro = node.type === "macro_definition";
+          const wasInMacro = this.inMacroBody;
+          if (isMacro) this.inMacroBody = true;
+          pushSym({
+            name,
+            kind: isMacro ? ASTEngine.SymbolKind.Macro : ASTEngine.SymbolKind.Function,
+            range: this.range(node),
+            complexity: this.complexity(node),
+            ownerName: scope || void 0,
+            metadata: { juliaSpecific: true, isMacro, hasBlockBody: !!this.firstNamedChildOfType(node, "compound_statement") }
+          });
+          if (scope && containerScope) relationships.push(this.rel(scope, ASTEngine.RelationshipType.Contains, memberKey(scope, name), node, 1));
+          activeScope = name;
+          containerScope = false;
+          const ovr = this.overrideEdgeFor(node, scope);
+          if (ovr) relationships.push(ovr);
+          break;
+        }
+        // ---------------------------------------------------------------- SHORT-FORM function definition
+        //
+        // `f(x) = expr` and `A.B(x) = expr` are NOT `function_definition` nodes. The grammar
+        // gives `(assignment (call_expression (identifier) (argument_list …)) (operator) rhs)`, so
+        // Julia's single most common way of writing a function has no node of its own. Handling
+        // only `function … end` found 4 functions in a sample where the file has 7, and — worse —
+        // attributed every call INSIDE a short-form body to the enclosing module, because the scope
+        // never advanced. Julia's own stdlib writes this way far more often than the long form.
+        case "assignment": {
+          let lhs = this.unwrapWhere(this.pos(node, 0) ?? node);
+          if (lhs.type === "typed_expression") {
+            const inner = this.pos(lhs, 0);
+            if (inner && inner.type === "call_expression") lhs = inner;
+          }
+          if (lhs.type === "parametrized_type_expression") {
+            const wrapper = node.parent ? node.parent.type : "";
+            if (wrapper === "const_statement" || wrapper === "global_statement" || wrapper === "local_statement") break;
+            const base = this.pos(lhs, 0);
+            const alias = base && base.type === "identifier" ? base.text.trim() : "";
+            if (!alias || IMPLICIT_OR_CONSTANT.has(alias)) break;
+            if (!containerScope) break;
+            pushSym({
+              name: alias,
+              kind: ASTEngine.SymbolKind.Class,
+              range: this.range(node),
+              complexity: this.complexity(node),
+              ownerName: scope || void 0,
+              metadata: { juliaSpecific: true, declarationForm: "parametric_alias" }
+            });
+            if (scope) relationships.push(this.rel(scope, ASTEngine.RelationshipType.Contains, memberKey(scope, alias), node, 1));
+            break;
+          }
+          if (lhs.type !== "call_expression") {
+            const wrapper = node.parent ? node.parent.type : "";
+            if (wrapper === "const_statement" || wrapper === "global_statement" || wrapper === "local_statement") break;
+            if (!containerScope) break;
+            const binding = this.plainModuleBinding(node);
+            if (!binding || IMPLICIT_OR_CONSTANT.has(binding)) break;
+            pushSym({
+              name: binding,
+              kind: ASTEngine.SymbolKind.Variable,
+              range: this.range(node),
+              complexity: this.complexity(node),
+              ownerName: scope || void 0,
+              metadata: { juliaSpecific: true, declarationForm: "module_assignment" }
+            });
+            if (scope) relationships.push(this.rel(scope, ASTEngine.RelationshipType.Contains, memberKey(scope, binding), node, 1));
+            break;
+          }
+          const name = this.calleeName(lhs);
+          if (!name || IMPLICIT_OR_CONSTANT.has(name)) break;
+          pushSym({
+            name,
+            kind: ASTEngine.SymbolKind.Function,
+            range: this.range(node),
+            complexity: this.complexity(node),
+            ownerName: scope || void 0,
+            metadata: { juliaSpecific: true, declarationForm: "short_form_assignment", hasBlockBody: false }
+          });
+          this.declSites.add(lhs.id);
+          if (scope && containerScope) relationships.push(this.rel(scope, ASTEngine.RelationshipType.Contains, memberKey(scope, name), node, 1));
+          const ovr = this.overrideEdgeFor(node, scope);
+          if (ovr) relationships.push(ovr);
+          activeScope = name;
+          containerScope = false;
+          break;
+        }
+        // ---------------------------------------------------------------- const / global / local
+        case "const_statement":
+        case "global_statement":
+        case "local_statement": {
+          const assign = this.firstNamedChildOfType(node, "assignment");
+          if (!assign) break;
+          const lhs = this.pos(assign, 0);
+          if (!lhs || lhs.type === "call_expression") break;
+          const name = this.nameOf(lhs);
+          if (!name || IMPLICIT_OR_CONSTANT.has(name)) break;
+          const isGlobal = node.type === "global_statement" || this.hasToken(node, "global");
+          const owner = isGlobal ? this.enclosingModuleName(node) : scope;
+          if (this.inMacroBody && node.type !== "const_statement") break;
+          pushSym({
+            name,
+            kind: node.type === "const_statement" ? ASTEngine.SymbolKind.Constant : ASTEngine.SymbolKind.Variable,
+            range: this.range(node),
+            complexity: this.complexity(node),
+            ownerName: owner || void 0,
+            metadata: { juliaSpecific: true, binding: node.type.replace("_statement", "") }
+          });
+          if (owner && (isGlobal || containerScope)) relationships.push(this.rel(owner, ASTEngine.RelationshipType.Contains, memberKey(owner, name), node, 1));
+          break;
+        }
+        // ---------------------------------------------------------------- imports
+        case "import_statement":
+        case "using_statement": {
+          for (const t of this.importTargets(node)) {
+            imports.push({
+              module: t.name,
+              items: t.items,
+              importType: node.type === "import_statement" ? "import" : "using",
+              lineNumber: node.startPosition.row + 1,
+              isExternal: !t.name.startsWith(".")
+            });
+            relationships.push(this.rel("root", ASTEngine.RelationshipType.References, t.name, node, 1, { juliaSpecific: true, isImport: true, importForm: node.type }));
+            relationships.push(
+              this.rel(scope || "root", ASTEngine.RelationshipType.Imports, t.name, node, 1, {
+                juliaSpecific: true,
+                importForm: node.type,
+                isExternal: !t.name.startsWith("."),
+                importRenamed: t.renamed === true
+              })
+            );
+          }
+          break;
+        }
+        case "export_statement":
+        case "public_statement": {
+          if (this.namedChildren(node)[0]?.type === "ERROR") break;
+          for (const child of this.namedChildren(node)) {
+            const name = this.exportableName(child);
+            if (!name) continue;
+            exports.push({
+              name,
+              // The kind is deliberately NOT asserted. `export X` exports a BINDING whose kind
+              // depends on what X turns out to be — a struct in one file, a function in another —
+              // and Julia allows the export to precede the declaration. The first version pushed a
+              // `SymbolKind.Function` for every `export`, which produced a SECOND `Circle` beside
+              // the real `class:Circle`, and the dedup did not merge them because its key is
+              // `kind:owner:name` and the kinds differed. So `export` records an export and marks
+              // nothing: the declaration is the declaration.
+              type: node.type === "export_statement" ? "value" : "type",
+              lineNumber: node.startPosition.row + 1,
+              metadata: { juliaSpecific: true, exportForm: node.type, declaresNothing: true }
+            });
+            for (const sym of symbols) {
+              if (sym.name !== name) continue;
+              sym.metadata = { ...sym.metadata ?? {}, isExported: true, exportForm: node.type };
+            }
+            relationships.push(
+              this.rel(scope || "root", ASTEngine.RelationshipType.Exports, name, node, 1, {
+                juliaSpecific: true,
+                exportForm: node.type,
+                declaresNothing: true
+              })
+            );
+          }
+          break;
+        }
+        // ---------------------------------------------------------------- two call shapes with no `call_expression`
+        //
+        // Both were INVISIBLE: the walk recursed into them, found nothing to declare, and returned no
+        // edge, so a real invocation in Julia's two most idiomatic forms simply did not appear in the
+        // graph. Found by classifying every node type the analyzer names against every node type the
+        // grammar produces — 53 produced types the analyzer never mentions, and these two are calls.
+        //
+        // MEASURED on the corpus: `adjoint_expression` occurs in 22 files and
+        // `broadcast_call_expression` in 74.
+        case "adjoint_expression": {
+          if (this.namedChildren(node).length === 1) {
+            relationships.push(this.rel(
+              scope || GLOBAL_SCOPE,
+              ASTEngine.RelationshipType.Calls,
+              "adjoint",
+              node,
+              1,
+              { juliaSpecific: true, isOperatorApplication: true, spelling: "postfix_prime" }
+            ));
+          }
+          break;
+        }
+        case "broadcast_call_expression": {
+          const callee = this.calleeName(node);
+          if (callee && !IMPLICIT_OR_CONSTANT.has(callee)) {
+            relationships.push(this.rel(
+              scope || GLOBAL_SCOPE,
+              ASTEngine.RelationshipType.Calls,
+              callee,
+              node,
+              1,
+              { juliaSpecific: true, isBroadcastCall: true }
+            ));
+          }
+          break;
+        }
+        // ---------------------------------------------------------------- calls and construction
+        case "call_expression": {
+          if (this.declSites.has(node.id)) break;
+          const callee = this.calleeName(node);
+          if (!callee || IMPLICIT_OR_CONSTANT.has(callee)) break;
+          if (callee === "include") {
+            const part = this.includePart(node);
+            if (part) {
+              relationships.push(this.rel(scope || GLOBAL_SCOPE, ASTEngine.RelationshipType.PartOf, part.target, node, 1, {
+                partRole: "library",
+                partPath: part.path,
+                partSymbol: part.target,
+                isJuliaInclude: true
+              }));
+              break;
+            }
+            relationships.push(this.rel(scope || GLOBAL_SCOPE, ASTEngine.RelationshipType.Calls, callee, node, 1, {
+              juliaSpecific: true,
+              isInclude: true,
+              isDynamicInclude: true
+            }));
+            break;
+          }
+          const dot = callee.indexOf(".");
+          const qualifier = dot > 0 ? callee.slice(0, dot) : "";
+          const ctorLeaf = dot > 0 ? callee.slice(callee.lastIndexOf(".") + 1) : callee;
+          const sameFileCtor = dot > 0 && declaredModules.has(qualifier) && declaredTypes.has(ctorLeaf);
+          const isCtor = declaredTypes.has(callee) || sameFileCtor || TYPE_DECLARATIONS.has(callee);
+          const foreign = callee === "ccall" ? this.ccallTarget(node) : null;
+          const meta = isCtor ? { juliaSpecific: true, isTypeConstruction: true } : foreign ? { juliaSpecific: true, isForeignCall: true, foreignSymbol: foreign.symbol, foreignLibrary: foreign.library, via: "ccall" } : this.foreignMarked.has(this.textKey(node, callee)) ? { juliaSpecific: true, isForeignCall: true, via: "@ccall" } : { juliaSpecific: true };
+          {
+            relationships.push(this.rel(
+              scope || GLOBAL_SCOPE,
+              isCtor ? ASTEngine.RelationshipType.Instantiates : ASTEngine.RelationshipType.Calls,
+              sameFileCtor ? ctorLeaf : callee,
+              node,
+              isCtor ? 0.9 : 1,
+              meta
+            ));
+          }
+          if (foreign) {
+            relationships.push(this.rel(
+              scope || GLOBAL_SCOPE,
+              ASTEngine.RelationshipType.Calls,
+              foreign.symbol,
+              node,
+              1,
+              {
+                juliaSpecific: true,
+                isForeignCall: true,
+                foreignSymbol: foreign.symbol,
+                foreignLibrary: foreign.library,
+                via: "ccall"
+              }
+            ));
+          }
+          break;
+        }
+        // ---------------------------------------------------------------- macro calls
+        case "macrocall_expression": {
+          const nameNode = this.firstNamedChildOfType(node, "macro_identifier");
+          const name = nameNode ? macroNameOf(nameNode.text) : "";
+          if (name === "ccall") this.markForeignCallees(node);
+          if (!name) break;
+          const decorated = this.decoratedDeclarations(node);
+          if (decorated.length > 0) {
+            for (const d of decorated) {
+              relationships.push(this.rel(d.name, ASTEngine.RelationshipType.Decorates, name, node, 1, {
+                decoratorName: name,
+                decoratedKind: d.kind,
+                isMacroDecorator: true
+              }));
+            }
+            break;
+          }
+          relationships.push(this.rel(scope || GLOBAL_SCOPE, ASTEngine.RelationshipType.Calls, name, node, 1, { juliaSpecific: true, isMacroCall: true }));
+          break;
+        }
+        // ---------------------------------------------------------------- type annotations
+        case "unary_typed_expression":
+        case "typed_expression": {
+          const typedKids = this.namedChildren(node);
+          const anonymous = node.type === "unary_typed_expression" || node.text.trimStart().startsWith("::");
+          const typeNode = anonymous ? typedKids[0] : typedKids.length >= 2 ? typedKids[1] : typedKids[0];
+          const typeName = typeNode ? this.typeRefName(typeNode) : "";
+          if (typeName) relationships.push(this.rel(scope || GLOBAL_SCOPE, ASTEngine.RelationshipType.References, typeName, node, 1, { juliaSpecific: true, isTypeReference: true }));
+          break;
+        }
+        case "parametrized_type_expression": {
+          for (const inner of this.namedChildren(node)) {
+            if (inner.type !== "curly_expression") continue;
+            for (const b of this.namedChildren(inner)) {
+              for (const link of this.subtypeChainLinks(b)) {
+                relationships.push(this.rel(
+                  link.from,
+                  ASTEngine.RelationshipType.Extends,
+                  link.to,
+                  link.at,
+                  1,
+                  { juliaSpecific: true, isSubtype: true, isWhereBound: true }
+                ));
+              }
+            }
+          }
+          if (this.withinTypeHead(node)) break;
+          const baseNode = this.pos(node, 0);
+          const base = baseNode ? this.fieldPath(baseNode) : "";
+          if (base) relationships.push(this.rel(scope || GLOBAL_SCOPE, ASTEngine.RelationshipType.References, base, node, 1, { juliaSpecific: true, isTypeReference: true }));
+          break;
+        }
+        case "where_expression": {
+          const whereKids = this.namedChildren(node);
+          const lastWhereKid = whereKids[whereKids.length - 1];
+          for (const child of whereKids) {
+            if (child.type === "curly_expression") {
+              for (const inner of this.namedChildren(child)) {
+                for (const link of this.subtypeChainLinks(inner)) {
+                  relationships.push(this.rel(link.from, ASTEngine.RelationshipType.Extends, link.to, link.at, 1, { juliaSpecific: true, isSubtype: true, isWhereBound: true }));
+                }
+              }
+              continue;
+            }
+            if (child.type !== "binary_expression") continue;
+            if (child !== lastWhereKid && node.parent?.type !== "curly_expression") continue;
+            for (const link of this.subtypeChainLinks(child)) {
+              relationships.push(this.rel(link.from, ASTEngine.RelationshipType.Extends, link.to, link.at, 1, { juliaSpecific: true, isSubtype: true, isWhereBound: true }));
+            }
+          }
+          break;
+        }
+        // ---------------------------------------------------------------- field access
+        case "field_expression": {
+          if (node.parent?.type === "field_expression") break;
+          const value = node.childForFieldName("value");
+          if (!value) break;
+          if (value.type === "field_expression") {
+            const path2 = this.fieldPath(node);
+            if (path2) {
+              relationships.push(this.rel(
+                scope || GLOBAL_SCOPE,
+                ASTEngine.RelationshipType.References,
+                path2,
+                node,
+                0.95,
+                { juliaSpecific: true, isQualifiedReference: true }
+              ));
+            }
+            break;
+          }
+          const member = this.namedChildren(node).find((c) => c.type === "identifier" && c.id !== value.id) ?? this.namedChildren(node).find((c) => c.type === "identifier" && c.id !== value.id) ?? this.namedChildren(node).find((c) => c.id !== value.id && (c.type === "quote_expression" || c.type === "operator"));
+          if (!member) break;
+          const memberName = member.type === "quote_expression" ? this.quotedName(member) : member.text.trim();
+          if (!memberName) break;
+          relationships.push(this.rel(
+            scope || GLOBAL_SCOPE,
+            ASTEngine.RelationshipType.Uses,
+            memberName,
+            node,
+            0.9,
+            { juliaSpecific: true, isFieldRead: true, isOperatorMember: member.type !== "identifier" }
+          ));
+          break;
+        }
+      }
+      walkStack.push({ node, activeScope: scope, containerScope: parentContainerScope, inMacroBody: parentInMacroBody, isExit: true });
+      const childScope = activeScope;
+      let opaqueArgs = null;
+      const opaqueArgsOf = (parent) => {
+        const set = /* @__PURE__ */ new Set();
+        for (const c of this.namedChildren(parent)) {
+          if (c.type === "macro_identifier" || c.type === "macro_argument_list") continue;
+          if (!this.directDeclarationArg(c)) set.add(c.id);
+        }
+        return set;
+      };
+      if (node.type === "macrocall_expression" && !this.macroIsScopeTransparent(node)) {
+        opaqueArgs = opaqueArgsOf(node);
+      }
+      if (node.type === "macro_argument_list" && node.parent && node.parent.type === "macrocall_expression" && !this.macroIsScopeTransparent(node.parent)) {
+        opaqueArgs = opaqueArgsOf(node);
+      }
+      depth++;
+      const fieldTypeChild = node.type === "typed_expression" && node.parent && node.parent.type === "struct_definition" ? this.pos(node, 1) : null;
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const c = node.namedChild(i);
+        if (!c) continue;
+        const typePositionChild = (node.type === "struct_definition" || node.type === "abstract_definition" || node.type === "primitive_definition") && c.type === "type_head" || (fieldTypeChild ? c.id === fieldTypeChild.id : false);
+        walkStack.push({ node: c, activeScope: childScope, containerScope: typePositionChild || opaqueArgs?.has(c.id) ? false : containerScope, inMacroBody: this.inMacroBody, isExit: false });
+      }
+    }
+    const symbolMap = /* @__PURE__ */ new Map();
+    for (const s of symbols) symbolMap.set(`${s.kind}:${s.ownerName || ""}:${s.name}`, s);
+    const uniqueSymbols = [...symbolMap.values()];
+    const declsByName = /* @__PURE__ */ new Map();
+    for (const s of uniqueSymbols) {
+      const list = declsByName.get(s.name) ?? [];
+      list.push(s);
+      declsByName.set(s.name, list);
+    }
+    if (bindingsByScope.size > 0) {
+      for (const r of relationships) {
+        if (r.type !== ASTEngine.RelationshipType.Calls && r.type !== ASTEngine.RelationshipType.References) continue;
+        const tgt = String(r.target ?? "");
+        if (!tgt || tgt.includes(".") || tgt.includes(BINDING_SEP)) continue;
+        if (!bindingsByScope.get(String(r.source ?? ""))?.has(tgt)) continue;
+        r.target = `${r.source}${BINDING_SEP}${tgt}`;
+        r.metadata = { ...r.metadata ?? {}, localBinding: true };
+      }
+    }
+    for (const r of relationships) {
+      if (r.type !== ASTEngine.RelationshipType.References) continue;
+      const tgt = String(r.target ?? "");
+      if (!tgt || tgt.includes(".")) continue;
+      const decls = declsByName.get(tgt);
+      if (!decls || decls.length !== 1) continue;
+      const q = decls[0].qualifiedName;
+      if (typeof q === "string" && q) r.target = q;
+    }
+    const relMap = /* @__PURE__ */ new Map();
+    for (const r of relationships) {
+      const key = `${r.type}|${r.source}->${r.target}`;
+      const prev = relMap.get(key);
+      if (prev) {
+        if (prev.line_number === void 0 && r.line_number !== void 0) prev.line_number = r.line_number;
+      } else relMap.set(key, r);
+    }
+    const uniqueRelationships = [...relMap.values()];
+    this.classifyEvidenceTier(uniqueRelationships);
+    const includeOwners = new Set(
+      uniqueSymbols.filter((s) => s.name === "include" && s.kind !== ASTEngine.SymbolKind.Module).map((s) => s.ownerName ?? "")
+    );
+    if (includeOwners.size > 0) {
+      for (const r of uniqueRelationships) {
+        const md = r.metadata;
+        if (!md || md.isJuliaInclude !== true) continue;
+        const src = String(r.source ?? "");
+        const shadowed = [...includeOwners].some((owner) => owner === "" || src === owner || src.startsWith(owner + "."));
+        if (!shadowed) continue;
+        r.type = ASTEngine.RelationshipType.Calls;
+        r.target = "include";
+        r.metadata = { juliaSpecific: true, isInclude: true, isShadowedInclude: true };
+      }
+    }
+    const declaredNames = new Set(uniqueSymbols.map((s) => s.name));
+    for (const r of uniqueRelationships) {
+      if (r.type !== ASTEngine.RelationshipType.Imports) continue;
+      const md = r.metadata;
+      if (!md || md.isExternal !== true) continue;
+      const tgt = String(r.target ?? "");
+      const dot = tgt.indexOf(".");
+      const dotted = dot > 0;
+      const root = dotted ? tgt.slice(0, dot) : tgt;
+      if (dotted || declaredNames.has(root)) md.isExternal = false;
+    }
+    return {
+      language: "julia",
+      symbols: uniqueSymbols,
+      relationships: uniqueRelationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        complexity: uniqueSymbols.length,
+        linesOfCode: content.split("\n").length,
+        declaredTypes: [...declaredTypes]
+      }
+    };
+  }
+  // ------------------------------------------------------------------ helpers
+  /**
+   * The declaration this node carries, as the pair julia's method table keys on: a NAME and a
+   * SIGNATURE. Returns null for a node that declares no method.
+   *
+   * The signature is the WHOLE argument list, normalised for whitespace, plus the `where` clause
+   * when the declaration has one — because `f(x) where {T} = …` and `f(x) where {S} = …` are two
+   * DIFFERENT methods and `f(x) = …` and `f(x, y) = …` are two different methods, while
+   * `f(x) = 1` and `f( x ) = 2` are the same one. Keying on the name alone would conflate every
+   * method of a generic function, and a generic function's methods are precisely the ones the
+   * `overrides` argument in this file's header says are NOT overrides.
+   *
+   * Both declaration FORMS are read, because julia has two and the corpus uses both heavily: the
+   * long `function f(x) … end` (whose `signature` holds the call) and the short `f(x) = …` (whose
+   * assignment's left-hand side is the call, possibly behind a `where`, a return-type annotation
+   * and parentheses — the same wrappers `unwrapWhere` already knows about).
+   */
+  declarationSiteOf(node) {
+    if (node.type === "function_definition" || node.type === "macro_definition") {
+      const sig = this.firstNamedChildOfType(node, "signature");
+      if (!sig) return null;
+      const name2 = this.signatureName(sig);
+      return name2 ? { name: name2, signature: this.methodSignatureKey(sig) } : null;
+    }
+    if (node.type !== "assignment") return null;
+    const rawLhs = this.pos(node, 0) ?? node;
+    let lhs = this.unwrapWhere(rawLhs);
+    if (lhs.type === "typed_expression") {
+      const inner = this.pos(lhs, 0);
+      if (inner && inner.type === "call_expression") lhs = inner;
+    }
+    if (lhs.type !== "call_expression") return null;
+    const name = this.calleeName(lhs);
+    if (!name || IMPLICIT_OR_CONSTANT.has(name)) return null;
+    return { name, signature: this.methodSignatureKey(rawLhs, lhs) };
+  }
+  /**
+   * The `(name, signature)` half that distinguishes two methods of the same generic function.
+   *
+   * `root` is the node the declaration's text hangs off — a `signature` for the long form, the
+   * assignment's un-unwrapped left-hand side for the short one — and `call` is the callable inside
+   * it. Both are needed because they are not the same node: `where` wraps the call in one and the
+   * other has no `where` at all, so a single argument could only ever capture one of the two shapes.
+   */
+  methodSignatureKey(root, call) {
+    const callNode = call ?? (root.type === "call_expression" ? root : this.namedChildren(root).find((c) => c.type === "call_expression"));
+    if (!callNode) return "";
+    const args = this.firstNamedChildOfType(callNode, "argument_list");
+    const whereNode = root.type === "where_expression" ? root : this.namedChildren(root).find((c) => c.type === "where_expression");
+    if (!args && !whereNode) return "";
+    return `${args ? collapseSpace(args.text) : ""}${whereNode ? `|where ${collapseSpace(whereNode.text)}` : ""}`;
+  }
+  /**
+   * Is this declaration reached unconditionally, with text julia itself wrote?
+   *
+   * Walks ANCESTORS rather than the parent, because the conditional node is not always adjacent:
+   * a declaration inside `else` sits under `else_clause` and `if_statement`, and a declaration
+   * inside `catch` sits under `catch_clause` and `try_statement`, so a parent-only test reads
+   * `try_statement` as unconditional. The whole list is what the test is — adding a construct to
+   * it makes the edge class narrower, which is the direction that errs toward refusing rather than
+   * toward asserting.
+   *
+   * `macrocall_expression` and the quote forms are in the set because their content is not julia text
+   * in this file: `@eval f(x) = …` and `quote f(x) = … end` are code GENERATED at expansion, and the
+   * tree shows the generated text, not what the file declares.
+   *
+   * `&&` and `||` are not in the set — they are `binary_expression` nodes, which are the most common
+   * node in julia and cannot be listed wholesale — so the short-circuit case is tested by OPERATOR.
+   * In `cond && function f() … end` the right operand runs only when `cond` holds, and a declaration
+   * there is as conditional as one inside an `if`. Only the RIGHT operand is conditional; the left
+   * one always runs, which is why the test looks at the second OPERAND rather than both.
+   *
+   * `&&` is the live operator and `||` is not: measured over the 971 admitted corpus files there are
+   * 11,549 `&&` binary_expressions and 5,145 `||` ones, and of the `&&` set exactly ONE has a
+   * declaration node as its right operand — `julia/JuliaSyntax/src/core/parse_stream.jl:316`,
+   *
+   *     VERSION < v"1.11.0-DEV.753" && function ParseStream(io::IOBuffer; version=VERSION)
+   *
+   * which is a version-guarded method definition and is exactly the shape that must not publish an
+   * edge. One is not zero, so this is a predicate the grammar can reach rather than a safety net
+   * that never fires; `||` is left out because no `||` in the corpus has one, and a branch that
+   * cannot match is what honesty contract §2's L2 audit exists to report.
+   *
+   * THE OPERAND INDEX IS NOT 1. The operator is a NAMED child of `binary_expression` in this
+   * grammar, so the operand list is `[left, operator, right]` over named children and the right
+   * operand sits at index 2. The first version read index 1, compared it to the declaration's own
+   * node id, never matched, and published `overrides` for the one guarded definition in the corpus
+   * — found by running the fixture rather than by reading the code, which is the only way a
+   * predicate that is wrong in the direction of asserting anything gets caught.
+   */
+  isUnconditionalPosition(node) {
+    let cur = node;
+    for (let i = 0; i < 24 && cur; i++) {
+      if (CONDITIONAL_OR_GENERATED.has(cur.type)) return false;
+      if (cur.type === "binary_expression" && this.shortCircuitOperator(cur) === "&&") {
+        const named = this.namedChildren(cur).filter((c) => c.type !== "operator");
+        const right = named.length > 1 ? named[named.length - 1] : null;
+        if (right && right.id === node.id) return false;
+      }
+      cur = cur.parent ?? null;
+    }
+    return true;
+  }
+  /** The operator token of a `binary_expression`, or "" — in this grammar the operator is a NAMED
+   *  child of type `operator`, the same shape `binOp` reads in the census instrument. */
+  shortCircuitOperator(node) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && c.type === "operator") return c.text.trim();
+    }
+    return "";
+  }
+  /**
+   * The `overrides` edge for a declaration that replaces an earlier one.
+   *
+   * ## The edge shape, and why it is not `name -> name`
+   *
+   * A Julia method-table replacement has both of its endpoints at the SAME symbol: the earlier
+   * declaration and the later one are both named `f` with the same signature, so the second
+   * definition replaces the first IN PLACE — it acquires no supertype, no owner and no new name. A
+   * self-loop `f -overrides-> f` is therefore the most literally accurate shape available, and it is
+   * exactly the shape this codebase already ruled out three times:
+   *
+   *   - `src/ast/real-php-analyzer.ts:2496` — "UNRESOLVABLE and emit NO edge (a self-loop is always
+   *     fabrication, and a …)"
+   *   - `src/lsp/rich_hover.ts:222` — "Degenerate self-loop rows … are not connections and not
+   *     usages: skip them."
+   *   - `src/intelligence/patterns/orphans.ts:818` — a self-loop `overrides` row is listed under
+   *     "REFUSED EVIDENCE", and the rake `listen` regression is the case it cites: a self-loop row
+   *     was the only thing standing between a real method and a dead-code report.
+   *
+   * A corpus full of rows every consumer discards is not coverage; it is volume that makes the
+   * signal harder to see. So the SOURCE is the enclosing DECLARED scope — a `module` or a type, a
+   * symbol this file really declares — and the TARGET is the method whose entry is replaced.
+   * `module M … f(x) = 1; f(x) = 2 … end` gives `M -overrides-> f` with both ends binding to real
+   * symbols in the same file, which is the same shape the bash lane settled on for the same
+   * construct (`real-bash-analyzer.ts:322-348`, BD8b) and the shape
+   * `src/ast/override-retarget.ts` is written to consume.
+   *
+   * ## Why the module-less case is REFUSED rather than published as `global`
+   *
+   * 71.9% of Julia corpus files declare no module at all — measured, see this file's `GLOBAL_SCOPE`
+   * note — so the refused case is the MAJORITY one and it is worth being explicit that it is a
+   * refusal rather than an oversight. Publishing `global -overrides-> f` would give the edge a
+   * source that resolves to nothing, which is the same dangling identity this file's `contains` case
+   * declines to invent, and `global -calls-> f` is already the largest unresolvable-source bucket in
+   * the census. The edge is dropped instead, and the drop is counted by the census rather than left
+   * invisible.
+   *
+   * Confidence 1.0: this is a byte comparison of two declaration signatures in one file, which is a
+   * parse fact and not a guess. `evidenceClass` is `structural` for the same reason (see
+   * `classifyEvidenceTier`), so the edge is never counted as a heuristic.
+   */
+  overrideEdgeFor(node, scope) {
+    const hit = this.redefinedAt.get(node.id);
+    if (!hit) return null;
+    if (!scope || scope === hit.name) return null;
+    if (!this.ownsAMethodTable(scope, hit.name)) return null;
+    return this.rel(scope, ASTEngine.RelationshipType.Overrides, hit.name, node, 1, {
+      juliaSpecific: true,
+      isMethodRedefinition: true,
+      redefinition: true,
+      via: "identical_signature_redefinition",
+      replacesLine: hit.replacesLine,
+      signature: hit.signature.slice(0, 120),
+      declaredIn: scope
+    });
+  }
+  /**
+   * Does this file declare `owner` as a module or a type — the two things whose bodies hold a method
+   * table?
+   *
+   * Answered from the symbol table rather than from the walk's `activeScope`, because `activeScope`
+   * names FUNCTIONS too and a function is not a method-table owner. The symbol kinds are the
+   * analyzer's own: `SymbolKind.Module` for a `module`/`baremodule`, `SymbolKind.Interface` for an
+   * `abstract type`/`primitive type` and `SymbolKind.Class` for a `struct`. Cost is a scan of the
+   * file's own symbols, once per admitted override edge, over a list that is already in memory.
+   */
+  ownsAMethodTable(owner, target) {
+    const syms = this.declaredSymbolKinds;
+    if (!syms) return false;
+    const kind = syms.get(owner);
+    if (kind !== ASTEngine.SymbolKind.Module && kind !== ASTEngine.SymbolKind.Interface && kind !== ASTEngine.SymbolKind.Class) return false;
+    const t = syms.get(target);
+    return t === ASTEngine.SymbolKind.Function || t === ASTEngine.SymbolKind.Macro;
+  }
+  /**
+   * The one place a relationship is constructed.
+   *
+   * `type` is `ASTEngine.RelationshipType` and NOT `RelationshipType | string`, and that narrowing is
+   * the point of this entry rather than a typing preference. The lane used to pass serialized string
+   * literals ("contains", "extends"), which type-checked because the parameter accepted `string` — and
+   * which `script/m14/verify-doc-truth-emissions.ts` cannot see: its header declares the limit
+   * outright, "A serialized kind emitted by assigning a STRING literal would be invisible to this
+   * gate", and it derives a lane's emitted surface from `RelationshipType.X` references in code. So
+   * every relationship this analyzer published was outside the one gate whose whole job is to catch a
+   * doc claiming a channel the analyzer does not fill. Naming the enum member makes the surface
+   * readable by that gate and makes a typo in a type label a compile error rather than a row nothing
+   * groups.
+   *
+   * The serialized values are identical to the literals that were here (`RelationshipType.Contains`
+   * is `"contains"`, `RelationshipType.Imports` is `"brain_import"`), so this changes the label's
+   * provenance and nothing about the bytes stored.
+   */
+  rel(source, type, target, node, confidence, metadata) {
+    return {
+      source,
+      target,
+      type,
+      confidence,
+      line_number: node.startPosition.row + 1,
+      metadata: { juliaSpecific: true, ...metadata ?? {} }
+    };
+  }
+  /**
+   * Is this macro ARGUMENT itself a declaration — the form a decorator applies to?
+   *
+   * The same shapes `decoratedDeclarations` admits, asked from the other side: a long-form
+   * definition, or a short-form `f(x) = …` assignment whose left-hand side unwraps to a call. Used
+   * to keep `@kwdef struct S` a module member while everything inside `@testset begin … end` is not.
+   */
+  /** Is this macro one whose arguments are evaluated in the scope they are written in? */
+  macroIsScopeTransparent(macrocall) {
+    const m = this.firstNamedChildOfType(macrocall, "macro_identifier");
+    return SCOPE_TRANSPARENT_MACROS.has(m ? macroNameOf(m.text) : "");
+  }
+  directDeclarationArg(arg) {
+    if (arg.type === "function_definition" || arg.type === "macro_definition" || arg.type === "struct_definition" || arg.type === "abstract_definition" || arg.type === "primitive_definition" || arg.type === "module_definition") return true;
+    if (arg.type !== "assignment") return false;
+    const lhs = this.pos(arg, 0);
+    const u = lhs ? this.unwrapWhere(lhs) : null;
+    return !!u && u.type === "call_expression";
+  }
+  /**
+   * The declarations a macro is APPLIED TO, read from its own `macro_argument_list`.
+   *
+   * `@doc "…" function g` puts the declaration after a string; `@kwdef mutable struct S` puts it
+   * first; `@inline h(x) = x` is the short form, whose declaration is the ASSIGNMENT's left-hand
+   * call. The scan is over the argument list, not the first child, because a macro that decorates a
+   * declaration can also carry a docstring or a configuration expression before it. A macro with no
+   * declaration argument returns [] and stays a `calls` edge — `@time f()` runs a call, it does not
+   * decorate a declaration.
+   */
+  decoratedDeclarations(call) {
+    const args = this.namedChildren(call).find((c) => c.type === "macro_argument_list");
+    if (!args) return [];
+    if (this.namedChildren(args).length > 4) return [];
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    const add = (name, kind) => {
+      const n = name.trim();
+      if (!n || seen.has(n)) return;
+      seen.add(n);
+      out.push({ name: n, kind });
+    };
+    for (const arg of this.namedChildren(args)) {
+      if (arg.type === "function_definition" || arg.type === "macro_definition") {
+        const sig = this.firstNamedChildOfType(arg, "signature");
+        add(sig ? this.signatureName(sig) : "", arg.type);
+      } else if (arg.type === "struct_definition" || arg.type === "abstract_definition" || arg.type === "primitive_definition") {
+        const head = this.firstNamedChildOfType(arg, "type_head");
+        add(head ? this.typeHeadName(head) : "", arg.type);
+      } else if (arg.type === "module_definition") {
+        const nameNode = arg.childForFieldName("name");
+        add(nameNode ? nameNode.text : "", arg.type);
+      } else if (arg.type === "assignment") {
+        const lhs = this.pos(arg, 0);
+        const u = lhs ? this.unwrapWhere(lhs) : null;
+        if (u && u.type === "call_expression") add(this.calleeName(u) ?? "", "short_function");
+      }
+    }
+    return out;
+  }
+  /**
+   * The PART an `include("path")` names, or null when the argument is not one literal string.
+   *
+   * THE TARGET IS THE BASENAME WITH ITS EXTENSION (`b.jl`), the spelling bash's BD2 module symbol
+   * uses, and the path as written is kept in `metadata.partPath`. A path is not a symbol name; the
+   * arbiter resolves target STRINGS against symbols, so the basename is the only spelling a file's
+   * own module symbol could carry. The written path is evidence, never a silent replacement.
+   *
+   * REJECTED, each because it does not name a part: a string with an interpolation or an escape
+   * sequence (the bytes are not the path), a path ending at a separator (no basename), `.`/`..`, and
+   * every non-`string_literal` argument (`joinpath(...)`, a variable, a `raw"…"`). A rejected
+   * literal is a DYNAMIC include and stays a call with `isDynamicInclude` — a different, true fact.
+   */
+  includePart(call) {
+    const args = this.namedChildren(call).find((c) => c.type === "argument_list");
+    if (!args) return null;
+    const first = this.namedChildren(args)[0];
+    if (!first || first.type !== "string_literal") return null;
+    if (this.namedChildren(first).some((c) => c.type === "string_interpolation" || c.type === "escape_sequence")) return null;
+    const text = first.text;
+    let body = "";
+    if (text.startsWith('"""') && text.endsWith('"""') && text.length >= 6) body = text.slice(3, -3);
+    else if (text.startsWith('"') && text.endsWith('"') && text.length >= 2) body = text.slice(1, -1);
+    else return null;
+    if (!body || body.endsWith("/") || body.endsWith("\\")) return null;
+    const cut = Math.max(body.lastIndexOf("/"), body.lastIndexOf("\\"));
+    const target = body.slice(cut + 1);
+    if (!target || target === "." || target === "..") return null;
+    return { path: body, target };
+  }
+  range(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+  /**
+   * This grammar is almost entirely POSITIONAL.
+   *
+   * Measured from the vendored `src/node-types.json`: **7 of 151 named node types carry field
+   * names** — `module_definition.name`, `field_expression.value`, `if_statement.condition` /
+   * `.alternative`, `elseif_clause.condition`, `while_statement.condition`, and the two prefixed
+   * string/command literals. Every other node, including `binary_expression`, `typed_expression`,
+   * `signature`, `call_expression` and `type_head`, must be navigated by child ORDER.
+   *
+   * The first version of this analyzer reached for `childForFieldName("right")` and
+   * `childForFieldName("name")` throughout, which returns null for a node that has no such
+   * field. It did not throw and it did not crash — it silently emitted **zero `extends` edges**
+   * and **zero struct fields** for a corpus that has thousands of both, and the symptom was a
+   * plausible-looking symbol list. That is the F1 node-type-literal class of defect the C lane's
+   * pin record warns about ("written from memory of a different tree-sitter release, which F1
+   * caught only because the vocabulary happened to be checked"), and the reason `pos()` exists
+   * here rather than another `childForFieldName`.
+   */
+  pos(node, index) {
+    const c = node.namedChild(index);
+    return c ?? null;
+  }
+  /**
+   * The two operands of a `binary_expression`.
+   *
+   * `binary_expression` here is `(left) (operator) (right)` where the OPERATOR IS A NAMED CHILD —
+   * measured, not assumed: `isNamed=true`, `type="operator"`, sitting at index 1. So the naive
+   * "left is child 0, right is child 1" is wrong twice over: index 1 is the operator, not the
+   * right operand, and an operand can itself be an operator token. Right is therefore the LAST
+   * named child, and left the first, which holds for every binary shape in the grammar
+   * (`a + b`, `a::T`, `a <: B`, `a where {B}`).
+   *
+   * Both halves of this were wrong in the first version — `tokenText` scanned only ANONYMOUS
+   * children for the operator, so it never found it, and `pos(node,1)` handed back the operator
+   * where the right operand belonged. The visible effect was **zero `extends` edges** over a
+   * corpus where `<:` is everywhere, on a file that parsed with zero ERROR nodes.
+   */
+  binOperands(node) {
+    const named = this.namedChildren(node).filter((c) => c.type !== "operator");
+    return {
+      op: this.tokenText(node, "operator"),
+      left: named[0] ?? null,
+      right: named.length > 1 ? named[named.length - 1] : null
+    };
+  }
+  /**
+   * A `<:` / `>:` CHAIN states one subtype fact per ADJACENT PAIR, and both ends must be NAMES.
+   *
+   * `A where LB <: X <: UB` parses as `(binary (binary LB <: X) <: UB)`. The previous code read
+   * `left.text` for the source, so it published an `extends` edge whose SOURCE was `LB <: X` — a
+   * source fragment is not a symbol, and the edge can resolve to nothing. MEASURED on the whole
+   * 1,985-file population by `direct-oracle-check.ts`: 25 of the 25 unexplained `extends` rows carry
+   * either a fragment source (`LB <: X`, `X <: f()`, `S <: V`) or a doubled target (`UB.UB`), and
+   * every one of the first ten is in `julia/JuliaLowering/test/typedefs_ir.jl` — a file of deliberate
+   * lowering-error probes whose `where` chains the grammar recovers around. The same defect occurs
+   * in a WELL-FORMED chain, which is the reason it is fixed rather than filed as an ERROR-shape
+   * artefact: a fragment source is a lie the graph tells on any file that writes the chain.
+   *
+   * The rule, stated rather than inferred: flatten the chain left to right, emit `a -> b` and
+   * `b -> c`, take each source with `typeHeadName` (never `.text`), and take each target through
+   * `boundTypeName`, which REFUSES a call/literal bound — `X <: f() <: Z` is a lowering error, and
+   * naming `f` as a type would invent a relation the source says is invalid.
+   */
+  subtypeChainLinks(node) {
+    const out = [];
+    const link = (left, right, at) => {
+      const from = left ? this.boundTypeName(left) : "";
+      const to = right ? this.boundTypeName(right) : "";
+      if (from && to && from !== to) out.push({ from, to, at });
+    };
+    const walk = (n) => {
+      if (n.type !== "binary_expression") return;
+      const { op, left, right } = this.binOperands(n);
+      if (op !== "<:" && op !== ">:") return;
+      let fromNode = left;
+      if (left && left.type === "binary_expression") {
+        const inner = this.binOperands(left);
+        if (inner.op === "<:" || inner.op === ">:") {
+          walk(left);
+          fromNode = inner.right;
+        }
+      }
+      link(fromNode, right, n);
+    };
+    walk(node);
+    return out;
+  }
+  /**
+   * The name a subtype BOUND states, or "" when the tree states none.
+   *
+   * `typeHeadName` accepts a call expression through its first-identifier fallback, which is right
+   * for a declaration head (`f(x) = …`) and wrong for a bound: `A where X <: f() <: Z` is a
+   * lowering error, and publishing `f` as the supertype would invent a type relation the source
+   * explicitly rejects. A bound is an identifier, a dotted path, or a parameterised/wrapped form of
+   * one — anything else is refused.
+   */
+  boundTypeName(node) {
+    if (!node) return "";
+    if (node.type === "identifier" || node.type === "operator") return node.text.trim();
+    if (node.type === "macro_identifier") return macroNameOf(node.text);
+    if (node.type === "field_expression") return this.fieldPath(node);
+    if (node.type === "parametrized_type_expression" || node.type === "where_expression" || node.type === "parenthesized_expression" || node.type === "curly_expression" || node.type === "type_head") {
+      return this.boundTypeName(this.pos(node, 0));
+    }
+    return "";
+  }
+  /**
+   * The operator token of a `binary_expression`. It is a NAMED child of type `operator` in this
+   * grammar — verified by walking the children of a real `struct Circle{T<:Real} <: Shape` —
+   * so a scan restricted to anonymous children finds nothing and the operator reads as empty.
+   */
+  tokenText(node, token) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && c.type === token) return c.text.trim();
+    }
+    return "";
+  }
+  namedChildren(node) {
+    const out = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c) out.push(c);
+    }
+    return out;
+  }
+  firstNamedChildOfType(node, type) {
+    for (const c of this.namedChildren(node)) if (c.type === type) return c;
+    return null;
+  }
+  firstNamedChildType(node) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && c.isNamed) return c.type;
+    }
+    return "";
+  }
+  hasToken(node, token) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && !c.isNamed && c.type === token) return true;
+    }
+    return false;
+  }
+  /**
+   * `type_head` is positional: `Name`, `Name{Params}`, or `Name{T} <: Super`.
+   *
+   * The `<:` case is the trap. `struct Circle{T<:Real} <: Shape` makes the head
+   * `(binary_expression (parametrized_type_expression Circle{T<:Real}) <: (identifier Shape))`, so
+   * the first identifier ANYWHERE in that subtree is **Shape** — the supertype — and the first
+   * version named every such struct after its supertype: one `class:Shape` with
+   * `contains -> radius`, and no `extends` edge, because the name and the supertype had been
+   * swapped by the same mistake. A declared name is the subtree's LEFT-most name, so a binary
+   * expression contributes its left operand and the supertype is read separately by
+   * `supertypesOf`. That is a plausible-looking wrong answer, which is the whole difficulty: the
+   * symbol list looked like a valid parse of a valid file.
+   */
+  typeRefName(node) {
+    if (node.type === "interpolation_expression") {
+      const inner = this.pos(node, 0);
+      return inner ? this.fieldPath(inner) : "";
+    }
+    return this.typeHeadName(node);
+  }
+  typeHeadName(node) {
+    if (node.type === "interpolation_expression") return "";
+    if (node.type === "identifier") return node.text.trim();
+    if (node.type === "macro_identifier") return macroNameOf(node.text);
+    if (node.type === "operator") return node.text.trim();
+    if (node.type === "binary_expression") {
+      const { left } = this.binOperands(node);
+      return left ? this.typeHeadName(left) : "";
+    }
+    if (node.type === "field_expression") {
+      const path2 = this.fieldPath(node);
+      if (path2) return path2;
+    }
+    const first = this.pos(node, 0);
+    if (first && first.type === "identifier") return first.text.trim();
+    if (first && first.type === "interpolation_expression") return "";
+    const direct = this.firstNamedChildOfType(node, "identifier");
+    if (direct) return direct.text.trim();
+    for (const c of this.namedChildren(node)) {
+      if (c.type === "curly_expression" || c.type === "parametrized_type_expression" || c.type === "binary_expression" || c.type === "field_expression") {
+        const inner = this.typeHeadName(c);
+        if (inner) return inner;
+      }
+      if (c.type === "where_expression") {
+        const inner = this.typeHeadName(c);
+        if (inner) return inner;
+      }
+    }
+    return "";
+  }
+  /** `signature` is positional: an identifier, a call, an argument list, a typed expr, or a where-expr. */
+  /**
+   * Strip a `where` clause to the callable underneath it. The callable is ALWAYS `pos(0)`.
+   *
+   * `f(x::T) where {T} = body` is `(assignment (where_expression (call_expression …) {T}) …)` and
+   * `function f(x::T) where T … end` is `(function_definition (signature (where_expression
+   * (call_expression …) T)) …)`. The corpus audit is what found this: `Compiler/test/inline.jl:664`
+   * declares `g41299(f::Tf, args::Vararg{Any,N}) where {Tf,N}`, nothing unwrapped the wrapper, so
+   * the declaration was never published and the call to it came out UNRESOLVED against a runtime
+   * that resolves it perfectly. Worse, the TYPE VARIABLE was read as the function's name.
+   *
+   * And note the two forms differ: `where {T}` puts a `curly_expression` after the call, but
+   * BARE `where T` puts the type variable there as a plain sibling `identifier`. That is why
+   * scanning for an identifier is unsound here — for `where T` it finds `T`, the parameter, and
+   * returns it as the function's name, fabricating a function called `T`. Positional access is
+   * not a workaround for this grammar; it is the only correct navigation.
+   */
+  unwrapWhere(node) {
+    const WRAPPERS = /* @__PURE__ */ new Set(["where_expression", "curly_expression", "typed_expression", "parenthesized_expression"]);
+    let cur = node;
+    for (let guard = 0; guard < 8 && WRAPPERS.has(cur.type); guard++) {
+      const first = this.pos(cur, 0);
+      if (!first) break;
+      cur = first;
+    }
+    return cur;
+  }
+  /**
+   * The nearest enclosing `module … end`, by name. Used by the `global` rule: the keyword declares a
+   * MODULE binding at any nesting, so the owner is this module and not the nearest container.
+   */
+  enclosingModuleName(node) {
+    let cur = node.parent ?? null;
+    while (cur) {
+      if (cur.type === "module_definition") {
+        const nm = cur.childForFieldName("name");
+        return nm ? nm.text.trim() : "";
+      }
+      cur = cur.parent ?? null;
+    }
+    return "";
+  }
+  /**
+   * The binding name a PLAIN module-scope assignment declares, or "" when this is not one.
+   *
+   * Julia admits a top-level assignment with no `const` (`x = 1`) and it creates a global binding in
+   * the module, which is what `contains` is for. Three things disqualify a node here, and each is a
+   * different fact:
+   *
+   *   - it is not written in a module's own scope (a `let`, a loop, a short-form body, a type body);
+   *   - its left side is not a NAME: `A.x = 1` assigns a field of another module, `a, b = 1, 2`
+   *     destructures (the grammar's tuple LHS), and a call/`where` head is a method definition;
+   *   - the name is a constant Julia implies (`nothing`, `missing`, …) rather than a binding.
+   *
+   * A `typed_expression` left side (`x::Int = 0`) is read through to its first child, the same rule
+   * the `const` case applies: the annotation is a reference, not part of the name.
+   */
+  plainModuleBinding(node) {
+    if (!this.inModuleBindingScope(node)) return "";
+    const lhs = this.pos(node, 0);
+    if (!lhs) return "";
+    const head = lhs.type === "typed_expression" ? this.pos(lhs, 0) : lhs;
+    if (!head) return "";
+    if (head.type === "identifier" || head.type === "operator" || head.type === "prefixed_string_literal") {
+      return head.text.trim();
+    }
+    return "";
+  }
+  /**
+   * Is this node written in a MODULE's own scope — not inside a body, loop, `let` or quote?
+   *
+   * The scope-introducing constructs are Julia's own list, not a heuristic: a binding written inside
+   * any of them is local to it. `begin`, `if` and `try` are transparent here (`if` is documented as
+   * introducing no scope; a top-level `begin` is the module body continuing). A SHORT-FORM FUNCTION
+   * is an `assignment` whose left side is a call, so the ancestor test has to recognise that shape
+   * as a body — otherwise `f(x) = (y = 1; y)` would publish `y` as a member of the module.
+   */
+  inModuleBindingScope(node) {
+    let cur = node.parent ?? null;
+    while (cur) {
+      if (cur.type === "module_definition") return true;
+      if (SCOPE_INTRODUCING_NODES.has(cur.type)) return false;
+      if (cur.type === "assignment") {
+        const head = this.unwrapWhere(this.pos(cur, 0) ?? cur);
+        const inner = head.type === "typed_expression" ? this.pos(head, 0) : head;
+        if (inner && inner.type === "call_expression") return false;
+      }
+      cur = cur.parent ?? null;
+    }
+    return false;
+  }
+  /** The `call_expression` at a definition's head, through the wrappers a head can carry. */
+  definitionCall(head) {
+    let cur = head;
+    for (let i = 0; i < 8 && cur; i++) {
+      if (cur.type === "call_expression") return cur;
+      if (cur.type === "where_expression") cur = this.unwrapWhere(cur);
+      else if (cur.type === "signature" || cur.type === "typed_expression" || cur.type === "parenthesized_expression" || cur.type === "macro_argument_list") cur = this.pos(cur, 0);
+      else return null;
+    }
+    return null;
+  }
+  signatureName(sig) {
+    if (sig.type === "typed_expression") {
+      const callable = this.pos(sig, 0);
+      if (callable) return this.signatureName(callable);
+    }
+    if (sig.type === "macrocall_expression") {
+      const m = this.firstNamedChildOfType(sig, "macro_identifier");
+      return m ? macroNameOf(m.text) : "";
+    }
+    if (sig.type === "call_expression") return this.calleeName(sig) ?? "";
+    if (sig.type === "where_expression") {
+      const callable = this.unwrapWhere(sig);
+      if (callable.type === "call_expression") return this.calleeName(callable) ?? "";
+    }
+    const direct = this.firstNamedChildOfType(sig, "identifier");
+    if (direct) return direct.text.trim();
+    const call = this.firstNamedChildOfType(sig, "call_expression");
+    if (call) return this.calleeName(call) ?? "";
+    for (const c of this.namedChildren(sig)) {
+      if (c.type === "where_expression" || c.type === "typed_expression" || c.type === "parenthesized_expression") {
+        const inner = this.signatureName(c);
+        if (inner) return inner;
+      }
+    }
+    return "";
+  }
+  /**
+  /**
+   * Is this node inside the `type_head` of a type DECLARATION?
+   *
+   * Checked by walking ancestors rather than the immediate parent, because the depth varies with
+   * the shape of the head: `struct Circle <: Shape` puts the `parametrized_type_expression` two
+   * levels down (`type_head > binary_expression > …`) while `struct Circle{T} <: Shape` puts it
+   * three, and a parent-only test silently missed the second. A guard that only sometimes fires
+   * is worse than none, because it leaves a self-reference edge on exactly the generic types that
+   * most need to be right.
+   */
+  withinTypeHead(node) {
+    let cur = node;
+    while (cur) {
+      if (this.typeHeadSites.has(cur.id)) return true;
+      if (cur.type === "function_definition" || cur.type === "macro_definition" || cur.type === "module_definition" || cur.type === "source_file") return false;
+      cur = cur.parent ?? null;
+    }
+    return false;
+  }
+  /** The C symbol a `ccall(...)` call targets, with its library when the two-tuple form gives one. */
+  ccallTarget(call) {
+    const args = this.firstNamedChildOfType(call, "argument_list");
+    const first = args ? this.pos(args, 0) : null;
+    if (!first) return null;
+    if (first.type === "quote_expression") {
+      const sym = this.pos(first, 0);
+      return sym ? { symbol: stripSigil(sym.text, ":"), library: null } : null;
+    }
+    if (first.type === "tuple_expression") {
+      const elem = (q) => {
+        if (!q) return "";
+        if (q.type === "quote_expression") {
+          const inner = this.pos(q, 0);
+          return inner ? stripSigil(inner.text.trim(), ":") : "";
+        }
+        return q.text.trim();
+      };
+      const parts = this.namedChildren(first).map(elem);
+      if (parts.length >= 2 && parts[0] && parts[1]) return { symbol: parts[0], library: parts[1] };
+      if (parts.length === 1 && parts[0]) return { symbol: parts[0], library: null };
+    }
+    return null;
+  }
+  /** Stable key for a call site, so a `@ccall` target can be recognised again when it is emitted. */
+  textKey(node, callee) {
+    return `${node.startIndex}:${callee}`;
+  }
+  /**
+   * Record every call site under an `@ccall` as a call to a FOREIGN symbol.
+   *
+   * `@ccall strlen(s)::Csize_t` puts the C function in an ordinary `call_expression` inside
+   * `macro_argument_list`, so without this the emit site cannot tell it from `f(s)` and asserts a
+   * Julia binding. Collected by node start index rather than by name, because two different C
+   * symbols can share a name and only the call SITE says which one this edge is.
+   */
+  markForeignCallees(macroNode) {
+    const args = this.firstNamedChildOfType(macroNode, "macro_argument_list");
+    if (!args) return;
+    const visit = (n) => {
+      if (n.type === "call_expression") {
+        const callee = this.calleeName(n);
+        if (callee) this.foreignMarked.add(this.textKey(n, callee));
+      }
+      for (const c of this.namedChildren(n)) visit(c);
+    };
+    visit(args);
+  }
+  /**
+   * The dotted path of a `field_expression` chain — this grammar's qualified access.
+   *
+   * MEASURED, and the measurement contradicted the code. There is NO `scoped_identifier` node in
+   * this grammar: scanning 400 corpus files for `scoped_identifier` under a `call_expression`
+   * callee found **0**, while `field_expression` accounted for every qualified callee. `Core
+   * .Intrinsics.bitcast` is `field_expression(field_expression(Core, Intrinsics), bitcast)` —
+   * left-nested, so the path is built by recursion, not by listing segments.
+   *
+   * The `scoped_identifier` branch this replaced was dead code written from a different grammar,
+   * and because it never matched, `calleeName` returned null and the analyzer emitted **nothing at
+   * all** for a file of qualified calls: zero symbols, zero relationships, no error. A silent empty
+   * graph is the worst failure shape there is — it reads as "nothing to see here" rather than
+   * "this analyzer is blind".
+   *
+   * The dotted path is kept WHOLE on purpose. Collapsing it to the last segment was measured to
+   * invent merges: over 400 files, 1,352 bare segments appear behind a qualified path and **72 of
+   * them are reachable by more than one distinct path**. `parse` alone is `Meta.parse`,
+   * `Base.parse`, `TOML.parse` and `Dates.parse` — four unrelated functions. `bitcast` is
+   * `Base.bitcast`, `Core.bitcast` and `Intrinsics.bitcast`. `isreadable` is
+   * `Filesystem.isreadable`, `Base.isreadable` and `Sys.isreadable`. One node per bare name would
+   * silently fuse them, and a merged node makes every edge into and out of it a statement about
+   * the wrong function. In Julia the qualified path IS the identity of the binding.
+   *
+   * `Base.:(==)` puts the operator in a `quote_expression`, so the last segment can be either.
+   */
+  /**
+   * THE NAME A NODE DECLARES, or "" when the node names nothing.
+   *
+   * One resolver for every position that must publish a NAME — a binding's left-hand side, a
+   * `where` bound's parameter — because the alternative is what this lane shipped: a `.text.trim()`
+   * at each site, each of which is correct for the shapes its author had in mind and a source SPAN
+   * for every other shape. The defect is not that any one site was careless; it is that "take the
+   * node's text" is a rule that has no answer to "what if the node is not a name".
+   *
+   * The walk descends the LEFT-most positional child through every wrapper this grammar can place
+   * around a declared name, and STOPS at a node it can spell:
+   *
+   *   typed_expression   `x::Int`        -> `x`      (child 1 is the type, a reference)
+   *   binary_expression  `T<:Real`       -> `T`      (left operand; the right is a bound)
+   *   parametrized_type  `Foo{T}`        -> `Foo`    (the base name, NOT the parameter list)
+   *   field_expression   `A.B`           -> `A.B`    (the whole path is the identity)
+   *   parenthesized/wrapped forms        -> their first child
+   *
+   * and returns "" for anything else — an `ERROR` node from a broken parse, a `tuple_expression`
+   * (which declares SEVERAL names and is therefore not one name), a literal, a comment. A refusal
+   * costs a symbol the grammar could not spell; publishing the node's text instead costs a key
+   * that no lookup can ever match, which is strictly worse.
+   *
+   * MEASURED on the whole corpus by `validation/m14/fixtures/julia/key-shape-census.ts`.
+   */
+  nameOf(node, depth = 0) {
+    if (depth > 8) return "";
+    switch (node.type) {
+      case "identifier":
+      case "operator":
+        return node.text.trim();
+      case "macro_identifier":
+        return stripSigil(node.text, "@");
+      case "scoped_identifier":
+      case "field_expression":
+      case "prefixed_string_literal":
+        return node.type === "prefixed_string_literal" ? node.text.trim() : this.fieldPath(node);
+      case "quote_expression":
+        return this.quotedName(node);
+      case "typed_expression":
+      case "unary_typed_expression":
+      case "binary_expression":
+      case "parenthesized_expression":
+      case "where_expression":
+      case "parametrized_type_expression":
+      case "curly_expression": {
+        const first = this.pos(node, 0);
+        return first ? this.nameOf(first, depth + 1) : "";
+      }
+      default:
+        return "";
+    }
+  }
+  /**
+   * The name a `quote_expression` spells — the OPERATOR for a quoted operator (`:(==)` → `==`), the
+   * quoted symbol itself for a Symbol value (`:foo`), or "" when the node's text is a SPAN rather
+   * than a spelling.
+   *
+   * The span rule is the whole point of the guard below. A `quote_expression` recovered over a
+   * broken region spans the reparsed remainder of the file —
+   * `julia/base/broadcast.jl`'s `:.>:` followed by the next line's `Expr(...)` came out as
+   * `":.>:\n        Expr"` and was published as a FUNCTION's name, with seven relationships
+   * sourced from it. A node whose text carries layout is not a name at all, so this refuses: the
+   * inner symbol is not read either, because when the wrapper spans a region the parser did not
+   * understand, the "inner operator" is whatever token it recovered on and spelling it would be a
+   * fabricated name rather than a missing one.
+   */
+  quotedName(node) {
+    const t = node.text.trim();
+    if (hasLayout(t)) return "";
+    const inner = this.pos(node, 0);
+    const plain = (n) => n && (n.type === "operator" || n.type === "identifier") && !hasLayout(n.text) ? n.text.trim() : "";
+    if (inner) {
+      const direct = plain(inner);
+      if (direct) return direct;
+      if (inner.type === "parenthesized_expression") {
+        const op = plain(this.pos(inner, 0));
+        if (op) return op;
+      }
+    }
+    return t;
+  }
+  fieldPath(node) {
+    if (node.type === "identifier") return node.text.trim();
+    if (node.type === "parametrized_type_expression") {
+      const base = this.pos(node, 0);
+      return base ? this.fieldPath(base) : "";
+    }
+    if (node.type === "quote_expression") return this.quotedName(node);
+    if (node.type === "macro_identifier") return macroNameOf(node.text);
+    if (node.type === "prefixed_string_literal") return node.text.trim();
+    if (node.type === "operator") return node.text.trim();
+    if (node.type === "typed_expression" || node.type === "unary_typed_expression") {
+      const inner = this.pos(node, 0);
+      return inner ? this.fieldPath(inner) : "";
+    }
+    if (node.type === "where_expression" || node.type === "parenthesized_expression") {
+      const inner = this.pos(node, 0);
+      return inner ? this.fieldPath(inner) : "";
+    }
+    if (node.type === "field_expression") {
+      const kids = this.namedChildren(node);
+      const receiver = kids[0];
+      const member = kids[kids.length - 1];
+      if (!receiver || !member) return "";
+      const head = this.fieldPath(receiver);
+      const tail = this.fieldPath(member);
+      return head && tail ? `${head}.${tail}` : head || tail || "";
+    }
+    return "";
+  }
+  /** The callee of a call: a bare name, or the WHOLE dotted path when it is qualified. */
+  calleeName(call) {
+    if (call.type === "where_expression") {
+      const callable = this.unwrapWhere(call);
+      if (callable !== call) return this.calleeName(callable);
+    }
+    const calleeNode = this.pos(call, 0);
+    if (calleeNode) {
+      if (calleeNode.type === "parenthesized_expression") {
+        const inner = this.pos(calleeNode, 0);
+        let base = inner;
+        for (let i = 0; i < 4 && base && (base.type === "where_expression" || base.type === "parenthesized_expression"); i++) {
+          base = this.pos(base, 0);
+        }
+        if (base && (base.type === "typed_expression" || base.type === "unary_typed_expression" || base.type === "interpolation_expression")) return null;
+        if (base && this.subtreeHasInterpolation(base)) return null;
+      }
+      const path2 = this.fieldPath(calleeNode);
+      if (path2) return path2;
+    }
+    for (const c of this.namedChildren(call)) {
+      if (c.type === "where_expression" || c.type === "parenthesized_expression") {
+        const inner = this.calleeName(c);
+        if (inner) return inner;
+      }
+    }
+    return null;
+  }
+  /**
+   * Does this subtree splice a runtime value (`$x`) into a NAME?
+   *
+   * A splice is not a spelling: `(Base.$fJ)(… ) = …` declares whichever binding the loop variable
+   * holds, and the source never names it. Walking the subtree rather than testing the top node is
+   * the point — the splice sits under a `field_expression` member, one level below the paren that
+   * `calleeName` inspects.
+   */
+  subtreeHasInterpolation(node) {
+    if (node.type === "interpolation_expression") return true;
+    for (const c of this.namedChildren(node)) if (this.subtreeHasInterpolation(c)) return true;
+    return false;
+  }
+  /**
+   * The supertype a type head STATES — the head's own `<:`, and never a comparison inside it.
+   *
+   * THE HEAD IS A WALL, NOT A ROAD, and this function used to descend it looking for `<:` at any
+   * depth. Two facts made every one of those edges wrong in a different way:
+   *
+   *   - a `<:` inside a supertype EXPRESSION is a COMPARISON, not a subtype of the declared type.
+   *     `struct S <: (S <: Real ? Any : Real)` published `S extends Real` — the CONDITION's right
+   *     operand read as the supertype, `1 of 1` corpus sites in `julia/test/typegroup.jl:665`.
+   *   - a `<:` chain inside a `where` clause bounds a PARAMETER (`(AbstractArray{T, N} where T <:
+   *     Integer where N)`), which the `where_expression` case below publishes with `T` as the
+   *     source; descending here also published `Foo extends N` and `Foo extends Integer`.
+   *
+   * Both were found by the direct oracle (`validation/m14/fixtures/julia/direct-oracle-check.ts`),
+   * whose own rule has been "the head's top-level binary, and the operand must NAME a type" since
+   * it was written — a second derivation of the same fact that disagreed, which is the only reason
+   * a reader could see it.
+   *
+   * A PARAMETER's bound is still published, by the `parametrized_type_expression`/
+   * `where_expression` cases, with the parameter as the source. That is a fact about `T`, not about
+   * the type, and it is a different edge.
+   */
+  supertypesOf(node) {
+    const head = this.firstNamedChildOfType(node, "type_head");
+    if (!head) return [];
+    const bin = this.firstNamedChildOfType(head, "binary_expression");
+    if (!bin) return [];
+    const { op, right } = this.binOperands(bin);
+    if (op !== "<:" && op !== ">:" || !right) return [];
+    const name = this.supertypeName(right);
+    return name ? [name] : [];
+  }
+  /**
+   * The NAME a supertype operand spells, or "" when the operand is a computed VALUE.
+   *
+   * MEASURED over the whole 1,985-file population (validation/m14/measurements/julia-supertype-
+   * shapes.json): 1,313 of the 1,324 `<:` sites in a type head are a NAME — identifier 891,
+   * `parametrized_type_expression` 346 (`AbstractVector{T}`), `field_expression` 76
+   * (`Base.AbstractSet`) — and the remaining 11 are the shapes below, every one of which this
+   * function REFUSES rather than guesses:
+   *
+   *   - `$typ <: $sup` (3, `julia/stdlib/LibGit2/src/types.jl:1084`): a runtime VALUE. The old
+   *     fallback published the interpolation's own identifier, `typ extends sup` — 3 edges saying a
+   *     type is a subtype of a loop variable.
+   *   - a statement BLOCK `(global g; g(::S) = 1; Any)` (2, `julia/test/typegroup.jl:652`): the
+   *     value is its last statement, `Any`, which happens to be a type — but the operand as written
+   *     states no name, and the block also DEFINES a method, which the walker published as
+   *     `contains S -> g`.
+   *   - `typeof(Core.apply_type)` (1), `0x01` (1), `@NamedTuple{x::Int}` (1), a TERNARY (1), and a
+   *     `where` chain (2) — a call, a literal, a macro call, a conditional and a UnionAll. The old
+   *     fallback read the call's CALLEE as the supertype (`Foo extends typeof`,
+   *     `julia/test/errorshow.jl:1540`) and the first bare identifier it could find inside the
+   *     others.
+   *
+   * A parenthesised NAME is still a name (`struct S <: (Any)`), and a `where`/`parametrized` wrapper
+   * is unwrapped to the type it is built from (`Tuple{T} where T` names `Tuple`, which is what the
+   * oracle derives and what a reader can follow). What is inside a CURLY parameter list is never
+   * read as the supertype: those are the type's ARGUMENTS.
+   */
+  supertypeName(node) {
+    switch (node.type) {
+      case "identifier":
+      case "operator":
+        return node.text.trim();
+      case "field_expression":
+        return this.fieldPath(node) || "";
+      case "parametrized_type_expression":
+      case "curly_expression":
+      case "parenthesized_expression":
+      case "where_expression": {
+        const inner = this.pos(node, 0);
+        return inner ? this.supertypeName(inner) : "";
+      }
+      default:
+        return "";
+    }
+  }
+  /** A struct body's `x::T` entries. The grammar has no dedicated field node for them. */
+  structFields(node) {
+    const out = [];
+    const fieldName = (c) => {
+      if (c.type === "typed_expression") return this.pos(c, 0)?.text.trim() ?? "";
+      if (c.type === "where_expression") {
+        const inner = this.pos(c, 0);
+        return inner ? fieldName(inner) : "";
+      }
+      if (c.type === "identifier") return c.text.trim();
+      if (c.type === "macrocall_expression") {
+        const args = this.namedChildren(c).find((n) => n.type === "macro_argument_list");
+        if (!args) return "";
+        for (const a of this.namedChildren(args)) {
+          const nm = fieldName(a);
+          if (nm) return nm;
+        }
+        return "";
+      }
+      if (c.type === "binary_expression") {
+        const { left } = this.binOperands(c);
+        if (left && left.type === "typed_expression") return this.pos(left, 0)?.text.trim() ?? "";
+        return "";
+      }
+      if (c.type === "const_statement") {
+        const inner = this.namedChildren(c).find((n) => n.type === "assignment" || n.type === "typed_expression" || n.type === "identifier");
+        return inner ? fieldName(inner) : "";
+      }
+      if (c.type === "assignment") {
+        const lhs = this.pos(c, 0);
+        if (!lhs) return "";
+        if (lhs.type === "typed_expression") return this.pos(lhs, 0)?.text.trim() ?? "";
+        if (lhs.type === "identifier") return lhs.text.trim();
+      }
+      return "";
+    };
+    for (const c of this.namedChildren(node)) {
+      const name = fieldName(c);
+      if (name) out.push({ name, node: c });
+    }
+    return out;
+  }
+  /**
+   * `import A: b, c` / `using A, B` — the module and the names brought in.
+   *
+   * ## WHY THIS IS NOW STATELESS, and what it cost to leave it stateful
+   *
+   * The previous version walked the statement's named children IN ORDER carrying a `pending`
+   * variable, and one of its branches read: *"a bare identifier when something is already pending,
+   * with no items yet, and a different name — that is an ITEM of the pending target."*
+   *
+   * That branch cannot tell a second MODULE from an item of the first. `using A, B` names two
+   * modules, and the corpus's second most common multi-path import shape by volume is exactly that:
+   * 32 two-path and 12 three-path statements in a 400-file draw (`validation/m14/fixtures/julia/
+   * import-export-shapes.ts`, which enumerates every observed shape with counts). The consequence was
+   * silent and total for the tail of a long list — `DataFrames.jl/src/DataFrames.jl:3-19` is one
+   * `using` statement naming **17 modules** and this function published ONE of them, calling the
+   * other sixteen "items" of `Base.Sort`.
+   *
+   * Measured over the whole admitted corpus by the oracle this change was written against
+   * (`script/m14/oracles/julia-imports.ts`, an independent derivation sharing no rule with this one):
+   * **167 of 440 `imports` edges were missing on a 200-file draw — 38% of the type.** Every one of
+   * the `imports` RELATIONSHIPS, every `ImportInfo[]` row and every `references` row carrying
+   * `isImport: true` lost the same dependencies, because all three are written from this one walk.
+   *
+   * The previous instrument could not have found it. `census.ts`'s construct-versus-edge
+   * reconciliation counts FILES containing the construct against files whose edge fired, and a file
+   * whose FIRST module produced an edge passed — the per-file granularity cannot see a missing second
+   * target. A differential against an independent derivation can, and did.
+   *
+   * ## THE RULE, WHICH IS ABOUT THE CHILD AND NOT ITS SIBLINGS
+   *
+   * Every named child is classified on its own, and the question asked of each is "is this child a
+   * module path, or is it a name inside a path's list?" — answerable from the child's own position in
+   * ITS parent, with no knowledge of what came before. Two siblings of the same type therefore cannot
+   * be confused for one another, which is the whole defect class.
+   *
+   * Shapes, all measured over the corpus rather than read out of `grammar.js`:
+   *
+   *   `using A` / `import A.B.C`   bare path      → `identifier` | `scoped_identifier` | `import_path`
+   *   `using A, B`                 two bare paths → two of the above as SIBLINGS — the fixed case
+   *   `using A: x, y`              path + names   → `selected_import`, module is its child 0
+   *   `import A as B`              renamed import → `import_alias`, module is its child 0
+   *
+   * The last one was dropped entirely before: the `import_alias` branch required `pending`, and a
+   * statement whose ONLY named child is an `import_alias` never had one, so `import ChainRulesCore as
+   * CRC` (`StaticArrays.jl/ext/StaticArraysChainRulesCoreExt.jl`) published nothing at all.
+   *
+   * `import_path` and `scoped_identifier` are taken WHOLE, leading dots and all: the dots are what
+   * distinguishes `using .Foo` from `using ..Foo`, and a dotted path's last segment is not the module
+   * a statement imports (`using Base.GMP.MPZ` imports `Base.GMP.MPZ`, not `MPZ`).
+   *
+   * ## What this function still does not do
+   *
+   * 45 of the corpus's 3,570 import/export statements carry an ERROR descendant, and almost all of
+   * them are legitimate julia the grammar cannot fully parse — `import .Base.Math.@horner`
+   * (`julia/base/special/log.jl:12`, in julia's own stdlib), `import ..test_mod.@old_hyg` (32
+   * statements in `julia/JuliaLowering/test/scopes.jl`), `import B.@mac as @mac2`. The module path
+   * around the unparsed part still parses, so taking the child's whole text records the dependency
+   * that exists. **Refusing these would trade 45 real edges for 2 fabricated ones, which is why the
+   * ERROR rule is applied to `export`/`public` only and for a different reason** — see the
+   * `export_statement` case, where the statement node ITSELF is wrong rather than one part of it.
+   */
+  importTargets(node) {
+    const out = [];
+    for (const c of this.namedChildren(node)) {
+      if (c.type === "selected_import" || c.type === "import_alias") {
+        const inner = this.namedChildren(c);
+        if (!inner.length) continue;
+        const modName = inner[0].text.trim();
+        if (!modName) continue;
+        const items = c.type === "selected_import" ? inner.slice(1).map((x) => x.text.trim()).filter((x) => x.length > 0) : [];
+        out.push({ name: modName, items, renamed: c.type === "import_alias" || void 0 });
+        continue;
+      }
+      if (c.type === "import_path" || c.type === "identifier" || c.type === "scoped_identifier") {
+        const name = c.text.trim();
+        if (name) out.push({ name, items: [] });
+      }
+    }
+    return out;
+  }
+  exportableName(node) {
+    if (node.type === "identifier") return node.text.trim();
+    if (node.type === "operator") return node.text.trim();
+    if (node.type === "scoped_identifier") {
+      const segs = this.namedChildren(node).filter((x) => x.type === "identifier");
+      return segs.length ? segs[segs.length - 1].text.trim() : node.text.trim();
+    }
+    if (node.type === "macro_identifier") return macroNameOf(node.text);
+    if (node.type === "call_expression") return this.calleeName(node) ?? "";
+    if (node.type === "tuple_expression" || node.type === "parenthesized_expression") {
+      for (const c of this.namedChildren(node)) {
+        const n = this.exportableName(c);
+        if (n) return n;
+      }
+    }
+    return "";
+  }
+  /**
+   * Evidence tier, the same rules as the swift/dart/csharp/objc family.
+   */
+  classifyEvidenceTier(rels) {
+    for (const r of rels) {
+      const md = r.metadata ?? {};
+      const t = String(r.type ?? "");
+      if (t === "contains") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "imports" || t === "exports" || t === "references") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "overrides") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "calls" || t === "uses" || t === "instantiates") {
+        md.evidenceClass = (r.confidence ?? 0) >= 0.85 ? "usage_contextual" : "inferred";
+        continue;
+      }
+      if (t === "extends" || t === "implements") {
+        md.evidenceClass = (r.confidence ?? 0) >= 0.9 ? "structural" : "inferred";
+        continue;
+      }
+    }
+  }
+  /**
+   * Cyclomatic complexity, counted over the tree.
+   *
+   * The walk is GUARDED at 200,000 node visits, and that guard is inherited from the other lanes
+   * rather than invented — the objective-c review measured its own guard at 3.33% of the cap on
+   * the worst corpus file, so the bound is real but never approached there. A truncated value
+   * would be indistinguishable from a true one in the artifact, which is why the cap exists at all
+   * and why its margin is measured rather than assumed.
+   */
+  complexity(root) {
+    let c = 1;
+    const decisions = /* @__PURE__ */ new Set(["if_statement", "elseif_clause", "for_statement", "while_statement"]);
+    const stack = [root];
+    let guard = 0;
+    while (stack.length > 0 && guard++ < 2e5) {
+      const n = stack.pop();
+      if (decisions.has(n.type)) c++;
+      else if (n.type === "binary_expression") {
+        const opNode = this.pos(n, 1);
+        const op = opNode && opNode.type === "operator" ? opNode.text.trim() : "";
+        if (op === "&&" || op === "||") c++;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const ch = n.namedChild(i);
+        if (ch) stack.push(ch);
+      }
+    }
+    return c;
+  }
+};
+export {
+  RealJuliaAnalyzer
+};