@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/real-nim-analyzer-M7FAIABG.js

@@ -0,0 +1,3603 @@
+import {
+  findDeclaringParent
+} from "./chunk-OWISBAOF.js";
+import {
+  ASTEngine
+} from "./chunk-V44PGPA6.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-nim-analyzer.ts
+var RealNimAnalyzer = class {
+  analyze(rootNode, content, filePath, context) {
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    const fileValues = /* @__PURE__ */ new Set();
+    const fileTypes = /* @__PURE__ */ new Set();
+    const fileCallables = /* @__PURE__ */ new Set();
+    const nestedCallables = /* @__PURE__ */ new Set();
+    const fileEnumMembers = /* @__PURE__ */ new Set();
+    const fileFieldNames = /* @__PURE__ */ new Set();
+    const genericParamNames = /* @__PURE__ */ new Set();
+    const importQualifiers = /* @__PURE__ */ new Set();
+    const declaredSubtypes = /* @__PURE__ */ new Map();
+    const docCommentByStartLine = /* @__PURE__ */ new Map();
+    const fileComplexity = this.collectDocModulesAndComplexity(
+      rootNode,
+      docCommentByStartLine,
+      imports,
+      exports,
+      importQualifiers,
+      relationships
+    );
+    this.collectDeclarations(rootNode, {
+      symbols,
+      errors,
+      docCommentByStartLine,
+      fileValues,
+      fileTypes,
+      fileCallables,
+      nestedCallables,
+      fileEnumMembers,
+      fileFieldNames,
+      genericParamNames,
+      declaredSubtypes
+    });
+    this.publishModuleSymbol(rootNode, filePath, symbols);
+    this.collectContainment(symbols, relationships);
+    this.collectPragmaDecorates(rootNode, symbols, relationships);
+    this.collectInheritance(symbols, relationships, fileTypes);
+    this.collectContractRefinement(rootNode, symbols, relationships);
+    this.pruneForeignReExports(symbols, exports);
+    this.collectOverrides(symbols, relationships, declaredSubtypes, context?.overrideCompanion);
+    this.collectCallsAndUses(rootNode, relationships, {
+      fileValues,
+      fileTypes,
+      fileCallables,
+      nestedCallables,
+      fileEnumMembers,
+      fileFieldNames,
+      genericParamNames,
+      importQualifiers
+    });
+    this.classifyEvidenceTier(relationships);
+    return {
+      language: "nim",
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        complexity: fileComplexity,
+        cyclomaticComplexity: fileComplexity,
+        linesOfCode: content.split("\n").length,
+        patterns: [],
+        framework: "Nim",
+        hasFrameworkIntelligence: true,
+        hasTypeInference: true
+      }
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // 1. DOCUMENTATION COMMENTS
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * `##` and `##[` are DISTINCT node types from `#` in this grammar
+   * (`documentation_comment` / `block_documentation_comment` vs `comment`), and
+   * both are `extra` — so the parser places each one relative to the construct
+   * it documents in one of TWO ways, and reading only the first is why docstrings
+   * measured 0 through the real CLI:
+   *
+   *   1. ABSORBED. A `##` line that sits between a declaration's `proc` keyword
+   *      and its body (the overwhelmingly common shape for a documented proc:
+   *      `proc f()` / `## doc` / `  body`) becomes a CHILD of the declaration
+   *      node, so its `nextNamedSibling` is the body's `statement_list`, not the
+   *      declaration. Anchoring to the sibling in that case documents nothing.
+   *      Measured: the doc for `proc newPoint` attached to a `statement_list`.
+   *   2. SIBLING. A `##` line above a whole top-level construct
+   *      (`## doc` / `proc f() = body`) is a child of the enclosing scope
+   *      (`source_file` or a `type_section`) and its `nextNamedSibling` IS the
+   *      declaration it documents.
+   *
+   * So: when the comment's PARENT is itself a declaration container, it belongs
+   * to that parent; otherwise it belongs to its next named sibling. Both are
+   * grammar-structure facts, and both are indexed by the anchor node's start line
+   * so attachment stays O(1) with no nearest-previous scan.
+   */
+  /**
+   * ONE traversal that does the work of three: file doc comments, the module
+   * surface (import / from-import / include / export), and the file's own
+   * cyclomatic complexity.
+   *
+   * These were three independent full-tree walks. They are three because they
+   * were written at three different times, not because they need three visits:
+   * all three are pure visitors over the same nodes with no shared state and no
+   * order dependency between them. Measured on a 200-file sample they were 5-9%,
+   * 8-19% and 4-19% of analyzer time, so the redundant traversal was a third of
+   * the budget spent re-reading the same tree.
+   *
+   * The fused walk keeps ONE plain local counter and pushes onto ONE stack. That
+   * is deliberate and it is the lesson from the rejected memoization: the win
+   * here is fewer node VISITS (a WASM boundary crossing each), and the moment a
+   * fused walk allocates per-node state — a Map keyed by node id, say — it costs
+   * more than the walks it replaced. Nothing here allocates per node.
+   *
+   * Named children only, for the reason the complexity counter needs it: an
+   * anonymous keyword token carries the same type string as the statement that
+   * owns it, so descending into anonymous children double-counts every branch.
+   */
+  collectDocModulesAndComplexity(rootNode, out, imports, exports, qualifiers, relationships) {
+    const isDeclarationContainer = (n) => !!this.callableNodes[n.type] || n.type === "type_declaration" || n.type === "variable_declaration" || n.type === "enum_field_declaration" || n.type === "field_declaration";
+    let complexity = 1;
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      const t = n.type;
+      if (BRANCH_NODES.indexOf(t) !== -1) complexity++;
+      else if (t === "infix_expression") {
+        const op = n.childForFieldName("operator");
+        if (op && !op.isNamed && (op.type === "and" || op.type === "or" || op.type === "xor")) complexity++;
+      }
+      if (t === "documentation_comment" || t === "block_documentation_comment") {
+        const text = this.docCommentText(n);
+        if (text) {
+          const parent = n.parent;
+          const anchor = parent && isDeclarationContainer(parent) ? parent : n.nextNamedSibling;
+          if (anchor) out.set(anchor.startPosition.row + 1, text);
+        }
+        continue;
+      }
+      if (t === "import_statement") {
+        this.readImportStatement(n, imports, qualifiers, relationships);
+      } else if (t === "import_from_statement") {
+        this.readImportFromStatement(n, imports, qualifiers, relationships);
+      } else if (t === "include_statement") {
+        this.readIncludeStatement(n, imports, relationships);
+      } else if (t === "export_statement") {
+        this.readExportStatement(n, exports, relationships);
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return complexity;
+  }
+  /**
+   * Strip the `##` / `##[` opener and the comment body indentation by index
+   * arithmetic, never by a pattern over the comment text — the opener is the
+   * grammar's own anonymous token, so its length is known from the node, and
+   * the body is a single `comment_content` child. No regex is involved, so
+   * there is nothing here for the regex census to classify.
+   */
+  docCommentText(node) {
+    const opener = node.childCount > 0 ? node.child(0) : null;
+    const openerText = opener && !opener.isNamed ? opener.text : "";
+    const content = node.namedChildCount > 0 ? node.namedChild(0) : null;
+    let raw = content ? content.text : node.text;
+    if (!content && openerText && raw.startsWith(openerText)) raw = raw.slice(openerText.length);
+    const lines = raw.split("\n");
+    const cleaned = [];
+    for (const line of lines) {
+      let l = line;
+      let i = 0;
+      while (i < l.length && (l[i] === " " || l[i] === "	")) i++;
+      cleaned.push(i > 0 ? l.slice(i) : l);
+    }
+    while (cleaned.length > 0 && cleaned[0].trim() === "") cleaned.shift();
+    while (cleaned.length > 0 && cleaned[cleaned.length - 1].trim() === "") cleaned.pop();
+    return cleaned.join("\n");
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // 2. SYMBOLS
+  // ═══════════════════════════════════════════════════════════════════════
+  callableNodes = {
+    proc_declaration: { kind: ASTEngine.SymbolKind.Function, callableKind: "proc" },
+    func_declaration: { kind: ASTEngine.SymbolKind.Function, callableKind: "func" },
+    method_declaration: { kind: ASTEngine.SymbolKind.Method, callableKind: "method" },
+    iterator_declaration: { kind: ASTEngine.SymbolKind.Function, callableKind: "iterator" },
+    template_declaration: { kind: ASTEngine.SymbolKind.Macro, callableKind: "template" },
+    macro_declaration: { kind: ASTEngine.SymbolKind.Macro, callableKind: "macro" },
+    converter_declaration: { kind: ASTEngine.SymbolKind.Function, callableKind: "converter" }
+  };
+  /** Every value-binding section in the grammar, with the kind it declares.
+   *  `const` → Constant; `let`/`var`/`using` → Variable. */
+  valueSectionNodes = {
+    const_section: ASTEngine.SymbolKind.Constant,
+    let_section: ASTEngine.SymbolKind.Variable,
+    var_section: ASTEngine.SymbolKind.Variable,
+    using_section: ASTEngine.SymbolKind.Variable
+  };
+  collectDeclarations(rootNode, ctx) {
+    const stack = [{ node: rootNode, inCallable: false, enclosingCallable: "", docExample: false, objectKind: "" }];
+    while (stack.length > 0) {
+      const { node, inCallable, enclosingCallable, docExample, objectKind } = stack.pop();
+      const type = node.type;
+      if (type === "ERROR" || node.isMissing) {
+        ctx.errors.push({
+          message: `Nim syntax error: ${this.snippet(node.text)}`,
+          range: this.nodeRange(node),
+          severity: "error"
+        });
+      }
+      const callable = this.callableNodes[type];
+      if (callable) {
+        const sym = this.buildCallableSymbol(node, callable, ctx, inCallable, enclosingCallable);
+        if (sym) {
+          ctx.symbols.push(sym);
+          if (inCallable) ctx.nestedCallables.add(sym.name);
+          else ctx.fileCallables.add(sym.name);
+        }
+        this.pushCallableChildren(node, stack, enclosingCallable);
+        continue;
+      }
+      if (type === "type_declaration") {
+        if (!inCallable || docExample) {
+          const sym = this.buildTypeSymbol(node, ctx, objectKind);
+          if (sym) {
+            ctx.symbols.push(sym);
+            ctx.fileTypes.add(sym.name);
+            for (const g of sym.genericParameters ?? []) ctx.genericParamNames.add(g);
+            this.pushTypeMembers(node, sym, ctx);
+          }
+        }
+        this.pushChildren(node, stack, inCallable, enclosingCallable, docExample, objectKind);
+        continue;
+      }
+      const sectionKind = this.valueSectionNodes[type];
+      if (sectionKind) {
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const decl = node.namedChild(i);
+          if (decl && decl.type === "variable_declaration") {
+            for (const sym of this.buildValueSymbols(decl, sectionKind, type, inCallable || docExample, ctx)) {
+              ctx.symbols.push(sym);
+              ctx.fileValues.add(sym.name);
+            }
+          }
+        }
+        this.pushChildren(node, stack, inCallable, enclosingCallable, docExample, objectKind);
+        continue;
+      }
+      const childObjectKind = type === "ref_type" ? "ref_type" : type === "pointer_type" ? "pointer_type" : type === "distinct_type" || type === "out_type" || type === "var_type" ? type : objectKind;
+      this.pushChildren(
+        node,
+        stack,
+        inCallable,
+        enclosingCallable,
+        docExample,
+        childObjectKind,
+        inCallable ? this.runnableExamplesArgument(node) : null
+      );
+    }
+  }
+  /**
+   * `runnableExamples:` — a `##` doc-comment block the Nim COMPILER compiles.
+   *
+   * ## What the grammar does with it, and why it matters
+   *
+   * The pinned grammar does not give the block a node type. For
+   *
+   *     proc `of`*[T, S](x: T, y: typedesc[S]): bool =
+   *       ## Checks if `x` is an instance of `y`.
+   *       runnableExamples:
+   *         type
+   *           Base = ref object of RootObj
+   *           Sub1 = ref object of Base
+   *           Sub2 = ref object of Base
+   *
+   * it emits ONE `documentation_comment` node for the first `##` line, and then
+   * parses `runnableExamples:` as ordinary CODE — a `call` whose `function` is the
+   * identifier `runnableExamples` and whose `argument_list` holds the whole
+   * example body — INSIDE the routine's `body` field. So the example's types are
+   * body-locals by tree position, and the C-D1 rule (a `type` section inside a
+   * body is an execution artifact) correctly suppressed them.
+   *
+   * That rule is right for a body and wrong here, because a `runnableExamples`
+   * block is not the routine's body: it is a separate compilation unit that
+   * `nim doc` type-checks, and the declarations in it are real.
+   *
+   * ## Measured cost of getting it wrong, and what is left
+   *
+   * Over 4,555 corpus files, 9 `object_declaration.inherits` occurrences on the
+   * parse tree had an owner symbol the analyzer published NOWHERE. This rule took
+   * that to 6, and the six that remain are three different things, none of them
+   * this rule:
+   *
+   *   - 2 in nimsuggest/tests/fixtures/mclass_macro.nim — `type \`typeName\` of
+   *     \`baseName\``, a macro that BUILDS an inheritance clause from two
+   *     backtick parameters. The declarations exist only as macro input.
+   *   - 1 in tests/macros/tgettypeinst.nim — `_ of Model`, where the declared
+   *     name is `_` and the analyzer suppresses `_` by design (it is Nim's
+   *     discard name for a declaration).
+   *   - 1 each in tests/stdlib/trepr.nim (`TFoo`, under `static:` inside a proc)
+   *     and tests/template/template_issues.nim (`name`, inside a `template` body)
+   *     — a `type` section inside a BODY, which is the C-D1 rule and is
+   *     deliberate. A `runnableExamples` block is a separate compilation unit; a
+   *     `static:` block or a template body is not.
+   *
+   * So the honest claim is 9 -> 6, with the residue enumerated. An earlier draft
+   * of this comment said the rule emptied the bucket; the measurement says
+   * otherwise and the measurement is what is written here.
+   *
+   * ## What is published, and what is not
+   *
+   * The block's `type_section` declarations are published — they are type
+   * declarations the compiler checks. Its value declarations are NOT: `var base:
+   * Base = Sub1()` is a local of the EXAMPLE, exactly like a local of a routine
+   * body, and publishing it as a file-scope value would be the same defect in the
+   * opposite direction.
+   *
+   * The trigger is read off the tree as a SHAPE WITH A ROLE — a `call` whose
+   * `function` field is the identifier `runnableExamples` — not as a text search,
+   * so a comment or a string cannot fake it. It fires only inside a routine body,
+   * because outside one `runnableExamples` is an ordinary (if odd) call and its
+   * arguments are ordinary expressions.
+   */
+  runnableExamplesArgument(node) {
+    if (node.type !== "call") return null;
+    const fn = node.childForFieldName("function") ?? this.namedChildOfType(node, "identifier");
+    if (!fn || fn.type !== "identifier") return null;
+    if (String(fn.text) !== "runnableExamples") return null;
+    const args = this.namedChildOfType(node, "argument_list");
+    if (!args) return null;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const c = args.namedChild(i);
+      if (c && (c.type === "statement_list" || c.type === "block")) return args;
+    }
+    return null;
+  }
+  /** The first NAMED child of the given node type, or null. */
+  namedChildOfType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === type) return c;
+    }
+    return null;
+  }
+  buildCallableSymbol(node, callable, ctx, inCallable, enclosingCallable) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode) return null;
+    const nameInfo = this.readNameNode(nameNode);
+    if (!nameInfo.name || nameInfo.name === "_") return null;
+    const parameters = this.readParameters(node);
+    const returnNode = node.childForFieldName("return_type");
+    const body = node.childForFieldName("body");
+    const genericParameters = this.readGenericParameterNames(node);
+    for (const g of genericParameters) ctx.genericParamNames.add(g);
+    const pragmas = this.readPragmaNames(node);
+    const hasPragma = (n) => pragmas.indexOf(n) !== -1;
+    const doc = ctx.docCommentByStartLine.get(node.startPosition.row + 1);
+    const receiverType = callable.callableKind === "method" ? this.methodReceiverTypeLeaf(node) : void 0;
+    const nestedIn = inCallable ? enclosingCallable : "";
+    const sym = {
+      name: nameInfo.name,
+      kind: callable.kind,
+      visibility: nestedIn ? "private" : nameInfo.exported ? "public" : "private",
+      range: this.nodeRange(node),
+      scope: nestedIn || void 0,
+      parameters,
+      returnType: returnNode ? this.nodeText(returnNode) : void 0,
+      genericParameters: genericParameters.length > 0 ? genericParameters : void 0,
+      decorators: pragmas.length > 0 ? pragmas : void 0,
+      comments: doc ? [doc] : void 0,
+      // A METHOD's owner is its receiver TYPE, and `ownerName` is the
+      // family-standard field for that — the one the store binds for ownership
+      // and the one `buildOverrideCompanion` keys on to index
+      // (owner -> declared method names) from previously parsed files.
+      //
+      // Leaving it unset made NIM methods invisible to every owner-based
+      // mechanism in the codebase, not just this one: the companion index came
+      // back EMPTY for a file whose base class declared a method, so
+      // cross-file override resolution could not work no matter what the
+      // override pass did. The receiver was already known, just parked in
+      // `metadata.nimReceiverType` where nothing generic reads it. The metadata
+      // copy stays — the override labels are built from it, and it is the
+      // documented place the receiver is recorded.
+      ...receiverType ? { ownerName: receiverType, ownerKind: ASTEngine.SymbolKind.Class } : {},
+      // `qualifiedName` is the disambiguating handle the override edges need.
+      // `overrides` endpoints are receiver-qualified (`Rect.describe`) because the
+      // bare name `describe` cannot address either end — and a consumer that
+      // resolves an edge by matching a target against published names has no way
+      // to reach `Rect.describe` unless some symbol publishes that spelling.
+      // Measured on nim/lib/pure (105 files, 6,638 symbols) with
+      // `script/m14/incoming-check.ts`: all 14 `overrides` edges reported as
+      // UNRESOLVED targets, every one of them a correct receiver-qualified edge.
+      // This is the same field the lua lane fills for the same reason
+      // (real-lua-analyzer.ts: `qualifiedName: label`, "the `name` field is the
+      // identity; this is the path").
+      ...receiverType ? { qualifiedName: `${receiverType}.${nameInfo.name}` } : {},
+      // The store binds `brain_symbol.docstring` from this field (see
+      // parallel-indexer's insertSymbol binding). Emitting only `comments`
+      // produced docs=0 for every nim symbol through the real CLI, so the `##`
+      // text is published under BOTH names.
+      ...doc ? { docstring: doc } : {},
+      complexity: body ? this.nimCyclomaticComplexity(body) : 1,
+      metadata: {
+        nimCallableKind: callable.callableKind,
+        // `isDeclaration` is the DECLARATION vs DEFINITION discriminator: the
+        // `routine` production makes `=`+`body` optional, so a body-less
+        // `proc f(): int` is a forward declaration. Nim has no separate
+        // forward-declaration syntax, so this shape only appears in .nims
+        // and macro-generated code — but when it does, an `extern`-like
+        // declaration competing on equal footing with the definition that
+        // implements it is exactly the zig #612 defect class.
+        ...body ? {} : { isDeclaration: true },
+        ...nameInfo.exported ? { exported: true } : {},
+        paramCount: parameters.length,
+        ...genericParameters.length > 0 ? { genericParameterCount: genericParameters.length } : {},
+        ...nestedIn ? { nimNestedIn: nestedIn } : {},
+        ...callable.callableKind === "method" ? { nimReceiverType: receiverType } : {},
+        // The receiver-qualified LABEL, recorded in metadata as well as in
+        // `qualifiedName`. Two reasons, both measured:
+        //   - `pool-worker.ts:870` reads `s.qualifiedName || s.metadata?.fqn ||
+        //     (s.scope ? …)`, so `metadata.fqn` is the worker\'s own declared
+        //     fallback channel and this is where the same fact belongs for a
+        //     consumer that reads metadata.
+        //   - `script/m14/run-fixtures.ts` cannot assert `qualifiedName`: it is
+        //     absent from that file\'s CONSTRAINT_KEY_ALLOWLIST, so a fixture row
+        //     carrying it is reported as an INERT assertion and the
+        //     `nim/method-qualified-name-dropped` mutant survives. `meta.*` keys
+        //     ARE assertable, so the same fact is pinned here instead of nowhere.
+        //     The allowlist gap is reported to the supervisor rather than edited
+        //     (workstream §8).
+        ...receiverType ? { fqn: `${receiverType}.${nameInfo.name}` } : {},
+        ...node.childForFieldName("rewrite_pattern") ? { nimRewritePattern: true } : {},
+        ...hasPragma("raises") ? { nimRaises: true } : {},
+        ...hasPragma("noSideEffect") ? { nimNoSideEffect: true } : {},
+        ...hasPragma("inline") ? { nimInline: true } : {},
+        ...hasPragma("deprecated") ? { nimDeprecated: true } : {},
+        ...hasPragma("base") ? { nimBaseMethod: true } : {},
+        ...hasPragma("tailcall") ? { nimTailcall: true } : {},
+        ...hasPragma("asm") ? { nimAsm: true } : {},
+        nameRange: nameInfo.range
+      }
+    };
+    if (doc) sym.metadata.nimDocumented = true;
+    return sym;
+  }
+  buildTypeSymbol(node, ctx, parentObjectKind) {
+    const symDecl = node.namedChildCount > 0 ? node.namedChild(0) : null;
+    if (!symDecl || symDecl.type !== "type_symbol_declaration") return null;
+    const nameNode = symDecl.childForFieldName("name");
+    if (!nameNode) return null;
+    const nameInfo = this.readNameNode(nameNode);
+    if (!nameInfo.name || nameInfo.name === "_") return null;
+    const genericParameters = this.readGenericParameterNames(symDecl);
+    const doc = ctx.docCommentByStartLine.get(node.startPosition.row + 1);
+    let objectKind = parentObjectKind;
+    let inherits = null;
+    let objectNode = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c || i === 0) continue;
+      if (c.type === "ref_type" || c.type === "pointer_type" || c.type === "out_type" || c.type === "var_type" || c.type === "distinct_type") {
+        objectKind = c.type;
+        const inner = this.lastNamedChild(c);
+        if (inner && inner.type === "object_declaration") objectNode = inner;
+      } else if (c.type === "object_declaration") {
+        objectNode = c;
+      } else if (c.type === "type_expression") {
+        const inner = c.namedChildCount > 0 ? c.namedChild(0) : null;
+        if (inner) {
+          if (inner.type === "object_declaration") objectNode = inner;
+          else if (inner.type === "ref_type" || inner.type === "pointer_type" || inner.type === "out_type" || inner.type === "var_type" || inner.type === "distinct_type") {
+            objectKind = inner.type;
+            const deep = this.lastNamedChild(inner);
+            if (deep && deep.type === "object_declaration") objectNode = deep;
+          }
+        }
+      }
+    }
+    if (objectNode && objectKind === "") objectKind = "object";
+    if (objectNode) {
+      const inh = objectNode.childForFieldName("inherits");
+      if (inh) inherits = this.typeLeafName(inh);
+    }
+    let kind;
+    const rhs = this.typeDefinitionRhs(node);
+    if (rhs && rhs.type === "concept_declaration") {
+      kind = ASTEngine.SymbolKind.Interface;
+    } else if (rhs && rhs.type === "enum_declaration") {
+      kind = ASTEngine.SymbolKind.Enum;
+    } else if (objectNode) {
+      kind = objectKind === "ref_type" ? ASTEngine.SymbolKind.Class : ASTEngine.SymbolKind.Struct;
+    } else if (rhs && (rhs.type === "tuple_type" || rhs.type === "tuple_deconstruct_declaration" || rhs.type === "tuple_construction")) {
+      kind = ASTEngine.SymbolKind.Struct;
+    } else {
+      kind = ASTEngine.SymbolKind.Type;
+    }
+    const refines = rhs && rhs.type === "concept_declaration" ? this.readRefinedConcepts(rhs) : [];
+    const sym = {
+      name: nameInfo.name,
+      kind,
+      visibility: nameInfo.exported ? "public" : "private",
+      range: this.nodeRange(node),
+      parameters: rhs && rhs.type === "concept_declaration" ? this.readConceptParameters(rhs) : void 0,
+      genericParameters: genericParameters.length > 0 ? genericParameters : void 0,
+      comments: doc ? [doc] : void 0,
+      ...doc ? { docstring: doc } : {},
+      metadata: {
+        nimTypeDefinition: true,
+        ...objectKind ? { nimObjectKind: objectKind } : {},
+        ...inherits ? { nimInherits: inherits } : {},
+        ...refines.length > 0 ? { nimRefines: refines } : {},
+        ...rhs ? { nimTypeRhs: this.nodeText(rhs) } : {},
+        nameRange: nameInfo.range
+      }
+    };
+    if (doc) sym.metadata.nimDocumented = true;
+    return sym;
+  }
+  /**
+   * The contracts a concept refines — `type A = concept x of B` names `B`.
+   *
+   * The grammar puts the clause in a `refines` field of type `refinement_list`,
+   * which is `sep1($.type_expression, ",")`, so `of Number, Container` is two
+   * entries and each entry is a `type_expression`. Reading the FIELD rather than
+   * the `of` keyword is what makes this immune to the failure the arbiter
+   * documents about text probes: `is` inside a concept body is a different
+   * construct entirely (it is how a concept states its body is satisfied), and a
+   * probe on the word would count those too.
+   *
+   * Each entry is named by its leaf, because the store resolves an edge by
+   * matching the endpoint against a symbol name and the R10 rule requires the
+   * spelling the lane itself uses. A qualified refinement keeps the written
+   * spelling in `nimRefinesQualified`, which is the same two-part record the f#
+   * lane writes for `System.IDisposable`.
+   */
+  readRefinedConcepts(concept) {
+    const list = this.refinementListOf(concept);
+    if (!list) return [];
+    const out = [];
+    for (let i = 0; i < list.namedChildCount; i++) {
+      const entry = list.namedChild(i);
+      if (!entry) continue;
+      const leaf = this.typeConstructorLeaf(entry);
+      const written = this.nodeText(entry);
+      const name = leaf ? leaf.text : this.lastPathSegment(written);
+      if (!name || out.indexOf(name) !== -1) continue;
+      out.push(name);
+    }
+    return out;
+  }
+  /**
+   * A `concept_declaration`'s `refinement_list`, or null when the concept
+   * refines nothing.
+   *
+   * ## The field shape, MEASURED
+   *
+   * `childForFieldName("refines")` on `type A = concept x of Number, Container`
+   * returns a node whose OWN TYPE is `refinement_list`, not a wrapper holding
+   * one — `childForFieldName("refinement_list")` on the same node returns null,
+   * while `childForFieldName("refines")` returns the two-entry list.
+   *
+   * Both readers of this clause (`readRefinedConcepts` for `implements`, the
+   * `concept_declaration` arm of `collectDeclaredTypeRefAt` for `references`)
+   * looked for a CHILD of that type on the field node instead, so both returned
+   * null on every file in the corpus and on a fixture that spells the construct
+   * correctly. Two readers independently wrong about one grammar fact is the
+   * reason the fact now has one function: the next grammar bump changes this.
+   */
+  refinementListOf(concept) {
+    const ref = concept.childForFieldName("refines");
+    if (!ref) return null;
+    return ref.type === "refinement_list" ? ref : this.firstChildOfType(ref, "refinement_list");
+  }
+  /** The final `/`- or `.`-separated segment of a written type name. Index
+   *  arithmetic only — no pattern matching, like every other position reader in
+   *  this analyzer. */
+  lastPathSegment(written) {
+    let cut = written.length;
+    for (let i = written.length - 1; i >= 0; i--) {
+      const ch = written[i];
+      if (ch === "/" || ch === ".") {
+        cut = i + 1;
+        break;
+      }
+    }
+    const seg = written.slice(cut);
+    return seg.length > 0 && seg.indexOf(" ") === -1 ? seg : "";
+  }
+  /** The node AFTER the `=` in a `type_declaration` — the `typeDefValue`. */
+  typeDefinitionRhs(node) {
+    const seenEq = { value: false };
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (!c) continue;
+      if (!seenEq.value) {
+        if (!c.isNamed && c.type === "=") seenEq.value = true;
+        continue;
+      }
+      if (c.isNamed) return this.unwrapTypeExpression(c);
+    }
+    return null;
+  }
+  /**
+   * See through the `type_expression` wrapper the grammar puts around a type
+   * RHS, so the classifier sees the SHAPE rather than the wrapper.
+   *
+   * Found by mutation, not by inspection (nim/tuple-type-classified-as-a-type
+   * SURVIVED the first run, which is the harness reporting that a documented
+   * rule — "a tuple type is a struct" — had no test behind it and turned out
+   * to be FALSE). The trees for the three shapes are not parallel:
+   *
+   *   type Color = enum …      -> enum_declaration          (no wrapper)
+   *   type A = concept x       -> concept_declaration       (no wrapper)
+   *   type Pair = tuple[x, y]  -> type_expression           (WRAPPER)
+   *                                 └── tuple_type
+   *
+   * so the old rule matched `tuple_type` at the top level, never saw it behind
+   * the wrapper, and `type Pair = tuple[x, y: int]` fell through to the
+   * catch-all and published a bare `type` — losing the struct kind its own
+   * documentation promised.
+   *
+   * ONLY THE SHAPES THE WIRED GRAMMAR ACTUALLY DISTINGUISHES ARE LISTED. Seven
+   * branches here used to test `array_type` / `generic_type` / `sequence_type` /
+   * `set_type` / `table_type` / `range_type` / `ordinal_type` — names from a
+   * different tree-sitter-nim revision. The wired build (`wasm/tree-sitter-nim.wasm`,
+   * 377 named node types) declares NONE of them, and the shapes they were meant
+   * for are not separate nodes at all: `seq[int]`, `array[3, int]`, `set[Color]`,
+   * `Table[string, int]` and `range[0..10]` each parse as
+   * `type_expression > bracket_expression` (each spelling parsed against the wired
+   * wasm on 2026-11-04 to confirm). The classifier below deliberately publishes
+   * every one of those as a type-level name through its catch-all, so the seven
+   * branches were unreachable and no behaviour is lost by deleting them. A
+   * correct-name rewrite (`bracket_expression`) was considered and rejected as a
+   * NO-OP: `typeConstructorLeaf`/`typeArgumentNodes` descend through the wrapper
+   * either way and the classifier's catch-all is the same branch, so the rewrite
+   * would only add code whose reachability no fixture could distinguish. Dead
+   * branches are deleted rather than kept, per the F1 rule.
+   */
+  unwrapTypeExpression(node) {
+    let cur = node;
+    for (let i = 0; i < 8; i++) {
+      if (cur.type !== "type_expression") return cur;
+      const inner = this.firstChildOfType(cur, "tuple_type") ?? this.firstChildOfType(cur, "tuple_construction") ?? this.firstChildOfType(cur, "enum_declaration") ?? this.firstChildOfType(cur, "concept_declaration") ?? this.firstChildOfType(cur, "object_declaration") ?? this.firstChildOfType(cur, "ref_type") ?? this.firstChildOfType(cur, "distinct_type") ?? this.firstChildOfType(cur, "pointer_type");
+      if (!inner) return cur;
+      cur = inner;
+    }
+    return cur;
+  }
+  /**
+   * Object/enum members. These ARE symbols: the object owns them, so they get
+   * `ownerName`/`ownerKind` and a `contains` edge. A field declaration can name
+   * several fields at once (`x, y: int`), so one `field_declaration` yields one
+   * symbol per `symbol_declaration` — with the declaration's own range and a
+   * per-name `nameRange`.
+   */
+  pushTypeMembers(node, owner, ctx) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "field_declaration" || n.type === "variant_discriminator_declaration") {
+        for (const sym of this.buildFieldSymbols(n, owner, ctx.docCommentByStartLine)) {
+          ctx.symbols.push(sym);
+          ctx.fileFieldNames.add(sym.name);
+        }
+      } else if (n.type === "enum_field_declaration") {
+        for (const sym of this.buildEnumFieldSymbols(n, owner, ctx.docCommentByStartLine)) {
+          ctx.symbols.push(sym);
+          ctx.fileEnumMembers.add(sym.name);
+        }
+      } else if (n.type === "object_declaration") {
+        const inh = n.childForFieldName("inherits");
+        if (inh) {
+          const base = this.typeLeafName(inh);
+          const set = ctx.declaredSubtypes.get(base) ?? /* @__PURE__ */ new Set();
+          set.add(owner.name);
+          ctx.declaredSubtypes.set(base, set);
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  /** True when some ancestor of `node` has the given type, within a bounded
+   *  walk. A malformed tree cannot hang this: the guard is 64 levels, deeper
+   *  than any declaration nesting the grammar produces. */
+  hasAncestorOfType(node, type) {
+    let cur = node.parent;
+    for (let i = 0; cur && i < 64; i++) {
+      if (cur.type === type) return true;
+      cur = cur.parent;
+    }
+    return false;
+  }
+  /** True when this `variant_discriminator_declaration` holds an author-written
+   *  discriminator rather than a branch list the parser absorbed.
+   *
+   *  A genuine discriminator is written adjacent to `case` — `case kind: Kind` —
+   *  so its name node shares a source row with the `case` token. The bare form
+   *  has no name to write, recovery attaches the following `of A, B:` line to the
+   *  slot, and that line is on a later row by construction.
+   *
+   *  The `case` token is looked up among the owning `variant_declaration`'s
+   *  children rather than through a field name, because the grammar exposes it as
+   *  an anonymous `case` token. A missing token is answered pessimistically
+   *  (NOT adjacent), so an unexpected tree drops the field instead of publishing a
+   *  fabricated one — the asymmetry is deliberate: a lost field is recoverable,
+   *  a fabricated edge poisons `bb_graph`, `bb_impact` and `bb_migrate`. */
+  discriminatorIsAdjacentToCase(node) {
+    const owner = node.parent;
+    if (!owner || owner.type !== "variant_declaration") return false;
+    let caseTok = null;
+    for (let i = 0; i < owner.childCount; i++) {
+      const c = owner.child(i);
+      if (c && c.type === "case") {
+        caseTok = c;
+        break;
+      }
+    }
+    if (!caseTok) return false;
+    return caseTok.startPosition.row === node.startPosition.row;
+  }
+  buildFieldSymbols(node, owner, docCommentByStartLine) {
+    const out = [];
+    const list = node.namedChildCount > 0 ? node.namedChild(0) : null;
+    if (!list || list.type !== "symbol_declaration_list") return out;
+    const typeNode = node.childForFieldName("type");
+    if (!typeNode && this.hasAncestorOfType(node, "tuple_type")) return out;
+    if (node.type === "variant_discriminator_declaration" && !this.discriminatorIsAdjacentToCase(node)) {
+      return out;
+    }
+    const doc = docCommentByStartLine.get(node.startPosition.row + 1);
+    for (let i = 0; i < list.namedChildCount; i++) {
+      const decl = list.namedChild(i);
+      if (!decl) continue;
+      if (decl.type === "tuple_deconstruct_declaration") {
+        for (const s of this.buildFieldSymbols(decl, owner, docCommentByStartLine)) out.push(s);
+        continue;
+      }
+      if (decl.type !== "symbol_declaration") continue;
+      const nameNode = decl.childForFieldName("name");
+      if (!nameNode) continue;
+      const nameInfo = this.readNameNode(nameNode);
+      if (!nameInfo.name || nameInfo.name === "_") continue;
+      out.push({
+        name: nameInfo.name,
+        kind: ASTEngine.SymbolKind.Property,
+        visibility: nameInfo.exported ? "public" : "private",
+        range: this.nodeRange(node),
+        scope: owner.name,
+        ownerName: owner.name,
+        ownerKind: owner.kind,
+        returnType: typeNode ? this.nodeText(typeNode) : void 0,
+        comments: doc ? [doc] : void 0,
+        ...doc ? { docstring: doc } : {},
+        metadata: {
+          nimField: true,
+          ...node.type === "variant_discriminator_declaration" ? { nimVariantDiscriminator: true } : {},
+          nameRange: nameInfo.range
+        }
+      });
+    }
+    return out;
+  }
+  buildEnumFieldSymbols(node, owner, docCommentByStartLine) {
+    const out = [];
+    const decl = node.namedChildCount > 0 ? node.namedChild(0) : null;
+    if (!decl || decl.type !== "symbol_declaration") return out;
+    const nameNode = decl.childForFieldName("name");
+    if (!nameNode) return out;
+    const nameInfo = this.readNameNode(nameNode);
+    if (!nameInfo.name || nameInfo.name === "_") return out;
+    const doc = docCommentByStartLine.get(node.startPosition.row + 1);
+    out.push({
+      name: nameInfo.name,
+      kind: ASTEngine.SymbolKind.EnumMember,
+      visibility: nameInfo.exported ? "public" : "private",
+      range: this.nodeRange(node),
+      scope: owner.name,
+      ownerName: owner.name,
+      ownerKind: owner.kind,
+      comments: doc ? [doc] : void 0,
+      metadata: { nimEnumMember: true, nameRange: nameInfo.range }
+    });
+    return out;
+  }
+  /**
+   * `const`/`let`/`var`/`using` declarations. Nim allows several names in one
+   * declaration (`var a, b: int`); each is a symbol with the declaration's
+   * range and its own `nameRange`.
+   */
+  buildValueSymbols(decl, kind, section, inCallable, ctx) {
+    if (inCallable) return [];
+    const out = [];
+    const list = decl.namedChildCount > 0 ? decl.namedChild(0) : null;
+    if (!list || list.type !== "symbol_declaration_list") return out;
+    const typeNode = decl.childForFieldName("type");
+    const valueNode = decl.childForFieldName("value");
+    const doc = ctx.docCommentByStartLine.get(decl.startPosition.row + 1);
+    for (let i = 0; i < list.namedChildCount; i++) {
+      const d = list.namedChild(i);
+      if (!d) continue;
+      if (d.type === "tuple_deconstruct_declaration") {
+        continue;
+      }
+      if (d.type !== "symbol_declaration") continue;
+      const nameNode = d.childForFieldName("name");
+      if (!nameNode) continue;
+      const nameInfo = this.readNameNode(nameNode);
+      if (!nameInfo.name || nameInfo.name === "_") continue;
+      out.push({
+        name: nameInfo.name,
+        kind,
+        visibility: nameInfo.exported ? "public" : "private",
+        range: this.nodeRange(decl),
+        returnType: typeNode ? this.nodeText(typeNode) : void 0,
+        comments: doc ? [doc] : void 0,
+        metadata: {
+          nimValueBinding: true,
+          nimSection: section,
+          ...valueNode ? { nimHasInitializer: true } : {},
+          ...nameInfo.exported ? { exported: true } : {},
+          nameRange: nameInfo.range
+        }
+      });
+    }
+    return out;
+  }
+  /**
+   * Names bound by ONE `let`/`var`/`const` head, including destructuring.
+   *
+   * Measured defect this fixes (pixie tests/megatest_emoji.nim line 42, found by
+   * the NIM differential, not by inspection): the frame binder walked a
+   * `symbol_declaration_list` and took only children whose type was
+   * `symbol_declaration`, so a DESTRUCTURING binding was skipped whole. The
+   * grammar nests those:
+   *
+   *   variable_declaration          "(_, name, _) = splitFile(filePath)"
+   *     symbol_declaration_list
+   *       tuple_deconstruct_declaration
+   *         symbol_declaration      "_"      -> blank_identifier
+   *         symbol_declaration      "name"   -> identifier
+   *         symbol_declaration      "_"      -> blank_identifier
+   *
+   * `name` therefore never entered the frame, `isShadowed("name")` was false at
+   * the `images.add((name, image))` read, and the analyzer attributed a read of
+   * the LOCAL to `EmojiSet.name` — a struct property declared 26 lines earlier
+   * and unrelated to the binding. The edge was not dangling (the target is a
+   * real symbol), so no dangling check could ever have caught it: only the
+   * shadow rule was wrong. That is the whole class — a same-named field
+   * anywhere in the file could absorb any destructured, iterated or
+   * pattern-bound local.
+   *
+   * Recursive, because the pattern nests: `let ((a, b), c) = …` is a
+   * tuple_deconstruct_declaration inside a tuple_deconstruct_declaration.
+   */
+  readBoundDeclarationNames(list) {
+    const out = [];
+    const visit = (n) => {
+      if (!n) return;
+      if (n.type === "tuple_deconstruct_declaration") {
+        for (let i = 0; i < n.namedChildCount; i++) visit(n.namedChild(i));
+        return;
+      }
+      if (n.type !== "symbol_declaration") return;
+      const nameNode = n.childForFieldName("name");
+      const info = nameNode ? this.readNameNode(nameNode) : null;
+      if (info?.name && info.name !== "_") out.push(info.name);
+    };
+    for (let i = 0; i < list.namedChildCount; i++) visit(list.namedChild(i));
+    return out;
+  }
+  readParameters(node) {
+    const paramsNode = node.childForFieldName("parameters");
+    if (!paramsNode) return [];
+    const out = [];
+    for (let i = 0; i < paramsNode.namedChildCount; i++) {
+      const p = paramsNode.namedChild(i);
+      if (!p) continue;
+      if (p.type === "parameter_declaration") {
+        const typeNode = p.childForFieldName("type");
+        const valueNode = p.childForFieldName("value");
+        const list = p.namedChildCount > 0 ? p.namedChild(0) : null;
+        if (!list) continue;
+        for (let j = 0; j < list.namedChildCount; j++) {
+          const d = list.namedChild(j);
+          if (!d || d.type !== "symbol_declaration") continue;
+          const nameNode = d.childForFieldName("name");
+          if (!nameNode) continue;
+          const info = this.readNameNode(nameNode);
+          if (!info.name) continue;
+          out.push({
+            name: info.name,
+            type: typeNode ? this.nodeText(typeNode) : void 0,
+            defaultValue: valueNode ? this.nodeText(valueNode) : void 0,
+            isOptional: valueNode != null,
+            ...info.exported ? { exported: true } : {}
+          });
+        }
+      }
+    }
+    return out;
+  }
+  readGenericParameterNames(node) {
+    const field = node.childForFieldName("generic_parameters");
+    if (field) return this.genericNamesFrom(field);
+    const direct = this.firstChildOfType(node, "generic_parameter_list");
+    if (direct) return this.genericNamesFrom(direct);
+    const first = node.namedChildCount > 0 ? node.namedChild(0) : null;
+    if (first && first.type === "type_symbol_declaration") return this.readGenericParameterNames(first);
+    return [];
+  }
+  genericNamesFrom(list) {
+    const out = [];
+    for (let i = 0; i < list.namedChildCount; i++) {
+      const p = list.namedChild(i);
+      if (!p) continue;
+      if (p.type !== "parameter_declaration") {
+        if (p.type === "identifier") out.push(p.text);
+        continue;
+      }
+      const declList = p.namedChildCount > 0 ? p.namedChild(0) : null;
+      if (!declList) continue;
+      for (let j = 0; j < declList.namedChildCount; j++) {
+        const d = declList.namedChild(j);
+        if (!d) continue;
+        if (d.type === "symbol_declaration") {
+          const n = d.childForFieldName("name");
+          const info = n ? this.readNameNode(n) : null;
+          if (info?.name) out.push(info.name);
+        } else if (d.type === "tuple_deconstruct_declaration") {
+          const info = this.readNameNode(d);
+          if (info.name) out.push(info.name);
+        }
+      }
+    }
+    return out;
+  }
+  readConceptParameters(concept) {
+    const list = concept.childForFieldName("parameters");
+    if (!list) return [];
+    const out = [];
+    for (let i = 0; i < list.namedChildCount; i++) {
+      const p = list.namedChild(i);
+      if (!p) continue;
+      if (p.type === "identifier") {
+        out.push({ name: p.text });
+        continue;
+      }
+      if (p.namedChildCount > 0) {
+        const sym = p.namedChild(p.namedChildCount - 1);
+        if (sym && sym.type === "identifier") {
+          out.push({ name: sym.text, ...p.type === "type_parameter" ? { isType: true } : {} });
+        }
+      }
+    }
+    return out;
+  }
+  /** Pragma names in the declaration's own `pragmas` field. `{.raises: [].}`
+   *  parses as `colon_expression(left: identifier(raises), …)`, so the pragma
+   *  NAME is the left side — the right side is the argument, not the pragma. */
+  readPragmaNames(node) {
+    const list = node.childForFieldName("pragmas") ?? this.firstChildOfType(node, "pragma_list");
+    if (!list) return [];
+    return this.pragmaNameNodes(list).map((p) => p.name);
+  }
+  /**
+   * THE ONE RULE for reading pragma NAMES out of a `pragma_list`, WITH each name's own line.
+   *
+   * `{.raises: [].}` parses as `colon_expression(left: identifier(raises), …)`, so the pragma NAME is
+   * the left side — the right side is the argument, not the pragma. The rule lives here ONCE because
+   * three readers now share it (symbol metadata, the `pragma` template marker, and the `decorates`
+   * emission), and the fleet has paid for a rule copied in two places: the ruby lane's operator-name
+   * class was extended at one of its two sites and 7 rows stayed dropped while a commit message
+   * claimed they were exempt. A COPY OF THIS RULE IS A DEFECT WAITING FOR ITS SECOND FIX.
+   *
+   * The LINE is the name node's own line rather than the declaration's: the fleet's line rule is
+   * "the line of the NAMING node", and for a pragma the naming node is the pragma identifier inside
+   * `{. … .}`. A multi-line pragma list puts its names on later lines than the declaration, and
+   * anchoring to the declaration would point a reader at the wrong line for every such row.
+   */
+  pragmaNameNodes(list) {
+    const out = [];
+    for (let i = 0; i < list.namedChildCount; i++) {
+      let c = list.namedChild(i);
+      if (!c) continue;
+      if (c.type === "colon_expression" || c.type === "equal_expression") c = c.childForFieldName("left") ?? c;
+      if (c && c.type === "identifier") out.push({ name: c.text, line: c.startPosition.row + 1 });
+    }
+    return out;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // 3. MODULES: import / export / include
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * `doc/grammar.txt`:
+   *   importStmt = 'import' optInd expr ((comma expr)* / 'except' optInd (expr^+ comma))
+   *   exportStmt = 'export' optInd expr ((comma expr)* / 'except' optInd (expr^+ comma))
+   *   fromStmt   = 'from' expr 'import' optInd expr (comma expr)*
+   *   includeStmt= 'include' optInd expr ^+ comma
+   *
+   * The module PATH is not always an identifier. `import std/[os, strutils]`
+   * parses as `infix_expression(left: std, operator: /, right:
+   * array_construction(os, strutils))` — the `/` is the stdlib path separator
+   * and the bracket is a module LIST. `import std/os as o` is the same
+   * infix shape with the `as` operator, where the right side is the local
+   * ALIAS, not a module. `import ./rel` and `import ../parent` are relative
+   * paths in the same infix shape. `import "file.nim"` is a string literal.
+   */
+  /**
+   * `from M import a, b` — the from-form. Extracted from the old collectModules
+   * walk so the fused walk can call it as a handler; the body is unchanged, and
+   * the path reader is the SAME one `import` uses, so a module spelled `./x` in
+   * one statement and `x` in another is still one target.
+   */
+  readImportFromStatement(n, imports, qualifiers, relationships) {
+    const moduleNode = n.childForFieldName("module");
+    const modulePathsParsed = moduleNode ? this.parseModuleExpression(moduleNode) : null;
+    const module = modulePathsParsed?.paths[0]?.path ?? "";
+    const list = this.firstChildOfType(n, "expression_list");
+    const items = this.identifierTextsIn(list);
+    if (module) {
+      imports.push({
+        module,
+        items,
+        isDefaultImport: false,
+        range: this.nodeRange(n),
+        metadata: { nimImport: true, nimFromImport: true }
+      });
+      for (const seg of this.moduleSegments(module)) qualifiers.add(seg);
+      relationships.push({
+        source: "(global)",
+        target: this.moduleNameOfPath(module),
+        type: ASTEngine.RelationshipType.Imports,
+        confidence: 1,
+        line_number: moduleNode ? moduleNode.startPosition.row + 1 : n.startPosition.row + 1,
+        // Only the edge TARGET is normalised, and only so that it can equal the module
+        // symbol's name — the two spellings drifted apart, which is what left 8,404 of
+        // 13,364 `imports` edges with no candidate to bind to. The path AS WRITTEN
+        // survives in `imports[].module` and on `meta.nimModulePath`.
+        metadata: this.moduleEdgeMetadata("nim_import", module)
+      });
+    }
+  }
+  /**
+   * `include a, b, c` — one edge per operand, through the same path reader.
+   *
+   * ## THE EDGE IS `part_of`, NOT `imports` — a 1:1 RELABEL AT RUNG R3 (2026-10-23)
+   *
+   * Nim's `include` is a TEXTUAL scope-sharing inclusion: the included file's declarations become
+   * part of the INCLUDING module's single declaration space; no module is created, no binding
+   * scope is imported, and nothing can `import` what was included. That is exactly the `part_of`
+   * contract (`src/ast/types.ts:164-190`: "A library unit INCLUDES a part file … a part shares
+   * the library's single scope, imports nothing, and cannot be resolved as a separate module").
+   * This file says the same thing in Nim's words further down: "`.nims`. A NimScript file is
+   * `include`d into another module; it is not a module and nothing can `import` it."
+   *
+   * So the stored TYPE moves `imports` -> `part_of` and NOTHING ELSE moves: the same source, the
+   * same target, the same line, the same confidence, the same `relationshipType: "nim_include"`
+   * marker, and the same `ImportInfo` payload pushed above (which `src/ast/parallel-indexer.ts`
+   * persists into `brain_import` — a consumer reading a file's directive list loses nothing when
+   * the relationship's label moves).
+   *
+   * THE FLEET'S PRECEDENT, three lanes and the same relabel discipline:
+   *   · fsharp (`real-fsharp-analyzer.ts:1900-1965`): `#load` -> `part_of`, 1:1;
+   *   · php (`real-php-analyzer.ts:3085-3100`): include/require -> `part_of`, 1:1;
+   *   · dart (`real-dart-analyzer.ts`): `part`/`part of` -> `part_of`.
+   *
+   * ## THE DIVERGENCE FROM fsharp/php IS RECORDED, NOT FLATTENED
+   *
+   * fsharp and php emit a PROJECT-RELATIVE PATH as the target (`targetResolution:
+   * "project-relative-path"`). Nim's target STAYS the analyzer's normalized MODULE NAME — the
+   * artifact of the 2026-10-14 import-resolution work, measured at 96.9 % intra-file / 98.0 %
+   * corpus-wide binding for the 458 `nim_include` edges (`validation/m14/fixtures/nim/
+   * import-resolution-probe.mts`, `s18-import-probe.txt`), and reverting the normalization to the
+   * verbatim path binds 0 of the 14 it leaves unresolved. The target rule is a property of the
+   * construct — a Nim include names a module path expression, not a string file literal — and a
+   * reader comparing two lanes' `part_of` cells must be able to see that they are resolved in
+   * DIFFERENT KEYSPACES. Hence `targetResolution: "module-name"` on every row: the shape is
+   * named on the row rather than normalized away.
+   *
+   * ## DIRECTION AND `partRole`
+   *
+   * The direction is the directive's own (types.ts:170-183): the source is the file carrying the
+   * directive (`(global)`, this analyzer's file-level source convention), the target is what it
+   * names. Nim has only ONE of Dart's two roles — there is no `part of` counterpart, because an
+   * included file does not know it is included — so every row is the host that INCLUDES the
+   * part: `partRole: "library"`, the same single-role shape php declares.
+   */
+  readIncludeStatement(n, imports, relationships) {
+    const list = this.firstChildOfType(n, "expression_list");
+    const includePaths = [];
+    if (list) {
+      for (let i = 0; i < list.namedChildCount; i++) {
+        const c = list.namedChild(i);
+        if (!c) continue;
+        const parsedInc = this.parseModuleExpression(c);
+        if (parsedInc) for (const pth of parsedInc.paths) includePaths.push(pth.path);
+      }
+    }
+    for (const text of includePaths) {
+      imports.push({
+        module: text,
+        isDefaultImport: false,
+        range: this.nodeRange(n),
+        metadata: { nimInclude: true }
+      });
+      relationships.push({
+        source: "(global)",
+        target: this.moduleNameOfPath(text),
+        type: ASTEngine.RelationshipType.PartOf,
+        confidence: 1,
+        line_number: n.startPosition.row + 1,
+        metadata: this.moduleEdgeMetadata("nim_include", text, {
+          // MANDATORY on every `part_of` row (src/ast/types.ts:170-183): the direction is the
+          // directive's own and `partRole` says which of Dart's two roles this row is. Nim has
+          // only the host role.
+          partRole: "library",
+          // THE RECORDED DIVERGENCE: fsharp and php emit project-relative PATHS; nim keeps the
+          // analyzer's normalized MODULE NAME (see this function's header for the measurement).
+          targetResolution: "module-name"
+        })
+      });
+    }
+  }
+  /**
+   * `export a, b` — the module's RE-EXPORT, and the only Nim export fact that
+   * has no other carrier in this codebase.
+   *
+   * ## Why this emits an `exports` edge when the `*` marker does not
+   *
+   * Nim has two ways to make a name visible outside its module and they are
+   * different facts, so they are not interchangeable:
+   *
+   *   - the `*` marker (`proc foo*()`) sets the VISIBILITY of a declaration.
+   *     This analyzer already publishes that, as `visibility: "public"` plus
+   *     `metadata.exported`, and the parallel indexer persists it into
+   *     `brain_symbol.visibility`, where it already drives `gravity_score`
+   *     (parallel-indexer.ts:3044, :3052). Measured over the corpus: 28,900
+   *     `exported_symbol` nodes in 1,335 files. Publishing a second 28,900-edge
+   *     graph saying the same thing would grow the relationship payload by
+   *     ~17.6% (163,960 edges measured before) to add nothing a query could not
+   *     already ask. It is therefore NOT a gap, and the number is recorded here
+   *     so a reader can disagree with the judgement using the measurement rather
+   *     than the prose.
+   *
+   *   - the `export` STATEMENT re-publishes names this module IMPORTED. Nothing
+   *     on any symbol records that, no metadata field carries it, and the LSP
+   *     usages file-level section — which answers with
+   *     `relationship_type IN ('imports','exports')`, the one reader that answers
+   *     "what does this module depend on and hand on" — saw nothing for Nim.
+   *     That is a capability that emits NOTHING, which is the class every
+   *     existing gate is blind to. It is emitted here.
+   *
+   * ## The `except` clause, which the first version got backwards
+   *
+   * `doc/grammar.txt` spells the statement
+   * `exportStmt = 'export' optInd expr ((comma expr)* / 'except' optInd (expr^+ comma))`
+   * and the grammar agrees: `export nifpools except info, NoLineInfo, tagId, …`
+   * parses as `export_statement(identifier(nifpools), except_clause(expression_list(…)))`.
+   *
+   * The old reader walked every identifier under the statement, so it listed the
+   * EXCEPTED names as exported — the precise inverse of what the construct means,
+   * and a mistake that inflates the export set with names the author explicitly
+   * refused to re-publish. Measured on the corpus: 9 of 155 `export_statement`
+   * nodes carry an `except_clause`, and they are the whole reason a
+   * name-collecting walk is the wrong reader here. The operands are now read
+   * positionally: an operand inside `except_clause` is an exclusion, it is not
+   * published, and it rides the published operand's `nimExportExcluded`
+   * metadata.
+   *
+   * ## Spelling
+   *
+   * A re-export is usually written qualified — `export astyaml.treeToYaml`,
+   * `export common_parser.Parser` — and R10 requires the endpoint to be spelled
+   * the way the lane spells its own symbols, so the edge carries the LEAF and the
+   * written form is kept in `nimQualifiedName`. This is the same two-part record
+   * the f# lane writes for `System.IDisposable`. A `/`-separated operand is a
+   * MODULE rather than a symbol and is published whole, which is what the
+   * `imports` reader does with the same spelling, so the two spellings of one
+   * module are one target in the graph.
+   *
+   * Confidence 1.0: the statement names the operand outright, with no inference
+   * and no name matching.
+   */
+  readExportStatement(n, exports, relationships) {
+    const exceptClause = this.firstChildOfType(n, "except_clause");
+    const exceptTexts = exceptClause ? this.identifierTextsIn(this.firstChildOfType(exceptClause, "expression_list")) : [];
+    for (const operand of this.exportOperands(n)) {
+      const read = this.readExportedName(operand);
+      if (!read.name) continue;
+      exports.push({
+        name: read.name,
+        metadata: {
+          nimExport: true,
+          nimReExport: true,
+          ...read.qualified ? { nimQualifiedName: read.qualified } : {},
+          ...read.alias ? { nimAlias: read.alias } : {}
+        }
+      });
+      relationships.push({
+        source: "(global)",
+        target: read.name,
+        type: ASTEngine.RelationshipType.Exports,
+        confidence: 1,
+        line_number: operand.startPosition.row + 1,
+        metadata: {
+          relationshipType: "nim_reexport",
+          nimReExport: true,
+          ...read.qualified ? { nimQualifiedName: read.qualified } : {},
+          ...read.alias ? { nimAlias: read.alias } : {},
+          ...read.isModule ? { nimModuleReExport: true } : {},
+          ...exceptTexts.length > 0 ? { nimExportExcluded: exceptTexts } : {}
+        }
+      });
+    }
+  }
+  /**
+   * Drop from the importable-unit list the re-exported names THIS FILE DOES NOT
+   * PROVIDE, keeping them on the `exports` relationship.
+   *
+   * ## Why the list and the edge answer different questions
+   *
+   * `result.exports` is the index's importable-unit set: a name an importer can
+   * bind, with this file as its provider. `exports foo` where `foo` is declared
+   * in another module is the opposite of that — the name is bindable, but
+   * SOMEBODY ELSE provides it, and recording it here would give one name two
+   * providers in the graph. The `exports` RELATIONSHIP is the right carrier for
+   * it, because the fact it states is "this module hands this name onward",
+   * which is true whoever declares it — and it is exactly what the LSP usages
+   * file-level section asks for with
+   * `relationship_type IN ('imports','exports')`.
+   *
+   * This is also the M49 exports-family invariant's own reading, which admits
+   * only names that resolve to a top-level symbol ("membership rides Contains")
+   * and lists the per-language exceptions explicitly. Nim's cross-module
+   * re-export needed no exception once the two carriers were separated; before
+   * this pass every `export` operand landed in the list, so a Nim fixture with
+   * an `export` statement at all failed the invariant on names that were never
+   * claimed to be local.
+   *
+   * The M49 invariant also requires export names to be UNIQUE — a duplicate
+   * cannot identify its provider — and `export a, a` is legal Nim, so the
+   * dedupe is here rather than left to a consumer to discover.
+   *
+   * Runs after `collectDeclarations` because answering "does this file declare
+   * it" needs the symbol set; the readers that fill the list run earlier, in
+   * the module-surface pass.
+   */
+  pruneForeignReExports(symbols, exports) {
+    if (exports.length === 0) return;
+    const local = /* @__PURE__ */ new Set();
+    for (const s of symbols) local.add(s.name);
+    const kept = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const e of exports) {
+      const isReExport = !!e.metadata?.nimReExport;
+      if (isReExport && !local.has(e.name)) continue;
+      if (seen.has(e.name)) continue;
+      seen.add(e.name);
+      kept.push(e);
+    }
+    exports.length = 0;
+    for (const e of kept) exports.push(e);
+  }
+  /** The `export` statement's operands, positionally: a bare named child, or each
+   *  child of its `expression_list`, and never a node inside `except_clause`. */
+  exportOperands(n) {
+    const out = [];
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const c = n.namedChild(i);
+      if (!c || c.type === "except_clause") continue;
+      if (c.type === "expression_list") {
+        for (let j = 0; j < c.namedChildCount; j++) {
+          const item = c.namedChild(j);
+          if (item) out.push(item);
+        }
+        continue;
+      }
+      out.push(c);
+    }
+    return out;
+  }
+  /** One `export` operand, read for the NAME it publishes. A `/` path is a
+   *  module and is published whole; a `.` qualification is a symbol reached
+   *  through a module and is published by its leaf; `X as Y` renames locally and
+   *  still publishes `X`. */
+  readExportedName(node) {
+    if (node.type === "identifier" || node.type === "accent_quoted") return { name: node.text };
+    if (node.type === "infix_expression") {
+      const op = node.childForFieldName("operator");
+      const left = node.childForFieldName("left");
+      const right = node.childForFieldName("right");
+      if (!op || !left) return { name: "" };
+      if (op.type === "as") {
+        const base = this.readExportedName(left);
+        const alias = right && right.type === "identifier" ? right.text : void 0;
+        return alias ? { ...base, alias } : base;
+      }
+      if (op.text.indexOf("/") !== -1) return { name: this.nodeText(node), isModule: true };
+      return { name: "" };
+    }
+    if (node.type === "dot_expression") {
+      const right = node.childForFieldName("right");
+      if (!right || right.type !== "identifier" && right.type !== "accent_quoted") return { name: "" };
+      const leaf = right.text;
+      const written = this.nodeText(node);
+      return written !== leaf ? { name: leaf, qualified: written } : { name: leaf };
+    }
+    return { name: "" };
+  }
+  readImportStatement(node, imports, qualifiers, relationships) {
+    const exceptClause = this.firstChildOfType(node, "except_clause");
+    const exceptTexts = exceptClause ? this.identifierTextsIn(this.firstChildOfType(exceptClause, "expression_list")) : [];
+    const moduleNodes = [];
+    const list = this.firstChildOfType(node, "expression_list");
+    if (list) {
+      for (let i = 0; i < list.namedChildCount; i++) {
+        const c = list.namedChild(i);
+        if (!c) continue;
+        if (exceptClause && this.isDescendantOf(c, exceptClause)) continue;
+        moduleNodes.push(c);
+      }
+    }
+    for (const mod of moduleNodes) {
+      const parsed = this.parseModuleExpression(mod);
+      if (!parsed) continue;
+      for (const { path, alias, qualifier, site } of parsed.paths) {
+        imports.push({
+          module: path,
+          isDefaultImport: false,
+          ...alias ? { alias } : {},
+          ...exceptTexts.length > 0 ? { items: exceptTexts } : {},
+          range: this.nodeRange(node),
+          metadata: { nimImport: true, ...parsed.isPathList ? { nimModuleList: true } : {} }
+        });
+        for (const seg of this.moduleSegments(path)) qualifiers.add(seg);
+        relationships.push({
+          source: "(global)",
+          target: this.moduleNameOfPath(path),
+          type: ASTEngine.RelationshipType.Imports,
+          confidence: 1,
+          line_number: site.startPosition.row + 1,
+          metadata: this.moduleEdgeMetadata("nim_import", path, {
+            ...parsed.isPathList ? { nimModuleList: true } : {},
+            ...alias ? { nimAlias: alias } : {},
+            ...qualifier ? { nimQualifier: qualifier } : {}
+          })
+        });
+      }
+    }
+  }
+  /**
+   * Flatten one `import` operand into module paths.
+   *   `strutils`                     → ["strutils"]
+   *   `std/[os, strutils]`            → ["std/os", "std/strutils"]
+   *   `os, strutils`                 → two operands at the list level
+   *   `std/os as o`                  → ["std/os"] alias "o"
+   *   `./rel`, `../parent`           → the relative path, verbatim
+   *   `"file.nim"`                   → the string literal, verbatim
+   */
+  parseModuleExpression(node) {
+    if (node.type === "identifier" || node.type === "accent_quoted") {
+      return { paths: [{ path: node.text, site: node }], isPathList: false };
+    }
+    if (node.type === "interpreted_string_literal" || node.type === "raw_string_literal" || node.type === "long_string_literal") {
+      return { paths: [{ path: this.unquote(node.text), site: node }], isPathList: false };
+    }
+    if (node.type === "array_construction") {
+      const out = [];
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (!c) continue;
+        const inner = this.parseModuleExpression(c);
+        if (inner) out.push(...inner.paths);
+      }
+      return out.length > 0 ? { paths: out, isPathList: true } : null;
+    }
+    if (node.type === "infix_expression") {
+      const op = node.childForFieldName("operator");
+      const left = node.childForFieldName("left");
+      const right = node.childForFieldName("right");
+      if (!op || !left || !right) return null;
+      if (op.type === "as") {
+        const base = this.parseModuleExpression(left);
+        const alias = right.type === "identifier" ? right.text : void 0;
+        if (!base) return null;
+        return {
+          paths: base.paths.map((p) => ({ path: p.path, ...alias ? { alias } : {}, site: p.site })),
+          isPathList: base.isPathList
+        };
+      }
+      const opText = op.text;
+      if (opText.indexOf("/") === -1) return null;
+      if (right.type === "pragma_expression") {
+        const inner = right.childForFieldName("left");
+        if (!inner || inner.type !== "identifier" && inner.type !== "accent_quoted") return null;
+        const qualifierList = right.childForFieldName("right");
+        return {
+          paths: [{
+            path: `${this.nodeText(left)}/${inner.text}`,
+            site: right,
+            ...qualifierList ? { qualifier: this.nodeText(qualifierList) } : {}
+          }],
+          isPathList: false
+        };
+      }
+      if (right.type === "array_construction") {
+        const out = [];
+        const prefix = this.nodeText(left);
+        for (let i = 0; i < right.namedChildCount; i++) {
+          const c = right.namedChild(i);
+          if (!c) continue;
+          const name = c.type === "identifier" ? c.text : null;
+          if (name) out.push({ path: `${prefix}/${name}`, site: c });
+        }
+        return out.length > 0 ? { paths: out, isPathList: true } : null;
+      }
+      return { paths: [{ path: this.nodeText(node), site: node }], isPathList: false };
+    }
+    if (node.type === "prefix_expression") {
+      const qualOp = node.childForFieldName("operator");
+      if (qualOp) {
+        let operand = null;
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const c = node.namedChild(i);
+          if (c && c.id !== qualOp.id) {
+            operand = c;
+            break;
+          }
+        }
+        if (operand && operand.type === "pragma_expression") {
+          const inner = operand.childForFieldName("left");
+          if (inner && (inner.type === "identifier" || inner.type === "accent_quoted")) {
+            const qualifierList = operand.childForFieldName("right");
+            return {
+              paths: [{
+                path: `${qualOp.text}${inner.text}`,
+                site: operand,
+                ...qualifierList ? { qualifier: this.nodeText(qualifierList) } : {}
+              }],
+              isPathList: false
+            };
+          }
+        }
+      }
+      return { paths: [{ path: this.nodeText(node), site: node }], isPathList: false };
+    }
+    if (node.type === "dot_expression") {
+      return { paths: [{ path: this.nodeText(node), site: node }], isPathList: false };
+    }
+    return null;
+  }
+  /**
+     * The MODULE this file defines, as one `SymbolKind.Module` symbol.
+     *
+     * ## Why this is a symbol and not a scope name
+     *
+     * A Nim `.nim` file IS a module, it has a name, it is the unit `import`
+     * names, and it is the unit `export` publishes from. Every one of those is a
+     * fact about a declaration, and before this pass the graph had no node for it:
+     * every `imports` edge named a module that existed nowhere in the symbol set.
+     *
+     * MEASURED, 6,063 corpus files, production `parseFile` (`census.ts`, artifacts in
+     * `validation/m14/measurements/nim/`): `imports` resolved its target on **37.1%** of
+     * 13,364 edges, and the unresolved population is the module path as written —
+     * `std/assertions`(823) `std/syncio`(671) `std/strutils`(386) `std/os`(297)
+     * `std/tables`(240). 8,404 of 13,364 edges named a module the graph could not bind
+     * to. It was not a resolution failure: there was no candidate to fail to find.
+     *
+     * The store cannot rescue it either, and that is checked rather than assumed. Its
+     * insert-time target resolver matches `brain_symbol.name` (`parallel-indexer.ts:2239`)
+     * and its three post-pass strategies match a bare `name`, a `qualified_name`, or —
+     * for a DOT target — everything after the first `.` (`parallel-indexer.ts:3755-3774`).
+     * `std/assertions` is none of those, and the fourth strategy, `resolveImportTargets`,
+     * is scoped to the `<module>:<item>` form that javascript/typescript/python emit —
+     * nim writes a bare path, so it never reaches that planner.
+     *
+     * ## Why the NAME is the last path segment, and why that is the module
+     *
+     * Nim resolves `import std/assertions` to the module `assertions` in
+     * `lib/std/assertions.nim`; the `std/` prefix is a directory on the module search
+     * path, not part of the module's name. So the symbol is named after the file's
+     * basename and the edge target is normalised to the same rule, which is what makes
+     * the two strings equal. This is the same "publish the string you target" shape the
+     * graphql lane measured at a 75% reduction, applied to the construct nim actually has.
+     *
+  * ## What is deliberately NOT published
+     *
+     *   - `.nims`. A NimScript file is `include`d into another module; it is not a module
+     *     and nothing can `import` it. Publishing one would be a node the language cannot
+     *     name. So `include`'s edge target is normalised by the SAME rule, and that is
+     *     measured rather than assumed: 458 `nim_include` edges over the corpus resolve
+     *     at both ends on 96.9% in-file and 98.0% in-corpus, and reverting them to the
+     *     verbatim path would bind **0** of the 14 they currently leave unresolved
+     *     (`import-resolution-probe.mts`, `s18-import-probe.txt`). An earlier draft of
+     *     this comment asserted the opposite — that `include` keeps the written path —
+     *     while the code normalised it; the measurement decided which of the two was
+     *     true and the comment was corrected to match.
+     *   - A renamed module. `module Foo` inside `bar.nim` declares module `Foo`, and the
+     *     pinned grammar has NO node for it — `grammars/tree-sitter-nim/grammar.js`
+     *     mentions "module" twice and neither is a declaration, so there is nothing on
+     *     the tree to read. The symbol is therefore named after the FILE. This is a real
+     *     inaccuracy and it is bounded: the corpus measurement is in the doc, and a file
+     *     that renames its module gets a module symbol no `import` will ever name.
+     *   - An empty basename. A path that yields no name publishes nothing rather than an
+     *     empty-named symbol.
+     *
+     * The range is the whole `source_file` node, so the symbol covers what it contains.
+     * A file whose root is not a `source_file` falls back to line 1, never to a line 0 —
+     * a line-0 symbol reads as a missed line to every consumer that checks.
+     */
+  publishModuleSymbol(rootNode, filePath, symbols) {
+    const name = this.moduleNameOfPath(filePath);
+    if (!name) return;
+    const lower = filePath.toLowerCase();
+    if (lower.endsWith(".nims")) return;
+    const src = rootNode.type === "source_file" ? rootNode : null;
+    symbols.push({
+      name,
+      kind: ASTEngine.SymbolKind.Module,
+      visibility: "public",
+      range: src ? this.nodeRange(src) : { startLine: 1, startColumn: 0, endLine: 1, endColumn: 0, startIndex: 0, endIndex: 0 },
+      // The module name is the whole identity here, so `qualifiedName` carries it too:
+      // the store's second resolution strategy matches `qualified_name`, and a row that
+      // is correct under one spelling should not be unreachable because it took another.
+      qualifiedName: name,
+      metadata: { nimModule: true, nimModuleName: name }
+    });
+  }
+  /**
+   * The module name a file path denotes: its basename without the extension, which is
+   * Nim's own rule for the name a file has unless it renames the module inside.
+   *
+   * It is also the LAST SEGMENT of an import path, and both spellings go through here so
+   * the publisher and the emitter cannot drift apart — the whole defect this pass exists
+   * to fix is two pieces of code spelling one symbol differently.
+   */
+  moduleNameOfPath(filePath) {
+    const seg = String(filePath ?? "").split("/").pop() ?? "";
+    let end = seg.length;
+    while (end > 0 && seg.charCodeAt(end - 1) === BACKSLASH) end--;
+    const base = seg.slice(0, end);
+    const dot = base.lastIndexOf(".");
+    const stem = dot > 0 ? base.slice(0, dot) : base;
+    const parts = stem.split("/");
+    const last = (parts[parts.length - 1] ?? "").trim();
+    return last;
+  }
+  /**
+   * Is this written module path Nim's own STANDARD LIBRARY?
+   *
+   * ## What the marker is for, and the number that sizes it
+   *
+   * After the module-symbol pass the residual `imports` population that is declared
+   * NOWHERE in the corpus — the population cause C is about — is 485 edges: 476 on
+   * `nim_import` and 9 on `nim_include`. Measured by
+   * `validation/m14/fixtures/nim/import-resolution-probe.mts` over the same 6,063
+   * files, same analyzer digest (`s18-import-probe.txt`):
+   *
+   *     bare name          309   (301 import + 8 include)
+   *     other path         103   (102 + 1)
+   *     std/ path prefix    66   (66 + 0)
+   *     parent-relative       8   (7 + 1)
+   *
+   * 66 of 485 — 13.6% — is identifiable from the spelling alone, and this is that
+   * identification. A `std/`-prefixed path is Nim's standard-library root by the
+   * language's own rule, so `nimStdlibModule` is a fact about the PATH, not a guess
+   * about where the declaration lives.
+   *
+   * ## Why the other 419 are NOT marked, which is the honest part
+   *
+   * 309 are BARE names. Per file, `import re` is three indistinguishable things: a
+   * module in this project, a module in `lib/pure` (which is how Nim spells `re`,
+   * `parseutils`, `algorithm`, `math` — no path prefix at all), or a typo. Nothing in
+   * one file separates them, and marking them external would assert that a local module
+   * is not local — the fabricated-edge failure the workstream brief calls the most
+   * expensive mistake available. 103 are paths with some other prefix (a `nimble`
+   * package name, a sibling directory) and 8 are `../`, which is local by definition.
+   *
+   * Separating the bare cases needs whole-program import resolution: for each bare
+   * target, find the file this project declares by that name and ask whether its path
+   * lies under the Nim library roots. That is shared machinery (workstream §8), so the
+   * need is reported rather than built.
+   *
+   * ## Why the key is `nimStdlibModule` and not the family's `isExternalTarget`
+   *
+   * 15 other analyzers write `isExternalTarget`, and in every one of them it means "the
+   * target is NOT declared in this file". For an `imports` edge that is vacuously true
+   * of every edge — a module is never declared in the file that imports it — so the
+   * family key would carry no information here and would be read as if it did. The key
+   * says what is actually known: the path names the standard library.
+   */
+  isStdlibModulePath(writtenPath) {
+    const s = String(writtenPath ?? "");
+    let i = 0;
+    const skipSpace = () => {
+      while (i < s.length && isPathSpace(s.charCodeAt(i))) i++;
+    };
+    skipSpace();
+    if (i < s.length && s.charCodeAt(i) === DOUBLE_QUOTE) i++;
+    skipSpace();
+    if (i + 3 > s.length) return false;
+    if (!startsWithStdAt(s, i)) return false;
+    i += 3;
+    skipSpace();
+    return i < s.length && s.charCodeAt(i) === SLASH;
+  }
+  /**
+   * The metadata block every `imports` edge carries, built from ONE argument so the
+   * written path and the stdlib marker can never be derived from different strings.
+   *
+   * This is the same one-function discipline `moduleNameOfPath` exists for, applied to
+   * the metadata: the defect being paid down is two pieces of code spelling one module
+   * differently, and a marker computed from a different string than the path it
+   * describes is that defect a second time.
+   */
+  moduleEdgeMetadata(relationshipType, writtenPath, extra) {
+    return {
+      relationshipType,
+      isImport: true,
+      fileLevel: true,
+      // The path AS WRITTEN. `brain_import` and the file-dependency engine read this,
+      // and so does anyone asking which file on disk is meant.
+      nimModulePath: writtenPath,
+      ...this.isStdlibModulePath(writtenPath) ? { nimStdlibModule: true } : {},
+      ...extra ?? {}
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // 4. RELATIONSHIPS
+  // ═══════════════════════════════════════════════════════════════════════
+  /** `contains` — owner → owned symbol, at the member's own declaration line. */
+  collectContainment(symbols, relationships) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if (s.ownerName) {
+        const key2 = `${s.ownerName} ${s.name}`;
+        if (seen.has(key2)) continue;
+        seen.add(key2);
+        relationships.push({
+          source: s.ownerName,
+          target: s.name,
+          type: ASTEngine.RelationshipType.Contains,
+          confidence: 1,
+          ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+          metadata: { relationshipType: "nim_contains" }
+        });
+        continue;
+      }
+      const parent = typeof s.metadata?.nimNestedIn === "string" ? s.metadata.nimNestedIn : "";
+      if (!parent) continue;
+      const key = `${parent} ${s.name}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      relationships.push({
+        source: parent,
+        target: s.name,
+        type: ASTEngine.RelationshipType.Contains,
+        confidence: 1,
+        ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+        metadata: { relationshipType: "nim_contains", nimNestedRoutine: true }
+      });
+    }
+  }
+  /**
+   * `decorates` — a declaration carrying a pragma that names a FILE-LOCAL pragma TEMPLATE.
+   *
+   * ## WHY THIS EXISTS, AND WHY IT IS NARROW ON PURPOSE (2026-10-23, rung R3)
+   *
+   * The lane's first plan was to RULE `decorates` ontological, on the csharp/fsharp precedent
+   * ("an annotation is passive metadata; a decorator is an applied callable"). The census
+   * (`script/m14/nim-extended-census.ts`) MEASURED THE FALSIFIER AND IT FIRED: over the whole
+   * 6,063-file admitted population, 294 pragma-use sites name a DECLARED pragma template — 48
+   * distinct `template X() {.pragma.}` / `macro X(...) {.pragma.}` declarations in 20 files — and
+   * a pragma template is INVOKED BY THE COMPILER at the site that names it. Those sites are the
+   * dictionary's decorator (`src/ast/types.ts:131-144`: decorated declaration → applied callable),
+   * and the ruling was WITHDRAWN BY ITS OWN FALSIFIER rather than published. The other 99.1 % of
+   * pragma name sites (`{.inline.}`, `{.cdecl.}`, `{.raises.}`, …) are COMPILER DIRECTIVES and are
+   * deliberately NOT emitted: sweeping them in would turn a 0.9 % construct into a 33,266-row lie.
+   *
+   * ## THE DISCRIMINATOR, AND THE PER-FILE CAVEAT
+   *
+   * A pragma name emits `decorates` ONLY when it resolves to a pragma template DECLARED IN THIS
+   * FILE. Same-file uses resolve (that is the construct a per-file analyzer can prove). A template
+   * imported from ANOTHER file is out of a per-file analyzer's reach, so its `decorates` row is not
+   * invented — this is the lane's standard per-file limitation (NIMD2's overrides scope, and the
+   * same caveat ruby and csharp carry), stated on the page rather than hidden here.
+   *
+   * ## THE CONTRACT DETAILS
+   *
+   *   · SOURCE = the decorated declaration's PUBLISHED symbol spelling (`qualifiedName` where the
+   *     symbol has one — a method is `Receiver.method`, exactly as the `overrides` endpoints are
+   *     spelled, because a bare method name cannot address either end), TARGET = the pragma
+   *     template name. Direction is the contract's (`types.ts:131-144`).
+   *   · NO ROW when the decorated declaration is not a published symbol: the vocabulary proposal's
+   *     decorates MUST-NOT ("no row when no published symbol is decorated") is implemented by the
+   *     symbol lookup below, not by a claim.
+   *   · `metadata.decoratorConstruct: "pragma_template"` is what tells a consumer this row is the
+   *     applied-callable class rather than a hypothetical annotation sweep.
+   *   · The pragma NAME stays on the symbol's `decorators` payload as well: it is the evidence, and
+   *     the java/dart lanes' rule (annotation mentions live in metadata) is not contradicted — this
+   *     row says the pragma is an applied callable, which those lanes' annotations are not.
+   */
+  collectPragmaDecorates(rootNode, symbols, relationships) {
+    const pragmaTemplates = /* @__PURE__ */ new Set();
+    const templateStack = [rootNode];
+    while (templateStack.length > 0) {
+      const n = templateStack.pop();
+      if (!n) continue;
+      if (n.type === "template_declaration" || n.type === "macro_declaration") {
+        const list = n.childForFieldName("pragmas") ?? this.firstChildOfType(n, "pragma_list");
+        if (list && this.pragmaNameNodes(list).some((p) => p.name === "pragma")) {
+          const nameNode = n.childForFieldName("name");
+          if (nameNode) {
+            const info = this.readNameNode(nameNode);
+            if (info.name) pragmaTemplates.add(info.name);
+          }
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) templateStack.push(c);
+      }
+    }
+    if (pragmaTemplates.size === 0) return;
+    const symbolsByStart = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      const line = s.range?.startLine;
+      if (typeof line === "number" && s.name) {
+        let a = symbolsByStart.get(line);
+        if (!a) {
+          a = [];
+          symbolsByStart.set(line, a);
+        }
+        a.push(s);
+      }
+    }
+    const DECORATABLE = /* @__PURE__ */ new Set([
+      "proc_declaration",
+      "func_declaration",
+      "method_declaration",
+      "iterator_declaration",
+      "template_declaration",
+      "macro_declaration",
+      "converter_declaration",
+      "type_symbol_declaration",
+      "type_declaration",
+      "enum_declaration",
+      "object_declaration",
+      "variable_declaration",
+      "field_declaration"
+    ]);
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (!n) continue;
+      if (DECORATABLE.has(n.type)) {
+        const list = n.childForFieldName("pragmas") ?? n.childForFieldName("pragma") ?? this.firstChildOfType(n, "pragma_list");
+        if (list) {
+          const nameNode = n.childForFieldName("name");
+          const own = nameNode ? this.readNameNode(nameNode).name : "";
+          const candidates = symbolsByStart.get(n.startPosition.row + 1) ?? [];
+          const sym = own ? candidates.find((c) => c.name === own) : candidates[0];
+          if (sym) {
+            for (const p of this.pragmaNameNodes(list)) {
+              if (!pragmaTemplates.has(p.name)) continue;
+              relationships.push({
+                source: sym.qualifiedName ?? sym.name,
+                target: p.name,
+                type: ASTEngine.RelationshipType.Decorates,
+                confidence: 1,
+                line_number: p.line,
+                metadata: {
+                  relationshipType: "nim_pragma_template",
+                  decoratorConstruct: "pragma_template",
+                  isDecorator: true,
+                  // Read straight off the declaration's `pragmas` field — a structural declaration,
+                  // the tier `extends` and `implements` carry for the same reason.
+                  evidenceClass: "structural"
+                }
+              });
+            }
+          }
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  /**
+   * `extends` — `type D = ref object of B`. The `inherits` field is a
+   * `type_expression`; its leaf is the base type.
+   *
+   * The base is NOT required to be declared in this file. In a real Nim module
+   * the base almost never is: `Named = ref object of Point` with `Point` in a
+   * sibling file is the normal shape, and requiring a same-file declaration
+   * dropped the whole family at the seam — measured: a three-file module whose
+   * subclass lived in a different file from its base persisted ZERO `extends`
+   * rows. The edge is emitted whenever the base is either declared in this file
+   * OR reachable through an import, and the evidence tier says which: a
+   * same-file base is `structural`, an imported one is `import_based` so the
+   * resolver never mistakes a cross-module base for a local one.
+   *
+   * `ref object of RootObj` names the compiler's own `RootObj`, which is
+   * neither declared nor imported — a name with no referent — so it is
+   * deliberately NOT emitted: an `extends` to a non-existent symbol is the
+   * phantom this guard exists to prevent.
+   */
+  collectInheritance(symbols, relationships, fileTypes) {
+    for (const s of symbols) {
+      const base = s.metadata?.nimInherits;
+      if (typeof base !== "string" || !base) continue;
+      if (base === s.name) continue;
+      if (NIM_COMPILER_ROOTS.has(base)) continue;
+      const sameFile = fileTypes.has(base);
+      relationships.push({
+        source: s.name,
+        target: base,
+        type: ASTEngine.RelationshipType.Extends,
+        confidence: 1,
+        ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+        metadata: { relationshipType: "nim_object_inheritance", ...sameFile ? {} : { nimCrossModuleBase: true } }
+      });
+    }
+  }
+  /**
+   * `implements` — `type A = concept x of B`.
+   *
+   * ## Why this is `implements` and not `extends`
+   *
+   * A Nim `concept` is the language's only interface-like construct, it is
+   * satisfied STRUCTURALLY and implicitly (no type is ever annotated as
+   * implementing it), and the `of` clause is a declaration that A's contract
+   * includes B's. That is the same fact the elixir lane publishes as
+   * `implements` for a `@impl Protocol` — a duck-typed contract, satisfied
+   * without naming — and the same fact graphql publishes for `type X implements
+   * Y`. `extends` in this analyzer is already taken by the nominal class
+   * hierarchy (`object_declaration.inherits`), and this edge is emphatically not
+   * that: there is no vtable, no base type and no nominal subtype relation
+   * anywhere in a concept refinement.
+   *
+   * The two labels are not interchangeable here, and conflating them is exactly
+   * the confusion question 4 asks about: `A extends B` says A's storage contains
+   * B's; `A implements B` says anything satisfying A satisfies B.
+   *
+   * ## Why the base need not be declared in this file
+   *
+   * Same decision as `collectInheritance`, for the same reason: a concept
+   * refining a contract from a sibling module is ordinary Nim, and requiring a
+   * same-file declaration would drop the family the way it dropped cross-file
+   * `extends` at the seam (measured there: a three-file module persisted ZERO
+   * `extends` rows). The edge carries `nimCrossModuleContract` so a reader can
+   * tell a locally-declared contract from an imported one; the store resolves
+   * the far end.
+   *
+   * ## Confidence
+   *
+   * 1.0, not a guess. The `refines` field names the contract outright, in one
+   * spelling, with no name matching and no inference — the same grounds on which
+   * `extends` is 1.0 and the f#/graphql interface edges are 1.0. The
+   * `overrides` companion edge is 0.9 for a different reason: that one walks a
+   * PARTLY VISIBLE hierarchy, and this one does not walk anything.
+   *
+   * ## What it deliberately does NOT emit
+   *
+   * Concept SATISFACTION by an ordinary type (`type T = object` that happens to
+   * have `+` and `in`) is not emitted, and cannot be: it is decided by the
+   * compiler's structural matching at instantiation time, with no syntax naming
+   * the relationship. Inventing those edges is precisely the fabrication the
+   * workstream forbids — they would be unresolvable at both ends and would poison
+   * `bb_impact`. The `references` edge for the same `of` clause is deliberately
+   * KEPT, mirroring what this analyzer already does for `inherits` (which yields
+   * both `extends` and `references`): the ontology edge answers "which contract
+   * does this claim" and the type-graph edge answers "which types does this
+   * depend on", and those are two questions.
+   */
+  collectContractRefinement(rootNode, symbols, relationships) {
+    const localTypes = /* @__PURE__ */ new Set();
+    for (const s of symbols) if (s.kind === ASTEngine.SymbolKind.Interface) localTypes.add(s.name);
+    if (localTypes.size === 0) return;
+    for (const s of symbols) {
+      const refines = s.metadata?.nimRefines;
+      if (!Array.isArray(refines) || refines.length === 0) continue;
+      for (const raw of refines) {
+        const target = String(raw ?? "");
+        if (!target) continue;
+        if (target === s.name) continue;
+        const sameFile = localTypes.has(target);
+        relationships.push({
+          source: s.name,
+          target,
+          type: ASTEngine.RelationshipType.Implements,
+          confidence: 1,
+          ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+          metadata: {
+            relationshipType: "nim_concept_refinement",
+            nimContractKind: "concept",
+            ...sameFile ? {} : { nimCrossModuleContract: true }
+          }
+        });
+      }
+    }
+    this.collectIsFormRefinement(rootNode, symbols, relationships, localTypes);
+  }
+  /**
+   * `implements`, second spelling — the `is` form of concept refinement.
+   *
+   * ## The two spellings, and which one real code uses
+   *
+   * `nim/doc/manual_experimental.md:1205-1213` names them as alternatives for
+   * one fact: "When the matched type within a concept is directly tested against
+   * a different concept, we say that the outer concept is a refinement of the
+   * inner concept … As an alternative way of defining concept refinements, you
+   * can use the object inheritance syntax involving the `of` keyword". So
+   *
+   *     type B = concept x
+   *       …
+   *     type A = concept x of B      # the `of` form  (collectContractRefinement)
+   *     type A = concept x
+   *       x is B                     # the `is` form  (here)
+   *
+   * state the same relationship. The `of` clause is the rarer of the two: over
+   * 4,101 corpus files it occurs ZERO times while the corpus holds 216 concept
+   * declarations, so an analyzer that read only the clause would report the type
+   * as absent from a corpus that is full of concepts.
+   *
+   * ## The three guards, and why each is load-bearing
+   *
+   * The `is` form is a much wider syntax than the `of` clause, so each guard
+   * removes a class of statement that is NOT a refinement:
+   *
+   *   1. The LEFT side must be one of the concept's own formal parameters. In a
+   *      concept body `o.foo is B` tests the type of a FIELD named `foo`, which
+   *      constrains that field and refines nothing — the corpus has exactly this
+   *      case (`nim/tests/concepts/texplain.nim:136`, `o.foo is RegularConcept`),
+   *      and reading it as a refinement would be a fabricated edge.
+   *   2. The RIGHT side must be a concept THIS FILE declares. `x is int` is a
+   *      type constraint on the matched parameter, and `int` implements nothing.
+   *      Measured on the corpus: of 125 `is X` expressions in concept bodies, the
+   *      most frequent right-hand sides are `T` (31), `int` (23), `bool` (15),
+   *      `string` (10), `V` (5), `float` (5) — a generic parameter or a concrete
+   *      type in every one of those, and emitting `implements -> int` for them is
+   *      the fabrication the workstream forbids. Only 5 name a same-file concept,
+   *      so the guard drops 120 of 125 rather than 0.
+   *   3. A concept naming ITSELF is skipped, as on the `of` path. All 5 corpus
+   *      cases are this shape (`nim/tests/concepts/trecursive_concepts.nim:26`,
+   *      `distinctBase(x) is Primitive`; `tconcepts_issues.nim:421`,
+   *      `bend(x is Bendable)`), which is why this family's corpus count is 0
+   *      edges rather than 5.
+   *
+   * An imported contract is NOT guessed at, even though `extends` does allow a
+   * cross-module base here: the same spelling names a concept or a concrete type
+   * depending on a scope this pass cannot see, so the guard is not relaxed for a
+   * confidence discount. That is the declared limit, with its measurement.
+   *
+   * Confidence 1.0 on the same grounds as the `of` form: the declaration names
+   * the contract outright, and guards 1-3 have already excluded every reading in
+   * which that name could be something else.
+   */
+  collectIsFormRefinement(rootNode, symbols, relationships, localConcepts) {
+    if (localConcepts.size === 0) return;
+    const sites = [];
+    const walk = (node) => {
+      if (node.type === "type_declaration") {
+        const decl = node.namedChildCount > 0 ? node.namedChild(0) : null;
+        if (decl && decl.type === "type_symbol_declaration") {
+          const nameNode = decl.childForFieldName("name");
+          const concept = this.conceptDeclarationIn(node);
+          if (nameNode && concept) {
+            const params = /* @__PURE__ */ new Set();
+            for (const p of this.readConceptParameters(concept)) if (p.name) params.add(p.name);
+            sites.push({
+              name: this.readNameNode(nameNode).name,
+              params,
+              body: this.conceptBody(concept)
+            });
+          }
+        }
+      }
+      for (let i = node.childCount - 1; i >= 0; i--) {
+        const c = node.child(i);
+        if (c) walk(c);
+      }
+    };
+    walk(rootNode);
+    if (sites.length === 0) return;
+    for (const site of sites) {
+      if (!site.name || !site.body) continue;
+      const contracts = this.isFormContracts(site.body, site.params, localConcepts);
+      for (const contract of contracts) {
+        if (contract === site.name) continue;
+        relationships.push({
+          source: site.name,
+          target: contract,
+          type: ASTEngine.RelationshipType.Implements,
+          confidence: 1,
+          line_number: site.body.startPosition.row + 1,
+          metadata: {
+            relationshipType: "nim_concept_refinement",
+            nimContractKind: "concept",
+            nimRefinementSpelling: "is"
+          }
+        });
+      }
+    }
+    void symbols;
+  }
+  /** The `concept_declaration` inside a `type_declaration`'s right-hand side, if
+   *  the declaration is a concept at all. */
+  conceptDeclarationIn(typeDecl) {
+    const find = (n) => {
+      if (n.type === "concept_declaration") return n;
+      for (let i = 0; i < n.childCount; i++) {
+        const c = n.child(i);
+        if (!c) continue;
+        const hit = find(c);
+        if (hit) return hit;
+      }
+      return null;
+    };
+    return find(typeDecl);
+  }
+  /** A concept's body — the LAST named child, which the grammar puts after the
+   *  optional parameter list and the optional `of` clause. */
+  conceptBody(concept) {
+    for (let i = concept.namedChildCount - 1; i >= 0; i--) {
+      const c = concept.namedChild(i);
+      if (c) return c;
+    }
+    return null;
+  }
+  /** The contracts a concept body tests its matched parameter against with `is`,
+   *  keeping only names that are a concept of this file.
+   *
+   *  Two structural guards, and both are needed because the `is` form is a much
+   *  wider syntax than the `of` clause:
+   *
+   *  - the LEFT side must be a BARE formal parameter. `o.length is Sized` tests a
+   *    field's type (`nim/tests/concepts/texplain.nim:136`), and
+   *    `distinctBase(x) is Primitive` tests the result of a call
+   *    (`trecursive_concepts.nim:26`); neither refines a contract, and both are
+   *    rejected because their left side is not the parameter itself. This one
+   *    guard covers a chain (`x is Shape or name(x) is Sized`) without needing to
+   *    understand `or`/`and`: the second operand's left side is a call, so it
+   *    fails here.
+   *  - an `argument_list` is not descended into, because `bend(x is Bendable)`
+   *    states a constraint passed to a call rather than a refinement. The corpus
+   *    has that shape too (`tconcepts_issues.nim:421`).
+   */
+  isFormContracts(body, params, localConcepts) {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    const walk = (node) => {
+      if (node.type === "argument_list") return;
+      if (node.type === "infix_expression") {
+        const op = node.childForFieldName("operator");
+        const left = node.childForFieldName("left");
+        const right = node.childForFieldName("right");
+        if (op && op.text === "is" && left && left.type === "identifier" && params.has(left.text) && right && right.type === "identifier") {
+          const name = right.text;
+          if (localConcepts.has(name) && !seen.has(name)) {
+            seen.add(name);
+            out.push(name);
+          }
+        }
+      }
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c) walk(c);
+      }
+    };
+    walk(body);
+    return out;
+  }
+  /**
+   * `overrides` — Nim method dispatch is dynamic, so overriding is real. The
+   * derivation is AST-only and file-local: `declaredSubtypes` comes from
+   * `object_declaration.inherits`, so a `method m(d: Dog)` overrides a
+   * `method m(a: Animal)` exactly when this file declares `Dog` as a subtype of
+   * `Animal`. An overload SET (`method m(d: Dog)` and `method m(d: Cat)`) emits
+   * one edge per candidate and marks the edge ambiguous rather than guessing.
+   *
+   * Cross-file and system-library bases are NOT inferable without a semantic
+   * index, and are declared as an explicit limit rather than guessed from name
+   * shape.
+   */
+  collectOverrides(symbols, relationships, declaredSubtypes, companion) {
+    if (declaredSubtypes.size === 0 && !companion) return;
+    const byKey = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      if (s.kind !== ASTEngine.SymbolKind.Method) continue;
+      const receiver = String(s.metadata?.nimReceiverType ?? "");
+      if (!receiver) continue;
+      const key = `${receiver} ${s.name}`;
+      const arr = byKey.get(key) ?? [];
+      arr.push(s);
+      byKey.set(key, arr);
+    }
+    if (byKey.size === 0) return;
+    const emitted = /* @__PURE__ */ new Set();
+    for (const [key, group] of byKey) {
+      const sep = key.indexOf(" ");
+      const receiver = key.slice(0, sep);
+      const name = key.slice(sep + 1);
+      for (const superType of this.transitiveSupertypes(receiver, declaredSubtypes)) {
+        const bases = byKey.get(`${superType} ${name}`);
+        if (!bases) continue;
+        for (const b of bases) {
+          if (superType === receiver) continue;
+          const sourceLabel = `${receiver}.${name}`;
+          const targetLabel = `${superType}.${name}`;
+          const k = `${sourceLabel} ${targetLabel}`;
+          if (emitted.has(k)) continue;
+          emitted.add(k);
+          relationships.push({
+            source: sourceLabel,
+            target: targetLabel,
+            type: ASTEngine.RelationshipType.Overrides,
+            confidence: 1,
+            ...b.range?.startLine ? { line_number: b.range.startLine } : {},
+            metadata: { relationshipType: "nim_method_override", receiverType: receiver, baseReceiverType: superType }
+          });
+        }
+      }
+    }
+    if (!companion || byKey.size === 0) return;
+    const parentsOf = /* @__PURE__ */ new Map();
+    for (const [base, subs] of declaredSubtypes) {
+      for (const sub of subs) {
+        const arr = parentsOf.get(sub) ?? [];
+        if (arr.indexOf(base) === -1) arr.push(base);
+        parentsOf.set(sub, arr);
+      }
+    }
+    const getParents = (typeName) => parentsOf.get(typeName) ?? [];
+    for (const [key, group] of byKey) {
+      const sep = key.indexOf(" ");
+      const receiver = key.slice(0, sep);
+      const name = key.slice(sep + 1);
+      const startParents = parentsOf.get(receiver) ?? [];
+      if (startParents.length === 0) continue;
+      const declaring = findDeclaringParent(name, startParents, companion, getParents);
+      if (!declaring || declaring === receiver) continue;
+      const sourceLabel = `${receiver}.${name}`;
+      const targetLabel = `${declaring}.${name}`;
+      const k = `${sourceLabel} ${targetLabel}`;
+      if (emitted.has(k)) continue;
+      emitted.add(k);
+      relationships.push({
+        source: sourceLabel,
+        target: targetLabel,
+        type: ASTEngine.RelationshipType.Overrides,
+        // 0.9, not 1: the companion asserts that the other module DECLARES the
+        // method, which is the substance of the edge, but the walk could not
+        // descend past a base that is itself in a third module. The
+        // differential's 0.7 claim threshold keeps this a claim rather than an
+        // assertion, which is the honest reading of a partly-visible hierarchy.
+        confidence: 0.9,
+        ...group[0]?.range?.startLine ? { line_number: group[0].range.startLine } : {},
+        metadata: {
+          relationshipType: "nim_method_override",
+          receiverType: receiver,
+          baseReceiverType: declaring,
+          nimCrossFileBase: true,
+          nimResolution: "companion-index"
+        }
+      });
+    }
+  }
+  /** Every strict supertype of `leaf` reachable through the declared-subtype map. */
+  transitiveSupertypes(leaf, declaredSubtypes) {
+    const supers = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set([leaf]);
+    const queue = [leaf];
+    while (queue.length > 0) {
+      const cur = queue.pop();
+      for (const [base, subs] of declaredSubtypes) {
+        if (!subs.has(cur)) continue;
+        if (seen.has(base)) continue;
+        seen.add(base);
+        supers.add(base);
+        queue.push(base);
+      }
+    }
+    return supers;
+  }
+  /**
+   * `calls` / `uses` — the two value-flow families.
+   *
+   * `calls`  — a `call` / `dot_generic_call` node: the target is the callee LEAF
+   *            (shared-callee family rule — `a.b.c()` targets `c`), read from
+   *            the grammar's `function` field. Command syntax (`echo "x"`) is
+   *            the same node. A `bracket_expression` callee (`Foo[int](x)`,
+   *            `parseJson[int](s)`) is a generic INSTANTIATION and its target is
+   *            the `left` leaf. Compiler intrinsics that Nim does not allow a
+   *            user to overload are filtered (see NIM_BUILTINS).
+   *
+   * `uses`   — a READ of a name this file declares, from two positions:
+   *            (a) a bare `identifier` in an expression position, and
+   *            (b) the member leaf of a `dot_expression` that is not a call
+   *            callee (Nim's UFCS makes `x.foo` a member read). Resolution
+   *            requires the name to be declared in THIS file, because Nim's
+   *            declare-before-use rule makes anything else either an import or
+   *            an error. A lexical scope stack (parameters, generic
+   *            parameters, block/branch/loop bindings) suppresses shadowed
+   *            names so a local never swallows a file-level value.
+   */
+  collectCallsAndUses(rootNode, relationships, ctx) {
+    const emitted = /* @__PURE__ */ new Set();
+    const instantiated = /* @__PURE__ */ new Set();
+    const typeRefEmitted = /* @__PURE__ */ new Set();
+    const typeRefHelpers = this.makeDeclaredTypeRefHelpers(
+      relationships,
+      ctx.fileTypes,
+      ctx.genericParamNames,
+      ctx.fileValues,
+      ctx.fileCallables,
+      typeRefEmitted
+    );
+    const push = (source, target, type, confidence, line, extra) => {
+      const key = `${source} ${type} ${target}`;
+      if (emitted.has(key)) return;
+      emitted.add(key);
+      relationships.push({
+        source,
+        target,
+        type,
+        confidence,
+        line_number: line,
+        metadata: extra
+      });
+    };
+    const scopeStack = [];
+    const top = () => scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : null;
+    const isShadowed = (name) => {
+      for (let i = scopeStack.length - 1; i >= 0; i--) if (scopeStack[i].names.has(name)) return true;
+      return false;
+    };
+    const currentFn = () => {
+      for (let i = scopeStack.length - 1; i >= 0; i--) {
+        const name = scopeStack[i].fnName;
+        if (name) return name;
+      }
+      return "(global)";
+    };
+    const resolvable = (name) => ctx.fileValues.has(name) || ctx.fileEnumMembers.has(name) || ctx.fileFieldNames.has(name);
+    const stack = [{ node: rootNode, exit: false, pushed: false }];
+    while (stack.length > 0) {
+      const { node, exit, pushed } = stack.pop();
+      if (exit) {
+        if (pushed) scopeStack.pop();
+        continue;
+      }
+      const type = node.type;
+      let pushedScope = false;
+      this.collectInstantiationAt(node, relationships, ctx.fileTypes, ctx.fileCallables, instantiated, currentFn());
+      this.collectDeclaredTypeRefAt(node, typeRefHelpers);
+      const callable = this.callableNodes[type];
+      if (callable) {
+        const frame = { names: /* @__PURE__ */ new Set(), fnName: null };
+        const nameNode = node.childForFieldName("name");
+        const info = nameNode ? this.readNameNode(nameNode) : null;
+        frame.fnName = info?.name ?? null;
+        for (const p of this.readParameters(node)) if (p.name && p.name !== "_") frame.names.add(p.name);
+        for (const g of this.readGenericParameterNames(node)) frame.names.add(g);
+        scopeStack.push(frame);
+        pushedScope = true;
+      } else if (type === "concept_declaration") {
+        const frame = { names: /* @__PURE__ */ new Set(), fnName: null };
+        const ownerDecl = node.parent && node.parent.type === "type_declaration" ? node.parent.namedChild(0) : null;
+        if (ownerDecl) {
+          const n = ownerDecl.childForFieldName("name");
+          const info = n ? this.readNameNode(n) : null;
+          frame.fnName = info?.name ?? null;
+        }
+        const params = this.firstChildOfType(node, "parameter_list");
+        if (params) {
+          for (let i = 0; i < params.namedChildCount; i++) {
+            const c = params.namedChild(i);
+            if (c && (c.type === "identifier" || c.type === "accent_quoted") && c.text !== "_") frame.names.add(c.text);
+          }
+        }
+        scopeStack.push(frame);
+        pushedScope = true;
+      } else if (type === "statement_list" || type === "block" || type === "do_block" || type === "term_rewriting_pattern") {
+        scopeStack.push({ names: /* @__PURE__ */ new Set(), fnName: null });
+        pushedScope = true;
+      } else if (type === "of_branch" || type === "except_branch" || type === "elif_branch" || type === "else_branch" || type === "finally_branch") {
+        scopeStack.push({ names: /* @__PURE__ */ new Set(), fnName: null });
+        pushedScope = true;
+      } else if (type === "variable_declaration") {
+        const frame = top();
+        if (frame) {
+          const list = node.namedChildCount > 0 ? node.namedChild(0) : null;
+          if (list && list.type === "symbol_declaration_list") {
+            for (const bound of this.readBoundDeclarationNames(list)) frame.names.add(bound);
+          }
+        }
+      } else if (type === "for") {
+        scopeStack.push({ names: /* @__PURE__ */ new Set(), fnName: null });
+        pushedScope = true;
+        const left = node.childForFieldName("left");
+        if (left) {
+          const frame = top();
+          for (const d of this.symbolNamesIn(left)) if (d && frame) frame.names.add(d);
+        }
+      }
+      if (type === "except_branch") {
+        const values = node.childForFieldName("values");
+        if (values) {
+          const frame = top();
+          for (let i = 0; i < values.namedChildCount; i++) {
+            const v = values.namedChild(i);
+            if (v && v.type === "infix_expression") {
+              const op = v.childForFieldName("operator");
+              if (op && op.type === "as") {
+                const r = v.childForFieldName("right");
+                if (r && r.type === "identifier" && frame) frame.names.add(r.text);
+              }
+            }
+          }
+        }
+      }
+      if (type === "call") {
+        const fn = node.childForFieldName("function");
+        const leafForGate = fn ? this.calleeLeafNode(fn) : null;
+        const isTypeConstruction = !!leafForGate && ctx.fileTypes.has(leafForGate.text) && !ctx.fileCallables.has(leafForGate.text);
+        if (fn && this.isParameterModifierCall(node) && this.isInTypePosition(node)) {
+        } else if (isTypeConstruction) {
+        } else {
+          const leaf = fn ? this.calleeLeafNode(fn) : void 0;
+          const leafText = leaf?.text;
+          const isDocPragma = leafText === "runnableExamples" && this.runnableExamplesArgument(node) !== null;
+          if (leafText && leafText !== "_" && !isDocPragma && REAL_NIM_BUILTINS.indexOf(leafText) === -1 && !isKeywordLike(leafText)) {
+            const source = currentFn();
+            const importBased = fn ? this.isImportQualified(fn, ctx.importQualifiers) : false;
+            push(source, leafText, ASTEngine.RelationshipType.Calls, importBased ? 0.75 : 0.85, leaf ? leaf.startPosition.row + 1 : node.startPosition.row + 1, {
+              relationshipType: "nim_call",
+              callExpression: this.nodeText(node).slice(0, 60),
+              ...importBased ? { nimImportBased: true } : {}
+            });
+          }
+        }
+      } else if (type === "dot_generic_call") {
+        const fn = node.childForFieldName("function");
+        const leafText = fn?.text;
+        if (leafText && leafText !== "_" && REAL_NIM_BUILTINS.indexOf(leafText) === -1) {
+          push(currentFn(), leafText, ASTEngine.RelationshipType.Calls, 0.85, fn ? fn.startPosition.row + 1 : node.startPosition.row + 1, {
+            relationshipType: "nim_dot_generic_call",
+            callExpression: this.nodeText(node).slice(0, 60)
+          });
+        }
+      }
+      if (type === "dot_expression") {
+        const leaf = this.dotLeafNode(node);
+        const leafText = leaf?.text;
+        const left = node.childForFieldName("left");
+        const inCallCallee = this.isCallCallee(node);
+        const callableName = leafText && (ctx.fileCallables.has(leafText) || ctx.nestedCallables.has(leafText)) ? leafText : null;
+        if (callableName && !inCallCallee) {
+          push(currentFn(), callableName, ASTEngine.RelationshipType.Calls, 0.9, leaf ? leaf.startPosition.row + 1 : node.startPosition.row + 1, {
+            relationshipType: "nim_ufcs_member_call",
+            callExpression: this.nodeText(node).slice(0, 60)
+          });
+        } else if (leafText && leafText !== "_" && !inCallCallee && resolvable(leafText) && !isKeywordLike(leafText)) {
+          const importBased = left ? this.isImportQualified(left, ctx.importQualifiers) : false;
+          push(currentFn(), leafText, ASTEngine.RelationshipType.Uses, 0.75, leaf ? leaf.startPosition.row + 1 : node.startPosition.row + 1, {
+            relationshipType: "nim_member_access",
+            fieldAccessExpression: this.nodeText(node).slice(0, 60),
+            ...importBased ? { nimImportBased: true } : {}
+          });
+        }
+      }
+      if (type === "identifier") {
+        const name = node.text;
+        if (name !== "_" && !name.startsWith("gensym") && resolvable(name) && !isKeywordLike(name) && !this.isDeclarationName(node) && !this.isConceptParameterPosition(node) && !this.isCallCalleeSubtree(node) && !this.isDotLeaf(node) && !this.isInTypePosition(node) && !this.isModulePathPosition(node) && !this.isLabelPosition(node) && !this.isColonLabel(node) && !this.isExceptAliasPosition(node) && !this.isAssignmentTarget(node) && !this.isAssignmentTarget(node, true) && !isShadowed(name)) {
+          push(currentFn(), name, ASTEngine.RelationshipType.Uses, 1, node.startPosition.row + 1, {
+            relationshipType: "nim_identifier_usage",
+            nodeType: node.type
+          });
+        }
+      }
+      stack.push({ node, exit: true, pushed: pushedScope });
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const c = node.namedChild(i);
+        if (c) stack.push({ node: c, exit: false, pushed: false });
+      }
+    }
+  }
+  /**
+   * `references` — the declared-type graph, from the positions the grammar
+   * marks as types: the `type` field of a parameter/field/variant
+   * discriminator/value binding, the `return_type` of a routine or do-block, the
+   * `inherits` of an object, the `refines` of a concept, a `cast[T]`, and the
+   * right-hand side of a type alias.
+   *
+   * Two leaves are collected from a type expression, and both matter in Nim:
+   *   - the type CONSTRUCTOR (`Vec`, `Table`) — the same as the C/Rust family
+   *     rule;
+   *   - each type ARGUMENT (`seq[T]`, `Table[K, V]`, `array[3, T]`) — Nim has
+   *     no `operator()` call syntax for types, so `seq[MyType]` is the ONLY way
+   *     to depend on `MyType` and dropping the argument would lose the
+   *     dependency entirely. This is a documented, NIM-specific extension of the
+   *     zig "no generic-application refs" precedent.
+   *
+   * Builtin type names, this file's own generic parameters, and the alias's own
+   * name are excluded, so no edge can point at a name that is not a type.
+   */
+  /**
+   * The `instantiates` half of the fused edge walk, as a per-node handler.
+   *
+   * It used to own a full-tree walk with its own `{node, fn}` stack purely to
+   * learn the enclosing callable — which the fused walk already tracks for the
+   * shadow rules, so the second copy of that state was pure cost.
+   *
+   * `enclosing` arrives as the fused walk's `currentFn()`, which returns the
+   * sentinel "(global)" when no callable is in scope. The original produced
+   * `null` there and wrote `nextEnclosing ?? "(file)"`, so the sentinel is
+   * translated back rather than emitted: an instantiation at file scope has no
+   * callable to name, and the store resolves a relationship's source_symbol_id by
+   * matching the source name against a symbol, so "(global)" would resolve to
+   * nothing while "(file)" is the established spelling for this family.
+   */
+  collectInstantiationAt(node, relationships, fileTypes, fileCallables, emitted, enclosing) {
+    if (node.type !== "call") return;
+    const source = enclosing === "(global)" ? "(file)" : enclosing;
+    const fn = node.childForFieldName("function");
+    const leaf = fn ? this.calleeLeafNode(fn) : null;
+    const leafText = leaf?.text;
+    if (leafText && fileTypes.has(leafText) && !fileCallables.has(leafText)) {
+      const key = leafText;
+      if (!emitted.has(key)) {
+        emitted.add(key);
+        relationships.push({
+          source,
+          target: leafText,
+          type: ASTEngine.RelationshipType.Instantiates,
+          confidence: 0.9,
+          line_number: leaf ? leaf.startPosition.row + 1 : node.startPosition.row + 1,
+          metadata: { relationshipType: "nim_object_construction", callExpression: this.nodeText(node).slice(0, 60), isConstructor: true }
+        });
+      }
+    }
+    if (leafText === "new") {
+      const args = this.firstChildOfType(node, "argument_list");
+      if (args) {
+        for (let i = 0; i < args.namedChildCount; i++) {
+          const a = args.namedChild(i);
+          if (!a) continue;
+          const t = a.type === "identifier" ? a.text : null;
+          if (t && fileTypes.has(t) && !fileCallables.has(t) && !emitted.has(`new:${t}`)) {
+            emitted.add(`new:${t}`);
+            relationships.push({
+              source,
+              target: t,
+              type: ASTEngine.RelationshipType.Instantiates,
+              confidence: 0.9,
+              line_number: a.startPosition.row + 1,
+              metadata: { relationshipType: "nim_new_allocation", isConstructor: true }
+            });
+          }
+        }
+      }
+    }
+  }
+  /**
+   * The declared-type half's closures, built ONCE PER FILE.
+   *
+   * Hoisting these is the whole point of the factory. The first attempt at
+   * fusing this family kept the logic inline in the per-node handler, which meant
+   * `ownerOf` and the recursive `collectFromTypeExpression` were REBUILT ON EVERY
+   * NODE VISIT — they had been built once per file before that. The output was
+   * byte-identical and the change measured 5.5% SLOWER, in a walk that visits
+   * thousands of nodes per file.
+   *
+   * Same lesson as the rejected per-node `Map` memoization, arriving from the
+   * other direction: in a hot walk, allocating anything per node costs more than
+   * the traversal it rides on. So the rule for this walk is one stack, one local
+   * counter, and closures built once.
+   */
+  makeDeclaredTypeRefHelpers(relationships, fileTypes, genericParamNames, fileValues, fileCallables, emitted) {
+    const ownerOf = (start) => {
+      let owner = null;
+      let p = start;
+      while (p) {
+        const callable = this.callableNodes[p.type];
+        if (callable) {
+          const n = p.childForFieldName("name");
+          const info = n ? this.readNameNode(n) : null;
+          if (info?.name) return { name: info.name, kind: "callable" };
+          return null;
+        }
+        if (p.type === "type_declaration") {
+          const symDecl = p.namedChildCount > 0 ? p.namedChild(0) : null;
+          if (symDecl && symDecl.type === "type_symbol_declaration") {
+            const n = symDecl.childForFieldName("name");
+            const info = n ? this.readNameNode(n) : null;
+            if (info?.name) return { name: info.name, kind: "type" };
+          }
+          return null;
+        }
+        if (p.type === "field_declaration" || p.type === "variant_discriminator_declaration") {
+          p = p.parent;
+          continue;
+        }
+        if (p.type === "object_declaration") {
+          p = p.parent;
+          continue;
+        }
+        if (p.type === "statement_list" || p.type === "block" || p.type === "do_block") {
+          p = p.parent;
+          continue;
+        }
+        p = p.parent;
+      }
+      return owner;
+    };
+    const isValueNotType = (leaf) => fileValues.has(leaf) || fileCallables.has(leaf) || NIM_LITERAL_KEYWORDS.indexOf(leaf) !== -1;
+    const insideConceptBody = (n) => {
+      let p = n.parent;
+      while (p) {
+        if (p.type === "concept_declaration") return true;
+        p = p.parent;
+      }
+      return false;
+    };
+    const push = (site, relation, owner) => {
+      if (site.type !== "identifier") return;
+      const leaf = site.text;
+      if (!leaf) return;
+      if (NIM_BUILTIN_TYPES.indexOf(leaf) !== -1) return;
+      if (NIM_TYPE_POSITION_KEYWORDS.indexOf(leaf) !== -1) return;
+      if (leaf === NIM_CONCEPT_SELF && !fileTypes.has(leaf) && insideConceptBody(site)) return;
+      if (genericParamNames.has(leaf)) return;
+      if (isValueNotType(leaf)) return;
+      if (!owner) return;
+      const key = `${owner.name} ${leaf}`;
+      if (emitted.has(key)) return;
+      emitted.add(key);
+      relationships.push({
+        source: owner.name,
+        target: leaf,
+        type: ASTEngine.RelationshipType.References,
+        confidence: 0.9,
+        line_number: site.startPosition.row + 1,
+        metadata: { relationshipType: relation, declaredBy: owner.kind }
+      });
+    };
+    const collectFromTypeExpression = (te, relation, owner) => {
+      if (!te) return;
+      const ctor = this.typeConstructorLeaf(te);
+      if (ctor) push(ctor, relation, owner);
+      for (const arg of this.typeArgumentNodes(te)) {
+        if (arg.type === "identifier") {
+          push(arg, "nim_type_argument", owner);
+        } else {
+          collectFromTypeExpression(arg, "nim_type_argument", owner);
+        }
+      }
+    };
+    return { relationships, fileTypes, genericParamNames, emitted, ownerOf, collectFromTypeExpression, push };
+  }
+  /** The per-node arm of the declared-type family, riding the fused edge walk. */
+  collectDeclaredTypeRefAt(n, helpers) {
+    const { fileTypes, genericParamNames, emitted, ownerOf, collectFromTypeExpression, push } = helpers;
+    switch (n.type) {
+      case "parameter_declaration":
+      case "field_declaration":
+      case "variant_discriminator_declaration":
+      case "variable_declaration":
+      case "cast":
+      case "do_block": {
+        const t = n.childForFieldName("type");
+        if (t) collectFromTypeExpression(t, "nim_declared_type", ownerOf(n));
+        break;
+      }
+      case "proc_declaration":
+      case "func_declaration":
+      case "method_declaration":
+      case "iterator_declaration":
+      case "template_declaration":
+      case "macro_declaration":
+      case "converter_declaration": {
+        const ret = n.childForFieldName("return_type");
+        if (ret) collectFromTypeExpression(ret, "nim_return_type", ownerOf(n));
+        break;
+      }
+      case "object_declaration": {
+        const inh = n.childForFieldName("inherits");
+        if (inh) collectFromTypeExpression(inh, "nim_declared_type", ownerOf(n));
+        break;
+      }
+      case "concept_declaration": {
+        const list = this.refinementListOf(n);
+        for (let i = 0; list && i < list.namedChildCount; i++) collectFromTypeExpression(list.namedChild(i), "nim_declared_type", ownerOf(n));
+        break;
+      }
+      case "type_declaration": {
+        const symDecl = n.namedChildCount > 0 ? n.namedChild(0) : null;
+        if (symDecl && symDecl.type === "type_symbol_declaration") {
+          const selfName = symDecl.childForFieldName("name");
+          const selfText = selfName ? this.readNameNode(selfName).name : "";
+          const owner = selfText ? { name: selfText, kind: "type" } : null;
+          const rhs = this.typeDefinitionRhs(n);
+          if (rhs) {
+            const ctor = this.typeConstructorLeaf(rhs);
+            if (ctor && ctor.text !== selfText) push(ctor, "nim_type_alias", owner);
+            for (const arg of this.typeArgumentNodes(rhs)) {
+              if (arg.type === "identifier") {
+                if (arg.text !== selfText) push(arg, "nim_type_argument", owner);
+              } else {
+                collectFromTypeExpression(arg, "nim_type_argument", owner);
+              }
+            }
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  /** #419-D evidence-tier classification (family standard: rust/c/cpp/go/zig
+   *  all classify; an unclassified edge cannot be judged by the resolver). */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.evidenceClass) continue;
+      const t = String(r.type ?? "");
+      const rt = String(md.relationshipType ?? "");
+      if (t === "contains" || t === "extends" || t === "implements" || t === "overrides") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = rt === "nim_declared_type" || rt === "nim_type_alias" || rt === "nim_type_argument" ? "reference_qualified" : "import_based";
+        continue;
+      }
+      if (t === "instantiates") {
+        md.evidenceClass = "usage_contextual";
+        continue;
+      }
+      if (t === "exports") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      md.evidenceClass = rt === "nim_import" || rt === "nim_include" || md.nimImportBased ? "import_based" : "usage_contextual";
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // 5. POSITION HELPERS — every one of these is a grammar field or node type
+  // ═══════════════════════════════════════════════════════════════════════
+  /** The leaf NAME node of a `name` field: `_symbol` (identifier /
+   *  accent_quoted) or `exported_symbol` (the same, then `*`). */
+  readNameNode(node) {
+    if (node.type === "exported_symbol") {
+      const inner = node.namedChildCount > 0 ? node.namedChild(0) : null;
+      return {
+        name: inner ? inner.text : "",
+        exported: true,
+        range: inner ? this.nodeRange(inner) : this.nodeRange(node)
+      };
+    }
+    if (node.type === "identifier" || node.type === "accent_quoted") {
+      return { name: node.text, exported: false, range: this.nodeRange(node) };
+    }
+    return { name: node.text, exported: false, range: this.nodeRange(node) };
+  }
+  /** The identifier/leaf a call targets. `call.function` is `_basic_expression`
+   *  in three shapes: a bare name, a `dot_expression` chain (leaf), or a
+   *  `bracket_expression` (generic instantiation → its `left` leaf). */
+  calleeLeafNode(fn) {
+    let cur = fn;
+    let guard = 0;
+    while (cur && guard++ < 16) {
+      switch (cur.type) {
+        case "identifier":
+        case "accent_quoted":
+          return cur;
+        case "dot_expression": {
+          const right = cur.childForFieldName("right");
+          if (!right) return null;
+          if (right.type === "identifier" || right.type === "accent_quoted") return right;
+          cur = right;
+          continue;
+        }
+        case "bracket_expression": {
+          const left = cur.childForFieldName("left");
+          if (!left) return null;
+          cur = left;
+          continue;
+        }
+        case "parenthesized": {
+          const inner = cur.namedChildCount > 0 ? cur.namedChild(0) : null;
+          if (!inner) return null;
+          cur = inner;
+          continue;
+        }
+        default:
+          return null;
+      }
+    }
+    return null;
+  }
+  /** True when this identifier is the `right` field of a `dot_expression` — a
+   *  MEMBER read, which the dot branch owns. Without this the bare-identifier
+   *  branch claimed it first and the deduped edge was mislabelled. */
+  isDotLeaf(node) {
+    const p = node.parent;
+    if (!p || p.type !== "dot_expression") return false;
+    const right = p.childForFieldName("right");
+    return !!right && right.startIndex === node.startIndex && right.endIndex === node.endIndex;
+  }
+  /** The member leaf of a `dot_expression` — its `right` field. */
+  dotLeafNode(expr) {
+    const right = expr.childForFieldName("right");
+    if (right && (right.type === "identifier" || right.type === "accent_quoted")) return right;
+    return null;
+  }
+  /** True when this node IS the callee subtree of a `call` / `dot_generic_call`
+   *  — the `calls` edge owns that span, so a `uses` edge would be a duplicate. */
+  isCallCallee(node) {
+    const p = node.parent;
+    return !!p && (p.type === "call" || p.type === "dot_generic_call");
+  }
+  isCallCalleeSubtree(node) {
+    let top = node;
+    let p = node.parent;
+    while (p && p.type !== "call" && p.type !== "dot_generic_call" && p.type !== "statement_list" && p.type !== "block") {
+      top = p;
+      p = p.parent;
+    }
+    if (!p || p.type !== "call" && p.type !== "dot_generic_call") return false;
+    const fn = p.childForFieldName("function");
+    if (!fn) return false;
+    return top.startIndex >= fn.startIndex && top.endIndex <= fn.endIndex;
+  }
+  /**
+   * True when the identifier names a declaration rather than reading one. The
+   * grammar puts every declared name in exactly one of these shapes, so this is
+   * a closed list and not a heuristic: `symbol_declaration` (fields, values,
+   * for-loop variables, tuple destructuring), `type_symbol_declaration`
+   * (types), `enum_field_declaration`, `variant_discriminator_declaration`,
+   * and a `for` loop's `left` list.
+   */
+  /**
+   * True for a CONCEPT's formal parameter: the `x` of `type Addable = concept x`.
+   *
+   * It is a binding, not a read, and it is the one formal parameter in Nim
+   * written without any of the syntax the other binders use — no
+   * `symbol_declaration` wrapper, no type annotation, nothing for
+   * `isDeclarationName` to match. The read pass therefore published
+   * `uses (global) -> x` at file scope.
+   *
+   * Found by the M12 ground truth, where it was the single false positive out of
+   * 105 observed facts (precision 0.990). Only an independent audit could catch
+   * it: the differential's oracle did not emit the edge either, so the lane
+   * reported 0% unexplained with two implementations agreeing on something
+   * neither should have published.
+   */
+  isConceptParameterPosition(node) {
+    const parent = node.parent;
+    if (!parent || parent.type !== "parameter_list") return false;
+    return this.hasAncestorOfType(parent, "concept_declaration");
+  }
+  isDeclarationName(node) {
+    const p = node.parent;
+    if (!p) return false;
+    switch (p.type) {
+      case "symbol_declaration":
+      case "type_symbol_declaration":
+      case "enum_field_declaration":
+      case "variant_discriminator_declaration":
+      // `x*: int` — the export marker wraps the name, so the identifier's parent
+      // is `exported_symbol` and the `symbol_declaration` case above never fires.
+      case "exported_symbol":
+      case "tuple_deconstruct_declaration":
+      case "symbol_declaration_list":
+        return true;
+      default:
+        return false;
+    }
+  }
+  /**
+   * True when the identifier sits in a TYPE position. Determined by the
+   * grammar's own `type` / `return_type` / `inherits` / `refines` /
+   * `generic_parameters` fields and span containment, never by an ancestry
+   * guess — a type read is a declared-type fact, and emitting a `uses` edge for
+   * it as well would double-count.
+   */
+  isInTypePosition(node) {
+    let cur = node;
+    let p = node.parent;
+    let guard = 0;
+    while (p && guard++ < 32) {
+      if (p.type === "statement_list" || p.type === "block" || p.type === "source_file" || p.type === "do_block") return false;
+      for (const f of TYPE_POSITION_FIELDS) {
+        const field = p.childForFieldName(f);
+        if (field && field.startIndex <= cur.startIndex && field.endIndex >= cur.endIndex) return true;
+      }
+      cur = p;
+      p = p.parent;
+    }
+    return false;
+  }
+  /** True when the identifier is part of an `import`/`export`/`include` path —
+   *  a module name, never a value read. */
+  isModulePathPosition(node) {
+    let cur = node;
+    let p = node.parent;
+    let guard = 0;
+    while (p && guard++ < 16) {
+      if (p.type === "import_statement" || p.type === "export_statement" || p.type === "include_statement" || p.type === "import_from_statement") {
+        return true;
+      }
+      if (p.type === "statement_list" || p.type === "source_file" || p.type === "block") return false;
+      cur = p;
+      p = p.parent;
+    }
+    return false;
+  }
+  /**
+   * True for a LABEL: the name of a `block name:`, the operand of `break name` /
+   * `continue name`, and the left side of a `colon_expression`. Nim has no
+   * ternary, so `x: value` only ever names a field — of an object construction
+   * (`Vec(x: 1)`) or of a variant branch — and never reads one.
+   */
+  isColonLabel(node) {
+    const p = node.parent;
+    if (!p || p.type !== "colon_expression") return false;
+    const left = p.childForFieldName("left");
+    return !!left && left.startIndex === node.startIndex && left.endIndex === node.endIndex;
+  }
+  /** True for a `block name:` label and the `break name` / `continue name`
+   *  operand — a goto target, not a read. */
+  isLabelPosition(node) {
+    const p = node.parent;
+    if (!p) return false;
+    if (p.type === "break_statement" || p.type === "continue_statement") return true;
+    const label = p.childForFieldName?.("label");
+    return !!label && label.startIndex === node.startIndex && label.endIndex === node.endIndex;
+  }
+  /** True for the right side of an `… as name` in an `except` clause — a
+   *  binding, not a read. */
+  isExceptAliasPosition(node) {
+    const p = node.parent;
+    if (!p || p.type !== "infix_expression") return false;
+    const op = p.childForFieldName("operator");
+    if (!op || op.type !== "as") return false;
+    const right = p.childForFieldName("right");
+    return !!right && right.startIndex === node.startIndex && right.endIndex === node.endIndex;
+  }
+  /**
+   * An assignment target is a WRITE, never a read. For `x = 1` the left field's
+   * identifier is the target; for `a.x = 1` the dot leaf is; for `a[i] = 1` the
+   * base and the index are both READS, so nothing is suppressed. The first pass
+   * (non-member) covers `identifier`; the `member` pass covers the dot leaf.
+   */
+  isAssignmentTarget(node, member = false) {
+    const p = node.parent;
+    if (!p || p.type !== "assignment") return false;
+    const left = p.childForFieldName("left");
+    if (!left || left.startIndex > node.startIndex || left.endIndex < node.endIndex) return false;
+    if (member) return this.isLeftmostLeafOf(p);
+    return left.type === "identifier";
+  }
+  isLeftmostLeafOf(node) {
+    let cur = node;
+    for (; ; ) {
+      const p = cur.parent;
+      if (!p) return false;
+      if (p.type === "dot_expression") {
+        const left = p.childForFieldName("left");
+        if (left && left.startIndex <= cur.startIndex && left.endIndex >= cur.endIndex) {
+          cur = p;
+          continue;
+        }
+        return false;
+      }
+      if (p.type === "bracket_expression") {
+        const left = p.childForFieldName("left");
+        if (left && left.startIndex <= cur.startIndex && left.endIndex >= cur.endIndex) {
+          cur = p;
+          continue;
+        }
+        return false;
+      }
+      if (p.type === "call" || p.type === "parenthesized") {
+        const first = p.namedChildCount > 0 ? p.namedChild(0) : null;
+        if (first && first.startIndex <= cur.startIndex && first.endIndex >= cur.endIndex) {
+          cur = p;
+          continue;
+        }
+        return false;
+      }
+      return false;
+    }
+  }
+  /** True when the leftmost identifier of a chain is a module qualifier from
+   *  this file's imports — `os.getCurrentDir()` is an import-based fact, not a
+   *  local member read. */
+  isImportQualified(node, qualifiers) {
+    if (qualifiers.size === 0) return false;
+    let cur = node;
+    let guard = 0;
+    while (guard++ < 16) {
+      if (cur.type === "identifier" || cur.type === "accent_quoted") return qualifiers.has(cur.text);
+      let next = null;
+      for (const f of ["left", "function", "first_argument"]) {
+        const fld = cur.childForFieldName(f);
+        if (fld && fld.startIndex <= cur.startIndex && cur.endIndex <= fld.endIndex) {
+          next = fld;
+          break;
+        }
+      }
+      if (!next && cur.type !== "dot_expression" && cur.type !== "bracket_expression" && cur.type !== "call") {
+        const first = cur.namedChildCount > 0 ? cur.namedChild(0) : null;
+        if (first && first.startIndex <= cur.startIndex && first.endIndex >= cur.endIndex) next = first;
+      }
+      if (!next) return false;
+      cur = next;
+    }
+    return false;
+  }
+  /**
+   * True for `sink T` / `out T` / `var T` / `let T` written as a one-argument
+   * call — the shape this grammar gives a modifier keyword that has no node of
+   * its own (`doc/grammar.txt` spells the modifier inline in `paramList`, and
+   * `var`/`out`/`ref`/`ptr`/`distinct` each got a `*_type` node; `sink` did not).
+   * `PARAMETER_MODIFIERS` is a closed set of grammar keywords, so this is a token
+   * comparison and never a text pattern.
+   */
+  isParameterModifierCall(node) {
+    if (node.type !== "call") return false;
+    const fn = node.childForFieldName("function");
+    if (!fn || fn.type !== "identifier") return false;
+    if (PARAMETER_MODIFIERS.indexOf(fn.text) === -1) return false;
+    const args = this.firstChildOfType(node, "argument_list");
+    return !!args && args.namedChildCount === 1;
+  }
+  /**
+   * The type CONSTRUCTOR leaf of a type expression: the leftmost identifier of
+   * the outermost `bracket_expression` / `call`, unwrapping the `ref`/`ptr`/
+   * `var`/`out`/`distinct`/`type` modifiers. `seq[T]` → `seq`, `Table[K, V]` →
+   * `Table`, `ref Node` → `Node`, `int` → `int`.
+   */
+  typeConstructorLeaf(te) {
+    let cur = te;
+    let guard = 0;
+    while (guard++ < 16) {
+      if (cur.type === "identifier" || cur.type === "accent_quoted") return cur;
+      if (cur.type === "type_expression") {
+        const inner = cur.namedChildCount > 0 ? cur.namedChild(0) : null;
+        if (!inner) return null;
+        cur = inner;
+        continue;
+      }
+      if (cur.type === "ref_type" || cur.type === "pointer_type" || cur.type === "out_type" || cur.type === "var_type" || cur.type === "distinct_type") {
+        const inner = this.lastNamedChild(cur);
+        if (!inner) return null;
+        cur = inner;
+        continue;
+      }
+      if (cur.type === "bracket_expression") {
+        const left = cur.childForFieldName("left");
+        if (!left) return null;
+        cur = left;
+        continue;
+      }
+      if (cur.type === "call") {
+        const fn = cur.childForFieldName("function");
+        if (!fn) return null;
+        if (this.isParameterModifierCall(cur)) {
+          const inner = this.firstChildOfType(cur, "argument_list");
+          const only = inner && inner.namedChildCount === 1 ? inner.namedChild(0) : null;
+          if (only) {
+            cur = only;
+            continue;
+          }
+        }
+        cur = fn;
+        continue;
+      }
+      if (cur.type === "dot_expression") {
+        const right = cur.childForFieldName("right");
+        if (!right) return null;
+        cur = right;
+        continue;
+      }
+      return null;
+    }
+    return null;
+  }
+  /** The type ARGUMENT nodes of a generic type expression — `T` in `seq[T]`,
+   *  `K` and `V` in `Table[K, V]`. */
+  typeArgumentNodes(te) {
+    let cur = te;
+    let guard = 0;
+    while (guard++ < 16) {
+      if (cur.type === "type_expression") {
+        const inner = cur.namedChildCount > 0 ? cur.namedChild(0) : null;
+        if (!inner) return [];
+        cur = inner;
+        continue;
+      }
+      if (cur.type === "ref_type" || cur.type === "pointer_type" || cur.type === "out_type" || cur.type === "var_type" || cur.type === "distinct_type") {
+        const inner = this.lastNamedChild(cur);
+        if (!inner) return [];
+        cur = inner;
+        continue;
+      }
+      if (cur.type === "bracket_expression") {
+        const right = cur.childForFieldName("right");
+        if (!right) return [];
+        const out = [];
+        for (let i = 0; i < right.namedChildCount; i++) {
+          const c = right.namedChild(i);
+          if (c) out.push(c);
+        }
+        return out;
+      }
+      if (cur.type === "call") {
+        if (this.isParameterModifierCall(cur)) {
+          const inner = this.firstChildOfType(cur, "argument_list");
+          const only = inner && inner.namedChildCount === 1 ? inner.namedChild(0) : null;
+          return only ? [only] : [];
+        }
+        const args = this.firstChildOfType(cur, "argument_list");
+        if (!args) return [];
+        const out = [];
+        for (let i = 0; i < args.namedChildCount; i++) {
+          const c = args.namedChild(i);
+          if (c) out.push(c);
+        }
+        return out;
+      }
+      return [];
+    }
+    return [];
+  }
+  /** The leaf NAME of a `type_expression`, used for `nimInherits` and for the
+   *  method receiver type. */
+  typeLeafName(te) {
+    const leaf = this.typeConstructorLeaf(te);
+    return leaf ? leaf.text : "";
+  }
+  /**
+   * A `method`'s dispatch receiver: the first parameter's declared type, as the
+   * OUTERMOST type name. `method speak(a: Animal)` → `Animal`;
+   * `method speak(d: ref Dog)` → `Dog`; a container receiver
+   * (`method first[T](a: seq[T])`) dispatches on the CONTAINER (`seq`), so the
+   * type arguments are deliberately not part of it. Derived from the AST
+   * (`parameters` → first `parameter_declaration` → `type` field), never by
+   * re-parsing the parameter's text.
+   */
+  methodReceiverTypeLeaf(node) {
+    const params = node.childForFieldName("parameters");
+    if (!params) return "";
+    for (let i = 0; i < params.namedChildCount; i++) {
+      const p = params.namedChild(i);
+      if (!p || p.type !== "parameter_declaration") continue;
+      const t = p.childForFieldName("type");
+      if (!t) return "";
+      const leaf = this.typeConstructorLeaf(t);
+      return leaf ? leaf.text : "";
+    }
+    return "";
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // 6. PURE HELPERS
+  // ═══════════════════════════════════════════════════════════════════════
+  pushChildren(node, stack, inCallable, enclosingCallable, docExample, objectKind, exampleBody) {
+    const exampleStart = exampleBody ? exampleBody.startIndex : -1;
+    for (let i = node.namedChildCount - 1; i >= 0; i--) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      const inExample = exampleStart >= 0 && c.startIndex === exampleStart;
+      stack.push({
+        node: c,
+        // Inside the example, `inCallable` is FALSE: the C-D1 rule suppressed
+        // these because they sat inside a routine BODY, and the example is not
+        // the body. Value declarations are suppressed separately, by `docExample`.
+        inCallable: inExample ? false : inCallable,
+        enclosingCallable,
+        docExample: inExample ? true : docExample,
+        objectKind
+      });
+    }
+  }
+  /**
+   * A routine's children are NOT all its body, and reading them as if they were
+   * dropped real declarations.
+   *
+   * The pinned grammar ABSORBS a `##` doc comment into the declaration node (see
+   * `collectDocModulesAndComplexity` for the two placements and why reading only
+   * the sibling form measured zero docstrings). So for
+   *
+   *     proc `of`*[T, S](x: T, y: typedesc[S]): bool =
+   *       ## Checks if `x` is an instance of `y`.
+   *       runnableExamples:
+   *         type
+   *           Base = ref object of RootObj
+   *           Sub1 = ref object of Base
+   *
+   * the doc comment — and the `runnableExamples:` code the Nim COMPILER compiles
+   * as its own unit — is a child of the `proc_declaration`, sibling to the `body`
+   * field. Pushing every child with `inCallable: true` therefore marked
+   * `Base` and `Sub1` as body-local and published neither.
+   *
+   * Measured cost over the corpus: 9 `object_declaration.inherits` occurrences on
+   * the parse tree had no published owner symbol, every one of them inside a
+   * `runnableExamples` block (nim/lib/system.nim Sub1/Sub2, lib/std/assertions.nim
+   * MyError, tests/stdlib/trepr.nim TFoo, tests/stdlib/tjsonmacro.nim MsgChallenge,
+   * tests/template/template_issues.nim `name`) — so `extends` lost the edges and
+   * the graph lost the symbols.
+   *
+   * Only the `body` field carries `inCallable: true`, which is exactly the
+   * distinction the C-D1 rule wanted: a `type` section inside a BODY is still
+   * dropped, and a `type` section inside a DOC COMMENT is a declaration the
+   * compiler type-checks.
+   */
+  pushCallableChildren(node, stack, enclosingCallable) {
+    const body = node.childForFieldName("body");
+    const selfName = this.callableNameOf(node);
+    const bodyStart = body ? body.startIndex : -1;
+    for (let i = node.namedChildCount - 1; i >= 0; i--) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      const isBody = c.startIndex === bodyStart && bodyStart >= 0;
+      stack.push({ node: c, inCallable: isBody, enclosingCallable: isBody ? selfName : enclosingCallable, docExample: false, objectKind: "" });
+    }
+  }
+  /** The published NAME of a routine node, or "" when it has none. */
+  callableNameOf(node) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode) return "";
+    return this.readNameNode(nameNode).name;
+  }
+  nodeRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+  nodeText(node) {
+    return node ? node.text : "";
+  }
+  snippet(text) {
+    return text.length > 50 ? `${text.slice(0, 50)}\u2026` : text;
+  }
+  /** The last NAMED child. `ref`/`ptr`/`var`/`out`/`distinct` are anonymous
+   *  tokens, so a wrapper node's only named child is the type it wraps —
+   *  `namedChild(1)` is always null on one. */
+  lastNamedChild(node) {
+    for (let i = node.namedChildCount - 1; i >= 0; i--) {
+      const c = node.namedChild(i);
+      if (c) return c;
+    }
+    return null;
+  }
+  firstChildOfType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === type) return c;
+    }
+    return null;
+  }
+  symbolNamesIn(node) {
+    const out = [];
+    if (node.type === "symbol_declaration_list") {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const d = node.namedChild(i);
+        if (!d) continue;
+        if (d.type === "symbol_declaration") {
+          const n = d.childForFieldName("name");
+          const info2 = n ? this.readNameNode(n) : null;
+          if (info2?.name) out.push(info2.name);
+        } else if (d.type === "tuple_deconstruct_declaration") {
+          for (let j = 0; j < d.namedChildCount; j++) {
+            const inner = d.namedChild(j);
+            const info2 = inner ? this.readNameNode(inner) : null;
+            if (info2?.name) out.push(info2.name);
+          }
+        }
+      }
+      return out;
+    }
+    const info = this.readNameNode(node);
+    if (info.name) out.push(info.name);
+    return out;
+  }
+  identifierTextsIn(node) {
+    if (!node) return [];
+    const out = [];
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "identifier") {
+        out.push(n.text);
+        continue;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return out;
+  }
+  unquote(text) {
+    if (text.length >= 2 && text.startsWith('"') && text.endsWith('"')) return text.slice(1, -1);
+    return text;
+  }
+  moduleSegments(path) {
+    const parts = path.split("/");
+    const out = [];
+    for (const p of parts) {
+      if (!p) continue;
+      if (p === "." || p === "..") {
+        out.push(p);
+        continue;
+      }
+      out.push(p);
+    }
+    return out;
+  }
+  isDescendantOf(node, ancestor) {
+    let p = node.parent;
+    let guard = 0;
+    while (p && guard++ < 32) {
+      if (p.id === ancestor.id) return true;
+      p = p.parent;
+    }
+    return false;
+  }
+  /**
+   * Cyclomatic complexity over a body. Decision points are the grammar's own
+   * branch/statement nodes (`if`, `when`, `case`, `while`, `for`, and every
+   * `elif`/`else`/`of`/`except`/`finally` branch), plus the short-circuit
+   * boolean operators. `and`/`or`/`xor`/`not` are ANONYMOUS tokens with their
+   * own node types, so they are matched by token type, never by a substring of
+   * the expression text.
+   */
+  nimCyclomaticComplexity(node) {
+    let c = 1;
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (BRANCH_NODES.indexOf(n.type) !== -1) c++;
+      if (n.type === "infix_expression") {
+        const op = n.childForFieldName("operator");
+        if (op && !op.isNamed && (op.type === "and" || op.type === "or" || op.type === "xor")) c++;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c2 = n.namedChild(i);
+        if (c2) stack.push(c2);
+      }
+    }
+    return c;
+  }
+};
+var NIM_LITERAL_KEYWORDS = ["true", "false", "nil", "void", "auto"];
+var BACKSLASH = 92;
+var DOUBLE_QUOTE = 34;
+var SLASH = 47;
+var WHITESPACE_CODE_UNITS = /* @__PURE__ */ new Set([
+  9,
+  10,
+  11,
+  12,
+  13,
+  // tab, LF, VT, FF, CR
+  32,
+  // space
+  160,
+  // no-break space
+  5760,
+  // ogham space mark
+  8192,
+  8193,
+  8194,
+  8195,
+  8196,
+  8197,
+  8198,
+  8199,
+  8200,
+  8201,
+  8202,
+  // en/em spaces + the rest of the U+2000 block
+  8232,
+  8233,
+  // line/paragraph separator
+  8239,
+  // narrow no-break space
+  8287,
+  // medium mathematical space
+  12288,
+  // ideographic space
+  65279
+  // zero width no-break space
+]);
+var isPathSpace = (code) => WHITESPACE_CODE_UNITS.has(code);
+var startsWithStdAt = (s, i) => s.charCodeAt(i) === 115 && // s
+s.charCodeAt(i + 1) === 116 && // t
+s.charCodeAt(i + 2) === 100;
+var TYPE_POSITION_FIELDS = ["type", "return_type", "inherits", "refines", "generic_parameters"];
+var BRANCH_NODES = [
+  "if",
+  "when",
+  "case",
+  "while",
+  "for",
+  "elif_branch",
+  "else_branch",
+  "of_branch",
+  "except_branch",
+  "finally_branch"
+];
+var REAL_NIM_BUILTINS = [
+  "echo",
+  "assert",
+  "new",
+  "newSeq",
+  "newString",
+  "newFloat",
+  "inc",
+  "dec",
+  "swap",
+  "copyMem",
+  "moveMem",
+  "zeroMem",
+  "getType",
+  "typeof",
+  "sizeof",
+  "alignof",
+  "isNil",
+  "wasMoved",
+  "incl",
+  "excl",
+  "high",
+  "low",
+  "ord",
+  "result",
+  "nil",
+  "true",
+  "false",
+  "cast",
+  "addr",
+  "bind",
+  "mixin",
+  "static",
+  "discard",
+  "raise",
+  "yield",
+  "return",
+  "break",
+  "continue",
+  "type",
+  "var",
+  "let",
+  "const",
+  "object",
+  "enum",
+  "tuple",
+  "proc",
+  "func",
+  "method",
+  "iterator",
+  "macro",
+  "template",
+  "converter",
+  "concept",
+  "out",
+  "ref",
+  "ptr",
+  "distinct",
+  "range",
+  "set",
+  "seq",
+  "array",
+  "varargs",
+  "pointer",
+  "auto",
+  "untyped",
+  "typedesc",
+  "void",
+  "int",
+  "int8",
+  "int16",
+  "int32",
+  "int64",
+  "uint",
+  "uint8",
+  "uint16",
+  "uint32",
+  "uint64",
+  "float",
+  "float32",
+  "float64",
+  "bool",
+  "char",
+  "string",
+  "cstring",
+  "byte",
+  "ordinal",
+  "system"
+];
+var PARAMETER_MODIFIERS = ["sink", "out", "var", "let", "static"];
+var NIM_COMPILER_ROOTS = /* @__PURE__ */ new Set(["RootObj", "RootRef", "Object", "rootObj"]);
+var NIM_CONCEPT_SELF = "Self";
+var NIM_TYPE_POSITION_KEYWORDS = ["static", "type"];
+var NIM_BUILTIN_TYPES = [
+  // integer / float / fixed-width
+  "int",
+  "int8",
+  "int16",
+  "int32",
+  "int64",
+  "uint",
+  "uint8",
+  "uint16",
+  "uint32",
+  "uint64",
+  "float",
+  "float32",
+  "float64",
+  "bool",
+  "char",
+  "byte",
+  "string",
+  "cstring",
+  "void",
+  "auto",
+  "untyped",
+  "typedesc",
+  "ordinal",
+  "range",
+  // algebraic type classes the standard library defines
+  "SomeInteger",
+  "SomeFloat",
+  "SomeNumber",
+  "SomeOrdinal",
+  "SomeOrdered",
+  "Natural",
+  "Positive",
+  "Signed",
+  "Unsigned",
+  "Ordinal",
+  "Ordered",
+  "SomeComparable",
+  "SomeCopyable",
+  "SomeDefault",
+  // containers (a declared-type reference to a container is not a dependency
+  // on a user type; the type ARGUMENTS are collected separately)
+  "seq",
+  "array",
+  "openArray",
+  "set",
+  "tuple",
+  "varargs",
+  "pointer",
+  "Table",
+  "OrderedTable",
+  "CountTable",
+  "HashSet",
+  "OrderedSet",
+  "CountSet",
+  "touches",
+  "isNil",
+  "lent",
+  // c-interop aliases
+  "cpointer",
+  "clong",
+  "cint",
+  "cshort",
+  "cchar",
+  "cschar",
+  "cuchar",
+  "csize",
+  "cfloat",
+  "cdouble",
+  "clonglong",
+  "culonglong",
+  "cstringarray",
+  // the compiler's own roots and the module every file implicitly imports
+  "Object",
+  "RootObj",
+  "RootRef",
+  "rootObj",
+  "system",
+  // common standard-library types that appear bare in annotations
+  "File",
+  "FileStream",
+  "PFile",
+  "PFileStream",
+  "StringStream",
+  "WideString",
+  "charStream",
+  "CString",
+  "TEndian",
+  "Endian"
+];
+function isKeywordLike(name) {
+  return KEYWORD_LIKE.indexOf(name) !== -1;
+}
+var KEYWORD_LIKE = [
+  "addr",
+  "and",
+  "as",
+  "bind",
+  "block",
+  "break",
+  "case",
+  "concept",
+  "const",
+  "continue",
+  "converter",
+  "defer",
+  "discard",
+  "distinct",
+  "div",
+  "do",
+  "elif",
+  "else",
+  "end",
+  "enum",
+  "except",
+  "export",
+  "finally",
+  "for",
+  "from",
+  "func",
+  "if",
+  "import",
+  "in",
+  "include",
+  "interface",
+  "is",
+  "isnot",
+  "iterator",
+  "let",
+  "macro",
+  "method",
+  "mixin",
+  "mod",
+  "nil",
+  "not",
+  "notin",
+  "object",
+  "of",
+  "or",
+  "out",
+  "proc",
+  "ptr",
+  "raise",
+  "ref",
+  "return",
+  "shl",
+  "shr",
+  "static",
+  "template",
+  "try",
+  "tuple",
+  "type",
+  "using",
+  "var",
+  "when",
+  "while",
+  "xor",
+  "yield"
+];
+export {
+  REAL_NIM_BUILTINS,
+  RealNimAnalyzer
+};