@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/real-rust-analyzer-LVSONPAN.js

@@ -0,0 +1,3359 @@
+import {
+  FILE_CLAIM_MAX_BYTES
+} from "./chunk-EWMWK7WN.js";
+import {
+  ASTEngine
+} from "./chunk-V44PGPA6.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-rust-analyzer.ts
+import { readdirSync, readFileSync, statSync } from "fs";
+import * as path from "path";
+var ROUTE_VERBS = ["get", "post", "put", "delete", "patch", "head", "options", "trace", "route"];
+function routeVerbOf(text) {
+  if (!text.startsWith("#[")) return "";
+  const rest = text.slice(2);
+  for (const verb of ROUTE_VERBS) {
+    if (!rest.startsWith(verb)) continue;
+    const next = rest[verb.length] ?? "";
+    if (next === "(" || next === " " || next === "	") return verb;
+  }
+  return "";
+}
+function extractRoutePath(text) {
+  if (!routeVerbOf(text)) return null;
+  const open = text.indexOf("(", 2);
+  if (open < 0) return null;
+  const q1 = text.indexOf('"', open);
+  if (q1 < 0) return null;
+  const q2 = text.indexOf('"', q1 + 1);
+  if (q2 <= q1 + 1) return null;
+  return text.slice(q1 + 1, q2);
+}
+function hasBareWord(hay, word) {
+  const isWordChar = (c) => c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95;
+  let i = hay.indexOf(word);
+  while (i >= 0) {
+    const before = i > 0 ? hay.charCodeAt(i - 1) : 0;
+    const after = i + word.length < hay.length ? hay.charCodeAt(i + word.length) : 0;
+    if (!isWordChar(before) && !isWordChar(after)) return true;
+    i = hay.indexOf(word, i + 1);
+  }
+  return false;
+}
+function startsUpperAscii(s) {
+  if (s.length === 0) return false;
+  const c = s.charCodeAt(0);
+  return c >= 65 && c <= 90;
+}
+function macroTokenTreeOf(inv) {
+  for (let i = 0; i < inv.namedChildCount; i++) {
+    const c = inv.namedChild(i);
+    if (c && c.type === "token_tree") return c;
+  }
+  return null;
+}
+function isTwoSegmentIdentPath(s) {
+  const sep2 = s.indexOf("::");
+  if (sep2 <= 0 || sep2 + 3 > s.length) return false;
+  if (s.indexOf("::", sep2 + 2) >= 0) return false;
+  const isStart = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95;
+  const isPart = (c) => isStart(c) || c >= 48 && c <= 57;
+  if (!isStart(s.charCodeAt(0))) return false;
+  for (let k = 1; k < sep2; k++) if (!isPart(s.charCodeAt(k))) return false;
+  const tail = sep2 + 2;
+  if (!isStart(s.charCodeAt(tail))) return false;
+  for (let k = tail + 1; k < s.length; k++) if (!isPart(s.charCodeAt(k))) return false;
+  return true;
+}
+function rustCrateSourceRoot(filePath, projectRoot) {
+  const dir = path.dirname(filePath);
+  const dirName = path.basename(dir);
+  if (dirName === "bin" || dirName === "tests" || dirName === "examples" || dirName === "benches") return dir;
+  const stop = path.resolve(projectRoot);
+  let d = dir;
+  for (; ; ) {
+    for (const rootFile of ["lib.rs", "main.rs"]) {
+      try {
+        if (statSync(path.join(d, rootFile)).isFile()) return d;
+      } catch {
+      }
+    }
+    const current = path.resolve(d);
+    if (current === stop) break;
+    const up = path.dirname(d);
+    if (up === d || !path.resolve(up).startsWith(stop)) break;
+    d = up;
+  }
+  return dir;
+}
+function rustModuleFileCandidates(module, filePath, projectRoot, atFileScope) {
+  const parts = module.split("::").filter((p) => p.length > 0);
+  if (parts.length === 0) return null;
+  const rootWord = parts[0];
+  const leafIsItem = parts.length >= 2 && startsUpperAscii(parts[parts.length - 1]);
+  const eff = leafIsItem ? parts.slice(0, -1) : parts;
+  if (rootWord === "crate" || rootWord === "self" || rootWord === "super") {
+    if (rootWord !== "crate" && !atFileScope) return null;
+    const dir = path.dirname(filePath);
+    if (rootWord === "crate") {
+      const base2 = rustCrateSourceRoot(filePath, projectRoot);
+      if (eff.length === 1 || eff.length === 2 && startsUpperAscii(eff[1])) {
+        return crateRootFileCandidates(base2);
+      }
+      const stem3 = path.join(base2, ...eff.slice(1));
+      return [`${stem3}.rs`, path.join(stem3, "mod.rs")];
+    }
+    const isModRs = path.basename(filePath) === "mod.rs";
+    if (rootWord === "self") {
+      if (eff.length < 2) return null;
+      const stem3 = path.join(dir, ...eff.slice(1));
+      return [`${stem3}.rs`, path.join(stem3, "mod.rs")];
+    }
+    const base = isModRs ? path.dirname(dir) : dir;
+    if (eff.length === 1) return [`${base}.rs`, path.join(base, "mod.rs")];
+    const stem2 = path.join(base, ...eff.slice(1));
+    return [`${stem2}.rs`, path.join(stem2, "mod.rs")];
+  }
+  if (rootWord === "std" || rootWord === "core" || rootWord === "alloc") return null;
+  const libFile = rustWorkspaceCrates(filePath, projectRoot).get(rootWord);
+  if (libFile === void 0) return null;
+  const localBase = rustCrateSourceRoot(filePath, projectRoot);
+  const localStem = path.join(localBase, rootWord);
+  if (isFile(localStem + ".rs") || isFile(path.join(localStem, "mod.rs"))) return null;
+  if (parts.length === 1) return [libFile];
+  const crateSrc = path.dirname(libFile);
+  const stem = path.join(crateSrc, ...parts.slice(1));
+  return [`${stem}.rs`, path.join(stem, "mod.rs")];
+}
+var RUST_SYSTEM_NAMESPACES = ["std", "core", "alloc"];
+function rustSystemNamespaceOf(modulePath) {
+  if (!modulePath.includes("::")) return null;
+  for (const root of RUST_SYSTEM_NAMESPACES) {
+    if (modulePath.startsWith(root + "::")) return root;
+  }
+  return null;
+}
+var RUST_WORKSPACE_CRATES = /* @__PURE__ */ new Map();
+function isFile(p) {
+  try {
+    return statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function crateRootFileCandidates(base) {
+  const lib = path.join(base, "lib.rs");
+  const main = path.join(base, "main.rs");
+  const hasLib = isFile(lib);
+  const hasMain = isFile(main);
+  if (hasLib && hasMain) return null;
+  if (hasLib) return [lib];
+  if (hasMain) return [main];
+  return null;
+}
+function readManifest(dir) {
+  try {
+    return readFileSync(path.join(dir, "Cargo.toml"), "utf8");
+  } catch {
+    return "";
+  }
+}
+function rustManifestFacts(text) {
+  const facts = { hasWorkspace: false, packageName: null, libPath: null, workspaceMembers: [] };
+  const n = text.length;
+  let i = 0;
+  let section = "";
+  const at = (k) => k >= 0 && k < n ? text.charCodeAt(k) : -1;
+  const skipTrivia = () => {
+    for (; ; ) {
+      while (i < n && (text.charCodeAt(i) === 32 || text.charCodeAt(i) === 9 || text.charCodeAt(i) === 13 || text.charCodeAt(i) === 10)) i++;
+      if (i < n && text.charCodeAt(i) === 35) {
+        while (i < n && text.charCodeAt(i) !== 10) i++;
+        continue;
+      }
+      break;
+    }
+  };
+  const parseString = () => {
+    const q = at(i);
+    if (q !== 34 && q !== 39) return null;
+    const triple = at(i + 1) === q && at(i + 2) === q;
+    i += triple ? 3 : 1;
+    let out = "";
+    while (i < n) {
+      const c = text.charCodeAt(i);
+      if (triple) {
+        if (c === q && at(i + 1) === q && at(i + 2) === q) {
+          i += 3;
+          return out;
+        }
+      } else if (c === q) {
+        i++;
+        return out;
+      }
+      if (c === 92 && q === 34) {
+        const e = at(i + 1);
+        if (e === 34) {
+          out += '"';
+          i += 2;
+          continue;
+        }
+        if (e === 92) {
+          out += "\\";
+          i += 2;
+          continue;
+        }
+        if (e === 110) {
+          out += "\n";
+          i += 2;
+          continue;
+        }
+        if (e === 116) {
+          out += "	";
+          i += 2;
+          continue;
+        }
+        if (e === 114) {
+          out += "\r";
+          i += 2;
+          continue;
+        }
+        if (e === 98) {
+          out += "\b";
+          i += 2;
+          continue;
+        }
+        if (e === 102) {
+          out += "\f";
+          i += 2;
+          continue;
+        }
+        if (e === 117 || e === 85) {
+          const len = e === 117 ? 4 : 8;
+          let hex = "";
+          i += 2;
+          for (let k = 0; k < len && i < n; k++, i++) hex += text[i];
+          const cp = parseInt(hex, 16);
+          if (Number.isFinite(cp) && cp >= 0 && cp <= 1114111) out += String.fromCodePoint(cp);
+          continue;
+        }
+        if (i + 1 < n) out += text[i + 1];
+        i += 2;
+        continue;
+      }
+      out += text[i];
+      i++;
+    }
+    return null;
+  };
+  const parseKey = () => {
+    const parts = [];
+    for (; ; ) {
+      while (i < n && (text.charCodeAt(i) === 32 || text.charCodeAt(i) === 9)) i++;
+      const c = at(i);
+      let seg = "";
+      if (c === 34 || c === 39) {
+        const s = parseString();
+        if (s === null) return null;
+        seg = s;
+      } else {
+        const start = i;
+        while (i < n) {
+          const d = text.charCodeAt(i);
+          const bare = d >= 48 && d <= 57 || d >= 65 && d <= 90 || d >= 97 && d <= 122 || d === 95 || d === 45;
+          if (!bare) break;
+          i++;
+        }
+        if (i === start) return null;
+        seg = text.slice(start, i);
+      }
+      parts.push(seg);
+      while (i < n && (text.charCodeAt(i) === 32 || text.charCodeAt(i) === 9)) i++;
+      if (at(i) === 46) {
+        i++;
+        continue;
+      }
+      break;
+    }
+    return parts.join(".");
+  };
+  const skipValue = () => {
+    let depth = 0;
+    while (i < n) {
+      const c = text.charCodeAt(i);
+      if (c === 34 || c === 39) {
+        if (parseString() === null) return;
+        continue;
+      }
+      if (c === 91 || c === 123) {
+        depth++;
+        i++;
+        continue;
+      }
+      if (c === 93 || c === 125) {
+        if (depth === 0) return;
+        depth--;
+        i++;
+        continue;
+      }
+      if (depth === 0 && (c === 10 || c === 44)) return;
+      if (depth === 0 && c === 35) {
+        while (i < n && text.charCodeAt(i) !== 10) i++;
+        return;
+      }
+      i++;
+    }
+  };
+  const parseValue = () => {
+    while (i < n && (text.charCodeAt(i) === 32 || text.charCodeAt(i) === 9)) i++;
+    const c = at(i);
+    if (c === 34 || c === 39) {
+      const s = parseString();
+      return s === null ? { kind: "other" } : { kind: "string", value: s };
+    }
+    if (c === 91) {
+      i++;
+      const items = [];
+      for (; ; ) {
+        skipTrivia();
+        if (i >= n) break;
+        const d = text.charCodeAt(i);
+        if (d === 93) {
+          i++;
+          break;
+        }
+        if (d === 44) {
+          i++;
+          continue;
+        }
+        if (d === 34 || d === 39) {
+          const s = parseString();
+          if (s === null) break;
+          items.push(s);
+          continue;
+        }
+        const before = i;
+        skipValue();
+        if (i === before) i++;
+      }
+      return { kind: "array", items };
+    }
+    skipValue();
+    return { kind: "other" };
+  };
+  for (; ; ) {
+    skipTrivia();
+    if (i >= n) break;
+    if (text.charCodeAt(i) === 91) {
+      i++;
+      const arrayOfTables = at(i) === 91;
+      if (arrayOfTables) i++;
+      const key2 = parseKey();
+      while (i < n && text.charCodeAt(i) !== 93) i++;
+      if (i < n) i++;
+      if (arrayOfTables && at(i) === 93) i++;
+      if (key2 !== null) {
+        section = key2;
+        if (key2 === "workspace") facts.hasWorkspace = true;
+      }
+      continue;
+    }
+    const key = parseKey();
+    if (key === null) {
+      i++;
+      continue;
+    }
+    skipTrivia();
+    if (at(i) !== 61) continue;
+    i++;
+    const value = parseValue();
+    let effSection = section;
+    let effKey = key;
+    if (effSection === "") {
+      const dot = key.lastIndexOf(".");
+      if (dot > 0) {
+        effSection = key.slice(0, dot);
+        effKey = key.slice(dot + 1);
+      }
+    }
+    if (effSection === "package" && effKey === "name" && value.kind === "string" && facts.packageName === null) {
+      facts.packageName = value.value;
+    }
+    if (effSection === "lib" && effKey === "path" && value.kind === "string" && facts.libPath === null) {
+      facts.libPath = value.value;
+    }
+    if (effSection === "workspace" && effKey === "members" && value.kind === "array" && facts.workspaceMembers.length === 0) {
+      facts.workspaceMembers = value.items;
+    }
+  }
+  return facts;
+}
+var RUST_MANIFEST_FACTS = /* @__PURE__ */ new Map();
+function manifestFactsOf(dir) {
+  const cached = RUST_MANIFEST_FACTS.get(dir);
+  if (cached !== void 0) return cached;
+  const facts = rustManifestFacts(readManifest(dir));
+  if (RUST_MANIFEST_FACTS.size > 4096) RUST_MANIFEST_FACTS.clear();
+  RUST_MANIFEST_FACTS.set(dir, facts);
+  return facts;
+}
+function manifestPackageName(dir) {
+  const raw = manifestFactsOf(dir).packageName;
+  return raw === null ? null : raw.split("-").join("_");
+}
+function manifestLibFile(dir) {
+  const facts = manifestFactsOf(dir);
+  const libFile = facts.libPath !== null ? path.resolve(dir, facts.libPath) : path.join(dir, "src", "lib.rs");
+  return isFile(libFile) ? libFile : null;
+}
+function expandMemberPattern(workspaceDir, pattern) {
+  let bases = [workspaceDir];
+  for (const seg of pattern.split("/")) {
+    if (seg === "*") {
+      const next = [];
+      for (const base of bases) {
+        try {
+          for (const e of readdirSync(base, { withFileTypes: true })) {
+            if (e.isDirectory() && !e.name.startsWith(".")) next.push(path.join(base, e.name));
+          }
+        } catch {
+        }
+      }
+      bases = next;
+    } else {
+      bases = bases.map((base) => path.join(base, seg));
+    }
+  }
+  return bases;
+}
+var RUST_WORKSPACE_DIRS = /* @__PURE__ */ new Map();
+function findWorkspaceDir(filePath, projectRoot) {
+  const startDir = path.dirname(filePath);
+  const cacheKey = `${projectRoot}\0${startDir}`;
+  const cached = RUST_WORKSPACE_DIRS.get(cacheKey);
+  if (cached !== void 0) return cached;
+  const found = findWorkspaceDirUncached(filePath, projectRoot);
+  if (RUST_WORKSPACE_DIRS.size > 4096) RUST_WORKSPACE_DIRS.clear();
+  RUST_WORKSPACE_DIRS.set(cacheKey, found);
+  return found;
+}
+function findWorkspaceDirUncached(filePath, projectRoot) {
+  const stop = path.resolve(projectRoot);
+  let dir = path.dirname(filePath);
+  let nearestPackageDir = null;
+  for (; ; ) {
+    if (isFile(path.join(dir, "Cargo.toml"))) {
+      if (nearestPackageDir === null) nearestPackageDir = dir;
+      if (manifestFactsOf(dir).hasWorkspace) return dir;
+    }
+    const current = path.resolve(dir);
+    if (current === stop) break;
+    const up = path.dirname(dir);
+    if (up === dir || !path.resolve(up).startsWith(stop)) break;
+    dir = up;
+  }
+  return nearestPackageDir;
+}
+function rustWorkspaceCrates(filePath, projectRoot) {
+  const workspaceDir = findWorkspaceDir(filePath, projectRoot);
+  if (workspaceDir === null) return /* @__PURE__ */ new Map();
+  const cached = RUST_WORKSPACE_CRATES.get(workspaceDir);
+  if (cached !== void 0) return cached;
+  const out = /* @__PURE__ */ new Map();
+  const addCrate = (dir) => {
+    const name = manifestPackageName(dir);
+    if (name === null || out.has(name)) return;
+    const libFile = manifestLibFile(dir);
+    if (libFile !== null) out.set(name, libFile);
+  };
+  addCrate(workspaceDir);
+  for (const pattern of manifestFactsOf(workspaceDir).workspaceMembers) {
+    for (const dir of expandMemberPattern(workspaceDir, pattern)) addCrate(dir);
+  }
+  if (RUST_WORKSPACE_CRATES.size > 32) RUST_WORKSPACE_CRATES.clear();
+  RUST_WORKSPACE_CRATES.set(workspaceDir, out);
+  return out;
+}
+function confirmModuleFile(candidates, projectRoot) {
+  const root = path.resolve(projectRoot);
+  for (const cand of candidates) {
+    const rel = path.relative(root, cand).split(path.sep).join("/");
+    if (rel.length === 0 || rel.startsWith("../") || path.isAbsolute(rel)) continue;
+    if (!rel.toLowerCase().endsWith(".rs")) continue;
+    try {
+      const st = statSync(cand);
+      if (!st.isFile() || st.size > FILE_CLAIM_MAX_BYTES) continue;
+    } catch {
+      continue;
+    }
+    return rel;
+  }
+  return null;
+}
+var RUST_FRAMEWORK_PRIORITY = [
+  "actix_web",
+  "axum",
+  "rocket",
+  "tokio",
+  "clap",
+  "serde",
+  "thiserror",
+  "tracing"
+];
+var RUST_UNNAMED_IMPL = "anonymous_impl";
+var RUST_FILE_SOURCE = "(file)";
+var RealRustAnalyzer = class {
+  // RSD3: per-file set of symbol ids already handed out, so impl blocks and
+  // other same-(owner,name) declarations never share an id (struct Foo + two
+  // `impl Foo` blocks previously produced THREE symbols all id "Foo"; 2,852
+  // duplicates across cargo+ripgrep). Reset per analyze() call.
+  usedIds = /* @__PURE__ */ new Set();
+  /**
+   * M59.A7 (#825): the 1-based line of a syntax node, or `undefined` when the
+   * node is absent. Never 0 — a site that cannot be named is OMITTED from the
+   * edge (the #820 rule), so a reader can tell "no line" from "line 1".
+   */
+  nodeLine(node) {
+    if (!node || !node.startPosition || typeof node.startPosition.row !== "number") return void 0;
+    return node.startPosition.row + 1;
+  }
+  /**
+   * R7, the SYMBOL-level half: the name of the declaration that owns an edge, or
+   * `null` when there is none.
+   *
+   * The old expression at six call sites was `parent?.name || "global"`, and the
+   * fallback was the literal the rule exists to forbid: over the 110-file ripgrep
+   * corpus it put `global` into 1,169 edge endpoints. Measured causes, by the
+   * enclosing node at the edge's own line (`script/incoming-rust/rust-r7-origin.ts`):
+   *
+   *   443 `imports`  file-scope `use_declaration`      -> no enclosing declaration
+   *   350 `calls`    file-scope `macro_invocation` body -> no enclosing declaration
+   *   140 `exports`  a `pub` item, whose OWN name is the target
+   *   108 `uses`     a `const` initializer             -> the const declares it
+   *   60  `imports`  a `use` inside a function body    -> no enclosing declaration
+   *   16  `calls`    a `const` initializer
+   *   36  `uses`     file-scope `macro_invocation` body
+   *
+   * Two of those have a real owner and are fixed by handing the const/static
+   * symbol back to the walk. Three genuinely have none, and for those the rule's
+   * own words govern: "When a fallback has nothing truthful to say the honest
+   * state is ABSENCE, not the string 'unknown'". So the caller OMITS the edge and
+   * records the omission in `metadata.unattributedEdges`, which is what makes the
+   * loss countable rather than invisible.
+   */
+  edgeSource(parent) {
+    const n = parent?.name;
+    return n && n.length > 0 ? n : null;
+  }
+  /** Record one refused edge and return `null`, for `const s = this.edgeSource(p); if (!s) return`. */
+  noOwner(ctx, type) {
+    ctx.unattributed.set(type, (ctx.unattributed.get(type) ?? 0) + 1);
+    return null;
+  }
+  analyze(rootNode, content, filePath, context) {
+    const ctx = {
+      tree: { rootNode },
+      content,
+      filePath,
+      // Absent for a per-file-only caller (the fixture runner calls `analyze` with no context):
+      // the file claim is then not emitted at all, which is the safe answer, never a guess.
+      projectRoot: typeof context?.projectRoot === "string" ? context.projectRoot : "",
+      symbols: [],
+      imports: [],
+      relationships: [],
+      exports: [],
+      metadata: {
+        language: "rust",
+        // R8 (M60 standing rule): the family contract's three keys, ALL
+        // declared here. `framework` is the deterministic primary pick and its
+        // VALUE is assigned after the walk (below), because detection happens
+        // in the attribute handler as the tree is traversed — but the key is
+        // part of what this analyzer publishes, so it is declared at
+        // construction exactly as the compliant lanes (java's
+        // `pickJavaFramework`, go's `frameworks[0]?.name`) declare theirs.
+        framework: void 0,
+        detectedFrameworks: [],
+        frameworkPatterns: []
+      },
+      emittedUses: /* @__PURE__ */ new Set(),
+      unattributed: /* @__PURE__ */ new Map(),
+      macroArgumentReads: 0,
+      pendingInstantiations: [],
+      awaitedCalls: /* @__PURE__ */ new Set()
+    };
+    this.usedIds = /* @__PURE__ */ new Set();
+    const valueOwners = /* @__PURE__ */ new Map();
+    const useImported = /* @__PURE__ */ new Set();
+    this.collectValueOwners(rootNode, valueOwners, useImported);
+    const fnBindings = this.collectFunctionBindings(rootNode, valueOwners, useImported);
+    const tupleShapeScopes = (() => {
+      const out = /* @__PURE__ */ new Map();
+      const walkShapes = (n, scopePath) => {
+        if (!n) return;
+        if (n.type === "mod_item") {
+          const nm = n.childForFieldName?.("name") ?? n.namedChild(0);
+          const childPath = [...scopePath, nm ? String(nm.text) : ""];
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c && c.type === "declaration_list") walkShapes(c, childPath);
+          }
+          return;
+        }
+        if (n.type === "struct_item") {
+          let tupleShape = false;
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c && c.type === "ordered_field_declaration_list") tupleShape = true;
+          }
+          if (tupleShape) {
+            const nm = n.childForFieldName?.("name") ?? n.namedChild(0);
+            if (nm) {
+              const list = out.get(String(nm.text)) ?? [];
+              list.push(scopePath);
+              out.set(String(nm.text), list);
+            }
+          }
+        }
+        for (let i = 0; i < n.namedChildCount; i++) walkShapes(n.namedChild(i), scopePath);
+      };
+      walkShapes(rootNode, []);
+      return out;
+    })();
+    const scopePrefixOf = (outer, inner) => {
+      if (outer.length > inner.length) return false;
+      for (let i = 0; i < outer.length; i++) if (outer[i] !== inner[i]) return false;
+      return true;
+    };
+    const bareTupleCtorVisible = (name, callScope) => {
+      for (const declScope of tupleShapeScopes.get(name) ?? []) if (scopePrefixOf(declScope, callScope)) return true;
+      return false;
+    };
+    if (rootNode.hasError) {
+      const errStack = [rootNode];
+      while (errStack.length > 0) {
+        const n = errStack.pop();
+        if (n.type === "ERROR" || n.isMissing) {
+          if (!ctx.metadata.errors) ctx.metadata.errors = [];
+          ctx.metadata.errors.push({
+            message: `Syntax ${n.type} detected. The Brain Engine is bypassing this broken node.`,
+            range: {
+              startLine: n.startPosition.row + 1,
+              startColumn: n.startPosition.column + 1,
+              endLine: n.endPosition.row + 1,
+              endColumn: n.endPosition.column + 1,
+              startIndex: n.startIndex,
+              endIndex: n.endIndex
+            },
+            severity: "warning"
+          });
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const child = n.namedChild(i);
+          if (child) errStack.push(child);
+        }
+      }
+    }
+    const stack = [{ node: rootNode, parent: null }];
+    while (stack.length > 0) {
+      const popped = stack.pop();
+      if (!popped) continue;
+      const { node, parent } = popped;
+      let currentParent = parent;
+      if (node.type === "struct_item" || node.type === "union_item") {
+        currentParent = this.handleStruct(node, ctx, parent) ?? parent;
+      } else if (node.type === "trait_item") {
+        currentParent = this.handleTrait(node, ctx, parent) ?? parent;
+      } else if (node.type === "impl_item") {
+        currentParent = this.handleImpl(node, ctx, parent) ?? parent;
+      } else if (node.type === "function_item" || node.type === "function_signature_item") {
+        currentParent = this.handleFunction(node, ctx, parent) ?? parent;
+      } else if (node.type === "enum_item") {
+        currentParent = this.handleEnum(node, ctx, parent) ?? parent;
+      } else if (node.type === "const_item" || node.type === "static_item") {
+        currentParent = this.handleVariable(node, ctx, parent) ?? parent;
+      } else if (node.type === "let_declaration") {
+        this.handleVariable(node, ctx, parent);
+      } else if (node.type === "use_declaration") {
+        this.handleUseDeclaration(node, ctx, parent);
+      } else if (node.type === "macro_definition") {
+        this.handleMacro(node, ctx, parent);
+      } else if (node.type === "mod_item") {
+        currentParent = this.handleMod(node, ctx, parent) ?? parent;
+      } else if (node.type === "attribute_item") {
+        this.handleAttribute(node, ctx);
+      } else if (node.type === "inner_attribute_item") {
+        this.noOwner(ctx, "decorates:inner_attribute");
+      } else if (node.type === "call_expression") {
+        this.handleCallExpression(node, ctx, parent);
+      } else if (node.type === "field_expression") {
+        const field = node.childForFieldName("field");
+        const value = node.childForFieldName("value");
+        const par = node.parent;
+        let isAssignLhs = false;
+        if (par && (par.type === "assignment_expression" || par.type === "compound_assignment_expr")) {
+          const left = par.namedChild(0);
+          if (left && left.startIndex === node.startIndex && left.endIndex === node.endIndex) isAssignLhs = true;
+        }
+        if (!isAssignLhs && field && field.type === "field_identifier" && field.text.trim() && node.parent?.type !== "call_expression") {
+          const source = this.edgeSource(parent);
+          if (!source) {
+            this.noOwner(ctx, "uses:field_expression");
+          } else if (!ctx.emittedUses.has(`${source}::uses::${field.text}`)) {
+            ctx.emittedUses.add(`${source}::uses::${field.text}`);
+            ctx.relationships.push({
+              source,
+              target: field.text,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.9,
+              // M59.A7 (#825): the FIELD identifier's line, not the receiver's —
+              // a `field_expression` starts at its value.
+              ...this.nodeLine(field) ? { line_number: this.nodeLine(field) } : {},
+              metadata: { relationshipType: "field_access", accessedFrom: value?.text }
+            });
+          }
+        }
+      } else if (node.type === "struct_expression") {
+        const typeNode = node.childForFieldName("name") || node.namedChild(0);
+        if (typeNode && (typeNode.type === "type_identifier" || typeNode.type === "scoped_type_identifier")) {
+          let leaf = this.stripGenerics(typeNode.text).split("::").filter(Boolean).pop() ?? typeNode.text;
+          if (leaf === "Self") leaf = this.enclosingImplType(node);
+          const source = leaf ? this.edgeSource(parent) : null;
+          if (leaf && source) {
+            ctx.relationships.push({
+              source,
+              target: leaf,
+              type: ASTEngine.RelationshipType.Instantiates,
+              confidence: 0.8,
+              // M59.A7 (#825): the constructed TYPE's own line.
+              ...this.nodeLine(typeNode) ? { line_number: this.nodeLine(typeNode) } : {},
+              metadata: { relationshipType: "struct_literal", isConstructor: true }
+            });
+          } else if (leaf) {
+            this.noOwner(ctx, "instantiates");
+          }
+        }
+      } else if (node.type === "macro_invocation") {
+        this.handleMacroInvocation(node, ctx, parent);
+      } else if (node.type === "enum_variant") {
+        const variantName = this.extractIdentifier(node, "name");
+        if (variantName && parent && parent.kind === ASTEngine.SymbolKind.Enum) {
+          const sym = this.createSymbol(variantName, ASTEngine.SymbolKind.EnumMember, node, parent);
+          ctx.symbols.push(sym);
+        }
+      } else if (node.type === "type_item" || node.type === "associated_type") {
+        const name = this.extractIdentifier(node, "name");
+        if (name) {
+          const sym = this.createSymbol(name, ASTEngine.SymbolKind.Type, node, parent, { type: "type_alias" });
+          ctx.symbols.push(sym);
+          if (this.isUnrestrictedPublic(node) && !parent) {
+            ctx.exports.push({
+              name,
+              type: ASTEngine.SymbolKind.Type,
+              range: sym.range,
+              isType: true
+            });
+          }
+        }
+      } else if (node.type === "closure_expression") {
+      } else if (node.type === "extern_crate_declaration") {
+        const name = this.extractIdentifier(node, "name");
+        if (name) {
+          ctx.imports.push({
+            module: name,
+            items: ["*"],
+            range: {
+              startLine: node.startPosition.row + 1,
+              startColumn: node.startPosition.column + 1,
+              endLine: node.endPosition.row + 1,
+              endColumn: node.endPosition.column + 1,
+              startIndex: node.startIndex,
+              endIndex: node.endIndex
+            },
+            metadata: { rustSpecific: true, externalCrate: true }
+          });
+        }
+      } else if (node.type === "unsafe_block") {
+        if (!ctx.metadata.patterns) ctx.metadata.patterns = [];
+        if (ctx.metadata.patterns.indexOf("Unsafe Code") === -1) ctx.metadata.patterns.push("Unsafe Code");
+      } else if (node.type === "await_expression") {
+        const inner = node.namedChild(0);
+        if (inner && (inner.type === "call_expression" || inner.type === "macro_invocation")) {
+          ctx.awaitedCalls.add(inner.startIndex);
+        }
+      } else if (node.type === "if_expression" || node.type === "while_expression" || node.type === "loop_expression" || node.type === "for_expression") {
+        if (!ctx.metadata.cyclomaticComplexity) ctx.metadata.cyclomaticComplexity = 1;
+        ctx.metadata.cyclomaticComplexity++;
+      } else if (node.type === "match_arm") {
+        if (!ctx.metadata.cyclomaticComplexity) ctx.metadata.cyclomaticComplexity = 1;
+        ctx.metadata.cyclomaticComplexity++;
+      } else if (node.type === "binary_expression") {
+        const op = node.childForFieldName("operator")?.text;
+        if (op === "&&" || op === "||") {
+          if (!ctx.metadata.cyclomaticComplexity) ctx.metadata.cyclomaticComplexity = 1;
+          ctx.metadata.cyclomaticComplexity++;
+        }
+      } else if (node.type === "try_expression") {
+        if (!ctx.metadata.patterns) ctx.metadata.patterns = [];
+        if (ctx.metadata.patterns.indexOf("Error Propagation (?)") === -1) ctx.metadata.patterns.push("Error Propagation (?)");
+      } else if (node.type === "where_clause") {
+        const genericParams = /* @__PURE__ */ new Set();
+        let gcur = node.parent;
+        while (gcur) {
+          if (gcur.type === "function_item" || gcur.type === "function_signature_item" || gcur.type === "trait_item" || gcur.type === "struct_item" || gcur.type === "enum_item" || gcur.type === "type_item" || gcur.type === "impl_item") {
+            const tp = gcur.childForFieldName("type_parameters");
+            if (tp) {
+              const pw = [tp];
+              while (pw.length > 0) {
+                const m = pw.pop();
+                if (m.type === "type_identifier" || m.type === "identifier") genericParams.add(m.text);
+                for (let k = 0; k < m.namedChildCount; k++) {
+                  const c = m.namedChild(k);
+                  if (c) pw.push(c);
+                }
+              }
+            }
+          }
+          gcur = gcur.parent;
+        }
+        const boundNames = (n) => {
+          if (!n) return [];
+          if (n.type === "scoped_type_identifier" || n.type === "scoped_identifier" || n.type === "qualified_type") {
+            const nm = n.childForFieldName("name");
+            if (nm) return [nm];
+            const last = n.namedChild(n.namedChildCount - 1);
+            return last && (last.type === "type_identifier" || last.type === "identifier") ? [last] : [];
+          }
+          const out = [];
+          const w = [n];
+          while (w.length > 0) {
+            const m = w.pop();
+            if (m.type === "lifetime") continue;
+            if (m.type === "type_identifier") out.push(m);
+            for (let k = m.namedChildCount - 1; k >= 0; k--) {
+              const ch = m.namedChild(k);
+              if (ch) w.push(ch);
+            }
+          }
+          return out;
+        };
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const c = node.namedChild(i);
+          if (!c || c.type !== "where_predicate") continue;
+          const left = c.namedChild(0);
+          for (const leaf of boundNames(left)) {
+            if (!leaf.text || genericParams.has(leaf.text)) continue;
+            const boundSource = this.edgeSource(parent);
+            if (!boundSource) {
+              this.noOwner(ctx, "references");
+              continue;
+            }
+            ctx.relationships.push({
+              source: boundSource,
+              target: leaf.text,
+              type: ASTEngine.RelationshipType.References,
+              // M59.A7 (#825): the bound's own line.
+              ...this.nodeLine(leaf) ? { line_number: this.nodeLine(leaf) } : {},
+              metadata: { rustSpecific: true, whereBound: true }
+            });
+          }
+        }
+      } else if (node.type === "lifetime") {
+        if (!ctx.metadata.patterns) ctx.metadata.patterns = [];
+        if (ctx.metadata.patterns.indexOf("Explicit Lifetimes") === -1) ctx.metadata.patterns.push("Explicit Lifetimes");
+      } else if (node.type === "scoped_type_identifier") {
+        const name = node.childForFieldName("name") || node.namedChild(node.namedChildCount - 1);
+        if (name) {
+          const n = name.text;
+          if (["Send", "Sync", "Sized", "Unpin", "UnwindSafe", "RefUnwindSafe"].includes(n)) {
+            if (!ctx.metadata.patterns) ctx.metadata.patterns = [];
+            if (ctx.metadata.patterns.indexOf("Auto Traits") === -1) ctx.metadata.patterns.push("Auto Traits");
+          }
+        }
+      } else if (node.type === "use_as_clause" || node.type === "scoped_use_list") {
+        if (this.isPublic(node.parent || node) && node.parent?.type === "use_declaration") {
+          if (!ctx.metadata.patterns) ctx.metadata.patterns = [];
+          if (ctx.metadata.patterns.indexOf("Re-exports") === -1) ctx.metadata.patterns.push("Re-exports");
+        }
+      } else if (node.type === "identifier") {
+        this.handleIdentifierRead(node, ctx, parent, valueOwners, useImported, fnBindings);
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) {
+          stack.push({ node: child, parent: currentParent });
+        }
+      }
+    }
+    for (const s of ctx.symbols) {
+      const _owner = s.ownerName || s.scope;
+      if (!_owner) continue;
+      ctx.relationships.push({
+        source: _owner,
+        target: s.name,
+        type: ASTEngine.RelationshipType.Contains,
+        confidence: 1,
+        // M59.A7 (#825): the member's own declaration line.
+        ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+        metadata: {}
+      });
+    }
+    for (const sym of ctx.symbols) {
+      if (sym.qualified_calls && sym.qualified_calls.length > 0) {
+        sym.qualified_calls = [...new Set(sym.qualified_calls)];
+      }
+    }
+    {
+      const inFile = /* @__PURE__ */ new Set();
+      for (const sym of ctx.symbols) {
+        if (sym.kind === ASTEngine.SymbolKind.Struct || sym.kind === ASTEngine.SymbolKind.Enum || sym.kind === ASTEngine.SymbolKind.Type || sym.kind === ASTEngine.SymbolKind.Impl) inFile.add(sym.name);
+      }
+      for (const cand of ctx.pendingInstantiations) {
+        if (!inFile.has(cand.target)) continue;
+        if (cand.bareSpelling && !bareTupleCtorVisible(cand.target, cand.callScope ?? [])) continue;
+        ctx.relationships.push({
+          source: cand.source,
+          target: cand.target,
+          fromSymbol: cand.source,
+          toSymbol: cand.qualified,
+          type: ASTEngine.RelationshipType.Instantiates,
+          confidence: 0.8,
+          // M59.A7 (#825): recorded at the call site (the type that names the
+          // construction), carried through the deferred resolution pass.
+          ...cand.line ? { line_number: cand.line } : {},
+          metadata: { isConstructor: true }
+        });
+      }
+    }
+    ctx.metadata.complexity = ctx.metadata.cyclomaticComplexity ?? 1;
+    ctx.metadata.framework = RUST_FRAMEWORK_PRIORITY.find(
+      (fw) => (ctx.metadata.detectedFrameworks ?? []).includes(fw)
+    );
+    this.extractRustDeclaredTypeRefs(rootNode, ctx);
+    this.emitRustModuleSurface(rootNode, ctx);
+    this.emitRustTraitOverrides(rootNode, ctx);
+    this.publishQualifiedCallTargets(ctx);
+    if (ctx.macroArgumentReads > 0) {
+      ;
+      ctx.metadata.macroArgumentReads = ctx.macroArgumentReads;
+    }
+    if (ctx.unattributed.size > 0) {
+      ;
+      ctx.metadata.unattributedEdges = Object.fromEntries(
+        [...ctx.unattributed.entries()].sort((a, b) => a[0].localeCompare(b[0]))
+      );
+    }
+    this.classifyEvidenceTier(ctx.relationships);
+    return {
+      symbols: ctx.symbols,
+      relationships: ctx.relationships,
+      imports: ctx.imports,
+      exports: ctx.exports,
+      metadata: ctx.metadata
+    };
+  }
+  /** R13: declared-type `references` (see the call site for the contract). */
+  extractRustDeclaredTypeRefs(rootNode, ctx) {
+    const emitted = /* @__PURE__ */ new Set();
+    const genericParamsOf = (item) => {
+      const out = /* @__PURE__ */ new Set();
+      let gcur = item;
+      while (gcur) {
+        if (gcur.type === "function_item" || gcur.type === "trait_item" || gcur.type === "struct_item" || gcur.type === "enum_item" || gcur.type === "type_item" || gcur.type === "impl_item") {
+          const tp = gcur.childForFieldName("type_parameters");
+          if (tp) {
+            const pw = [tp];
+            while (pw.length > 0) {
+              const m = pw.pop();
+              if (m.type === "type_identifier" || m.type === "identifier") out.add(m.text);
+              for (let k = 0; k < m.namedChildCount; k++) {
+                const c = m.namedChild(k);
+                if (c) pw.push(c);
+              }
+            }
+          }
+          break;
+        }
+        gcur = gcur.parent;
+      }
+      return out;
+    };
+    const push = (source, leafNode, gparams) => {
+      if (!source) {
+        this.noOwner(ctx, "references");
+        return;
+      }
+      let target = leafNode.text;
+      if (!target || target === "Self") {
+        const resolved = this.enclosingImplType(leafNode);
+        if (!resolved) return;
+        target = resolved;
+      }
+      if (gparams.has(target)) return;
+      const key = `${source}::references::${target}`;
+      if (emitted.has(key)) return;
+      emitted.add(key);
+      ctx.relationships.push({
+        source,
+        target,
+        type: ASTEngine.RelationshipType.References,
+        confidence: 0.9,
+        // M59.A7 (#825): the leaf that names the type.
+        ...this.nodeLine(leafNode) ? { line_number: this.nodeLine(leafNode) } : {},
+        metadata: { relationshipType: "declared_type" }
+      });
+    };
+    const collectLeaves = (typeNode) => {
+      const out = [];
+      if (!typeNode) return out;
+      const w = [typeNode];
+      while (w.length > 0) {
+        const m = w.pop();
+        if (m !== typeNode && (m.type === "where_clause" || m.type === "type_parameters")) continue;
+        if (m.type === "type_identifier") out.push(m);
+        for (let i = m.namedChildCount - 1; i >= 0; i--) {
+          const c = m.namedChild(i);
+          if (c) w.push(c);
+        }
+      }
+      return out;
+    };
+    const walk = [rootNode];
+    while (walk.length > 0) {
+      const n = walk.pop();
+      const t = n.type;
+      if (t === "macro_definition") continue;
+      if (t === "function_item") {
+        const src = this.extractIdentifier(n, "name") ?? this.noOwner(ctx, "references");
+        const gparams = genericParamsOf(n);
+        const params = n.childForFieldName("parameters");
+        if (params) {
+          for (let i = 0; i < params.namedChildCount; i++) {
+            const p = params.namedChild(i);
+            if (!p) continue;
+            if (p.type === "self_parameter") continue;
+            const ty = p.type === "parameter" ? p.childForFieldName("type") : null;
+            for (const leaf of collectLeaves(ty)) push(src, leaf, gparams);
+          }
+        }
+        const ret = n.childForFieldName("return_type");
+        for (const leaf of collectLeaves(ret)) push(src, leaf, gparams);
+      } else if (t === "struct_item" || t === "union_item") {
+        const src = this.extractIdentifier(n, "name") ?? this.noOwner(ctx, "references");
+        const gparams = genericParamsOf(n);
+        const fw = [n];
+        while (fw.length > 0) {
+          const m = fw.pop();
+          if (m !== n && (m.type === "where_clause" || m.type === "type_parameters")) continue;
+          if (m.type === "field_declaration") {
+            for (let i = 0; i < m.namedChildCount; i++) {
+              const c = m.namedChild(i);
+              if (c && c.type !== "field_identifier" && c.type !== "visibility_modifier" && c.type !== "attribute_item") {
+                for (const leaf of collectLeaves(c)) push(src, leaf, gparams);
+              }
+            }
+            continue;
+          }
+          if (m.type === "ordered_field_declaration_list") {
+            for (let i = 0; i < m.namedChildCount; i++) {
+              const c = m.namedChild(i);
+              if (c) for (const leaf of collectLeaves(c)) push(src, leaf, gparams);
+            }
+            continue;
+          }
+          for (let i = m.namedChildCount - 1; i >= 0; i--) {
+            const c = m.namedChild(i);
+            if (c) fw.push(c);
+          }
+        }
+      } else if (t === "enum_item") {
+        const src = this.extractIdentifier(n, "name") ?? this.noOwner(ctx, "references");
+        const gparams = genericParamsOf(n);
+        const ew = [n];
+        while (ew.length > 0) {
+          const m = ew.pop();
+          if (m !== n && (m.type === "where_clause" || m.type === "type_parameters")) continue;
+          if (m.type === "field_declaration") {
+            for (let i = 0; i < m.namedChildCount; i++) {
+              const c = m.namedChild(i);
+              if (c && c.type !== "field_identifier" && c.type !== "visibility_modifier" && c.type !== "attribute_item") {
+                for (const leaf of collectLeaves(c)) push(src, leaf, gparams);
+              }
+            }
+            continue;
+          }
+          if (m.type === "ordered_field_declaration_list") {
+            for (let i = 0; i < m.namedChildCount; i++) {
+              const c = m.namedChild(i);
+              if (c) for (const leaf of collectLeaves(c)) push(src, leaf, gparams);
+            }
+            continue;
+          }
+          for (let i = m.namedChildCount - 1; i >= 0; i--) {
+            const c = m.namedChild(i);
+            if (c) ew.push(c);
+          }
+        }
+      } else if (t === "type_item" || t === "associated_type") {
+        const src = this.extractIdentifier(n, "name") ?? this.noOwner(ctx, "references");
+        const gparams = genericParamsOf(n);
+        const nameNode = n.childForFieldName("name") ?? n.namedChild(0);
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const c = n.namedChild(i);
+          if (!c || c.type === "type_parameters" || c.type === "where_clause") continue;
+          if (nameNode && c.startIndex === nameNode.startIndex && c.endIndex === nameNode.endIndex) continue;
+          for (const leaf of collectLeaves(c)) push(src, leaf, gparams);
+          break;
+        }
+      } else if (t === "const_item" || t === "static_item") {
+        const nm = n.childForFieldName("name")?.text;
+        if (nm && nm !== "_") {
+          const ty = n.childForFieldName("type");
+          const gparams = genericParamsOf(n);
+          for (const leaf of collectLeaves(ty)) push(nm, leaf, gparams);
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) walk.push(c);
+      }
+    }
+  }
+  /**
+   * INCOMING_RUST — the MODULE SURFACE: `imports` from `use` declarations and
+   * `exports` from the `pub` surface.
+   *
+   * ## Why both, and why they were missing
+   *
+   * The lane measured 0 `imports` edges and 0 `exports` edges over 110 real
+   * `.rs` files of ripgrep through the production entry, and the two are the
+   * edges an INBOUND query is made of: "who imports this module" and "what does
+   * this module publish". Rust states both explicitly — `use a::b::C;` and
+   * `pub fn f` — and this analyzer was already reading both nodes. It recorded
+   * them as an `ImportInfo` row and an `ExportInfo` row and stopped there, so
+   * `bb_graph`'s file-level reader (`src/lsp/graph_usages.ts` filters
+   * `relationship_type IN ('imports','exports')`) could not see either. The
+   * information existed; nothing joined on it.
+   *
+   * The doc's "no references edge (Java-family contract)" rule stays true and is
+   * why these are their own KIND: a module path is not a symbol name, and putting
+   * `std::io` in a `references` target is the c/#924 defect (a target no
+   * declaration can match). `imports` is the family's label for a dependency.
+   *
+   * ## `imports` — one edge per MODULE PATH
+   *
+   * Target is the path the `use` writes, verbatim: `std::io`, `crate::flags`,
+   * `super::util`, `grep_matcher::Matcher`, `::libc::c_int`. That is a real,
+   * stable Rust path — the same string the compiler resolves — not a leaf, not a
+   * file name, and not a guess. A brace group's PREFIX is the module
+   * (`use std::io::{Read, Write}` → `std::io`) because that is what the group is
+   * a use OF; the leaves are bindings, and a binding is the `exports`/`contains`
+   * surface of wherever it lives, not a dependency edge.
+   *
+   * Source is the enclosing inline module, or `global` at file scope — the same
+   * convention every other rust edge in this analyzer already uses, so an
+   * `imports` row joins with the rest of the file's graph on the same source.
+   *
+   * ## `exports` — one edge per PUBLISHED NAME
+   *
+   * Target is a name this file's own symbol table publishes. The gate is
+   * `publishedNames.has(name)`, not "the export list is non-empty": an export row
+   * whose name is a path prefix (`pub use storage::MemoryStorage` records
+   * `storage`) is a PATH and cannot be a target, and `pub use` of a foreign item
+   * names something this file does not declare. Those are refused rather than
+   * published, which is R7/R10: an unresolvable endpoint is a lie the graph
+   * tells. Re-exported ITEM names are published instead, because the item name is
+   * what a consumer of this module can actually import.
+   *
+   * The one pre-existing `exports` edge — an axum/actix route attribute naming a
+   * URL — is untouched, and is still not counted here: its target is a route, not
+   * a symbol.
+   */
+  emitRustModuleSurface(rootNode, ctx) {
+    const importableUnits = /* @__PURE__ */ new Set();
+    for (const s of ctx.symbols) if (s.name && !s.ownerName) importableUnits.add(s.name);
+    const importRowByKey = /* @__PURE__ */ new Map();
+    const seenExports = /* @__PURE__ */ new Set();
+    const pushedExportNames = new Set(ctx.exports.map((e) => e.name));
+    const publishExport = (source, name, line, kind, symbolKind, allowForeignName = false) => {
+      if (!name || !allowForeignName && !importableUnits.has(name)) return;
+      const key = `${source}::exports::${name}`;
+      if (seenExports.has(key)) return;
+      seenExports.add(key);
+      ctx.relationships.push({
+        source,
+        target: name,
+        fromSymbol: source,
+        toSymbol: name,
+        type: ASTEngine.RelationshipType.Exports,
+        confidence: 1,
+        ...line ? { line_number: line } : {},
+        metadata: {
+          rustSpecific: true,
+          relationshipType: kind,
+          symbolKind,
+          // R7 / M60 #910: an export is published BY the module, so a file-scope
+          // export names the FILE as its source. Without this the store wrote
+          // `source_external = "global"` and the row was unreachable from the
+          // one reader that displays file-level exports.
+          ...source === RUST_FILE_SOURCE ? { fileLevel: true } : {}
+        }
+      });
+    };
+    const walk = [rootNode];
+    while (walk.length > 0) {
+      const n = walk.pop();
+      if (n.type === "use_declaration") {
+        const mods = this.enclosingMods(n);
+        const scope = (() => {
+          let cur = n.parent ?? null;
+          let guard = 0;
+          while (cur && guard++ < 64) {
+            if (cur.type === "function_item") {
+              const fnName = cur.childForFieldName?.("name");
+              return { kind: "function", name: fnName ? String(fnName.text) : RUST_FILE_SOURCE };
+            }
+            if (cur.type === "mod_item") {
+              const modName = cur.childForFieldName?.("name") ?? cur.namedChild(0);
+              return { kind: "module", name: modName ? String(modName.text) : RUST_FILE_SOURCE };
+            }
+            cur = cur.parent;
+          }
+          return { kind: "file", name: RUST_FILE_SOURCE };
+        })();
+        const atFileScope = mods.length === 0;
+        const source = scope.name;
+        const isPublic = this.isUnrestrictedPublic(n);
+        const exportSource = isPublic && atFileScope ? RUST_FILE_SOURCE : null;
+        for (const row of this.rustImportRows(n)) {
+          const key = `${source}::imports::${row.module}`;
+          const reExports = exportSource ? row.items.filter((x) => !!x && x !== "*") : [];
+          if (exportSource) {
+            for (const item of reExports) {
+              publishExport(exportSource, item, row.line, "re_export", "symbol", true);
+              if (importableUnits.has(item) && !pushedExportNames.has(item)) {
+                pushedExportNames.add(item);
+                ctx.exports.push({
+                  name: item,
+                  type: ASTEngine.SymbolKind.Module,
+                  range: {
+                    startLine: n.startPosition.row + 1,
+                    startColumn: n.startPosition.column + 1,
+                    endLine: n.endPosition.row + 1,
+                    endColumn: n.endPosition.column + 1,
+                    startIndex: n.startIndex,
+                    endIndex: n.endIndex
+                  },
+                  isType: false
+                });
+              }
+            }
+          }
+          const existing = importRowByKey.get(key);
+          if (existing) {
+            if (reExports.length > 0) {
+              const md = existing.metadata ?? {};
+              md.reExports = [.../* @__PURE__ */ new Set([...Array.isArray(md.reExports) ? md.reExports : [], ...reExports])];
+              existing.metadata = md;
+            }
+            continue;
+          }
+          const moduleFiles = ctx.projectRoot.length > 0 && path.isAbsolute(ctx.filePath) ? rustModuleFileCandidates(row.module, ctx.filePath, ctx.projectRoot, atFileScope) : null;
+          const projectFile = moduleFiles === null ? null : confirmModuleFile(moduleFiles, ctx.projectRoot);
+          importRowByKey.set(key, {
+            source,
+            target: row.module,
+            fromSymbol: source,
+            toSymbol: row.module,
+            type: ASTEngine.RelationshipType.Imports,
+            confidence: 1,
+            ...row.line ? { line_number: row.line } : {},
+            metadata: {
+              rustSpecific: true,
+              isImport: true,
+              // RUST-D31 declared scope contract (file / module / function) — the fixture pins all three.
+              importScope: scope.kind,
+              evidenceClass: "import_based",
+              relationshipType: "use_import",
+              modulePath: row.module,
+              moduleKind: row.kind,
+              // R7 / M60 #910: the source of a FILE-SCOPE dependency is the IMPORTING FILE, and this
+              // flag is what makes the store write the project-relative path. It keys on the DECLARED
+              // scope, not on "no inline mod": a function-local `use` is sourced at the function, so
+              // it must not be rewritten as a file-level edge.
+              ...scope.kind === "file" ? { fileLevel: true } : {},
+              // The names the declaration brings into scope. Carried, not
+              // emitted as edges: a binding is not a dependency, and the same
+              // binding is re-declared by every file that imports it.
+              items: row.items,
+              ...reExports.length > 0 ? { reExports } : {},
+              // THE ARBITER'S FILE CLAIM (`FILE_CLAIM_KEY` in script/m14/incoming-rule.ts).
+              // A project-relative POSIX path the project's own admitted list can CONFIRM; the
+              // claim is never written unconfirmed, which is what keeps extFAIL at 0. Not a
+              // declaration claim: it says the module this path names is a file this project
+              // has, and it is the right terminal state for an import whose declaring file is
+              // outside the run's population (the 400-file sample, or a build target).
+              ...projectFile !== null ? { importProjectFile: projectFile } : {},
+              // THE NAMESPACE CLAIM (`NAMESPACE_CLAIM_KEY`), emitted only where the file claim did
+              // NOT fire: a path rooted at a system crate names no project file, and before the
+              // `::` separator landed in the arbiter's matcher this class was unclaimable. The
+              // authority is the analyzer's own declared-root list above, so a root the list does
+              // not name reads `externalRefuted` — the pre-registered falsifier is any extFAIL
+              // here, which is why the list is three literals and not a pattern.
+              ...projectFile === null && rustSystemNamespaceOf(row.module) !== null ? { languageNamespace: [rustSystemNamespaceOf(row.module)] } : {}
+            }
+          });
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) walk.push(c);
+      }
+    }
+    for (const row of importRowByKey.values()) ctx.relationships.push(row);
+    for (const e of ctx.exports) {
+      publishExport(RUST_FILE_SOURCE, e.name, e.range?.startLine, "public_item", String(e.type ?? ""));
+    }
+  }
+  /**
+   * The `use` declarations of one `use_declaration` node, as
+   * (dependency path, bound names, 1-based line, form) rows.
+   *
+   * Shares no state with `handleUseDeclaration`'s ImportInfo assembly on
+   * purpose: that one answers "what does the index store per BINDING" (a row
+   * per name, module = the prefix), this one answers "what module does this file
+   * DEPEND ON" (a row per PATH, and the leaf is a binding rather than a
+   * dependency). The two therefore disagree about `use std::collections::HashMap`
+   * — one row there, one dependency here — and they must: a binding is
+   * re-declared by every importer, so a binding is not a dependency.
+   *
+   * A path's LEAF is never the dependency. `use crate::flags::Flag` depends on
+   * `crate::flags`; `use serde;` depends on `serde` (a one-segment path is
+   * itself the dependency, and it binds its own name).
+   */
+  rustImportRows(node) {
+    const out = [];
+    const pathOf = (n) => {
+      if (!n) return null;
+      if (n.type === "identifier" || n.type === "type_identifier") return n.text;
+      if (n.type === "crate" || n.type === "super" || n.type === "self") return n.text;
+      if (n.type === "scoped_identifier") {
+        const p = n.childForFieldName("path");
+        const name = n.childForFieldName("name") || n.namedChild(n.namedChildCount - 1);
+        if (p) {
+          const base = pathOf(p);
+          if (base === null) return null;
+          return `${base}::${name ? name.text : ""}`;
+        }
+        return `${n.text.startsWith("::") ? "::" : ""}${name ? name.text : ""}`;
+      }
+      return null;
+    };
+    const splitLeaf = (full) => {
+      const parts = full.split("::");
+      if (parts.length < 2) return { module: full, item: full };
+      const prefix = parts.slice(0, -1).join("::");
+      const item = parts[parts.length - 1];
+      if (prefix === "super" || prefix === "crate" || prefix === "self") {
+        return { module: full, item };
+      }
+      return { module: prefix, item };
+    };
+    const pushLeafPath = (full, alias, at, kind) => {
+      if (!full) return;
+      const { module, item } = splitLeaf(full);
+      if (!module) return;
+      out.push({ module, items: [alias ?? item], line: this.nodeLine(at), kind });
+    };
+    const groupLeaves = (list, base) => {
+      const items = [];
+      if (!list || list.type !== "use_list") return items;
+      for (let j = 0; j < list.namedChildCount; j++) {
+        const leaf = list.namedChild(j);
+        if (!leaf || leaf.type === ",") continue;
+        if (leaf.type === "use_as_clause") {
+          const al = leaf.childForFieldName("alias") || leaf.namedChild(leaf.namedChildCount - 1);
+          if (al) items.push(al.text);
+        } else if (leaf.type === "identifier" || leaf.type === "type_identifier") {
+          items.push(leaf.text);
+        } else if (leaf.type === "self") {
+          const last = base.split("::").filter(Boolean).pop();
+          if (last) items.push(last);
+        } else if (leaf.type === "scoped_identifier") {
+          const inner = pathOf(leaf);
+          if (inner) {
+            const { module, item } = splitLeaf(inner);
+            items.push(item);
+            if (module && module !== base) {
+              out.push({ module: `${base}::${module}`, items: [], line: this.nodeLine(leaf), kind: "nested_group" });
+            }
+          }
+        } else if (leaf.type === "scoped_use_list") {
+          const innerBase = pathOf(leaf.namedChild(0));
+          if (innerBase) {
+            for (const it of groupLeaves(leaf.namedChild(1), innerBase)) items.push(it);
+            if (innerBase !== base) {
+              out.push({ module: innerBase, items: [], line: this.nodeLine(leaf), kind: "nested_group" });
+            }
+          }
+        }
+      }
+      return items;
+    };
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c || c.type === "visibility_modifier" || c.type === "use" || c.type === "crate") continue;
+      if (c.type === "scoped_use_list") {
+        const base = pathOf(c.namedChild(0));
+        if (base) out.push({ module: base, items: groupLeaves(c.namedChild(1), base), line: this.nodeLine(c), kind: "group" });
+        continue;
+      }
+      if (c.type === "use_list") {
+        for (let j = 0; j < c.namedChildCount; j++) {
+          const leaf = c.namedChild(j);
+          if (!leaf || leaf.type === ",") continue;
+          if (leaf.type === "scoped_use_list") {
+            const base = pathOf(leaf.namedChild(0));
+            if (base) out.push({ module: base, items: groupLeaves(leaf.namedChild(1), base), line: this.nodeLine(leaf), kind: "top_level_group" });
+            continue;
+          }
+          if (leaf.type === "use_as_clause") {
+            pushLeafPath(pathOf(leaf.childForFieldName("path") || leaf.namedChild(0)), leaf.childForFieldName("alias")?.text ?? null, leaf, "top_level_group");
+            continue;
+          }
+          pushLeafPath(pathOf(leaf), null, leaf, "top_level_group");
+        }
+        continue;
+      }
+      if (c.type === "use_wildcard") {
+        const base = pathOf(c.namedChild(0));
+        if (base) out.push({ module: base, items: ["*"], line: this.nodeLine(c), kind: "wildcard" });
+        continue;
+      }
+      if (c.type === "use_as_clause") {
+        pushLeafPath(pathOf(c.childForFieldName("path") || c.namedChild(0)), c.childForFieldName("alias")?.text ?? null, c, "alias");
+        continue;
+      }
+      pushLeafPath(pathOf(c), null, c, "path");
+    }
+    return out;
+  }
+  /**
+   * INCOMING_RUST — `overrides`.
+   *
+   * ## What the language has, and what it does not
+   *
+   * Rust has no `override` keyword. Its override is the trait implementation:
+   * `impl Display for Foo { fn fmt(&self, …) }` REPLACES `Display::fmt` for the
+   * type `Foo`, and the author's writing of both the trait and the method is the
+   * assertion — there is nothing to infer. Measured on this lane's corpus
+   * (110 ripgrep files): 252 `implements` edges over 44 files, so the construct
+   * is not rare, and the previous ruling ("Rust trait impls are captured as
+   * `implements`") was a prose justification for a type the language expresses —
+   * which is the exact failure the ontology gate was built to catch.
+   *
+   * What Rust does NOT have is a second declaration replacing a first. A second
+   * `impl Foo { }` block RE-OPENS the type; it cannot redefine a method (E0592,
+   * duplicate definitions with the same name), so no such edge is derivable and
+   * none is emitted. The corpus found 107 such re-opens across 40 files, which
+   * is the measurement behind that half of the ruling.
+   *
+   * ## Endpoints, and why they are dotted
+   *
+   * `Type.method` → `Trait.method`, the shape java, go and csharp already use,
+   * for one reason that is not cosmetic: `parallel-indexer` resolves a relationship
+   * target by (1) exact `qualified_name`, (2) a bare `name` that is UNIQUE across
+   * the project, (3) everything after the first `.` of a dotted target. This
+   * analyzer publishes no `qualifiedName`, so every rust symbol's stored
+   * `qualified_name` IS its bare name and a bare target can only resolve while it
+   * is project-unique — which for a member name it almost never is. A dotted
+   * target takes strategy 3. A bare `method` target would name the right method
+   * and still not say WHICH type's, so the qualification is what makes the edge
+   * answerable for an incoming query ("who overrides `Trait::method`").
+   *
+   * ## Confidence: two tiers, and the split is the point
+   *
+   *   1.0  `local-trait-signature` — the trait is DECLARED IN THIS FILE, so both
+   *        ends are facts read out of this file's own items.
+   *   0.85 `cross-file-trait-signature` — the trait is not declared here. The
+   *        edge is still what the source says (`impl Display for Foo` + `fn
+   *        fmt`), so it is not a guess, but the target resolves only once the
+   *        whole project is indexed, and it is below the `patterns.ts` default
+   *        threshold, so a thresholded consumer never treats it as ground truth.
+   *
+   * `Drop::drop` is included: `impl Drop for Foo { fn drop(&mut self) }` is
+   * Rust's most common override and a reader asking "who overrides drop" wants
+   * the answer.
+   */
+  emitRustTraitOverrides(rootNode, ctx) {
+    const localTraitMethods = /* @__PURE__ */ new Map();
+    const impls = [];
+    const seen = /* @__PURE__ */ new Set();
+    const walk = [rootNode];
+    while (walk.length > 0) {
+      const n = walk.pop();
+      if (n.type === "trait_item") {
+        const nm = n.childForFieldName("name")?.text;
+        if (nm) {
+          const ms = /* @__PURE__ */ new Set();
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c?.type !== "declaration_list") continue;
+            for (let j = 0; j < c.namedChildCount; j++) {
+              const f = c.namedChild(j);
+              if (f?.type === "function_signature_item" || f?.type === "function_item") {
+                const mn = f.childForFieldName("name")?.text;
+                if (mn) ms.add(mn);
+              }
+            }
+          }
+          localTraitMethods.set(nm, ms);
+        }
+      } else if (n.type === "impl_item") {
+        const traitNode = n.childForFieldName("trait");
+        const typeNode = n.childForFieldName("type");
+        if (!traitNode || !typeNode) {
+        } else {
+          const typeName = this.implSelfTypeName(typeNode);
+          const traitName = this.extractTraitName(traitNode);
+          if (typeName && traitName) {
+            const ms = /* @__PURE__ */ new Set();
+            for (let i = 0; i < n.namedChildCount; i++) {
+              const c = n.namedChild(i);
+              if (c?.type !== "declaration_list") continue;
+              for (let j = 0; j < c.namedChildCount; j++) {
+                const f = c.namedChild(j);
+                if (f?.type === "function_item") {
+                  const mn = f.childForFieldName("name")?.text;
+                  if (mn) ms.add(mn);
+                }
+              }
+            }
+            impls.push({ type: typeName, trait: traitName, methods: ms, node: n });
+          }
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) walk.push(c);
+      }
+    }
+    const genericParamsOfImpl = (implNode) => {
+      const out = /* @__PURE__ */ new Set();
+      for (let i = 0; i < implNode.namedChildCount; i++) {
+        const tp = implNode.namedChild(i);
+        if (!tp || tp.type !== "type_parameters") continue;
+        const stack2 = [tp];
+        while (stack2.length > 0) {
+          const n = stack2.pop();
+          if (n.type === "type_parameter") {
+            const id = n.namedChild(0);
+            if (id && (id.type === "type_identifier" || id.type === "identifier")) out.add(String(id.text));
+          }
+          for (let j = 0; j < n.namedChildCount; j++) {
+            const c = n.namedChild(j);
+            if (c) stack2.push(c);
+          }
+        }
+      }
+      return out;
+    };
+    for (const impl of impls) {
+      const genericParams = genericParamsOfImpl(impl.node);
+      if (genericParams.has(impl.type)) continue;
+      for (const m of impl.methods) {
+        const declared = localTraitMethods.get(impl.trait);
+        if (declared && !declared.has(m)) continue;
+        const key = `${impl.type}.${m}::${impl.trait}.${m}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const local = !!declared;
+        const line = this.overrideLine(rootNode, impl.type, impl.trait, m);
+        ctx.relationships.push({
+          source: `${impl.type}.${m}`,
+          // THE TARGET IS THE MEMBER NAME, NOT `Owner.member`: the resolver binds against
+          // DECLARATIONS, and a declaration is named by its leaf. Measured: 100% of this lane's
+          // overrides targets are dotted, 100% have their leaf declared in the edge's own file, and
+          // 100% classify unresolved — a naming problem, not a mechanism problem. `localEdgeName`
+          // derives the leaf AFTER the paren deletion `localEdgeLabel` performs, so a dotted
+          // parameter list cannot be cut into a non-name (see its doc).
+          target: m,
+          type: ASTEngine.RelationshipType.Overrides,
+          confidence: local ? 1 : 0.85,
+          ...line ? { line_number: line } : {},
+          metadata: {
+            rustSpecific: true,
+            relationshipType: "trait_method_impl",
+            reasonCode: local ? "local-trait-signature" : "cross-file-trait-signature",
+            implementsType: impl.type,
+            trait: impl.trait,
+            method: m
+          }
+        });
+      }
+    }
+  }
+  /** The line of the overriding method, found by re-walking to the same impl. */
+  overrideLine(rootNode, type, trait, method) {
+    const walk = [rootNode];
+    while (walk.length > 0) {
+      const n = walk.pop();
+      if (n.type === "impl_item") {
+        const traitNode = n.childForFieldName("trait");
+        const typeNode = n.childForFieldName("type");
+        if (traitNode && typeNode && this.implSelfTypeName(typeNode) === type && this.extractTraitName(traitNode) === trait) {
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c?.type !== "declaration_list") continue;
+            for (let j = 0; j < c.namedChildCount; j++) {
+              const f = c.namedChild(j);
+              if (f?.type === "function_item" && f.childForFieldName("name")?.text === method) {
+                return this.nodeLine(f.childForFieldName("name"));
+              }
+            }
+          }
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) walk.push(c);
+      }
+    }
+    return void 0;
+  }
+  /** #419-D evidence-tier classification (family rules). */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.evidenceClass) continue;
+      const t = String(r.type ?? "");
+      const conf = typeof r.confidence === "number" ? r.confidence : 1;
+      if (t === "contains" || t === "exports") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = md.whereBound ? "reference_qualified" : "import_based";
+        continue;
+      }
+      if (t === "imports") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "extends" || t === "implements" || t === "overrides") {
+        md.evidenceClass = conf >= 1 ? "structural" : conf >= 0.85 ? "usage_contextual" : "inferred";
+        continue;
+      }
+      if (t === "instantiates") {
+        md.evidenceClass = conf >= 0.8 && md.isConstructor ? "usage_contextual" : "structural";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  handleAttribute(node, ctx) {
+    const text = node.text;
+    {
+      const decorated = (() => {
+        let sib = node.nextSibling;
+        while (sib) {
+          const st = String(sib.type);
+          if (st === "line_comment" || st === "block_comment" || st === "attribute_item") {
+            sib = sib.nextSibling;
+            continue;
+          }
+          break;
+        }
+        return sib;
+      })();
+      if (decorated) {
+        const declName = decorated.childForFieldName?.("name") ?? (() => {
+          for (let k = 0; k < decorated.namedChildCount; k++) {
+            const c = decorated.namedChild(k);
+            const ct = String(c?.type ?? "");
+            if (ct === "type_identifier" || ct === "identifier") return c;
+          }
+          return null;
+        })();
+        if (!declName || !declName.text || declName.text.length === 0) {
+          this.noOwner(ctx, "decorates:unnamed_declaration");
+        } else {
+          const attr = node.namedChild(0);
+          const nameNode = attr ? attr.childForFieldName?.("path") ?? attr.namedChild(0) : null;
+          const attrName = nameNode ? String(nameNode.text) : "";
+          if (attrName.length === 0) {
+            this.noOwner(ctx, "decorates:attribute_without_name");
+          } else {
+            const BUILTIN = /* @__PURE__ */ new Set([
+              "derive",
+              "allow",
+              "deny",
+              "warn",
+              "cfg",
+              "cfg_attr",
+              "inline",
+              "test",
+              "repr",
+              "doc",
+              "path",
+              "no_mangle",
+              "cold",
+              "deprecated",
+              "must_use",
+              "feature",
+              "macro_use",
+              "macro_export",
+              "should_panic",
+              "ignore",
+              "bench",
+              "global_allocator",
+              "windows_sdk",
+              "no_std",
+              "panic_handler",
+              "proc_macro",
+              "proc_macro_derive",
+              "proc_macro_attribute"
+            ]);
+            const qualified = attrName.includes("::");
+            const kind = BUILTIN.has(attrName) ? "builtin_directive" : "applied_callable_candidate";
+            ctx.relationships.push({
+              source: String(declName.text),
+              target: attrName,
+              fromSymbol: String(declName.text),
+              toSymbol: `attribute:${attrName}`,
+              type: ASTEngine.RelationshipType.Decorates,
+              // Both endpoints are read from the tree — the declaration's name node and the
+              // attribute's own name node — and the sibling relation is structural, so 1.0.
+              confidence: 1,
+              ...this.nodeLine(nameNode) ? { line_number: this.nodeLine(nameNode) } : {},
+              metadata: {
+                attributeKind: kind,
+                isQualifiedPath: qualified,
+                rustSpecific: true,
+                decoratesDeclaration: String(decorated.type)
+              }
+            });
+          }
+        }
+      } else {
+        this.noOwner(ctx, "decorates:no_declaration_sibling");
+      }
+    }
+    const detectFw = (name) => {
+      if (!ctx.metadata.detectedFrameworks?.includes(name)) {
+        ctx.metadata.detectedFrameworks = [...ctx.metadata.detectedFrameworks || [], name];
+      }
+    };
+    {
+      const decoratedMix = (() => {
+        let sib = node.nextSibling;
+        while (sib) {
+          const st = String(sib.type);
+          if (st === "line_comment" || st === "block_comment" || st === "attribute_item") {
+            sib = sib.nextSibling;
+            continue;
+          }
+          break;
+        }
+        return sib;
+      })();
+      const attrOuterMix = node.namedChild(0);
+      const attrNameMix = attrOuterMix ? attrOuterMix.childForFieldName?.("path") ?? attrOuterMix.namedChild(0) : null;
+      if (decoratedMix && attrNameMix && String(attrNameMix.text) === "derive") {
+        const declNameMix = decoratedMix.childForFieldName?.("name") ?? (() => {
+          for (let k = 0; k < decoratedMix.namedChildCount; k++) {
+            const c = decoratedMix.namedChild(k);
+            const ct = String(c?.type ?? "");
+            if (ct === "type_identifier" || ct === "identifier") return c;
+          }
+          return null;
+        })();
+        if (declNameMix && declNameMix.text) {
+          const ttMix = attrOuterMix ? attrOuterMix.childForFieldName?.("arguments") ?? attrOuterMix.namedChild(1) : null;
+          if (ttMix) {
+            const seenMix = /* @__PURE__ */ new Set();
+            const args = [];
+            for (let k = 0; k < ttMix.childCount; k++) {
+              const c = ttMix.child(k);
+              if (!c) continue;
+              const isIdent = String(c.type) === "identifier";
+              args.push({ text: String(c.text), isIdent, node: c });
+            }
+            let k2 = 0;
+            while (k2 < args.length) {
+              if (!args[k2].isIdent) {
+                k2++;
+                continue;
+              }
+              let pathEnd = k2;
+              while (pathEnd + 2 < args.length && args[pathEnd + 1].text === "::" && args[pathEnd + 2].isIdent) pathEnd += 2;
+              const traitName = args[pathEnd].text;
+              const lineNode = args[pathEnd].node;
+              if (traitName.length > 0 && !seenMix.has(traitName)) {
+                seenMix.add(traitName);
+                ctx.relationships.push({
+                  source: String(declNameMix.text),
+                  target: traitName,
+                  fromSymbol: String(declNameMix.text),
+                  toSymbol: `derive:${traitName}`,
+                  type: ASTEngine.RelationshipType.MixesIn,
+                  // The trait name and the declaration name are both tree-read nodes, and the
+                  // derive args are structural children of the attribute — 1.0.
+                  confidence: 1,
+                  ...this.nodeLine(lineNode) ? { line_number: this.nodeLine(lineNode) } : {},
+                  metadata: {
+                    isMixin: true,
+                    deriveComposition: true,
+                    rustSpecific: true,
+                    decoratesDeclaration: String(decoratedMix.type)
+                  }
+                });
+              }
+              k2 = pathEnd + 1;
+            }
+            if (seenMix.size === 0) this.noOwner(ctx, "mixes_in:derive_no_traits");
+          }
+        }
+      }
+    }
+    if (text.startsWith("#[")) {
+      const dStart = text.indexOf("derive(");
+      if (dStart >= 0) {
+        const body = text.slice(dStart + 7);
+        if (hasBareWord(body, "Serialize") || hasBareWord(body, "Deserialize")) detectFw("serde");
+        if (hasBareWord(body, "Parser") || hasBareWord(body, "Subcommand") || hasBareWord(body, "Args") || hasBareWord(body, "ValueEnum")) detectFw("clap");
+        if (text.includes("thiserror")) detectFw("thiserror");
+      }
+      if (text.includes("tokio::main") || text.includes("tokio::test") || text.includes("tokio::flavor")) detectFw("tokio");
+      if (text.includes("axum::")) detectFw("axum");
+      if (text.includes("rocket::")) detectFw("rocket");
+      if (text.includes("tracing::instrument")) detectFw("tracing");
+      if (text.includes("derive(Parser")) detectFw("clap");
+    }
+    if (routeVerbOf(text)) {
+      detectFw("actix_web");
+      let existing = void 0;
+      if (ctx.metadata.frameworkPatterns) {
+        for (let i = 0; i < ctx.metadata.frameworkPatterns.length; i++) {
+          if (ctx.metadata.frameworkPatterns[i].framework === "Actix Web") {
+            existing = ctx.metadata.frameworkPatterns[i];
+            break;
+          }
+        }
+      }
+      if (!existing) {
+        ctx.metadata.frameworkPatterns = [
+          ...ctx.metadata.frameworkPatterns || [],
+          { framework: "Actix Web", patterns: ["route_handlers"] }
+        ];
+      }
+      let targetNode = node.parent;
+      if (targetNode?.type === "source_file" || targetNode?.type === "declaration_list") {
+        targetNode = node.nextNamedSibling;
+      }
+      if (targetNode && targetNode.type === "function_item") {
+        const nameNode = targetNode.childForFieldName("name");
+        if (nameNode) {
+          const routePath = extractRoutePath(text);
+          if (routePath) {
+            ctx.relationships.push({
+              source: nameNode.text,
+              target: routePath,
+              type: ASTEngine.RelationshipType.Exports,
+              // M59.A7 (#825): the function that carries the attribute.
+              ...this.nodeLine(nameNode) ? { line_number: this.nodeLine(nameNode) } : {},
+              metadata: {}
+            });
+          }
+        }
+      }
+    }
+    if (text.includes("#[test]") || text.includes("#[cfg(test)") || text.includes("#[tokio::test")) {
+      if (!ctx.metadata.patterns) ctx.metadata.patterns = [];
+      if (ctx.metadata.patterns.indexOf("Testing") === -1) ctx.metadata.patterns.push("Testing");
+    }
+    if (text.includes("derive")) {
+      if (!ctx.metadata.patterns) ctx.metadata.patterns = [];
+      if (ctx.metadata.patterns.indexOf("Derive Macros") === -1) ctx.metadata.patterns.push("Derive Macros");
+    }
+    if (text.includes("must_use")) {
+      if (!ctx.metadata.patterns) ctx.metadata.patterns = [];
+      if (ctx.metadata.patterns.indexOf("Must Use") === -1) ctx.metadata.patterns.push("Must Use");
+    }
+    if (text.includes("deprecated")) {
+      if (!ctx.metadata.patterns) ctx.metadata.patterns = [];
+      if (ctx.metadata.patterns.indexOf("Deprecated API") === -1) ctx.metadata.patterns.push("Deprecated API");
+    }
+  }
+  extractIdentifier(node, field) {
+    const child = node.childForFieldName(field);
+    if (child) return child.text;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && (c.type === "identifier" || c.type === "type_identifier" || c.type === "scoped_identifier")) {
+        return c.text;
+      }
+    }
+    return null;
+  }
+  /** Strip a trailing generic parameter list: `UserService<T>` → `UserService`. */
+  stripGenerics(name) {
+    const lt = name.indexOf("<");
+    return lt >= 0 ? name.slice(0, lt) : name;
+  }
+  isPublic(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === "visibility_modifier") {
+        return true;
+      }
+    }
+    return false;
+  }
+  /** D3 (rust second review): unrestricted `pub` only. `pub(crate)` /
+   *  `pub(super)` items are not externally importable and must not enter
+   *  the export list (the M49 importable-units invariant). Symbol
+   *  visibility fields are untouched — only export gating changes. */
+  isUnrestrictedPublic(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === "visibility_modifier" && child.text.trim() === "pub") {
+        return true;
+      }
+    }
+    return false;
+  }
+  /** D2 (rust second review): the `Self` type of the enclosing impl block
+   *  (`Self { x }` constructs the implementing type). Trait bodies have no
+   *  impl to resolve (null → existing filtered behavior).
+   *
+   *  R10 (M60 standing rule): `Self` is the implemented TYPE, so it resolves to
+   *  that type's NOMINAL name — and when the type has no nominal name the
+   *  honest answer is ABSENCE (R7), not the impl block's synthetic name:
+   *  `Self` in `impl ToPkgId for (T, U)` is `(T, U)`, which is not
+   *  `anonymous_impl` and is not a name at all, so no edge is emitted. */
+  enclosingImplType(node) {
+    let cur = node ? node.parent : null;
+    while (cur) {
+      if (cur.type === "impl_item") return this.implSelfTypeName(cur.childForFieldName("type"));
+      cur = cur.parent;
+    }
+    return null;
+  }
+  /**
+   * M14 RUST RESIDUAL — the receiver forms whose type Rust fixes at PARSE time.
+   *
+   * `self` in a method body IS the enclosing impl type, and `Self` is that type's own
+   * keyword alias, so `self.m()` / `Self::m()` name the enclosing type with no inference.
+   * The turbofish wrappers (`self.m::<T>()`, `Self::m::<T>()`) are unwrapped to the same
+   * base. Every other callee shape this analyzer sees — `self.repository.find()`,
+   * `x.y.z()`, `Type::new()` — is either an arbitrary receiver EXPRESSION or a path whose
+   * first segment is a module or an external type, and none of those is decidable from the
+   * tree alone. Returns `null` outside an `impl` block (a trait default body has no impl
+   * type, and `Self` there resolves to the trait — not to a member key this lane
+   * publishes).
+   */
+  selfReceiverImplType(node, functionNode) {
+    const base = functionNode.type === "generic_function" ? functionNode.childForFieldName("function") ?? functionNode : functionNode;
+    if (base.type === "field_expression") {
+      if (base.childForFieldName("value")?.text !== "self") return null;
+    } else if (base.type === "scoped_identifier") {
+      if (!base.text.startsWith("Self::")) return null;
+    } else {
+      return null;
+    }
+    return this.enclosingImplType(node);
+  }
+  /**
+   * M14 RUST RESIDUAL — publish the qualifier the lane already computes, ON BOTH ENDS.
+   *
+   * ## The defect, measured
+   *
+   * `incoming-gate.ts rust rs 400` reads 42,930 edges / 23,637 unresolved, and the largest
+   * unresolved bucket is the call whose callee carries a receiver (13,423). `handleCallExpression`
+   * sets `metadata.qualified` (the receiver expression) on every call edge and resolves on the
+   * BARE LEAF — and a member name is not identifying, so the edge has no answer.
+   *
+   * ## What this pass does, and the three things it refuses
+   *
+   * It re-spells the target as `<ImplType>::<member>` for a `self.m()` / `Self::m()` call
+   * **only when THIS FILE declares that exact member key in an `impl` block** (the keys are the
+   * `metadata.fqn` values `createSymbol` publishes). Three refusals, each one a measurement:
+   *
+   *   1. **No dot, ever.** `parallel-indexer` strategy 3 fires on any target containing a `.`:
+   *      it reduces the target to everything after the first dot and binds `MIN(sym.id)` — the
+   *      arbitrary tie-break the indexer measures ~75% wrong. `::` cannot reach that branch, so
+   *      a miss here is an honest NULL rather than a confident wrong answer.
+   *   2. **Own file only.** A cross-file member would resolve too, and would move the edge from
+   *      `sameFileUnproven` to `arbitraryTwin` in the gate's binding-intent test — the
+   *      file-crossing class that must not grow. The own-file test is what keeps it flat.
+   *   3. **Calls only.** An `overrides` target rewritten to `<Trait>::<m>` has the same
+   *      cross-file hazard (the trait is usually declared elsewhere) and the emitter's own note
+   *      records that a dotted variant was measured 100% unresolved; it is left alone.
+   *
+   * `toSymbol` and `metadata.qualified` are NOT touched: they are the `qualified_calls` PAYLOAD
+   * (pinned by `validation/m14/fixtures/rust/qualified-calls-ownership.rs`), a different fact
+   * from the resolution key, and re-spelling them would change a pinned surface to serve a
+   * resolution it does not perform.
+   */
+  publishQualifiedCallTargets(ctx) {
+    const declaredMembers = /* @__PURE__ */ new Set();
+    for (const s of ctx.symbols) {
+      const fqn = s.metadata?.fqn;
+      if (typeof fqn === "string" && fqn) declaredMembers.add(fqn);
+    }
+    if (declaredMembers.size === 0) return;
+    for (const rel of ctx.relationships) {
+      if (rel.type !== ASTEngine.RelationshipType.Calls) continue;
+      const target = String(rel.target ?? "");
+      if (!target || target.includes("::")) continue;
+      let key = ctx.qualifiedCallCandidates?.get(rel) ?? null;
+      if (!key) {
+        const q = String(rel.metadata?.qualified ?? "");
+        if (isTwoSegmentIdentPath(q) && q.endsWith(`::${target}`)) key = q;
+      }
+      if (!key || !declaredMembers.has(key)) continue;
+      rel.target = key;
+    }
+  }
+  /**
+   * R10 (M60 standing rule) — the NAME of the type an impl implements.
+   *
+   * An impl symbol is named after the type it implements (stable identity, see
+   * `handleImpl`), and an `&mut`/`&`/`*const`/`(...)` wrapper does not change
+   * what the type is NAMED: `&mut ProcessBuilder` is the type `ProcessBuilder`
+   * behind a reference, so those wrappers are TRANSPARENT here and the
+   * innermost nominal name is the answer. The old rule took
+   * `stripGenerics(typeNode.text)` verbatim, so for a wrapped type it published
+   * SOURCE TEXT as a name — `&mut ProcessBuilder` rode the impl SYMBOL, the
+   * `implements` edge's SOURCE and every `Self` resolution inside the block,
+   * and the M60 target-spelling census convicted it (6 `references` targets over
+   * 2 files: `&mut ProcessBuilder` x5, `&mut Execs` x1). The differential could
+   * never see it: its truth derives from the same rule, so both sides spelled
+   * the fabrication identically.
+   *
+   * A type with NO nominal name — a slice `[u8]`, a tuple `(T, U)`, a unit, a
+   * never type, a function pointer, `dyn Trait`, `<T as Trait>::Assoc` — has no
+   * name to publish, so this returns `null` and each caller decides the honest
+   * state: the SYMBOL falls back to the family's declared synthetic
+   * (`RUST_UNNAMED_IMPL`, keeping the source spelling in metadata where it is
+   * evidence rather than an identifier), and `Self` RESOLUTION falls back to
+   * ABSENCE.
+   *
+   * The two callers then read the SAME unwrapped node two different ways, and
+   * the difference is deliberate and pre-existing:
+   *
+   *   `implTypeSymbolName` keeps a path's QUALIFICATION (`impl From<X> for
+   *   std::io::Error` publishes `std::io::Error`) because the deferred
+   *   constructor resolution reads in-file SYMBOL names — flattening a foreign
+   *   `io::Error` to `Error` would make `Error::new()` inside the impl look like
+   *   a local construction. Measured: flattening it added 12 spurious
+   *   `instantiates` edges on ripgrep alone.
+   *   `implSelfTypeName` takes the LEAF (`Error`), because a `references` or
+   *   `instantiates` TARGET is a leaf by the family's leaf-target contract
+   *   (#419-B).
+   */
+  nominalTypeNode(typeNode) {
+    let cur = typeNode;
+    for (let guard = 0; cur && guard < 16; guard++) {
+      const t2 = cur.type;
+      if (t2 === "reference_type" || t2 === "pointer_type" || t2 === "parenthesized_type") {
+        const inner = cur.childForFieldName("type") ?? cur.namedChild(cur.namedChildCount - 1);
+        if (!inner) return null;
+        cur = inner;
+        continue;
+      }
+      break;
+    }
+    if (!cur) return null;
+    const t = cur.type;
+    if (t === "type_identifier" || t === "primitive_type" || t === "scoped_type_identifier" || t === "generic_type") {
+      return cur;
+    }
+    return null;
+  }
+  /** The impl SYMBOL's name: the unwrapped type's own spelling, generics
+   *  stripped, path qualification PRESERVED (`std::io::Error`, `Vec`). */
+  implTypeSymbolName(typeNode) {
+    const n = this.nominalTypeNode(typeNode);
+    if (!n) return null;
+    return this.stripGenerics(n.text) || null;
+  }
+  /** The name `Self` resolves to inside the impl: the unwrapped type's LEAF
+   *  (`Error` for `std::io::Error`), or `null` when the type has no nominal
+   *  name at all. */
+  implSelfTypeName(typeNode) {
+    const n = this.nominalTypeNode(typeNode);
+    if (!n) return null;
+    return this.stripGenerics(n.text).split("::").filter(Boolean).pop() || null;
+  }
+  createSymbol(name, kind, node, parent, extraMetadata = {}) {
+    let ownerName = parent?.name;
+    let ownerKind = parent?.kind;
+    if (parent?.metadata?.type === "impl") {
+      ownerName = parent.metadata?.target ?? parent.name;
+    }
+    if (parent?.kind === ASTEngine.SymbolKind.Trait) {
+      ownerKind = ASTEngine.SymbolKind.Interface;
+    }
+    if (parent?.kind === ASTEngine.SymbolKind.Interface) {
+      ownerKind = ASTEngine.SymbolKind.Interface;
+    }
+    const symbol = {
+      name,
+      kind,
+      // Rust default visibility is private - never leave it undefined.
+      visibility: "private",
+      range: {
+        startLine: node.startPosition.row + 1,
+        // Columns are 1-based family-wide (+1 was missing).
+        startColumn: node.startPosition.column + 1,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column + 1,
+        startIndex: node.startIndex,
+        endIndex: node.endIndex
+      },
+      id: `${parent ? parent.id + "." : ""}${name}`,
+      parent: parent ? parent.name : void 0,
+      ownerName,
+      ownerKind,
+      metadata: { ...extraMetadata }
+    };
+    symbol.id = this.uniqueId(symbol.id);
+    if (kind === ASTEngine.SymbolKind.Function || kind === ASTEngine.SymbolKind.Method) {
+      const memberList = node.parent;
+      const implNode = memberList?.parent;
+      if (memberList?.type === "declaration_list" && implNode?.type === "impl_item") {
+        const implType = this.implSelfTypeName(implNode.childForFieldName("type"));
+        if (implType) symbol.metadata.fqn = `${implType}::${name}`;
+      }
+    }
+    return symbol;
+  }
+  /** Hand out a per-file-unique id: first claim wins plain, later claims get
+   *  a deterministic numeric suffix (`Foo`, `Foo#2`, …). RSD3. */
+  uniqueId(base) {
+    let id = base;
+    let n = 2;
+    while (this.usedIds.has(id)) {
+      id = `${base}#${n}`;
+      n++;
+    }
+    this.usedIds.add(id);
+    return id;
+  }
+  handleStruct(node, ctx, parent) {
+    const name = this.extractIdentifier(node, "name");
+    if (!name) return null;
+    const symbol = this.createSymbol(name, ASTEngine.SymbolKind.Struct, node, parent);
+    if (this.isPublic(node)) symbol.visibility = "public";
+    ctx.symbols.push(symbol);
+    let fieldDeclarationList = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === "field_declaration_list") {
+        fieldDeclarationList = child;
+        break;
+      }
+    }
+    if (fieldDeclarationList) {
+      for (let i = 0; i < fieldDeclarationList.namedChildCount; i++) {
+        const fieldNode = fieldDeclarationList.namedChild(i);
+        if (fieldNode && fieldNode.type === "field_declaration") {
+          const fieldName = this.extractIdentifier(fieldNode, "name");
+          if (fieldName) {
+            const fieldSymbol = this.createSymbol(fieldName, ASTEngine.SymbolKind.Property, fieldNode, symbol, {
+              type: "field"
+            });
+            fieldSymbol.visibility = this.isPublic(fieldNode) ? "public" : "private";
+            ctx.symbols.push(fieldSymbol);
+          }
+        }
+      }
+    }
+    if (this.isUnrestrictedPublic(node) && !parent) {
+      ctx.exports.push({
+        name,
+        type: ASTEngine.SymbolKind.Class,
+        range: symbol.range,
+        isType: true
+      });
+    }
+    return symbol;
+  }
+  handleTrait(node, ctx, parent) {
+    const nameNode = node.childForFieldName("name");
+    let name = nameNode ? nameNode.text : null;
+    if (!name) return null;
+    const genericParams = [];
+    const nextSibling = nameNode ? nameNode.nextNamedSibling : null;
+    if (nextSibling && nextSibling.type === "type_parameters") {
+      genericParams.push(nextSibling.text);
+    }
+    const symbol = this.createSymbol(name, ASTEngine.SymbolKind.Trait, node, parent, {
+      type: "trait",
+      ...genericParams.length > 0 ? { genericParameters: genericParams } : {}
+    });
+    if (genericParams.length > 0) symbol.genericParameters = genericParams;
+    ctx.symbols.push(symbol);
+    const boundsNode = node.childForFieldName("bounds");
+    if (boundsNode) {
+      for (let i = 0; i < boundsNode.namedChildCount; i++) {
+        let bound = boundsNode.namedChild(i);
+        if (bound?.type === "higher_ranked_trait_bound") {
+          for (let j = 0; j < bound.namedChildCount; j++) {
+            const inner = bound.namedChild(j);
+            if (inner && (inner.type === "type_identifier" || inner.type === "scoped_type_identifier" || inner.type === "generic_type")) {
+              bound = inner;
+              break;
+            }
+          }
+        }
+        if (bound && (bound.type === "type_identifier" || bound.type === "scoped_type_identifier" || bound.type === "generic_type")) {
+          ctx.relationships.push({
+            source: name,
+            target: this.extractTraitName(bound),
+            type: ASTEngine.RelationshipType.Extends,
+            confidence: 1,
+            // M59.A7 (#825): the supertrait's own line in the bound list.
+            ...this.nodeLine(bound) ? { line_number: this.nodeLine(bound) } : {},
+            metadata: { rustSpecific: true, traitBound: true }
+          });
+        }
+      }
+    }
+    if (this.isUnrestrictedPublic(node) && !parent) {
+      ctx.exports.push({
+        name,
+        type: ASTEngine.SymbolKind.Trait,
+        range: symbol.range,
+        isType: true
+      });
+    }
+    return symbol;
+  }
+  handleImpl(node, ctx, parent) {
+    let traitNode = null;
+    let typeNode = null;
+    traitNode = node.childForFieldName("trait");
+    typeNode = node.childForFieldName("type");
+    if (!traitNode && !typeNode) {
+      let forIndex = -1;
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && c.type === "for") {
+          forIndex = i;
+          break;
+        }
+      }
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (!c) continue;
+        if (c.type === "type_identifier" || c.type === "scoped_type_identifier" || c.type === "generic_type") {
+          if (forIndex !== -1) {
+            if (i < forIndex) traitNode = c;
+            if (i > forIndex) typeNode = c;
+          } else {
+            typeNode = c;
+          }
+        }
+      }
+    }
+    if (!typeNode) return null;
+    const traitName = traitNode ? traitNode.text : void 0;
+    const nominal = this.implTypeSymbolName(typeNode);
+    const implName = nominal === null ? RUST_UNNAMED_IMPL : `${nominal}::r#impl`;
+    const symbol = this.createSymbol(
+      implName,
+      ASTEngine.SymbolKind.Impl,
+      node,
+      parent,
+      nominal ? { type: "impl", target: nominal } : { type: "impl", implementedType: typeNode.text }
+    );
+    ctx.symbols.push(symbol);
+    if (traitNode && traitName) {
+      ctx.relationships.push({
+        source: nominal ?? implName,
+        target: this.extractTraitName(traitNode),
+        type: ASTEngine.RelationshipType.Implements,
+        // INCOMING_RUST: same absent-confidence defect as `calls` — 252 of 252
+        // `implements` rows on this lane's corpus carried none. 1.0: the
+        // `impl Trait for Type` clause names both ends.
+        confidence: 1,
+        // M59.A7 (#825): the TRAIT reference's line — the site that names the
+        // target, not the implementing type's.
+        ...this.nodeLine(traitNode) ? { line_number: this.nodeLine(traitNode) } : {},
+        metadata: {}
+      });
+    }
+    return symbol;
+  }
+  /** Leaf type name of a trait reference: `super::Repository<User>` → `Repository`. */
+  extractTraitName(node) {
+    const nameField = node.childForFieldName("name") || node.namedChild(0);
+    if (nameField && nameField.type === "type_identifier") return nameField.text;
+    if (nameField && nameField.type === "scoped_type_identifier") {
+      const last = nameField.namedChild(nameField.namedChildCount - 1);
+      if (last && last.type === "type_identifier") return last.text;
+    }
+    if (node.type === "type_identifier") return node.text;
+    return this.stripGenerics(node.text).split("::").pop() || node.text;
+  }
+  handleMod(node, ctx, parent) {
+    const name = this.extractIdentifier(node, "name");
+    if (!name) return null;
+    const symbol = this.createSymbol(name, ASTEngine.SymbolKind.Module, node, parent, { type: "mod" });
+    ctx.symbols.push(symbol);
+    if (this.isUnrestrictedPublic(node) && !parent) {
+      ctx.exports.push({
+        name,
+        type: ASTEngine.SymbolKind.Module,
+        range: symbol.range,
+        isType: false
+      });
+    }
+    return symbol;
+  }
+  handleEnum(node, ctx, parent) {
+    const name = this.extractIdentifier(node, "name");
+    if (!name) return null;
+    const symbol = this.createSymbol(name, ASTEngine.SymbolKind.Enum, node, parent, { type: "enum" });
+    ctx.symbols.push(symbol);
+    if (this.isUnrestrictedPublic(node) && !parent) {
+      ctx.exports.push({
+        name,
+        type: ASTEngine.SymbolKind.Enum,
+        range: symbol.range,
+        isType: true
+      });
+    }
+    return symbol;
+  }
+  handleFunction(node, ctx, parent) {
+    const name = this.extractIdentifier(node, "name");
+    if (!name) return null;
+    const isMethod = parent && (parent.metadata?.type === "impl" || parent.metadata?.type === "trait" || parent.kind === ASTEngine.SymbolKind.Trait || parent.kind === ASTEngine.SymbolKind.Impl);
+    let isConstFn = false;
+    let isAsyncFn = false;
+    let isUnsafeFn = false;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === "const") isConstFn = true;
+      if (c && c.type === "async") isAsyncFn = true;
+      if (c && c.type === "unsafe") isUnsafeFn = true;
+    }
+    const symbol = this.createSymbol(
+      name,
+      isMethod ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Function,
+      node,
+      parent,
+      {
+        type: "function",
+        isConstFn,
+        isAsyncFn,
+        isUnsafeFn,
+        // #612 store-phase: a rust `function_item` carries a body; a
+        // `function_signature_item` does not — that node is a trait method
+        // signature or an `extern "C" { fn f(); }` FFI declaration. Both used
+        // to publish an indistinguishable `function` symbol, so the extern
+        // declaration could win name resolution against the definition that
+        // implements it in another file. (The node-type discriminator already
+        // existed here for scope purposes; only the published fact was absent.)
+        ...node.type === "function_signature_item" ? { isDeclaration: true } : {}
+      }
+    );
+    if (isConstFn) symbol.metadata = { ...symbol.metadata, isConst: true };
+    if (isAsyncFn) symbol.isAsync = true;
+    if (isUnsafeFn) symbol.metadata = { ...symbol.metadata, isUnsafe: true };
+    let visibility = "private";
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === "visibility_modifier") {
+        visibility = c.text.includes("crate") ? "crate" : c.text.includes("super") ? "super" : "public";
+        break;
+      }
+    }
+    symbol.visibility = visibility;
+    const returnTypeNode = node.childForFieldName("return_type");
+    if (returnTypeNode) {
+      symbol.returnType = returnTypeNode.text;
+    }
+    const typeParametersNode = node.childForFieldName("type_parameters");
+    if (typeParametersNode) {
+      symbol.genericParameters = [typeParametersNode.text];
+    }
+    symbol.complexity = this.functionComplexityRust(node);
+    const parametersNode = node.childForFieldName("parameters");
+    if (parametersNode) {
+      const params = [];
+      for (let i = 0; i < parametersNode.namedChildCount; i++) {
+        const p = parametersNode.namedChild(i);
+        if (p && (p.type === "parameter" || p.type === "self_parameter")) {
+          const pName = p.childForFieldName("pattern") || (p.type === "self_parameter" ? p : null);
+          const pType = p.childForFieldName("type");
+          const name2 = pName ? pName.text.replace("&", "").replace("mut ", "").trim() : "";
+          if (name2) params.push({ name: name2, type: pType ? pType.text : "any" });
+        }
+      }
+      if (params.length > 0) symbol.parameters = params;
+    }
+    ctx.symbols.push(symbol);
+    if (this.isUnrestrictedPublic(node) && !isMethod && !parent) {
+      ctx.exports.push({
+        name,
+        type: ASTEngine.SymbolKind.Function,
+        range: symbol.range,
+        isType: false
+      });
+    }
+    return symbol;
+  }
+  /** R1: file-visible VALUE names mapped to owner sets ("" = file scope).
+   *  Kinds that name run-time entities readable bare: Constant
+   *  (const/static), Function (callbacks), EnumMember (variants),
+   *  Struct/Enum/Union/Type (constructors and unit values). Modules,
+   *  macros, traits, methods, properties never resolve bare. Function
+   *  bodies and const/static bodies contribute no declarations (locals);
+   *  impl/trait members are associated items (never bare-readable).
+   *  Use-imported leaves resolve file-wide (imports bind names too). */
+  collectValueOwners(rootNode, owners, useImported) {
+    const add = (name, modOwners) => {
+      if (!name) return;
+      let s = owners.get(name);
+      if (!s) {
+        s = /* @__PURE__ */ new Set();
+        owners.set(name, s);
+      }
+      if (modOwners.length === 0) s.add("");
+      else for (const m of modOwners) s.add(m);
+    };
+    const leftmostId = (n) => {
+      let cur = n;
+      while (cur) {
+        if (cur.type === "identifier") return cur.text;
+        cur = cur.namedChild(0);
+      }
+      return null;
+    };
+    const stack = [
+      { n: rootNode, mods: [], inFn: false, inImpl: false }
+    ];
+    while (stack.length > 0) {
+      const { n, mods, inFn, inImpl } = stack.pop();
+      const t = n.type;
+      if (t === "mod_item") {
+        const nm = n.childForFieldName("name")?.text;
+        const body = n.namedChild(n.namedChildCount - 1);
+        const hasBody = !!body && body.type === "declaration_list";
+        if (nm && hasBody) {
+          for (let i = n.namedChildCount - 1; i >= 0; i--) {
+            const c = n.namedChild(i);
+            if (c) stack.push({ n: c, mods: [...mods, nm], inFn, inImpl });
+          }
+          continue;
+        }
+      } else if (t === "function_item") {
+        if (!inImpl) {
+          const nm = n.childForFieldName("name")?.text;
+          if (nm) {
+            if (mods.length === 0) add(nm, []);
+            else add(nm, mods);
+          }
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const c = n.namedChild(i);
+          if (c) stack.push({ n: c, mods, inFn: true, inImpl });
+        }
+        continue;
+      } else if (t === "impl_item" || t === "trait_item") {
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const c = n.namedChild(i);
+          if (c) stack.push({ n: c, mods, inFn, inImpl: true });
+        }
+        continue;
+      } else if (!inFn && (t === "const_item" || t === "static_item")) {
+        const nm = n.childForFieldName("name")?.text ?? leftmostId(n);
+        if (nm && nm !== "_" && !inImpl) add(nm, mods);
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const c = n.namedChild(i);
+          if (c) stack.push({ n: c, mods, inFn: true, inImpl });
+        }
+        continue;
+      } else if (!inFn && !inImpl && (t === "struct_item" || t === "enum_item" || t === "union_item" || t === "type_item")) {
+        const nm = n.childForFieldName("name")?.text;
+        if (nm) add(nm, mods);
+      } else if (t === "enum_variant") {
+        const nm = n.childForFieldName("name")?.text ?? n.namedChild(0)?.text;
+        if (nm && !inFn) add(nm, mods);
+      } else if (t === "use_declaration") {
+        for (const leaf of this.useLeafNames(n)) {
+          if (leaf && leaf !== "self" && leaf !== "*") useImported.add(leaf);
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push({ n: c, mods, inFn, inImpl });
+      }
+    }
+  }
+  /** R1: leaf names bound by one `use` (alias-aware, self-aware). Mirrors
+   *  handleUseDeclaration's leaf logic without building ImportInfo rows. */
+  useLeafNames(node) {
+    const out = [];
+    const walk = (n) => {
+      if (!n) return;
+      if (n.type === "identifier" || n.type === "type_identifier") {
+        if (n.parent && (n.parent.type === "use_declaration" || n.parent.type === "use_list")) out.push(n.text);
+        return;
+      }
+      if (n.type === "scoped_identifier") {
+        const par = n.parent;
+        if (par && (par.type === "use_declaration" || par.type === "use_list")) {
+          const last = n.namedChild(n.namedChildCount - 1);
+          if (last && (last.type === "identifier" || last.type === "type_identifier")) {
+            const t = last.text;
+            if (t && t !== "self" && t !== "super" && t !== "crate") out.push(t);
+          }
+        }
+        return;
+      }
+      if (n.type === "use_as_clause") {
+        const alias = n.childForFieldName("alias") || n.namedChild(n.namedChildCount - 1);
+        if (alias) out.push(alias.text);
+        return;
+      }
+      if (n.type === "self") return;
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c);
+      }
+    };
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type !== "visibility_modifier" && c.type !== "use" && c.type !== "crate") walk(c);
+    }
+    return out;
+  }
+  /** R1: per-function bound names (parameters + all pattern bindings in the
+   *  body, closures folded in). Keyed by function_item startIndex. */
+  /** R1: enclosing inline-module names for one node (outermost first). */
+  enclosingMods(node) {
+    const out = [];
+    let cur = node ? node.parent : null;
+    while (cur) {
+      if (cur.type === "mod_item") {
+        const nm = cur.childForFieldName("name")?.text;
+        if (nm) out.unshift(nm);
+      }
+      cur = cur.parent;
+    }
+    return out;
+  }
+  /** R1: identifiers bound by one PATTERN subtree. In DECLARATION
+   *  positions (let/param/for/let-condition patterns) every lowercase
+   *  identifier binds, and UPPERCASE ones bind too (the grammar declares —
+   *  `let G`, `fn f(G)`). In MATCH positions (arms, or-patterns) lowercase
+   *  binds but UPPERCASE is a path pattern (`None`, `RED`) — reported via
+   *  `uses` when the probe says resolvable, otherwise bound (harmless).
+   *  Tuple-struct HEADS (`Some` in `Some(v)`) never bind anywhere — they
+   *  name the constructor (emitted as uses when resolvable). Accepted
+   *  residual: UPPERCASE locals read as uses when a same-named global
+   *  exists AND the binding sits in match position. */
+  collectPatternIds(node, out, resolves, isDecl) {
+    if (!node) return;
+    if (node.type === "identifier") {
+      const nm = node.text;
+      if (!nm || nm === "_" || nm.startsWith("$")) return;
+      const first = nm.charCodeAt(0);
+      if (first >= 65 && first <= 90 && !isDecl && resolves(nm)) return;
+      out.add(nm);
+      return;
+    }
+    if (node.type === "type_identifier" || node.type === "scoped_identifier" || node.type === "field_identifier" || node.type === "lifetime" || node.type === "primitive_type") return;
+    if (node.type === "tuple_struct_pattern") {
+      for (let i = 1; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c) this.collectPatternIds(c, out, resolves, isDecl);
+      }
+      return;
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c) this.collectPatternIds(c, out, resolves, isDecl);
+    }
+  }
+  /** R1: per-function bound-name sets. The uppercase path-pattern rule
+   *  needs resolvability: probe = file-scope owners, use-imported leaves,
+   *  or the function's own enclosing modules. */
+  collectFunctionBindings(rootNode, valueOwners, useImported) {
+    const out = /* @__PURE__ */ new Map();
+    const stack = [rootNode];
+    const fns = [];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "function_item") fns.push(n);
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    for (const fn of fns) {
+      const bound = /* @__PURE__ */ new Set();
+      const fnMods = this.enclosingMods(fn);
+      const resolves = (nm) => {
+        const owners = valueOwners.get(nm);
+        if (!owners) return useImported.has(nm);
+        if (owners.has("")) return true;
+        if (useImported.has(nm)) return true;
+        for (const m of fnMods) if (owners.has(m)) return true;
+        return false;
+      };
+      const params = fn.childForFieldName("parameters");
+      if (params) {
+        for (let i = 0; i < params.namedChildCount; i++) {
+          const p = params.namedChild(i);
+          if (!p) continue;
+          if (p.type === "self_parameter") continue;
+          const pat = p.childForFieldName("pattern") ?? p;
+          this.collectPatternIds(pat, bound, resolves, true);
+        }
+      }
+      const body = [fn];
+      while (body.length > 0) {
+        const m = body.pop();
+        if (m.type === "let_declaration") {
+          const pat = m.childForFieldName("pattern") ?? m.namedChild(0);
+          this.collectPatternIds(pat, bound, resolves, true);
+        } else if (m.type === "let_condition") {
+          this.collectPatternIds(m.namedChild(0), bound, resolves, false);
+        } else if (m.type === "for_expression") {
+          this.collectPatternIds(m.namedChild(0), bound, resolves, true);
+        } else if (m.type === "closure_expression") {
+          for (let i = 0; i < m.namedChildCount; i++) {
+            const c = m.namedChild(i);
+            if (c && c.type === "closure_parameters") {
+              this.collectPatternIds(c, bound, resolves, true);
+            }
+          }
+        } else if (m.type === "match_arm") {
+          const patField = m.childForFieldName("pattern");
+          if (patField) {
+            const psub = [patField];
+            while (psub.length > 0) {
+              const q = psub.pop();
+              if (q !== patField && (q.type === "let_declaration" || q.type === "let_condition" || q.type === "for_expression")) continue;
+              if (q.type === "match_pattern" || q.type === "identifier" || q.type === "tuple_pattern" || q.type === "struct_pattern" || q.type === "tuple_struct_pattern" || q.type === "ref_pattern" || q.type === "or_pattern" || q.type === "slice_pattern") {
+                this.collectPatternIds(q, bound, resolves, false);
+              }
+              for (let i = q.namedChildCount - 1; i >= 0; i--) {
+                const c = q.namedChild(i);
+                if (c) psub.push(c);
+              }
+            }
+          }
+          const sub = [m];
+          while (sub.length > 0) {
+            const q = sub.pop();
+            if (q !== m && (q.type === "let_declaration" || q.type === "let_condition" || q.type === "for_expression")) continue;
+            if (q.type === "tuple_pattern" || q.type === "struct_pattern" || q.type === "tuple_struct_pattern" || q.type === "ref_pattern" || q.type === "or_pattern" || q.type === "slice_pattern") {
+              this.collectPatternIds(q, bound, resolves, false);
+            }
+            for (let i = q.namedChildCount - 1; i >= 0; i--) {
+              const c = q.namedChild(i);
+              if (c) sub.push(c);
+            }
+          }
+        }
+        if (m !== fn && (m.type === "function_item" || m.type === "const_item" || m.type === "static_item")) continue;
+        for (let i = m.namedChildCount - 1; i >= 0; i--) {
+          const c = m.namedChild(i);
+          if (c) body.push(c);
+        }
+      }
+      out.set(fn.startIndex, bound);
+    }
+    return out;
+  }
+  /** R1: one bare `identifier` occurrence — emit Uses iff it names a
+   *  file-visible VALUE and survives the exclusion discipline (declaration
+   *  positions incl. leftmost rule, call callees incl. turbofish climb,
+   *  member leaves, qualified non-leaves, preprocessor/macros/attributes/
+   *  use-paths, LHS writes, where-bounds, shadowing). */
+  handleIdentifierRead(node, ctx, parent, valueOwners, useImported, fnBindings) {
+    const name = node.text;
+    if (!name || name === "_" || name === "self" || name === "Self" || name === "super" || name === "crate" || name.startsWith("$")) return;
+    const p = node.parent;
+    if (this.hasAncestor(node, "macro_definition", ["macro_invocation"])) return;
+    {
+      let mtop = node;
+      let mup = p;
+      while (mup && (mup.type === "scoped_identifier" || mup.type === "generic_function")) {
+        mtop = mup;
+        mup = mup.parent;
+      }
+      if (mup && mup.type === "macro_invocation") {
+        const mfield = mup.childForFieldName("macro");
+        if (mfield && mfield.startIndex === mtop.startIndex && mfield.endIndex >= mtop.endIndex) return;
+      }
+    }
+    if (this.hasAncestor(node, "attribute_item", ["function_item", "struct_item", "enum_item", "impl_item", "trait_item", "mod_item"])) return;
+    if (this.hasAncestor(node, "use_declaration", null)) return;
+    if (p && p.type === "parameter") {
+      const params = p.parent;
+      const holder = params?.parent;
+      if (params?.type === "parameters" && holder && holder.type === "function_type") return;
+      if (params?.type === "parameters") {
+        let owner = params.parent;
+        while (owner && owner.type !== "function_item" && owner.type !== "function_signature_item" && owner.type !== "closure_expression") owner = owner.parent;
+        if (owner && owner.type === "function_signature_item") return;
+      }
+    }
+    if (this.hasAncestor(node, "where_predicate", null)) return;
+    let top = node;
+    let up = p;
+    while (up && (up.type === "generic_function" || up.type === "parenthesized_expression")) {
+      top = up;
+      up = up.parent;
+    }
+    if (up && up.type === "call_expression") {
+      const fnField = up.childForFieldName("function");
+      if (fnField && fnField.startIndex === top.startIndex && fnField.endIndex >= top.endIndex) return;
+      const first = up.namedChild(0);
+      if (first && first.startIndex === top.startIndex && first.endIndex >= top.endIndex) return;
+    }
+    if (p && p.type === "field_expression") {
+      const field = p.childForFieldName("field");
+      if (field && field.startIndex === node.startIndex) return;
+    }
+    if (p && p.type === "scoped_identifier") {
+      const last = p.namedChild(p.namedChildCount - 1);
+      if (!last || last.startIndex !== node.startIndex) return;
+    } else if (this.hasAncestor(node, "scoped_identifier", ["call_expression", "field_expression"])) {
+      return;
+    }
+    if (p && (p.type === "assignment_expression" || p.type === "compound_assignment_expr")) {
+      const lhs = p.namedChild(0);
+      if (lhs && lhs.startIndex === node.startIndex && lhs.endIndex >= node.endIndex) return;
+    }
+    if (p && this.isItemNamePosition(node, p)) return;
+    let fnNode = p;
+    while (fnNode && fnNode.type !== "function_item") fnNode = fnNode.parent;
+    if (fnNode) {
+      const bound = fnBindings.get(fnNode.startIndex);
+      if (bound && bound.has(name)) return;
+    }
+    const owners = valueOwners.get(name);
+    let ok = false;
+    if (owners) {
+      if (owners.has("")) ok = true;
+      else if (useImported.has(name)) ok = true;
+      else {
+        const mods = this.enclosingMods(node);
+        for (const m of mods) {
+          if (owners.has(m)) {
+            ok = true;
+            break;
+          }
+        }
+      }
+    } else if (useImported.has(name)) {
+      ok = true;
+    }
+    if (!ok) return;
+    const source = this.edgeSource(parent);
+    if (!source) {
+      this.noOwner(ctx, "uses:identifier_read");
+      return;
+    }
+    const relKey = `${source}::uses::${name}`;
+    if (ctx.emittedUses.has(relKey)) return;
+    ctx.emittedUses.add(relKey);
+    const inMacroArgument = this.hasAncestor(node, "macro_invocation", null);
+    ctx.relationships.push({
+      source,
+      target: name,
+      type: ASTEngine.RelationshipType.Uses,
+      confidence: inMacroArgument ? 0.6 : 1,
+      // M59.A7 (#825): the identifier's own line.
+      ...this.nodeLine(node) ? { line_number: this.nodeLine(node) } : {},
+      metadata: {
+        relationshipType: "identifier_usage",
+        nodeType: node.type,
+        ...inMacroArgument ? { macroArgument: true, reasonCode: "unexpanded-macro-argument" } : {}
+      }
+    });
+    if (inMacroArgument) ctx.macroArgumentReads++;
+  }
+  /** True when `node` sits under an ancestor of one of `types` before
+   *  crossing any node of a stop type (null stops = never stop early). */
+  hasAncestor(node, types, stopAt) {
+    const want = Array.isArray(types) ? types : [types];
+    let cur = node.parent;
+    while (cur) {
+      if (want.includes(cur.type)) return true;
+      if (stopAt) {
+        for (const s of stopAt) {
+          if (cur.type === s) return false;
+        }
+      }
+      cur = cur.parent;
+    }
+    return false;
+  }
+  /** True when `node` is the defining NAME occurrence of its item parent
+   *  (first identifier-ish named child of an entity-declaring node). */
+  isItemNamePosition(node, parent) {
+    switch (parent.type) {
+      case "function_item":
+      // RUST-MR: a TRAIT method DECLARATION is a `function_signature_item` (no
+      // body), and the switch below listed `function_item` only — so a trait
+      // method's own NAME fell through to the read sweep. When the name also
+      // resolved (a use-imported leaf of the same name, or a file-visible value)
+      // it published a `uses` edge for its own DECLARATION, and at
+      // cargo-test-support/src/lib.rs:1477 that edge was a SELF-EDGE
+      // (`uses current_dir -> current_dir`). The IMPLEMENTATION of the same
+      // method never did, which is what made the class look like a trait quirk
+      // rather than a missing node type. 10 sites survived the macro-callee fix
+      // in the same 550-file slice; the whole class is trait method signatures
+      // whose name collides with an import.
+      case "function_signature_item":
+      case "struct_item":
+      case "enum_item":
+      case "trait_item":
+      case "mod_item":
+      case "type_item":
+      case "associated_type":
+      case "static_item":
+      case "const_item":
+      case "enum_variant":
+      case "field_declaration":
+      case "extern_crate_declaration":
+        break;
+      default:
+        return false;
+    }
+    for (let i = 0; i < parent.namedChildCount; i++) {
+      const c = parent.namedChild(i);
+      if (c && (c.type === "identifier" || c.type === "type_identifier" || c.type === "field_identifier")) {
+        return c.startIndex === node.startIndex && c.endIndex === node.endIndex;
+      }
+    }
+    return false;
+  }
+  /** Returns the symbol it created, so a `const`/`static` can own its own
+   *  initializer's reads (R7). `null` when it declares nothing. */
+  handleVariable(node, ctx, parent) {
+    let patternNode = node.childForFieldName("pattern");
+    if (!patternNode) {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === "identifier") {
+          patternNode = child;
+          break;
+        }
+      }
+    }
+    if (!patternNode) return null;
+    const name = patternNode.text;
+    if (name === "_") return null;
+    if (node.type === "let_declaration") return null;
+    const symbol = this.createSymbol(name, ASTEngine.SymbolKind.Variable, node, parent, { type: node.type });
+    ctx.symbols.push(symbol);
+    if (this.isUnrestrictedPublic(node) && !parent) {
+      ctx.exports.push({
+        name,
+        type: ASTEngine.SymbolKind.Variable,
+        range: symbol.range,
+        isType: false
+      });
+    }
+    return symbol;
+  }
+  handleUseDeclaration(node, ctx, parent) {
+    const isPublic = this.isPublic(node);
+    const collect = (n) => {
+      if (n.type === "identifier" || n.type === "type_identifier") {
+        return { path: n.text, items: [n.text], node: n };
+      }
+      if (n.type === "crate" || n.type === "super" || n.type === "self") {
+        return { path: n.text, items: [n.text], node: n };
+      }
+      if (n.type === "scoped_identifier") {
+        const pathNode = n.childForFieldName("path");
+        const name = n.childForFieldName("name") || n.namedChild(n.namedChildCount - 1);
+        const p = pathNode ? collect(pathNode).path + "::" : n.text.startsWith("::") ? "::" : "";
+        return { path: p + (name ? name.text : ""), items: [name ? name.text : ""], node: n };
+      }
+      if (n.type === "scoped_use_list") {
+        const pathNode = n.namedChild(0);
+        const listNode = n.namedChild(1);
+        const base = pathNode ? collect(pathNode).path : "";
+        const items = [];
+        if (listNode && listNode.type === "use_list") {
+          for (let i = 0; i < listNode.namedChildCount; i++) {
+            const c = listNode.namedChild(i);
+            if (!c) continue;
+            if (c.type === "self") {
+              const leaf = base.split("::").filter(Boolean).pop();
+              if (leaf) items.push(leaf);
+            } else if (c.type === "use_as_clause") {
+              const aliasName = c.childForFieldName("alias") || c.namedChild(c.namedChildCount - 1);
+              if (aliasName) items.push(aliasName.text);
+            } else if (c.type === "identifier" || c.type === "type_identifier") {
+              items.push(c.text);
+            } else if (c.type === "scoped_identifier") {
+              const leaf = c.namedChild(c.namedChildCount - 1);
+              if (leaf) items.push(leaf.text);
+            } else if (c.type === "scoped_use_list") {
+              const inner = collect(c);
+              for (const it of inner.items) items.push(it);
+            }
+          }
+        }
+        return { path: base, items, node: n };
+      }
+      if (n.type === "use_list") {
+        const items = [];
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (!c) continue;
+          if (c.type === "use_as_clause") {
+            const aliasName = c.childForFieldName("alias") || c.namedChild(c.namedChildCount - 1);
+            if (aliasName) items.push(aliasName.text);
+          } else if (c.type === "identifier" || c.type === "type_identifier") {
+            items.push(c.text);
+          } else if (c.type === "scoped_identifier") {
+            const leaf = c.namedChild(c.namedChildCount - 1);
+            if (leaf) items.push(leaf.text);
+          }
+        }
+        return { path: "", items, node: n };
+      }
+      if (n.type === "use_as_clause") {
+        const path2 = n.childForFieldName("path") || n.namedChild(0);
+        const aliasName = n.childForFieldName("alias") || n.namedChild(n.namedChildCount - 1);
+        return { path: path2 ? collect(path2).path : n.text, items: [aliasName ? aliasName.text : path2 ? collect(path2).items[0] : n.text], node: n };
+      }
+      if (n.type === "use_wildcard") {
+        const inner = n.namedChild(0);
+        const path2 = inner ? collect(inner).path : n.text;
+        return { path: path2, items: ["*"], node: n };
+      }
+      if (n.type === "use_as_clause" || n.type === "scoped_use_list" || n.type === "use_list" || n.type === "scoped_identifier") {
+        return { path: n.text, items: [n.text], node: n };
+      }
+      return { path: "", items: [], node: n };
+    };
+    const rows = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c || c.type === "visibility_modifier" || c.type === "use" || c.type === "crate") continue;
+      if (c.type === "use_list") {
+        for (let j = 0; j < c.namedChildCount; j++) {
+          const sub = c.namedChild(j);
+          if (!sub || sub.type === ",") continue;
+          const r2 = collect(sub);
+          if (r2.items.length) rows.push(r2);
+        }
+        continue;
+      }
+      const r = collect(c);
+      if (r.items.length) rows.push(r);
+    }
+    if (rows.length === 0) return;
+    const mergedRows = [];
+    for (const r of rows) {
+      const ex = mergedRows.find((m) => m.path === r.path && m.items[0] !== "*" && r.items[0] !== "*");
+      if (ex) ex.items.push(...r.items);
+      else mergedRows.push({ path: r.path, items: [...r.items], node: r.node });
+    }
+    const modulePath = mergedRows[0].path;
+    for (const row of mergedRows) {
+      ctx.imports.push({
+        module: row.path,
+        source: row.path,
+        items: row.items,
+        // RUST-D27: the range is the PATH's, not the whole declaration's. A
+        // multi-line group (`use {\n    aho_corasick::AhoCorasick,\n    bstr,\n};`)
+        // gave every one of its rows the line of the `use` keyword, so the record
+        // pointed at a line that does not bear the path it names — 56 such records
+        // in ripgrep alone, found by the first audit ever run over this channel.
+        range: (() => {
+          const n2 = row.node ?? node;
+          return {
+            startLine: n2.startPosition.row + 1,
+            startColumn: n2.startPosition.column + 1,
+            endLine: n2.endPosition.row + 1,
+            endColumn: n2.endPosition.column + 1,
+            startIndex: n2.startIndex,
+            endIndex: n2.endIndex
+          };
+        })(),
+        metadata: { rustSpecific: true, isPublic }
+      });
+    }
+    void modulePath;
+  }
+  // Extract function calls at any scope (not just inside function bodies)
+  handleCallExpression(node, ctx, parent) {
+    const functionNode = node.childForFieldName("function");
+    if (!functionNode) return;
+    let target = "";
+    let qualified = "";
+    let selfSpelling = false;
+    let calleeNameNode = null;
+    if (functionNode.type === "field_expression") {
+      const fieldNode = functionNode.childForFieldName("field");
+      const valueNode = functionNode.childForFieldName("value");
+      if (fieldNode) {
+        target = fieldNode.text;
+        qualified = valueNode ? `${valueNode.text}.${fieldNode.text}` : fieldNode.text;
+        calleeNameNode = fieldNode;
+      }
+    } else if (functionNode.type === "scoped_identifier") {
+      const nameNode = functionNode.childForFieldName("name") || functionNode.namedChild(functionNode.namedChildCount - 1);
+      if (nameNode) {
+        target = nameNode.text;
+        qualified = functionNode.text;
+        calleeNameNode = nameNode;
+      }
+    } else if (functionNode.type === "generic_function") {
+      const baseNode = functionNode.childForFieldName("function");
+      if (baseNode) {
+        if (baseNode.type === "field_expression") {
+          const fieldNode = baseNode.childForFieldName("field");
+          if (fieldNode) {
+            target = fieldNode.text;
+            qualified = baseNode.text;
+            calleeNameNode = fieldNode;
+          }
+        } else if (baseNode.type === "scoped_identifier") {
+          const nameNode = baseNode.childForFieldName("name") || baseNode.namedChild(baseNode.namedChildCount - 1);
+          if (nameNode) {
+            target = nameNode.text;
+            qualified = baseNode.text;
+            calleeNameNode = nameNode;
+          }
+        } else if (baseNode.text === "Self") {
+          const resolved = this.enclosingImplType(node);
+          if (!resolved) return;
+          target = resolved;
+          qualified = resolved;
+          calleeNameNode = baseNode;
+        } else {
+          target = baseNode.text;
+          qualified = baseNode.text;
+          calleeNameNode = baseNode;
+        }
+      }
+    } else {
+      if (functionNode.type === "identifier") {
+        if (functionNode.text === "Self") {
+          const resolved = this.enclosingImplType(node);
+          if (!resolved) return;
+          target = resolved;
+          qualified = resolved;
+          calleeNameNode = functionNode;
+          selfSpelling = true;
+        } else {
+          target = functionNode.text;
+          qualified = target;
+          calleeNameNode = functionNode;
+        }
+      }
+    }
+    if (!target) return;
+    const source = this.edgeSource(parent);
+    if (!source) {
+      this.noOwner(ctx, "calls:call_expression");
+      return;
+    }
+    const metadata = { qualified };
+    if (ctx.awaitedCalls.has(node.startIndex)) {
+      metadata.rustSpecific = true;
+      metadata.isAwait = true;
+    }
+    const callRel = {
+      source,
+      target,
+      fromSymbol: source,
+      toSymbol: qualified,
+      type: ASTEngine.RelationshipType.Calls,
+      // INCOMING_RUST: this edge published NO confidence at all — 17,083 of
+      // 17,083 rows on this lane's corpus read `undefined`. Two consequences,
+      // both invisible from inside the analyzer: `classifyEvidenceTier` defaults
+      // a missing value to 1, so the evidence tier looked right, and every
+      // consumer that computes a heuristic/deterministic ratio (honesty
+      // contract §4) got no number to compute. The call site is a callee NAME
+      // read from the tree, so 1.0 is the honest value and it is the value the
+      // lane's own relationship table already claimed.
+      confidence: 1,
+      ...this.nodeLine(calleeNameNode) ? { line_number: this.nodeLine(calleeNameNode) } : {},
+      metadata
+    };
+    ctx.relationships.push(callRel);
+    const selfImplType = this.selfReceiverImplType(node, functionNode);
+    if (selfImplType) {
+      const candidates = ctx.qualifiedCallCandidates ?? (ctx.qualifiedCallCandidates = /* @__PURE__ */ new Map());
+      candidates.set(callRel, `${selfImplType}::${target}`);
+    }
+    const qcOwner = parent && (parent.kind === ASTEngine.SymbolKind.Function || parent.kind === ASTEngine.SymbolKind.Method);
+    if (qcOwner) {
+      const arr = parent.qualified_calls ?? [];
+      arr.push(qualified);
+      parent.qualified_calls = arr;
+    }
+    let instTarget = null;
+    let bareSpelling = false;
+    if (functionNode.type === "field_expression" || functionNode.type === "scoped_identifier") {
+      const receiver = functionNode.childForFieldName("value") ?? functionNode.childForFieldName("path") ?? functionNode.namedChild(functionNode.namedChildCount - 2);
+      if (target === "new" && receiver) {
+        const recvText = this.stripGenerics(receiver.text);
+        let leaf = recvText.split("::").filter(Boolean).pop() ?? "";
+        if (leaf === "Self") leaf = this.enclosingImplType(node) ?? "";
+        if (leaf.length > 0 && leaf.charCodeAt(0) >= 65 && leaf.charCodeAt(0) <= 90) instTarget = leaf;
+      }
+    } else if (target.length > 0 && target.charCodeAt(0) >= 65 && target.charCodeAt(0) <= 90) {
+      instTarget = target;
+      if (!selfSpelling) bareSpelling = true;
+    }
+    if (instTarget === "Self") instTarget = this.enclosingImplType(node) ?? null;
+    if (instTarget) {
+      const instNameNode = functionNode.type === "identifier" ? functionNode : functionNode.type === "scoped_identifier" ? functionNode.childForFieldName("path") ?? functionNode : functionNode.childForFieldName("value") ?? functionNode;
+      ctx.pendingInstantiations.push({
+        source,
+        target: instTarget,
+        qualified,
+        line: this.nodeLine(instNameNode),
+        bareSpelling,
+        ...bareSpelling ? { callScope: (() => {
+          const scopePath = [];
+          let cur = node.parent ?? null;
+          let guard = 0;
+          while (cur && guard++ < 128) {
+            if (cur.type === "mod_item") {
+              const nm = cur.childForFieldName?.("name") ?? cur.namedChild(0);
+              scopePath.push(nm ? String(nm.text) : "");
+            }
+            cur = cur.parent;
+          }
+          return scopePath.reverse();
+        })() } : {}
+      });
+    }
+  }
+  /** Per-function cyclomatic complexity (T1 family contract). */
+  functionComplexityRust(node) {
+    const decisionTypes = /* @__PURE__ */ new Set([
+      // match ARMS are counted (per-case family granularity) - counting the
+      // match_expression TOO would double-count every dispatch.
+      "if_expression",
+      "match_arm",
+      "while_expression",
+      "loop_expression",
+      "for_expression",
+      "try_expression"
+    ]);
+    let c = 1;
+    const st = [node];
+    while (st.length) {
+      const n = st.pop();
+      if (decisionTypes.has(n.type)) c++;
+      else if (n.type === "binary_expression") {
+        const op = n.childForFieldName("operator")?.text;
+        if (op === "&&" || op === "||") c++;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const ch = n.namedChild(i);
+        if (ch) st.push(ch);
+      }
+    }
+    return c;
+  }
+  // Extract macro invocations: println!(), vec![], format!(), etc.
+  handleMacroInvocation(node, ctx, parent) {
+    const macroNode = node.childForFieldName("macro");
+    if (!macroNode) return;
+    let macroName = "";
+    let macroNameNode = macroNode;
+    if (macroNode.type === "scoped_identifier") {
+      const nameNode = macroNode.childForFieldName("name") || macroNode.namedChild(macroNode.namedChildCount - 1);
+      macroName = nameNode ? nameNode.text : macroNode.text;
+      macroNameNode = nameNode ?? macroNode;
+    } else {
+      macroName = macroNode.text;
+    }
+    if (!macroName) return;
+    if (macroName === "include") {
+      const tt = macroTokenTreeOf(node);
+      let includePath = null;
+      if (tt) {
+        for (let k = 0; k < tt.namedChildCount; k++) {
+          const c = tt.namedChild(k);
+          if (c && c.type === "string_literal") {
+            const raw = c.text;
+            includePath = raw.length >= 2 ? raw.slice(1, -1) : raw;
+            break;
+          }
+        }
+      }
+      if (includePath !== null && includePath.length > 0) {
+        const scope = (() => {
+          let cur = node.parent ?? null;
+          let guard = 0;
+          while (cur && guard++ < 64) {
+            if (cur.type === "function_item") {
+              const fn = cur.childForFieldName?.("name");
+              return fn ? String(fn.text) : RUST_FILE_SOURCE;
+            }
+            if (cur.type === "mod_item") {
+              const mn = cur.childForFieldName?.("name") ?? cur.namedChild(0);
+              return mn ? String(mn.text) : RUST_FILE_SOURCE;
+            }
+            cur = cur.parent;
+          }
+          return RUST_FILE_SOURCE;
+        })();
+        let projectFile = null;
+        if (ctx.projectRoot.length > 0 && path.isAbsolute(ctx.filePath)) {
+          const cand = path.resolve(path.dirname(ctx.filePath), includePath);
+          projectFile = confirmModuleFile([cand], ctx.projectRoot);
+        }
+        const partMetadata = {
+          partRole: "library",
+          isFileInclusion: true,
+          rustSpecific: true,
+          macroInvocation: true,
+          ...scope === RUST_FILE_SOURCE ? { fileLevel: true } : {}
+        };
+        if (projectFile) partMetadata.importProjectFile = projectFile;
+        ctx.relationships.push({
+          source: scope,
+          target: includePath,
+          fromSymbol: scope,
+          toSymbol: includePath,
+          type: ASTEngine.RelationshipType.PartOf,
+          // Read from the tree (the literal's own node), and the claim is statted — 1.0.
+          confidence: 1,
+          ...this.nodeLine(macroNameNode) ? { line_number: this.nodeLine(macroNameNode) } : {},
+          metadata: partMetadata
+        });
+      } else if (tt) {
+        this.noOwner(ctx, "part_of:include_non_literal");
+      }
+    }
+    if (macroName === "view" || macroName === "html" || macroName === "rsx" || macroName === "render" || macroName === "maud" || macroName === "markup") {
+      const ttR = macroTokenTreeOf(node);
+      if (ttR) {
+        const flat = [];
+        for (let k = 0; k < ttR.childCount; k++) {
+          const c = ttR.child(k);
+          if (!c) continue;
+          flat.push({ text: String(c.text), type: String(c.type) });
+        }
+        const BARE_HTML = /* @__PURE__ */ new Set(["div", "span", "p", "a", "ul", "li", "ol", "h1", "h2", "h3", "h4", "h5", "h6", "br", "hr", "img", "input", "button", "form", "table", "tr", "td", "th", "section", "header", "footer", "nav", "main", "aside", "article", "label", "select", "option", "textarea", "canvas", "svg", "path", "g", "template", "slot"]);
+        for (let k = 0; k + 1 < flat.length; k++) {
+          if (flat[k].text === "<" && flat[k + 1].type === "identifier") {
+            const tag = flat[k + 1].text;
+            if (tag.length > 0 && !BARE_HTML.has(tag.toLowerCase())) {
+              const hasSymbol = ctx.symbols.some((sym) => sym.name === tag);
+              if (hasSymbol) {
+                const renderScope = this.edgeSource(parent) ?? RUST_FILE_SOURCE;
+                ctx.relationships.push({
+                  source: renderScope,
+                  target: tag,
+                  fromSymbol: renderScope,
+                  toSymbol: tag,
+                  type: ASTEngine.RelationshipType.Renders,
+                  // The tag identifier and the same-file symbol match are both tree-read — 1.0.
+                  confidence: 1,
+                  ...this.nodeLine(macroNameNode) ? { line_number: this.nodeLine(macroNameNode) } : {},
+                  metadata: {
+                    renderMacro: macroName,
+                    isComponentTag: true,
+                    corpusUnexercised: true,
+                    rustSpecific: true
+                  }
+                });
+              } else {
+                this.noOwner(ctx, "renders:tag_not_a_same_file_symbol");
+              }
+            } else {
+              this.noOwner(ctx, "renders:bare_html_tag");
+            }
+            k++;
+          }
+        }
+      }
+    }
+    const source = this.edgeSource(parent);
+    if (!source) {
+      this.noOwner(ctx, "calls:macro_invocation");
+      return;
+    }
+    const metadata = { macroInvocation: true };
+    if (ctx.awaitedCalls.has(node.startIndex)) {
+      metadata.rustSpecific = true;
+      metadata.isAwait = true;
+    }
+    ctx.relationships.push({
+      source,
+      target: macroName,
+      fromSymbol: source,
+      toSymbol: `macro:${macroName}`,
+      type: ASTEngine.RelationshipType.Calls,
+      // INCOMING_RUST: same absent-confidence defect as the call edge above —
+      // a macro invocation's NAME is a callee read from the tree, so 1.0.
+      confidence: 1,
+      ...this.nodeLine(macroNameNode) ? { line_number: this.nodeLine(macroNameNode) } : {},
+      metadata
+    });
+    const qcOwner = parent && (parent.kind === ASTEngine.SymbolKind.Function || parent.kind === ASTEngine.SymbolKind.Method);
+    if (qcOwner) {
+      const arr = parent.qualified_calls ?? [];
+      arr.push(`macro:${macroName}`);
+      parent.qualified_calls = arr;
+    }
+    if (["panic", "todo", "unimplemented", "unreachable"].includes(macroName)) {
+      if (!ctx.metadata.patterns) ctx.metadata.patterns = [];
+      const pName = macroName + "!";
+      if (ctx.metadata.patterns.indexOf(pName) === -1) ctx.metadata.patterns.push(pName);
+    }
+  }
+  handleMacro(node, ctx, parent) {
+    let nameNode = node.childForFieldName("name");
+    if (!nameNode) {
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && child.type === "identifier") {
+          nameNode = child;
+          break;
+        }
+      }
+    }
+    if (!nameNode) return null;
+    const name = nameNode.text;
+    const symbol = this.createSymbol(name, ASTEngine.SymbolKind.Macro, node, parent);
+    ctx.symbols.push(symbol);
+    if (this.isPublic(node) || node.text.includes("#[macro_export]")) {
+      ctx.exports.push({
+        name,
+        type: "function",
+        range: symbol.range,
+        isType: false
+      });
+    }
+    return symbol;
+  }
+};
+export {
+  RealRustAnalyzer,
+  rustManifestFacts,
+  rustModuleFileCandidates,
+  rustSystemNamespaceOf
+};