@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/real-fsharp-analyzer-5QLTOV3E.js

@@ -0,0 +1,2390 @@
+import {
+  ASTEngine
+} from "./chunk-V44PGPA6.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import {
+  BINDING_SEP
+} from "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-fsharp-analyzer.ts
+import * as path from "path";
+import { existsSync } from "fs";
+var FSHARP_PROJECT_ROOT_CACHE = /* @__PURE__ */ new Map();
+function fsharpRepoRelPath(projectRoot, absPath) {
+  const rel = path.relative(path.resolve(projectRoot), path.resolve(absPath));
+  if (rel.length === 0 || path.isAbsolute(rel)) return null;
+  if (rel === ".." || rel.startsWith(`..${path.sep}`)) return null;
+  return rel.split(path.sep).join("/");
+}
+function fsharpProjectRootOf(filePath) {
+  const start = path.dirname(path.resolve(filePath));
+  const seen = [];
+  let dir = start;
+  for (let i = 0; i < 64; i++) {
+    const cached = FSHARP_PROJECT_ROOT_CACHE.get(dir);
+    if (cached !== void 0) {
+      for (const d of seen) FSHARP_PROJECT_ROOT_CACHE.set(d, cached);
+      return cached;
+    }
+    seen.push(dir);
+    if (existsSync(path.join(dir, ".git"))) {
+      if (FSHARP_PROJECT_ROOT_CACHE.size > 2e4) FSHARP_PROJECT_ROOT_CACHE.clear();
+      for (const d of seen) FSHARP_PROJECT_ROOT_CACHE.set(d, dir);
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (FSHARP_PROJECT_ROOT_CACHE.size > 2e4) FSHARP_PROJECT_ROOT_CACHE.clear();
+  for (const d of seen) FSHARP_PROJECT_ROOT_CACHE.set(d, null);
+  return null;
+}
+var FSHARP_CONSOLE_BUILTINS = /* @__PURE__ */ new Set([
+  "printfn",
+  "printf",
+  "eprintfn",
+  "eprintf",
+  "fprintfn",
+  "fprintf",
+  "Console.WriteLine",
+  "Console.Write",
+  "Console.Error.WriteLine",
+  "Console.Error.Write"
+]);
+var OBJECT_LEAF_METHODS = /* @__PURE__ */ new Set(["ToString", "GetHashCode", "Equals", "GetType", "ReferenceEquals"]);
+var PIPELINE_CALLEE_SIDE = /* @__PURE__ */ new Map([
+  ["|>", "right"],
+  ["|>>", "right"],
+  [">>=", "right"],
+  ["<|", "left"],
+  ["<<", "left"]
+]);
+var PIPELINE_NAMEY = /* @__PURE__ */ new Set(["long_identifier", "identifier", "long_identifier_or_op", "dot_expression"]);
+var isCallableOwnerNode = (n) => n.type === "member_defn" || n.type === "function_or_value_defn" || n.type === "additional_constr_defn";
+var TYPE_CLAUSE_TYPES = /* @__PURE__ */ new Set([
+  "type_abbrev_defn",
+  "anon_type_defn",
+  "record_type_defn",
+  "union_type_defn",
+  "interface_type_defn",
+  "enum_type_defn",
+  "delegate_type_defn",
+  "type_declaration"
+]);
+var TYPE_WRAPPER_NODES = /* @__PURE__ */ new Set([
+  "simple_type",
+  "postfix_type",
+  "paren_type",
+  "generic_type",
+  "function_type",
+  "compound_type",
+  "list_type",
+  "atomic_type",
+  "nullable_type",
+  "struct_type",
+  "static_type",
+  "byref_type",
+  "flexible_type",
+  "types"
+]);
+var UNRESOLVED_TYPE = "unresolved-type-name";
+var UNRESOLVED_NAMESPACE = "unresolved-namespace";
+var UNRESOLVED_BASE = "unresolved-base-name";
+var UNRESOLVED_INTERFACE = "unresolved-interface-name";
+var TYPE_POSITION_KINDS = /* @__PURE__ */ new Set([
+  ASTEngine.SymbolKind.Class,
+  ASTEngine.SymbolKind.Interface,
+  ASTEngine.SymbolKind.Enum,
+  ASTEngine.SymbolKind.Type,
+  ASTEngine.SymbolKind.Struct,
+  ASTEngine.SymbolKind.Delegate
+]);
+var RealFsharpAnalyzer = class {
+  analyze(rootNode, content, filePath, context) {
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    const publishedNames = /* @__PURE__ */ new Set();
+    const fqnOfName = /* @__PURE__ */ new Map();
+    const qualifyScope = (n) => n === void 0 ? void 0 : fqnOfName.get(n) ?? n;
+    const publishedQnames = /* @__PURE__ */ new Set();
+    const typeFqnOfName = /* @__PURE__ */ new Map();
+    const publishedTypeNames = /* @__PURE__ */ new Set();
+    const isIdentStart = (c) => c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c === "_";
+    const isIdentPart = (c) => isIdentStart(c) || c >= "0" && c <= "9" || c === "'";
+    const isSpaceChar = (c) => {
+      if (c === " " || c === "	" || c === "\n" || c === "\v" || c === "\f" || c === "\r") return true;
+      if (c === "\xA0" || c === "\uFEFF" || c === "\u1680" || c === "\u2028" || c === "\u2029" || c === "\u202F" || c === "\u205F" || c === "\u3000") return true;
+      const cp = c.codePointAt(0) ?? 0;
+      return cp >= 8192 && cp <= 8202;
+    };
+    const isName = (s) => {
+      if (s.length === 0) return false;
+      if (s.startsWith("`")) {
+        const q = s.length >= 4 && s.startsWith("``") ? 2 : 1;
+        const close = q === 2 ? "``" : "`";
+        if (s.length < q * 2 || !s.endsWith(close)) return false;
+        return !s.slice(q, s.length - q).includes("`");
+      }
+      if (s.startsWith("(")) {
+        if (s.length < 3 || !s.endsWith(")")) return false;
+        for (let i = 1; i < s.length - 1; i++) {
+          const c = s[i];
+          if (c === "(" || c === ")" || isSpaceChar(c)) return false;
+        }
+        return true;
+      }
+      if (!isIdentStart(s[0])) return false;
+      for (let i = 1; i < s.length; i++) if (!isIdentPart(s[i])) return false;
+      return true;
+    };
+    const localNames = /* @__PURE__ */ new Set();
+    const openedScopes = /* @__PURE__ */ new Set();
+    const moduleLike = (seg) => !!seg && seg.length > 0 && seg[0] >= "A" && seg[0] <= "Z";
+    const targetSpelling = (written, enclosingType, position = "type") => {
+      const parts = written.split(".");
+      if (!parts.every(isName)) {
+        const last = [...parts].reverse().find(isName);
+        if (last) {
+          const prefix = written.slice(0, written.lastIndexOf(last));
+          const cut = prefix.endsWith(".") ? prefix.slice(0, -1) : prefix;
+          return { target: last, resolution: "call-chain-receiver", ...cut ? { qualifier: cut } : {} };
+        }
+        return { target: written, resolution: "not-a-name" };
+      }
+      const leaf = parts[parts.length - 1] || written;
+      if (parts.length === 1) {
+        if (localNames.has(written)) return { target: written, resolution: "local-binding" };
+        const fqn = fqnOfName.get(written);
+        return fqn ? { target: fqn, resolution: "in-file-declaration" } : { target: written, resolution: "bare-external" };
+      }
+      const head = parts[0];
+      const qualifier = parts.slice(0, -1).join(".");
+      if (head === "this") {
+        return enclosingType ? { target: `${enclosingType}.${leaf}`, resolution: "self-member" } : { target: leaf, resolution: "self-member-unknown-type", qualifier };
+      }
+      if (head === "base") {
+        const b = enclosingType ? baseTypes.get(enclosingType) : void 0;
+        const bLeaf = b ? b.split(".").pop() : void 0;
+        return bLeaf && fqnOfName.has(bLeaf) ? { target: `${bLeaf}.${leaf}`, resolution: "base-member" } : { target: leaf, resolution: "base-member-external", qualifier };
+      }
+      if (publishedQnames.has(written)) return { target: written, resolution: "in-file-qualified", qualifier };
+      const penult = parts[parts.length - 2];
+      if (position === "member") {
+        if (parts.length > 2 && moduleLike(penult)) {
+          const two = `${penult}.${leaf}`;
+          if (publishedQnames.has(two)) return { target: two, resolution: "in-file-qualified", qualifier };
+          return { target: two, resolution: "module-member", qualifier };
+        }
+        if (parts.length === 2 && moduleLike(head)) {
+          return {
+            target: written,
+            resolution: openedScopes.has(head) ? "opened-module" : "external-type-or-module",
+            qualifier
+          };
+        }
+        return { target: leaf, resolution: "receiver-value", qualifier };
+      }
+      if (openedScopes.has(head)) return { target: leaf, resolution: "opened-module", qualifier };
+      return { target: leaf, resolution: moduleLike(head) ? "external-type-or-module" : "receiver-value", qualifier };
+    };
+    const bindingSpelled = (owner, spelled) => spelled.resolution === "local-binding" && owner ? { ...spelled, target: `${owner}${BINDING_SEP}${spelled.target}`, localBinding: true } : spelled;
+    const publish = (s) => {
+      if (s?.name) publishedNames.add(s.name);
+      const owner = String(s?.ownerName ?? "");
+      if (owner.length > 0 && s?.name) {
+        const metadata = s.metadata ?? {};
+        if (metadata.fqn === void 0) metadata.fqn = `${owner}.${s.name}`;
+        s.metadata = metadata;
+      }
+      if (s?.name && !fqnOfName.has(s.name)) {
+        const metadata = s.metadata ?? {};
+        const fqn = typeof metadata.fqn === "string" ? metadata.fqn : s.name;
+        fqnOfName.set(s.name, fqn);
+        publishedQnames.add(fqn);
+      }
+      if (s?.name && TYPE_POSITION_KINDS.has(String(s.kind ?? ""))) {
+        publishedTypeNames.add(s.name);
+        if (!typeFqnOfName.has(s.name)) {
+          const metadata = s.metadata ?? {};
+          const fqn = typeof metadata.fqn === "string" ? metadata.fqn : s.name;
+          typeFqnOfName.set(s.name, fqn);
+        }
+      }
+      symbols.push(s);
+    };
+    const seenRels = /* @__PURE__ */ new Set();
+    const pushRel = (source, target, type, confidence, metadata = {}, line) => {
+      const hasLine = typeof line === "number" && Number.isInteger(line) && line > 0;
+      const key = `${source}|${type}|${target}|${hasLine ? line : ""}`;
+      if (seenRels.has(key)) return;
+      seenRels.add(key);
+      relationships.push({
+        source,
+        target,
+        type,
+        confidence,
+        metadata,
+        ...hasLine ? { line_number: line } : {}
+      });
+    };
+    const lineOf = (node) => {
+      if (!node) return void 0;
+      const line = node.startPosition.row + 1;
+      return line > 0 ? line : void 0;
+    };
+    const abstractMemberNames = /* @__PURE__ */ new Set();
+    const baseTypes = /* @__PURE__ */ new Map();
+    const typeNamesDeclaredInFile = this.collectDeclaredTypeNames(rootNode);
+    const fileScope = this.collectFileScope(rootNode);
+    const fileIdentity = this.fsharpFileIdentity(filePath, context);
+    const fileScopeName = fileScope ?? fileIdentity.stem;
+    const typeExtensionsPublished = /* @__PURE__ */ new Set();
+    const moduleNames = /* @__PURE__ */ new Set();
+    const namespaceNames = /* @__PURE__ */ new Set();
+    const walkStack = [{ node: rootNode, scopePath: [], callOwner: void 0, callOwnerQualified: void 0, bodyDepth: 0 }];
+    while (walkStack.length > 0) {
+      const { node, scopePath, callOwner, callOwnerQualified, bodyDepth, asTypeUnit, unitAttributes } = walkStack.pop();
+      const type = node.type;
+      if (type === "ERROR") {
+        errors.push({
+          message: "parse recovery region: the tree here is the parser's reconstruction, not the source",
+          range: { startLine: node.startPosition.row + 1, startColumn: node.startPosition.column, endLine: node.endPosition.row + 1, endColumn: node.endPosition.column },
+          severity: "warning"
+        });
+        continue;
+      }
+      if (node.isMissing) {
+        errors.push({
+          message: `missing ${node.type} \u2014 the parser inserted this token`,
+          range: { startLine: node.startPosition.row + 1, startColumn: node.startPosition.column, endLine: node.endPosition.row + 1, endColumn: node.endPosition.column },
+          severity: "warning"
+        });
+        continue;
+      }
+      let currentScope = [...scopePath];
+      let childCallOwner = callOwner;
+      let childCallOwnerQualified = callOwnerQualified;
+      let childBodyDepth = bodyDepth;
+      if (type === "namespace" || type === "named_module" || type === "module_defn") {
+        const nameNode = this.findChild(node, (n) => n.type === "identifier" || n.type === "long_identifier");
+        if (nameNode && nameNode.text) {
+          const name = nameNode.text;
+          publish({
+            name,
+            kind: type === "namespace" ? ASTEngine.SymbolKind.Namespace : ASTEngine.SymbolKind.Module,
+            range: this.nodeToRange(node),
+            ownerName: currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0,
+            metadata: { nodeType: type }
+          });
+          if (type === "namespace") namespaceNames.add(name);
+          else moduleNames.add(name);
+          currentScope.push(name);
+        }
+      } else if (type === "type_definition" || asTypeUnit) {
+        const isExtensionBody = !!this.findChild(node, (n) => n.type === "type_extension");
+        const isForwardDeclaration = !!this.findChild(node, (n) => n.type === "type_declaration");
+        if (!asTypeUnit) {
+          const clauseNodes = this.filterChildren(
+            node,
+            (n) => TYPE_CLAUSE_TYPES.has(n.type) && !!this.findChild(n, (c) => c.type === "type_name")
+          );
+          if (clauseNodes.length >= 2) {
+            const keyOf = (n) => `${n.startIndex}:${n.endIndex}`;
+            const clauseKeys = new Set(clauseNodes.map(keyOf));
+            const attrsOfClause = /* @__PURE__ */ new Map();
+            const pending = [];
+            for (let i = 0; i < node.namedChildCount; i++) {
+              const c = node.namedChild(i);
+              if (!c) continue;
+              if (c.type === "attributes") pending.push(c);
+              else if (clauseKeys.has(keyOf(c))) attrsOfClause.set(keyOf(c), pending.splice(0, pending.length));
+            }
+            const firstKey = keyOf(clauseNodes[0]);
+            if (pending.length > 0) {
+              attrsOfClause.set(firstKey, [...attrsOfClause.get(firstKey) ?? [], ...pending]);
+            }
+            for (let i = node.namedChildCount - 1; i >= 0; i--) {
+              const child = node.namedChild(i);
+              if (!child || child.type === "attributes") continue;
+              const key = keyOf(child);
+              const isClause = clauseKeys.has(key);
+              walkStack.push({
+                node: child,
+                scopePath: currentScope,
+                callOwner: childCallOwner,
+                callOwnerQualified: childCallOwnerQualified,
+                bodyDepth: childBodyDepth,
+                ...isClause ? { asTypeUnit: true, unitAttributes: attrsOfClause.get(key) } : {}
+              });
+            }
+            continue;
+          }
+        }
+        const declarationAttributes = asTypeUnit ? [...unitAttributes ?? [], ...this.filterChildren(node, (n) => n.type === "attributes")] : this.filterChildren(node, (n) => n.type === "attributes");
+        const typeNameNode = this.findDescendant(node, (n) => n.type === "type_name");
+        const typeInfo = typeNameNode ? this.typeInfoOf(typeNameNode) : null;
+        const name = typeInfo?.name ?? null;
+        const accessModifier = this.accessModifierOf(node, typeNameNode ?? null);
+        if (name) {
+          const anonNode = node.type === "anon_type_defn" ? node : this.findChild(node, (n) => n.type === "anon_type_defn");
+          const hasAnonTypeDefn = !!anonNode;
+          const hasRecordTypeDefn = node.type === "record_type_defn" || this.findDescendants(node, (n) => n.type === "record_type_defn").length > 0;
+          const hasUnionTypeDefn = node.type === "union_type_defn" || this.findDescendants(node, (n) => n.type === "union_type_defn").length > 0;
+          const hasInterfaceTypeDefn = node.type === "interface_type_defn" || this.findDescendants(node, (n) => n.type === "interface_type_defn").length > 0;
+          const hasEnumTypeDefn = node.type === "enum_type_defn" || this.findDescendants(node, (n) => n.type === "enum_type_defn").length > 0;
+          const hasDelegateTypeDefn = node.type === "delegate_type_defn" || this.findDescendants(node, (n) => n.type === "delegate_type_defn").length > 0;
+          const hasTypeAbbrevDefn = node.type === "type_abbrev_defn" || this.findDescendants(node, (n) => n.type === "type_abbrev_defn").length > 0;
+          let kind = ASTEngine.SymbolKind.Class;
+          let isInterface = false;
+          const isMeasure = declarationAttributes.some(
+            (attrs) => this.findDescendants(attrs, (n) => n.type === "attribute", 3).some((attr) => {
+              const nm = this.findDescendant(attr, (n) => n.type === "long_identifier", 3) ?? this.findDescendant(attr, (n) => n.type === "identifier", 3);
+              return nm?.text === "Measure" || nm?.text === "MeasureAttribute";
+            })
+          );
+          if (isMeasure) kind = ASTEngine.SymbolKind.Type;
+          if (hasRecordTypeDefn) {
+            kind = ASTEngine.SymbolKind.Class;
+          } else if (hasUnionTypeDefn) {
+            kind = ASTEngine.SymbolKind.Enum;
+          } else if (hasInterfaceTypeDefn) {
+            kind = ASTEngine.SymbolKind.Interface;
+            isInterface = true;
+          } else if (hasEnumTypeDefn) {
+            kind = ASTEngine.SymbolKind.Enum;
+          } else if (hasDelegateTypeDefn) kind = ASTEngine.SymbolKind.Type;
+          else if (hasTypeAbbrevDefn) kind = ASTEngine.SymbolKind.Type;
+          else if (hasAnonTypeDefn) {
+            if (anonNode) {
+              const memberSigs = this.findDescendants(anonNode, (n) => n.type === "member_signature");
+              const hasMemberSig = memberSigs.length > 0;
+              const hasInherits = this.findDescendants(anonNode, (n) => n.type === "class_inherits_decl").length > 0;
+              const hasInterfaceImpl = this.findDescendants(anonNode, (n) => n.type === "interface_implementation").length > 0;
+              const hasConcreteMembers = this.findDescendants(
+                anonNode,
+                (n) => n.type === "member_defn" && !this.findDescendant(n, (child) => child.type === "member_signature")
+              ).length > 0;
+              if (hasMemberSig && !hasInherits && !hasInterfaceImpl && !hasConcreteMembers) {
+                kind = ASTEngine.SymbolKind.Interface;
+                isInterface = true;
+              }
+            }
+          }
+          const isExtensionOnly = isExtensionBody && !typeNamesDeclaredInFile.has(name) && !typeExtensionsPublished.has(name);
+          if (!isExtensionBody || isExtensionOnly) {
+            publish({
+              name,
+              kind,
+              range: this.nodeToRange(node),
+              ownerName: currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0,
+              genericParameters: typeInfo?.genericParameters,
+              metadata: {
+                nodeType: type,
+                ...isExtensionBody ? { isTypeExtension: true } : {},
+                ...isForwardDeclaration ? { isForwardDeclaration: true } : {},
+                ...accessModifier ? { accessModifier } : {}
+              }
+            });
+          }
+          if (isExtensionBody) typeExtensionsPublished.add(name);
+          currentScope.push(name);
+          const inherits = this.findDescendants(node, (n) => n.type === "class_inherits_decl", 8);
+          if (inherits.length > 0) {
+            const firstInherit = inherits[0];
+            const baseType = this.findDescendant(firstInherit, (n) => n.type === "long_identifier" || n.type === "identifier");
+            if (baseType?.text) baseTypes.set(name, baseType.text);
+          }
+          if (hasRecordTypeDefn) {
+            const fields = this.findDescendants(node, (n) => n.type === "record_field");
+            for (const field of fields) {
+              const fieldName = this.findChild(field, (n) => n.type === "identifier");
+              if (!fieldName?.text) continue;
+              publish({
+                name: fieldName.text,
+                kind: ASTEngine.SymbolKind.Property,
+                range: this.nodeToRange(field),
+                ownerName: name,
+                ownerKind: kind,
+                metadata: { nodeType: "record_field", isRecordField: true }
+              });
+            }
+          }
+          if (kind === ASTEngine.SymbolKind.Enum) {
+            const unionDefns = node.type === "union_type_defn" ? [node] : this.findDescendants(node, (n) => n.type === "union_type_defn");
+            for (const unionDefn of unionDefns) {
+              const cases = this.findDescendants(unionDefn, (n) => n.type === "union_type_case");
+              for (const c of cases) {
+                const caseNameNode = this.findDescendant(c, (n) => n.type === "identifier");
+                if (caseNameNode && caseNameNode.text) {
+                  publish({
+                    name: caseNameNode.text,
+                    kind: ASTEngine.SymbolKind.EnumMember,
+                    range: this.nodeToRange(c),
+                    ownerName: name,
+                    metadata: { nodeType: "union_type_case" }
+                  });
+                }
+              }
+            }
+          }
+          const enumDefns = node.type === "enum_type_defn" ? [node] : this.findDescendants(node, (n) => n.type === "enum_type_defn");
+          for (const enumDefn of enumDefns) {
+            const cases = this.findDescendants(enumDefn, (n) => n.type === "enum_type_case");
+            for (const c of cases) {
+              const caseNameNode = this.findDescendant(c, (n) => n.type === "identifier");
+              if (caseNameNode && caseNameNode.text) {
+                publish({
+                  name: caseNameNode.text,
+                  kind: ASTEngine.SymbolKind.EnumMember,
+                  range: this.nodeToRange(c),
+                  ownerName: name,
+                  metadata: { nodeType: "enum_type_case" }
+                });
+              }
+            }
+          }
+          const ifaceImpls = this.findDescendants(node, (n) => n.type === "interface_implementation", 8);
+          for (const impl of ifaceImpls) {
+            const ifaceType = this.findDescendant(impl, (n) => n.type === "long_identifier" || n.type === "identifier");
+            const writtenIface = ifaceType ? ifaceType.text : null;
+            if (writtenIface) {
+              const leaf = writtenIface.includes(".") ? writtenIface.split(".").pop() : writtenIface;
+              pushRel(
+                qualifyScope(name) ?? name,
+                leaf,
+                ASTEngine.RelationshipType.Implements,
+                1,
+                {
+                  // FS-P7-1: the reason, and the spelling that was discarded to get here.
+                  // `qualifiedType` below IS that discarded spelling (R10's record, kept
+                  // because two fixtures pin it), so this site carries the REASON only and
+                  // the census reads `targetWritten ?? qualifiedType`.
+                  nodeType: "interface_implementation",
+                  targetResolution: UNRESOLVED_TYPE,
+                  ...leaf !== writtenIface ? { qualifiedType: writtenIface } : {}
+                },
+                lineOf(ifaceType)
+              );
+            }
+          }
+          for (const inh of inherits) {
+            const baseType = this.findDescendant(inh, (n) => n.type === "long_identifier" || n.type === "identifier");
+            const writtenName = baseType ? baseType.text : null;
+            if (writtenName) {
+              const leaf = writtenName.includes(".") ? writtenName.split(".").pop() : writtenName;
+              pushRel(
+                qualifyScope(name) ?? name,
+                leaf,
+                ASTEngine.RelationshipType.Extends,
+                1,
+                {
+                  nodeType: "class_inherits_decl",
+                  targetResolution: UNRESOLVED_TYPE,
+                  ...leaf !== writtenName ? { qualifiedType: writtenName } : {}
+                },
+                lineOf(baseType)
+              );
+            }
+          }
+        }
+      } else if (type === "value_declaration" || type === "function_or_value_defn" || type === "member_defn") {
+        if (bodyDepth > 0 && (type === "value_declaration" || type === "function_or_value_defn")) {
+          const localName = this.declaredBindingName(node);
+          if (localName) localNames.add(String(localName));
+          childCallOwner = callOwner;
+          childCallOwnerQualified = callOwnerQualified;
+          childBodyDepth = bodyDepth;
+        } else {
+          let nameNode = this.findChild(
+            node,
+            (n) => !!n.text && (n.type === "identifier" || n.type === "long_identifier" || n.type === "identifier_pattern")
+          );
+          if (!nameNode) {
+            const leftNode = this.findChild(
+              node,
+              (n) => n.type === "function_declaration_left" || n.type === "value_declaration_left"
+            );
+            if (leftNode) {
+              nameNode = this.findChild(leftNode, (n) => n.type === "identifier" || n.type === "identifier_pattern");
+              if (nameNode?.type === "identifier_pattern") {
+                nameNode = this.patternNameNode(nameNode) ?? nameNode;
+              }
+            }
+          }
+          if (!nameNode) {
+            const mopNode = this.findChild(node, (n) => n.type === "method_or_prop_defn");
+            if (mopNode) {
+              const propNode = this.findChild(mopNode, (n) => n.type === "property_or_ident");
+              if (propNode) {
+                const idents = this.filterChildren(propNode, (n) => n.type === "identifier");
+                nameNode = idents.length >= 2 ? idents[idents.length - 1] : idents[0];
+              }
+            }
+          }
+          if (nameNode && nameNode.text) {
+            const name = nameNode.text;
+            const isFunc = !!this.findChild(
+              node,
+              (n) => n.type === "function_declaration_left" || n.type === "argument_patterns" || n.type === "argument_spec" || n.type === "arguments_spec"
+            );
+            const isMember = type === "member_defn";
+            const hasMethodOrProp = !!this.findChild(node, (n) => n.type === "method_or_prop_defn");
+            const owner = currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0;
+            const isAbstractDefaultImpl = isMember && !!owner && abstractMemberNames.has(`${owner}:${name}`);
+            if (!isAbstractDefaultImpl) {
+              let kind;
+              let isProperty = false;
+              if (isMember && hasMethodOrProp) {
+                const mopNode = this.findChild(node, (n) => n.type === "method_or_prop_defn");
+                if (mopNode) {
+                  const argsNode = mopNode.childForFieldName?.("args") ?? null;
+                  if (argsNode) {
+                    isProperty = false;
+                  } else {
+                    let afterIdent = false;
+                    for (let i = 0; i < mopNode.namedChildCount; i++) {
+                      const c = mopNode.namedChild(i);
+                      if (!c) continue;
+                      if (c.type === "property_or_ident") {
+                        afterIdent = true;
+                        continue;
+                      }
+                      if (afterIdent) {
+                        if (c.type === "paren_pattern" || c.type === "argument_patterns" || c.type === "identifier_pattern" || c.type === "typed_pattern" || c.type === "wildcard_pattern" || c.type === "list_pattern" || c.type === "optional_pattern" || c.type === "const" && c.text === "()") {
+                          isProperty = false;
+                          break;
+                        }
+                        isProperty = true;
+                        break;
+                      }
+                    }
+                  }
+                }
+                kind = isProperty ? ASTEngine.SymbolKind.Property : ASTEngine.SymbolKind.Method;
+              } else if (isMember) {
+                kind = ASTEngine.SymbolKind.Method;
+              } else {
+                kind = isFunc ? ASTEngine.SymbolKind.Function : ASTEngine.SymbolKind.Variable;
+              }
+              const isAsync = !!this.findDescendant(
+                node,
+                (n) => n.type === "ce_expression" || n.type === "short_comp_expression",
+                4
+              );
+              const memberAccess = this.accessModifierOf(node, null);
+              publish({
+                name,
+                kind,
+                range: this.nodeToRange(node),
+                ownerName: owner,
+                isAsync,
+                metadata: { nodeType: type, ...memberAccess ? { accessModifier: memberAccess } : {} }
+              });
+              const extraLefts = [];
+              for (let i = 0; i < node.namedChildCount; i++) {
+                const c = node.namedChild(i);
+                if (c && (c.type === "function_declaration_left" || c.type === "value_declaration_left")) {
+                  extraLefts.push(c);
+                }
+              }
+              for (let k = 1; k < extraLefts.length; k++) {
+                const andName = this.nameOfDeclarationLeft(extraLefts[k]);
+                if (andName && andName !== name) {
+                  publish({
+                    name: andName,
+                    kind,
+                    range: this.nodeToRange(node),
+                    ownerName: owner,
+                    isAsync,
+                    metadata: { nodeType: type, isMutualRecursionClause: true }
+                  });
+                }
+              }
+              if (isMember && this.firstTokenIs(node, "override")) {
+                const qualifiedSource = owner ? `${owner}.${name}` : name;
+                const implementedInterface = this.enclosingInterfaceImplementationLeaf(node);
+                if (implementedInterface) {
+                  pushRel(
+                    qualifiedSource,
+                    `${implementedInterface}.${name}`,
+                    ASTEngine.RelationshipType.Overrides,
+                    1,
+                    {
+                      nodeType: type,
+                      isOverride: true,
+                      relationshipType: "interface_member_implementation",
+                      isInterfaceMemberImplementation: true,
+                      targetResolution: UNRESOLVED_INTERFACE
+                    },
+                    lineOf(node)
+                  );
+                } else {
+                  const baseName = owner ? baseTypes.get(owner) : void 0;
+                  if (baseName) {
+                    pushRel(
+                      qualifiedSource,
+                      `${baseName}.${name}`,
+                      ASTEngine.RelationshipType.Overrides,
+                      1,
+                      {
+                        nodeType: type,
+                        isOverride: true,
+                        targetResolution: UNRESOLVED_BASE,
+                        // The base is stored AS WRITTEN (`baseTypes` takes `baseType.text`), so
+                        // `inherit System.Exception()` spells the target
+                        // `System.Exception.ToString` — three segments whose store tail
+                        // (everything after the FIRST dot) is `Exception.ToString`, which no
+                        // symbol is named. The leaf form `Exception.ToString` can reach
+                        // strategy 3's tail (`ToString`) instead.
+                        //
+                        // PRICED AND DECLINED, FS-P7-2's method applied to this site
+                        // (`.tmp-probe/fs-p7-base.py`, arm `rows-pass10-meta.ndjson`): the
+                        // tempting reading is that 542 `base-member-external` rows are all
+                        // three-segment spellings, and they are not — only 6 carry a DOTTED
+                        // written base, because `inherit Base()` with a bare name already
+                        // spells the leaf. Respelling those 6 moves **+3 determinate / −0**
+                        // and converts 3 UNATTACHED edges into ARBITRARY ones
+                        // (`none -> ambiguous`: the store now picks MIN(id) among several
+                        // symbols named `Invoke`). An arbitrary attachment is not a gain
+                        // under this lane's accounting — it is the analyzer saying nothing
+                        // while the store says something — so the as-written base stands and
+                        // the number lives here rather than in a TODO.
+                        ...baseName.includes(".") ? { targetWritten: baseName } : {}
+                      },
+                      lineOf(node)
+                    );
+                  }
+                }
+              }
+              if (kind === ASTEngine.SymbolKind.Property && !this.hasExplicitSetter(node)) {
+                childCallOwner = void 0;
+                childCallOwnerQualified = void 0;
+              } else {
+                childCallOwner = name;
+                childCallOwnerQualified = owner ? `${owner}.${name}` : name;
+              }
+              childBodyDepth = bodyDepth + 1;
+            } else {
+              childCallOwner = name;
+              childCallOwnerQualified = owner ? `${owner}.${name}` : name;
+              childBodyDepth = bodyDepth + 1;
+            }
+          }
+        }
+      } else if (type === "additional_constr_defn") {
+        const nameNode = this.findDescendant(node, (n) => n.type === "identifier" || n.type === "long_identifier");
+        if (nameNode && nameNode.text) {
+          const owner = currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0;
+          publish({
+            name: "constructor",
+            kind: ASTEngine.SymbolKind.Constructor,
+            range: this.nodeToRange(node),
+            ownerName: owner,
+            metadata: { nodeType: "additional_constr_defn" }
+          });
+          childCallOwner = "constructor";
+          childCallOwnerQualified = owner ? `${owner}.constructor` : "constructor";
+          childBodyDepth = bodyDepth + 1;
+        }
+      } else if (type === "member_signature") {
+        const nameNode = this.findChild(node, (n) => n.type === "identifier" || n.type === "property_or_ident");
+        if (nameNode && nameNode.text) {
+          const owner = currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0;
+          publish({
+            name: nameNode.text,
+            kind: ASTEngine.SymbolKind.Method,
+            range: this.nodeToRange(node),
+            ownerName: owner,
+            metadata: { nodeType: "member_signature" }
+          });
+          if (owner) abstractMemberNames.add(`${owner}:${nameNode.text}`);
+        }
+      } else if (type === "value_declaration" && bodyDepth > 0) {
+        childCallOwner = callOwner;
+        childCallOwnerQualified = callOwnerQualified;
+        childBodyDepth = bodyDepth;
+      } else if (type === "object_expression") {
+        const iface = this.objectExpressionInterface(node);
+        if (iface) {
+          const { written, leaf } = iface;
+          const ownerName = currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0;
+          publish({
+            name: "new " + written,
+            kind: ASTEngine.SymbolKind.Class,
+            range: this.nodeToRange(node),
+            ownerName,
+            metadata: { nodeType: "object_expression" }
+          });
+          currentScope.push("new " + written);
+          if (ownerName) {
+            pushRel(
+              qualifyScope(ownerName) ?? ownerName,
+              leaf,
+              ASTEngine.RelationshipType.Implements,
+              1,
+              { nodeType: "object_expression", targetResolution: UNRESOLVED_TYPE, ...leaf !== written ? { qualifiedType: written } : {} },
+              lineOf(node)
+            );
+          }
+        }
+      } else if (type === "active_pattern") {
+        publish({
+          name: node.text,
+          kind: ASTEngine.SymbolKind.Function,
+          range: this.nodeToRange(node),
+          ownerName: currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0,
+          metadata: { nodeType: "active_pattern" }
+        });
+      } else if (type === "exception_definition") {
+        const nameNode = this.findDescendant(node, (n) => n.type === "identifier");
+        if (nameNode && nameNode.text) {
+          publish({
+            name: nameNode.text,
+            kind: ASTEngine.SymbolKind.Class,
+            range: this.nodeToRange(node),
+            ownerName: currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0,
+            metadata: { nodeType: "exception_definition" }
+          });
+        }
+      } else if (type === "module_val_declaration") {
+        const nameNode = this.findChild(node, (n) => n.type === "identifier");
+        if (nameNode?.text) {
+          publish({
+            name: nameNode.text,
+            kind: ASTEngine.SymbolKind.Function,
+            range: this.nodeToRange(node),
+            ownerName: currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0,
+            metadata: { nodeType: "module_val_declaration", isDeclaration: true }
+          });
+        }
+      } else if (type === "type_extension") {
+        const typeNameNode = this.findChild(node, (n) => n.type === "type_name");
+        const extName = typeNameNode ? this.typeInfoOf(typeNameNode)?.name ?? null : null;
+        if (extName) currentScope.push(extName);
+      } else if (type === "attribute") {
+        const attrNameNode = this.findDescendant(node, (n) => n.type === "identifier" || n.type === "long_identifier");
+        if (attrNameNode && attrNameNode.text) {
+          const attrText = attrNameNode.text;
+          if (attrText.includes("TypeProvider") || attrText.includes("TypeProviderAssembly")) {
+            publish({
+              name: attrText,
+              kind: ASTEngine.SymbolKind.Class,
+              range: this.nodeToRange(node),
+              ownerName: currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0,
+              metadata: { nodeType: "attribute", isTypeProvider: true }
+            });
+          }
+        }
+        const attrTarget = node.childForFieldName("target");
+        let attrTypeNode = null;
+        for (let i = 0; i < node.childCount; i++) {
+          const c = node.child(i);
+          if (!c || !c.isNamed) continue;
+          if (node.fieldNameForChild(i) === "target") continue;
+          const named = this.typeNameNodeOf(c);
+          if (named) {
+            attrTypeNode = named;
+            break;
+          }
+        }
+        const attrName = attrTypeNode ? this.dependencyLeafName(attrTypeNode) : null;
+        const attrWritten = attrTypeNode ? String(attrTypeNode.text) : null;
+        if (attrName) {
+          const attrOwner = currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0;
+          const spelledAttr = targetSpelling(attrWritten ?? attrName, attrOwner, "type");
+          pushRel(
+            qualifyScope(attrOwner) || qualifyScope(fileScope) || "Global",
+            spelledAttr.target,
+            ASTEngine.RelationshipType.Uses,
+            1,
+            {
+              nodeType: type,
+              relationshipType: "attribute_application",
+              isAttributeUsage: true,
+              targetResolution: spelledAttr.resolution,
+              ...spelledAttr.qualifier ? { targetQualifier: spelledAttr.qualifier } : {},
+              ...attrTarget ? { attributeTarget: attrTarget.text } : {}
+            },
+            attrTypeNode ? lineOf(attrTypeNode) : lineOf(node)
+          );
+        }
+      } else if (type === "module_abbrev") {
+        const aliasNode = this.filterChildren(node, (n) => n.type === "identifier")[0];
+        const pathNode = this.filterChildren(node, (n) => n.type === "long_identifier").pop();
+        if (pathNode && pathNode.text) {
+          const alias = aliasNode?.text;
+          imports.push({
+            module: pathNode.text,
+            items: [],
+            isDefault: true,
+            alias,
+            range: this.nodeToRange(node)
+          });
+          const abbrevOwner = currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0;
+          pushRel(
+            qualifyScope(abbrevOwner) || qualifyScope(fileScope) || "Global",
+            pathNode.text,
+            ASTEngine.RelationshipType.Imports,
+            1,
+            { nodeType: type, relationshipType: "module_alias", targetResolution: "module-alias-path", ...alias ? { moduleAlias: alias } : {} },
+            lineOf(pathNode)
+          );
+        }
+      } else if (type === "fsi_directive_decl") {
+        const resourceKeywords = /* @__PURE__ */ new Set(["#r", "#I"]);
+        const partKeywords = /* @__PURE__ */ new Set(["#load"]);
+        let directiveKeyword = "";
+        for (let i = 0; i < node.childCount; i++) {
+          const c = node.child(i);
+          if (c && !c.isNamed) {
+            directiveKeyword = c.text;
+            break;
+          }
+        }
+        const specifiers = this.filterChildren(
+          node,
+          (n) => n.type === "string" || n.type === "verbatim_string"
+        );
+        const isPart = partKeywords.has(directiveKeyword);
+        if (specifiers.length > 0 && (resourceKeywords.has(directiveKeyword) || isPart)) {
+          const dirOwner = currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0;
+          const source = qualifyScope(dirOwner) || qualifyScope(fileScope) || "Global";
+          const partSource = qualifyScope(dirOwner) || qualifyScope(fileScope) || fileScopeName;
+          const named = isPart ? specifiers : specifiers.slice(0, 1);
+          for (const specifier of named) {
+            const specifierValue = this.stringLiteralValue(specifier);
+            if (!specifierValue) continue;
+            imports.push({
+              module: specifierValue,
+              items: [],
+              isDefault: false,
+              isExternal: true,
+              path: specifierValue,
+              range: this.nodeToRange(node),
+              metadata: { fsharpSpecific: true, directive: directiveKeyword }
+            });
+            if (isPart) {
+              const partTarget = this.fsharpPartTargetPath(filePath, context, specifierValue);
+              if (partTarget) {
+                pushRel(
+                  partSource,
+                  partTarget,
+                  ASTEngine.RelationshipType.PartOf,
+                  1,
+                  {
+                    nodeType: type,
+                    relationshipType: "part_directive",
+                    directive: directiveKeyword,
+                    partRole: "library",
+                    targetResolution: "project-relative-path"
+                  },
+                  lineOf(specifier)
+                );
+              }
+            } else {
+              pushRel(
+                source,
+                specifierValue,
+                ASTEngine.RelationshipType.Imports,
+                1,
+                { nodeType: type, relationshipType: "resource_directive", directive: directiveKeyword, targetResolution: "resource-path" },
+                lineOf(specifier)
+              );
+            }
+          }
+        }
+      } else if (type === "import_decl") {
+        const targetNode = this.findChild(node, (n) => n.type === "long_identifier" || n.type === "identifier");
+        if (targetNode && targetNode.text) {
+          imports.push({
+            module: targetNode.text,
+            items: [],
+            isDefault: true,
+            range: this.nodeToRange(node)
+          });
+          const owner = currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0;
+          const openedHead = String(targetNode.text).split(".")[0];
+          if (openedHead) openedScopes.add(openedHead);
+          pushRel(
+            qualifyScope(owner) || qualifyScope(fileScope) || "Global",
+            targetNode.text,
+            ASTEngine.RelationshipType.References,
+            0.9,
+            { nodeType: type, isImport: true, targetResolution: UNRESOLVED_NAMESPACE },
+            lineOf(node)
+          );
+          pushRel(
+            qualifyScope(owner) || qualifyScope(fileScope) || "Global",
+            targetNode.text,
+            ASTEngine.RelationshipType.Imports,
+            1,
+            { nodeType: type, relationshipType: "open_directive", targetResolution: UNRESOLVED_NAMESPACE, ...this.nodeHasToken(node, "type") ? { opensTypes: true } : {} },
+            lineOf(node)
+          );
+        }
+      } else if (type === "infix_expression") {
+        let opText = "";
+        let opIndex = -1;
+        for (let i = 0; i < node.childCount; i++) {
+          const c = node.child(i);
+          if (c && c.type === "infix_op") {
+            opText = c.text;
+            opIndex = i;
+            break;
+          }
+        }
+        const side = PIPELINE_CALLEE_SIDE.get(opText);
+        if (side && callOwner && opIndex >= 0) {
+          const operandNode = node.child(side === "right" ? opIndex + 1 : opIndex - 1);
+          const calleeNode = this.pipelineCalleeName(operandNode);
+          const calleeText = calleeNode?.text ?? "";
+          const leaf = calleeText.split(".").pop() || calleeText;
+          if (calleeText.length > 1 && !this.isFSharpBuiltin(calleeText, leaf)) {
+            const callSource = callOwnerQualified ?? callOwner;
+            const spelled = bindingSpelled(callSource, targetSpelling(calleeText, currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0, "member"));
+            pushRel(
+              callSource,
+              spelled.target,
+              ASTEngine.RelationshipType.Calls,
+              0.8,
+              {
+                nodeType: type,
+                isPipelineCall: true,
+                pipelineOperator: opText,
+                targetResolution: spelled.resolution,
+                ...spelled.qualifier ? { targetQualifier: spelled.qualifier } : {},
+                ...spelled.localBinding ? { localBinding: true } : {}
+              },
+              lineOf(calleeNode ?? node)
+            );
+          }
+        }
+      } else if (type === "application_expression") {
+        let fnName = "";
+        const fnNode = node.namedChild(0);
+        if (fnNode) {
+          if (fnNode.type === "long_identifier" || fnNode.type === "identifier" || fnNode.type === "long_identifier_or_op") {
+            fnName = fnNode.text;
+          } else if (fnNode.type === "infix_expression") {
+            const rhs = fnNode.namedChild(fnNode.namedChildCount - 1);
+            if (rhs && (rhs.type === "long_identifier" || rhs.type === "identifier" || rhs.type === "long_identifier_or_op")) {
+              fnName = rhs.text;
+            }
+          } else if (fnNode.type === "dot_expression") {
+            fnName = fnNode.text;
+          }
+        }
+        if (fnName && callOwner) {
+          const leaf = fnName.split(".").pop() || fnName;
+          if (!this.isFSharpBuiltin(fnName, leaf)) {
+            const enclosingType = currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0;
+            if (callOwner === "constructor" && leaf === enclosingType) {
+              pushRel(
+                callOwnerQualified ?? callOwner,
+                leaf,
+                ASTEngine.RelationshipType.Instantiates,
+                0.95,
+                { nodeType: type, isConstructorChain: true },
+                lineOf(node)
+              );
+            } else {
+              const callSource = callOwnerQualified ?? callOwner;
+              const spelled = bindingSpelled(callSource, targetSpelling(fnName, enclosingType, "member"));
+              pushRel(
+                callSource,
+                spelled.target,
+                ASTEngine.RelationshipType.Calls,
+                0.8,
+                {
+                  nodeType: type,
+                  targetResolution: spelled.resolution,
+                  ...spelled.qualifier ? { targetQualifier: spelled.qualifier } : {},
+                  ...spelled.localBinding ? { localBinding: true } : {}
+                },
+                lineOf(node)
+              );
+            }
+          }
+        }
+      } else if (type === "prefixed_expression") {
+        if (this.firstTokenIs(node, "new") && callOwner) {
+          const operand = node.namedChild(0);
+          if (operand && operand.type === "application_expression") {
+            const calleeNode = operand.namedChild(0);
+            const calleeText = calleeNode ? calleeNode.text : "";
+            const leaf = calleeText.split(".").pop() || calleeText;
+            if (calleeText && calleeText.length > 1 && !this.isFSharpBuiltin(calleeText, leaf)) {
+              const spelled = targetSpelling(calleeText, currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0, "type");
+              pushRel(
+                callOwnerQualified ?? callOwner,
+                spelled.target,
+                ASTEngine.RelationshipType.Instantiates,
+                0.95,
+                {
+                  nodeType: type,
+                  isNewConstruction: true,
+                  targetResolution: spelled.resolution,
+                  ...spelled.qualifier ? { targetQualifier: spelled.qualifier } : {}
+                },
+                lineOf(node)
+              );
+              for (let i = operand.namedChildCount - 1; i >= 0; i--) {
+                const argChild = operand.namedChild(i);
+                if (argChild) {
+                  walkStack.push({ node: argChild, scopePath: currentScope, callOwner: childCallOwner, callOwnerQualified: childCallOwnerQualified, bodyDepth: childBodyDepth });
+                }
+              }
+              continue;
+            }
+          }
+        }
+      } else if (type === "compiler_directive_decl") {
+        const nameNode = this.findDescendant(node, (n) => n.type === "identifier" || n.type === "long_identifier");
+        if (nameNode && nameNode.text) {
+          publish({
+            name: nameNode.text,
+            kind: ASTEngine.SymbolKind.Macro,
+            range: this.nodeToRange(node),
+            ownerName: currentScope.length > 0 ? currentScope[currentScope.length - 1] : void 0,
+            metadata: { nodeType: type }
+          });
+        }
+      }
+      if (asTypeUnit) {
+        for (const attrs of unitAttributes ?? []) {
+          walkStack.push({ node: attrs, scopePath: currentScope, callOwner: childCallOwner, callOwnerQualified: childCallOwnerQualified, bodyDepth: childBodyDepth });
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) {
+          walkStack.push({ node: child, scopePath: currentScope, callOwner: childCallOwner, callOwnerQualified: childCallOwnerQualified, bodyDepth: childBodyDepth });
+        }
+      }
+    }
+    const parentNameCounts = /* @__PURE__ */ new Map();
+    const ownerlessUnitNames = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if (!s.name) continue;
+      if (!s.ownerName) ownerlessUnitNames.add(s.name);
+      else parentNameCounts.set(String(s.ownerName), (parentNameCounts.get(String(s.ownerName)) ?? 0) + 1);
+    }
+    const fqnByName = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      if (!s.name) continue;
+      const fqn = typeof s.metadata?.fqn === "string" ? s.metadata.fqn : null;
+      const prev = fqnByName.get(s.name);
+      if (prev === void 0) fqnByName.set(s.name, fqn);
+      else if (prev !== fqn) fqnByName.set(s.name, null);
+    }
+    for (const s of symbols) {
+      const _owner = s.ownerName || s.scope;
+      if (_owner && _owner !== s.name) {
+        const childFqn = typeof s.metadata?.fqn === "string" ? s.metadata.fqn : s.name;
+        const parentFqn = fqnByName.get(String(_owner));
+        pushRel(
+          parentFqn || String(_owner),
+          childFqn,
+          ASTEngine.RelationshipType.Contains,
+          1,
+          {
+            nodeType: s.metadata?.nodeType || "symbol",
+            isContained: true,
+            // FS-P7-1. Both ends of a containment edge get a reason, because both ends
+            // have one and only the target's was ever written down.
+            //
+            // The TARGET is always an identity this file minted, so it needs no class
+            // beyond that fact: `contains` cannot spell its child any other way — the
+            // child IS the symbol, and re-spelling it would attach the edge to a
+            // different symbol. What the class does is make the residual auditable: a
+            // target that does not resolve is a target the CORPUS duplicates (the `.fs`
+            // and `.fsi` halves of one declaration, or two files declaring the same
+            // identity), never an analyzer guess.
+            targetResolution: "published-identity",
+            // The SOURCE is the parent's identity when the file has exactly one symbol of
+            // that name, and the bare owner NAME when it has two with different
+            // identities (`fqnByName` nulls the ambiguous case) — a real loss of one end,
+            // invisible until it is named.
+            //
+            // THREE classes, not two, because a top-level unit is not an ambiguity: a
+            // module with no owner IS its own name, and calling that ambiguous (the first
+            // draft did) mislabelled every module-scoped containment in the corpus.
+            sourceResolution: parentFqn ? "in-file-declaration" : ownerlessUnitNames.has(String(_owner)) ? "ownerless-unit" : (parentNameCounts.get(String(_owner)) ?? 0) > 1 ? "ambiguous-owner-name" : "in-file-declaration"
+          },
+          s.range?.startLine
+        );
+      }
+    }
+    this.extractDeclaredTypeRefs(rootNode, pushRel, publishedNames, fqnOfName, typeFqnOfName);
+    const exportedNames = /* @__PURE__ */ new Set();
+    const declaredUnits = new Set(
+      symbols.filter((s) => !s.ownerName && s.metadata?.isForwardDeclaration !== true).map((s) => s.name)
+    );
+    for (const s of symbols) {
+      if (s.kind === ASTEngine.SymbolKind.Variable) continue;
+      if (s.kind === ASTEngine.SymbolKind.EnumMember) continue;
+      const isForwardDecl = s.metadata?.isForwardDeclaration === true;
+      if (isForwardDecl && declaredUnits.has(s.name)) continue;
+      const visibility = this.visibilityOf(s);
+      if (visibility === "private" || visibility === "internal") continue;
+      const isTypeMember = !!s.ownerName && !moduleNames.has(s.ownerName) && !namespaceNames.has(s.ownerName);
+      if (isTypeMember) continue;
+      if (!s.ownerName && (s.kind === ASTEngine.SymbolKind.Property || s.kind === ASTEngine.SymbolKind.Method)) continue;
+      if (exportedNames.has(s.name)) continue;
+      exportedNames.add(s.name);
+      exports.push({ name: s.name, kind: s.kind, range: s.range, visibility });
+      const exportTarget = typeof s.metadata?.fqn === "string" ? s.metadata.fqn : s.name;
+      const exportOwner = s.ownerName || s.scope;
+      const exportParent = exportOwner ? fqnByName.get(String(exportOwner)) || String(exportOwner) : null;
+      pushRel(
+        exportParent || "Global",
+        exportTarget,
+        ASTEngine.RelationshipType.Exports,
+        1,
+        {
+          nodeType: s.metadata?.nodeType || "symbol",
+          // WHICH rule of the FS-D8 surface published this name, so a consumer can tell an
+          // export from a containment row without re-deriving the filter.
+          exportForm: "module-surface",
+          declaredKind: s.kind,
+          visibility,
+          publishedBy: exportOwner ? "enclosing-scope" : "file-scope",
+          // The SAME three-valued source class `contains` writes (FS-P7-1), because the
+          // lookup and its two failure modes are the same lookup: a top-level unit is not
+          // an ambiguity, an owner the file published twice is, and a source that fell
+          // back to the bare owner name says so rather than reading as a declaration.
+          sourceResolution: exportParent ? "in-file-declaration" : ownerlessUnitNames.has(String(exportOwner)) ? "ownerless-unit" : (parentNameCounts.get(String(exportOwner)) ?? 0) > 1 ? "ambiguous-owner-name" : "in-file-declaration",
+          targetResolution: "published-identity"
+        },
+        s.range?.startLine
+      );
+    }
+    for (const rel of relationships) {
+      const md = rel.metadata;
+      if (!md) continue;
+      const marker = md.targetResolution;
+      if (marker !== UNRESOLVED_TYPE && marker !== UNRESOLVED_NAMESPACE && marker !== UNRESOLVED_BASE && marker !== UNRESOLVED_INTERFACE) continue;
+      const target = String(rel.target ?? "");
+      const leaf = target.split(".").pop() ?? "";
+      if (marker === UNRESOLVED_TYPE) {
+        const inFile = publishedTypeNames.has(leaf) || publishedQnames.has(target);
+        md.targetResolution = inFile ? "in-file-declaration" : "external-type";
+        continue;
+      }
+      if (marker === UNRESOLVED_NAMESPACE) {
+        md.targetResolution = publishedQnames.has(target) ? "in-file-declaration" : "external-namespace";
+        continue;
+      }
+      const writtenBase = typeof md.targetWritten === "string" && md.targetWritten ? String(md.targetWritten).split(".").pop() ?? "" : target.split(".").slice(0, -1).join(".");
+      const baseInFile = publishedTypeNames.has(writtenBase);
+      md.targetResolution = marker === UNRESOLVED_INTERFACE ? baseInFile ? "interface-member" : "interface-member-external" : baseInFile ? "base-member" : "base-member-external";
+    }
+    const projectIndex = context?.projectIndex;
+    if (projectIndex && relationships.length > 0) {
+      const projectTypes = projectIndex.typeKinds;
+      const projectNames = projectIndex.symbolNames;
+      const projectMemberMap = projectIndex.typeMembers;
+      const projectBaseMap = projectIndex.typeBases;
+      const knowsType = (n) => n.length > 0 && (projectTypes?.has(n) ?? false);
+      const knowsName = (n) => n.length > 0 && ((projectNames?.has(n) ?? false) || knowsType(n));
+      const memberClosure = (t, seen = /* @__PURE__ */ new Set()) => {
+        const direct = projectMemberMap?.get(t);
+        if (direct === void 0) return /* @__PURE__ */ new Set();
+        if (seen.has(t)) return /* @__PURE__ */ new Set();
+        seen.add(t);
+        const out = new Set(direct);
+        for (const b of projectBaseMap?.get(t) ?? []) {
+          for (const m of memberClosure(b, seen)) out.add(m);
+        }
+        return out;
+      };
+      for (const rel of relationships) {
+        const md = rel.metadata;
+        if (!md) continue;
+        const cls = String(md.targetResolution ?? "");
+        const target = String(rel.target ?? "");
+        const leaf = target.split(".").pop() ?? "";
+        const writtenOwner = (() => {
+          const q = typeof md.targetQualifier === "string" ? md.targetQualifier : "";
+          const w = typeof md.targetWritten === "string" ? md.targetWritten : "";
+          const qt = typeof md.qualifiedType === "string" ? md.qualifiedType : "";
+          const own = target.includes(".") ? target.slice(0, target.lastIndexOf(".")) : "";
+          return q || w || qt || own;
+        })();
+        const ownerHead = writtenOwner.split(".")[0] ?? "";
+        const ownerLeaf = writtenOwner.split(".").pop() ?? "";
+        let next = "";
+        if (cls === "bare-external") {
+          if (knowsName(leaf)) next = "in-project-name";
+        } else if (cls === "external-type-or-module") {
+          if (knowsType(writtenOwner) || knowsName(writtenOwner)) next = "in-project-type-or-module";
+        } else if (cls === "external-namespace") {
+          if (knowsName(target)) next = "in-project-namespace";
+        } else if (cls === "external-type") {
+          if (knowsName(leaf)) next = "in-project-type";
+        } else if (cls === "base-member-external" || cls === "interface-member-external") {
+          const baseLeaf = ownerLeaf;
+          if (knowsType(baseLeaf)) {
+            next = cls === "interface-member-external" ? "interface-member-in-project" : "base-member-in-project";
+            if (projectMemberMap?.has(baseLeaf)) {
+              const members = memberClosure(baseLeaf);
+              if (members.size > 0 && !members.has(leaf)) md.baseInProjectLacksMember = true;
+            }
+          }
+        }
+        if (next !== "") {
+          md.targetResolution = next;
+          md.projectIndexRefined = true;
+        }
+      }
+    }
+    const CAUSE_BASE_CLASSES = /* @__PURE__ */ new Set([
+      "external-type-or-module",
+      // the owner is module-like and NOT opened here (:537, :548)
+      "external-namespace",
+      // the namespace path is not an identity this file minted (:2428)
+      "module-member",
+      // `penult.leaf`, the two-segment form unpublished here (:532)
+      "base-member-external",
+      // the base type is not in this file (:520, :2439)
+      "interface-member-external"
+      // ditto, for the interface form (:2439)
+    ]);
+    const isPlainIdentifier = (t) => {
+      if (t.length === 0) return false;
+      const head = t.charCodeAt(0);
+      const headOk = head >= 65 && head <= 90 || head >= 97 && head <= 122 || head === 95 || head === 36;
+      if (!headOk) return false;
+      for (let i = 1; i < t.length; i++) {
+        const c = t.charCodeAt(i);
+        const ok = c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 95 || c === 36;
+        if (!ok) return false;
+      }
+      return true;
+    };
+    const CAUSE_BASE_SHAPE = { test: isPlainIdentifier };
+    const EXTERNAL_CLAIM_KEYS = [
+      "zigExternalRef",
+      "nimStdlibModule",
+      "isExternal",
+      "isExternalTarget",
+      "external",
+      "externalRef",
+      "isStdlib",
+      "stdlibModule",
+      "moduleNamingEdges",
+      "markAsExternal",
+      "isExternalBase",
+      "importOutsideProject"
+    ];
+    for (const rel of relationships) {
+      const md = rel.metadata;
+      if (!md) continue;
+      if (!CAUSE_BASE_CLASSES.has(String(md.targetResolution ?? ""))) continue;
+      if (md.projectIndexRefined === true) continue;
+      if (EXTERNAL_CLAIM_KEYS.some((k) => md[k] === true || Array.isArray(md[k]) && md[k].length > 0)) continue;
+      const target = String(rel.target ?? "");
+      const dot = target.lastIndexOf(".");
+      if (dot <= 0) continue;
+      const base = target.slice(0, dot);
+      if (!CAUSE_BASE_SHAPE.test(base)) continue;
+      if (publishedNames.has(base) || publishedQnames.has(base) || publishedTypeNames.has(base) || moduleNames.has(base) || namespaceNames.has(base) || openedScopes.has(base) || localNames.has(base)) continue;
+      md.baseBeyondRunScope = base;
+    }
+    if (fileIdentity.relPath !== null) {
+      publish({
+        name: fileIdentity.stem,
+        kind: ASTEngine.SymbolKind.Module,
+        qualifiedName: fileIdentity.relPath,
+        range: { startLine: 1, startColumn: 0, endLine: 1, endColumn: 0 },
+        metadata: { nodeType: "file_scope", fsharpFileScope: true }
+      });
+    }
+    this.classifyEvidenceTier(relationships);
+    return {
+      language: "fsharp",
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        complexity: symbols.length,
+        linesOfCode: content.split("\n").length,
+        patterns: [],
+        framework: "F#",
+        hasFrameworkIntelligence: true,
+        hasTypeInference: true
+      }
+    };
+  }
+  /**
+   * #419-D — THE EVIDENCE TIER OF EVERY RELATIONSHIP, AS A PROPERTY OF ITS RULE.
+   *
+   * The tier answers WHY the target spelling can be trusted, which is a different question
+   * from whether this run resolved it. The vocabulary and the mapping follow the fleet's two
+   * shipped tables (`real-c-analyzer.ts:classifyEvidenceTier`, `real-bash-analyzer.ts`'s
+   * `evidenceClassFor`) so the same edge class carries the same tier in every lane:
+   *
+   *   structural           the parse tree STATES the relation — a declaration body, a heritage
+   *                        clause, a `new` construction: contains / exports / extends /
+   *                        implements / instantiates.
+   *   import_based         the source writes a module/file dependency: `imports` (open
+   *                        directives, #r resources) and every `references` row that is an
+   *                        `open` rather than a written type.
+   *   reference_qualified  the target is a WRITTEN TYPE matched as a name (`references` with
+   *                        `relationshipType: declared_type`), or an override whose base member
+   *                        is qualified `Owner.member` (`overrides`).
+   *   usage_contextual     the target is inferred from how the source USES the name — a call's
+   *                        callee, a read: calls / uses.
+   *
+   * No tier is `inferred`: this analyzer refuses the shapes it cannot classify at the emit site
+   * (FS-D11's type queries, FS-A4's dead branches, the withdrawn external claims) rather than
+   * publishing an unclassified edge, so the fallback is `usage_contextual` — a true statement
+   * about how the name was reached, never a guess about where it resolves.
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.evidenceClass) continue;
+      const t = String(r.type ?? "");
+      if (t === "contains" || t === "exports" || t === "extends" || t === "implements" || t === "instantiates") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "imports") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "part_of") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = md.relationshipType === "declared_type" ? "reference_qualified" : "import_based";
+        continue;
+      }
+      if (t === "overrides") {
+        md.evidenceClass = "reference_qualified";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  /**
+   * FS-D11 — is this written type a TYPE QUERY rather than a declared type?
+   *
+   * `typeof<T>` and `unbox<T>` are EXPRESSIONS that carry a type argument:
+   * `typeof<TypeInThisAssembly>.Assembly.Location` depends on a RUNTIME VALUE, and
+   * publishing `references loc -> TypeInThisAssembly` as a declared-type dependency
+   * says the opposite — that the declaration names the type in its signature.
+   *
+   * The discriminator walks up through the two shapes the grammar spells the query with,
+   * because it spells it differently depending on which one it is:
+   *   * `typed_expression` whose `base` is a `long_identifier_or_op` reading `typeof` /
+   *     `unbox` — the corpus's own shape (measured by reading the tree: `typeof<Foo>` is
+   *     `typed_expression > long_identifier_or_op(typeof) + types > simple_type`);
+   *   * a `static_type` wrapper, the other spelling.
+   *
+   * A first draft tested only the DIRECT parent for the `long_identifier_or_op`, which
+   * measured nothing, because the type's parent is the `typed_expression` and the
+   * `long_identifier_or_op` is ITS base. The differential's UNEXPLAINED row is what
+   * forced the second reading.
+   */
+  /**
+   * FS-D13 — does a member declare an explicit SETTER?
+   *
+   * F#'s `member _.P with get, set` is ONE member with two `property_accessor` bodies,
+   * and the setter's body executes. The property-getter contract ("a computed property
+   * emits no calls", inherited from the C# family) is about an EXPRESSION-bodied
+   * property, which has no second body to run code in — applying it to the setter
+   * deleted the calls in real code.
+   *
+   * Read from the `property_accessor` node's own keyword token, never from the member's
+   * text: `with get () = … and set (x) = …` and `with get, set` are the same shape.
+   */
+  hasExplicitSetter(memberDefn) {
+    const mop = this.findChild(memberDefn, (n) => n.type === "method_or_prop_defn");
+    if (!mop) return false;
+    for (const acc of this.findDescendants(mop, (n) => n.type === "property_accessor", 6)) {
+      for (let i = 0; i < acc.childCount; i++) {
+        const c = acc.child(i);
+        if (c && !c.isNamed && c.type === "set") return true;
+      }
+    }
+    return false;
+  }
+  isTypeQueryPosition(t) {
+    let cur = t;
+    for (let hop = 0; cur && hop < 3; hop++) {
+      if (cur.type === "static_type") return true;
+      if (cur.type === "typed_expression") {
+        for (let i = 0; i < cur.namedChildCount; i++) {
+          const c = cur.namedChild(i);
+          if (c && c.type === "long_identifier_or_op" && (c.text === "typeof" || c.text === "unbox")) return true;
+        }
+        return false;
+      }
+      const parent = cur.parent;
+      if (!parent) return false;
+      if (parent.type === "long_identifier_or_op" && (parent.text === "typeof" || parent.text === "unbox")) return true;
+      if (parent.type === "static_type" || parent.type === "typed_expression") {
+        cur = parent;
+        continue;
+      }
+      return false;
+    }
+    return false;
+  }
+  /** The member's declared name: `method_or_prop_defn -> property_or_ident`, LAST identifier. */
+  /**
+   * The interface an OBJECT EXPRESSION constructs, as `{ written, leaf }`.
+   *
+   * FS-D14. The object-expression branch used to take the first `long_identifier`
+   * descendant of the node and call that the interface name, which is right exactly
+   * when the name is unqualified. A qualified name is NESTED in this grammar —
+   *
+   *     object_expression
+   *       new
+   *       typed_expression "System.Collections.Generic.IEqualityComparer<InferedType>"
+   *         dot_expression "System.Collections.Generic.IEqualityComparer"
+   *           long_identifier_or_op "System.Collections"
+   *             long_identifier "System"        <-- what the old code found
+   *           . identifier "Collections"
+   *           . long_identifier_or_op "Generic.IEqualityComparer"
+   *         types "InferedType"
+   *
+   * — so "first `long_identifier`" is the FIRST SEGMENT, and the published name was
+   * `new System` with `implements -> System`, a target that resolves to nothing.
+   *
+   * The differential found it twice and in the most useful way available: the lane's
+   * truth side read the SECOND segment. `{ new System.Collections.Generic.IEqualityComparer
+   * with … }` gave the analyzer `System` and the truth `Collections`, which cannot both
+   * be the interface and makes it obvious that the name is somewhere else entirely
+   * rather than that one of them is off by a rule. Two implementations independently
+   * wrong in the same place is the cheapest kind of evidence there is.
+   *
+   * The written name is therefore read from the `dot_expression` that carries it — a
+   * node whose own text IS the full dotted path — and the leaf from the LAST identifier
+   * inside it, so R10's spelling rule applies to the same leaf a consumer would join.
+   * The tree this is built on is printed by script/m14/tmp/fs030-object-expr-name.ts.
+   */
+  objectExpressionInterface(node) {
+    const first = node.namedChild(0);
+    const isNameish = (n) => !!n && (n.type === "dot_expression" || n.type === "typed_expression" || n.type === "long_identifier_or_op" || n.type === "long_identifier");
+    const carrier = isNameish(first) ? first : (
+      // Kept for shapes where the name is not the first child, so this is a narrowing of
+      // where the name may be READ rather than a claim that it is never elsewhere.
+      this.findDescendant(node, (n) => n.type === "dot_expression", 4) ?? this.findDescendant(
+        node,
+        (n) => n.type === "typed_expression" || n.type === "long_identifier_or_op" || n.type === "long_identifier",
+        4
+      )
+    );
+    if (!carrier) return void 0;
+    const written = carrier.text.split("<")[0].trim();
+    if (!written) return void 0;
+    const nameish = carrier.type === "typed_expression" ? carrier.namedChild(0) ?? carrier : carrier;
+    const idents = this.findDescendants(nameish, (n) => n.type === "identifier", 8);
+    const leaf = idents.length ? idents[idents.length - 1].text : written;
+    return { written, leaf: leaf || written };
+  }
+  /**
+   * The interface a member IMPLEMENTS, when the member is written inside
+   * `interface I with …` — the LEAF of the interface's written name, or undefined.
+   *
+   * FS-A2. The walk to the nearest `interface_implementation` ancestor is unbounded on
+   * purpose: `findAncestor` cannot distinguish "no interface above this" from "further than
+   * N levels up", and treating both as the first is how the `overrides` rule ended up naming
+   * a base type for a member that implements an interface (see the call site).
+   *
+   * The name is read the SAME WAY the `implements` branch reads it — the first
+   * `long_identifier`/`identifier` descendant of the implementation node, then the leaf of a
+   * dotted path, with R10's spelling rule (`System.IDisposable` declares `IDisposable`). Two
+   * implementations of one rule is the point: a member-level edge and a type-level edge about
+   * the same `interface I with` clause that spell the interface differently would be
+   * indistinguishable downstream from two different interfaces.
+   *
+   * THE OBJECT-EXPRESSION ARM, and it is not a rare shape: `{ new IFoo with override x.M() }`
+   * has NO `interface_implementation` node at all — the grammar puts the interface directly on
+   * the `object_expression` as its own `long_identifier_or_op` child. So a walk that stops at
+   * `interface_implementation` answers "no interface" for every mock in the corpus, and the
+   * corpus is full of them: vsintegration/tests/Salsa/VsMocks.fs alone carries 6 such members
+   * on 2 object expressions. The interface is therefore read a second way, through the SAME
+   * `objectExpressionInterface` the `implements` branch and the symbol publication use, so the
+   * three edges about one object expression cannot spell its interface differently.
+   */
+  enclosingInterfaceImplementationLeaf(node) {
+    let cur = node.parent;
+    while (cur) {
+      if (cur.type === "interface_implementation") {
+        const written = this.findDescendant(cur, (n) => n.type === "long_identifier" || n.type === "identifier", 3);
+        if (!written?.text) return void 0;
+        return written.text.includes(".") ? written.text.split(".").pop() : written.text;
+      }
+      if (cur.type === "object_expression") return this.objectExpressionInterface(cur)?.leaf;
+      cur = cur.parent;
+    }
+    return void 0;
+  }
+  memberNameOf(decl) {
+    const mop = this.findChild(decl, (n) => n.type === "method_or_prop_defn");
+    const prop = mop ? this.findChild(mop, (n) => n.type === "property_or_ident") : void 0;
+    const idents = prop ? this.filterChildren(prop, (n) => n.type === "identifier") : [];
+    return idents.length >= 2 ? idents[idents.length - 1]?.text : idents[0]?.text;
+  }
+  /**
+   * The name a `function_or_value_defn` / `value_declaration` DECLARES, read
+   * structurally and never from an `identifier_pattern`'s text (FS-D6).
+   */
+  /**
+   * The name a `*_declaration_left` node declares.
+   *
+   * The binding's own left-hand side spans a parameter list and a return annotation, so its
+   * `identifier_pattern` text is the WHOLE left side (FS-D6) and cannot be used. The name is
+   * the first `long_identifier` inside the pattern, in document order.
+   */
+  /**
+   * The binding a type annotation belongs to, when the declaration node holds several.
+   *
+   * `let rec f … and g …` is ONE node with two left-hand sides, and each owns its own
+   * signature. The name is read from the left whose SPAN contains the annotation, so the
+   * answer is a fact about position rather than about order — and this is the same correction
+   * the truth oracle needed for a dotted name and for a `let … and …` group, and the analyzer
+   * needed twice.
+   */
+  declaredNameAt(decl, t) {
+    let best;
+    for (let i = 0; i < decl.namedChildCount; i++) {
+      const c = decl.namedChild(i);
+      if (!c) continue;
+      if (c.type !== "function_declaration_left" && c.type !== "value_declaration_left") continue;
+      if (c.startIndex <= t.startIndex && t.endIndex <= c.endIndex) best = c;
+    }
+    return best ? this.nameOfDeclarationLeft(best) : void 0;
+  }
+  nameOfDeclarationLeft(left) {
+    const pat = this.findChild(left, (n) => n.type === "identifier_pattern");
+    const carrier = (pat ? this.findChild(pat, (n) => n.type === "long_identifier_or_op") ?? this.findChild(pat, (n) => n.type === "long_identifier") : void 0) ?? left;
+    const idents = this.findDescendants(carrier, (n) => n.type === "identifier", 3).filter((n) => n.startIndex < (pat?.endIndex ?? left.endIndex)).sort((a, b) => a.startIndex - b.startIndex);
+    if (idents.length) return idents[0].text;
+    const direct = this.findChild(left, (n) => n.type === "identifier");
+    return direct?.text;
+  }
+  declaredBindingName(decl) {
+    let left;
+    for (let i = 0; i < decl.namedChildCount; i++) {
+      const c = decl.namedChild(i);
+      if (c && (c.type === "function_declaration_left" || c.type === "value_declaration_left")) {
+        left = c;
+        break;
+      }
+    }
+    if (!left) {
+      const direct = this.findChild(decl, (n) => n.type === "identifier" || n.type === "long_identifier");
+      if (direct?.text) return direct.text.includes(".") ? direct.text.split(".").pop() : direct.text;
+      return void 0;
+    }
+    const pat = this.findChild(left, (n) => n.type === "identifier_pattern");
+    const leaf = pat ? this.patternNameNode(pat) : this.findChild(left, (n) => n.type === "identifier");
+    if (leaf?.text) return leaf.text;
+    if (pat) {
+      const names = this.filterChildren(pat, (n) => n.type === "long_identifier" || n.type === "long_identifier_or_op");
+      const isBareName = names.length === 1 && pat.namedChildCount === 1 && !this.findDescendant(pat, (n) => n.type === "argument_patterns", 2);
+      if (isBareName) {
+        const text = names[0].text;
+        if (text) return text.includes(".") ? text.split(".").pop() : text;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * The declared NAME inside an `identifier_pattern` — the FIRST
+   * `long_identifier_or_op -> long_identifier -> identifier` chain.
+   *
+   * Not `pattern.text`: an `identifier_pattern` spans the entire left-hand side,
+   * parameters and return annotation included, so its text is a signature, not a name.
+   * See FS-D6 at the call site.
+   */
+  patternNameNode(pattern) {
+    const holder = pattern.type === "identifier_pattern" ? pattern : this.findChild(pattern, (n) => n.type === "identifier_pattern");
+    const scope = holder ?? pattern;
+    return this.findDescendant(
+      scope,
+      (n) => n.type === "identifier" && !!n.parent && (n.parent.type === "long_identifier" || n.parent.type === "long_identifier_or_op"),
+      3
+    );
+  }
+  /**
+   * The nearest ANCESTOR matching the predicate, bounded by `maxDepth` hops.
+   *
+   * Distinct from `findDescendant` on purpose: the declared-type graph asks "which
+   * declaration am I inside?", which is a question about the tree ABOVE the node, and
+   * reusing the descendant search for it would mean passing the whole root — an O(n)
+   * scan per type node, i.e. O(n²) over a file. Bounded hops keep the walk linear (the
+   * lane's own hot-path rule: no per-symbol O(n) scans).
+   */
+  /**
+   * The OUTERMOST callable above `n` — the member a local belongs to — or undefined if
+   * there is none, which means `n` is itself top-level and is its own owner.
+   *
+   * This replaces `findAncestor(decl, isCallable, 8)`, and the bound was the defect. A
+   * depth-limited search cannot distinguish "there is no callable above this" from "the
+   * callable is further than 8 levels up", and the code treated both as the first. It then
+   * fell through to publishing the LOCAL's own name, and a local is not a symbol — the lane's
+   * contract, pinned by the `Negative.fs` fixture, says so — so the edge it published had no
+   * other end:
+   *
+   *     references insert -> ConsoleKeyInfo      // `let insert(key: ConsoleKeyInfo) =` in console.fs
+   *     references select -> Type                // `let select (methInfo:MethodInfo) =` in the same file
+   *
+   * Neither `insert` nor `select` is a symbol; the truth oracle independently derived both
+   * facts against `ReadLine`, the method that contains them, and the differential reported
+   * 125 such rows. `insert` sits inside nested `for`/`do` bindings in a method body, which is
+   * more than 8 levels up.
+   *
+   * Walking to the root and keeping the LAST callable found is both unbounded and simpler to
+   * state: a local inside a local inside a member is owned by the member, because a namespace
+   * and a module are not callables and so never become the answer. A decl with no callable
+   * anywhere above it really is top-level, and its own name is then correct — which is the
+   * `annotated : Bar` case in the fixture, and the reason the fallback is kept rather than
+   * removed.
+   *
+   * Cost is O(depth) per annotation and the walk terminates at the root, so the bound that
+   * caused this cannot come back.
+   */
+  /**
+   * Owner lookups, memoised PER DECLARATION rather than per annotation.
+   *
+   * Both of the root walks below are O(depth) and both are asked the same question about the
+   * same `decl` once for every type node the declaration carries — so a member with four
+   * annotations walked to the root four times to learn the same thing. The pass is therefore
+   * O(annotations · depth) over what is really O(declarations · depth).
+   *
+   * MEASURED on CheckExpressions.fs (702 KB), analyze-only with the parse excluded and the
+   * median of 7: 1411 ms before this change, 1510 ms after the walks were introduced — about
+   * 7% of the analyzer's own time, from two lines of correct-looking code. It is easy to miss
+   * because the end-to-end dump barely moves: parse is 8.6 s on that file, so a 100 ms
+   * regression is under 1% of the number a corpus run reports. That is the same shape as the
+   * O(n^2) the M12 envelope found on the production path, found there by scaling rather than by
+   * reading — so it was found here by measuring the thing the walks sit inside, not the file.
+   *
+   * Keyed by node in a WeakMap, so it needs no reset between runs and cannot outlive its tree.
+   */
+  ownerMemo = /* @__PURE__ */ new WeakMap();
+  outermostCallableAbove(n) {
+    const hit = this.ownerMemo.get(n);
+    if (hit && "callable" in hit) return hit.callable ?? void 0;
+    let found;
+    let cur = n.parent;
+    while (cur) {
+      if (isCallableOwnerNode(cur)) found = cur;
+      cur = cur.parent;
+    }
+    this.ownerMemo.set(n, { ...hit ?? {}, callable: found ?? null });
+    return found;
+  }
+  /**
+   * The type declaration whose body contains `n`, walking to the root.
+   *
+   * The OUTERMOST one, which for a mutual group is the node that holds every clause in the
+   * group — `type A = … and B = …` is one `type_definition` with both bodies inside it. The
+   * name of the type that actually owns a declaration is recovered separately, by taking the
+   * last `type_name` before the declaration; see the class-field arm in `resolveSource`.
+   */
+  outermostTypeDefinitionAbove(n) {
+    const hit = this.ownerMemo.get(n);
+    if (hit && "typeDef" in hit) return hit.typeDef ?? void 0;
+    let found;
+    let cur = n.parent;
+    while (cur) {
+      if (cur.type === "type_definition") found = cur;
+      cur = cur.parent;
+    }
+    this.ownerMemo.set(n, { ...hit ?? {}, typeDef: found ?? null });
+    return found;
+  }
+  findAncestor(node, predicate, maxDepth = 12) {
+    let cur = node.parent;
+    for (let i = 0; cur && i < maxDepth; i++) {
+      if (predicate(cur)) return cur;
+      cur = cur.parent;
+    }
+    return void 0;
+  }
+  /**
+   * The ACCESS MODIFIER written on a declaration, from the grammar's own
+   * `access_modifier` node — never from the declaration's text.
+   *
+   * Where the modifier sits differs by construct, which is why a declaration node and
+   * (for a type) its `type_name` node are both offered:
+   *   * a TYPE — `type internal Tables<'Token>` puts it INSIDE the `type_name`, as its
+   *     first named child; that node's own text is literally `internal Tables<'Token>`,
+   *     which is how the pre-FS-D6 name read published a name with an access modifier
+   *     inside it;
+   *   * a VALUE or a MEMBER — `let internal f = …`, `member private this.Reset()` — puts
+   *     it on the declaration itself;
+   *   * an omitted modifier is `public` in F# and the grammar then emits no node, so
+   *     the answer is `undefined`, which the caller treats as public. `undefined` is
+   *     deliberately NOT "public": a caller can tell "written public" from "written
+   *     nothing" without a second pass.
+   */
+  accessModifierOf(decl, typeNameNode) {
+    const read = (n) => {
+      if (!n) return void 0;
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c && c.type === "access_modifier") return c.text;
+      }
+      return void 0;
+    };
+    const fromTypeName = read(typeNameNode);
+    if (fromTypeName) return fromTypeName;
+    const fromDecl = read(decl);
+    if (fromDecl) return fromDecl;
+    for (let i = 0; i < decl.namedChildCount; i++) {
+      const c = decl.namedChild(i);
+      if (!c) continue;
+      if (c.type === "attributes" || c.type === "type_attributes") {
+        const inner = read(c);
+        if (inner) return inner;
+      }
+    }
+    return void 0;
+  }
+  /** The access modifier a symbol was minted with, defaulting to F#'s implicit public. */
+  visibilityOf(symbol) {
+    const recorded = symbol.metadata?.accessModifier;
+    if (recorded === "internal" || recorded === "private" || recorded === "public") return recorded;
+    return "public";
+  }
+  /**
+   * Every type name this file DECLARES with a real `type X = …` body — i.e. NOT by
+   * `type X with …`. Collected before the walk so the publication rule is
+   * order-independent.
+   */
+  /**
+   * The module or namespace a FILE declares, or undefined.
+   *
+   * FS-D17. An `open` is a SIBLING of the file's `module` declaration, not a child, so a
+   * scope stack maintained by walking down the tree is empty when the walk reaches one.
+   * The analyzer's behaviour was then inconsistent in a way the corpus made obvious:
+   *
+   *   FscMain.fs         `module … CommandLineMain` (line 3), `open System` (line 5)
+   *                      -> the import was sourced to the module, because the walk had
+   *                         already entered the module node by the time it got there
+   *   AssemblyCheck.fs   `open System` (line 3), `module AssemblyCheck =` (line 10)
+   *                      -> the import was sourced to `Global`, because the walk had not
+   *                         reached the module yet
+   *
+   * The file's scope is the same in both cases — in F# the whole file is inside
+   * `AssemblyCheck` — so one of the two answers was wrong and the rule that produced them
+   * was "wherever the walk happened to be", which is not a rule about the program. The
+   * fix is a PRE-PASS, so the answer does not depend on the order of two sibling
+   * declarations.
+   *
+   * A module is preferred over a namespace because a file that declares both nests the
+   * module inside the namespace, and a module name is the closer scope of the two.
+   *
+   * Measured: 128 UNEXPLAINED open-path rows per 120 corpus files before the rule, and
+   * the two example files above disagreeing with each other rather than with the truth.
+   *
+   * ONE top-level declaration, and only one. The first version of this pre-pass took the
+   * FIRST module it found, which is right for AssemblyCheck.fs and wrong for
+   * `docs/fcs/project.fsx`, and the two are the same shape: an `open` above the `module`
+   * keyword. In a single-module file that scope is the file's, wherever the `open` sits. In
+   * a SCRIPT with several modules it is not — `project.fsx` opens `System` at line 35 and
+   * declares `module Inputs` at line 48, and code above the first module in a script is at
+   * the SCRIPT's scope, not inside `Inputs`. "The first module" made 128 rows disagree in
+   * the other direction.
+   *
+   * So the distinction is the count, and it is structural rather than a file extension: a
+   * file with more than one top-level module/namespace is a script, and the walk's own scope
+   * — which is correct inside a module and correctly empty above the first one — already
+   * answers it.
+   */
+  collectFileScope(root) {
+    const topLevel = [];
+    let topLevelStartIndex;
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "module_defn" || n.type === "named_module" || n.type === "namespace") {
+        const nm = this.findChild(n, (c) => c.type === "type_name" || c.type === "long_identifier" || c.type === "identifier");
+        if (nm?.text) {
+          topLevel.push(nm.text.trim());
+          if (topLevelStartIndex === void 0) topLevelStartIndex = n.startIndex;
+        }
+        continue;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    if (topLevel.length !== 1) return void 0;
+    const moduleStart = topLevelStartIndex;
+    if (moduleStart === void 0) return void 0;
+    const codeWalker = [root];
+    while (codeWalker.length > 0) {
+      const n = codeWalker.pop();
+      if ((n.type === "function_or_value_defn" || n.type === "value_declaration" || n.type === "sequential_expression") && n.startIndex < moduleStart) {
+        return void 0;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) codeWalker.push(c);
+      }
+    }
+    return topLevel[0];
+  }
+  collectDeclaredTypeNames(root) {
+    const names = /* @__PURE__ */ new Set();
+    const stack = [root];
+    const readName = (typeNameNode) => {
+      const li = this.findChild(typeNameNode, (c) => c.type === "long_identifier");
+      const id = li ? this.findDescendant(li, (c) => c.type === "identifier", 3) : this.findChild(typeNameNode, (c) => c.type === "identifier");
+      return id?.text;
+    };
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "type_definition" && !this.findChild(n, (c) => c.type === "type_extension")) {
+        const clauses = this.filterChildren(n, (c) => TYPE_CLAUSE_TYPES.has(c.type));
+        const typeNameNodes = clauses.length > 0 ? clauses.map((c) => this.findChild(c, (x) => x.type === "type_name")).filter((x) => !!x) : [this.findDescendant(n, (c) => c.type === "type_name", 3)].filter((x) => !!x);
+        for (const typeNameNode of typeNameNodes) {
+          const name = readName(typeNameNode);
+          if (name) names.add(name);
+        }
+        continue;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return names;
+  }
+  /**
+   * FS-D4 — the R9 DECLARED-TYPE reference graph: a declaration's WRITTEN type is a
+   * dependency, published as a `references` edge marked
+   * `metadata.relationshipType === "declared_type"`.
+   *
+   * WHY THIS LANE NEEDED IT. R9 is a family standard — rust's own R13 header calls it
+   * one ("mirrors go/c/zig") and thirteen lanes implement it.
+   * `script/m60/declared-type-refs-census.ts` measured fsharp **absent** with the
+   * control present: the snippet parses, the holder is walked, and the lane emits no
+   * type reference at all. A capability that is absent emits nothing for a per-edge
+   * oracle to adjudicate, which is why it survived — the same failure mode R9 was
+   * created to find.
+   *
+   * THE POSITIONS. A written type in F# is a `simple_type` / `postfix_type` /
+   * `generic_type` / … wrapper whose NAME is a `long_identifier` (dotted) or a bare
+   * `identifier`; the position is decided by the wrapper's PARENT, and the source
+   * attribution follows the family rule measured off java/kotlin/python and pinned by
+   * csharp's `declared-type-graph` fixture: a MEMBER's written type belongs to the
+   * enclosing TYPE, a parameter's / return's / local's to the enclosing CALLABLE.
+   *
+   *   record field        -> the record type   (a field is a property OF the type)
+   *   class-body `let`    -> the class          (F#'s private field — a member)
+   *   member parameter    -> the member
+   *   member return type  -> the member
+   *   DU case payload    -> the union type
+   *   module let / local -> the binding or the enclosing function
+   *   type abbreviation  -> the abbreviation
+   *   class inherit      -> REFUSED: already an `extends` edge
+   *   interface impl     -> REFUSED: already an `implements` edge
+   *   the ambiguous `type X = SomeType` (which the grammar reads as a one-case union)
+   *                     -> REFUSED: the RHS and a DU case are the same text, and
+   *                        script/m14/tmp/fs020 measured 114 such sites per 400 files
+   *                        that single-file analysis cannot separate. See that probe
+   *                        for the ruling.
+   *
+   * WHAT MUST NOT BECOME A NAME, each measured (script/m14/tmp/fs016):
+   *   a bound type PARAMETER (`'T`, `^T`) — inside a declaration's own `type_arguments`
+   *   it is a BINDING, not a dependency (rust's R13 rule; csharp's `_genericBound`
+   *   control);
+   *   an UNDERSCORE (`_`, the anonymous type of `Map<string,_>`) — not a name at all;
+   *   an F# PREDEFINED type (`int`, `string`, `unit`, …) — the analogue of go's
+   *   BUILTINS set and csharp's `int`/`string` control.
+   * Deliberately NOT used: the capitalisation of a name. F# lets a type be named
+   * anything, so this lane does not guess a type from its spelling.
+   */
+  extractDeclaredTypeRefs(rootNode, pushRel, publishedNames, fqnOfName, typeFqnOfName) {
+    const PREDEFINED = /* @__PURE__ */ new Set([
+      "int",
+      "uint",
+      "int8",
+      "uint8",
+      "int16",
+      "uint16",
+      "int32",
+      "uint32",
+      "int64",
+      "uint64",
+      "nativeint",
+      "unativeint",
+      "float",
+      "double",
+      "float32",
+      "single",
+      "decimal",
+      "bool",
+      "char",
+      "string",
+      "obj",
+      "unit",
+      "void",
+      "exn",
+      "list",
+      "array",
+      "seq",
+      "option",
+      "ref",
+      "byte",
+      "sbyte",
+      "intptr",
+      "uintptr",
+      "bigint"
+    ]);
+    const nameNodeOf = (t) => this.typeNameNodeOf(t);
+    const isTypeBinderNode = (node) => {
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c && c.type === "'") return true;
+      }
+      return false;
+    };
+    const isIdentifierNameNode = (node, leaf) => {
+      if (node.type === "identifier") return node.text === leaf;
+      if (node.type === "long_identifier" || node.type === "long_identifier_or_op") {
+        const last = this.filterChildren(node, (n) => n.type === "identifier").pop();
+        return last?.text === leaf;
+      }
+      const inner = this.findDescendant(node, (n) => n.type === "identifier", 3);
+      return inner?.text === leaf;
+    };
+    const publishedName = (node) => {
+      const text = (node.text ?? "").trim();
+      if (!text) return null;
+      if (text === "_") return null;
+      const leaf = text.includes(".") ? text.split(".").pop() : text;
+      if (!leaf || leaf === "_") return null;
+      if (isTypeBinderNode(node)) return null;
+      if (PREDEFINED.has(leaf)) return null;
+      if (!isIdentifierNameNode(node, leaf)) return null;
+      return leaf;
+    };
+    const callablePosition = (t, decl) => {
+      const inArgs = this.findAncestor(
+        t,
+        (n) => n.type === "paren_pattern" || n.type === "argument_patterns" || n.type === "argument_spec" || n.type === "arguments_spec" || n.type === "curried_spec",
+        3
+      );
+      if (inArgs) return "parameter";
+      if (decl.type === "value_declaration") return "local_annotation";
+      return "return_type";
+    };
+    const resolveSource = (t) => {
+      const parent = t.parent;
+      if (!parent) return null;
+      if (parent.type === "class_inherits_decl" || parent.type === "interface_implementation") {
+        return null;
+      }
+      if (parent.type === "type_attribute" || parent.type === "type_arguments" || parent.type === "type_argument_defn") {
+        return null;
+      }
+      if (parent.type === "record_field") {
+        const rt = this.findAncestor(parent, (n) => n.type === "record_type_defn", 6);
+        if (!rt) return null;
+        const tn = this.findChild(rt, (n) => n.type === "type_name");
+        const name2 = tn ? this.typeInfoOf(tn)?.name ?? null : null;
+        return name2 ? { source: name2, declaredOn: "record_field" } : null;
+      }
+      if (parent.type === "union_type_field") {
+        const ud = this.findAncestor(parent, (n) => n.type === "union_type_defn", 4);
+        if (!ud) return null;
+        const tn = this.findDescendant(ud, (n) => n.type === "type_name", 2);
+        const name2 = tn ? this.typeInfoOf(tn)?.name ?? null : null;
+        return name2 ? { source: name2, declaredOn: "union_case_payload" } : null;
+      }
+      if (parent.type === "type_abbrev_defn") {
+        const tn = this.findChild(parent, (n) => n.type === "type_name");
+        const name2 = tn ? this.typeInfoOf(tn)?.name ?? null : null;
+        return name2 ? { source: name2, declaredOn: "type_abbreviation" } : null;
+      }
+      const isDecl = (n) => n.type === "member_defn" || n.type === "function_or_value_defn" || n.type === "value_declaration" || n.type === "additional_constr_defn";
+      const inLambda = this.findAncestor(
+        parent,
+        (n) => n.type === "fun_expression",
+        6
+      );
+      if (inLambda) return null;
+      const decl = isDecl(parent) ? parent : this.findAncestor(parent, isDecl, 14);
+      if (!decl) return null;
+      const pos = callablePosition(t, decl);
+      if (decl.type === "member_defn") {
+        const mop = this.findChild(decl, (n) => n.type === "method_or_prop_defn");
+        const prop = mop ? this.findChild(mop, (n) => n.type === "property_or_ident") : void 0;
+        const idents = prop ? this.filterChildren(prop, (n) => n.type === "identifier") : [];
+        const name2 = idents.length >= 2 ? idents[idents.length - 1]?.text : idents[0]?.text;
+        return name2 ? { source: name2, declaredOn: pos } : null;
+      }
+      if (decl.type === "additional_constr_defn") return { source: "constructor", declaredOn: "parameter" };
+      const inTypeBody = this.findAncestor(decl, (n) => n.type === "type_extension_elements", 3) !== void 0;
+      const enclosingCallable = this.outermostCallableAbove(decl);
+      if (inTypeBody && enclosingCallable === void 0) {
+        const td = this.outermostTypeDefinitionAbove(decl);
+        if (!td) return null;
+        const fieldStart = decl.startIndex;
+        const names = this.findDescendants(td, (n) => n.type === "type_name", 4).filter((n) => n.startIndex < fieldStart).sort((a, b) => a.startIndex - b.startIndex);
+        const tn = names.length ? names[names.length - 1] : void 0;
+        const tName = tn ? this.typeInfoOf(tn)?.name ?? null : null;
+        if (tName) return { source: tName, declaredOn: "class_field" };
+      }
+      if (enclosingCallable) {
+        if (enclosingCallable.type === "additional_constr_defn") return { source: "constructor", declaredOn: "local_annotation" };
+        const cName = enclosingCallable.type === "member_defn" ? this.memberNameOf(enclosingCallable) : this.declaredBindingName(enclosingCallable);
+        if (cName) return { source: cName, declaredOn: "local_annotation" };
+      }
+      const name = this.declaredBindingName(decl);
+      if (name && publishedNames.has(name)) return { source: name, declaredOn: pos };
+      return null;
+    };
+    const emitted = /* @__PURE__ */ new Set();
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "ERROR" || n.isMissing) continue;
+      if (TYPE_WRAPPER_NODES.has(n.type)) {
+        const nestedInType = n.parent != null && TYPE_WRAPPER_NODES.has(n.parent.type);
+        if (!this.isTypeQueryPosition(n) && !nestedInType) {
+          const nameNode = nameNodeOf(n);
+          const writtenLeaf = nameNode ? publishedName(nameNode) : null;
+          const target = writtenLeaf && typeFqnOfName.has(writtenLeaf) ? typeFqnOfName.get(writtenLeaf) : writtenLeaf;
+          const src = resolveSource(n);
+          const key = `${src?.source}|${target}|${n.startIndex}`;
+          if (target && src && !emitted.has(key)) {
+            emitted.add(key);
+            const dottedAncestor = (() => {
+              let cur = nameNode;
+              for (let guard = 0; guard < 6 && cur; guard++) {
+                if (cur.type === "long_identifier") return cur.text;
+                cur = cur.parent;
+              }
+              return "";
+            })();
+            const writtenType = dottedAncestor || (nameNode?.text ?? "").trim();
+            pushRel(
+              fqnOfName.get(src.source) ?? src.source,
+              target,
+              ASTEngine.RelationshipType.References,
+              1,
+              {
+                nodeType: n.type,
+                relationshipType: "declared_type",
+                declaredOn: src.declaredOn,
+                declaredType: target,
+                // FS-P7-1: the same two facts every other target carries — the reason,
+                // and the spelling this one is a reduction of. `publishedName` takes the
+                // LAST segment of a dotted type, so `System.IO.Stream` becomes `Stream`
+                // and the path the source wrote is otherwise unrecoverable from the
+                // result. Whether that reduction is right is a price, not an opinion.
+                targetResolution: UNRESOLVED_TYPE,
+                ...writtenType.includes(".") && writtenType !== target ? { targetWritten: writtenType } : {}
+              },
+              nameNode ? nameNode.startPosition.row + 1 : n.startPosition.row + 1
+            );
+          }
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  /**
+   * Pure-AST name + declared generic-parameter extraction for a type_name
+   * node. The clean name is long_identifier -> identifier (generics live in a
+   * sibling type_arguments node, never inside the identifier).
+   */
+  typeInfoOf(node) {
+    const liNode = this.findChild(node, (n) => n.type === "long_identifier");
+    const idNode = liNode ? this.findDescendant(liNode, (n) => n.type === "identifier") : this.findChild(node, (n) => n.type === "identifier");
+    if (!idNode?.text) return null;
+    const genericParameters = [];
+    const taNode = this.findChild(node, (n) => n.type === "type_arguments");
+    if (taNode) {
+      for (let i = 0; i < taNode.namedChildCount; i++) {
+        const c = taNode.namedChild(i);
+        if (c?.type !== "type_argument_defn") continue;
+        const argNode = this.findChild(c, (n) => n.type === "type_argument");
+        if (argNode?.text) genericParameters.push(argNode.text);
+      }
+    }
+    return {
+      name: idNode.text,
+      genericParameters: genericParameters.length > 0 ? genericParameters : void 0
+    };
+  }
+  isFSharpBuiltin(call, leaf) {
+    if (FSHARP_CONSOLE_BUILTINS.has(call)) return true;
+    if (OBJECT_LEAF_METHODS.has(leaf)) return true;
+    if (call === "Console.WriteLine" || call.startsWith("Console.")) return true;
+    return false;
+  }
+  /**
+   * Does this node CARRY an unnamed token equal to `text`, anywhere in its children?
+   *
+   * Distinct from `firstTokenIs`, which asks about the FIRST non-trivia token and is
+   * used for a declaration's keyword (`override`, `new`). `open type X` needs the
+   * opposite question — the token is not first, it sits between the keyword and the
+   * path — so it asks for the token's presence rather than its position.
+   */
+  nodeHasToken(node, text) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && !c.isNamed && c.type === text) return true;
+    }
+    return false;
+  }
+  /**
+   * The name-bearing node inside a F# type wrapper, or null.
+   *
+   * WRAPPERS NEST (`postfix_type` holds a `simple_type` for its base and a
+   * `long_identifier` for the postfix), so the rule is: descend to the first type-ish
+   * child, then take the LAST `long_identifier`/`identifier` at that level — the name
+   * the wrapper writes LAST, which is the type the whole expression denotes (`int option`
+   * is `option`, `Map<string,int>` is `Map`). This is the extraction the declared-type
+   * pass has always used; it is a METHOD now so the attribute rule reads a wrapper the
+   * same way instead of carrying a second copy of the descent that could drift from it.
+   * A bound type parameter (`type_argument`) yields null: `'T` is a binder, not a name.
+   */
+  typeNameNodeOf(t) {
+    let cur = t;
+    for (let guard = 0; guard < 8 && cur; guard++) {
+      if (cur.type === "type_argument") return null;
+      if (cur.type === "long_identifier") {
+        let leaf = null;
+        for (let i = 0; i < cur.namedChildCount; i++) {
+          const c = cur.namedChild(i);
+          if (c && (c.type === "identifier" || c.type === "long_identifier")) leaf = c;
+        }
+        return leaf ?? cur;
+      }
+      if (cur.type === "identifier") return cur;
+      let next = null;
+      for (let i = 0; i < cur.namedChildCount; i++) {
+        const c = cur.namedChild(i);
+        if (c && (TYPE_WRAPPER_NODES.has(c.type) || c.type === "type_argument" || c.type === "type_arguments" || c.type === "long_identifier" || c.type === "identifier")) {
+          next = c;
+          break;
+        }
+      }
+      if (!next) return null;
+      cur = next;
+    }
+    return null;
+  }
+  /**
+   * The dependency LEAF a name-bearing node denotes: the last segment of a dotted path.
+   *
+   * `System.Obsolete` is `Obsolete`, which is the spelling a consumer binds by — the
+   * index stores one symbol per name, and `System.Obsolete` binds to nothing while
+   * `Obsolete` binds to the attribute class.
+   *
+   * "Is this a name?" is asked of the NODE and never of the string. This lane's doc
+   * carries a regex inventory whose first two rows are exactly this decision — the
+   * patterns `/^['^]/` and `/^[A-Za-z_][A-Za-z0-9_']*$/` — and both were replaced for
+   * the same reason this method has no pattern: the grammar already makes the
+   * distinction as a node type. `typeNameNodeOf` returns an `identifier` or a
+   * `long_identifier`, so a non-`identifier` node here is not a name, and `_` is
+   * refused because the grammar writes it as an `identifier` with that one spelling
+   * and it names no declaration.
+   */
+  dependencyLeafName(node) {
+    if (node.type !== "identifier" && node.type !== "long_identifier") return null;
+    const raw = (node.text ?? "").trim();
+    if (!raw || raw === "_") return null;
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && (c.type === "'" || c.type === "^")) return null;
+    }
+    const leaf = raw.includes(".") ? raw.split(".").pop() : raw;
+    return leaf && leaf !== "_" ? leaf : null;
+  }
+  /**
+   * The VALUE inside an F# string-literal node, with the delimiters removed.
+   *
+   * The grammar gives the content no node: `(fsi_directive_decl (string))` — the
+   * `string` node's two children are the two `"` tokens and `namedChildCount` is 0.
+   * So the delimiters are read off the TREE (their `endIndex`/`startIndex` are the
+   * exact byte bounds) and the content is the span between them. Taking `node.text`
+   * instead put the quotes IN the dependency: `imports Fixture.ImportAndUse ->
+   * "nuget: FSharp.Core"`, a target that binds to nothing, which is the shape of a
+   * fabricated edge even though the fact underneath it is real.
+   *
+   * `verbatim_string` (`@"C:\dir\file.fsx"`) has three delimiter tokens: the opening
+   * `@"`, the escape `\`, and the closing `"`. The span between the FIRST and the LAST
+   * is the content. Its one disclosed limit: F# escapes a quote inside a verbatim
+   * string by doubling it, and this does not un-double it, so a specifier containing
+   * `""` keeps both characters. No corpus specifier does (measured over the whole
+   * corpus's 193 `fsi_directive_decl` nodes), and a wrong-but-visible path is better
+   * than a silently truncated one.
+   */
+  /**
+   * THE FILE A `#load` NAMES, AS A PROJECT-RELATIVE PATH — or null when this checkout cannot
+   * place it, in which case NO `part_of` ROW IS PUBLISHED.
+   *
+   * THE RULES, IN THE ORDER THEY APPLY:
+   *
+   * 1. A SPECIFIER WITH A SCHEME (`nuget:`, `http:`) names something that is not a path in
+   *    this checkout. Refused.
+   * 2. A RELATIVE SPECIFIER IS RESOLVED AGAINST THE INCLUDING FILE'S OWN DIRECTORY — F#'s
+   *    `#load` is relative to the file that writes it, not to the project root.
+   * 3. THE RESULT IS EXPRESSED RELATIVE TO THE PROJECT ROOT, so the spelling does not depend
+   *    on where the checkout lives (the same reason the yaml lane's document identity is
+   *    project-relative — src/ast/engine.ts:2405-2429).
+   * 4. A TARGET THAT ESCAPES THE PROJECT (`..`) IS REFUSED: it is not a file of this project,
+   *    and a `part_of` row whose target no project key can answer is exactly the shape this
+   *    label exists to stop publishing (types.ts:187-190).
+   * 5. WITHOUT A PROJECT ROOT THERE IS NO PROJECT-RELATIVE PATH TO PUBLISH, and the row is
+   *    REFUSED. Fail-closed: a `part_of` edge is a fact about two files of one project, and a
+   *    caller that cannot say which project the file is in cannot make that fact. The root
+   *    comes from `context.projectRoot` (production always supplies it — pool-worker.ts:2041)
+   *    and, failing that, from the nearest `.git` above the file (the dart sibling's rule).
+   *
+   * NO SOURCE TEXT IS READ: this is a pure path computation over the two strings the caller
+   * already has, so the resolution cannot differ between two runs of the same file.
+   */
+  /**
+   * FS-P1. THE FILE'S IDENTITY — the path a `part_of` target is spelled in, and the name
+   * the file-scoped symbol carries.
+   *
+   * The path is computed against the SAME root the `part_of` target is computed against
+   * (`context.projectRoot`, the repository root in production — pool-worker.ts:2041), so
+   * the two spellings agree by construction rather than by coincidence.
+   */
+  fsharpFileIdentity(filePath, context) {
+    const base = path.basename(filePath);
+    const dot = base.lastIndexOf(".");
+    const stem = dot > 0 ? base.slice(0, dot) : base;
+    const contextRoot = context?.projectRoot;
+    const projectRoot = typeof contextRoot === "string" && contextRoot.length > 0 ? contextRoot : fsharpProjectRootOf(filePath);
+    if (projectRoot === null) return { relPath: null, stem };
+    return { relPath: fsharpRepoRelPath(projectRoot, filePath), stem };
+  }
+  fsharpPartTargetPath(filePath, context, specifier) {
+    if (specifier.length === 0) return null;
+    if (specifier.indexOf(":") >= 0) return null;
+    const contextRoot = context?.projectRoot;
+    const projectRoot = typeof contextRoot === "string" && contextRoot.length > 0 ? contextRoot : fsharpProjectRootOf(filePath);
+    if (projectRoot === null) return null;
+    const abs = path.resolve(path.dirname(path.resolve(filePath)), specifier);
+    const rel = path.relative(path.resolve(projectRoot), abs);
+    if (rel.length === 0 || path.isAbsolute(rel)) return null;
+    if (rel === ".." || rel.startsWith(`..${path.sep}`)) return null;
+    return rel.split(path.sep).join("/");
+  }
+  stringLiteralValue(node) {
+    if (node.type !== "string" && node.type !== "verbatim_string") return null;
+    if (node.childCount === 0) return null;
+    const first = node.child(0);
+    const last = node.child(node.childCount - 1);
+    if (!first || !last) return null;
+    const from = first.endIndex - node.startIndex;
+    const to = last.startIndex - node.startIndex;
+    if (!(to > from)) return null;
+    const value = node.text.slice(from, to);
+    return value.length > 0 ? value : null;
+  }
+  firstTokenIs(node, text) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (!c) continue;
+      if (c.type === text) return true;
+      if (c.isNamed) break;
+    }
+    return false;
+  }
+  findChild(node, predicate) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && predicate(child)) return child;
+    }
+    return void 0;
+  }
+  filterChildren(node, predicate) {
+    const results = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && predicate(child)) results.push(child);
+    }
+    return results;
+  }
+  /**
+   * The callee NAME inside a pipeline operand (FS-D30).
+   *
+   * An operand is either name-like already (the `xs |> ignore` shape) or an application whose callee
+   * is its FIRST name-like child (the `xs |> Array.exists(fun …)` shape), which is what puts an
+   * `application_expression` on the callee side and defeated the old direct-children filter. One
+   * level of descent is enough for both observed shapes and deliberately not more: descending until
+   * something name-like turns up would read an ARGUMENT on the shapes where the callee is absent.
+   */
+  pipelineCalleeName(operand) {
+    if (!operand) return void 0;
+    if (PIPELINE_NAMEY.has(operand.type)) return operand;
+    if (operand.type === "application_expression" || operand.type === "prefixed_expression") {
+      for (let i = 0; i < operand.namedChildCount; i++) {
+        const c = operand.namedChild(i);
+        if (c && PIPELINE_NAMEY.has(c.type)) return c;
+      }
+    }
+    return void 0;
+  }
+  findDescendants(node, predicate, maxDepth = 5) {
+    const results = [];
+    if (maxDepth <= 0) return results;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) {
+        if (predicate(child)) results.push(child);
+        results.push(...this.findDescendants(child, predicate, maxDepth - 1));
+      }
+    }
+    return results;
+  }
+  findDescendant(node, predicate, maxDepth = 5) {
+    if (maxDepth <= 0) return void 0;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) {
+        if (predicate(child)) return child;
+        const found = this.findDescendant(child, predicate, maxDepth - 1);
+        if (found) return found;
+      }
+    }
+    return void 0;
+  }
+  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
+    };
+  }
+};
+export {
+  RealFsharpAnalyzer
+};