@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/real-haskell-analyzer-I5L2GR3Y.js

@@ -0,0 +1,2533 @@
+import {
+  ASTEngine
+} from "./chunk-V44PGPA6.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import {
+  BINDING_SEP
+} from "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-haskell-analyzer.ts
+var HASKELL_DECLARATION_KEYWORDS = /* @__PURE__ */ new Set([
+  "type",
+  "data",
+  "newtype",
+  "class",
+  "instance",
+  "family",
+  "pattern",
+  "proc",
+  "default",
+  "module"
+]);
+var HASKELL_TYPE_BEARING_NODES = /* @__PURE__ */ new Set([
+  "type",
+  "signature",
+  "type_synomym",
+  "type_synonym",
+  "data_type",
+  "newtype",
+  "type_patterns",
+  "type_family",
+  "type_instance",
+  "deriving",
+  "deriving_instance",
+  "class",
+  "instance",
+  "strict_field",
+  "field_pattern",
+  "forall",
+  "quantified_variables",
+  "promoted",
+  "type_params",
+  "constraint",
+  "context",
+  "deriving_strategy",
+  "via",
+  "kind_signature",
+  "arity",
+  "kind",
+  "children"
+]);
+var RealHaskellAnalyzer = class {
+  analyze(rootNode, content, filePath) {
+    const ctx = {
+      symbols: [],
+      relationships: [],
+      imports: [],
+      exports: [],
+      errors: [],
+      patterns: {},
+      frameworks: {},
+      typeSignatures: {},
+      functionSymbolIndex: {},
+      declaredFunctions: /* @__PURE__ */ new Set(),
+      declaredTypes: /* @__PURE__ */ new Set(),
+      declaredConstructors: /* @__PURE__ */ new Set(),
+      importAliases: /* @__PURE__ */ new Map(),
+      annPragmas: 0,
+      classMethods: /* @__PURE__ */ new Map(),
+      localScopes: { callableScoped: /* @__PURE__ */ new Map(), blockLocals: /* @__PURE__ */ new Map(), frameLocals: /* @__PURE__ */ new Map() },
+      // A file with no `module` header is module `Main` — the language rule.
+      // Defaulted HERE, before the walk, because the import edge is pushed during
+      // it and read `currentModule || ""`; defaulting in the post-loop was too
+      // late and still produced `imports -> Distribution.Simple` with no source.
+      currentModule: "Main",
+      currentFunction: void 0,
+      seenRels: /* @__PURE__ */ new Set()
+    };
+    const scopeStack = [];
+    const stack = [{ node: rootNode }];
+    let cyclomaticComplexity = 1;
+    this.collectDeclaredFunctions(rootNode, ctx.declaredFunctions);
+    this.collectDeclaredTypes(rootNode, ctx.declaredTypes);
+    this.collectDeclaredConstructors(rootNode, ctx.declaredConstructors);
+    this.collectClassMethods(rootNode, ctx.classMethods);
+    this.collectLocalScopes(rootNode, ctx.localScopes);
+    while (stack.length > 0) {
+      const { node, isExit, restoreFn } = stack.pop();
+      if (isExit) {
+        if (restoreFn !== void 0) ctx.currentFunction = restoreFn;
+        else if (node.type === "function" || node.type === "bind" || node.type === "class" || node.type === "instance" || node.type === "data" || node.type === "newtype") {
+          ctx.currentFunction = void 0;
+        }
+        if (scopeStack.length > 0 && scopeStack[scopeStack.length - 1].node === node) scopeStack.pop();
+        continue;
+      }
+      if (node.hasError || node.isMissing) {
+        if (node.type === "ERROR" || node.type === "MISSING") {
+          ctx.errors.push({
+            message: `Syntax ${node.type} detected.`,
+            range: this.nodeToRange(node),
+            severity: "warning"
+          });
+        }
+      }
+      let pushedScope = false;
+      const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+      if (node.type === "case" || node.type === "conditional" || node.type === "guards") {
+        cyclomaticComplexity++;
+      }
+      if (node.type === "do") ctx.patterns["Monads"] = true;
+      if (node.type === "list_comprehension") ctx.patterns["List Comprehensions"] = true;
+      if (node.type === "case" || node.type === "patterns") ctx.patterns["Pattern Matching"] = true;
+      if (node.type === "header") {
+        pushedScope = this.processModule(node, ctx, scopeStack);
+      } else if (node.type === "import") {
+        this.processImport(node, ctx);
+      } else if (node.type === "signature") {
+        const p = node.parent?.type;
+        const isDeclSig = p === "declarations" || p === "local_binds" || p === "class" || p === "instance" || p === "class_declarations" || p === "instance_declarations";
+        if (isDeclSig) {
+          this.processSignature(node, ctx, currentScope, currentScope?.kind === ASTEngine.SymbolKind.Namespace);
+          continue;
+        }
+        const expr = node.namedChildCount > 0 ? node.namedChild(0) : null;
+        if (expr) stack.push({ node: expr });
+        continue;
+      } else if (node.type === "function" || node.type === "bind") {
+        const hasArrowBind = this.hasChildOfType(node, "<-");
+        const localScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+        const insideLocalBlock = localScope?.kind === ASTEngine.SymbolKind.Namespace;
+        if (hasArrowBind) {
+          stack.push({ node, isExit: true, restoreFn: ctx.currentFunction });
+        } else if (!insideLocalBlock) {
+          pushedScope = this.processFunction(node, ctx, currentScope, scopeStack);
+          if (!pushedScope && !(node.type === "function" && (node.childForFieldName("parameter") || node.childForFieldName("result")))) {
+            stack.push({ node, isExit: true, restoreFn: ctx.currentFunction });
+          }
+        } else if (node.type === "function") {
+          stack.push({ node, isExit: true, restoreFn: ctx.currentFunction });
+          const head = node.namedChildCount > 0 ? node.namedChild(0) : null;
+          let localName;
+          if (head?.type === "variable") {
+            localName = head.text;
+          } else if (head && (head.type === "infix" || head.type === "prefix_id")) {
+            const op = this.findNamedChildByType(head, ["operator"])?.text;
+            if (op) {
+              localName = op;
+            } else {
+              const infixId = this.findNamedChildByType(head, ["infix_id"]);
+              const tv = infixId ? this.findNamedChildByType(infixId, ["variable"]) : void 0;
+              if (tv?.text) localName = tv.text;
+            }
+          }
+          const scopedLocal = ctx.localScopes.callableScoped.get(node.id) ?? localName;
+          ctx.currentFunction = scopedLocal;
+          scopeStack.push({
+            node,
+            name: scopedLocal ?? "local",
+            kind: ASTEngine.SymbolKind.Namespace,
+            locals: ctx.localScopes.frameLocals.get(node.id),
+            isFrame: true
+          });
+        } else {
+          stack.push({ node, isExit: true, restoreFn: ctx.currentFunction });
+          const head = node.namedChildCount > 0 ? node.namedChild(0) : null;
+          const scopedLocal = ctx.localScopes.callableScoped.get(node.id) ?? (head?.type === "variable" ? head.text : void 0);
+          if (scopedLocal !== void 0) {
+            ctx.currentFunction = scopedLocal;
+            scopeStack.push({
+              node,
+              name: scopedLocal,
+              kind: ASTEngine.SymbolKind.Namespace,
+              locals: ctx.localScopes.frameLocals.get(node.id),
+              isFrame: true
+            });
+          }
+        }
+      } else if (node.type === "let" || node.type === "local_binds" || node.type === "list_comprehension") {
+        const blockLocals = ctx.localScopes.blockLocals.get(node.id);
+        if (blockLocals && this.isForwardVisibleLocalBlock(node)) {
+          for (let i = scopeStack.length - 1; i >= 0; i--) {
+            if (scopeStack[i].isFrame) {
+              const fm = scopeStack[i].locals ?? /* @__PURE__ */ new Map();
+              for (const [k, v] of blockLocals) fm.set(k, v);
+              scopeStack[i].locals = fm;
+              break;
+            }
+          }
+        }
+        scopeStack.push({ node, name: "local", kind: ASTEngine.SymbolKind.Namespace, locals: blockLocals });
+        pushedScope = true;
+      } else if (node.type === "class") {
+        pushedScope = this.processClass(node, ctx, scopeStack);
+      } else if (node.type === "instance") {
+        pushedScope = this.processInstance(node, ctx, scopeStack);
+      } else if (node.type === "data_type" || node.type === "newtype") {
+        pushedScope = this.processData(node, ctx, scopeStack);
+      } else if (node.type === "type_synomym") {
+        pushedScope = this.processTypeSynonym(node, ctx, scopeStack);
+      } else if (node.type === "pattern_synonym") {
+        pushedScope = this.processPatternSynonym(node, ctx);
+      } else if (node.type === "foreign_import") {
+        pushedScope = this.processForeignImport(node, ctx, scopeStack);
+      } else if (node.type === "deriving_instance") {
+        const grab = (nn) => {
+          let cls;
+          let clsNode = null;
+          let target;
+          for (let i = 0; i < nn.namedChildCount; i++) {
+            const c = nn.namedChild(i);
+            if (!c) continue;
+            if (c.type === "name" || c.type === "qualified") {
+              cls = c.text;
+              clsNode = c;
+            } else if (c.type === "apply") {
+              const h = c.namedChildCount > 0 ? c.namedChild(0) : null;
+              if (h?.text) {
+                cls = h.text;
+                clsNode = h;
+              }
+            } else if (c.type === "type_patterns") {
+              const t2 = this.findNamedChildByType(c, ["name", "constructor"]);
+              target = t2?.text;
+            } else if (c.type === "parens") grab(c);
+          }
+          if (cls && target) {
+            this.pushRel(
+              ctx,
+              target,
+              cls,
+              ASTEngine.RelationshipType.Implements,
+              1,
+              {
+                derived: true,
+                isStandaloneDeriving: true
+              },
+              this.lineOf(clsNode)
+            );
+          }
+        };
+        grab(node);
+      } else if (node.type === "record") {
+        const ctor = this.findNamedChildByType(node, ["constructor"]);
+        if (ctor?.text && ctx.currentFunction && !this.isDataDeclarationPosition(node) && !this.isPatternPosition(node)) {
+          this.pushRel(
+            ctx,
+            ctx.currentFunction,
+            ctor.text,
+            ASTEngine.RelationshipType.Instantiates,
+            0.9,
+            {
+              haskellSpecific: true,
+              isRecordConstruction: true
+            },
+            this.lineOf(ctor)
+          );
+        }
+      } else if (node.type === "apply") {
+        this.extractApplyCall(node, ctx, scopeStack);
+      } else if (node.type === "infix") {
+        this.processInfix(node, ctx, scopeStack);
+      } else if (node.type === "prefix_id") {
+        this.emitOperatorApplication(node, ctx, scopeStack);
+      } else if (node.type === "top_splice") {
+        this.decorateFromSplice(node, ctx);
+      } else if (node.type === "pragma") {
+        this.countPragmas(node, ctx);
+      } else if (node.type === "cpp") {
+        this.processCppDirective(node, ctx);
+      }
+      if (pushedScope) stack.push({ node, isExit: true });
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push({ node: child });
+      }
+    }
+    const frameworks = [];
+    for (const f in ctx.frameworks) frameworks.push(f);
+    const patterns = [];
+    for (const p in ctx.patterns) patterns.push(p);
+    const frameworkPatterns = [];
+    for (let i = 0; i < frameworks.length; i++) {
+      frameworkPatterns.push({
+        framework: frameworks[i],
+        patterns: [{ type: "usage", detected: true, description: `${frameworks[i]} usage detected` }]
+      });
+    }
+    if (!ctx.symbols.some((s) => s.kind === ASTEngine.SymbolKind.Module)) {
+      ctx.symbols.push({
+        name: "Main",
+        kind: ASTEngine.SymbolKind.Module,
+        range: this.nodeToRange(rootNode),
+        scope: "",
+        ownerName: "",
+        visibility: "public",
+        metadata: { haskellSpecific: true, isImplicitMain: true }
+      });
+      for (const s of ctx.symbols) {
+        if (s.kind !== ASTEngine.SymbolKind.Module && !s.ownerName && !s.scope) s.ownerName = "Main";
+      }
+    }
+    const declaredHere = /* @__PURE__ */ new Set();
+    for (const s of ctx.symbols) {
+      if (s.ownerName && s.ownerName !== ctx.currentModule) continue;
+      if (s.kind === ASTEngine.SymbolKind.Class || s.kind === ASTEngine.SymbolKind.Type || // `TypeAlias` is a legacy ALIAS for `type` -- both members carry the value
+      // "type" (see SymbolKind in engine.ts) -- so comparing it here tested the
+      // same value twice. TypeScript collapses same-valued enum members, which is
+      // what made this comparison an error rather than a redundancy.
+      s.kind === ASTEngine.SymbolKind.Interface || s.kind === ASTEngine.SymbolKind.Enum) declaredHere.add(s.name);
+    }
+    for (const s of ctx.symbols) {
+      const _owner = s.ownerName || (s.scope && s.scope !== ctx.currentModule ? s.scope : void 0);
+      if (_owner && _owner !== ctx.currentModule && s.kind === ASTEngine.SymbolKind.Method && !declaredHere.has(_owner)) continue;
+      if (_owner && _owner !== s.name && s.kind !== ASTEngine.SymbolKind.Instance) {
+        this.pushRel(ctx, _owner, s.name, ASTEngine.RelationshipType.Contains, 1, {}, s.range?.startLine);
+      }
+    }
+    if (ctx.exports.length === 0) {
+      for (const s of ctx.symbols) {
+        if (s.ownerName === ctx.currentModule || !s.ownerName && !s.scope) {
+          ctx.exports.push({ name: s.name, kind: s.kind, range: s.range, visibility: "public" });
+        }
+      }
+    }
+    const localIdentities = /* @__PURE__ */ new Set();
+    for (const block of ctx.localScopes.blockLocals.values()) {
+      for (const identity of block.values()) localIdentities.add(identity);
+    }
+    if (localIdentities.size > 0) {
+      for (const rel of ctx.relationships) {
+        const target = rel.target ?? "";
+        if (!localIdentities.has(target)) continue;
+        rel.target = `${rel.source ?? ""}${BINDING_SEP}${target}`;
+        rel.metadata = { ...rel.metadata ?? {}, localBinding: true };
+      }
+    }
+    this.classifyEvidenceTier(ctx.relationships);
+    return {
+      language: "haskell",
+      symbols: ctx.symbols,
+      relationships: ctx.relationships,
+      imports: ctx.imports,
+      exports: ctx.exports,
+      errors: ctx.errors,
+      metadata: {
+        complexity: cyclomaticComplexity,
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity,
+        framework: frameworks[0],
+        patterns,
+        detectedFrameworks: frameworks,
+        frameworkPatterns,
+        architecturalScore: Math.min(100, Math.max(0, 100 - ctx.errors.length * 5)),
+        codeQuality: ctx.errors.length === 0 ? "Excellent" : "Fair",
+        hasTypeInference: true,
+        hasFrameworkIntelligence: true,
+        analysisVersion: "10.1.0-haskell-pure-ast",
+        // The passive-metadata pragma class, disclosed as a count. `{-# ANN #-}`
+        // attaches a value to a target and applies no callable, so it emits no
+        // relationship; the number is here so the omission is a stated class and
+        // not a silence a reader has to interpret.
+        ...ctx.annPragmas > 0 ? { annPragmaSites: ctx.annPragmas } : {}
+      }
+    };
+  }
+  // ==========================================================================
+  // Relationship emission (dedupe by source|type|target identity).
+  // ==========================================================================
+  // M59.A7 / formula §8 (dimension 8) — the site line, the clean/erlang
+  // contract verbatim:
+  //   * the line is part of the DEDUPE KEY: a function called from three lines
+  //     is three edges at three lines, not one edge at whichever line the walk
+  //     saw first (the store keys its rows the same way, parallel-indexer.ts);
+  //   * the anchor is the NAME-BEARING node — the callee head for a call, the
+  //     constructed name for an `instantiates`, the class name for
+  //     `implements`/`extends`, the imported module name for `references`, and
+  //     the child's OWN naming line for `contains` (#921: it is what resolves
+  //     the intended target among same-named siblings);
+  //   * a line that is not a positive integer is recorded as ABSENT, never as 0
+  //     (M59.O2: the contract is "the site line or NULL" — a fabricated 0 reads
+  //     as "line 0" to every reader downstream).
+  pushRel(ctx, source, target, type, confidence, metadata = {}, line) {
+    const hasLine = typeof line === "number" && Number.isInteger(line) && line > 0;
+    const key = `${source}|${type}|${target}|${hasLine ? line : ""}`;
+    if (ctx.seenRels.has(key)) return;
+    ctx.seenRels.add(key);
+    ctx.relationships.push({
+      source,
+      target,
+      type,
+      confidence,
+      // HSA1 — the claim rides every row this writer publishes, so a new emission site cannot
+      // silently drop it (see `bareExternalClaim`).
+      metadata: { ...metadata, ...this.bareExternalClaim(ctx, type, target) },
+      ...hasLine ? { line_number: line } : {}
+    });
+  }
+  /**
+   * HSA1 — A DEPENDENCY THE FILE DOES NOT DECLARE IS A CLAIM, NOT SILENCE.
+   *
+   * The lane's wall after its declaration wave was 60,898 ambiguous/unresolved of 193,418 edges, and
+   * the two largest classes are the two dependencies Haskell spells as a BARE CAPITALISED NAME:
+   *
+   *   `instance Show Foo where …`      the class `Show` lives in `base`, not in this project
+   *   `Just x`, `Left e`, `Right v`    the constructors are the language's own
+   *
+   * MEASURED over the whole admitted population (3,702 files / 6 repos): `implements` 11,563
+   * unresolved, led by `Show` 2,459 / `Eq` 1,899 / `Generic` 1,404 / `Ord` 703 / `ToJSON` 662 /
+   * `FromJSON` 641 / `NFData` 530 / `Hashable` 327; and `instantiates` 10,978 unresolved, led by
+   * `Just` 3,657 / `Right` 1,017 / `Left` 617. None of those names can be declared by a corpus file
+   * that does not already declare it, so every row was a dependency published with NO reading at all.
+   *
+   * THE CLAIM IS THE FLEET'S `externalTarget`, and it is SAFE BY CONSTRUCTION rather than by care: the
+   * arbiter consults a claim only where the name model has NOTHING (`decls === 0`), so a name the
+   * project really does declare keeps its resolved/ambiguous answer and can never be refuted by this
+   * row. A REFUTATION requires `decls > 0` on an UNRESOLVED row, which this claim cannot reach.
+   *
+   * THREE REFUSALS, each because the spelling is not a bare declaration name:
+   *   · a QUALIFIED target (`Csv.ToNamedRecord`, `T.unpack`) — a module path, and the arbiter's own
+   *     `importPath` claim is the one that reads it; a second claim would be a different question.
+   *   · a target that is not capitalised — Haskell type and data constructors are upper-case, so a
+   *     lower-case name here is a parse artifact, not a type.
+   *   · a name THIS FILE declares — the row is a local dependency and must resolve, not claim.
+   */
+  bareExternalClaim(ctx, type, target) {
+    if (type === ASTEngine.RelationshipType.Exports && target.length > 0) {
+      if (target === ctx.currentModule) return {};
+      if (ctx.declaredTypes.has(target) || ctx.declaredFunctions.has(target)) return {};
+      const first2 = target.charCodeAt(0);
+      const firstOk = first2 >= 65 && first2 <= 90 || first2 >= 97 && first2 <= 122 || first2 === 95;
+      if (!firstOk) return {};
+      for (let i = 1; i < target.length; i++) {
+        const c = target.charCodeAt(i);
+        const ok = c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 95 || c === 39;
+        if (!ok) return {};
+      }
+      return { externalTarget: true, externalVia: "re-export" };
+    }
+    if (type === ASTEngine.RelationshipType.Calls) {
+      const dot = target.indexOf(".");
+      if (dot > 0) {
+        const mod = ctx.importAliases.get(target.slice(0, dot));
+        if (mod !== void 0 && mod.length > 0) {
+          return { externalTarget: true, externalReason: "module-namespace", externalSpecifier: mod };
+        }
+        return {};
+      }
+      return {};
+    }
+    if (type === ASTEngine.RelationshipType.Imports && target.length > 0) {
+      if (ctx.declaredTypes.has(target) || ctx.declaredFunctions.has(target)) return {};
+      return { externalTarget: true, externalReason: "module-namespace", externalSpecifier: target };
+    }
+    if (type === ASTEngine.RelationshipType.Implements) {
+      const dotI = target.indexOf(".");
+      if (dotI > 0) {
+        const mod = ctx.importAliases.get(target.slice(0, dotI));
+        if (mod !== void 0 && mod.length > 0) {
+          return { externalTarget: true, externalReason: "module-namespace", externalSpecifier: mod };
+        }
+        return {};
+      }
+    }
+    if (type === ASTEngine.RelationshipType.Uses) {
+      if (target.length === 0 || target.indexOf(".") >= 0) return {};
+      const firstU = target.charCodeAt(0);
+      if (!(firstU >= 65 && firstU <= 90)) return {};
+      for (let i = 1; i < target.length; i++) {
+        const c = target.charCodeAt(i);
+        const ok = c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 95 || c === 39;
+        if (!ok) return {};
+      }
+      if (ctx.declaredTypes.has(target) || ctx.declaredFunctions.has(target)) return {};
+      return { externalTarget: true, externalVia: "type" };
+    }
+    if (type === ASTEngine.RelationshipType.Instantiates) {
+      const dot = target.indexOf(".");
+      if (dot > 0) {
+        const mod = ctx.importAliases.get(target.slice(0, dot));
+        if (mod !== void 0 && mod.length > 0) {
+          return { externalTarget: true, externalReason: "module-namespace", externalSpecifier: mod };
+        }
+        return {};
+      }
+    }
+    if (type === ASTEngine.RelationshipType.Extends) {
+      if (target.length === 0 || target.indexOf(".") >= 0) return {};
+      const firstE = target.charCodeAt(0);
+      if (!(firstE >= 65 && firstE <= 90)) return {};
+      for (let i = 1; i < target.length; i++) {
+        const c = target.charCodeAt(i);
+        const ok = c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 95 || c === 39;
+        if (!ok) return {};
+      }
+      if (ctx.declaredTypes.has(target)) return {};
+      return { externalTarget: true, externalVia: "superclass" };
+    }
+    if (type !== ASTEngine.RelationshipType.Implements && type !== ASTEngine.RelationshipType.Instantiates) return {};
+    if (!target || target.length === 0) return {};
+    for (let i = 0; i < target.length; i++) {
+      const c = target.charCodeAt(i);
+      if (c === 46 || c === 58) return {};
+    }
+    const first = target.charCodeAt(0);
+    if (!(first >= 65 && first <= 90)) return {};
+    if (ctx.declaredTypes.has(target) || ctx.declaredFunctions.has(target) || ctx.declaredConstructors.has(target)) return {};
+    return {
+      externalTarget: true,
+      externalVia: type === ASTEngine.RelationshipType.Implements ? "instance-class" : "constructor"
+    };
+  }
+  /** 1-based line of a node, or undefined — never 0 (M59.O2). */
+  lineOf(node) {
+    if (!node) return void 0;
+    const line = node.startPosition.row + 1;
+    return line > 0 ? line : void 0;
+  }
+  // ==========================================================================
+  // Template Haskell: `decorates` from a declaration-position splice.
+  //
+  // WHY THIS IS `decorates` AND NOT A RULING. Template Haskell runs code at
+  // COMPILE TIME. `$(makeLenses ''Widget)` applies the function `makeLenses` to
+  // the named declaration `Widget` and the function GENERATES accessor
+  // declarations for it; the declaration therefore CARRIES the decorator in
+  // exactly the sense the vocabulary means (`decorates`: a decorator is applied
+  // to a declaration). The measured population has 420 declaration-position
+  // splices, 177 of which name a declaration this file declares.
+  //
+  // THE DISCRIMINATOR IS ON THE DECORATED DECLARATION, NEVER ON THE HEAD.
+  // TH decorators are LIBRARY functions — `makeLenses` is imported from
+  // `Control.Lens.TH`, `deriveJSON` from `Data.Aeson.TH` — exactly as Python's
+  // `@dataclass` is imported from `dataclasses`. Requiring the HEAD to be
+  // declared in the file would exclude the construct and publish nothing; the
+  // test that identifies the construct is the `th_quoted_name` argument naming a
+  // declaration of THIS file. Measured near misses that must therefore stay
+  // silent: a splice quoting an IMPORTED declaration (33 sites — the quoted
+  // name is declared in another module, so this file cannot source an edge from
+  // it), and a declaration-position splice with no callable head (77 sites —
+  // `$(do ... [d| ... |])` generators and C-preprocessor macro lines such as
+  // `INSTANCE_CLUMP_1(...)`, which the grammar parses as a bare top-level
+  // expression splice).
+  //
+  // THE EDGE, per the lane's brief: source is the ENCLOSING MODULE SCOPE and the
+  // target is the DECORATED DECLARATION's own symbol. The decorator name is
+  // often external and unresolvable, so it is carried in
+  // `metadata.decoratorName` rather than emitted as a dangling endpoint — an
+  // edge to a name nothing declares would be a claim the index cannot answer.
+  //
+  // `{-# ANN #-}` IS NOT THIS CONSTRUCT. It attaches a value to a target
+  // (`{-# ANN getEnvironment ("HLINT: ..." :: String) #-}`) and applies no
+  // callable, so it is the passive-metadata class and publishes no edge; its
+  // sites are counted in `metadata.annPragmaSites` so the class is disclosed
+  // rather than silently dropped.
+  // ==========================================================================
+  decorateFromSplice(node, ctx) {
+    ctx.patterns["Template Haskell"] = true;
+    let expr = node.namedChildCount > 0 ? node.namedChild(0) : null;
+    for (let guard = 0; guard < 6 && expr; guard++) {
+      if (expr.type === "splice" || expr.type === "parens") {
+        expr = expr.namedChildCount > 0 ? expr.namedChild(0) : null;
+        continue;
+      }
+      break;
+    }
+    if (!expr) return;
+    let head = expr;
+    let decoratorName;
+    let decoratorQualified = false;
+    for (let guard = 0; guard < 12 && head; guard++) {
+      if (head.type === "variable" || head.type === "name") {
+        decoratorName = head.text;
+        break;
+      }
+      if (head.type === "qualified") {
+        const mod = this.findNamedChildByType(head, ["module"]);
+        const v = this.findNamedChildByType(head, ["variable", "constructor"]);
+        const modText = this.stripTrailingDot(mod?.text ?? "");
+        decoratorName = modText && v?.text ? `${modText}.${v.text}` : head.text;
+        decoratorQualified = true;
+        break;
+      }
+      if (head.type === "apply") {
+        head = head.namedChildCount > 0 ? head.namedChild(0) : null;
+        continue;
+      }
+      break;
+    }
+    if (!decoratorName) return;
+    const quotes = this.thQuotedNames(expr);
+    let decorated;
+    for (const q of quotes) {
+      if (ctx.declaredTypes.has(q.name) || ctx.declaredFunctions.has(q.name)) {
+        decorated = q;
+        break;
+      }
+    }
+    if (!decorated) return;
+    const scope = ctx.currentModule || "Main";
+    this.pushRel(
+      ctx,
+      scope,
+      decorated.name,
+      ASTEngine.RelationshipType.Decorates,
+      1,
+      {
+        decoratorName,
+        isQualifiedDecorator: decoratorQualified,
+        thQuotedForm: decorated.raw,
+        isTemplateHaskell: true,
+        haskellSpecific: true
+      },
+      this.lineOf(node)
+    );
+  }
+  /**
+   * Every `th_quoted_name` under a subtree, with the quotes stripped.
+   *
+   * The grammar puts the quoted name in a `name` child (`''Foo` -> `''` token +
+   * `name` "Foo"); the raw text is kept so the edge's metadata can say which
+   * quote form was used. A quote with no readable name is skipped rather than
+   * published with its ticks — a name that is not a name is not an endpoint.
+   */
+  thQuotedNames(node) {
+    const out = [];
+    const visit = (n) => {
+      if (n.type === "th_quoted_name") {
+        const raw = n.text ?? "";
+        const nameNode = this.findNamedChildByType(n, ["name", "variable", "constructor"]);
+        const name = (nameNode?.text ?? "").trim();
+        if (name.length > 0) out.push({ name, raw });
+        return;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) visit(c);
+      }
+    };
+    visit(node);
+    return out;
+  }
+  /**
+   * Count the passive-metadata pragma family (`{-# ANN ... #-}`).
+   *
+   * The pragma node's body is OPAQUE to the grammar (the node carries no named
+   * children — measured over the whole population), so the keyword is read from
+   * the text between `{-#` and the first whitespace, with no regular
+   * expression: the analyzer's no-regex criterion forbids a pattern literal and
+   * a keyword test does not need one.
+   */
+  countPragmas(node, ctx) {
+    const text = (node.text ?? "").trim();
+    if (!text.startsWith("{-#")) return;
+    let i = 3;
+    while (i < text.length && (text[i] === " " || text[i] === "	")) i++;
+    const keyword = text.slice(i, i + 3).toUpperCase();
+    if (keyword === "ANN") ctx.annPragmas++;
+  }
+  // ==========================================================================
+  // `part_of` FROM A CPP `#include` — THE R3 EMISSION ON AN EXISTING NODE TYPE.
+  //
+  // WHY THIS IS `part_of` AND NOT AN `imports`. Haskell has no textual include
+  // of its own: `import Module` is a MODULE LOAD — it creates binding scope for
+  // the module's exports and can be resolved as `Module.item`, which is the
+  // OPPOSITE of a fragment. The ONE textual-inclusion construct a Haskell file
+  // can carry is the C preprocessor's `#include`, available under
+  // `{-# LANGUAGE CPP #-}`: the named file's text is spliced into this module
+  // BEFORE parsing, it shares this module's single scope, and it has no module
+  // identity at all. That is the contract's `part_of` verbatim ("a part shares
+  // the library's single scope, imports nothing, and cannot be resolved as a
+  // separate module"), and the fleet's implemented `part_of` set is unanimously
+  // textual file inclusion (cpp `#include`, fsharp `#load`, php include/require,
+  // erlang `-include`, typescript reference directives).
+  //
+  // RUNG WALKED: R1 and R2 are UNNECESSARY — `cpp` is already a NAMED node type
+  // of the SERVED grammar (253 named of 552 ids, digest 37a6b07b1a83; measured
+  // in validation/m14/measurements/haskell-grammar-nodes.json), so R3 is live
+  // and no grammar build or patch is needed.
+  //
+  // THE TARGET IS THE PART'S MODULE SYMBOL (its file STEM), NOT A PATH, and the
+  // written path is kept in `metadata.partPath`. The arbiter resolves TARGET
+  // STRINGS AGAINST SYMBOL NAMES and has no space for a path — the cpp lane
+  // measured that emitting paths gave 0 resolved of 4,612 rows — while the
+  // contract permits either ("the part's file OR ITS MODULE SYMBOL"). The stem
+  // is symbol-shaped, so it can bind when it names something.
+  //
+  // MEASURED over the whole admitted population (3,702 files): FOUR real
+  // directive sites, every one a quoted `#include "MachDeps.h"` (three Cabal
+  // Cmm test-suite files, one hasura-engine module), 0 non-literal. The SEVEN
+  // other `#include` strings in the corpus are NOT directives and emit nothing:
+  // a string-built line `["#include \"" ++ hdr ++ "\""]`, the `-#include` ghc
+  // FLAG as a string, a Haddock comment mentioning the flag, and a JSON
+  // quasiquote carrying the text. All four are pinned as negatives by the
+  // fixture. `MachDeps.h` is a GHC SYSTEM header, so its stem resolves to
+  // nothing in the admitted set — the system-header case the cpp lane handles,
+  // and it reads unresolved rather than wrong.
+  // ==========================================================================
+  processCppDirective(node, ctx) {
+    const include = this.readCppInclude(node.text ?? "");
+    if (!include) return;
+    ctx.patterns["CPP"] = true;
+    const scope = ctx.currentModule || "Main";
+    if (include.form === "quoted") {
+      this.pushRel(
+        ctx,
+        scope,
+        include.stem,
+        ASTEngine.RelationshipType.PartOf,
+        1,
+        {
+          // MANDATORY on every part_of row (src/ast/types.ts): "library" because
+          // THIS file is the library/unit and the directive names its part.
+          partRole: "library",
+          // The written path is EVIDENCE; the stem is the target. Keeping both
+          // is what makes the difference between them checkable.
+          partPath: include.specifier,
+          partSymbol: include.stem,
+          isQuotedInclude: true,
+          isCppDirective: true,
+          relationshipType: "part_of_directive",
+          haskellSpecific: true
+        },
+        this.lineOf(node)
+      );
+    } else {
+      this.pushRel(
+        ctx,
+        scope,
+        include.specifier,
+        ASTEngine.RelationshipType.Imports,
+        1,
+        {
+          isSystemInclude: true,
+          isCppDirective: true,
+          relationshipType: "include_dependency",
+          haskellSpecific: true
+        },
+        this.lineOf(node)
+      );
+    }
+  }
+  /**
+   * Read a `#include` directive's specifier from a `cpp` node's text.
+   *
+   * Returns undefined unless the directive's keyword is EXACTLY `include` and it
+   * names a quoted or angle specifier. `#if`, `#else`, `#endif` and a shebang
+   * share the `cpp` node type and name no file, so every one of them falls out
+   * here. PURE STRING SCAN — the analyzer's no-regex contract forbids a pattern
+   * literal, and a keyword test does not need one.
+   */
+  readCppInclude(text) {
+    const isSpace = (c) => c === " " || c === "	" || c === "\n" || c === "\r";
+    let i = 0;
+    while (i < text.length && isSpace(text[i])) i++;
+    if (i >= text.length || text[i] !== "#") return void 0;
+    i++;
+    while (i < text.length && (text[i] === " " || text[i] === "	")) i++;
+    const keyword = "include";
+    if (i + keyword.length > text.length) return void 0;
+    if (text.slice(i, i + keyword.length).toLowerCase() !== keyword) return void 0;
+    let j = i + keyword.length;
+    if (j < text.length && !(text[j] === " " || text[j] === "	" || text[j] === '"' || text[j] === "<")) return void 0;
+    while (j < text.length && (text[j] === " " || text[j] === "	")) j++;
+    if (j >= text.length) return void 0;
+    const open = text[j];
+    if (open === '"') {
+      const end = text.indexOf('"', j + 1);
+      if (end < 0) return void 0;
+      const specifier = text.slice(j + 1, end).trim();
+      if (specifier.length === 0) return void 0;
+      return { form: "quoted", specifier, stem: this.cppIncludeStem(specifier) };
+    }
+    if (open === "<") {
+      const end = text.indexOf(">", j + 1);
+      if (end < 0) return void 0;
+      const specifier = text.slice(j + 1, end).trim();
+      if (specifier.length === 0) return void 0;
+      return { form: "angle", specifier, stem: this.cppIncludeStem(specifier) };
+    }
+    return void 0;
+  }
+  /** A specifier's module stem: no directories, no extension (`util/Service.h` -> `Service`). */
+  cppIncludeStem(specifier) {
+    const slash = specifier.lastIndexOf("/");
+    let base = slash >= 0 ? specifier.slice(slash + 1) : specifier;
+    const backslash = base.lastIndexOf("\\");
+    if (backslash >= 0) base = base.slice(backslash + 1);
+    const dot = base.lastIndexOf(".");
+    return (dot > 0 ? base.slice(0, dot) : base).trim();
+  }
+  // ==========================================================================
+  // Pre-pass: declared TYPE names at module scope (forward-reference resolution
+  // for TH quotes). A `data`/`newtype`/`type`/`class`/`pattern` declaration is
+  // the thing a Template Haskell decorator is applied to, and the splice may
+  // appear before or after it in source order.
+  // ==========================================================================
+  collectDeclaredTypes(node, out) {
+    const t = node.type;
+    if (t === "data_type" || t === "newtype" || t === "type_synomym" || t === "class" || t === "pattern_synonym") {
+      const nameNode = this.findNamedChildByType(node, ["name"]);
+      if (nameNode?.text) out.add(nameNode.text);
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child) continue;
+      if (child.type === "local_binds" || child.type === "let" || child.type === "let_in") continue;
+      this.collectDeclaredTypes(child, out);
+    }
+  }
+  /**
+   * HSA1 — the DATA CONSTRUCTORS this module declares, for the external-claim guard only.
+   *
+   * The walk is deliberately generous: every `constructor` under a `data_type`/`newtype` is
+   * collected, field types included (`data T = C Int` also collects `Int`). Over-collecting can only
+   * WITHHOLD a claim, and a withheld claim leaves the row where it was — the safe direction. Missing
+   * one would publish a false statement about the module's own declaration, which is what the fixture
+   * caught.
+   */
+  collectDeclaredConstructors(node, out) {
+    if (node.type === "data_type" || node.type === "newtype") {
+      const grab = (n) => {
+        if (n.type === "constructor" && n.text) out.add(n.text);
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) grab(c);
+        }
+      };
+      grab(node);
+      return;
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child) continue;
+      if (child.type === "local_binds" || child.type === "let" || child.type === "let_in") continue;
+      this.collectDeclaredConstructors(child, out);
+    }
+  }
+  // ==========================================================================
+  // Pre-pass: declared function/method names (forward-reference resolution).
+  // ==========================================================================
+  // class -> its method names. This is what makes `overrides` derivable at all:
+  // an instance declares a method name, and the only way to know that name
+  // OVERRIDES rather than merely exists is to compare it against the class
+  // body's method set. A single walk cannot do that — the instance may be
+  // visited before the class, and in the payloads/cabal corpus it frequently is
+  // — so the class side is gathered first and the instance side is compared
+  // against it when the instance is reached.
+  collectClassMethods(node, out) {
+    if (node.type === "class") {
+      const clsName = this.findNamedChildByType(node, ["name"])?.text ?? "";
+      if (clsName) {
+        let set = out.get(clsName);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          out.set(clsName, set);
+        }
+        const decls = this.findNamedChildByType(node, ["class_declarations"]);
+        const groups = decls ? [decls] : [];
+        for (const g of groups) {
+          for (const sig of this.collectNamedChildrenByType(g, ["signature"])) {
+            const v = this.findNamedChildByType(sig, ["variable"]);
+            if (v?.text) set.add(v.text);
+          }
+          for (const fn of this.collectNamedChildrenByType(g, ["function", "bind"])) {
+            const first = fn.namedChildCount > 0 ? fn.namedChild(0) : null;
+            if (first?.type === "variable" && first.text) set.add(first.text);
+          }
+        }
+      }
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c) this.collectClassMethods(c, out);
+    }
+  }
+  collectDeclaredFunctions(node, out) {
+    if (node.type === "function" && (node.childForFieldName("parameter") || node.childForFieldName("result"))) {
+      return;
+    }
+    if (node.type === "function" || node.type === "bind") {
+      if (!(node.type === "bind" && this.hasChildOfType(node, "<-"))) {
+        const nameNode = node.namedChildCount > 0 ? node.namedChild(0) : null;
+        if (nameNode && nameNode.type === "variable") {
+          out.add(nameNode.text);
+        } else if (nameNode && (nameNode.type === "infix" || nameNode.type === "prefix_id")) {
+          const op = this.findNamedChildByType(nameNode, ["operator"]);
+          const tv = op ? void 0 : (() => {
+            const infixId = this.findNamedChildByType(nameNode, ["infix_id"]);
+            return infixId ? this.findNamedChildByType(infixId, ["variable"]) : void 0;
+          })();
+          const callable = op?.text ?? tv?.text;
+          if (callable) out.add(callable);
+        }
+      }
+    }
+    if (node.type === "signature") {
+      if (node.parent?.type === "parens") return;
+      const first = node.namedChildCount > 0 ? node.namedChild(0) : null;
+      if (first?.type !== "variable") return;
+      out.add(first.text);
+      return;
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child) continue;
+      if (child.type === "local_binds" || child.type === "let" || child.type === "let_in") continue;
+      this.collectDeclaredFunctions(child, out);
+    }
+  }
+  // ==========================================================================
+  // Pre-pass: lexical local identity (M60 functional lane, 2026-09-26).
+  // A callable declared inside a where/let block is a real callable but NOT
+  // a module symbol (HSD6/HSD19 contract, unchanged). Its identity carries
+  // its lexical owner chain: `outer.local` (nested: `outer.inner.local`), so
+  // it can never be confused with a module-level callable of the same name.
+  // ==========================================================================
+  collectLocalScopes(root, out) {
+    const stack = [
+      { n: root, frameId: -1, frameScoped: void 0 }
+    ];
+    while (stack.length > 0) {
+      const { n, frameId, frameScoped } = stack.pop();
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const child = n.namedChild(i);
+        if (!child) continue;
+        const t = child.type;
+        if (t === "local_binds" || t === "let" || t === "let_in") {
+          const binders = this.localBlockBinders(child);
+          if (binders.length > 0) {
+            const map = /* @__PURE__ */ new Map();
+            for (const b of binders) {
+              const nm2 = this.callableHeadName(b);
+              if (!nm2) continue;
+              const scoped = frameScoped !== void 0 ? `${frameScoped}.${nm2}` : nm2;
+              map.set(nm2, scoped);
+              out.callableScoped.set(b.id, scoped);
+            }
+            if (map.size > 0) {
+              out.blockLocals.set(child.id, map);
+              if (t === "local_binds" && frameId >= 0) {
+                const fm = out.frameLocals.get(frameId) ?? /* @__PURE__ */ new Map();
+                for (const [k, v] of map) fm.set(k, v);
+                out.frameLocals.set(frameId, fm);
+              }
+            }
+          }
+          for (let j = 0; j < child.namedChildCount; j++) {
+            const c = child.namedChild(j);
+            if (!c) continue;
+            const scoped = out.callableScoped.get(c.id);
+            if (scoped !== void 0 && this.callableHeadName(c) !== void 0) {
+              stack.push({ n: c, frameId: c.id, frameScoped: scoped });
+            } else {
+              stack.push({ n: c, frameId, frameScoped });
+            }
+          }
+          continue;
+        }
+        const nm = this.callableHeadName(child);
+        if (nm !== void 0) {
+          const scoped = frameScoped !== void 0 ? `${frameScoped}.${nm}` : nm;
+          out.callableScoped.set(child.id, scoped);
+          stack.push({ n: child, frameId: child.id, frameScoped: scoped });
+        } else {
+          stack.push({ n: child, frameId, frameScoped });
+        }
+      }
+    }
+  }
+  /** Direct callable children of a where/let block (the local binders). */
+  localBlockBinders(block) {
+    const out = [];
+    for (let i = 0; i < block.namedChildCount; i++) {
+      const c = block.namedChild(i);
+      if (!c || c.type !== "function" && c.type !== "bind") continue;
+      if (this.callableHeadName(c) === void 0) continue;
+      out.push(c);
+    }
+    return out;
+  }
+  /**
+   * The declared name of a callable node, or undefined when the node is not a
+   * callable at all (type-position function, do-bind, pattern-headed bind).
+   * Mirrors collectDeclaredFunctions' naming rules exactly — one ruler for
+   * module-level and local callables.
+   */
+  callableHeadName(node) {
+    if (node.type !== "function" && node.type !== "bind") return void 0;
+    if (node.type === "function" && (node.childForFieldName("parameter") || node.childForFieldName("result"))) {
+      return void 0;
+    }
+    if (node.type === "bind" && this.hasChildOfType(node, "<-")) return void 0;
+    const head = node.namedChildCount > 0 ? node.namedChild(0) : null;
+    if (!head) return void 0;
+    if (head.type === "variable") return head.text;
+    if (head.type === "infix" || head.type === "prefix_id") {
+      const op = this.findNamedChildByType(head, ["operator"]);
+      if (op?.text) return op.text;
+      const infixId = this.findNamedChildByType(head, ["infix_id"]);
+      const tv = infixId ? this.findNamedChildByType(infixId, ["variable"]) : void 0;
+      return tv?.text;
+    }
+    return void 0;
+  }
+  /**
+   * A do-block `let` (`do { let g = ...; ... g x }`): its binders stay visible
+   * for the REST of the do block — subsequent statements are siblings, not
+   * descendants, so the block scope alone cannot carry them. Folded into the
+   * nearest callable frame as the walk reaches the block (source order).
+   */
+  isForwardVisibleLocalBlock(node) {
+    if (node.type !== "local_binds") return false;
+    const p = node.parent;
+    return p?.type === "let" && p.parent?.type === "do";
+  }
+  /**
+   * Resolve a bare variable head to its callable target: the innermost
+   * visible local wins (Haskell scoping — a where-binder shadows the module
+   * binding for its whole RHS), else the module-level declared set, else no
+   * edge (imported/Prelude/parameter names produce none).
+   */
+  resolveCallableTarget(name, scopeStack, ctx) {
+    for (let i = scopeStack.length - 1; i >= 0; i--) {
+      const locals = scopeStack[i].locals;
+      if (locals !== void 0) {
+        const hit = locals.get(name);
+        if (hit !== void 0) return hit;
+      }
+    }
+    return ctx.declaredFunctions.has(name) ? name : void 0;
+  }
+  processModule(node, ctx, scopeStack) {
+    let moduleName = "";
+    const moduleNode = this.findNamedChildByType(node, ["module"]);
+    if (moduleNode) {
+      moduleName = this.assembleModuleId(moduleNode);
+    } else {
+      const mIdx = this.findChildIndexByText(node, "module");
+      if (mIdx !== -1 && node.childCount > mIdx + 1) {
+        moduleName = node.child(mIdx + 1)?.text || "";
+      }
+    }
+    if (!moduleName) return false;
+    ctx.currentModule = moduleName;
+    const exportsList = this.findNamedChildByType(node, ["exports"]);
+    if (exportsList) {
+      for (let i = 0; i < exportsList.namedChildCount; i++) {
+        const expNode = exportsList.namedChild(i);
+        if (!expNode) continue;
+        let exportName;
+        let isReExport = false;
+        let anchor = expNode;
+        if (expNode.type === "export") {
+          const read = this.readExportName(expNode, exportsList, i);
+          exportName = read.name;
+          if (read.anchor) anchor = read.anchor;
+        } else if (expNode.type === "module_export") {
+          const mod = this.findNamedChildByType(expNode, ["module", "module_id"]);
+          exportName = mod ? this.assembleModuleId(mod) : void 0;
+          isReExport = exportName !== void 0;
+        } else {
+          continue;
+        }
+        if (exportName && exportName !== ",") {
+          ctx.exports.push({ name: exportName, isDefault: false, range: this.nodeToRange(expNode) });
+          this.pushRel(
+            ctx,
+            moduleName,
+            exportName,
+            ASTEngine.RelationshipType.Exports,
+            1,
+            { evidenceClass: "structural", ...isReExport ? { isReExport: true } : {} },
+            this.lineOf(anchor)
+          );
+        }
+      }
+    }
+    ctx.symbols.push({
+      name: moduleName,
+      kind: ASTEngine.SymbolKind.Module,
+      range: this.nodeToRange(node),
+      scope: "",
+      visibility: "public",
+      metadata: { haskellSpecific: true }
+    });
+    scopeStack.push({ node, name: moduleName, kind: ASTEngine.SymbolKind.Module });
+    return true;
+  }
+  /**
+   * THE NAME an `export` node exports, or undefined when it exports none.
+   *
+   * WHY THIS IS NOT `expNode.text`. The export list states a name with a
+   * DECLARATION KEYWORD in front of it whenever the entry narrows what is
+   * exported, and the raw text is the whole phrase:
+   *
+   *     export -> namespace("type") + name("T")        text "type T"
+   *     export -> namespace("pattern") + name("P")     text "pattern P"
+   *     export -> name("U") + children("(..)")         text "U(..)"
+   *     export -> variable("data")   + ERROR("D")      text "data"   (a mis-parse)
+   *
+   * Measured over the whole corpus before this method existed (analyzer pass,
+   * `script/m14/tmp/hs-ontology-analyse.ts`): 392 of 54,830 `exports` edges
+   * carried a target that was a keyword or a keyword phrase — 100 `type`,
+   * 32 `data`, 8 `pattern`, and the rest `pattern <Ctor>` / `type <Ty>`.
+   * `exports Data.Type.Bool -> type` names the Haskell keyword: it resolves to
+   * nothing, and `T(A, B)`-style narrowing means the thing the module actually
+   * exports is `T`, not `T(A, B)`.
+   *
+   * Tree shapes, counted on the pinned grammar over all 14,066 admitted files
+   * (`script/m14/tmp/hs-export-ffi-probe.ts`): 31,892 `export` nodes —
+   * 6,697 with a `name`/`constructor` child, 24,515 a bare `variable`, 43 a bare
+   * declaration keyword whose real name the grammar pushed into a SIBLING `ERROR`
+   * (37 of the 43 recoverable that way), and 0 unclassified.
+   *
+   * The 6 unrecoverable ones emit NOTHING. Under standing rule R7 the honest
+   * state for "I cannot read this name" is absence, not a keyword standing in for
+   * a name — a literal in a name-bearing field becomes an edge endpoint that does
+   * not exist in the source, and `bb_graph` will happily count and display it.
+   */
+  readExportName(expNode, exportsList, index) {
+    const named = this.findNamedChildByType(expNode, ["name", "constructor"]);
+    if (named?.text) return { name: named.text, anchor: named };
+    const opId = this.findNamedChildByType(expNode, ["prefix_id", "infix_id"]);
+    if (opId) {
+      const op = this.findNamedChildByType(opId, ["operator", "constructor_operator"]);
+      if (op?.text) return { name: op.text, anchor: op };
+      const innerVar = this.findNamedChildByType(opId, ["variable"]);
+      if (innerVar?.text) return { name: innerVar.text, anchor: innerVar };
+    }
+    const variable = this.findNamedChildByType(expNode, ["variable"]);
+    if (variable?.text) {
+      if (!HASKELL_DECLARATION_KEYWORDS.has(variable.text)) return { name: variable.text, anchor: variable };
+      for (let j = index + 1; j < exportsList.namedChildCount; j++) {
+        const nx = exportsList.namedChild(j);
+        if (!nx) continue;
+        if (nx.type === "export" || nx.type === "module_export") break;
+        if (nx.type === "ERROR") {
+          const rec = this.findNamedChildByType(nx, ["name", "constructor"]);
+          if (rec?.text) return { name: rec.text, anchor: rec };
+        }
+      }
+      return { name: void 0 };
+    }
+    const text = expNode.text.trim();
+    if (!text) return { name: void 0 };
+    const paren = text.indexOf("(");
+    return { name: paren >= 0 ? text.slice(0, paren).trim() : text, anchor: expNode };
+  }
+  // module_id children compose dotted names: Data → List → "Data.List"
+  assembleModuleId(node) {
+    let out = "";
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      const leaf = c.type === "module_id" ? this.assembleModuleId(c) : c.text;
+      if (out) out += ".";
+      out += leaf;
+    }
+    return out || node.text;
+  }
+  processImport(node, ctx) {
+    let isQualified = false;
+    const items = [];
+    const modulesToImport = [];
+    let currentIsHiding = this.findChildIndexByText(node, "hiding") !== -1;
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === "qualified") {
+        isQualified = true;
+      } else if (child.type === "module" || child.type === "module_id") {
+        const name = this.assembleModuleId(child);
+        if (i > 0 && node.child(i - 1)?.text.trim() === "as") {
+          const lastMod = modulesToImport[modulesToImport.length - 1];
+          if (lastMod) lastMod.alias = name;
+        } else {
+          modulesToImport.push({ name, isHiding: currentIsHiding, node: child });
+        }
+      } else if (child.type === "hiding") {
+        currentIsHiding = true;
+      } else if (child.type === "import_list") {
+        for (let j = 0; j < child.namedChildCount; j++) {
+          const item = child.namedChild(j);
+          if (item && item.type !== "hiding") {
+            const itemText = this.stripOuterParens(item.text.trim());
+            if (itemText && itemText !== "hiding" && itemText !== ",") {
+              const paren = itemText.indexOf("(");
+              items.push(paren >= 0 ? itemText.slice(0, paren).trim() : itemText);
+            }
+          }
+        }
+      }
+    }
+    for (const mod of modulesToImport) {
+      if (!mod.name) continue;
+      const importItems = [];
+      if (items.length > 0) {
+        for (const item of items) importItems.push(item);
+      } else {
+        importItems.push("*");
+      }
+      if (mod.alias && mod.alias.length > 0) ctx.importAliases.set(mod.alias, mod.name);
+      const own = mod.name.indexOf(".") < 0 ? mod.name : mod.name.slice(mod.name.lastIndexOf(".") + 1);
+      if (own.length > 0 && !ctx.importAliases.has(own)) ctx.importAliases.set(own, mod.name);
+      ctx.imports.push({
+        module: mod.name,
+        source: mod.name,
+        items: importItems,
+        isTypeOnly: false,
+        range: this.nodeToRange(node),
+        metadata: { isQualified, alias: mod.alias, isHiding: mod.isHiding }
+      });
+      this.pushRel(
+        ctx,
+        ctx.currentModule || "",
+        mod.name,
+        ASTEngine.RelationshipType.Imports,
+        0.9,
+        {
+          isHaskellImport: true
+        },
+        this.lineOf(mod.node)
+      );
+      if (mod.name.indexOf("Scotty") !== -1) ctx.frameworks["Scotty"] = true;
+      if (mod.name.indexOf("Servant") !== -1) ctx.frameworks["Servant"] = true;
+      if (mod.name.indexOf("QuickCheck") !== -1) ctx.frameworks["QuickCheck"] = true;
+      if (mod.name.indexOf("Database.Persist") !== -1) ctx.frameworks["Persistent"] = true;
+      if (mod.name.indexOf("Yesod") !== -1) ctx.frameworks["Yesod"] = true;
+    }
+  }
+  processSignature(node, ctx, currentScope, inLocalBlock = false) {
+    const nameNode = this.findNamedChildByType(node, ["variable"]);
+    if (nameNode && !inLocalBlock) {
+      const idx = node.text.indexOf("::");
+      if (idx !== -1) {
+        ctx.typeSignatures[nameNode.text] = node.text.slice(idx + 2).trim();
+      }
+    }
+    if (nameNode && currentScope && (currentScope.kind === ASTEngine.SymbolKind.Interface || currentScope.kind === ASTEngine.SymbolKind.Class)) {
+      const methodKey = `${currentScope.name}::${nameNode.text}`;
+      const existingIdx = ctx.functionSymbolIndex[methodKey];
+      if (existingIdx === void 0) {
+        ctx.functionSymbolIndex[methodKey] = ctx.symbols.length;
+        ctx.symbols.push({
+          name: nameNode.text,
+          kind: ASTEngine.SymbolKind.Method,
+          range: this.nodeToRange(node),
+          scope: currentScope.name || "",
+          ownerName: currentScope.name,
+          ownerKind: currentScope.kind,
+          visibility: "public",
+          metadata: { haskellSpecific: true, isInterfaceMethod: true }
+        });
+      }
+    }
+  }
+  processFunction(node, ctx, currentScope, scopeStack) {
+    if (node.type === "function" && (node.childForFieldName("parameter") || node.childForFieldName("result"))) {
+      return false;
+    }
+    let name = "";
+    const nameNode = node.namedChildCount > 0 ? node.namedChild(0) : null;
+    if (nameNode && nameNode.type === "variable") {
+      name = nameNode.text;
+    } else if (nameNode && (nameNode.type === "infix" || nameNode.type === "prefix_id")) {
+      const op = this.findNamedChildByType(nameNode, ["operator"]);
+      if (op?.text) {
+        name = op.text;
+      } else {
+        const infixId = this.findNamedChildByType(nameNode, ["infix_id"]);
+        const tv = infixId ? this.findNamedChildByType(infixId, ["variable"]) : void 0;
+        if (tv?.text) name = tv.text;
+      }
+    }
+    if (!name || name === "=" || name === "|" || node.parent?.type === "signature" || node.parent?.type === "function") {
+      return false;
+    }
+    const functionKey = `${currentScope?.name || ""}::${name}`;
+    const existingIndex = ctx.functionSymbolIndex[functionKey];
+    const existing = existingIndex !== void 0 ? ctx.symbols[existingIndex] : void 0;
+    if (existing) {
+      const newRange = this.nodeToRange(node);
+      existing.range.endLine = Math.max(existing.range.endLine, newRange.endLine);
+      if (existing.range.endIndex !== void 0 && newRange.endIndex !== void 0) {
+        existing.range.endIndex = Math.max(existing.range.endIndex, newRange.endIndex);
+      } else if (newRange.endIndex !== void 0) {
+        existing.range.endIndex = newRange.endIndex;
+      }
+      if (existing.complexity !== void 0) {
+        existing.complexity = Math.max(existing.complexity, this.calculateNodeComplexity(node));
+      }
+      ctx.currentFunction = name;
+      scopeStack.push({
+        node,
+        name,
+        kind: existing.kind,
+        locals: ctx.localScopes.frameLocals.get(node.id),
+        isFrame: true
+      });
+      return true;
+    }
+    const typeSignature = ctx.typeSignatures[name];
+    let isHigherOrder = false;
+    let returnType = void 0;
+    if (typeSignature && typeof typeSignature === "string") {
+      isHigherOrder = this.hasArrowInParens(typeSignature);
+      const parts = this.splitOnArrows(typeSignature);
+      if (parts.length > 0) returnType = parts[parts.length - 1].trim();
+    }
+    if (isHigherOrder) ctx.patterns["Higher-Order Functions"] = true;
+    const kind = currentScope && (currentScope.kind === ASTEngine.SymbolKind.Interface || currentScope.kind === ASTEngine.SymbolKind.Class) ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Function;
+    ctx.symbols.push({
+      name,
+      kind,
+      range: this.nodeToRange(node),
+      scope: currentScope?.name || "",
+      ownerName: currentScope?.name || ctx.currentModule,
+      ownerKind: currentScope?.kind,
+      visibility: "public",
+      returnType,
+      complexity: this.calculateNodeComplexity(node),
+      metadata: { typeSignature, isHigherOrder, haskellSpecific: true }
+    });
+    ctx.functionSymbolIndex[functionKey] = ctx.symbols.length - 1;
+    ctx.currentFunction = name;
+    scopeStack.push({ node, name, kind, locals: ctx.localScopes.frameLocals.get(node.id), isFrame: true });
+    return true;
+  }
+  // A type synonym is a first-class declaration — `type Result = [Int64]` names
+  // a type that other code can annotate with, so omitting it left every use of
+  // the name with nothing to resolve to. The grammar's node is spelled
+  // `type_synomym` (the upstream typo is in the node NAME, not this comment), and
+  // its shape is `name` + right-hand side, so the name is the first `name` child.
+  processTypeSynonym(node, ctx, scopeStack) {
+    ctx.patterns["Type Synonyms"] = true;
+    const nameNode = this.findNamedChildByType(node, ["name"]);
+    const name = nameNode?.text ?? "";
+    if (!name) return false;
+    const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+    ctx.symbols.push({
+      name,
+      kind: ASTEngine.SymbolKind.Type,
+      range: this.nodeToRange(node),
+      scope: currentScope?.name || "",
+      ownerName: currentScope?.name || ctx.currentModule,
+      visibility: "public",
+      metadata: { haskellSpecific: true, isTypeSynonym: true }
+    });
+    if (currentScope) {
+      this.pushRel(
+        ctx,
+        currentScope.name,
+        name,
+        ASTEngine.RelationshipType.Contains,
+        1,
+        { evidenceClass: "structural" },
+        this.lineOf(node)
+      );
+    }
+    if (nameNode) {
+      for (const leaf of this.collectTypeNameLeafNodes(node, nameNode)) {
+        if (leaf.text.trim() === name) continue;
+        this.pushRel(
+          ctx,
+          name,
+          leaf.text.trim(),
+          ASTEngine.RelationshipType.Uses,
+          1,
+          { evidenceClass: "declared_type" },
+          this.lineOf(leaf)
+        );
+      }
+    }
+    return true;
+  }
+  // Type-name leaves reachable in a subtree, skipping the subtree rooted at
+  // `skip`, returned as NODES so a caller can cite each one's own line.
+  // Haskell type expressions nest arbitrarily (`Map.Map ByteString ByteString`
+  // is apply → qualified(name) + name), so this walks rather than reading one
+  // level, and it takes `name` and `constructor` only: a `variable` in a type
+  // position is a type PARAMETER (`f a`), not a type, and publishing `a` as a
+  // use of some type named `a` is exactly the fabrication the declared-type
+  // contract forbids.
+  collectTypeNameLeafNodes(node, skip, out = []) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c || skip !== null && c.id === skip.id) continue;
+      if (c.type === "name" || c.type === "constructor") {
+        if (c.text.trim() && !out.some((o) => o.text === c.text)) out.push(c);
+        continue;
+      }
+      this.collectTypeNameLeafNodes(c, null, out);
+    }
+    return out;
+  }
+  // A pattern synonym is a first-class top-level DECLARATION — `pattern Head a b =
+  // expr` names a constructor-shaped value the module defines, so omitting it left
+  // every use of the name with nothing to resolve to, exactly as omitting a type
+  // synonym did. It is not exotic: GHC's own sources carry 1,094 of them across
+  // 261 files (`script/m14/tmp/hs-pattern-synonyms.ts`, all 14,038 admitted files),
+  // and 94 export entries name one, so those `exports` edges had a target nothing
+  // declared. Found by the `haskell/exports-and-ffi` fixture, which the M14 runner
+  // refused with `export(s) [":|"] do not resolve to a top-level symbol`.
+  //
+  // MEASURED shape distribution over those 1,094 nodes: 449 carry a readable name
+  // (421 a `signature` child, 28 a bare `equation`), and 645 are VIEW PATTERNS
+  // (`pattern P x <- Q x where P x = Q x`) whose name the previous reader could not
+  // reach at all. The name is ALWAYS the head of the equation's left-hand side, so
+  // one rule covers every shape:
+  //
+  //   pattern_synonym -> pattern + signature -> prefix_id -> constructor_operator   (`:|`)
+  //   pattern_synonym -> pattern + signature -> constructor                       (`Zero`)
+  //   pattern_synonym -> pattern + equation  -> apply(apply(constructor, x), y)    (`OptMResult`)
+  //   pattern_synonym -> pattern + equation  -> apply -> constructor              (a view pattern)
+  //   pattern_synonym -> pattern + equation  -> infix -> constructor_operator      (`:|`)
+  //
+  // The symbol kind is `constructor`, not `function`: a pattern synonym is built
+  // and matched like a data constructor (`instantiates` already targets it through
+  // the `apply`-head rule), and calling it a function would put a name the module
+  // never defines into the FP-family `calls` set.
+  processPatternSynonym(node, ctx) {
+    ctx.patterns["Pattern Synonyms"] = true;
+    const sig = this.findNamedChildByType(node, ["signature"]);
+    const eq = this.findNamedChildByType(node, ["equation"]);
+    let name;
+    let anchor;
+    if (sig) {
+      const head = this.findNamedChildByType(sig, ["prefix_id", "infix_id", "constructor", "constructor_operator", "variable"]);
+      if (head) {
+        name = head.type === "prefix_id" || head.type === "infix_id" ? this.findNamedChildByType(head, ["constructor_operator", "operator", "constructor", "variable"])?.text : head.text;
+        anchor = head;
+      }
+    }
+    if (!name && eq) {
+      for (let i = 0; i < eq.namedChildCount; i++) {
+        const c = eq.namedChild(i);
+        if (!c) continue;
+        if (c.type === "constructor" && c.text) {
+          name = c.text;
+          anchor = c;
+          break;
+        }
+        if (c.type === "infix") {
+          const op = this.findNamedChildByType(c, ["constructor_operator", "operator"]);
+          if (op?.text) {
+            name = op.text;
+            anchor = op;
+            break;
+          }
+          continue;
+        }
+        if (c.type === "apply") {
+          const head = this.haskellAppliedHeadName(c);
+          if (head) {
+            name = head;
+            anchor = this.findAppliedHeadNode(c) ?? c;
+            break;
+          }
+        }
+      }
+    }
+    if (!name || !anchor) return false;
+    return this.publishPatternSynonym(name, node, anchor, ctx);
+  }
+  publishPatternSynonym(name, declNode, anchor, ctx) {
+    if (!name || name === " ") return false;
+    const key = `${ctx.currentModule ?? ""}::${name}`;
+    const existingIdx = ctx.functionSymbolIndex[key];
+    if (existingIdx !== void 0) {
+      const existing = ctx.symbols[existingIdx];
+      if (existing) {
+        const declRange = this.nodeToRange(declNode);
+        existing.range.endLine = Math.max(existing.range.endLine, declRange.endLine);
+        if (existing.range.endIndex !== void 0 && declRange.endIndex !== void 0) {
+          existing.range.endIndex = Math.max(existing.range.endIndex, declRange.endIndex);
+        }
+      }
+      return true;
+    }
+    const range = this.nodeToRange(declNode);
+    range.startLine = anchor.startPosition.row + 1;
+    range.startColumn = anchor.startPosition.column + 1;
+    ctx.symbols.push({
+      name,
+      kind: ASTEngine.SymbolKind.Constructor,
+      range,
+      scope: ctx.currentModule ?? "",
+      ownerName: ctx.currentModule,
+      ownerKind: ASTEngine.SymbolKind.Type,
+      visibility: "public",
+      metadata: { haskellSpecific: true, isPatternSynonym: true }
+    });
+    ctx.functionSymbolIndex[key] = ctx.symbols.length - 1;
+    return true;
+  }
+  /** The node carrying the head name of an applied type/expression spine. */
+  findAppliedHeadNode(node) {
+    let cur = node;
+    let guard = 0;
+    while (cur && guard++ < 64) {
+      if (cur.type === "apply" || cur.type === "parens" || cur.type === "strict") {
+        cur = cur.namedChildCount > 0 ? cur.namedChild(0) : null;
+        continue;
+      }
+      break;
+    }
+    return cur;
+  }
+  // FFI declarations. `foreign import capi "libpq-fe.h PQresultStatus"`
+  // parses as foreign_import → calling_convention, entity (the C symbol),
+  // signature → variable (the HASKELL name) → function (its type). Nothing in
+  // the tree above the module carried the Haskell-side binding, so a file whose
+  // entire content is FFI published one symbol: the module. postgrest's
+  // `Hasql/LibPq14/Ffi.hs` is exactly that file — 6 declarations, 0 published.
+  // The Haskell name is `signature → variable`; the C entity is kept as metadata
+  // and as a `references` edge, because that string is how a reader finds the
+  // symbol in the C headers and nothing else in the graph points at it.
+  processForeignImport(node, ctx, scopeStack) {
+    ctx.patterns["Foreign Imports"] = true;
+    const sig = this.findNamedChildByType(node, ["signature"]);
+    const varNode = sig ? this.findNamedChildByType(sig, ["variable"]) : null;
+    const name = varNode?.text ?? "";
+    if (!name) return false;
+    const convention = this.findNamedChildByType(node, ["calling_convention"])?.text ?? "";
+    const entity = this.foreignEntityName(this.readForeignEntity(node) ?? "", convention);
+    const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+    ctx.symbols.push({
+      name,
+      kind: ASTEngine.SymbolKind.Function,
+      range: this.nodeToRange(node),
+      scope: currentScope?.name || "",
+      ownerName: currentScope?.name || ctx.currentModule,
+      visibility: "public",
+      metadata: {
+        haskellSpecific: true,
+        isForeignImport: true,
+        ...entity ? { foreignEntity: entity } : {},
+        ...convention ? { callingConvention: convention } : {}
+      }
+    });
+    const owner = currentScope?.name || ctx.currentModule;
+    if (owner) {
+      this.pushRel(
+        ctx,
+        owner,
+        name,
+        ASTEngine.RelationshipType.Contains,
+        1,
+        // The entity travels with the edge as well as the symbol: the cited line
+        // is the `foreign import` line, which spells the C name
+        // (`WaitForSingleObject`) while the Haskell binding adds an underscore
+        // (`waitForSingleObject_`). A consumer — or a gate — checking that the
+        // target name appears at the cited line has to be able to find the
+        // spelling that IS there.
+        { evidenceClass: "structural", isForeignImport: true, ...entity ? { foreignEntity: entity } : {} },
+        this.lineOf(node)
+      );
+      if (entity) {
+        this.pushRel(
+          ctx,
+          name,
+          entity,
+          ASTEngine.RelationshipType.References,
+          0.9,
+          { evidenceClass: "foreign_symbol", isForeignEntity: true },
+          this.lineOf(node)
+        );
+      }
+    }
+    return true;
+  }
+  processData(node, ctx, scopeStack) {
+    ctx.patterns["Algebraic Data Types"] = true;
+    let name = "";
+    const nameNode = this.findNamedChildByType(node, ["name"]);
+    if (nameNode) name = nameNode.text;
+    else {
+      const dataIdx = this.findChildIndexByText(node, ["data", "newtype"]);
+      if (dataIdx !== -1 && node.childCount > dataIdx + 1) {
+        name = node.child(dataIdx + 1)?.text || "";
+      }
+    }
+    if (!name) return false;
+    const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+    const typeRange = this.nodeToRange(node);
+    if (nameNode) {
+      typeRange.startLine = nameNode.startPosition.row + 1;
+      typeRange.startColumn = nameNode.startPosition.column;
+    }
+    ctx.symbols.push({
+      name,
+      kind: ASTEngine.SymbolKind.Type,
+      range: typeRange,
+      scope: currentScope?.name || "",
+      ownerName: currentScope?.name || ctx.currentModule,
+      visibility: "public",
+      metadata: { haskellSpecific: true, isData: node.type === "data_type" }
+    });
+    const ctorNodes = [];
+    for (const group of ["data_constructors", "gadt_constructors"]) {
+      const g = this.findNamedChildByType(node, [group]);
+      if (!g) continue;
+      for (const c of this.collectNamedChildrenByType(g, ["data_constructor", "gadt_constructor"])) {
+        if (!ctorNodes.includes(c)) ctorNodes.push(c);
+      }
+    }
+    for (const c of this.collectNamedChildrenByType(node, ["newtype_constructor", "data_constructor", "gadt_constructor"])) {
+      if (!ctorNodes.includes(c)) ctorNodes.push(c);
+    }
+    for (const cNode of ctorNodes) {
+      const cName = this.extractConstructorName(cNode);
+      if (cName) {
+        ctx.symbols.push({
+          name: cName,
+          kind: ASTEngine.SymbolKind.Constructor,
+          range: this.nodeToRange(cNode),
+          scope: name,
+          ownerName: name,
+          ownerKind: ASTEngine.SymbolKind.Type,
+          visibility: "public",
+          metadata: { isDataConstructor: true }
+        });
+      }
+      const recordNode = this.findNamedChildByType(cNode, ["record"]);
+      if (recordNode) {
+        const fields = this.collectFields(recordNode);
+        for (const field of fields) {
+          const fNameNode = this.findNamedChildByType(field, ["field_name"]);
+          const varNode = fNameNode ? fNameNode.namedChild(0) : null;
+          if (varNode?.text) {
+            ctx.symbols.push({
+              name: varNode.text,
+              kind: ASTEngine.SymbolKind.Property,
+              range: this.nodeToRange(field),
+              scope: name,
+              ownerName: name,
+              ownerKind: ASTEngine.SymbolKind.Type,
+              visibility: "public",
+              metadata: { haskellSpecific: true, isRecordField: true }
+            });
+          }
+        }
+      }
+    }
+    const deriving = this.findNamedChildByType(node, ["deriving", "deriving_strategy"]);
+    if (deriving) {
+      const derived = [];
+      const derivedNodes = [];
+      const grab = (nn) => {
+        for (let i = 0; i < nn.namedChildCount; i++) {
+          const c = nn.namedChild(i);
+          if (!c) continue;
+          if (c.type === "name") {
+            derived.push(c.text);
+            derivedNodes.push(c);
+          } else if (c.type === "qualified") {
+            derived.push(c.text);
+            derivedNodes.push(c);
+          } else if (c.type === "apply") {
+            const h = c.namedChildCount > 0 ? c.namedChild(0) : null;
+            if (h?.text) {
+              derived.push(h.text);
+              derivedNodes.push(h);
+            }
+          } else if (c.type === "parens") grab(c);
+        }
+      };
+      const tuple = this.findNamedChildByType(deriving, ["tuple"]);
+      if (tuple) grab(tuple);
+      grab(deriving);
+      for (let i = 0; i < derived.length; i++) {
+        this.pushRel(
+          ctx,
+          name,
+          derived[i],
+          ASTEngine.RelationshipType.Implements,
+          1,
+          { derived: true },
+          this.lineOf(derivedNodes[i])
+        );
+      }
+    }
+    scopeStack.push({ node, name, kind: ASTEngine.SymbolKind.Type });
+    return true;
+  }
+  // data_constructor → prefix → constructor "Node" | record → constructor "Rect"
+  extractConstructorName(node) {
+    const prefix = this.findNamedChildByType(node, ["prefix"]);
+    if (prefix) {
+      const con = this.findNamedChildByType(prefix, ["constructor", "name"]);
+      if (con?.text) return con.text;
+    }
+    const record = this.findNamedChildByType(node, ["record"]);
+    if (record) {
+      const con = this.findNamedChildByType(record, ["constructor"]);
+      if (con?.text) return con.text;
+    }
+    const direct = this.findNamedChildByType(node, ["constructor", "name"]);
+    if (direct?.text) return direct.text;
+    return void 0;
+  }
+  processClass(node, ctx, scopeStack) {
+    ctx.patterns["Type Classes"] = true;
+    let name = "";
+    const nameNode = this.findNamedChildByType(node, ["name"]);
+    if (nameNode) name = nameNode.text;
+    else {
+      const classIdx = this.findChildIndexByText(node, "class");
+      if (classIdx !== -1 && node.childCount > classIdx + 1) {
+        name = node.child(classIdx + 1)?.text || "";
+      }
+    }
+    if (!name) return false;
+    const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+    const context = this.findNamedChildByType(node, ["context"]);
+    if (context) {
+      const superNames = /* @__PURE__ */ new Set();
+      const superNodes = /* @__PURE__ */ new Map();
+      const stack = [context];
+      while (stack.length > 0) {
+        const x = stack.pop();
+        if (x.type === "apply") {
+          let head = x;
+          while (head && head.type === "apply") head = head.namedChildren[0] ?? null;
+          if (head && (head.type === "name" || head.type === "constructor" || head.type === "qualified")) {
+            superNames.add(head.text);
+            if (!superNodes.has(head.text)) superNodes.set(head.text, head);
+          }
+        }
+        for (const c of x.namedChildren) if (c) stack.push(c);
+      }
+      for (const sn of superNames) {
+        if (sn === name) continue;
+        this.pushRel(
+          ctx,
+          name,
+          sn,
+          ASTEngine.RelationshipType.Extends,
+          1,
+          { isSuperclass: true },
+          this.lineOf(superNodes.get(sn))
+        );
+      }
+    }
+    const classRange = this.nodeToRange(node);
+    if (nameNode) {
+      classRange.startLine = nameNode.startPosition.row + 1;
+      classRange.startColumn = nameNode.startPosition.column;
+    }
+    ctx.symbols.push({
+      name,
+      kind: ASTEngine.SymbolKind.Interface,
+      range: classRange,
+      scope: currentScope?.name || "",
+      ownerName: currentScope?.name || ctx.currentModule,
+      visibility: "public",
+      metadata: { haskellSpecific: true }
+    });
+    scopeStack.push({ node, name, kind: ASTEngine.SymbolKind.Interface });
+    return true;
+  }
+  /**
+   * M60 (#924, haskell E half): the TYPE NAME at the head of an applied type.
+   *
+   * An instance declaration such as  instance GArbitrary (M1 i c f)  declares an
+   * implementation FOR the type M1 i c f, whose name is its head type constructor
+   * M1; the published symbol was the whole application (M1 i c), i.e. a payload
+   * where a name belongs — measured as 2 distinct strings over 6 occurrences on the
+   * census's own haskell samples (script/m14/tmp/c924-name-surface-probe.ts). Walks
+   * the APPLICATION SPINE (apply / parens / strict) to the leftmost leaf and returns
+   * its text verbatim (a qualified head keeps its dots). The class head already
+   * takes this same left-spine descent; only the instance TARGET did not.
+   */
+  haskellAppliedHeadName(node) {
+    let cur = node;
+    let guard = 0;
+    while (cur && guard++ < 64) {
+      if (cur.type === "apply" || cur.type === "parens" || cur.type === "strict") {
+        cur = cur.namedChildCount > 0 ? cur.namedChild(0) : null;
+        continue;
+      }
+      break;
+    }
+    return cur?.text || void 0;
+  }
+  processInstance(node, ctx, scopeStack) {
+    let className = "";
+    let targetType = "";
+    let targetNode = null;
+    const classNode = this.findNamedChildByType(node, ["name"]);
+    const tpNode = this.findNamedChildByType(node, ["type_patterns"]);
+    if (classNode?.text) className = classNode.text;
+    if (tpNode) {
+      const direct = this.findNamedChildByType(tpNode, ["name", "constructor"]);
+      if (direct?.text) {
+        targetType = direct.text;
+        targetNode = direct;
+      } else {
+        const list = this.findNamedChildByType(tpNode, ["list"]);
+        if (list) {
+          targetType = "[]";
+        } else {
+          const parens = this.findNamedChildByType(tpNode, ["parens"]);
+          if (parens) {
+            const ap = this.findNamedChildByType(parens, ["apply"]);
+            const first = ap?.namedChildCount ? ap.namedChild(0) : null;
+            if (first) {
+              targetType = this.haskellAppliedHeadName(first) ?? first.text;
+              const head = first.namedChildren.find((c) => c.type === "name" || c.type === "constructor");
+              targetNode = head ?? first;
+            }
+          } else {
+            const firstPattern = tpNode.namedChildCount > 0 ? tpNode.namedChild(0) : null;
+            if (firstPattern?.type === "qualified" && firstPattern.text) {
+              targetType = firstPattern.text;
+              targetNode = firstPattern;
+            }
+          }
+        }
+      }
+    }
+    if (!className || !targetType) {
+      const named = [];
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && (c.type === "name" || c.type === "constructor")) {
+          named.push(c.text);
+        }
+      }
+      if (!className && named.length >= 1) className = named[0];
+      if (!targetType && named.length >= 2) targetType = named[1];
+    }
+    const name = targetType || className;
+    if (!name || name === " ") return false;
+    const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+    const instRange = this.nodeToRange(node);
+    if (targetNode) {
+      instRange.startLine = targetNode.startPosition.row + 1;
+      instRange.startColumn = targetNode.startPosition.column;
+    }
+    ctx.symbols.push({
+      name,
+      // An INSTANCE, not a class. It is named after the type it instantiates,
+      // and `contains` is derived from symbol ownership, so publishing it as
+      // a Class asserted this module DECLARES that type. The scope pushed for
+      // the body below stays Class on purpose -- method resolution reads it.
+      kind: ASTEngine.SymbolKind.Instance,
+      range: instRange,
+      scope: currentScope?.name || "",
+      ownerName: currentScope?.name || ctx.currentModule,
+      visibility: "public",
+      metadata: { haskellSpecific: true, className, targetType }
+    });
+    if (className && targetType) {
+      this.pushRel(
+        ctx,
+        targetType,
+        className,
+        ASTEngine.RelationshipType.Implements,
+        1,
+        { isInstance: true },
+        this.lineOf(classNode)
+      );
+    }
+    const classM = ctx.classMethods.get(className);
+    if (classM && classM.size > 0 && targetType) {
+      const decls = this.findNamedChildByType(node, ["instance_declarations"]);
+      const bodies = [];
+      if (decls) {
+        for (const d of this.collectNamedChildrenByType(decls, ["function", "bind"])) bodies.push(d);
+      }
+      for (const d of this.collectNamedChildrenByType(node, ["function", "bind"])) {
+        if (!bodies.includes(d)) bodies.push(d);
+      }
+      for (const b of bodies) {
+        const mName = b.namedChildCount > 0 ? b.namedChild(0)?.text : void 0;
+        if (!mName || !classM.has(mName)) continue;
+        this.pushRel(
+          ctx,
+          `${targetType}.${mName}`,
+          `${className}.${mName}`,
+          ASTEngine.RelationshipType.Override,
+          1,
+          { isInstanceMethod: true, evidenceClass: "structural" },
+          this.lineOf(b)
+        );
+      }
+    }
+    scopeStack.push({ node, name: className || name, kind: ASTEngine.SymbolKind.Class });
+    return true;
+  }
+  // ==========================================================================
+  // Call extraction — apply nodes in body position.
+  // ==========================================================================
+  extractApplyCall(node, ctx, scopeStack) {
+    const head = node.namedChildCount > 0 ? node.namedChild(0) : null;
+    if (!head) return;
+    const fn = ctx.currentFunction;
+    if (!fn) return;
+    if (head.type === "constructor" || head.type === "prefix") {
+      if (this.isPatternPosition(node)) return;
+      this.pushRel(
+        ctx,
+        fn,
+        head.text,
+        ASTEngine.RelationshipType.Instantiates,
+        0.9,
+        {
+          haskellSpecific: true,
+          isConstructorApplication: true
+        },
+        this.lineOf(head)
+      );
+      return;
+    }
+    if (head.type === "qualified") {
+      const mod = this.findNamedChildByType(head, ["module"]);
+      const modText = mod ? this.stripTrailingDot(mod.text) : "";
+      const ctor = this.findNamedChildByType(head, ["constructor"]);
+      if (modText && ctor?.text) {
+        if (!this.isPatternPosition(node)) {
+          this.pushRel(
+            ctx,
+            fn,
+            `${modText}.${ctor.text}`,
+            ASTEngine.RelationshipType.Instantiates,
+            0.9,
+            {
+              haskellSpecific: true,
+              isQualifiedConstructorApplication: true
+            },
+            this.lineOf(head)
+          );
+        }
+        return;
+      }
+      const func = this.findNamedChildByType(head, ["variable"]);
+      if (modText && func?.text) {
+        this.pushRel(
+          ctx,
+          fn,
+          `${modText}.${func.text}`,
+          ASTEngine.RelationshipType.Calls,
+          0.9,
+          {
+            haskellSpecific: true,
+            isQualifiedCall: true
+          },
+          this.lineOf(head)
+        );
+      }
+      return;
+    }
+    if (head.type === "variable") {
+      const target = this.resolveCallableTarget(head.text, scopeStack, ctx);
+      if (target !== void 0) {
+        this.pushRel(
+          ctx,
+          fn,
+          target,
+          ASTEngine.RelationshipType.Calls,
+          0.9,
+          {
+            haskellSpecific: true,
+            context: "local function call"
+          },
+          this.lineOf(head)
+        );
+      }
+    }
+  }
+  isPatternPosition(node) {
+    let cur = node.parent;
+    let prev = node;
+    while (cur) {
+      if (cur.type === "patterns") return true;
+      if (cur.type === "alternative") return true;
+      if (cur.type === "pattern_guard") {
+        if (prev && prev.id === cur.namedChild(0)?.id) return true;
+      } else if (cur.type === "match" || cur.type === "do" || cur.type === "class" || cur.type === "instance") {
+        return false;
+      } else if (cur.type === "function" || cur.type === "bind") {
+        if (prev.type === "match" || prev.type === "patterns") return false;
+        if (prev.id === cur.namedChild(0)?.id) return true;
+        return false;
+      }
+      prev = cur;
+      cur = cur.parent;
+    }
+    return false;
+  }
+  // =========================================================================
+  // Infix handling: backtick calls, $ application, and pattern marking.
+  // HSD1/HSD2 (probe 2026-09-03): infix_id is a backtick call (`x `elem2` xs`);
+  // operator "$" is function application — Haskell's most common idiom. Both
+  // were previously dropped entirely.
+  // =========================================================================
+  processInfix(node, ctx, scopeStack) {
+    const opNode = this.findNamedChildByType(node, ["operator"]);
+    const infixId = this.findNamedChildByType(node, ["infix_id"]);
+    if (infixId) {
+      const tickedCtor = this.findNamedChildByType(infixId, ["constructor"]);
+      if (tickedCtor?.text) {
+        const fnC = ctx.currentFunction;
+        if (fnC && !this.isPatternPosition(node) && !this.isTypePosition(node)) {
+          this.pushRel(
+            ctx,
+            fnC,
+            tickedCtor.text,
+            ASTEngine.RelationshipType.Instantiates,
+            0.9,
+            {
+              haskellSpecific: true,
+              isTickedConstructorApplication: true
+            },
+            this.lineOf(tickedCtor)
+          );
+        }
+        return;
+      }
+      if (this.isPatternPosition(node)) return;
+      const fn = ctx.currentFunction;
+      const target = this.findNamedChildByType(infixId, ["variable"]);
+      const resolved = target?.text !== void 0 ? this.resolveCallableTarget(target.text, scopeStack, ctx) : void 0;
+      if (fn && resolved !== void 0) {
+        this.pushRel(
+          ctx,
+          fn,
+          resolved,
+          ASTEngine.RelationshipType.Calls,
+          0.9,
+          {
+            haskellSpecific: true,
+            context: "backtick infix call"
+          },
+          this.lineOf(target)
+        );
+      }
+    } else if (opNode?.text === "$") {
+      const fn = ctx.currentFunction;
+      if (fn) {
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const c = node.namedChild(i);
+          if (!c || c.type === "operator") continue;
+          const resolved = c.type === "variable" ? this.resolveCallableTarget(c.text, scopeStack, ctx) : void 0;
+          if (resolved !== void 0) {
+            this.pushRel(
+              ctx,
+              fn,
+              resolved,
+              ASTEngine.RelationshipType.Calls,
+              0.9,
+              {
+                haskellSpecific: true,
+                context: "$ application"
+              },
+              this.lineOf(c)
+            );
+          } else if (c.type === "qualified") {
+            const mod = this.findNamedChildByType(c, ["module"]);
+            const func = this.findNamedChildByType(c, ["variable"]);
+            const modText = mod ? this.stripTrailingDot(mod.text) : "";
+            if (modText && func?.text) {
+              this.pushRel(
+                ctx,
+                fn,
+                `${modText}.${func.text}`,
+                ASTEngine.RelationshipType.Calls,
+                0.9,
+                {
+                  haskellSpecific: true,
+                  isQualifiedCall: true,
+                  context: "$ application"
+                },
+                this.lineOf(c)
+              );
+            }
+          }
+          break;
+        }
+      }
+    } else {
+      this.emitOperatorApplication(node, ctx, scopeStack);
+    }
+    const op = opNode?.text ?? "";
+    if (op === ">>=" || op === ">>" || op === "<-") ctx.patterns["Monads"] = true;
+    if (op === "<$>" || op === "<*>") ctx.patterns["Functors and Applicatives"] = true;
+    if (op === "|>") ctx.patterns["Pipe Operator"] = true;
+  }
+  // ==========================================================================
+  // VERIFY_HS9 — operator and infix-constructor APPLICATION (G1 + G2).
+  //
+  // What was missing, measured (script/m14/tmp/hs9-opshape-probe.ts, 60-file
+  // GHC draw, all counts AST-side):
+  //
+  //   EXP/infix:operator            3,140   of which 86 name an operator THIS
+  //                                         file declares as a callable
+  //   EXP/infix:constructor_operator   111   an infix DATA-CONSTRUCTOR
+  //                                         application (`a :+: b`) — a
+  //                                         construction, emitted as nothing
+  //   EXP/infix_id:constructor          9   a ticked constructor (`x `Cons` y`)
+  //   EXP/prefix_id:operator           22   `(<+>) a b`, a prefix application
+  //   EXP/prefix_id:constructor_operator 3   `(:+:) a b`
+  //   TYP/infix:operator               29   TYPE-level operator — must emit
+  //                                         nothing, and the node type alone
+  //                                         cannot tell it from an expression
+  //   PAT/infix:constructor_operator   98   pattern — must emit nothing
+  //
+  // WHY THE POSITION TEST IS NOT OPTIONAL: `infix` is ONE node type for THREE
+  // syntactic positions in the pinned grammar. _exp_infix (grammar/exp.js:353),
+  // _pat_infix (grammar/pat.js:99) and _type_infix (grammar/type.js:116) are all
+  // aliased to `infix`, and all three use the field names left_operand /
+  // operator / right_operand. A type-level operator is a bare `operator` node,
+  // exactly like an expression's — the 29 TYP rows above are sites that an
+  // operator-only test would have turned into 29 fabricated calls.
+  //
+  // WHY NAME RESOLUTION IS RIGHT AND NOT A GUESS: Haskell resolves an
+  // unqualified name lexically, and a module's own top-level declaration — or
+  // class method — SHADOWS the implicit Prelude import. So in a module that
+  // declares `==`, `x == y` IS that module's `==`; the alternative would be an
+  // ambiguous-occurrence error. This is the same rule resolveCallableTarget
+  // already applies to plain variables, extended to operators.
+  //
+  // WHY SECTIONS ARE NOT EMITTED: `(x +)` is a PARTIAL application — it builds
+  // a function value, it performs no call. `(<+>) a b` is a full application
+  // and is emitted. The line is full-application vs partial, and it is stated
+  // here rather than left to a reader of the code.
+  // ==========================================================================
+  emitOperatorApplication(node, ctx, scopeStack) {
+    const fn = ctx.currentFunction;
+    if (!fn) return;
+    if (this.isPatternPosition(node) || this.isTypePosition(node)) return;
+    const opField = node.childForFieldName("operator");
+    const head = opField ?? (node.namedChildCount > 0 ? node.namedChild(0) : null);
+    if (!head) return;
+    if (head.type === "constructor_operator") {
+      this.pushRel(
+        ctx,
+        fn,
+        head.text,
+        ASTEngine.RelationshipType.Instantiates,
+        0.9,
+        {
+          haskellSpecific: true,
+          isInfixConstructorApplication: true
+        },
+        this.lineOf(head)
+      );
+      return;
+    }
+    if (head.type !== "operator") return;
+    if (head.text === "$") return;
+    const resolved = this.resolveCallableTarget(head.text, scopeStack, ctx);
+    if (resolved === void 0) return;
+    this.pushRel(
+      ctx,
+      fn,
+      resolved,
+      ASTEngine.RelationshipType.Calls,
+      0.9,
+      {
+        haskellSpecific: true,
+        context: "operator application"
+      },
+      this.lineOf(head)
+    );
+  }
+  /**
+   * VERIFY_HS9: is this node part of a TYPE rather than an expression?
+   *
+   * Needed because `infix` covers expression, pattern AND type position in the
+   * pinned grammar (see emitOperatorApplication). The list is the grammar's own
+   * type-bearing vocabulary; the loop stops at an expression-bearing node so a
+   * `type` buried inside a body does not capture expression operators above it.
+   * Measured 29 type-level `infix:operator` sites on a 60-file draw, so this
+   * test is load-bearing rather than defensive.
+   */
+  isTypePosition(node) {
+    let cur = node.parent;
+    let guard = 0;
+    while (cur && guard++ < 256) {
+      if (HASKELL_TYPE_BEARING_NODES.has(cur.type)) return true;
+      if (cur.type === "match" || cur.type === "do" || cur.type === "bind" || cur.type === "let_in" || cur.type === "lambda" || cur.type === "record" || cur.type === "guard") {
+        return false;
+      }
+      cur = cur.parent;
+    }
+    return false;
+  }
+  /**
+   * Per-symbol cyclomatic complexity (family contract: python #270 / ruby
+   * #269 / php #268). Haskell decision points per the analyzer's own
+   * module-level counter: case, conditional (if), guards.
+   */
+  calculateNodeComplexity(node) {
+    if (!node) return 1;
+    let complexity = 1;
+    const stack = [node];
+    let guard = 0;
+    while (stack.length > 0 && guard++ < 2e5) {
+      const n = stack.pop();
+      if (n.type === "case" || n.type === "conditional" || n.type === "guards") complexity++;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return complexity;
+  }
+  /**
+   * Evidence-tier classification — same rules as the python/ruby/php family
+   * (M14 section D requires >=2 distinct evidenceClass values).
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ??= {};
+      if (md.evidenceClass) continue;
+      const t = r.type;
+      const conf = r.confidence ?? 0;
+      if (t === "contains" || t === "exports") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "imports") {
+        md.evidenceClass = md.isHaskellImport ? "import_based" : "structural";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = md.isHaskellImport ? "import_based" : "reference_qualified";
+        continue;
+      }
+      if (t === "extends" || t === "implements") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "overrides") {
+        md.evidenceClass = md.isInstanceMethod ? "structural" : md.evidenceClass ?? "structural";
+        continue;
+      }
+      if (t === "decorates") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "part_of") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "instantiates") {
+        md.evidenceClass = md.isRecordConstruction || md.isConstructorApplication || md.isQualifiedConstructorApplication || md.isInfixConstructorApplication || md.isTickedConstructorApplication ? "usage_contextual" : "structural";
+        continue;
+      }
+      md.evidenceClass = conf >= 0.85 ? "usage_contextual" : "inferred";
+    }
+  }
+  // Data-DECLARATION records live inside data_constructors; body-position
+  // records sit under a match/do/bind. Walk up: crossing a match/bind/do
+  // before any data_constructor means body position.
+  isDataDeclarationPosition(node) {
+    let cur = node.parent;
+    while (cur) {
+      if (cur.type === "match" || cur.type === "do" || cur.type === "bind" || cur.type === "let_in") return false;
+      if (cur.type === "data_constructor" || cur.type === "newtype_constructor") return true;
+      cur = cur.parent;
+    }
+    return false;
+  }
+  // ==========================================================================
+  // Pure-string helpers (no regex).
+  // ==========================================================================
+  stripOuterParens(text) {
+    let start = 0;
+    let end = text.length;
+    while (start < end && text[start] === "(") start++;
+    while (end > start && text[end - 1] === ")") end--;
+    return text.slice(start, end);
+  }
+  stripTrailingDot(text) {
+    return text.length > 0 && text[text.length - 1] === "." ? text.slice(0, -1) : text;
+  }
+  /**
+   * The C entity a `foreign_import` binds, or undefined when the declaration
+   * names none.
+   *
+   * The Haskell 2010 FFI grammar is `foreign import [cc] [safety] import
+   * [stringliteral] (entity | variadic)`: the string literal is the OPTIONAL
+   * HEADER and the entity is the name that follows it. The pinned grammar models
+   * both as `entity` children, so `foreign import capi "libwidget.h"
+   * "widget_alloc" c_widgetAlloc` carries TWO of them — the header first — and
+   * taking the FIRST match publishes the header as the symbol:
+   * `references c_widgetAlloc -> "libwidget.h"`, a file name where a function
+   * name belongs.
+   *
+   * MEASURED, and it corrected the hypothesis: over all 14,038 admitted `.hs`
+   * files there are 1,153 `foreign_import` nodes and the shape distribution is
+   * 1,040 with ONE quoted `entity` (which IS the entity — GHC writes
+   * `foreign import ccall unsafe "rts_isDebugged" c_rtsIsDebugged`), 113 with NO
+   * `entity` node at all, exactly 1 whose entity sits inside a sibling `ERROR`,
+   * and ZERO with two `entity` children
+   * (`script/m14/tmp/hs-ffi-shapes.ts`). So on THIS corpus the header case never
+   * fires and the only live FFI defect was the quotes. The LAST-entity rule is
+   * kept because it is strictly more correct on a shape the grammar does produce
+   * elsewhere, and the count above is what says its reach here is 0 — a fix whose
+   * corpus measurement is 0 is still worth having, and its 0 is recorded rather
+   * than implied.
+   */
+  readForeignEntity(node) {
+    let found = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c?.type === "entity") found = c;
+    }
+    return found?.text;
+  }
+  /**
+   * Drop ONE surrounding pair of double quotes.
+   *
+   * The FFI `entity` is a Haskell string literal, so the grammar's node text is
+   * `"name"` and the quotes are part of the node's text rather than of the name.
+   * Only the exact pair is removed, and only when both ends have one: a C
+   * identifier cannot contain `"`, and a bare word that happens to be an entity
+   * (the `foreign export`/`foreign import` variants whose entity is not a literal)
+   * is left exactly as it was. No regex — the lane's string contract is char
+   * scans over values already extracted from AST nodes.
+   */
+  stripQuotes(text) {
+    if (text.length >= 2 && text[0] === '"' && text[text.length - 1] === '"') return text.slice(1, -1);
+    return text;
+  }
+  /**
+   * THE C SYMBOL an FFI `entity` literal binds, not the whole literal.
+   *
+   * MEASURED DEFECT (2026-10-03, `script/m14/tmp/hs-verify-ffi-instance.ts`, tree
+   * pass over a stride-40 draw of the GHC corpus — 351 files, 23 `foreign_import`
+   * nodes): 7 of those 23 entity literals (30.4 %) carry a HEADER AND THE C NAME
+   * IN ONE STRING, separated by a space, and the analyzer published the header as
+   * the symbol:
+   *
+   *   references log1pDoubleOld -> "math.h log1p"      <- a FILE NAME
+   *   references functionInC    -> "T15933.h function_in_c"
+   *
+   * This is the Haskell 2010 Report's own grammar, F.3.2.1:
+   *
+   *     impent  →  'static' [chname] [&] [cid]  |  string
+   *
+   * and for the string form the header and the entity share one literal, so
+   * `foreign import ccall "T15933.h function_in_c"` binds the C symbol
+   * `function_in_c`. GHC writes both shapes in this very corpus:
+   * `foreign import ccall unsafe "RTSkeepAlive" c_keepCAFsForGHCi` (name only)
+   * and the two above (header + name). The name-only shape is unaffected, which
+   * is why the defect sat unread: every spot check drew the common form.
+   *
+   * WHY THE PRIOR MEASUREMENT MISSED IT. `readForeignEntity`'s own comment
+   * records a tree census of 1,153 `foreign_import` nodes with "ZERO with two
+   * `entity` children", and concluded the header case never fires. That count is
+   * of NODES, and it is correct — this grammar really does model the header and
+   * the entity as ONE `entity` node whose text is the whole literal. The header
+   * is inside the string, not beside it, so no node census can see it; only the
+   * literal's CONTENT distinguishes the two shapes. A fix whose measured reach
+   * was recorded as 0 was recorded from the wrong quantity.
+   *
+   * RULE, IN TWO PARTS, BOTH CONDITIONED ON THE CALLING CONVENTION.
+   *
+   * (a) `javascript` NAMES NO ENTITY, so it yields "". `foreign import
+   *     javascript "(($1, $2) => { return $1($2); })"` binds a JAVASCRIPT BODY.
+   *     Measured over a stride-12 draw (1,170 files, 62 `foreign_import` nodes,
+   *     `script/m14/tmp/hs-verify-ffi-conv.ts`): 13 of 13 `javascript` nodes name
+   *     JS code and not one names an entity. Before this branch the analyzer
+   *     published those bodies verbatim, and 8 of them SHIPPED — they contain
+   *     none of the characters `pool-worker.filterNoiseRelationships` bans, so
+   *     the filter did not catch them:
+   *
+   *       references js_print         -> "console.log($1)"
+   *       references js_req_to_str   -> "$1.text($2)"
+   *       references js_server_create -> "$1.createServer($2)"
+   *       references js_fetch_post    -> "r.text();"
+   *
+   *     That is the R7 payload-as-name shape: a code fragment standing where a
+   *     symbol belongs, counted by bb_graph and displayed by bb_impact. Under R7
+   *     the honest state for "no entity is named here" is ABSENCE. The declaration
+   *     still publishes its Haskell symbol and its `contains` edge; only the
+   *     `references` edge — which asserts an external symbol exists — is withheld.
+   *
+   * (b) For every C convention (`ccall`, `capi`, `stdcall`, `prim`, …) the C
+   *     entity is the LAST whitespace-separated token of the unquoted literal,
+   *     less a leading `&`. A C identifier contains neither a space nor a `&`
+   *     sigil, and the Report puts the header and the `static` keyword before the
+   *     entity, separated by a space. Measured in the same draw, the C
+   *     conventions are where the header and the `&` actually live:
+   *
+   *       capi   HEADER_PLUS_NAME  x6   "math.h log1p"
+   *       ccall  HEADER_PLUS_NAME  x2   "test_error_throwing.h equivalent_to_id"
+   *       ccall  AMPERSAND         x1   "stdio.h &putchar"
+   *
+   *     against 37 name-only C nodes and 13 javascript ones. The `&` is Report
+   *     F.3.2.1's `impent → 'static' [chname] [&] [cid]`: it means "pass the
+   *     address of this entity" and is not part of the entity's spelling, so
+   *     `foreign import ccall unsafe "&ghc_unique_counter64" ghc_unique_counter64`
+   *     (compiler/GHC/Types/Unique/Supply.hs:280) names the C symbol
+   *     `ghc_unique_counter64`.
+   *
+   * A corpus-wide count of the two prefix defects together, over the 1,356 quoted
+   * FFI literals GHC writes: **391 header+name and 42 `&`-prefixed = 433 of
+   * 1,356 (31.9 %)**, with 923 clean. That count is taken over the literals; the
+   * convention split is taken over the tree, because only the tree knows which
+   * convention a literal belongs to and the two must not be conflated — 10 of the
+   * 391 text-level "header" hits are JavaScript bodies, not headers.
+   */
+  foreignEntityName(literal, convention) {
+    if (convention === "javascript") return "";
+    const unquoted = this.stripQuotes(literal).trim();
+    if (!unquoted) return "";
+    let start = 0;
+    for (let i = 0; i < unquoted.length; i++) {
+      if (unquoted[i] === " " || unquoted[i] === "	" || unquoted[i] === "\n" || unquoted[i] === "\r") {
+        start = i + 1;
+      }
+    }
+    let name = unquoted.slice(start);
+    if (name[0] === "&") name = name.slice(1);
+    return name;
+  }
+  hasArrowInParens(text) {
+    let depth = 0;
+    for (let i = 0; i < text.length - 1; i++) {
+      const ch = text[i];
+      if (ch === "(") depth++;
+      else if (ch === ")") depth = Math.max(0, depth - 1);
+      else if (ch === "-" && text[i + 1] === ">" && depth > 0) return true;
+    }
+    return false;
+  }
+  splitOnArrows(text) {
+    const parts = [];
+    let cur = "";
+    for (let i = 0; i < text.length; i++) {
+      if (text[i] === "-" && text[i + 1] === ">") {
+        parts.push(cur);
+        cur = "";
+        i++;
+      } else {
+        cur += text[i];
+      }
+    }
+    parts.push(cur);
+    return parts;
+  }
+  nodeToRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+  findNamedChildByType(node, types, extraPredicate) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child) continue;
+      let found = false;
+      for (let j = 0; j < types.length; j++) {
+        if (types[j] === child.type) {
+          found = true;
+          break;
+        }
+      }
+      if (found || extraPredicate && extraPredicate(child.type)) return child;
+    }
+    return null;
+  }
+  collectFields(recordNode) {
+    const fields = [];
+    const stack = [recordNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const child = n.namedChild(i);
+        if (!child) continue;
+        if (child.type === "field") fields.push(child);
+        else stack.push(child);
+      }
+    }
+    return fields;
+  }
+  collectNamedChildrenByType(node, types) {
+    const matches = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) {
+        let found = false;
+        for (let j = 0; j < types.length; j++) {
+          if (types[j] === child.type) {
+            found = true;
+            break;
+          }
+        }
+        if (found) matches.push(child);
+      }
+    }
+    return matches;
+  }
+  hasChildOfType(node, type) {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child && child.type === type) return true;
+    }
+    return false;
+  }
+  findChildIndexByText(node, needle) {
+    const needles = [];
+    if (Array.isArray(needle)) {
+      for (let i = 0; i < needle.length; i++) needles.push(needle[i]);
+    } else {
+      needles.push(needle);
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) {
+        for (let j = 0; j < needles.length; j++) {
+          if (needles[j] === child.text) return i;
+        }
+      }
+    }
+    return -1;
+  }
+};
+export {
+  RealHaskellAnalyzer
+};