@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-clean-analyzer-4EEZLPV5.js

@@ -0,0 +1,3470 @@
+import {
+  fileClaimForTarget
+} from "./chunk-EWMWK7WN.js";
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-clean-analyzer.ts
+import * as path from "path";
+var LOCAL_SCOPE_NAME = "local";
+var OPTIONAL_PARAM_NAME = "_";
+function declarationKey(frame, owner, name) {
+  return `${frame ?? ""}|${owner ?? ""}::${name}`;
+}
+function stripWhitespace(text) {
+  let out = "";
+  for (const ch of text) if (ch !== " " && ch !== "	" && ch !== "\n" && ch !== "\r") out += ch;
+  return out;
+}
+function unparenthesizeText(text) {
+  let body = text;
+  if (body.startsWith("(")) body = body.slice(1);
+  if (body.endsWith(")")) body = body.slice(0, -1);
+  const inner = body.trim();
+  if (!inner) return null;
+  if (inner.includes(",") || inner.includes("{") || inner.includes("}")) return null;
+  return inner;
+}
+function unquoteText(text) {
+  if (text.length >= 2 && text.startsWith('"') && text.endsWith('"')) return text.slice(1, -1);
+  return text;
+}
+var RESERVED_DECLARATION_NAMES = /* @__PURE__ */ new Set([
+  "as",
+  "case",
+  "class",
+  "code",
+  "definition",
+  "derive",
+  "else",
+  "export",
+  "foreign",
+  "from",
+  "generic",
+  "if",
+  "implementation",
+  "import",
+  "in",
+  "infix",
+  "infixl",
+  "infixr",
+  "instance",
+  "let",
+  "module",
+  "of",
+  "qualified",
+  "special",
+  "system",
+  "then",
+  "where",
+  "with"
+]);
+function isReservedDeclarationName(name) {
+  return name !== null && name !== void 0 && RESERVED_DECLARATION_NAMES.has(name);
+}
+var OPERATOR_LEAF_TYPES = /* @__PURE__ */ new Set([
+  "operator",
+  "operator_add",
+  "operator_and",
+  "operator_compare",
+  "operator_cons",
+  "operator_cons_strict",
+  "operator_dot",
+  "operator_exp",
+  "operator_mul",
+  "operator_or",
+  "operator_pipe",
+  "monad_bind",
+  "backtick_operator",
+  "uniqueness_star",
+  "parenthesized_operator"
+]);
+var DERIVE_TARGET_NODE_TYPES = /* @__PURE__ */ new Set([
+  "type_variable",
+  "constructor",
+  "dotted_type",
+  "type_application",
+  "type_paren",
+  "parenthesized_operator"
+]);
+var PATTERN_NODE_TYPES = /* @__PURE__ */ new Set([
+  "constructor_pattern",
+  "list_pattern",
+  "tuple_pattern",
+  "record_pattern",
+  "paren_pattern",
+  "unboxed_pattern",
+  "cons_pattern",
+  "strict_binding_pattern",
+  "record_update_pattern"
+]);
+var CONSTRAINT_MARKER_TYPES = /* @__PURE__ */ new Set([
+  "number",
+  "integer",
+  "float",
+  "uniqueness_star",
+  "uniqueness_constraints"
+]);
+var INSTANCE_CONTAINER_SUFFIX = "::instance";
+var CALLABLE_NODE_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "operator_definition",
+  "generic_case_definition",
+  "macro_definition"
+]);
+var COMMENT_TYPES = /* @__PURE__ */ new Set(["line_comment", "block_comment"]);
+var DECISION_NODE_TYPES = /* @__PURE__ */ new Set([
+  "case_expression",
+  "case_alternative",
+  "guard_equation",
+  "guard",
+  "if_expression",
+  "comprehension_qualifier",
+  "binary_expression"
+]);
+var CLEAN_STD_ENV_NAMES = /* @__PURE__ */ new Set([
+  "Applicative",
+  "Arith",
+  "Array",
+  "Bool",
+  "CONS",
+  "Char",
+  "ConsPos",
+  "DynamicTemp",
+  "EITHER",
+  "Enum",
+  "Eq",
+  "FIELD",
+  "File",
+  "FileEnv",
+  "FileSystem",
+  "Files",
+  "Functor",
+  "GenConsAssoc",
+  "GenConsPrio",
+  "GenType",
+  "GenericConsDescriptor",
+  "GenericDict",
+  "GenericDict0",
+  "GenericFieldDescriptor",
+  "GenericRecordDescriptor",
+  "GenericTypeDefDescriptor",
+  "IncDec",
+  "Int",
+  "List",
+  "Maybe",
+  "Monad",
+  "MultDiv",
+  "NormaliseState",
+  "Num",
+  "OBJECT",
+  "Option",
+  "Ord",
+  "PAIR",
+  "PlusMin",
+  "Prelude",
+  "RECORD",
+  "Real",
+  "Semigroup",
+  "Show",
+  "St",
+  "StdArray",
+  "StdBool",
+  "StdChar",
+  "StdCharList",
+  "StdClass",
+  "StdDebug",
+  "StdDynamic",
+  "StdEnum",
+  "StdEnv",
+  "StdFile",
+  "StdFunc",
+  "StdFunctions",
+  "StdGeneric",
+  "StdInt",
+  "StdList",
+  "StdMaybe",
+  "StdMisc",
+  "StdOrdList",
+  "StdOverloaded",
+  "StdOverloadedList",
+  "StdReal",
+  "StdStrictLists",
+  "StdString",
+  "StdTuple",
+  "String",
+  "TC_Bool",
+  "TC_Char",
+  "TC_Dynamic",
+  "TC_File",
+  "TC_Int",
+  "TC_Real",
+  "TC_World",
+  "TC__Arrow",
+  "TC__LazyArray",
+  "TC__LazyArrayP2",
+  "TC__List",
+  "TC__Maybe",
+  "TC__PackedArray",
+  "TC__PackedArrayP2",
+  "TC__STuple10",
+  "TC__STuple11",
+  "TC__STuple12",
+  "TC__STuple13",
+  "TC__STuple14",
+  "TC__STuple15",
+  "TC__STuple16",
+  "TC__STuple17",
+  "TC__STuple18",
+  "TC__STuple19",
+  "TC__STuple2",
+  "TC__STuple20",
+  "TC__STuple21",
+  "TC__STuple22",
+  "TC__STuple23",
+  "TC__STuple24",
+  "TC__STuple25",
+  "TC__STuple26",
+  "TC__STuple27",
+  "TC__STuple28",
+  "TC__STuple29",
+  "TC__STuple3",
+  "TC__STuple30",
+  "TC__STuple31",
+  "TC__STuple32",
+  "TC__STuple4",
+  "TC__STuple5",
+  "TC__STuple6",
+  "TC__STuple7",
+  "TC__STuple8",
+  "TC__STuple9",
+  "TC__StrictArray",
+  "TC__StrictArrayP2",
+  "TC__StrictList",
+  "TC__StrictMaybe",
+  "TC__StrictTailStrictList",
+  "TC__TailStrictList",
+  "TC__Tuple10",
+  "TC__Tuple11",
+  "TC__Tuple12",
+  "TC__Tuple13",
+  "TC__Tuple14",
+  "TC__Tuple15",
+  "TC__Tuple16",
+  "TC__Tuple17",
+  "TC__Tuple18",
+  "TC__Tuple19",
+  "TC__Tuple2",
+  "TC__Tuple20",
+  "TC__Tuple21",
+  "TC__Tuple22",
+  "TC__Tuple23",
+  "TC__Tuple24",
+  "TC__Tuple25",
+  "TC__Tuple26",
+  "TC__Tuple27",
+  "TC__Tuple28",
+  "TC__Tuple29",
+  "TC__Tuple3",
+  "TC__Tuple30",
+  "TC__Tuple31",
+  "TC__Tuple32",
+  "TC__Tuple4",
+  "TC__Tuple5",
+  "TC__Tuple6",
+  "TC__Tuple7",
+  "TC__Tuple8",
+  "TC__Tuple9",
+  "TC__UnboxedArray",
+  "TC__UnboxedArrayP2",
+  "TC__UnboxedList",
+  "TC__UnboxedMaybe",
+  "TC__UnboxedTailStrictList",
+  "TC__Unit",
+  "TypeCode",
+  "TypeCodeConstructor",
+  "UList",
+  "UMaybe",
+  "UNIT",
+  "UTSList",
+  "UnificationEnvironment",
+  "World",
+  "_SystemArray",
+  "_SystemDynamic",
+  "_SystemEnum",
+  "_SystemEnumStrict",
+  "_SystemStrictLists",
+  "_SystemStrictMaybes",
+  "_UnificationEnvironment"
+]);
+var RealCleanAnalyzer = class {
+  analyze(rootNode, fileContent, filePath, context) {
+    const ctx = {
+      symbols: [],
+      relationships: [],
+      imports: [],
+      exports: [],
+      errors: [],
+      patterns: {},
+      fixities: [],
+      declaredFunctions: /* @__PURE__ */ new Set(),
+      functionSymbolIndex: /* @__PURE__ */ Object.create(null),
+      signatures: /* @__PURE__ */ new Map(),
+      signaturesByNode: /* @__PURE__ */ new Map(),
+      localScopes: { callableScoped: /* @__PURE__ */ new Map(), blockLocals: /* @__PURE__ */ new Map(), frameLocals: /* @__PURE__ */ new Map() },
+      importAliases: /* @__PURE__ */ new Set(),
+      declaredTypeNames: /* @__PURE__ */ new Set(),
+      declaredTypeDefNames: /* @__PURE__ */ new Set(),
+      declaredFieldNames: /* @__PURE__ */ new Set(),
+      declaredConstructors: /* @__PURE__ */ new Set(),
+      declaredClassNames: /* @__PURE__ */ new Set(),
+      classMembers: /* @__PURE__ */ new Map(),
+      frameSymbolIndex: /* @__PURE__ */ new Map(),
+      currentModule: void 0,
+      currentFrame: void 0,
+      currentFrameIsLocal: false,
+      seenRels: /* @__PURE__ */ new Set(),
+      fileComplexity: 1,
+      declinedInstantiations: { count: 0, names: [] },
+      typeCoercions: { count: 0, names: [] },
+      operatorImports: { count: 0, names: [] },
+      foreignCodeImports: { count: 0, objects: [] },
+      detachedLocals: 0,
+      frameComplexity: /* @__PURE__ */ new Map()
+    };
+    const scopeStack = [];
+    const stack = [{ node: rootNode }];
+    this.collectNames(rootNode, ctx);
+    while (stack.length > 0) {
+      const entry = stack.pop();
+      if (entry.isExit) {
+        if (entry.restoresFrame) {
+          if (ctx.currentFrame !== void 0) {
+            const idx = ctx.frameSymbolIndex.get(ctx.currentFrame);
+            if (idx !== void 0) {
+              const sym = ctx.symbols[idx];
+              sym.complexity = Math.max(sym.complexity ?? 1, ctx.frameComplexity.get(ctx.currentFrame) ?? 1);
+            }
+          }
+          ctx.currentFrame = entry.restoreFrame;
+          ctx.currentFrameIsLocal = entry.restoreLocal === true;
+        }
+        if (scopeStack.length > 0 && scopeStack[scopeStack.length - 1].node === entry.node) scopeStack.pop();
+        continue;
+      }
+      const node = entry.node;
+      if (node.isMissing) continue;
+      if (node.type === "ERROR") {
+        ctx.errors.push({
+          message: "Syntax Error",
+          range: {
+            startLine: node.startPosition.row + 1,
+            startColumn: node.startPosition.column,
+            endLine: node.endPosition.row + 1,
+            endColumn: node.endPosition.column,
+            startIndex: node.startIndex,
+            endIndex: node.endIndex
+          },
+          severity: "error"
+        });
+      }
+      if (DECISION_NODE_TYPES.has(node.type)) {
+        ctx.fileComplexity++;
+        if (ctx.currentFrame !== void 0) {
+          ctx.frameComplexity.set(ctx.currentFrame, (ctx.frameComplexity.get(ctx.currentFrame) ?? 1) + 1);
+        }
+      }
+      const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+      const inErrorRegion = entry.inError === true || node.type === "ERROR";
+      let frame = null;
+      let openedScope = false;
+      switch (node.type) {
+        case "module_declaration":
+          openedScope = this.enterModule(node, ctx, scopeStack);
+          break;
+        case "type_definition":
+          openedScope = this.processTypeDefinition(node, ctx, scopeStack);
+          break;
+        case "class_declaration":
+          openedScope = this.processClass(node, ctx, scopeStack);
+          break;
+        case "instance_declaration":
+          openedScope = this.processInstance(node, ctx, scopeStack);
+          break;
+        case "generic_declaration":
+          this.processGenericDeclaration(node, ctx, currentScope);
+          break;
+        case "derive_declaration":
+          this.processDeriveDeclaration(node, ctx);
+          break;
+        case "function_declaration":
+        case "operator_definition":
+        case "generic_case_definition":
+          frame = this.processCallableNode(node, ctx, currentScope, inErrorRegion);
+          break;
+        case "macro_definition":
+          frame = this.processMacro(node, ctx, currentScope);
+          break;
+        case "foreign_export":
+          this.processForeignExport(node, ctx, currentScope);
+          break;
+        case "fixity_declaration":
+          this.processFixityDeclaration(node, ctx);
+          break;
+        case "type_signature":
+          this.processTypeSignature(node, ctx, currentScope, inErrorRegion);
+          break;
+        case "where_block":
+        case "with_block":
+        case "let_expression":
+          scopeStack.push({
+            node,
+            name: LOCAL_SCOPE_NAME,
+            kind: ASTEngine.SymbolKind.Namespace,
+            locals: ctx.localScopes.blockLocals.get(node.id)
+          });
+          openedScope = true;
+          break;
+        case "special_block":
+          this.processSpecialBlock(node, ctx);
+          break;
+        case "application":
+          this.extractApplication(node, ctx, scopeStack);
+          break;
+        case "field_access":
+          this.emitFieldUse(node, ctx, "field_read");
+          break;
+        case "record_update":
+          this.extractRecordUpdate(node, ctx);
+          break;
+        case "record_expression":
+          this.extractRecordExpression(node, ctx);
+          break;
+        case "constructor_pattern":
+          this.extractConstructorPattern(node, ctx);
+          break;
+        case "lambda_expression":
+          ctx.patterns["Higher-Order Functions"] = true;
+          break;
+        case "list_comprehension":
+        case "array_comprehension":
+          ctx.patterns["List Comprehensions"] = true;
+          break;
+        case "case_expression":
+        case "case_alternative":
+          ctx.patterns["Pattern Matching"] = true;
+          break;
+        case "code_expression":
+          ctx.patterns["Inline Machine Code"] = true;
+          break;
+        case "unboxed_expression":
+        case "unboxed_pattern":
+        case "uniqueness_type":
+        case "uniqueness_star":
+          ctx.patterns["Uniqueness Types"] = true;
+          break;
+        case "type_definition_body":
+          ctx.patterns["Algebraic Data Types"] = true;
+          break;
+        case "record_definition":
+          ctx.patterns["Record Types"] = true;
+          break;
+        case "record_update_pattern":
+        case "update_field":
+          ctx.patterns["Record Updates"] = true;
+          break;
+        case "monad_bind":
+          ctx.patterns["Do Notation"] = true;
+          break;
+        case "range_operator":
+          ctx.patterns["Range Expressions"] = true;
+          break;
+        default:
+          break;
+      }
+      if (frame) {
+        const previousFrame = ctx.currentFrame;
+        const previousLocal = ctx.currentFrameIsLocal;
+        ctx.currentFrame = previousFrame === void 0 ? frame.name : `${previousFrame}.${frame.name}`;
+        ctx.currentFrameIsLocal = frame.isLocal;
+        const frameIdx = ctx.functionSymbolIndex[frame.key];
+        if (frameIdx !== void 0) ctx.frameSymbolIndex.set(ctx.currentFrame, frameIdx);
+        scopeStack.push({
+          node,
+          name: frame.name,
+          kind: frame.kind,
+          locals: ctx.localScopes.frameLocals.get(node.id),
+          isFrame: true
+        });
+        stack.push({ node, isExit: true, restoresFrame: true, restoreFrame: previousFrame, restoreLocal: previousLocal });
+      } else if (openedScope) {
+        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, inError: inErrorRegion });
+      }
+    }
+    this.attachFixities(ctx);
+    this.emitContainsEdges(ctx);
+    this.emitExports(ctx);
+    this.qualifyModuleLevelSymbols(ctx);
+    this.classifyEvidenceTier(ctx);
+    const claimRoot = typeof context?.projectRoot === "string" && context.projectRoot.length > 0 ? context.projectRoot : null;
+    if (claimRoot !== null) {
+      const root = path.resolve(claimRoot);
+      const fileRel = path.relative(root, filePath).split(path.sep).join("/");
+      const relDir = path.posix.dirname(fileRel);
+      const fileDir = relDir === "." ? "" : `${relDir}/`;
+      for (const r of ctx.relationships) {
+        if (r.type !== ASTEngine.RelationshipType.Imports) continue;
+        const md = r.metadata;
+        if (!md || typeof md.importProjectFile === "string") continue;
+        const moduleName = typeof md.module === "string" && md.module.length > 0 ? md.module : String(r.target ?? "").split(":")[0];
+        if (moduleName.length === 0) continue;
+        const modulePath = moduleName.split(".").join("/");
+        const rootCandidates = [`${modulePath}.icl`, `${modulePath}.dcl`];
+        const extraCandidates = fileDir.length > 0 ? [`${fileDir}${modulePath}.icl`, `${fileDir}${modulePath}.dcl`, ...rootCandidates] : rootCandidates;
+        const claim = fileClaimForTarget({
+          projectRoot: claimRoot,
+          filePath,
+          written: String(r.target ?? ""),
+          admittedExtensions: ["icl", "dcl"],
+          extraCandidates
+        });
+        if (claim === null) continue;
+        md.importProjectFile = claim;
+      }
+    }
+    this.markStandardEnvironmentTargets(ctx);
+    const patterns = [];
+    for (const p in ctx.patterns) patterns.push(p);
+    return {
+      language: "clean",
+      symbols: ctx.symbols,
+      relationships: ctx.relationships,
+      imports: ctx.imports,
+      exports: ctx.exports,
+      errors: ctx.errors,
+      metadata: {
+        complexity: ctx.fileComplexity,
+        linesOfCode: fileContent.split("\n").length,
+        cyclomaticComplexity: ctx.fileComplexity,
+        patterns,
+        hasTypeInference: true,
+        analysisVersion: "12.0.0-clean-ast-complete",
+        // The price of the in-file resolution rule, stated in the output rather
+        // than inferred from a diff. See the field's declaration for the
+        // measurement behind it.
+        declinedInstantiations: ctx.declinedInstantiations.count,
+        declinedInstantiationNames: ctx.declinedInstantiations.names,
+        // Applying a declared type: a coercion, counted apart from the declines
+        // because the construct is known rather than unclassifiable.
+        typeCoercions: ctx.typeCoercions.count,
+        typeCoercionNames: ctx.typeCoercions.names,
+        // Imported operators: a real dependency the shared `<module>:<item>` edge
+        // form cannot express, so it is counted rather than emitted unresolvable.
+        operatorImports: ctx.operatorImports.count,
+        operatorImportNames: ctx.operatorImports.names,
+        // Foreign code imports: a real dependency the `<module>:<item>` edge form
+        // cannot express, because a linker input is not a module.
+        foreignCodeImports: ctx.foreignCodeImports.count,
+        foreignCodeObjects: ctx.foreignCodeImports.objects,
+        // Locals whose enclosing function the pinned grammar could not read, so the
+        // module owns them instead of a frame that does not exist.
+        detachedLocals: ctx.detachedLocals
+      }
+    };
+  }
+  // ============================================================================
+  // PASS 1 — name tables
+  // ============================================================================
+  /**
+   * Imports, including the SELECTIVE item list.
+   *
+   * The old version pushed `items: []` unconditionally. Measured over the
+   * corpus: 367 of the 1,332 `import_declaration`s are `from M import …` with an
+   * item list — 943 items across 20 distinct item node types (`constructor` 541,
+   * `identifier` 188, `range_operator` 59, `parenthesized_operator` 45,
+   * `operator_compare` 30, `operator` 17, `record_subset` 11,
+   * `class_method_name` 10, `constructor_subset` 7, …). Every one of those names
+   * was invisible to the product: the import edge had to be `<module>:*` when the
+   * file actually said exactly which symbols it wanted, which is the difference
+   * between an edge that resolves and one that never can (see
+   * src/ast/import-resolution.ts — a target must be in the exporting file's
+   * export surface before it may be joined).
+   */
+  collectImport(n, ctx, edgeSource, importEdges) {
+    {
+      {
+        const moduleNodes = this.fields(n, "module");
+        const aliasNode = n.childForFieldName("alias");
+        const alias = aliasNode ? this.assembleModuleName(aliasNode) : void 0;
+        let isQualified = false;
+        for (let i = 0; i < n.childCount; i++) {
+          const c = n.child(i);
+          if (c && !c.isNamed && c.type === "qualified") {
+            isQualified = true;
+            break;
+          }
+        }
+        if (alias) ctx.importAliases.add(alias);
+        const items = this.importItems(n, moduleNodes);
+        for (const it of items) {
+          if (it.name.includes(":")) {
+            ctx.operatorImports.count++;
+            if (ctx.operatorImports.names.length < 25 && !ctx.operatorImports.names.includes(it.name)) {
+              ctx.operatorImports.names.push(it.name);
+            }
+            continue;
+          }
+          const key = `${edgeSource}|${it.module}:${it.name}|${it.line}`;
+          if (importEdges.has(key)) continue;
+          importEdges.add(key);
+          this.pushRel(
+            ctx,
+            edgeSource,
+            `${it.module}:${it.name}`,
+            ASTEngine.RelationshipType.Imports,
+            1,
+            {
+              cleanSpecific: true,
+              module: it.module,
+              itemKind: it.kind,
+              isInstanceImport: it.kind === "instance",
+              isClassImport: it.kind === "class",
+              // ★ THE STDLIB CLAIM, emitted where the evidence exists (2026-10-28). The target of an
+              // import here is `${module}:${item}` (`StdEnv:map`) — a spelling no symbol can ever carry, so
+              // every one of the lane's 1,917 import edges read unresolved or unverifiable. The fleet's
+              // `moduleNamespace` claim is the mechanism for exactly this shape (python's `pathlib:Path`),
+              // and its evidence must be a CLOSED list, not a guess: `CLEAN_STD_ENV_NAMES` is the lane's own
+              // stdlib module set, measured, and the arbiter verifies the MODULE against the project's module
+              // space — so a project that DOES declare `StdEnv` REFUTES the claim. That direction is the one
+              // this lane must watch: `extFAIL` may not rise, and the arm is what says so.
+              // THE STDLIB CLAIM ONLY, AND A NON-STDLIB MODULE CARRIES NO CLAIM AT THIS SITE.
+              //
+              // ANY OTHER module (`Data.Error`, a corpus project's own `Clyde.Cocoa.tabview`) may be a
+              // project module or a dependency, and THE PROJECT'S FILE LIST DECIDES WHICH — but THIS SITE
+              // CANNOT SEE THAT LIST, so it must not state the claim. It used to: a flat
+              // `[Module/Sub.icl, Module/Sub.dcl]` was attached to every non-stdlib module, and the arm
+              // REFUTED **1,177 of the 1,615** claims it made (`extFAIL 1177`), because a Clean module's
+              // file is found on a SEARCH PATH (`Clyde` puts module `IdeState` at
+              // `cleantools/BatchBuild/IdeState.icl`, eastwood puts `Diagnostic` at
+              // `src/sharedUtil/Diagnostic.icl`) and the root-relative arithmetic below is only one of the
+              // spellings a loader tries. A file claim that a run can refute is a FALSE statement, not a
+              // conservative one: `fileClaimForTarget` refuses to emit an unconfirmed candidate for
+              // exactly this reason. PASS 3 owns the claim instead — it has `context.projectRoot`, it
+              // runs the shared guard over the importing file's own directory AND the project root, and
+              // it attaches a claim only when a candidate is CONFIRMED on disk (see the block there).
+              ...CLEAN_STD_ENV_NAMES.has(it.module) ? { isExternal: true, externalReason: "module-namespace", externalSpecifier: it.module } : {}
+            },
+            it.line
+          );
+        }
+        for (const modNode of moduleNodes) {
+          if (!modNode) continue;
+          const modName = this.assembleModuleName(modNode);
+          const mine = items.filter((it) => it.module === modName);
+          const seenItem = /* @__PURE__ */ new Set();
+          const unique = mine.filter((it) => {
+            if (seenItem.has(it.name)) return false;
+            seenItem.add(it.name);
+            return true;
+          });
+          ctx.imports.push({
+            module: modName,
+            source: modName,
+            items: unique.map((it) => it.name),
+            isTypeOnly: false,
+            range: this.nodeToRange(n),
+            metadata: {
+              cleanSpecific: true,
+              isQualified,
+              alias,
+              isSelective: mine.length > 0,
+              itemKinds: mine.map((it) => it.kind),
+              // Which imported names are opened as a SUBSET (`::T(..)`,
+              // `::T{field}`). Recorded because the subset marker is not a name
+              // and so has no edge of its own, and "this import binds all of T's
+              // constructors" is a fact the product can use.
+              openItems: unique.filter((it) => it.opens).map((it) => `${it.name}${it.opens === "record" ? "{}" : "(..)"}`)
+            }
+          });
+          this.pushRel(
+            ctx,
+            ctx.currentModule || "",
+            modName,
+            ASTEngine.RelationshipType.References,
+            1,
+            { cleanSpecific: true, isImportDependency: true },
+            this.lineOf(modNode)
+          );
+          if (modName.indexOf("StdEnv") !== -1) ctx.patterns["Standard Environment"] = true;
+          if (mine.length === 0) {
+            const key = `${edgeSource}|${modName}:*`;
+            if (!importEdges.has(key)) {
+              importEdges.add(key);
+              this.pushRel(
+                ctx,
+                edgeSource,
+                `${modName}:*`,
+                ASTEngine.RelationshipType.Imports,
+                1,
+                {
+                  cleanSpecific: true,
+                  module: modName,
+                  isWildcard: true,
+                  // THE WILDCARD FORM NEEDS THE SAME CLAIM AS THE ITEM FORM, and it was the gap: `import StdEnv`
+                  // publishes `StdEnv:*`, and this site carried NO claim at all, so 52 `StdEnv:*` + 23 `StdString:*`
+                  // rows read unresolved while the identical module on the item path was verified. MEASURED: the
+                  // claim existed at ONE of the two emission sites (`grep -c module-namespace` = 1) and the
+                  // unclaimed remainder was dominated by `StdEnv:*` (52), `StdString` (23), `StdBool` (21) — every
+                  // one of them a module already in the closed `CLEAN_STD_ENV_NAMES` set.
+                  // A NON-STDLIB module carries no file claim here — see the item site above for the 1,177
+                  // refutations that measured why, and PASS 3 for where the claim is made instead.
+                  ...CLEAN_STD_ENV_NAMES.has(modName) ? { isExternal: true, externalReason: "module-namespace", externalSpecifier: modName } : {}
+                },
+                this.lineOf(modNode)
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * The item list of one import declaration, each item tagged by the keyword that
+   * introduces it.
+   *
+   * All four keyword forms exist in the corpus and each names a DIFFERENT thing,
+   * so the tag is load-bearing rather than cosmetic:
+   *   `from M import ::NSApplication, sharedApplication` → `::` = public-only
+   *   `from M import instance toString {#Char}`            → an INSTANCE
+   *   `from M import class C a`                            → a CLASS
+   *   `import M => qualified join`                          → a QUALIFIED name
+   *   `from M import ::GeneralSt{..}`                      → an open record
+   */
+  importItems(node, moduleNodes) {
+    const out = [];
+    let currentModule = moduleNodes.length > 0 && moduleNodes[0] ? this.assembleModuleName(moduleNodes[0]) : "";
+    let keyword = "name";
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (!c) continue;
+      if (!c.isNamed) {
+        if (c.type === "instance") keyword = "instance";
+        else if (c.type === "class") keyword = "class";
+        else if (c.type === "qualified") keyword = "qualified";
+        else if (c.type === "::") keyword = "name";
+        continue;
+      }
+      let isModuleField = false;
+      for (let k = 0; k < node.childCount; k++) {
+        const field = node.fieldNameForChild(k);
+        if (field !== "module" && field !== "alias") continue;
+        const fc = node.child(k);
+        if (fc && fc.startIndex === c.startIndex) {
+          isModuleField = true;
+          break;
+        }
+      }
+      if (isModuleField) {
+        if (c.type === "module_name" && moduleNodes.some((m) => m.startIndex === c.startIndex)) {
+          currentModule = this.assembleModuleName(c);
+        }
+        continue;
+      }
+      if (this.isOpenSubsetMarker(c)) {
+        if (out.length > 0) {
+          const last = out[out.length - 1];
+          last.opens = c.type === "record_subset" ? "record" : "constructor";
+        }
+        continue;
+      }
+      for (const described of this.describeImportItems(c, keyword)) {
+        out.push({ ...described, module: currentModule });
+      }
+    }
+    return out;
+  }
+  /**
+   * Is this import-item child an OPEN-SUBSET MARKER rather than a name?
+   *
+   * `constructor_subset`, `record_subset`, and the `parenthesized_operator` the
+   * grammar types for a `(..)` list — every one of which QUALIFIES the name in
+   * front of it. All three are real corpus node types (7, 11 and — as the `(..)`
+   * spelling — the bulk of the 512 `parenthesized_operator` sites).
+   */
+  isOpenSubsetMarker(node) {
+    if (node.type === "record_subset") return true;
+    if (node.type === "constructor_subset") {
+      return this.firstNamedChildOfType(node, "constructor") === null;
+    }
+    if (node.type === "parenthesized_operator") return this.isDotsOnly(this.unparenthesize(node.text) ?? node.text);
+    return false;
+  }
+  /** Is every character a dot (and is there at least one)? `(..)` → true, `(==)` → false. */
+  isDotsOnly(text) {
+    const t = text.trim();
+    if (!t) return false;
+    for (const ch of t) if (ch !== ".") return false;
+    return true;
+  }
+  /** Name + kind for one import-item node, or null when it names nothing. */
+  describeImportItems(node, keyword) {
+    const line = this.lineOf(node);
+    if (!line) return [];
+    const kind = keyword === "name" ? "name" : keyword;
+    switch (node.type) {
+      case "identifier":
+      case "constructor":
+        return node.text ? [{ name: node.text, kind, line }] : [];
+      case "constructor_subset": {
+        const out = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const inner = node.namedChild(i);
+          if (!inner || inner.type !== "constructor" || !inner.text) continue;
+          out.push({ name: inner.text, kind, line });
+        }
+        return out;
+      }
+      case "class_method_name": {
+        const out = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const inner = node.namedChild(i);
+          if (!inner || !inner.text) continue;
+          out.push({ name: inner.text, kind, line });
+        }
+        return out.length ? out : node.text ? [{ name: node.text, kind, line }] : [];
+      }
+      case "backtick_operator": {
+        const bare = this.backtickOperatorName(node.text);
+        return bare ? [{ name: bare, kind, line }] : [];
+      }
+      default:
+        if (OPERATOR_LEAF_TYPES.has(node.type)) {
+          const name = node.text.trim();
+          return name ? [{ name, kind, line }] : [];
+        }
+        return [];
+    }
+  }
+  /** `` `on` `` → `on`. A character filter, not a regex; an empty result is not a name. */
+  backtickOperatorName(text) {
+    let out = "";
+    for (const ch of text) if (ch !== "`") out += ch;
+    out = out.trim();
+    return out || null;
+  }
+  /**
+   * THE NAME-COLLECTION WALK. One traversal builds every table the emitting walk
+   * needs: the module name, the imports and their item lists, the type signatures
+   * keyed by declaration identity, the declared type / class / constructor /
+   * field / callable name sets, and the lexical local scopes.
+   *
+   * It was four separate traversals (imports, signatures, declared names, local
+   * scopes) plus a fifth for the module header, so the analyzer visited the
+   * corpus's 331,079 nodes five times before emitting anything. All five need the
+   * same two pieces of context — the enclosing FRAME identity and the enclosing
+   * OWNER — so they share one walk and one tracker and the traversal count drops
+   * from six (five names + one emit) to two.
+   *
+   * The tracker is the same rule the emitting walk uses, in the same order, so the
+   * `declarationKey` a signature is stored under is the key the emitting walk
+   * looks it up with. Both call `declarationKey`; neither spells the identity.
+   */
+  collectNames(root, ctx) {
+    const importEdges = /* @__PURE__ */ new Set();
+    const visit = (n, frameId, frame, owner) => {
+      let nextFrameId = frameId;
+      let nextFrame = frame;
+      let nextOwner = owner;
+      switch (n.type) {
+        case "module_declaration": {
+          const nameNode = n.childForFieldName("name");
+          if (nameNode) {
+            ctx.currentModule = this.assembleModuleName(nameNode);
+            nextOwner = ctx.currentModule;
+          }
+          break;
+        }
+        case "import_declaration":
+          this.collectImport(n, ctx, ctx.currentModule ?? "", importEdges);
+          break;
+        case "foreign_code_import": {
+          ctx.foreignCodeImports.count++;
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const item = n.namedChild(i);
+            if (!item || item.type !== "foreign_code_item") continue;
+            const obj = item.childForFieldName("object");
+            const name = obj ? unquoteText(obj.text) : void 0;
+            if (name && ctx.foreignCodeImports.objects.length < 25 && !ctx.foreignCodeImports.objects.includes(name)) {
+              ctx.foreignCodeImports.objects.push(name);
+            }
+          }
+          break;
+        }
+        case "type_definition": {
+          const nm = n.childForFieldName("name");
+          if (nm) {
+            ctx.declaredTypeNames.add(nm.text);
+            ctx.declaredTypeDefNames.add(nm.text);
+          }
+          const body = n.childForFieldName("body");
+          if (body) this.addTypeMention(body.childForFieldName("rhs") ?? body, ctx);
+          break;
+        }
+        case "class_declaration": {
+          const nm = n.childForFieldName("name");
+          if (nm) {
+            ctx.declaredTypeNames.add(nm.text);
+            ctx.declaredClassNames.add(nm.text);
+            const members = /* @__PURE__ */ new Set();
+            for (let i = 0; i < n.namedChildCount; i++) {
+              const m = n.namedChild(i);
+              if (m?.type !== "class_member") continue;
+              const declared = this.memberDeclaredName(m);
+              if (declared) members.add(declared);
+            }
+            if (members.size > 0) {
+              ctx.classMembers.set(nm.text, members);
+              const bare = this.unparenthesize(nm.text);
+              if (bare !== null && bare !== nm.text) ctx.classMembers.set(bare, members);
+            }
+          }
+          nextOwner = nm?.text ?? nextOwner;
+          break;
+        }
+        case "generic_declaration": {
+          const nm = n.childForFieldName("name");
+          if (nm) {
+            ctx.declaredTypeNames.add(nm.text);
+            ctx.declaredClassNames.add(nm.text);
+          }
+          nextOwner = nm?.text ?? nextOwner;
+          break;
+        }
+        case "instance_declaration":
+          for (const a of this.fields(n, "argument")) this.addTypeMention(a, ctx);
+          break;
+        case "generic_case_definition": {
+          const nm = n.childForFieldName("name");
+          if (nm) ctx.declaredFunctions.add(nm.text);
+          break;
+        }
+        case "macro_definition": {
+          const name = this.normalizeParenthesized(n.childForFieldName("name"));
+          if (name) {
+            ctx.declaredFunctions.add(name);
+            ctx.declaredTypeNames.add(name);
+          }
+          break;
+        }
+        case "foreign_export": {
+          const nm = n.childForFieldName("name");
+          if (nm) ctx.declaredFunctions.add(nm.text);
+          break;
+        }
+        case "data_constructor": {
+          const nm = n.childForFieldName("name");
+          if (nm) {
+            ctx.declaredConstructors.add(nm.text);
+            ctx.declaredTypeNames.add(nm.text);
+          }
+          break;
+        }
+        case "record_field": {
+          const nm = n.childForFieldName("name");
+          if (nm) {
+            ctx.declaredFieldNames.add(nm.text);
+            ctx.declaredTypeNames.add(nm.text);
+          }
+          const t = n.childForFieldName("type");
+          if (t) this.addTypeMention(t, ctx);
+          break;
+        }
+        case "special_member": {
+          const t = n.childForFieldName("type");
+          if (t) this.addTypeMention(t, ctx);
+          break;
+        }
+        case "type_signature": {
+          const name = this.declarationName(n);
+          if (name) {
+            ctx.declaredFunctions.add(name);
+            const key = declarationKey(frame, owner, name);
+            let info = ctx.signaturesByNode.get(n.id);
+            if (!info) {
+              info = this.readSignature(n, ctx);
+              ctx.signaturesByNode.set(n.id, info);
+              if (!ctx.signatures.has(key)) ctx.signatures.set(key, info);
+            }
+          }
+          break;
+        }
+        case "where_block":
+        case "with_block":
+        case "let_expression": {
+          const map = this.localBlockLocals(n, ctx.localScopes, frame);
+          if (map && map.size > 0) {
+            ctx.localScopes.blockLocals.set(n.id, map);
+            if (frameId >= 0) {
+              const fm = ctx.localScopes.frameLocals.get(frameId) ?? /* @__PURE__ */ new Map();
+              for (const [k, v] of map) fm.set(k, v);
+              ctx.localScopes.frameLocals.set(frameId, fm);
+            }
+          }
+          nextOwner = nextFrame;
+          break;
+        }
+        default:
+          break;
+      }
+      const callableName = this.callableDeclaredName(n);
+      if (callableName !== void 0) {
+        if (n.type !== "type_definition") ctx.declaredFunctions.add(callableName);
+        const scoped = nextFrame !== void 0 ? `${nextFrame}.${callableName}` : callableName;
+        ctx.localScopes.callableScoped.set(n.id, scoped);
+        nextFrameId = n.id;
+        nextFrame = scoped;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) visit(c, nextFrameId, nextFrame, nextOwner);
+      }
+    };
+    visit(root, -1, void 0, void 0);
+  }
+  /** The binders a where/with/let block declares, as name -> scoped identity. */
+  localBlockLocals(block, out, frameScoped) {
+    let map = null;
+    const consider = (defNode) => {
+      const nm = this.callableDeclaredName(defNode);
+      if (!nm) return;
+      const scoped = frameScoped !== void 0 ? `${frameScoped}.${nm}` : nm;
+      out.callableScoped.set(defNode.id, scoped);
+      if (!map) map = /* @__PURE__ */ new Map();
+      map.set(nm, scoped);
+    };
+    for (let i = 0; i < block.namedChildCount; i++) {
+      const c = block.namedChild(i);
+      if (!c) continue;
+      if (c.type === "local_binding" || c.type === "record_binding") {
+        const inner = c.namedChild(0);
+        if (inner) consider(inner);
+        continue;
+      }
+      if (c.type === "let_group") {
+        for (const pat of this.fields(c, "pattern")) consider(pat);
+        continue;
+      }
+      consider(c);
+    }
+    return map;
+  }
+  /** Read one `type_signature` into a `SignatureInfo`. */
+  readSignature(node, ctx) {
+    const info = {
+      node,
+      paramTypes: [],
+      genericVars: /* @__PURE__ */ new Set(),
+      typeRefs: [],
+      contextClasses: [],
+      specialTypes: [],
+      hasCodeBody: false
+    };
+    const typeNode = node.childForFieldName("type");
+    if (typeNode) this.readFunctionType(typeNode, info, ctx);
+    const context = node.childForFieldName("context");
+    if (context) this.readClassContext(context, info);
+    const special = this.findChild(node, (n) => n.type === "special_block");
+    if (special) {
+      for (let i = 0; i < special.namedChildCount; i++) {
+        const m = special.namedChild(i);
+        if (!m || m.type !== "special_member") continue;
+        const t = m.childForFieldName("type");
+        if (t) for (const ref of this.typeRefsIn(t, ctx)) info.specialTypes.push(ref.name);
+      }
+    }
+    if (node.childForFieldName("body")) info.hasCodeBody = true;
+    const fixity = node.childForFieldName("fixity");
+    if (fixity) {
+      info.fixity = {
+        associativity: fixity.namedChild(0)?.text,
+        precedence: fixity.namedChild(1)?.text
+      };
+    }
+    return info;
+  }
+  /**
+   * `[domain, arrow, result]` from a `type_function`, or a bare type when the
+   * signature is not a function type at all (`f :: Int`).
+   */
+  readFunctionType(typeNode, info, ctx) {
+    if (typeNode.type !== "type_function") {
+      info.returnType = typeNode.text;
+      this.collectTypeRefs(typeNode, info, ctx, /* @__PURE__ */ new Set());
+      return;
+    }
+    const domain = typeNode.child(0);
+    const result = typeNode.child(2);
+    if (result) {
+      info.returnType = result.text;
+      this.collectTypeRefs(result, info, ctx, /* @__PURE__ */ new Set());
+    }
+    if (!domain) return;
+    if (domain.type === "type_application") {
+      for (let i = 0; i < domain.namedChildCount; i++) {
+        const arg = domain.namedChild(i);
+        if (!arg) continue;
+        info.paramTypes.push(arg.text);
+        this.collectTypeRefs(arg, info, ctx, /* @__PURE__ */ new Set());
+      }
+    } else {
+      info.paramTypes.push(domain.text);
+      this.collectTypeRefs(domain, info, ctx, /* @__PURE__ */ new Set());
+    }
+  }
+  /**
+   * The class names a `|` context constrains on, split at the `,` and `&` CHILD
+   * nodes. Measured: `class_context` is `|` followed by a flat constraint list —
+   * `| Enum, Ord, Num a` is ONE node with three named children and two `,`
+   * tokens — so the split is a child walk, not a text split.
+   *
+   * **`&` is a second spelling of `,` and was not read.** The two forms produce
+   * the SAME child shape with a different separator token, so this is the
+   * two-spellings-one-handler case, not two constructs:
+   *
+   *     | == a          -> !| operator_compare type_variable
+   *     | == a & UList a -> !| operator_compare type_variable !& constructor type_variable
+   *
+   * (`clean-stdlib/StdOverloadedList.dcl:5,8`.) Reading only `,` published the
+   * first conjunct and dropped the second. Measured over the corpus
+   * (`validation/m14/fixtures/clean/ampersand-context-probe.mts`): 1,995
+   * `class_context` nodes at WIDE carry only the three unnamed child types `|`,
+   * `,` and `&`; 365 contain an `&`; and the conjuncts a `,`-only reader dropped
+   * split **249 that would ADD a row** against **264 that would name a class
+   * already published on that same line** — `| toReal a & toReal b & toReal c`
+   * (Clyde/Clyde/timeprofile.icl:337) is the shape, and at TRACKED the split is
+   * 62 against 47.
+   *
+   * The 264 are NOT a doubling, and the reason is `pushRel`'s own key rather than
+   * a judgement made here: it collapses on `source|type|target|line`, so a repeated
+   * conjunct cannot produce a second identical edge on one line. Measured as an A/B
+   * on the TRACKED population, reverting only the `&` in this line
+   * (`validation/m14/fixtures/clean/references-duplicate-probe.mts`):
+   *
+   *                references edges   distinct (source,target,line)   groups with >1
+   *     `,` only            10,049                    9,570                      387
+   *     `,` and `&`         10,108                    9,629                      387
+   *
+   * Both columns of the third are identical, per discriminator, so the fix adds 59
+   * edges and 59 NEW groups and changes the duplicate count by zero. The previous
+   * round declined to ship this fix precisely because it could not show that, and
+   * named the duplicate-vs-multiplicity question as the blocker; the question is
+   * answered by a key that was already in the file. `249` is the WIDE count of rows
+   * this adds, not a measured edge delta — WIDE is not re-measurable on this
+   * machine, so only the TRACKED `+59` is a measurement of the output.
+   *
+   * `&&` is NOT handled: it is 0 of the 1,995 contexts, and handling an unobserved
+   * token would be a claim no measurement supports.
+   *
+   * A constraint that names no class publishes nothing and emits no edge: 5 of
+   * the 474 contexts in the corpus are `*` (a `uniqueness_star` leaf — the
+   * unboxedness constraint `| * , toInt a`), and 469 name a class that does.
+   */
+  readClassContext(context, info) {
+    let expectName = true;
+    for (let i = 0; i < context.childCount; i++) {
+      const c = context.child(i);
+      if (!c) continue;
+      if (!c.isNamed) {
+        if (c.type === "," || c.type === "&") expectName = true;
+        continue;
+      }
+      if (!expectName) continue;
+      expectName = false;
+      const name = this.constraintName(c);
+      if (name) info.contextClasses.push(name);
+    }
+  }
+  /**
+   * The class a single constraint names, or null when it names none. The
+   * constraint node is a class name (`constructor` / `identifier`) or an operator
+   * class (`operator_compare` for `==`, `operator_add` for `<+>`, …) — 287
+   * constructors, 69 identifiers, 32 `operator_compare`, 10 `operator_add`, 2
+   * `operator_mul`, 5 unnamed `*`.
+   */
+  constraintName(c) {
+    if (c.type === "constructor" || c.type === "identifier") return c.text;
+    if (OPERATOR_LEAF_TYPES.has(c.type)) return c.text;
+    return null;
+  }
+  /**
+   * Every TYPE NAME a type expression mentions, with type variables filtered out.
+   * This is Clean's version of the TypeScript lane's `extractDeclaredTypeRefs`
+   * (real-typescript-analyzer.ts:3144) and the single largest source of
+   * relationships the lane did not have: 9,660 `strict_type` and 3,191
+   * `type_application` sites over the corpus, every one of which names at least
+   * one type.
+   *
+   * A `type_variable` is a BINDING, not a reference: `swap :: a a -> a` names no
+   * type and binds two. That distinction is what makes `genericParameters`
+   * correct and keeps `a` out of the reference graph.
+   *
+   * A module-qualified type is the one shape that needs context: `M.Map String
+   * User` lexes as `constructor M`, `dotted_type .Map`, then the arguments, so
+   * `M` is only a qualifier because it is a DECLARED IMPORT ALIAS of this file.
+   * That is why `ctx` is in scope here: an alias set is a fact about the file,
+   * and a qualifier is read from the alias set, not guessed from the spelling.
+   */
+  collectTypeRefs(n, info, ctx, bound) {
+    switch (n.type) {
+      case "type_variable": {
+        const inner = n.namedChild(0);
+        if (inner?.text) {
+          bound.add(inner.text);
+          info.genericVars.add(inner.text);
+        }
+        return;
+      }
+      case "unique_var_type": {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (!c) continue;
+          if (c.type === "type_variable") {
+            const inner = c.namedChild(0);
+            if (inner?.text) {
+              bound.add(inner.text);
+              info.genericVars.add(inner.text);
+            }
+          } else if (c.startIndex > n.startIndex) {
+            this.collectTypeRefs(c, info, ctx, bound);
+          }
+        }
+        return;
+      }
+      case "constructor": {
+        this.addTypeRef(info, n.text, n);
+        return;
+      }
+      case "single_quoted_name": {
+        const target = this.qualifiedTarget(n.text);
+        if (target) this.addTypeRef(info, target, n);
+        return;
+      }
+      case "dotted_type": {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) this.collectTypeRefs(c, info, ctx, bound);
+        }
+        return;
+      }
+      case "type_paren":
+      case "strict_type":
+      case "uniqueness_type":
+      case "list_type":
+      case "array_type":
+      case "tuple_type":
+      case "question_type":
+      case "builtin_question_type":
+      case "type_application": {
+        const head = n.namedChild(0);
+        if (head && head.type === "constructor" && ctx.importAliases.has(head.text)) {
+          const second = n.namedChild(1);
+          if (second) {
+            const leafText = second.type === "dotted_type" ? stripLeadingDot(second.text) : second.text;
+            if (leafText && second.type !== "type_variable") {
+              this.addTypeRef(info, `${head.text}.${leafText}`, second);
+            }
+            for (let i = 2; i < n.namedChildCount; i++) {
+              const c = n.namedChild(i);
+              if (c) this.collectTypeRefs(c, info, ctx, bound);
+            }
+            return;
+          }
+        }
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) this.collectTypeRefs(c, info, ctx, bound);
+        }
+        return;
+      }
+      default: {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) this.collectTypeRefs(c, info, ctx, bound);
+        }
+        return;
+      }
+    }
+  }
+  addTypeRef(info, name, node) {
+    if (info.typeRefs.some((r) => r.name === name)) return;
+    info.typeRefs.push({ name, node });
+  }
+  /**
+   * Every bare type name a type expression mentions, with the node that spells
+   * it. One reader (`collectTypeRefs`) and one rule, so the field path and the
+   * signature path cannot drift — the drift is exactly what FIX B measured.
+   */
+  typeRefsIn(typeNode, ctx) {
+    const info = {
+      node: typeNode,
+      paramTypes: [],
+      genericVars: /* @__PURE__ */ new Set(),
+      typeRefs: [],
+      contextClasses: [],
+      specialTypes: [],
+      hasCodeBody: false
+    };
+    this.collectTypeRefs(typeNode, info, ctx, /* @__PURE__ */ new Set());
+    return info.typeRefs;
+  }
+  /** Every constructor named anywhere inside a type expression. */
+  addTypeMention(n, ctx) {
+    if (n.type === "type_variable") return;
+    if (n.type === "constructor") {
+      ctx.declaredTypeNames.add(n.text);
+      return;
+    }
+    if (n.type === "dotted_type") {
+      const inner = n.namedChild(0);
+      if (inner?.type === "constructor") ctx.declaredTypeNames.add(inner.text);
+      return;
+    }
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const c = n.namedChild(i);
+      if (c) this.addTypeMention(c, ctx);
+    }
+  }
+  /** The declared name of a callable node, or undefined when it declares none. */
+  callableDeclaredName(node) {
+    const declared = this.rawCallableDeclaredName(node);
+    return isReservedDeclarationName(declared) ? void 0 : declared;
+  }
+  rawCallableDeclaredName(node) {
+    switch (node.type) {
+      case "function_declaration":
+        return this.declaredName(node)?.text ?? void 0;
+      case "operator_definition":
+        return this.operatorDefinitionName(node) ?? void 0;
+      case "generic_case_definition":
+        return node.childForFieldName("name")?.text ?? void 0;
+      case "type_signature":
+        return this.declarationName(node) ?? void 0;
+      case "macro_definition":
+        return this.normalizeParenthesized(node.childForFieldName("name")) ?? void 0;
+      case "type_definition":
+        return node.childForFieldName("name")?.text ?? void 0;
+      default:
+        return void 0;
+    }
+  }
+  /**
+   * A declaration the pinned grammar produced for TEXT THAT IS NOT A DECLARATION: its
+   * declared name is a RESERVED WORD, re-lexed as an identifier by recovery (a `where`
+   * opening a block in an already-damaged region becomes a top-level
+   * `function_declaration` named `where`). The node is not a function — but its NAME is
+   * a name the file writes at a declaration head, and F14's C1 (M60-C) requires every
+   * declared name to be published somewhere in its file.
+   *
+   * THE ROW IS SURFACED, THE FRAME IS NOT. `visibility: "local"` keeps it out of the
+   * export surface (`emitExports` skips local rows) and out of the module-qualified
+   * identity (`qualifyModuleLevelSymbols` skips them), while `metadata.parseDamage`
+   * says what the row is. Returning no `FrameSpec` is the load-bearing half: attributing
+   * the applications BENEATH such a node to it is the `instantiates -> where -> XOffs`
+   * fabrication the reserved-name decline existed for, and this change does not weaken
+   * that rule — it only stops the NAME from being dropped along with the frame.
+   *
+   * Deliberately NOT indexed in `functionSymbolIndex`: a later real definition of the
+   * same name must not merge into a damage row.
+   */
+  publishParseDamageSymbol(node, name, ctx, currentScope) {
+    const isLocal = this.isLocalScope(currentScope);
+    ctx.symbols.push({
+      name,
+      kind: this.callableKind(currentScope, isLocal),
+      range: this.nodeToRange(node),
+      scope: currentScope?.name,
+      ownerName: isLocal ? this.localOwner(ctx) : currentScope?.name || ctx.currentModule,
+      ownerKind: isLocal ? ASTEngine.SymbolKind.Function : currentScope?.kind,
+      visibility: "local",
+      metadata: { cleanSpecific: true, parseDamage: true, isReservedDeclarationName: true }
+    });
+  }
+  /**
+   * The row a callable DEFINITION may merge into, or `undefined` when it must publish
+   * one of its own.
+   *
+   * `declarationKey` is shared on purpose by the three merges that are real —
+   * signature↔definition, clause↔clause, `foreign export`↔definition — so the KEY
+   * cannot be what discriminates them; the KIND can. A MACRO is a different entity
+   * from a callable definition even when the two spell the same name.
+   *
+   * MEASURED (F14 C1, `Clyde/cleantools/Pm/PmParse.icl`): the file defines the macro
+   * `Special c :== …` at 1222, and the pinned grammar lifts a case alternative to a
+   * top-level `function_declaration` named `Special` at 1333. The keyed merge treated
+   * the second as a second clause of the macro and published only the macro row, so
+   * the declaration's name was never published at all. That is a RULE defect — a
+   * `function_declaration` may not merge into a macro row — not a name to suppress.
+   */
+  callableMergeIndex(key, ctx) {
+    const idx = ctx.functionSymbolIndex[key];
+    if (idx === void 0) return void 0;
+    return ctx.symbols[idx]?.kind === ASTEngine.SymbolKind.Macro ? void 0 : idx;
+  }
+  // ============================================================================
+  // PASS 2 — declaration handlers
+  // ============================================================================
+  enterModule(node, ctx, scopeStack) {
+    const nameNode = node.childForFieldName("name");
+    const name = nameNode ? this.assembleModuleName(nameNode) : ctx.currentModule;
+    if (!name) return false;
+    ctx.currentModule = name;
+    let moduleKind = "module";
+    const first = node.child(0);
+    if (first && !first.isNamed && (first.type === "definition" || first.type === "implementation")) {
+      moduleKind = first.type;
+    }
+    ctx.symbols.push({
+      name,
+      kind: ASTEngine.SymbolKind.Module,
+      range: this.nodeToRange(node),
+      visibility: "public",
+      metadata: { cleanSpecific: true, moduleKind }
+    });
+    scopeStack.push({ node, name, kind: ASTEngine.SymbolKind.Module });
+    return true;
+  }
+  /**
+   * A type declaration. The pinned grammar has ONE node type for all six Clean
+   * type forms, distinguished by the `type_definition_body.rhs` node type:
+   * synonym (`:==`), abstract (no rhs), record (`= {…}`), ADT (`= C | D`),
+   * enumerated (`= A | B`) and quantified ADT (`= E a | C !a`). Measured on the
+   * 503 `type_definition_body` sites: 255 `data_constructors`, 114
+   * `record_definition`, 49 `type_application`, 3 `tuple_type`, 6 `array_type`,
+   * 3 `list_type`, 1 `type_paren`, 1 `unit_type` and 71 bare `constructor`
+   * (synonym / enumerated).
+   */
+  /**
+   * Is this `type_definition` the PARSER'S RECOVERY OF A SIGNATURE rather than a
+   * declaration? A Clean signature such as `widByPtr :: !WID -> Bool` is not a
+   * `type_signature` to the pinned grammar: it comes back as a `type_definition` with no
+   * `body`, no `rhs`, a `name` field holding the FIRST ARGUMENT TYPE, and text that stops
+   * there (`:: !WID`). Publishing that row puts a fabricated `type` in the symbol set and
+   * makes every edge that mentions the argument type point at it.
+   *
+   * MEASURED over the 2,179-file WIDE manifest (`validation/m14/measurements/clean/
+   * type-definition-recovery-2179.txt`, regenerable with
+   * `npx tsx .tmp-probe/tdef-rule.mts`), production wasm, node shapes only:
+   *
+   *   type_definition with a body or rhs      3,930
+   *   with NEITHER                               447   (10.21% of all type_definitions)
+   *
+   * Of the 447, 74 carry a uniqueness marker (`!`, `#`) or an `ERROR` as the child
+   * immediately after the `::`, and reading all 74 sites shows every one of them is a
+   * signature. The other 373 are real declarations the rule must not touch: 293 `:: ErrPrefs`
+   * (an abstract type in a `.dcl`), 32 `:: Conversions a`, 25 `:: *TTY` (an abstract unique
+   * class) and 23 with a trailing `;` or a body the grammar filed under `uniqueness_type`.
+   *
+   * 74 IS NOT THE WITHDRAWABLE SET, and the reason is the trap this function exists to
+   * avoid. `eastwood/test/suite-default/GoToModule1.dcl:89` is `:: !*AbstractTypeSynonym`
+   * and `:92` is `:: !*EastwoodAbstractNewType` — two REAL declarations whose child shape
+   * `[:: ! ERROR constructor]` is byte-identical to the phantom at
+   * `Libraries/Hilde/FamkeConcurrentClean.dcl:8` (`:: !(*World`). No node-INTERNAL rule
+   * separates them; every child, field and name is the same. So the discriminator is
+   * POSITIONAL and uses node positions only: a signature's `::` follows the callable's name
+   * on the same row, a definition's `::` begins its own row. Measured on the same
+   * population, that withdraws 72 and keeps exactly those 2.
+   *
+   * NO TEXT AND NO REGEX. The test is whether the nearest preceding NAMED sibling ENDS on
+   * this node's start row, so no string can be mistaken for a construct and no file-path
+   * convention can stand in for one.
+   */
+  isSignatureRecoveryTypeDefinition(node) {
+    if (node.childForFieldName("body") || node.childForFieldName("rhs")) return false;
+    let afterColonColon = "";
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (!c || c.type !== "::") continue;
+      const next = node.child(i + 1);
+      if (next) afterColonColon = next.type;
+      break;
+    }
+    if (afterColonColon !== "!" && afterColonColon !== "#" && afterColonColon !== "ERROR") return false;
+    const parent = node.parent;
+    if (!parent) return false;
+    let index = -1;
+    for (let i = 0; i < parent.childCount; i++) {
+      const c = parent.child(i);
+      if (c && c.id === node.id) {
+        index = i;
+        break;
+      }
+    }
+    if (index < 0) return false;
+    for (let i = index - 1; i >= 0; i--) {
+      const sibling = parent.child(i);
+      if (!sibling || !sibling.isNamed) continue;
+      return sibling.endPosition.row === node.startPosition.row;
+    }
+    return false;
+  }
+  processTypeDefinition(node, ctx, scopeStack) {
+    if (this.isSignatureRecoveryTypeDefinition(node)) return false;
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode?.text) return false;
+    const name = nameNode.text;
+    const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+    const body = node.childForFieldName("body");
+    const rhs = body ? body.childForFieldName("rhs") ?? body : node.childForFieldName("rhs");
+    const form = this.typeForm(rhs);
+    const genericParameters = [];
+    for (const p of this.fields(node, "parameter")) {
+      const inner = p.namedChild(0);
+      if (inner?.text) genericParameters.push(inner.text);
+    }
+    if (body) {
+      for (const e of this.fields(body, "existential")) {
+        const inner = e.namedChild(0);
+        if (inner?.text) genericParameters.push(`!${inner.text}`);
+      }
+    }
+    ctx.symbols.push({
+      name,
+      kind: ASTEngine.SymbolKind.Type,
+      range: this.nodeToRange(node),
+      scope: currentScope?.name,
+      ownerName: currentScope?.name || ctx.currentModule,
+      ownerKind: currentScope?.kind,
+      visibility: "public",
+      genericParameters: genericParameters.length > 0 ? genericParameters : void 0,
+      metadata: { cleanSpecific: true, typeForm: form }
+    });
+    this.attachComments(ctx.symbols[ctx.symbols.length - 1], node);
+    if (rhs && rhs.type !== "data_constructors" && rhs.type !== "record_definition") {
+      this.emitTypeRefs(rhs, name, "type_alias_rhs", ctx);
+    }
+    for (const cNode of this.dataConstructorsOf(rhs)) {
+      const cName = cNode.childForFieldName("name");
+      if (!cName?.text) continue;
+      ctx.symbols.push({
+        name: cName.text,
+        kind: ASTEngine.SymbolKind.Constructor,
+        range: this.nodeToRange(cNode),
+        scope: name,
+        ownerName: name,
+        ownerKind: ASTEngine.SymbolKind.Type,
+        visibility: "public",
+        metadata: { cleanSpecific: true, isADTConstructor: true }
+      });
+      this.attachComments(ctx.symbols[ctx.symbols.length - 1], cNode);
+      for (const arg of this.fields(cNode, "argument")) {
+        this.emitTypeRefs(arg, cName.text, "data_constructor_arg", ctx);
+      }
+    }
+    const recordDef = rhs && rhs.type === "record_definition" ? rhs : body ? this.findChild(body, (n) => n.type === "record_definition") : null;
+    if (recordDef) {
+      for (let i = 0; i < recordDef.namedChildCount; i++) {
+        const rf = recordDef.namedChild(i);
+        if (!rf || rf.type !== "record_field") continue;
+        const fieldId = rf.childForFieldName("name");
+        if (!fieldId?.text) continue;
+        ctx.symbols.push({
+          name: fieldId.text,
+          kind: ASTEngine.SymbolKind.Property,
+          range: this.nodeToRange(rf),
+          scope: name,
+          ownerName: name,
+          ownerKind: ASTEngine.SymbolKind.Type,
+          visibility: "public",
+          metadata: { cleanSpecific: true, isRecordField: true }
+        });
+        this.attachComments(ctx.symbols[ctx.symbols.length - 1], rf);
+        const ft = rf.childForFieldName("type");
+        if (ft) this.emitTypeRefs(ft, fieldId.text, "record_field_type", ctx);
+      }
+    }
+    scopeStack.push({ node, name, kind: ASTEngine.SymbolKind.Type });
+    return true;
+  }
+  /** The `data_constructor` children of a type's rhs, however it is nested. */
+  dataConstructorsOf(rhs) {
+    if (!rhs) return [];
+    if (rhs.type === "data_constructors") return this.filterChildren(rhs, (n) => n.type === "data_constructor");
+    return this.filterChildren(rhs, (n) => n.type === "data_constructor");
+  }
+  /** Which of Clean's six type forms a `rhs` node type denotes. */
+  typeForm(rhs) {
+    if (!rhs) return "abstract";
+    switch (rhs.type) {
+      case "data_constructors":
+        return "adt";
+      case "record_definition":
+        return "record";
+      case "constructor":
+        return "enumerated";
+      default:
+        return "synonym";
+    }
+  }
+  /**
+   * A class declaration: `class C a | D a where …`.
+   *
+   * Two things the old version did not do. (1) It read the name with
+   * `findChild(node, n => n.type === "class_name")` instead of the `name` field;
+   * the field is exact and the scan is a guess. (2) It published members by
+   * scanning `class_member` children for a `type_signature` and then `continue`d
+   * on every `type_signature` in the walk — so a class member's `special` block
+   * (90 sites) and inline `code` body (74 sites) were never visited, and a class
+   * member that is a `function_declaration` rather than a signature published
+   * nothing. Members now run through the same handlers as everything else, with
+   * the class on the scope stack.
+   */
+  processClass(node, ctx, scopeStack) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode?.text) return false;
+    const name = nameNode.text;
+    const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+    const genericParameters = [];
+    for (const p of this.fields(node, "parameter")) {
+      const inner = p.namedChild(0);
+      if (inner?.text) genericParameters.push(inner.text);
+    }
+    ctx.symbols.push({
+      name,
+      kind: ASTEngine.SymbolKind.Interface,
+      range: this.nodeToRange(node),
+      scope: currentScope?.name,
+      ownerName: currentScope?.name || ctx.currentModule,
+      ownerKind: currentScope?.kind,
+      visibility: "public",
+      genericParameters: genericParameters.length > 0 ? genericParameters : void 0,
+      metadata: { cleanSpecific: true, isTypeClass: true }
+    });
+    this.attachComments(ctx.symbols[ctx.symbols.length - 1], node);
+    const context = node.childForFieldName("context");
+    if (context) this.emitContextRefs(context, name, "class_context", ctx);
+    if (node.childForFieldName("type")) ctx.patterns["Algebraic Type Classes"] = true;
+    ctx.patterns["Type Classes"] = true;
+    scopeStack.push({ node, name, kind: ASTEngine.SymbolKind.Interface });
+    return true;
+  }
+  /**
+   * An instance declaration: `instance C T where …`.
+   *
+   * THE 253-DEFECT. The old handler required a direct `constructor` child to name
+   * the target type. Measured over the corpus the `argument` FIELD is 782
+   * occurrences on 741 instances, and only 489 are a bare `constructor`; the other
+   * 293 are `array_type` 127 (`instance Array {} a`), `list_type` 97
+   * (`instance toString [a]`), `type_variable` 32, `type_paren` 16,
+   * `question_type` 9, `tuple_type` 8 and `unit_type` 4. On those 253
+   * declarations (51 files) the scan found nothing and the instance was skipped
+   * whole — no Class symbol, no `implements` edge, no member scope, and every
+   * `instance_member` inside it (1,009 members corpus-wide) left ownerless or
+   * attributed to the module. The field is exact.
+   *
+   * Reading the field is not sufficient on its own, though: the argument list is
+   * `constraint* Type`, so the TYPE is the LAST argument that names one, and a
+   * bare uniqueness constraint names none. Taking the first argument named every
+   * constrained instance after its constraint — `instance Array {#} Int` as
+   * `{#} -> Array` — which is most of Clean's own StdEnv. See
+   * `instanceTargetName`.
+   */
+  processInstance(node, ctx, scopeStack) {
+    const classNode = node.childForFieldName("name");
+    if (!classNode?.text) return false;
+    const className = classNode.text;
+    const args = this.fields(node, "argument");
+    const typeArgs = args.filter((a) => this.instanceTargetName(a) !== null);
+    const targetNames = [];
+    for (const a of args) {
+      const t = this.instanceTargetName(a);
+      if (t) targetNames.push(t);
+    }
+    const targetType = typeArgs.length > 0 ? this.instanceTargetName(typeArgs[typeArgs.length - 1]) : null;
+    if (!targetType) return false;
+    const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+    const targetIsPolymorphic = typeArgs[typeArgs.length - 1]?.type === "type_variable";
+    if (!targetIsPolymorphic) {
+      ctx.symbols.push({
+        // THE IMPLEMENTATION IS NAMESPACED UNDER ITS TARGET. It used to be named EXACTLY the
+        // target type, and on a per-file analyzer that is a PHANTOM DECLARATION: a file whose
+        // only statement about `Int` is `instance Show Int` published a `class` symbol named
+        // `Int`, which counts as a declaration of `Int` in the project's name space and therefore
+        // turns every `references -> Int` edge elsewhere into an ambiguity. Measured on the
+        // 312-file population (`validation/m14/fixtures/clean/phantom-census.mts`): **699 such
+        // containers in 94 files, 93 of them named after a type the SAME file also declares for
+        // real, 150 of them not an identifier at all** (`.a`, `[a]`, `?` — instance heads that
+        // are type EXPRESSIONS, so the name could never match any reference in the first place).
+        // Deleting them alone reaches **1,009 of the lane's 6,856 residual edges (14.7%)** —
+        // 574 `references` whose target has no real declaration in the project at all, 366 whose
+        // target has exactly one real declaration beside the phantoms (those RESOLVE once the
+        // phantom stops counting), and 69 `exports` that were never exports.
+        //
+        // The naming is the RUST lane's (`impl Foo` publishes `Foo::impl`, so the implementation
+        // is addressable without claiming Foo is declared here), and the reason is the same: an
+        // instance is a DECLARATION OF AN IMPLEMENTATION, not of its target type. What made this
+        // lane worse than Rust's is that Clean's instance heads are usually types from StdEnv
+        // (`Int`, `Char`, `Real`, `Bool` — the five most common container names), so the phantom
+        // landed on exactly the names the language uses most.
+        //
+        // THE MEMBERS KEEP THE NOMINAL OWNER (`frameOwner` below), which is what keeps this fix
+        // surgical: `contains` still reads `Int -> show`, `overrides` still reads `Int.show ->
+        // Show.show`, and the member's `qualifiedName` is unchanged — every observable edge
+        // surface is identical to before, and the ONLY difference is that the file no longer
+        // declares `Int`. Moving the owner as well would rename 2,000+ edges to fix a declaration
+        // count, which is the wrong trade: the endpoint of a `contains` edge is the name a reader
+        // navigates to, and `Int.show` is what Clean itself calls that member.
+        name: `${targetType}${INSTANCE_CONTAINER_SUFFIX}`,
+        // `impl`, not `class`: `class` is an EXPORTABLE kind, so the container became a module
+        // export — `Prelude/Data/List.dcl` exported `[]` and `.a` because it holds instances whose
+        // heads are those type expressions (69 measured `exports` rows, all of them naming a
+        // phantom). An instance is not part of a module's interface.
+        kind: ASTEngine.SymbolKind.Impl,
+        range: this.nodeToRange(node),
+        scope: currentScope?.name,
+        ownerName: currentScope?.name || ctx.currentModule,
+        ownerKind: currentScope?.kind,
+        visibility: "public",
+        metadata: {
+          cleanSpecific: true,
+          className,
+          targetType,
+          targetTypes: targetNames,
+          // The instance's target as the SOURCE spells it (`List a`), kept beside the nameable
+          // identity (`List`) so a reader can see which instance this is when one type has
+          // several — the identity is what resolves, the spelling is what distinguishes.
+          targetSpelling: typeArgs[typeArgs.length - 1]?.text,
+          isTypeClassInstance: true,
+          // The container's name is DERIVED (`<target>::instance`), so the target it was derived
+          // from travels with it: a consumer reading `Int::instance` should not have to strip a
+          // suffix to learn which type the instance is for, and the pair must not drift apart.
+          instanceTarget: targetType
+        }
+      });
+      this.attachComments(ctx.symbols[ctx.symbols.length - 1], node);
+    }
+    this.pushRel(
+      ctx,
+      targetType,
+      className,
+      ASTEngine.RelationshipType.Implements,
+      1,
+      {
+        cleanSpecific: true,
+        isInstance: true,
+        className,
+        // Almost every class is imported (`instance Eq Int` names StdEnv's `Eq`),
+        // so the flag records the normal case explicitly instead of leaving the
+        // reader to infer it from a missing symbol.
+        //
+        // The second spelling is the operator case, and it is not cosmetic: a class
+        // DECLARATION spells an operator-named class parenthesised (`class (==) infix 4 a ::`,
+        // clean-stdlib/StdOverloaded.icl:23) while the INSTANCE spells it bare
+        // (`instance == Bool`, clean-stdlib/StdBool.dcl:10). `declaredTypeNames` therefore
+        // holds `(==)` and the lookup below held only `==`, so 24 `implements` edges on
+        // the 312-file corpus carried `isExternalClass: true` for a class declared in the
+        // SAME file — a false statement in the one field whose whole job is to say which
+        // of the two it is. `classMembers` gets the same treatment where `overrides` reads it.
+        isExternalClass: !ctx.declaredTypeNames.has(className) && !this.isLocallyDeclaredOperatorClass(ctx, className),
+        // The instance's target is a type VARIABLE, so the instance is polymorphic:
+        // it publishes no symbol (see above) and this flag says why the edge has no
+        // symbol at its source.
+        isPolymorphicInstance: targetIsPolymorphic || void 0
+      },
+      this.lineOf(classNode)
+    );
+    for (let i = 1; i < args.length; i++) this.emitTypeRefs(args[i], targetType, "instance_target", ctx);
+    const context = node.childForFieldName("context");
+    if (context) this.emitContextRefs(context, targetType, "instance_context", ctx);
+    if (node.childForFieldName("type")) ctx.patterns["Qualified Instances"] = true;
+    if (node.childForFieldName("body")) ctx.patterns["Inline Machine Code"] = true;
+    ctx.patterns["Type Classes"] = true;
+    const frameOwner = !targetIsPolymorphic ? targetType : ctx.declaredClassNames.has(className) ? className : ctx.currentModule ?? className;
+    const classMem = ctx.classMembers.get(className);
+    if (classMem && classMem.size > 0) {
+      if (frameOwner !== className) {
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const m = node.namedChild(i);
+          if (m?.type !== "instance_member") continue;
+          const memberName = this.memberDeclaredName(m);
+          if (!memberName || !classMem.has(memberName)) continue;
+          const nameNode = m.namedChild(0)?.childForFieldName("name") ?? m.namedChild(0);
+          this.pushRel(
+            ctx,
+            `${frameOwner}.${memberName}`,
+            `${className}.${memberName}`,
+            ASTEngine.RelationshipType.Overrides,
+            1,
+            { cleanSpecific: true, isTypeClassOverride: true, className, instanceType: frameOwner, member: memberName },
+            this.lineOf(nameNode)
+          );
+        }
+      }
+    }
+    scopeStack.push({
+      node,
+      name: frameOwner,
+      kind: ASTEngine.SymbolKind.Class
+    });
+    return true;
+  }
+  /**
+   * The TYPE an `argument` names, or null when the argument is a bare UNIQUENESS
+   * CONSTRAINT rather than a type.
+   *
+   * Clean's instance head is `instance Class constraint* Type`, and the grammar puts
+   * a constraint that applies to the WHOLE instance in the same `argument` field as
+   * the type, so the argument list is not all types:
+   *
+   *   instance Array {!} a         args = [ array_type({!}), type_variable(a) ]
+   *   instance Array {#} Int       args = [ array_type({#}), constructor(Int) ]
+   *   instance Array {#} {32#.a}  args = [ array_type({#}), array_type({32#.a}) ]
+   *   instance == {#Char}          args = [ array_type({#Char}) ]  <- ONE arg, and
+   *                                                                    it IS the type
+   *
+   * Taking the FIRST argument named every constrained instance after its
+   * CONSTRAINT: `instance Array {#} Int` became `{#} -> Array`, and
+   * `instance Array {32#} Int` became `32 -> Array` (the inner child of `{32#}`).
+   * That is the misnamed `implements` edge and instance symbol behind every
+   * constrained instance — the shape Clean's own StdEnv uses most, since `Array`
+   * alone has six. Taking the LAST argument fixes the head but still returns `32`
+   * for `{32#.a}`, because an `array_type` may hold a constraint LEVEL and a TYPE
+   * together.
+   *
+   * So the walk is STRUCTURAL: inside a `type_paren` / `array_type` /
+   * `uniqueness_type`, take the first named child that is not a constraint marker.
+   * `{!}` and `{#}` have no such child and are therefore constraints (null);
+   * `{#Char}` and `{32#.a}` have a `dotted_type` and are therefore types. The
+   * earlier version of this comment claimed the same thing via a text test on
+   * `{#…}`; the node shape says it outright, so there is no text inspection left.
+   */
+  instanceTargetName(arg) {
+    switch (arg.type) {
+      case "constructor":
+      case "type_function":
+      case "dotted_type":
+        return arg.text;
+      // A LIST OR TUPLE TYPE'S NAME HAS NO SPACES IN IT. `instance length [ !]`
+      // (clean-stdlib/StdOverloadedList.icl:142) is the strict list type constructor, and the
+      // source's own spacing inside the brackets is layout, not spelling: the type `[ !]` and the
+      // type `[!]` are the same type and Clean's own declaration writes `[!]`. Leaving the space in
+      // gave the instance's members a `contains` source and an `implements` target that no symbol
+      // can match. Measured: 3 edges on the 312-file population, and 0 after the normalization.
+      case "tuple_type":
+      case "list_type":
+        return stripWhitespace(arg.text) || arg.text;
+      case "type_application": {
+        const head = arg.namedChild(0);
+        if (!head) return arg.text;
+        const headName = this.instanceTargetName(head);
+        if (!headName) return arg.text;
+        return this.unparenthesize(headName) ?? headName;
+      }
+      case "question_type": {
+        const head = arg.namedChild(0);
+        return head?.text || arg.text;
+      }
+      case "type_variable":
+        return arg.namedChild(0)?.text ?? arg.text;
+      case "type_paren":
+      case "array_type":
+      case "uniqueness_type":
+      case "unique_var_type": {
+        for (let i = 0; i < arg.namedChildCount; i++) {
+          const inner = arg.namedChild(i);
+          if (!inner || CONSTRAINT_MARKER_TYPES.has(inner.type)) continue;
+          const name = this.instanceTargetName(inner);
+          if (name) return name;
+        }
+        return null;
+      }
+      default:
+        return arg.text;
+    }
+  }
+  /**
+   * A Clean generic: `generic bimap a b | bimap b a :: .a -> .b`.
+   *
+   * A generic is a class over TYPES rather than values — Clean's type-level
+   * dispatch, the machinery behind the "HACK: dictionaries for all generics"
+   * comment in `StdGeneric.dcl`. It is therefore an `Interface` with generic
+   * parameters, and the `| bimap b a` context is a requirement on the generic
+   * itself, emitted as a `references` edge like any other context. 11
+   * declarations corpus-wide.
+   */
+  processGenericDeclaration(node, ctx, currentScope) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode?.text) return;
+    const name = nameNode.text;
+    const genericParameters = [];
+    for (const p of this.fields(node, "parameter")) {
+      const inner = p.namedChild(0);
+      if (inner?.text) genericParameters.push(inner.text);
+    }
+    const contextArgs = [];
+    for (const p of this.fields(node, "context_arg")) {
+      const inner = p.namedChild(0);
+      if (inner?.text) contextArgs.push(inner.text);
+    }
+    const contextName = node.childForFieldName("context")?.text;
+    ctx.symbols.push({
+      name,
+      kind: ASTEngine.SymbolKind.Interface,
+      range: this.nodeToRange(node),
+      scope: currentScope?.name,
+      ownerName: currentScope?.name || ctx.currentModule,
+      ownerKind: currentScope?.kind,
+      visibility: "public",
+      genericParameters: genericParameters.length > 0 ? genericParameters : void 0,
+      metadata: {
+        cleanSpecific: true,
+        isGeneric: true,
+        genericContext: contextName,
+        genericContextArgs: contextArgs,
+        genericType: this.unnamedChildOfType(node, "type_function")?.text
+      }
+    });
+    this.attachComments(ctx.symbols[ctx.symbols.length - 1], node);
+    if (contextName && contextName !== name) {
+      this.pushRel(
+        ctx,
+        name,
+        contextName,
+        ASTEngine.RelationshipType.References,
+        0.95,
+        { cleanSpecific: true, relationshipType: "generic_context" },
+        this.lineOf(node.childForFieldName("context"))
+      );
+    }
+    ctx.patterns["Generics"] = true;
+  }
+  /**
+   * `derive bimap c` — the generic `bimap` is derived for the type `c`.
+   *
+   * The same shape as an instance: an implementation of a class at a type, so the
+   * edge is `implements` from the derived type to the generic, with the generic's
+   * own node as the name-bearing site line. 43 sites corpus-wide (all in
+   * `StdGeneric.dcl`), and every one published nothing before: the
+   * `derive_declaration` node type was named nowhere in the analyzer.
+   */
+  processDeriveDeclaration(node, ctx) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode?.text) return;
+    const genericName = nameNode.text;
+    let target = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c || c.startIndex === nameNode.startIndex) continue;
+      if (!DERIVE_TARGET_NODE_TYPES.has(c.type)) continue;
+      const spelled = c.type === "type_variable" ? c.namedChild(0)?.text ?? c.text : c.text;
+      if (!spelled || isReservedDeclarationName(spelled)) continue;
+      target = c;
+      break;
+    }
+    if (!target) return;
+    const targetName = target.type === "type_variable" ? target.namedChild(0)?.text ?? target.text : target.text;
+    if (!targetName) return;
+    this.pushRel(
+      ctx,
+      targetName,
+      genericName,
+      ASTEngine.RelationshipType.Implements,
+      1,
+      { cleanSpecific: true, isDerive: true, genericName },
+      this.lineOf(nameNode)
+    );
+    ctx.patterns["Generics"] = true;
+  }
+  /**
+   * A callable definition: `function_declaration`, `operator_definition` or
+   * `generic_case_definition`.
+   *
+   * The old code handled the first two and nothing else.
+   * `generic_case_definition` (52 sites) is the third shape Clean uses to define a
+   * callable — `bimap{|PAIR|} fx _ fy _ (PAIR x y) = …` — and the six `bimap{|…|}`
+   * case equations are ONE function, so they merge into one symbol with the case
+   * kinds recorded, exactly as multi-clause definitions merge.
+   */
+  /**
+   * The owner of a `where`/`with`/`let` binder.
+   *
+   * Normally the enclosing FRAME, which is what makes a local's identity scoped and
+   * its `contains` edge resolvable. But a local can be reached with no frame at all
+   * when the pinned grammar could not read the function it belongs to: a
+   * tuple-destructuring `where` binding — `(transition_nr, transition) =
+   * SelectTransition 0 head …` — is not in the grammar, so it becomes an ERROR node
+   * and everything after it inside that function sits inside the ERROR subtree,
+   * detached from the `function_declaration` that would have opened the frame.
+   *
+   * Measured on the 2,179-file corpus: 7 such locals — `left` and `right` in
+   * `ObjectIO/…/turing/tm.icl`, `key` and `keyIndex` in `Ed/EdKeyMapping.icl`,
+   * `toolBoxFun` and `okWindowKeyboardAtt` in `ObjectIO/…/keyboardevent.icl`, and
+   * `sp` in `Charlie.icl` — each found by the honesty gate as a symbol carrying an
+   * `ownerKind` with no `ownerName`.
+   *
+   * Falling back to the MODULE is the honest answer rather than a fudge: the binder
+   * really is declared in this file, and the module is the nearest owner that
+   * EXISTS. A symbol with no owner resolves to nothing, and the file-level count
+   * records that the enclosing function was lost to damage instead of pretending
+   * the local is module-level by design.
+   */
+  localOwner(ctx) {
+    if (ctx.currentFrame !== void 0) return ctx.currentFrame;
+    if (ctx.currentModule !== void 0) ctx.detachedLocals++;
+    return ctx.currentModule;
+  }
+  processCallableNode(node, ctx, currentScope, inErrorRegion = false) {
+    const declared = this.rawCallableDeclaredName(node);
+    if (!declared) return null;
+    if (isReservedDeclarationName(declared)) {
+      this.publishParseDamageSymbol(node, declared, ctx, currentScope);
+      return null;
+    }
+    const name = declared;
+    const isOperator = node.type === "operator_definition" || node.type === "generic_case_definition";
+    const isLocal = this.isLocalScope(currentScope);
+    const kind = this.callableKind(currentScope, isLocal);
+    const key = declarationKey(ctx.currentFrame, this.ownerIdentity(currentScope, ctx), name);
+    const existingIdx = this.callableMergeIndex(key, ctx);
+    if (existingIdx !== void 0) {
+      const existing = ctx.symbols[existingIdx];
+      const fromDeclaration = existing.metadata?.isDeclaration === true;
+      if (fromDeclaration || !existing.range) {
+        existing.range = this.nodeToRange(node);
+      } else {
+        const r = this.nodeToRange(node);
+        const prevEnd = existing.range.endLine ?? r.startLine;
+        const prevEndIndex = existing.range.endIndex ?? node.startIndex;
+        existing.range = {
+          ...existing.range,
+          endLine: Math.max(prevEnd, r.endLine),
+          endColumn: r.endLine > prevEnd ? r.endColumn : existing.range.endColumn ?? r.endColumn,
+          endIndex: Math.max(prevEndIndex, r.endIndex ?? prevEndIndex)
+        };
+      }
+      delete existing.metadata?.isDeclaration;
+      if (existing.isAbstract) existing.isAbstract = false;
+      this.mergeComments(existing, node);
+      const md2 = existing.metadata ?? (existing.metadata = {});
+      if (isOperator && !md2.isOperatorDefinition) md2.isOperatorDefinition = true;
+      if (node.type === "generic_case_definition") this.addCaseKind(md2, node);
+      this.joinParameters(existing, node, ctx, this.ownerIdentity(currentScope, ctx));
+      return { name, kind, isLocal, key };
+    }
+    const md = { cleanSpecific: true };
+    if (isOperator) md.isOperatorDefinition = true;
+    const scopedName = isLocal ? ctx.currentFrame === void 0 ? name : `${ctx.currentFrame}.${name}` : void 0;
+    if (scopedName) {
+      md.isLocalDefinition = true;
+      md.scopedName = scopedName;
+    }
+    if (node.type === "generic_case_definition") this.addCaseKind(md, node);
+    const sym = {
+      name,
+      kind,
+      range: this.nodeToRange(node),
+      scope: currentScope?.name,
+      // The store's `qualified_name`, which is what relationship endpoints are
+      // resolved against. A module-level symbol needs none: its name is already
+      // unique in the file, and the store falls back to `name`.
+      ...scopedName ? { qualifiedName: scopedName } : {},
+      ownerName: isLocal ? this.localOwner(ctx) : currentScope?.name || ctx.currentModule,
+      ownerKind: isLocal ? ASTEngine.SymbolKind.Function : currentScope?.kind,
+      // A callable reached only through an ERROR region has no knowable scope, so it
+      // is not part of the module's API and must not claim to be exported.
+      visibility: isLocal || inErrorRegion ? "local" : "public",
+      complexity: 1,
+      metadata: md
+    };
+    ctx.symbols.push(sym);
+    ctx.functionSymbolIndex[key] = ctx.symbols.length - 1;
+    this.joinParameters(sym, node, ctx, this.ownerIdentity(currentScope, ctx));
+    return { name, kind, isLocal, key };
+  }
+  addCaseKind(md, node) {
+    const kind = node.childForFieldName("kind")?.text;
+    if (!kind) return;
+    const kinds = md.caseKinds ?? (md.caseKinds = []);
+    if (!kinds.includes(kind)) kinds.push(kind);
+  }
+  /**
+   * A module-level macro: `NSWindowCloseButton :== 0`, `(FWI) f i :== fwritei i f`.
+   *
+   * 583 sites corpus-wide with the analyzer naming `macro_definition` nowhere, so
+   * every one published nothing AND every application inside a macro body
+   * attributed to whatever frame happened to be open. A macro is a
+   * `SymbolKind.Macro` (the kind exists for exactly this: Rust `macro_rules!`) and
+   * it is a frame, because a macro body is expanded at its use site and the calls
+   * in it are the module's calls.
+   */
+  processMacro(node, ctx, currentScope) {
+    const name = this.normalizeParenthesized(node.childForFieldName("name"));
+    if (!name) return null;
+    if (isReservedDeclarationName(name)) return null;
+    const isLocal = this.isLocalScope(currentScope);
+    const key = declarationKey(ctx.currentFrame, this.ownerIdentity(currentScope, ctx), name);
+    if (ctx.functionSymbolIndex[key] === void 0) {
+      const macroSym = {
+        name,
+        kind: ASTEngine.SymbolKind.Macro,
+        range: this.nodeToRange(node),
+        scope: currentScope?.name,
+        ownerName: isLocal ? this.localOwner(ctx) : currentScope?.name || ctx.currentModule,
+        ownerKind: isLocal ? ASTEngine.SymbolKind.Function : currentScope?.kind,
+        visibility: isLocal ? "local" : "public",
+        qualifiedName: isLocal ? ctx.currentFrame === void 0 ? name : `${ctx.currentFrame}.${name}` : void 0,
+        metadata: {
+          cleanSpecific: true,
+          isMacroDefinition: true,
+          isLocalDefinition: isLocal || void 0,
+          scopedName: isLocal ? ctx.currentFrame === void 0 ? name : `${ctx.currentFrame}.${name}` : void 0
+        }
+      };
+      this.attachComments(macroSym, node);
+      ctx.symbols.push(macroSym);
+      ctx.functionSymbolIndex[key] = ctx.symbols.length - 1;
+    }
+    ctx.patterns["Macros"] = true;
+    return { name, kind: ASTEngine.SymbolKind.Macro, isLocal, key };
+  }
+  /**
+   * `foreign export f` — a C function re-exported under Clean's calling
+   * convention. 41 sites corpus-wide, published nothing before. It is a real
+   * callable and an explicit export, so it is a `Function` symbol flagged
+   * `isForeignExport` and it enters the module's export surface.
+   */
+  processForeignExport(node, ctx, currentScope) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode?.text) return;
+    const name = nameNode.text;
+    ctx.patterns["Foreign Function Interface"] = true;
+    const line = this.lineOf(node);
+    const key = declarationKey(ctx.currentFrame, currentScope?.name, name);
+    const existingIdx = ctx.functionSymbolIndex[key];
+    if (existingIdx !== void 0) {
+      const existing = ctx.symbols[existingIdx];
+      const md = existing.metadata ?? (existing.metadata = {});
+      md.isForeignExport = true;
+      if (typeof md.foreignExportLine !== "number") md.foreignExportLine = line;
+      return;
+    }
+    ctx.symbols.push({
+      name,
+      kind: ASTEngine.SymbolKind.Function,
+      range: this.nodeToRange(node),
+      scope: currentScope?.name,
+      ownerName: currentScope?.name || ctx.currentModule,
+      ownerKind: currentScope?.kind,
+      visibility: "public",
+      metadata: { cleanSpecific: true, isForeignExport: true, foreignExportLine: line, isDeclaration: true }
+    });
+    this.attachComments(ctx.symbols[ctx.symbols.length - 1], node);
+    ctx.functionSymbolIndex[key] = ctx.symbols.length - 1;
+  }
+  /**
+   * `($) infixr 9` — an operator fixity declaration. 17 sites corpus-wide,
+   * published nothing before. A fixity names an OPERATOR that is declared
+   * elsewhere (usually a macro or an `operator_definition`), so it emits no symbol
+   * of its own: the fixity is attached to that operator's symbol by
+   * `attachFixities`, and the record is kept on the file so a fixity on an
+   * operator this file does not define stays visible instead of being dropped.
+   */
+  processFixityDeclaration(node, ctx) {
+    const opNode = node.childForFieldName("operator");
+    if (!opNode) return;
+    const name = this.normalizeParenthesized(opNode);
+    if (!name) return;
+    ctx.patterns["Operator Fixity Declarations"] = true;
+    ctx.fixities.push({
+      name,
+      associativity: node.childForFieldName("associativity")?.text,
+      precedence: node.childForFieldName("precedence")?.text,
+      line: this.lineOf(node)
+    });
+  }
+  /**
+   * THE MODULE-QUALIFIED IDENTITY OF EVERY MODULE-LEVEL SYMBOL — `StdPathname.Pathname`, `PmTypes.Project`.
+   *
+   * A Clean module is DECLARED in `.dcl` and IMPLEMENTED in `.icl`, so a type, function, class or macro at
+   * module scope is ONE declaration written in TWO files. The incoming gate models that with
+   * `--binding-collapse`: a key becomes ONE declaration iff every declaration answering to it carries the
+   * same NON-EMPTY `qualifiedName` — and the gate requires that name to DIFFER from the bare name, because
+   * `pool-worker.ts` falls back to `qualifiedName = name` for a file-scope symbol and a fallback is not a
+   * qualification. This analyzer published NO qualifiedName for module-level symbols ("its name is already
+   * unique in the file"), so every module-level `.dcl`/`.icl` pair reached the gate as TWO declarations and
+   * the pair was counted as a name collision.
+   *
+   * MEASURED on the 312-file arm (2026-10-28, whole population): 1,808 `references` ambiguous, and 797 of
+   * them name a module-level pair like this — `Pathname` 143 (`StdPathname.dcl` + `.icl`), `Modulename` 46,
+   * `Project` 34, `StaticLibInfo` 32, `CompilerOptions` 30, `UtilStrictLists` 27 — plus 28 of the 40
+   * ambiguous `exports` rows (operator `&&`, `:!`, `!!|` written in both halves). The lane already ruled the
+   * pair ONE declaration for class/instance MEMBERS, where the store's `Owner.member` spelling made the
+   * collapse fire (`overrides` 2/306 -> 306/306, 719 keys collapsed); the same ruling was simply not
+   * reachable for module scope, because there was no qualified spelling for it to fire on.
+   *
+   * WHAT IS NOT TOUCHED, and each exclusion is a fact about the symbol rather than a convenience:
+   *
+   *   - a MODULE symbol (its name IS the module; there is nothing above it to qualify with), and it is the
+   *     module's own name, so `qualifiedName = name` would be the fallback the gate rightly ignores;
+   *   - a CLASS/INSTANCE MEMBER (`ownerName` is the class or the instance's target, not the module) — those
+   *     already carry `Owner.member`, which is what `overrides` and `implements` endpoints are spelled
+   *     against;
+   *   - an ADT CONSTRUCTOR or RECORD FIELD (`ownerName` is the type that declares it);
+   *   - a LOCAL (`visibility: "local"; it keeps its frame-scoped spelling and is never part of the module
+   *     interface).
+   *
+   * THE IDENTITY IS NOT INVENTED. Clean names a module-scope entity `Module.name` — that is the spelling a
+   * consumer writes when two modules declare the same name, and it is what the module's own `module` header
+   * plus the declaration produce. The bare `name` stays exactly as the source writes it, so every existing
+   * endpoint, export and fixture pin is unchanged; this field is the QUALIFIED spelling beside it, which is
+   * what the store resolves relationship endpoints against.
+   */
+  qualifyModuleLevelSymbols(ctx) {
+    const module = ctx.currentModule;
+    if (!module) return;
+    for (const s of ctx.symbols) {
+      if (s.qualifiedName) continue;
+      if (s.kind === ASTEngine.SymbolKind.Module) continue;
+      if (s.visibility === "local" || s.metadata?.isLocalDefinition) continue;
+      if (s.ownerName !== module) continue;
+      s.qualifiedName = `${module}.${s.name}`;
+    }
+  }
+  /** Apply the collected fixities to the operator symbols they name. */
+  attachFixities(ctx) {
+    if (ctx.fixities.length === 0) return;
+    for (const f of ctx.fixities) {
+      for (const s of ctx.symbols) {
+        if (s.name !== f.name) continue;
+        s.metadata = s.metadata ?? {};
+        s.metadata.fixity = { associativity: f.associativity, precedence: f.precedence };
+      }
+    }
+  }
+  /**
+   * Evidence tiers on EVERY relationship, and the lane's own provenance bit.
+   *
+   * M14 section D requires at least two distinct `evidenceClass` values pinned by
+   * fixtures, and the family vocabulary is fixed: `structural`,
+   * `usage_contextual`, `import_based`, `reference_qualified`, `inferred` (the
+   * typescript and haskell classifiers are the precedents). Clean uses only those
+   * five, so the values mean what they mean in every other lane.
+   *
+   * | kind | tier | why |
+   * | --- | --- | --- |
+   * | `contains`, `exports` | `structural` | both endpoints are names this file publishes, and the store's own resolution proves it |
+   * | `imports` | `import_based` | the source spells the module and the item |
+   * | `instantiates`, `uses` | `structural` | in-file by construction — the target must be a `data_constructor`, record field or local this file declares, or no edge is emitted |
+   * | `implements` | `structural` in-file, `reference_qualified` external | an `instance C T` is a structural fact when `C` is declared here; when `C` is imported the edge names a class by reference, which is 322 of 782 corpus sites |
+   * | `references` | `reference_qualified` | the family rule: a type reference names its type |
+   * | `calls` | `usage_contextual`, or `reference_qualified` for a source-spelled qualified target | a call is usage evidence; a call to `'Data.Error'.Ok` or `M.lookup` is identified by the spelling in the source, not by a same-file binding |
+   *
+   * `evidenceClass` answers "how do we know this edge"; it cannot answer "could
+   * this file have known the target at all", which is Clean's actual signature
+   * property and the one the honesty gate measures. So `targetIsInFile` is
+   * emitted alongside: `true` when the target resolves to a name this file
+   * publishes (bare, `Owner.member`, or the leaf after the first `.` — the
+   * store's own three strategies), `false` when the target is external by nature.
+   * 7,777 of 9,568 corpus `references` and 322 of 782 `implements` are `false`,
+   * and a consumer that wants only provable edges can now say so without
+   * re-deriving it.
+   */
+  classifyEvidenceTier(ctx) {
+    const names = new Set(ctx.symbols.map((s) => s.name));
+    const qNames = new Set(ctx.symbols.map((s) => s.qualifiedName).filter(Boolean));
+    const resolves = (name) => {
+      if (names.has(name) || qNames.has(name)) return true;
+      const dot = name.indexOf(".");
+      return dot > 0 && (names.has(name.slice(dot + 1)) || qNames.has(name.slice(dot + 1)));
+    };
+    for (const r of ctx.relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      const t = String(r.type);
+      const target = String(r.target);
+      md.targetIsInFile = resolves(target);
+      if (md.evidenceClass) continue;
+      switch (t) {
+        case "contains":
+        case "exports":
+        case "instantiates":
+        case "uses":
+          md.evidenceClass = "structural";
+          continue;
+        case "imports":
+          md.evidenceClass = "import_based";
+          continue;
+        case "references":
+          md.evidenceClass = "reference_qualified";
+          continue;
+        case "implements":
+          md.evidenceClass = md.targetIsInFile ? "structural" : "reference_qualified";
+          continue;
+        default:
+          md.evidenceClass = target.includes(".") || target.includes("'") ? "reference_qualified" : "usage_contextual";
+      }
+    }
+  }
+  /**
+   * MARK THE STANDARD ENVIRONMENT'S TYPE NAMES — one pass over the finished edge list, exactly as
+   * kotlin's `markPlatformTargets` (`real-kotlin-analyzer.ts:411`) and go's stdlib marker do it, so
+   * a new emission site cannot forget it and no pre-existing key is touched.
+   *
+   * THE PROBLEM IT ANSWERS, MEASURED ON THE WHOLE 312-FILE LANE. `unresolved` is 4,677 edges and
+   * 2,540 of them are a BARE name: `String` 869, `World` 222, `Bool` 126, `Int` 90, `Real` 75,
+   * `StdEnv` 56 … The declaration exists — in the Clean standard library, in another repository —
+   * and this analyzer's own doctrine says why the edge is still emitted: "a `references` edge in a
+   * typed position is a type reference whatever the type is" (this file's EDGE DISCIPLINE header).
+   * What was missing was not the edge, it was the STATEMENT: 1,788 of those edges name a name the
+   * standard environment declares, and the lane said nothing about it, so the arbiter counted every
+   * one of them as a silent hole.
+   *
+   * THREE GUARDS, and each one is a fact about THIS file rather than a guess:
+   *
+   *  1. EDGE KIND. Only `references` and `implements` — the two edge types whose target IS a type
+   *     mention. `contains` / `exports` targets are this file's own declarations; `calls` targets
+   *     are callee leaves or the source-spelled qualified names the calls rule owns; `imports`
+   *     targets are `Module:item`, which cannot equal a bare name; `uses`, `overrides` and
+   *     `instantiates` carry 0 unresolved edges in the measured population (TABLE 1 of the report),
+   *     so marking them would be inert and is not done.
+   *  2. THE CLOSED LIST. The target must be in `CLEAN_STD_ENV_NAMES`, which is DERIVED from the
+   *     corpus's own stdlib repositories (`clean-stdlib` + `Prelude`) — see that constant. A target
+   *     containing a dot is never in it, which matters: the arbiter refutes an `owner` claim whose
+   *     owner the project declares, and every dotted target has an owner segment that a project may
+   *     well publish (`System.CommandLine` in Clyde). Bare names only, so no claim this pass attaches
+   *     can be refuted, and `extFAIL` cannot move.
+   *  3. THE FILE'S OWN DECLARATIONS VETO. `targetIsInFile` is computed by `classifyEvidenceTier`
+   *     over this file's symbol table and is already on every edge; where it is true the edge is a
+   *     same-file reference and there is nothing external to claim. Without this guard the claim
+   *     would be FALSE at the file's own scope, and the arbiter discloses exactly that as
+   *     `contradicted` in its claim-carrying-ambiguous block.
+   *
+   * NOTHING ELSE ABOUT AN EDGE IS TOUCHED: source, target, type, line and every pre-existing
+   * metadata key are byte-identical, and the marker is read by the arbiter ONLY where the target
+   * names nothing in the project's key space — so it can never move a resolved edge, can never
+   * raise `resolved`, and never changes `collRes`.
+   */
+  markStandardEnvironmentTargets(ctx) {
+    for (const r of ctx.relationships) {
+      const t = String(r.type);
+      if (t !== ASTEngine.RelationshipType.References && t !== ASTEngine.RelationshipType.Implements) continue;
+      const target = r.target;
+      if (typeof target !== "string" || target.length === 0) continue;
+      if (!CLEAN_STD_ENV_NAMES.has(target)) continue;
+      const md = r.metadata;
+      if (!md || typeof md !== "object") continue;
+      if (md.targetIsInFile === true) continue;
+      if (md.isStdlib === true) continue;
+      md.isStdlib = true;
+    }
+  }
+  /**
+   * A `type_signature` — Clean's declaration form, and where a function's
+   * parameter types, result type, generic parameters, class context, special
+   * types and inline code body all live. 3,611 of them published only a bare
+   * Function symbol with no types at all before.
+   *
+   * The old handler published a symbol ONLY at module scope
+   * (`scopeStack.length === 0`) and then `continue`d, which meant a class member's
+   * signature got its Method from a separate scan inside `processClass`, an
+   * instance member's signature published nothing at all (only its
+   * `function_declaration` / `operator_definition` sibling did), and a where-local
+   * signature was discarded. All three publish through this one handler now.
+   */
+  processTypeSignature(node, ctx, currentScope, inErrorRegion = false) {
+    const name = this.declarationName(node);
+    if (!name) return;
+    const isLocal = this.isLocalScope(currentScope);
+    const isMember = currentScope?.kind === ASTEngine.SymbolKind.Interface || currentScope?.kind === ASTEngine.SymbolKind.Class;
+    const key = declarationKey(ctx.currentFrame, this.ownerIdentity(currentScope, ctx), name);
+    const info = ctx.signaturesByNode.get(node.id) ?? ctx.signatures.get(key);
+    const existingIdx = ctx.functionSymbolIndex[key];
+    if (existingIdx !== void 0) {
+      if (process.env.BB_CLEAN_DIAG) process.stderr.write(`DIAG apply L${this.lineOf(node)} sym=${ctx.symbols[existingIdx].name} key=${key} merge info=${info ? "Y" : "N"}
+`);
+      if (info) this.applySignature(ctx.symbols[existingIdx], info, ctx, isLocal);
+      return;
+    }
+    const kind = this.callableKind(currentScope, isLocal);
+    const sym = {
+      name,
+      kind,
+      range: this.nodeToRange(node),
+      scope: currentScope?.name,
+      ...isLocal ? { qualifiedName: ctx.currentFrame === void 0 ? name : `${ctx.currentFrame}.${name}` } : {},
+      ownerName: isLocal ? this.localOwner(ctx) : currentScope?.name || ctx.currentModule,
+      ownerKind: isLocal ? ASTEngine.SymbolKind.Function : currentScope?.kind,
+      // A callable reached only through an ERROR region has no knowable scope, so it
+      // is not part of the module's API and must not claim to be exported.
+      visibility: isLocal || inErrorRegion ? "local" : "public",
+      // A member whose only occurrence is a signature is an ABSTRACT member: the
+      // class declares it and no instance in this file defines it.
+      isAbstract: isMember ? true : void 0,
+      metadata: {
+        cleanSpecific: true,
+        isDeclaration: true,
+        isLocalDeclaration: isLocal || void 0
+      }
+    };
+    this.attachComments(sym, node);
+    ctx.symbols.push(sym);
+    ctx.functionSymbolIndex[key] = ctx.symbols.length - 1;
+    if (info) {
+      if (process.env.BB_CLEAN_DIAG) process.stderr.write(`DIAG apply L${this.lineOf(info.node)} sym=${sym.name} key=${key} fresh
+`);
+      this.applySignature(sym, info, ctx, isLocal);
+    }
+  }
+  /** Copy a `SignatureInfo` onto the symbol it declares, and emit its edges. */
+  applySignature(sym, info, ctx, isLocal) {
+    const md = sym.metadata ?? (sym.metadata = {});
+    if (info.returnType && !sym.returnType) sym.returnType = info.returnType;
+    if (info.genericVars.size > 0) {
+      const existing = sym.genericParameters ?? [];
+      for (const g of info.genericVars) if (!existing.includes(g)) existing.push(g);
+      sym.genericParameters = existing;
+    }
+    if (md.typeSignature === void 0) md.typeSignature = info.node.text;
+    if (info.specialTypes.length > 0) {
+      md.specialTypes = info.specialTypes;
+      ctx.patterns["Specialised Members"] = true;
+    }
+    if (info.hasCodeBody) {
+      md.hasInlineCodeBody = true;
+      ctx.patterns["Inline Machine Code"] = true;
+    }
+    if (info.fixity) {
+      md.fixity = info.fixity;
+      ctx.patterns["Operator Fixity Declarations"] = true;
+      ctx.fixities.push({ name: sym.name, ...info.fixity, line: this.lineOf(info.node) });
+    }
+    const source = isLocal ? md.scopedName ?? sym.name : sym.name;
+    if (info.contextClasses.length > 0) {
+      md.classContext = info.contextClasses;
+      ctx.patterns["Class Contexts"] = true;
+      const line = this.lineOf(info.node.childForFieldName("context"));
+      for (const c of info.contextClasses) {
+        this.pushRel(ctx, source, c, ASTEngine.RelationshipType.References, 0.95, {
+          cleanSpecific: true,
+          relationshipType: "class_context"
+        }, line);
+      }
+    }
+    for (const ref of info.typeRefs) {
+      this.pushRel(ctx, source, ref.name, ASTEngine.RelationshipType.References, 0.95, {
+        cleanSpecific: true,
+        relationshipType: "declared_type"
+      }, this.lineOf(ref.node));
+    }
+    md.paramTypes = info.paramTypes;
+  }
+  /**
+   * The `special` block of a signature: `special a=Int; a=Char`.
+   *
+   * 104 blocks / 507 members corpus-wide, published nothing before. A `special`
+   * member does not declare a new NAME — the variable is the enclosing
+   * declaration's own type parameter (`_from :: a -> .[a] | Enum, Ord a` with
+   * `special a=Int` specialises `_from`) — so it publishes no symbol. What it does
+   * declare is a set of TYPES the enclosing callable is specialised for, and
+   * those are real `references` edges.
+   */
+  processSpecialBlock(node, ctx) {
+    const owner = this.relationshipSource(ctx) ?? this.enclosingDeclarationName(node);
+    if (!owner) return;
+    ctx.patterns["Specialised Members"] = true;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const m = node.namedChild(i);
+      if (!m || m.type !== "special_member") continue;
+      const t = m.childForFieldName("type");
+      if (!t) continue;
+      for (const ref of this.typeRefsIn(t, ctx)) {
+        this.pushRel(ctx, owner, ref.name, ASTEngine.RelationshipType.References, 0.95, {
+          cleanSpecific: true,
+          relationshipType: "special_type"
+        }, this.lineOf(ref.node));
+      }
+    }
+  }
+  /**
+   * Join a `type_signature`'s parameter TYPES to the definition's parameter NAMES.
+   *
+   * This is the join that makes Clean parameter data real. A Clean signature
+   * `comp3 :: !(.a -> .b) u:(.c -> .a) !(.d -> .c) -> u:(.d -> .b)` yields three
+   * domain types; the definition `comp3 f g h` yields three names; pairing them
+   * positionally is sound because a Clean function type's domain is a
+   * left-nested `type_application` whose children are in parameter order, and a
+   * definition's `pattern` fields are its parameters in order — including the
+   * multi-guard shape `f x # g y = …`, where the guard equations share the
+   * parameter list and the patterns are collected across all of them, first
+   * occurrence winning.
+   */
+  joinParameters(sym, defNode, ctx, owner) {
+    if (sym.parameters && sym.parameters.length > 0) return;
+    const key = declarationKey(ctx.currentFrame, owner, sym.name);
+    const info = ctx.signatures.get(key);
+    if (!info) return;
+    const params = [];
+    let i = 0;
+    for (const p of this.fields(defNode, "pattern")) {
+      const name = this.patternParameterName(p);
+      params.push({ name, type: info.paramTypes[i], isOptional: name === OPTIONAL_PARAM_NAME });
+      i++;
+    }
+    if (params.length > 0) sym.parameters = params;
+  }
+  /**
+   * The NAME a parameter pattern binds, or the placeholder for a pattern that
+   * binds none.
+   *
+   * ONE `pattern` field is ONE parameter. That is the rule, and the first
+   * implementation got it wrong in a way the fixture caught: it collected the
+   * names bound INSIDE each pattern, so `addBid (Book bids asks) price` produced
+   * three parameters (`bids`, `asks`, `price`) while the signature
+   * `OrderBook Int -> OrderBook` has two domain types — a tuple pattern is one
+   * parameter of a tuple type, not three parameters.
+   *
+   * A pattern that names its target (`identifier`, or `strict_binding_pattern`'s
+   * `p=:t` left side) yields that name. A destructuring pattern
+   * (`constructor_pattern`, `list_pattern`, `tuple_pattern`, `record_pattern`,
+   * `unboxed_pattern`, `cons_pattern`, `wildcard`, `record_update_pattern`)
+   * binds no single target, so the parameter is anonymous and is named by the
+   * constant below rather than by inventing a name: the store keys a parameter by
+   * name, so a fabricated one would collide across overloads, while a reserved
+   * placeholder cannot.
+   */
+  patternParameterName(pat) {
+    switch (pat.type) {
+      case "identifier":
+        return pat.text;
+      case "strict_binding_pattern": {
+        const first = pat.namedChild(0);
+        if (first?.type === "identifier") return first.text;
+        return this.condensePattern(pat);
+      }
+      case "strict_pattern": {
+        const first = pat.namedChild(0);
+        return first?.type === "identifier" ? first.text : this.condensePattern(pat);
+      }
+      case "wildcard":
+        return OPTIONAL_PARAM_NAME;
+      default:
+        return this.condensePattern(pat);
+    }
+  }
+  /**
+   * A destructuring pattern as a one-line name. The pattern's own text is the
+   * name the source gives that parameter slot, so it is used verbatim; only
+   * NEWLINES and RUNS OF SPACES are folded, because a name that carries a
+   * newline is not a name. Folding is a character operation (indexOf/slice over
+   * the two whitespace characters), not a pattern match.
+   */
+  condensePattern(pat) {
+    const raw = pat.text;
+    let out = "";
+    let pendingSpace = false;
+    for (let i = 0; i < raw.length; i++) {
+      const code = raw.charCodeAt(i);
+      const isSpace = code === 32 || code === 9 || code === 10 || code === 13;
+      if (isSpace) {
+        pendingSpace = out.length > 0;
+        continue;
+      }
+      if (pendingSpace) {
+        out += " ";
+        pendingSpace = false;
+      }
+      out += raw[i];
+    }
+    return out || OPTIONAL_PARAM_NAME;
+  }
+  // ============================================================================
+  // PASS 2 — expression-level extraction
+  // ============================================================================
+  /**
+   * An application: the lane's call / instantiation / qualified-call surface.
+   *
+   * The pinned grammar makes an application LEFT-NESTED: `f a b c` is
+   * `application(application(application(f, a), b), c)`, so only the INNERMOST
+   * application carries the callee. Measured over 23,908 applications, the
+   * `function` field is 13,102 `application` (the nest), 8,340 `identifier`, 2,045
+   * `constructor`, 162 `field_access`, 78 `single_quoted_name`, 61
+   * `unboxed_expression`, 25 `parenthesized_operator`, 25 `number`, 22 `string`,
+   * 20 `paren_expression`, 14 `index_access`, and 15 across five more shapes. The
+   * old handler recognised only `identifier` and `constructor` (plus the corpus-dead
+   * `qualified_identifier`), so the 265 `field_access` / `single_quoted_name` /
+   * `parenthesized_operator` heads produced no edge at all.
+   */
+  extractApplication(node, ctx, scopeStack) {
+    const head = node.childForFieldName("function");
+    if (!head) return;
+    const owner = this.relationshipSource(ctx);
+    if (!owner) return;
+    switch (head.type) {
+      case "identifier": {
+        const target = this.resolveCallableTarget(head.text, scopeStack, ctx);
+        if (!target) return;
+        this.pushRel(ctx, owner, target, ASTEngine.RelationshipType.Calls, 0.9, {
+          cleanSpecific: true,
+          context: "local function call"
+        }, this.lineOf(head));
+        return;
+      }
+      case "constructor": {
+        if (this.isPatternPosition(node)) return;
+        const name = head.text;
+        if (ctx.declaredConstructors.has(name)) {
+          this.pushRel(ctx, owner, name, ASTEngine.RelationshipType.Instantiates, 1, {
+            cleanSpecific: true,
+            isConstructorApplication: true,
+            // A `data_constructor` node in THIS file proves the target is a data
+            // constructor, so this edge carries no inference at all.
+            isExternalTarget: false
+          }, this.lineOf(head));
+          return;
+        }
+        if (ctx.declaredFunctions.has(name)) {
+          const target = this.resolveCallableTarget(name, scopeStack, ctx);
+          if (target) {
+            this.pushRel(ctx, owner, target, ASTEngine.RelationshipType.Calls, 0.9, {
+              cleanSpecific: true,
+              context: "uppercase function application"
+            }, this.lineOf(head));
+          }
+          return;
+        }
+        if (ctx.declaredClassNames.has(name)) {
+          this.pushRel(ctx, owner, name, ASTEngine.RelationshipType.Calls, 0.9, {
+            cleanSpecific: true,
+            context: "class method application",
+            isClassMethodCall: true
+          }, this.lineOf(head));
+          return;
+        }
+        if (ctx.declaredTypeDefNames.has(name)) {
+          ctx.typeCoercions.count++;
+          if (ctx.typeCoercions.names.length < 25 && !ctx.typeCoercions.names.includes(name)) {
+            ctx.typeCoercions.names.push(name);
+          }
+          return;
+        }
+        ctx.declinedInstantiations.count++;
+        if (ctx.declinedInstantiations.names.length < 25 && !ctx.declinedInstantiations.names.includes(name)) {
+          ctx.declinedInstantiations.names.push(name);
+        }
+        return;
+      }
+      case "single_quoted_name":
+      case "qualified_identifier": {
+        const target = head.type === "single_quoted_name" ? this.qualifiedTarget(head.text) : head.text;
+        if (!target) return;
+        this.pushRel(ctx, owner, target, ASTEngine.RelationshipType.Calls, 0.9, {
+          cleanSpecific: true,
+          isQualifiedCall: true,
+          qualifier: this.qualifierOf(head.text)
+        }, this.lineOf(head));
+        if (ctx.currentFrame) {
+          const idx = ctx.frameSymbolIndex.get(ctx.currentFrame);
+          const sym = idx === void 0 ? void 0 : ctx.symbols[idx];
+          if (sym) {
+            const list = sym.qualified_calls ?? (sym.qualified_calls = []);
+            if (!list.includes(target)) list.push(target);
+          }
+        }
+        return;
+      }
+      case "field_access": {
+        this.emitFieldUse(head, ctx, "method_call");
+        return;
+      }
+      case "parenthesized_operator": {
+        const name = this.unparenthesize(head.text);
+        if (!name) return;
+        if (ctx.declaredFunctions.has(name) || ctx.declaredTypeNames.has(name)) {
+          this.pushRel(ctx, owner, name, ASTEngine.RelationshipType.Calls, 0.9, {
+            cleanSpecific: true,
+            context: "prefix operator application"
+          }, this.lineOf(head));
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  /**
+   * `obj.field` — a record field read. 1,129 sites corpus-wide, published nothing
+   * before. The `field` field carries the field NAME (1,058 `identifier`, 55
+   * `constructor` — a field may be uppercase, as in `d.Diagnostic.severity` — and
+   * 16 `single_quoted_name`).
+   *
+   * Emitted only when the name is a record field THIS FILE declares (the
+   * FP-family rule, applied to property access as to calls): the receiver's type
+   * is not resolvable inside one file, so an unguarded edge to a name that may be
+   * a local variable would be a fabrication. `uses` is the type — a field read is
+   * a use of the field, not a call of it.
+   */
+  emitFieldUse(access, ctx, label) {
+    const owner = this.relationshipSource(ctx);
+    if (!owner) return;
+    const field = access.childForFieldName("field");
+    if (!field) return;
+    const name = field.text;
+    if (!ctx.declaredFieldNames.has(name)) return;
+    this.pushRel(ctx, owner, name, ASTEngine.RelationshipType.Uses, 0.9, {
+      cleanSpecific: true,
+      relationshipType: label,
+      isRecordField: true
+    }, this.lineOf(field));
+  }
+  /**
+   * `{base & f = v, g = w}` — a record update. 469 sites, 793 `update_field`s.
+   *
+   * The `field` field points at an `update_field` and the `value` fields
+   * interleave with it, so the field NAMES are read from the `update_field`
+   * children (`field → identifier`) rather than by zipping two parallel field
+   * lists. Measured: field count equals value count on all 469 (`f1v1` 288,
+   * `f2v2` 90, `f3v3` 66, `f4v4` 14, `f5v5` 7, `f6v6` 2, `f11v11` 1,
+   * `f12v12` 1), so a positional zip would work today, but the names are on the
+   * nodes and reading them there is the construction that cannot break.
+   */
+  extractRecordUpdate(node, ctx) {
+    const owner = this.relationshipSource(ctx);
+    if (!owner) return;
+    for (const f of this.fields(node, "field")) {
+      const inner = f.childForFieldName("field") ?? f.namedChild(0);
+      if (!inner) continue;
+      const name = inner.text;
+      if (!ctx.declaredFieldNames.has(name)) continue;
+      this.pushRel(ctx, owner, name, ASTEngine.RelationshipType.Uses, 0.9, {
+        cleanSpecific: true,
+        relationshipType: "record_field_update",
+        isRecordField: true
+      }, this.lineOf(inner));
+    }
+  }
+  /**
+   * `{a = 1, b = 2}` — a record CONSTRUCTION. 399 sites, published nothing before.
+   * Every field the literal sets is a `uses` of that field.
+   */
+  extractRecordExpression(node, ctx) {
+    const owner = this.relationshipSource(ctx);
+    if (!owner) return;
+    for (const n of this.fields(node, "name")) {
+      const name = n.text;
+      if (!ctx.declaredFieldNames.has(name)) continue;
+      this.pushRel(ctx, owner, name, ASTEngine.RelationshipType.Uses, 0.9, {
+        cleanSpecific: true,
+        relationshipType: "record_construction",
+        isRecordField: true
+      }, this.lineOf(n));
+    }
+  }
+  /**
+   * `Just x` in PATTERN position — a match on a data constructor. 1,240 sites,
+   * published nothing before.
+   *
+   * This is deliberately NOT an `instantiates`: `case x of Just y -> …` does not
+   * build a `Just`, it depends on one. `uses` is the type, guarded by the same
+   * in-file declaration rule as every other edge, and labelled so the graph can
+   * tell a match from a read or a write.
+   */
+  extractConstructorPattern(node, ctx) {
+    const owner = this.relationshipSource(ctx);
+    if (!owner) return;
+    for (const c of this.fields(node, "constructor")) {
+      if (c.type !== "constructor") continue;
+      if (!ctx.declaredConstructors.has(c.text)) continue;
+      this.pushRel(ctx, owner, c.text, ASTEngine.RelationshipType.Uses, 0.9, {
+        cleanSpecific: true,
+        relationshipType: "pattern_match",
+        isPatternMatch: true
+      }, this.lineOf(c));
+    }
+  }
+  /**
+   * Resolve a bare callee name to a target: the innermost visible LOCAL wins
+   * (Clean scoping — a where-binder shadows the module binding for the whole RHS
+   * of its callable), else the module-level declared set, else no edge.
+   *
+   * The walk order makes the local win correct without a second rule: a
+   * `where_block` pushes its `locals` before the walk descends into the
+   * definitions' bodies, and pops on exit, so an application in a guard equation
+   * resolves against the block that encloses it.
+   */
+  resolveCallableTarget(name, scopeStack, ctx) {
+    for (let i = scopeStack.length - 1; i >= 0; i--) {
+      const locals = scopeStack[i].locals;
+      if (locals === void 0) continue;
+      const hit = locals.get(name);
+      if (hit !== void 0) return hit;
+    }
+    return ctx.declaredFunctions.has(name) ? name : void 0;
+  }
+  /**
+   * The symbol an expression-level edge is attributed to: the innermost open
+   * frame's scoped identity, or the module when no frame is open. An application
+   * outside any callable (a module-level initialiser) is attributed to the
+   * module, which is where its symbol lives.
+   */
+  relationshipSource(ctx) {
+    return ctx.currentFrame ?? ctx.currentModule;
+  }
+  /** The name of the nearest enclosing declaration, for a non-frame position. */
+  enclosingDeclarationName(node) {
+    let p = node.parent;
+    while (p) {
+      if (CALLABLE_NODE_TYPES.has(p.type)) return this.callableDeclaredName(p);
+      if (p.type === "class_declaration" || p.type === "instance_declaration" || p.type === "type_definition" || p.type === "generic_declaration") {
+        return p.childForFieldName("name")?.text;
+      }
+      p = p.parent;
+    }
+    return void 0;
+  }
+  /**
+   * `'Data.Map'.get` → `Data.Map.get`.
+   *
+   * The quote in a Clean qualified name wraps the MODULE, not the whole name:
+   * the corpus form is `'Data.Error'.Ok` — `'Data.Error'` quoted, `.Ok` not — and
+   * the alias form is `M.lookup`, unquoted. The first implementation of this
+   * function assumed a fully-quoted name (remove one leading `'`, require one
+   * trailing `'`), so it returned null for every real corpus site: measured, the
+   * 78 `single_quoted_name` application heads in the corpus produced ZERO
+   * qualified `calls` edges while the branch looked live.
+   *
+   * The normalization is therefore "drop the quote characters", which is a
+   * character filter, and a result with no characters left is not a name.
+   */
+  qualifiedTarget(text) {
+    if (!text.startsWith("'")) return text || null;
+    let out = "";
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (ch !== "'") out += ch;
+    }
+    return out || null;
+  }
+  /** The qualifier (module or alias) part of a qualified name, for metadata. */
+  qualifierOf(text) {
+    const inner = this.qualifiedTarget(text);
+    if (!inner) return void 0;
+    const dot = inner.indexOf(".");
+    return dot > 0 ? inner.slice(0, dot) : void 0;
+  }
+  // ============================================================================
+  // PASS 3 — closure
+  // ============================================================================
+  /**
+   * `contains` for owned symbols — module → members, type → constructors and
+   * fields, class/instance → methods, local frame → its own definitions. The
+   * CHILD's own naming line is the anchor that resolves the intended target among
+   * same-named siblings (#921), and a self-named edge is skipped because a symbol
+   * cannot contain itself.
+   */
+  emitContainsEdges(ctx) {
+    for (const s of ctx.symbols) {
+      const owner = s.ownerName;
+      if (owner && owner !== s.name) {
+        this.pushRel(ctx, owner, s.name, ASTEngine.RelationshipType.Contains, 1, {}, s.range?.startLine);
+      }
+    }
+  }
+  /**
+   * Exports: every symbol the MODULE owns, plus an explicit `foreign export`.
+   * Clean has no export keyword — a `.dcl`'s definition list IS the interface and
+   * everything in it is public by default.
+   *
+   * Class/instance members keep their owner (`<class>` / the instance target type),
+   * so they are NOT exported: their membership rides the `contains` edge, exactly
+   * as the haskell lane treats a class method. Where/with/let locals are NOT
+   * exported (M11.11 §2: a local is a real symbol but not part of the module's
+   * surface) — now that locals publish at all, that exclusion is load-bearing
+   * rather than incidental, and it is stated here because it is the one place a
+   * `visibility: "local"` symbol could otherwise leak into the module interface.
+   *
+   * Name-keyed first-wins dedupe: the exports-family invariant (run-fixtures.ts,
+   * M49 JVM-closure audit) requires UNIQUE export names, because a duplicate
+   * cannot identify its provider. THE DEDUPE SURVIVES THE INSTANCE-CONTAINER FIX, and
+   * the invariant is why: it is a property of the export LIST (one name, one
+   * provider), not of any one declaration form, so it stays regardless of which
+   * forms happen to collide this round. What the dedupe USED to absorb is gone at the
+   * source — a file declaring `ParseState` and also implementing `instance Eq
+   * ParseState` offered `ParseState` twice (59 of 312 files), and the instance
+   * container is now `ParseState::instance` of kind `impl`, which is neither exported
+   * nor a declaration of `ParseState`. Same dedupe as cpp/go/objc/clojure, keyed by
+   * bare name — a Clean module exports a name, not a name+kind pair.
+   */
+  emitExports(ctx) {
+    const EXPORTABLE_KINDS = /* @__PURE__ */ new Set([
+      ASTEngine.SymbolKind.Function,
+      ASTEngine.SymbolKind.Type,
+      ASTEngine.SymbolKind.Interface,
+      ASTEngine.SymbolKind.Class,
+      ASTEngine.SymbolKind.Module,
+      ASTEngine.SymbolKind.Constructor,
+      ASTEngine.SymbolKind.Property,
+      ASTEngine.SymbolKind.Macro
+    ]);
+    const seen = /* @__PURE__ */ new Set();
+    const source = ctx.currentModule ?? "";
+    for (const sym of ctx.symbols) {
+      if (sym.name.startsWith("_")) continue;
+      if (sym.name === ctx.currentModule) continue;
+      if (!EXPORTABLE_KINDS.has(sym.kind)) continue;
+      if (sym.visibility === "local" || sym.metadata?.isLocalDefinition) continue;
+      if (seen.has(sym.name)) continue;
+      if (sym.ownerName !== ctx.currentModule && sym.ownerName !== void 0) continue;
+      seen.add(sym.name);
+      ctx.exports.push({ name: sym.name, kind: sym.kind, range: sym.range, visibility: "public" });
+      if (source) {
+        this.pushRel(
+          ctx,
+          source,
+          sym.name,
+          ASTEngine.RelationshipType.Exports,
+          1,
+          { cleanSpecific: true },
+          sym.range?.startLine
+        );
+      }
+    }
+  }
+  // ============================================================================
+  // PASS 3 — plumbing
+  // ============================================================================
+  /**
+   * Relationship emission, deduped by source|type|target|line identity.
+   *
+   * Dimension 8 / M59.O2: an edge carries the SITE LINE it happened on — 1-based,
+   * on the name-bearing node, per-site and not per-set, because navigation is the
+   * product. Two consequences, both deliberate:
+   *   * the line is part of the DEDUPE KEY (the clojure lane's rule,
+   *     real-clojure-analyzer.ts:1388): a function called from three lines is
+   *     three edges at three lines, not one edge at whichever line the walk saw
+   *     first. The store already keys its rows the same way
+   *     (parallel-indexer.ts:4439), and for a `contains` edge the child's own
+   *     naming line is what resolves the intended target among same-named
+   *     siblings (#921);
+   *   * 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) {
+    if (!source || !target) return;
+    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,
+      metadata,
+      ...hasLine ? { line_number: line } : {}
+    });
+  }
+  /** 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;
+  }
+  // ============================================================================
+  // PASS 2 — shared helpers
+  // ============================================================================
+  isLocalScope(scope) {
+    return scope !== void 0 && scope.kind === ASTEngine.SymbolKind.Namespace && scope.name === LOCAL_SCOPE_NAME;
+  }
+  /**
+   * The identity a declaration in `scope` merges under: the local's enclosing
+   * FRAME when the scope is a where/with/let block (that is what keeps a local
+   * from colliding with a module callable), otherwise the scope's own name.
+   */
+  ownerIdentity(scope, ctx) {
+    if (this.isLocalScope(scope)) return ctx.currentFrame;
+    return scope?.name;
+  }
+  /** A callable's kind from the scope it is declared in. */
+  callableKind(scope, isLocal) {
+    if (isLocal) return ASTEngine.SymbolKind.Function;
+    if (scope === void 0) return ASTEngine.SymbolKind.Function;
+    if (scope.kind === ASTEngine.SymbolKind.Interface || scope.kind === ASTEngine.SymbolKind.Class) {
+      return ASTEngine.SymbolKind.Method;
+    }
+    if (scope.kind === ASTEngine.SymbolKind.Type) return ASTEngine.SymbolKind.Property;
+    return ASTEngine.SymbolKind.Function;
+  }
+  /** The `| C a, D b` constraints of a class or instance, as edges. */
+  emitContextRefs(context, source, label, ctx) {
+    const info = {
+      node: context,
+      paramTypes: [],
+      genericVars: /* @__PURE__ */ new Set(),
+      typeRefs: [],
+      contextClasses: [],
+      specialTypes: [],
+      hasCodeBody: false
+    };
+    this.readClassContext(context, info);
+    if (info.contextClasses.length === 0) return;
+    ctx.patterns["Class Contexts"] = true;
+    for (const c of info.contextClasses) {
+      this.pushRel(ctx, source, c, ASTEngine.RelationshipType.References, 0.95, {
+        cleanSpecific: true,
+        relationshipType: label
+      }, this.lineOf(context));
+    }
+  }
+  /**
+   * Type names mentioned by a type expression, as `references` edges — Clean's
+   * `extractDeclaredTypeRefs` (the TypeScript lane's, at
+   * real-typescript-analyzer.ts:3144). The line is the NAME's own line, not the
+   * type expression's start, because a multi-line type puts its arguments on
+   * later lines and the reader navigates to the name.
+   */
+  emitTypeRefs(typeNode, source, label, ctx) {
+    for (const ref of this.typeRefsIn(typeNode, ctx)) {
+      this.pushRel(ctx, source, ref.name, ASTEngine.RelationshipType.References, 0.95, {
+        cleanSpecific: true,
+        relationshipType: label
+      }, this.lineOf(ref.node));
+    }
+  }
+  /**
+   * The declared name of a function/operator definition, read from the grammar's
+   * FIELD.
+   *
+   * `findChild(node, n => n.type === "identifier")` returns the FIRST identifier
+   * child, which is only the name while the name happens to be typed `identifier`.
+   * An uppercase definition's name is typed `constructor` (Clean lets a constructor
+   * be a function and the grammar says so), so the heuristic skipped over it and
+   * published the first PARAMETER as the function name. Measured over this lane's
+   * corpora, per grammar: pinned v1.2.4 — 4,607 declarations, 452 published a
+   * parameter as the name, 252 dropped; v1.2.7 — 4,647 declarations, 447 published
+   * a parameter, 244 dropped. The field is exact, so it is used when present and
+   * the scan remains only as a fallback for a node with no field.
+   */
+  declaredName(node) {
+    const byField = node.childForFieldName("name");
+    if (byField?.text) return byField;
+    return this.findChild(node, (n) => n.type === "identifier" || n.type === "constructor");
+  }
+  /**
+   * The name an `operator_definition` declares. Same normalization as
+   * `declarationName`'s parenthesized branch, so a signature and its definition
+   * land on ONE key and merge instead of producing two symbols.
+   */
+  operatorDefinitionName(node) {
+    const nameNode = node.childForFieldName("name") ?? this.findChild(node, (n) => n.type === "parenthesized_operator" || n.type === "parenthesized_name");
+    if (!nameNode?.text) return null;
+    return this.unparenthesize(nameNode.text);
+  }
+  /**
+   * The name a `type_signature` DECLARES, normalized across the four shapes the
+   * pinned grammar puts inside `signature_name`:
+   *
+   *   identifier              `f :: !Int -> Bool`
+   *   constructor             `NSMakeSize :: !NSSize !NSSizeType -> NSSize*`
+   *                           — Clean lets an uppercase name be a FUNCTION and the
+   *                           grammar types it `constructor`
+   *   parenthesized_operator  `(%.) infixl 9 :: ...` — the name is `%.`
+   *   parenthesized_name      `(bitxor) :: !Int !Int -> Int` — the name is
+   *                           `bitxor` (a prefix declaration of an infix-capable
+   *                           name)
+   *
+   * A parenthesized shape carrying a comma or a brace is NOT a name: it is the
+   * grammar's mis-shape for a PATTERN (`# (a,b,c) = expr;`), and publishing it
+   * would fabricate a symbol no source declares. Measured over the corpus
+   * (312 files, 148 of them `.dcl`): 2,753 module-level signature sites, of which
+   * 1,021 names were published nowhere — 708 identifiers, 259 constructors, 45
+   * operators, 9 parenthesized names.
+   */
+  declarationName(node) {
+    const sigName = node.childForFieldName("name") ?? this.findChild(node, (n) => n.type === "signature_name");
+    if (!sigName) return null;
+    const kid = sigName.namedChildCount > 0 ? sigName.namedChild(0) : null;
+    if (!kid) return null;
+    if (kid.type === "identifier" || kid.type === "constructor") return kid.text;
+    if (kid.type === "parenthesized_operator" || kid.type === "parenthesized_name") {
+      return this.unparenthesize(kid.text);
+    }
+    return null;
+  }
+  unparenthesize(text) {
+    return unparenthesizeText(text);
+  }
+  /**
+   * Is `name` a class this file declares, under the OTHER spelling Clean uses for an
+   * operator-named class?
+   *
+   * A declaration writes `class (==) …` and an instance reads `instance == …`, so
+   * `declaredTypeNames` holds `(==)` while the lookup holds `==`. Only the parenthesised
+   * direction is tried, and only when the bare name is not itself declared, so a file
+   * that declares BOTH `class (===)` and `class ===` still resolves `===` to the
+   * declaration that actually spells it that way. Returns false for any name that is not
+   * a plausible operator, which keeps this from matching an ordinary identifier.
+   */
+  isLocallyDeclaredOperatorClass(ctx, name) {
+    if (this.isPlainIdentifierName(name)) return false;
+    const parenthesised = `(${name})`;
+    return ctx.declaredTypeNames.has(parenthesised) || ctx.declaredClassNames.has(parenthesised);
+  }
+  /**
+   * Is `name` an ordinary identifier — a letter or `_`, then letters, digits, `_` or `'`?
+   *
+   * Character tests, not a pattern. This file's one regex-free property is checked by
+   * `script/m14/clean-completeness-gate.ts`, which fails on ANY `RegularExpressionLiteral`
+   * — a stronger rule than the M49.R2 "no regex doing syntax work" policy, and the reason a
+   * two-line predicate like `/^[A-Za-z_][A-Za-z0-9_']*$/` had to be written this way. The
+   * first version of `isLocallyDeclaredOperatorClass` used that regex and turned the gate
+   * red, which is the gate working: it caught a regression introduced by the very commit
+   * that added the fixture meant to prove the correction.
+   */
+  isPlainIdentifierName(name) {
+    if (name.length === 0) return false;
+    const isHead = (c) => c === "_" || c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+    if (!isHead(name[0])) return false;
+    for (let i = 1; i < name.length; i++) {
+      const c = name[i];
+      if (!isHead(c) && !(c >= "0" && c <= "9") && c !== "'") return false;
+    }
+    return true;
+  }
+  /**
+   * The comments belonging to a declaration: the run of comment nodes that
+   * IMMEDIATELY precede it, plus any comment inside it.
+   *
+   * Contiguity is the boundary. Without it a trailing remark about the PREVIOUS
+   * declaration — the common case in Clean's `.dcl` files, where every interface
+   * member is introduced by a comment — is stolen by the next one, and a `.dcl`
+   * that documents twenty members would give all twenty the same text. So the
+   * walk stops at the first comment with a blank line between it and the
+   * declaration, which is the same rule the TypeScript lane uses
+   * (real-typescript-analyzer.ts:5439).
+   *
+   * 3,062 comment nodes over the corpus (2,679 line, 383 block) reached no symbol
+   * before this: the lane published a symbol's type, parameters and generics and
+   * never its documentation, so `brain_symbol.docstring` was empty for every Clean
+   * symbol in existence.
+   */
+  /**
+   * Add a node's comments to a symbol that already has some.
+   *
+   * The order is signature-then-definition, which is the source order for the
+   * `.dcl` house style (documentation above the signature, definition below), and
+   * the DEFINITION's leading run takes the `docstring` when it has one.
+   */
+  mergeComments(sym, node) {
+    const before = sym.comments?.length ?? 0;
+    this.attachComments(sym, node);
+    if ((sym.comments?.length ?? 0) === before) return;
+    if (this.leadingComments(node).length > 0 && !sym.docstring) sym.docstring = sym.comments?.[0];
+  }
+  attachComments(sym, node) {
+    const leading = this.leadingComments(node);
+    const inner = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child || !COMMENT_TYPES.has(child.type)) continue;
+      const text = commentText(child.text);
+      if (text && !leading.includes(text) && !inner.includes(text)) inner.push(text);
+    }
+    const trailing = this.trailingComments(node);
+    const all = [...leading, ...trailing, ...inner];
+    if (all.length === 0) return;
+    const existing = sym.comments ?? [];
+    const merged = [...existing];
+    for (const c of all) if (!merged.includes(c)) merged.push(c);
+    sym.comments = merged;
+    if (leading.length > 0 && !sym.docstring) sym.docstring = leading[0];
+  }
+  /**
+   * The contiguous run of comment nodes IMMEDIATELY above a declaration, in
+   * source order.
+   *
+   * Two boundaries, and the first implementation had only one:
+   *
+   *   * a BLANK LINE ends the run — otherwise a remark about the PREVIOUS
+   *     declaration is stolen by the next one, and a `.dcl` that documents twenty
+   *     members would give all twenty the same text;
+   *   * a comment that begins ON the preceding declaration's own line is that
+   *     declaration's TRAILING comment, not this one's documentation. Clean's
+   *     grammar puts such a comment in the source-file child list right after the
+   *     declaration it annotates, so it is the next declaration's
+   *     `previousSibling` and the blank-line rule alone cannot exclude it. The
+   *     measured damage: `initAppDelegate` was documented with
+   *     "create the AppDelegate class", which is `createAppDelegate`'s comment.
+   *     The barrier is the nearest preceding NON-comment sibling's end row; a
+   *     comment starting at or above it belongs to that sibling.
+   */
+  leadingComments(node) {
+    const parent = node.parent;
+    if (!parent) return [];
+    const at = this.childIndexOf(parent, node);
+    if (at < 0) return [];
+    let barrierRow = -1;
+    for (let i = at - 1; i >= 0; i--) {
+      const c = parent.child(i);
+      if (!c || !c.isNamed) continue;
+      if (COMMENT_TYPES.has(c.type)) continue;
+      barrierRow = c.endPosition.row;
+      break;
+    }
+    const out = [];
+    let anchorRow = node.startPosition.row;
+    for (let i = at - 1; i >= 0; i--) {
+      const c = parent.child(i);
+      if (!c || !c.isNamed || !COMMENT_TYPES.has(c.type)) break;
+      if (c.endPosition.row + 1 < anchorRow) break;
+      if (c.startPosition.row <= barrierRow) break;
+      const text = commentText(c.text);
+      if (text) out.unshift(text);
+      anchorRow = c.startPosition.row;
+    }
+    return out;
+  }
+  /**
+   * A TRAILING comment: the run of comment nodes that start on the declaration's
+   * own END row.
+   *
+   * Clean's house style in every `.dcl` in this corpus is a remark at the end of
+   * the signature line, and this grammar places it in the PARENT's child list
+   * after the declaration — so it is also the next declaration's leading
+   * neighbour, which is why the barrier in `leadingComments` exists.
+   */
+  trailingComments(node) {
+    const parent = node.parent;
+    if (!parent) return [];
+    const at = this.childIndexOf(parent, node);
+    if (at < 0) return [];
+    const out = [];
+    for (let i = at + 1; i < parent.childCount; i++) {
+      const c = parent.child(i);
+      if (!c || !c.isNamed || !COMMENT_TYPES.has(c.type)) break;
+      if (c.startPosition.row !== node.endPosition.row) break;
+      const text = commentText(c.text);
+      if (text && !out.includes(text)) out.push(text);
+    }
+    return out;
+  }
+  /**
+   * This node's index in its parent's child list, or -1.
+   *
+   * It is found by START INDEX rather than by identity because web-tree-sitter
+   * recreates a Node object on every access — and the sibling ACCESSORS cannot be
+   * used at all on this grammar: measured, `previousSibling` here returns the
+   * previous NAMED NON-COMMENT sibling, skipping the very comment nodes this
+   * method exists to find, so `total`'s leading block comment was unreachable
+   * through it. Scanning the child list is the construction that works, and it is
+   * the same one the rest of this file uses to find a node's neighbours.
+   */
+  childIndexOf(parent, child) {
+    for (let i = 0; i < parent.childCount; i++) {
+      const c = parent.child(i);
+      if (c && c.startIndex === child.startIndex && c.endIndex === child.endIndex) return i;
+    }
+    return -1;
+  }
+  // ============================================================================
+  // AST PLUMBING
+  //
+  // Everything here reads a node's own structure. No method inspects a node's
+  // text to decide what it is: the grammar's FIELDS are the discriminator
+  // everywhere, and the only text-level operations in the file are the four
+  // positional ones already justified at their definitions (the unparenthesize
+  // pair, the dot strip, the quote drop, the whitespace fold).
+  // ============================================================================
+  /**
+   * `childrenForFieldName` with the null entries dropped.
+   *
+   * web-tree-sitter's `childrenForFieldName` is typed `(Node | null)[]` because
+   * it walks the whole child list matching field ids. Every caller here wants the
+   * real children, and a `for..of` over the raw array would need a non-null
+   * assertion at each use. One filter, here, is both shorter and honest about the
+   * shape.
+   */
+  fields(node, name) {
+    const raw = node.childrenForFieldName(name);
+    const out = [];
+    for (let i = 0; i < raw.length; i++) {
+      const c = raw[i];
+      if (c) out.push(c);
+    }
+    return out;
+  }
+  findChild(node, predicate) {
+    const count = node.namedChildCount;
+    for (let i = 0; i < count; i++) {
+      const child = node.namedChild(i);
+      if (child && predicate(child)) return child;
+    }
+    return null;
+  }
+  filterChildren(node, predicate) {
+    const result = [];
+    const count = node.namedChildCount;
+    for (let i = 0; i < count; i++) {
+      const child = node.namedChild(i);
+      if (child && predicate(child)) result.push(child);
+    }
+    return result;
+  }
+  firstNamedChildOfType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === type) return c;
+    }
+    return null;
+  }
+  /** A child the grammar leaves UNFIELDED — `generic_declaration`'s `::` type. */
+  unnamedChildOfType(node, type) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && c.type === type) return c;
+    }
+    return null;
+  }
+  /**
+   * A name node normalized for a parenthesized operator or name: `(==)` → `==`,
+   * anything else → its own text.
+   *
+   * The parenthesized forms are how Clean spells an infix-capable name, and the
+   * four shapes that carry a name (`constructor`, `identifier`,
+   * `parenthesized_operator`, `parenthesized_name`) must all land on ONE key, or
+   * a signature and its definition become two symbols.
+   */
+  normalizeParenthesized(node) {
+    if (!node?.text) return null;
+    if (node.type === "parenthesized_operator" || node.type === "parenthesized_name") {
+      return this.unparenthesize(node.text);
+    }
+    return node.text;
+  }
+  /**
+   * The name a `class_member` / `instance_member` wrapper's inner declaration
+   * declares, normalized across all three shapes the two wrappers carry.
+   *
+   * A `type_signature` wraps its name in a `signature_name` (four shapes, see
+   * `declarationName`); an `operator_definition` puts a `parenthesized_operator`
+   * straight in the `name` field; a `function_declaration` puts an `identifier`.
+   * All three are read from the FIELD, never from the first child, for the reason
+   * `declaredName` documents: an uppercase definition's name is typed
+   * `constructor` and a first-child scan publishes the first PARAMETER instead.
+   */
+  memberDeclaredName(wrapper) {
+    const inner = wrapper.namedChild(0);
+    if (!inner) return null;
+    if (inner.type === "type_signature") return this.declarationName(inner);
+    return this.normalizeParenthesized(this.declaredName(inner));
+  }
+  /** module_name children compose dotted names (Data.Map → Data + "." + Map). */
+  assembleModuleName(node) {
+    let out = "";
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      const leaf = c.type === "module_name" ? this.assembleModuleName(c) : c.text;
+      if (out) out += ".";
+      out += leaf;
+    }
+    return out || node.text;
+  }
+  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
+    };
+  }
+  /**
+   * Is this application in PATTERN territory?
+   *
+   * A constructor application is an `instantiates` in a body and a match in a
+   * pattern, and the two are different edges. Pattern territory is:
+   *   * any pattern-node subtree (`constructor_pattern`, `list_pattern`,
+   *     `tuple_pattern`, `record_pattern`, `paren_pattern`, `unboxed_pattern`,
+   *     `cons_pattern`, `strict_binding_pattern`, `record_update_pattern`);
+   *   * a `case_alternative` head — the pattern before the `->`;
+   *   * everything in a definition BEFORE its `body` FIELD (the head patterns).
+   *
+   * The pre-#884 form of the third rule scanned the children for one typed
+   * `operator` with text `=`, which the pinned grammar cannot produce: a
+   * definition's s-expression carries name/pattern…/body and NO `=` child at all
+   * (measured three ways — the 1,576 `operator` nodes in the corpus have parents
+   * `binary_expression` 829, `unary_expression` 99, `paren_pattern` 9,
+   * `operator_definition` 5, `instance_class` 11 and never a
+   * `function_declaration`, and no `operator` node's text is `=`). Expressed
+   * against the field, the rule is live and means the same thing.
+   */
+  isPatternPosition(node) {
+    let cur = node.parent;
+    while (cur) {
+      if (PATTERN_NODE_TYPES.has(cur.type)) return true;
+      if (cur.type === "case_alternative") {
+        const first = cur.namedChild(0);
+        return first !== null && first.startIndex === node.startIndex || this.isBeforeArrow(cur, node);
+      }
+      if (CALLABLE_NODE_TYPES.has(cur.type)) return this.isBeforeBody(cur, node);
+      if (cur.type === "type_definition" || cur.type === "class_declaration" || cur.type === "instance_declaration" || cur.type === "type_signature") {
+        return false;
+      }
+      cur = cur.parent;
+    }
+    return false;
+  }
+  isBeforeArrow(caseAlt, node) {
+    for (let i = 0; i < caseAlt.namedChildCount; i++) {
+      const c = caseAlt.namedChild(i);
+      if (!c) continue;
+      if (c.type === "arrow") return node.startIndex < c.startIndex;
+      if (c.startIndex === node.startIndex) return true;
+    }
+    return false;
+  }
+  /**
+   * Pattern territory inside a definition is everything BEFORE its body FIELD. A
+   * definition with no body field at all (a damaged parse) still has `pattern`
+   * fields, and territory is everything before the LAST of them, so a constructor
+   * application in a body-less node is not mistaken for a match.
+   */
+  isBeforeBody(defNode, node) {
+    for (const b of this.fields(defNode, "body")) {
+      if (node.startIndex < b.startIndex) return true;
+    }
+    const patterns = this.fields(defNode, "pattern");
+    if (patterns.length === 0) return false;
+    let last = -1;
+    for (const p of patterns) last = Math.max(last, p.endIndex);
+    return node.startIndex < last;
+  }
+};
+function commentText(raw) {
+  let s = raw;
+  if (s.startsWith("/*")) {
+    s = s.slice(2);
+    while (s.startsWith("*")) s = s.slice(1);
+    if (s.endsWith("*/")) s = s.slice(0, -2);
+    return s.trim();
+  }
+  while (s.startsWith("/")) s = s.slice(1);
+  return s.trim();
+}
+function stripLeadingDot(text) {
+  return text.startsWith(".") ? text.slice(1) : text;
+}
+export {
+  RealCleanAnalyzer
+};