@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-elixir-analyzer-MQWGAH2I.js

@@ -0,0 +1,2192 @@
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-elixir-analyzer.ts
+var EXPORTED_KINDS = /* @__PURE__ */ new Set([
+  ASTEngine.SymbolKind.Module,
+  ASTEngine.SymbolKind.Interface,
+  ASTEngine.SymbolKind.Class,
+  ASTEngine.SymbolKind.Struct,
+  ASTEngine.SymbolKind.Function,
+  ASTEngine.SymbolKind.Method,
+  ASTEngine.SymbolKind.Macro,
+  ASTEngine.SymbolKind.Type
+]);
+var DEFAULT_EVIDENCE_CLASS = {
+  contains: "structural",
+  exports: "structural",
+  implements: "structural",
+  instantiates: "structural",
+  overrides: "structural",
+  extends: "structural",
+  imports: "import_based",
+  references: "reference_qualified",
+  // A `calls` edge's class depends on the CALLEE'S SPELLING (`Mod.fun` was read
+  // off a dot node and resolved through the alias table; a bare `f(...)` is
+  // checked against the module's declared set), which a table cannot see —
+  // `evidenceClassFor` splits it.
+  calls: "usage_contextual",
+  uses: "usage_contextual"
+};
+function evidenceClassFor(type, confidence, target) {
+  if (String(type) === "calls") return target.indexOf(".") !== -1 ? "reference_qualified" : "usage_contextual";
+  return DEFAULT_EVIDENCE_CLASS[String(type)] ?? (confidence >= 0.85 ? "structural" : "inferred");
+}
+var complexityNodes = (function() {
+  const r = /* @__PURE__ */ Object.create(null);
+  const arr = ["if", "unless", "case", "cond", "receive", "with", "for", "def", "defp", "defmacro", "defmacrop"];
+  for (let i = 0; i < arr.length; i++) r[arr[i]] = true;
+  return r;
+})();
+var DEF_CONSTRUCTS = /* @__PURE__ */ new Set(["def", "defp", "defmacro", "defmacrop", "defdelegate", "defguard", "defguardp"]);
+var DIRECTIVES = /* @__PURE__ */ new Set(["use", "import", "alias", "require"]);
+var DECLARATION_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "moduledoc",
+  "doc",
+  "spec",
+  "type",
+  "typep",
+  "opaque",
+  "callback",
+  "macrocallback",
+  "optional_callbacks",
+  "behaviour",
+  "behavior",
+  "derive",
+  "deprecated"
+]);
+var SPECIAL_FORMS = /* @__PURE__ */ new Set([
+  "if",
+  "unless",
+  "case",
+  "cond",
+  "receive",
+  "for",
+  "with",
+  "try",
+  "rescue",
+  "catch",
+  "after",
+  "else",
+  "quote",
+  "unquote",
+  "super",
+  "raise",
+  "throw",
+  "exit",
+  "fn",
+  "do"
+]);
+var KERNEL_FUNCTIONS = /* @__PURE__ */ new Set([
+  "length",
+  "hd",
+  "tl",
+  "elem",
+  "put_elem",
+  "map_size",
+  "tuple_size",
+  "byte_size",
+  "bit_size",
+  "div",
+  "rem",
+  "abs",
+  "round",
+  "trunc",
+  "ceil",
+  "floor",
+  "min",
+  "max",
+  "is_atom",
+  "is_binary",
+  "is_bitstring",
+  "is_boolean",
+  "is_float",
+  "is_function",
+  "is_integer",
+  "is_list",
+  "is_map",
+  "is_map_key",
+  "is_number",
+  "is_pid",
+  "is_port",
+  "is_reference",
+  "is_tuple",
+  "is_nil",
+  "is_struct",
+  "is_exception",
+  "map_get",
+  "to_string",
+  "inspect",
+  "apply",
+  "self",
+  "send",
+  "send_after",
+  "spawn",
+  "spawn_link",
+  "spawn_monitor",
+  "make_ref",
+  "node",
+  "put_in",
+  "get_in",
+  "update_in",
+  "get_and_update_in",
+  "pop_in",
+  "struct",
+  "struct!",
+  "binary_part",
+  "binding",
+  "tap",
+  "then",
+  "dbg",
+  "tuple_to_list",
+  "list_to_tuple",
+  "atom_to_binary",
+  "binary_to_atom",
+  "term_to_binary",
+  "binary_to_term",
+  "process_flag",
+  "sleep",
+  "yield",
+  "match?",
+  "function_exported?",
+  "macro_exported?",
+  "reraise"
+]);
+var RealElixirAnalyzer = class {
+  analyze(rootNode, content, filePath) {
+    const ctx = {
+      symbols: [],
+      relationships: [],
+      imports: [],
+      exports: [],
+      errors: [],
+      patterns: {},
+      frameworks: {},
+      content,
+      // W23-E1: alias frames are prototype CHAINS (Object.create(parent));
+      // the null-prototype root makes chain lookups pollution-safe.
+      aliases: /* @__PURE__ */ Object.create(null),
+      functionHeads: {},
+      pendingDoc: void 0,
+      importList: [],
+      callbackSpecs: {},
+      optionalCallbacks: {},
+      symbolByName: /* @__PURE__ */ new Map(),
+      seenRels: /* @__PURE__ */ new Set(),
+      overridableNames: /* @__PURE__ */ new Map(),
+      overridableModules: /* @__PURE__ */ new Map(),
+      overridable: /* @__PURE__ */ new Map(),
+      lastDeclLine: /* @__PURE__ */ new Map(),
+      moduleUses: /* @__PURE__ */ new Map(),
+      pendingImpl: void 0,
+      moduleBehaviours: {},
+      moduleCallbacks: {},
+      usesCandidates: [],
+      mapBoundByScope: /* @__PURE__ */ new Map(),
+      usesVerified: 0,
+      usesContextual: 0,
+      mapKeyReceiverDropped: 0
+    };
+    const scopeStack = [];
+    const stack = [{ node: rootNode }];
+    let cyclomaticComplexity = 1;
+    while (stack.length > 0) {
+      const { node, isExit } = stack.pop();
+      if (isExit) {
+        if (scopeStack.length > 0 && scopeStack[scopeStack.length - 1].node === node) {
+          const sc = scopeStack.pop();
+          if (sc.symbol) sc.symbol.complexity = Math.max(sc.symbol.complexity ?? 1, sc.complexity + 1);
+          if (sc.savedAliases) ctx.aliases = sc.savedAliases;
+          if ((sc.kind === ASTEngine.SymbolKind.Module || sc.kind === ASTEngine.SymbolKind.Interface) && sc.name) {
+            const implied = sc.name.split(".").pop();
+            if (implied && !ctx.aliases[implied]) ctx.aliases[implied] = sc.name;
+          }
+        }
+        continue;
+      }
+      if (node.hasError || node.isMissing) {
+        if (node.type === "ERROR" || node.type === "MISSING") {
+          ctx.errors.push({ message: `Syntax ${node.type} detected.`, range: this.nodeToRange(node), severity: "warning" });
+        }
+      }
+      let pushedScope = false;
+      const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+      if (node.type === "call") {
+        const targetNode = this.findChild(node, (c) => c?.type === "identifier" || c?.type === "dot");
+        const t = targetNode?.text || "";
+        if (complexityNodes[t] && !this.isInQuotedCode(node)) {
+          cyclomaticComplexity++;
+          if (scopeStack.length > 0) scopeStack[scopeStack.length - 1].complexity++;
+        }
+        if (t) {
+          if (this.isInQuotedCode(node)) {
+          } else if (t === "defmodule") {
+            pushedScope = this.processModule(node, ctx, currentScope, scopeStack);
+          } else if (DEF_CONSTRUCTS.has(t)) {
+            pushedScope = this.processFunction(node, t, ctx, currentScope, scopeStack);
+          } else if (t === "defprotocol") {
+            pushedScope = this.processProtocol(node, ctx, currentScope, scopeStack);
+          } else if (t === "defimpl") {
+            pushedScope = this.processImpl(node, ctx, currentScope, scopeStack);
+          } else if (t === "defstruct" || t === "defexception") {
+            this.processStruct(node, ctx, currentScope);
+          } else if (DIRECTIVES.has(t)) {
+            this.processDirective(node, t, ctx, currentScope, scopeStack);
+          } else if (t === "defoverridable") {
+            this.recordOverridable(node, ctx, currentScope);
+          } else if (t === "case" || t === "cond" || t === "receive" || t === "match") {
+            ctx.patterns["Pattern Matching"] = true;
+            if (t === "receive") ctx.patterns["Actor Model (OTP)"] = true;
+          } else if (t === "struct" || t === "struct!" || t === "raise" || t === "reraise") {
+            if (!this.isInDeclarationAttributeValue(node) && !this.isDefHead(node)) {
+              const structArgs = this.findChild(node, (c) => c?.type === "arguments");
+              const first = structArgs && structArgs.namedChildCount > 0 ? structArgs.namedChild(0) : void 0;
+              if (first?.type === "alias") this.recordInstantiates(this.resolveAlias(first.text, ctx), ctx, currentScope, first.startPosition.row + 1);
+              else if (first?.type === "identifier" && first.text === "__MODULE__") {
+                let modScope;
+                for (let i = scopeStack.length - 1; i >= 0; i--) {
+                  const k = scopeStack[i].kind;
+                  if (k === ASTEngine.SymbolKind.Module || k === ASTEngine.SymbolKind.Interface) {
+                    modScope = scopeStack[i].name;
+                    break;
+                  }
+                }
+                if (modScope) this.recordInstantiates(modScope, ctx, currentScope, first.startPosition.row + 1);
+              }
+            }
+          } else {
+            if (t === "send" || t === "send_after") {
+              ctx.patterns["Actor Model (OTP)"] = true;
+              ctx.patterns["Message Passing"] = true;
+            } else if (t === "spawn" || t === "spawn_link" || t === "spawn_monitor" || t === "Task.async" || t === "Task.start" || t === "Task.start_link" || t === "Agent.start" || t === "Agent.start_link") {
+              ctx.patterns["Actor Model (OTP)"] = true;
+              ctx.patterns["Process Spawning"] = true;
+            }
+            const memberLeaf = this.memberReadLeaf(node);
+            if (memberLeaf && !this.isDefHead(node) && !this.isInDeclarationAttributeValue(node) && !this.isPatternPosition(node)) {
+              ctx.usesCandidates.push({
+                source: currentScope?.name || "Global",
+                field: memberLeaf.leaf,
+                receiver: memberLeaf.receiver,
+                line: targetNode ? targetNode.startPosition.row + 1 : node.startPosition.row + 1
+              });
+            } else if (!this.shouldSkipCall(node, t) && !this.isPipeStep(node) && !this.isCaptureHead(node)) {
+              let meta = {};
+              if (t === "Task.async" || t === "Task.start" || t === "Task.start_link" || t === "Agent.start" || t === "Agent.start_link") meta = { isProcessSpawn: true };
+              const callArgs = this.findChild(node, (c) => c?.type === "arguments");
+              this.recordCall(t, ctx, currentScope, this.enclosingDeclaredScope(scopeStack), meta, targetNode ? targetNode.startPosition.row + 1 : node.startPosition.row + 1, callArgs ? callArgs.namedChildCount : 0);
+            }
+          }
+        }
+      } else if (node.type === "map") {
+        const structChild = this.findChild(node, (c) => c?.type === "struct");
+        const aliasChild = structChild ? this.findChild(structChild, (c) => c?.type === "alias") : void 0;
+        if (aliasChild?.text && !this.isInQuotedCode(node) && !this.isDefHead(node) && !this.isInDeclarationAttributeValue(node) && !this.isPatternPosition(node)) {
+          this.recordInstantiates(this.resolveAlias(aliasChild.text, ctx), ctx, currentScope, aliasChild.startPosition.row + 1);
+        } else if (!aliasChild && !this.isInQuotedCode(node) && !this.isDefHead(node) && !this.isInDeclarationAttributeValue(node) && !this.isPatternPosition(node)) {
+          const selfChild = structChild ? this.findChild(structChild, (c) => c?.type === "identifier" && c.text === "__MODULE__") : void 0;
+          if (selfChild) {
+            let modScope;
+            for (let i = scopeStack.length - 1; i >= 0; i--) {
+              const k = scopeStack[i].kind;
+              if (k === ASTEngine.SymbolKind.Module || k === ASTEngine.SymbolKind.Interface) {
+                modScope = scopeStack[i].name;
+                break;
+              }
+            }
+            if (modScope) this.recordInstantiates(modScope, ctx, currentScope, selfChild.startPosition.row + 1);
+          }
+        }
+      } else if (node.type === "unary_operator" && node.child(0)?.text === "@" && !this.isInQuotedCode(node)) {
+        const attrCall = node.child(1);
+        const attrCallId = attrCall?.type === "call" ? this.findChild(attrCall, (c) => c?.type === "identifier") : void 0;
+        const attrName = attrCallId?.text || (attrCall?.type !== "call" ? attrCall?.text || "" : "");
+        if (attrName === "moduledoc" || attrName === "doc") ctx.patterns["Documentation"] = true;
+        if (attrName === "spec" || attrName === "type" || attrName === "typep" || attrName === "opaque") ctx.patterns["Typespecs"] = true;
+        if (attrName === "callback" || attrName === "macrocallback" || attrName === "optional_callbacks") {
+          ctx.patterns["Behaviours"] = true;
+          if (attrCallId && (attrCallId.text === "callback" || attrCallId.text === "macrocallback")) {
+            const argsNode = this.findChild(attrCall, (c) => c?.type === "arguments");
+            const findTypeOp = (n, depth = 0) => {
+              if (!n || depth > 4) return null;
+              if (n.type === "binary_operator" && n.child(1)?.text === "::") return n;
+              for (let i = 0; i < n.childCount; i++) {
+                const c = n.child(i);
+                if (c && c.type === "binary_operator") {
+                  const hit = findTypeOp(c, depth + 1);
+                  if (hit) return hit;
+                }
+              }
+              return null;
+            };
+            const binOp = findTypeOp(argsNode);
+            let lhs = null;
+            if (binOp) {
+              const left = binOp.child(0);
+              if (left?.type === "identifier") lhs = left;
+              else if (left?.type === "call") lhs = this.findChild(left, (c) => c?.type === "identifier");
+            }
+            if (lhs?.text) {
+              let arity = 0;
+              if (binOp) {
+                const left = binOp.child(0);
+                if (left?.type === "call") {
+                  for (let i = 0; i < left.childCount; i++) {
+                    const c = left.child(i);
+                    if (c && c.type === "arguments") arity = c.namedChildCount;
+                  }
+                }
+              }
+              let ownerName = "";
+              let ownerKind;
+              for (let i = scopeStack.length - 1; i >= 0; i--) {
+                const k = scopeStack[i].kind;
+                if (k === ASTEngine.SymbolKind.Module || k === ASTEngine.SymbolKind.Interface) {
+                  ownerName = scopeStack[i].name;
+                  ownerKind = k;
+                  break;
+                }
+              }
+              const specText = this.nodeToRange(binOp ?? node) && (binOp ? binOp.text : node.text);
+              const key = `${ownerName}/${lhs.text}/${arity}`;
+              ctx.callbackSpecs[key] = specText;
+              if (ownerName) ctx.moduleCallbacks[ownerName] = [...ctx.moduleCallbacks[ownerName] ?? [], lhs.text];
+              const existing = ctx.symbols.find((sym) => sym.name === lhs.text && (sym.ownerName ?? sym.scope ?? "") === ownerName && sym.metadata?.arity === arity);
+              if (existing) {
+                existing.metadata = { ...existing.metadata, callbackSpec: specText, isCallbackDeclaration: true, ...attrCallId.text === "macrocallback" ? { isMacroCallback: true } : {} };
+                if (existing.isDeclaration) existing.metadata.isDeclaration = true;
+                this.extendRange(existing, this.nodeToRange(node));
+              } else {
+                const isMethod = ownerKind === ASTEngine.SymbolKind.Interface || ownerKind === ASTEngine.SymbolKind.Class;
+                const cbSym = {
+                  name: lhs.text,
+                  kind: isMethod ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Function,
+                  range: this.nodeToRange(node),
+                  scope: ownerName,
+                  ownerName: ownerName || void 0,
+                  ownerKind,
+                  visibility: "public",
+                  isDeclaration: true,
+                  metadata: {
+                    elixirSpecific: true,
+                    isCallback: true,
+                    isBodylessDeclaration: true,
+                    isDeclaration: true,
+                    arity,
+                    heads: 0,
+                    clauseRanges: [],
+                    ...attrCallId.text === "macrocallback" ? { isMacroCallback: true } : {},
+                    callbackSpec: specText,
+                    hasCallbackSpec: true
+                  }
+                };
+                ctx.symbols.push(cbSym);
+                if (ownerName) ctx.functionHeads[`${ownerName}.${lhs.text}/${arity}`] = cbSym;
+              }
+            }
+          } else if (attrCallId && attrCallId.text === "optional_callbacks") {
+            const argsNode = this.findChild(attrCall, (c) => c?.type === "arguments");
+            const names = [];
+            const keywordGroups = [];
+            if (argsNode) {
+              for (const c of this.filterChildren(argsNode, (x) => x?.type === "keywords" || x?.type === "list")) {
+                if (c.type === "keywords") {
+                  keywordGroups.push(c);
+                  continue;
+                }
+                for (const inner of this.filterChildren(c, (x) => x?.type === "keywords" || x?.type === "pair")) keywordGroups.push(inner);
+              }
+            }
+            for (const grp of keywordGroups) {
+              for (let j = 0; j < grp.namedChildCount; j++) {
+                const pair = grp.namedChild(j);
+                if (!pair || pair.type !== "pair") continue;
+                const kw = this.findChild(pair, (c) => c?.type === "keyword" || c?.type === "quoted_keyword");
+                if (kw?.text) names.push(this.stripAfterColon(this.stripQuotes(kw.text)));
+              }
+            }
+            let ownerName = "";
+            for (let i = scopeStack.length - 1; i >= 0; i--) {
+              const k = scopeStack[i].kind;
+              if (k === ASTEngine.SymbolKind.Module || k === ASTEngine.SymbolKind.Interface) {
+                ownerName = scopeStack[i].name;
+                break;
+              }
+            }
+            if (names.length > 0 && ownerName) {
+              ctx.optionalCallbacks[ownerName] = [...ctx.optionalCallbacks[ownerName] ?? [], ...names];
+              const ownerSym = ctx.symbolByName.get(ownerName);
+              if (ownerSym) ownerSym.metadata = { ...ownerSym.metadata, optionalCallbacks: [...ownerSym.metadata?.optionalCallbacks ?? [], ...names] };
+            }
+          }
+        }
+        if (attrCallId && (attrCallId.text === "type" || attrCallId.text === "typep" || attrCallId.text === "opaque")) {
+          const argsNode = this.findChild(attrCall, (c) => c?.type === "arguments");
+          const binOp = argsNode ? this.findChild(argsNode, (c) => c?.type === "binary_operator") : void 0;
+          let typeNameNode = null;
+          if (binOp) {
+            const lhs = binOp.child(0);
+            if (lhs?.type === "identifier") typeNameNode = lhs;
+            else if (lhs?.type === "call") typeNameNode = this.findChild(lhs, (c) => c?.type === "identifier");
+          } else if (argsNode) {
+            typeNameNode = this.findChild(argsNode, (c) => c?.type === "identifier");
+          }
+          if (typeNameNode?.text) {
+            const isPrivateAlias = attrCallId.text === "typep";
+            ctx.symbols.push({ name: typeNameNode.text, kind: ASTEngine.SymbolKind.Type, range: this.nodeToRange(node), ownerName: currentScope?.unnamedModule ? void 0 : currentScope?.name, ownerKind: currentScope?.unnamedModule ? void 0 : currentScope?.kind, scope: currentScope?.unnamedModule ? "" : currentScope?.name || "", visibility: isPrivateAlias ? "private" : "public", metadata: { elixirSpecific: true, isTypeSpec: true, ...isPrivateAlias ? { isPrivateTypeAlias: true } : {}, ...currentScope?.unnamedModule ? { elixirOwnerUnknown: "un-nameable enclosing defmodule/defprotocol" } : {} } });
+          }
+        }
+        if (attrName === "behaviour" || attrName === "behavior") {
+          const argsNode = attrCall?.type === "call" ? this.findChild(attrCall, (c) => c?.type === "arguments") : void 0;
+          const first = argsNode && argsNode.namedChildCount > 0 ? argsNode.namedChild(0) : void 0;
+          let bhvRaw = first ? this.stripQuotes(first.text).trim() : "";
+          if (bhvRaw.startsWith(":")) bhvRaw = bhvRaw.slice(1);
+          const bhv = bhvRaw ? this.resolveAlias(bhvRaw, ctx) : "";
+          if (bhv) {
+            this.pushRel(ctx, currentScope?.name || "Global", bhv, ASTEngine.RelationshipType.Implements, 0.9, { reasonCode: "elixir_behaviour_attribute" }, first ? first.startPosition.row + 1 : node.startPosition.row + 1);
+            if (currentScope) ctx.moduleBehaviours[currentScope.name] = [...ctx.moduleBehaviours[currentScope.name] ?? [], bhv];
+          }
+        }
+        if (attrName === "impl") {
+          const argsNode = attrCall?.type === "call" ? this.findChild(attrCall, (c) => c?.type === "arguments") : void 0;
+          const first = argsNode && argsNode.namedChildCount > 0 ? argsNode.namedChild(0) : void 0;
+          const denies = !!first && (first.type === "boolean" && first.text === "false" || first.type === "nil");
+          let candidates = [];
+          let form = "denied";
+          if (denies) {
+            candidates = [];
+          } else if (first?.type === "alias") {
+            candidates = [this.resolveAlias(first.text, ctx)];
+            form = "explicit_protocol";
+          } else {
+            let implProto = "";
+            for (let i = scopeStack.length - 1; i >= 0; i--) {
+              const sc = scopeStack[i];
+              if (sc.kind === ASTEngine.SymbolKind.Class) {
+                const proto = ctx.symbolByName.get(sc.name)?.metadata?.protocol;
+                if (typeof proto === "string" && proto) implProto = proto;
+                break;
+              }
+              if (sc.kind === ASTEngine.SymbolKind.Module || sc.kind === ASTEngine.SymbolKind.Interface) break;
+            }
+            const behaviours = currentScope ? [...new Set(ctx.moduleBehaviours[currentScope.name] ?? [])] : [];
+            if (implProto) {
+              candidates = [implProto];
+              form = "defimpl_protocol";
+            } else if (behaviours.length === 1) {
+              candidates = behaviours;
+              form = "single_behaviour";
+            } else if (behaviours.length > 1) {
+              candidates = behaviours;
+              form = "declared_callback";
+            }
+          }
+          ctx.pendingImpl = candidates.length > 0 ? { candidates, form } : void 0;
+        }
+        if (attrName === "derive") {
+          const argsNode = attrCall?.type === "call" ? this.findChild(attrCall, (c) => c?.type === "arguments") : void 0;
+          const first = argsNode && argsNode.namedChildCount > 0 ? argsNode.namedChild(0) : void 0;
+          const protoNodes = [];
+          if (first?.type === "alias") protoNodes.push(first);
+          else if (first?.type === "tuple") {
+            const a = this.findChild(first, (c) => c?.type === "alias");
+            if (a) protoNodes.push(a);
+          } else if (first?.type === "list") {
+            for (let i = 0; i < first.namedChildCount; i++) {
+              const el = first.namedChild(i);
+              if (!el) continue;
+              if (el.type === "alias") protoNodes.push(el);
+              else if (el.type === "tuple") {
+                const a = this.findChild(el, (c) => c?.type === "alias");
+                if (a) protoNodes.push(a);
+              }
+            }
+          }
+          for (const pn of protoNodes) {
+            const proto = this.resolveAlias(pn.text, ctx);
+            if (currentScope && proto) {
+              this.pushRel(ctx, currentScope.name, proto, ASTEngine.RelationshipType.Implements, 0.9, { reasonCode: "elixir_derive_attribute" }, pn.startPosition.row + 1);
+            }
+          }
+        }
+        if (attrName === "moduledoc") {
+          const argsNode = attrCall?.type === "call" ? this.findChild(attrCall, (c) => c?.type === "arguments") : void 0;
+          const first = argsNode && argsNode.namedChildCount > 0 ? argsNode.namedChild(0) : void 0;
+          const text = first ? this.docContent(first) : "";
+          if (text && currentScope) {
+            const sym = ctx.symbolByName.get(currentScope.name);
+            if (sym) {
+              sym.comments = [text];
+              sym.docstring = text;
+            }
+          }
+        }
+        if (attrName === "doc") {
+          const argsNode = attrCall?.type === "call" ? this.findChild(attrCall, (c) => c?.type === "arguments") : void 0;
+          const first = argsNode && argsNode.namedChildCount > 0 ? argsNode.namedChild(0) : void 0;
+          if (first && (first.text === "false" || first.text === "nil") && (first.type === "identifier" || first.type === "boolean" || first.type === "nil")) ctx.pendingDoc = void 0;
+          else {
+            const text = first ? this.docContent(first) : "";
+            if (text) ctx.pendingDoc = text;
+          }
+        }
+      } else if (node.type === "unary_operator" && node.child(0)?.text === "&") {
+        const inner = node.child(1);
+        if (inner?.type === "binary_operator" && inner.child(1)?.text === "/" && !this.isInQuotedCode(node)) {
+          const fnNode = inner.child(0);
+          const arityNode = inner.child(2);
+          const arity = arityNode ? parseInt(arityNode.text, 10) : 0;
+          let fnName = "";
+          if (fnNode?.type === "identifier") fnName = fnNode.text;
+          else if (fnNode?.type === "call") {
+            const tgt = this.findChild(fnNode, (c) => c?.type === "identifier" || c?.type === "dot");
+            if (tgt && !this.findChild(fnNode, (c) => c?.type === "arguments")) fnName = tgt.text;
+          }
+          const leaf = fnName.split(".").pop() ?? fnName;
+          const skipName = fnName.includes(".") ? fnName : leaf;
+          if (fnName && !this.shouldSkipCall(node, skipName)) {
+            this.recordCall(fnName, ctx, currentScope, this.enclosingDeclaredScope(scopeStack), { isCapture: true }, fnNode ? fnNode.startPosition.row + 1 : node.startPosition.row + 1, arity);
+          }
+        }
+      } else if (node.type === "anonymous_function" || node.type === "stab_clause") {
+        ctx.patterns["Closures"] = true;
+        if (node.type === "stab_clause" && node.parent?.type === "do_block" && !this.isInQuotedCode(node)) {
+          cyclomaticComplexity++;
+          if (scopeStack.length > 0) scopeStack[scopeStack.length - 1].complexity++;
+        }
+      } else if ((node.type === "rescue_block" || node.type === "catch_block" || node.type === "after_block" || node.type === "else_block") && !this.isInQuotedCode(node)) {
+        cyclomaticComplexity++;
+        if (scopeStack.length > 0) scopeStack[scopeStack.length - 1].complexity++;
+      } else if (node.type === "binary_operator") {
+        const op = node.child(1)?.text;
+        if (op === "|>") {
+          ctx.patterns["Pipe Operator"] = true;
+          const right = node.child(2);
+          if (right) {
+            let targetName = "";
+            if (right.type === "call") {
+              const rId = this.findChild(right, (c) => c?.type === "identifier" || c?.type === "dot");
+              if (rId) targetName = rId.text;
+            } else if (right.type === "identifier" || right.type === "dot") {
+              targetName = right.text;
+            }
+            if (targetName && !this.shouldSkipCall(right, targetName)) {
+              const rightArgs = right.type === "call" ? this.findChild(right, (c) => c?.type === "arguments") : null;
+              this.recordCall(targetName, ctx, currentScope, this.enclosingDeclaredScope(scopeStack), { isPipe: true }, right.startPosition.row + 1, (rightArgs ? rightArgs.namedChildCount : 0) + 1);
+            }
+          }
+        }
+        if ((op === "and" || op === "or" || op === "&&" || op === "||") && !this.isInQuotedCode(node)) {
+          cyclomaticComplexity++;
+          if (scopeStack.length > 0) scopeStack[scopeStack.length - 1].complexity++;
+        }
+      } else if (node.type === "dot") {
+        const left = node.child(0)?.text;
+        if (left === "Enum" || left === "Stream") ctx.patterns["Functional Programming"] = true;
+      }
+      if (pushedScope) stack.push({ node, isExit: true });
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push({ node: child });
+      }
+    }
+    const frameworks = [];
+    for (const f in ctx.frameworks) frameworks.push(f);
+    const patterns = [];
+    for (const p in ctx.patterns) patterns.push(p);
+    const frameworkPatterns = [];
+    for (let i = 0; i < frameworks.length; i++) {
+      frameworkPatterns.push({
+        framework: frameworks[i],
+        patterns: [{ type: "usage", detected: true, description: `${frameworks[i]} usage detected` }]
+      });
+    }
+    for (const s of ctx.symbols) {
+      const isModLevel = !s.ownerName || s.kind === ASTEngine.SymbolKind.Module || s.kind === ASTEngine.SymbolKind.Interface;
+      const isPub = s.visibility === "public";
+      const isExp = [ASTEngine.SymbolKind.Module, ASTEngine.SymbolKind.Function, ASTEngine.SymbolKind.Interface, ASTEngine.SymbolKind.Struct].includes(s.kind);
+      if (isModLevel && isPub && isExp) {
+        ctx.exports.push({ name: s.name, kind: s.kind, range: s.range, visibility: s.visibility });
+      }
+    }
+    for (const s of ctx.symbols) if (s.name === "Unknown" && s.metadata) s.metadata.unresolvedName = true;
+    for (const s of ctx.symbols) {
+      const _owner = s.ownerName || s.scope;
+      if (_owner && _owner !== s.name && !s.metadata?.unresolvedName && !this.isPlaceholderName(_owner) && !this.isPlaceholderName(s.name) && s.name !== "unquote" && s.name !== "unquote_splicing") {
+        this.pushRel(ctx, _owner, s.name, ASTEngine.RelationshipType.Contains, 1, { reasonCode: "elixir_symbol_owner_ownership" }, s.range.startLine);
+      }
+    }
+    for (const s of ctx.symbols) {
+      const owner = s.ownerName || s.scope || "";
+      if (owner.length === 0 || owner === s.name) continue;
+      if (s.visibility !== "public") continue;
+      if (!EXPORTED_KINDS.has(String(s.kind))) continue;
+      if (s.name.length === 0) continue;
+      if (s.metadata?.unresolvedName || this.isPlaceholderName(owner) || this.isPlaceholderName(s.name)) continue;
+      if (s.name === "unquote" || s.name === "unquote_splicing") continue;
+      this.pushRel(
+        ctx,
+        owner,
+        s.name,
+        ASTEngine.RelationshipType.Exports,
+        1,
+        {
+          elixirSpecific: true,
+          exportKind: String(s.kind),
+          exportForm: String(s.kind) === "macro" ? "macro" : String(s.kind) === "method" ? "method" : String(s.kind) === "module" ? "module" : String(s.kind) === "type" ? "type" : "function",
+          evidenceClass: "structural",
+          // `exports-public-surface`: a behaviour surface declared with `@callback`
+          // and NO `def` at all is still public callable surface, and the flag
+          // says which rows came from a callback declaration rather than from a
+          // definition. The symbol already carries it (the callback attribute
+          // writes `isCallbackDeclaration`); the edge is what the consumer reads.
+          // A callback-only behaviour surface carries `isCallback` (`@callback`
+          // creates the symbol; a later `def` would complete it and set
+          // `isCallbackDeclaration`) — both spellings mean the same thing to a
+          // consumer reading the edge, so both publish the flag.
+          ...s.metadata?.isCallbackDeclaration || s.metadata?.isCallback ? { isCallbackDeclaration: true } : {}
+        },
+        s.range.startLine
+      );
+    }
+    for (const [mod, used] of ctx.moduleUses) {
+      for (const provider of used) {
+        const named = ctx.overridableNames.get(provider);
+        const moduleMarks = ctx.overridableModules.get(provider);
+        if (!named && !moduleMarks) continue;
+        for (const member of ctx.symbols) {
+          const owner = member.ownerName || "";
+          if (owner !== mod) continue;
+          const arity = typeof member.metadata?.arity === "number" ? String(member.metadata.arity) : "?";
+          const qualified = `${member.name}/${arity}`;
+          const bare = member.name;
+          let overriddenBy = "";
+          if (named && (named.has(qualified) || named.has(bare))) overriddenBy = provider;
+          else if (moduleMarks) {
+            for (const m of moduleMarks) {
+              const declares = ctx.symbols.some((s) => (s.ownerName || "") === m && s.name === member.name);
+              if (declares) {
+                overriddenBy = m;
+                break;
+              }
+            }
+          }
+          if (overriddenBy.length === 0) continue;
+          const overridden = `${overriddenBy}.${member.name}`;
+          if (overridden === `${mod}.${member.name}`) continue;
+          this.pushRel(
+            ctx,
+            `${mod}.${member.name}`,
+            overridden,
+            ASTEngine.RelationshipType.Overrides,
+            0.9,
+            { elixirSpecific: true, elixirOverridesKind: "use_of_defoverridable", provider: overriddenBy, evidenceClass: "structural", reasonCode: "elixir_use_defoverridable" },
+            member.range.startLine
+          );
+        }
+      }
+    }
+    const declaredStructFields = /* @__PURE__ */ new Set();
+    for (const s of ctx.symbols) {
+      if (s.kind === ASTEngine.SymbolKind.Property && s.metadata?.isStructField) declaredStructFields.add(s.name);
+    }
+    const verifyAgainstDeclaredFields = declaredStructFields.size > 0;
+    for (const c of ctx.usesCandidates) {
+      if (c.receiver.charCodeAt(0) !== 37 && (ctx.mapBoundByScope.get(c.source)?.has(c.receiver) ?? false)) {
+        ctx.mapKeyReceiverDropped++;
+        continue;
+      }
+      if (verifyAgainstDeclaredFields && !declaredStructFields.has(c.field)) continue;
+      if (verifyAgainstDeclaredFields) {
+        ctx.usesVerified++;
+        this.pushRel(
+          ctx,
+          c.source,
+          c.field,
+          ASTEngine.RelationshipType.Uses,
+          0.9,
+          { elixirSpecific: true, memberAccess: true, receiver: c.receiver, elixirUsesKind: "member_field_read", evidenceClass: "struct_field_read", reasonCode: "elixir_struct_field_read" },
+          c.line
+        );
+      } else {
+        ctx.usesContextual++;
+        this.pushRel(
+          ctx,
+          c.source,
+          c.field,
+          ASTEngine.RelationshipType.Uses,
+          0.7,
+          { elixirSpecific: true, memberAccess: true, receiver: c.receiver, elixirUsesKind: "member_field_read", evidenceClass: "usage_contextual", reasonCode: "elixir_member_field_read" },
+          c.line
+        );
+      }
+    }
+    const declaredByScope = /* @__PURE__ */ new Map();
+    for (const s of ctx.symbols) {
+      if (s.kind === ASTEngine.SymbolKind.Function || s.kind === ASTEngine.SymbolKind.Macro || s.kind === ASTEngine.SymbolKind.Method) {
+        const owner = s.ownerName || s.scope || "";
+        let set = declaredByScope.get(owner);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          declaredByScope.set(owner, set);
+        }
+        set.add(s.name);
+      }
+    }
+    const filteredRels = [];
+    for (const r of ctx.relationships) {
+      if (r.type === ASTEngine.RelationshipType.Calls && typeof r.target === "string" && r.target.indexOf(".") === -1) {
+        const declaredScope = r.metadata?._declaredScope;
+        if (typeof declaredScope === "string" && declaredScope !== "" && !declaredByScope.get(declaredScope)?.has(r.target)) {
+          const callScope = typeof r.metadata?._callScope === "string" ? r.metadata._callScope : void 0;
+          const resolved = this.resolveImport(ctx, declaredScope, r.target, callScope);
+          if (resolved) {
+            r.target = resolved;
+            if (r.metadata && typeof r.metadata === "object") {
+              r.metadata.evidenceClass = "reference_qualified";
+              r.metadata.reasonCode = "elixir_import_resolved_call";
+            }
+          } else continue;
+        }
+      }
+      if (r.metadata && typeof r.metadata === "object") {
+        if ("_declaredScope" in r.metadata) delete r.metadata._declaredScope;
+        if ("_callScope" in r.metadata) delete r.metadata._callScope;
+      }
+      filteredRels.push(r);
+    }
+    ctx.relationships = filteredRels;
+    return {
+      language: "elixir",
+      symbols: ctx.symbols,
+      relationships: ctx.relationships,
+      imports: ctx.imports,
+      exports: ctx.exports,
+      errors: ctx.errors,
+      metadata: {
+        complexity: ctx.symbols.length + ctx.relationships.length,
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity,
+        framework: frameworks[0],
+        patterns,
+        detectedFrameworks: frameworks,
+        frameworkPatterns,
+        architecturalScore: Math.min(100, Math.max(0, 100 - ctx.errors.length * 5)),
+        codeQuality: ctx.errors.length === 0 ? "Excellent" : "Fair",
+        hasTypeInference: false,
+        hasFrameworkIntelligence: true,
+        analysisVersion: "10.0.0-elixir-dfs-strict",
+        // EX-EX3 × ELIXIR_FIX2-U1: the countable split of the `uses` surface
+        // ( clause 3 — a ratio is only countable if the populations are named).
+        usesCandidates: ctx.usesCandidates.length,
+        usesVerified: ctx.usesVerified,
+        usesContextual: ctx.usesContextual,
+        mapKeyReceiverDropped: ctx.mapKeyReceiverDropped
+      }
+    };
+  }
+  // ELXD17: resolve an unqualified call through :only-constrained imports
+  // (last import wins, mirroring Elixir's conflict rule). Bare imports and
+  // :except lists cannot confirm a target per-file, so they never resolve —
+  // those calls stay dropped rather than fabricated.
+  // EX2-U5: the import's lexical scope must equal the declared scope that
+  // governs the call site (module-level import) OR the call site's own
+  // function (an import written inside a def body).
+  resolveImport(ctx, scope, name, callScope) {
+    for (let i = ctx.importList.length - 1; i >= 0; i--) {
+      const imp = ctx.importList[i];
+      if (imp.scope !== scope && imp.scope !== callScope) continue;
+      if (imp.only && imp.only.has(name)) return `${imp.module}.${name}`;
+    }
+    return void 0;
+  }
+  // EX2-U1: resolve the ROOT segment of a dotted name through the module's
+  // alias table (`alias MyApp.OrderBook` → OrderBook → MyApp.OrderBook).
+  // recordCall already did this; every other site that NAMES a type/module —
+  // struct literals, struct()/1, @behaviour, @derive, defimpl (protocol and
+  // target), and use/import/require module names — did not, so their edges
+  // pointed at strings that match nothing in the symbol table. Pure
+  // alias-table lookup on AST text — no scanning, no regexes.
+  resolveAlias(name, ctx) {
+    if (!name) return name;
+    const parts = name.split(".");
+    const root = parts[0];
+    if (root && ctx.aliases[root]) {
+      parts[0] = ctx.aliases[root];
+      return parts.join(".");
+    }
+    return name;
+  }
+  // The top non-function scope on the stack — the module/class whose declared
+  // set governs unqualified-call resolution for the current call site.
+  enclosingDeclaredScope(scopeStack) {
+    for (let i = scopeStack.length - 1; i >= 0; i--) {
+      const k = scopeStack[i].kind;
+      if (k !== ASTEngine.SymbolKind.Function && k !== ASTEngine.SymbolKind.Macro && k !== ASTEngine.SymbolKind.Method) {
+        return scopeStack[i].name;
+      }
+    }
+    return void 0;
+  }
+  // ==========================================================================
+  // Relationship emission helpers (dedupe by source|type|target identity).
+  // ==========================================================================
+  pushRel(ctx, source, target, type, confidence, metadata = {}, line) {
+    const key = `${source}|${type}|${target}|${line ?? ""}|${metadata.callArity ?? ""}`;
+    if (ctx.seenRels.has(key)) return;
+    ctx.seenRels.add(key);
+    let md = metadata;
+    const needReason = confidence < 1 && !(typeof metadata.reasonCode === "string" && metadata.reasonCode.length > 0);
+    const needClass = !(typeof metadata.evidenceClass === "string" && metadata.evidenceClass.length > 0);
+    if (needReason || needClass) {
+      md = { ...metadata };
+      if (needReason) {
+        md.reasonCode = `elixir_${String(type)}_heuristic`;
+        md.reasonCodeSource = "default_at_pushrel";
+      }
+      if (needClass) md.evidenceClass = evidenceClassFor(type, confidence, target);
+    }
+    const rel = {
+      source,
+      target,
+      type,
+      confidence,
+      metadata: md,
+      ...typeof line === "number" && line > 0 ? { line_number: line } : {}
+    };
+    ctx.relationships.push(rel);
+  }
+  recordCall(targetName, ctx, currentScope, declaredScope, meta = {}, line, arity) {
+    let finalTarget = targetName;
+    if (finalTarget.indexOf("(") !== -1) {
+      const lastDot = finalTarget.lastIndexOf(".");
+      finalTarget = lastDot >= 0 ? finalTarget.slice(lastDot + 1) : finalTarget;
+      const paren = finalTarget.indexOf("(");
+      if (paren !== -1) finalTarget = finalTarget.slice(0, paren);
+      if (finalTarget) {
+        if (arity && arity > 0) meta = { ...meta, callArity: arity };
+        this.pushRel(ctx, currentScope?.name || "Global", finalTarget, ASTEngine.RelationshipType.Calls, 0.8, { elixirSpecific: true, reasonCode: "elixir_call_chained_receiver_leaf", ...meta }, line);
+      }
+      return;
+    }
+    if (finalTarget.startsWith("__MODULE__.")) {
+      if (!declaredScope) return;
+      finalTarget = declaredScope + finalTarget.slice("__MODULE__".length);
+    }
+    const parts = finalTarget.split(".");
+    if (parts.length > 1) {
+      const root = parts[0];
+      if (ctx.aliases[root]) {
+        parts[0] = ctx.aliases[root];
+        finalTarget = parts.join(".");
+      }
+    }
+    if (!finalTarget) return;
+    if (finalTarget.startsWith("&")) return;
+    if (finalTarget.startsWith("__ENV__.") || finalTarget.startsWith("__CALLER__.") || finalTarget.startsWith("__DIR__.") || finalTarget.startsWith("__STACKTRACE__.")) return;
+    if (finalTarget.startsWith("Kernel.")) {
+      const leaf = finalTarget.slice("Kernel.".length);
+      if (KERNEL_FUNCTIONS.has(leaf) || SPECIAL_FORMS.has(leaf)) return;
+      let hasNameChar = false;
+      for (const ch of leaf) {
+        if (ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch === "_") {
+          hasNameChar = true;
+          break;
+        }
+      }
+      if (!hasNameChar) return;
+    }
+    if (finalTarget.indexOf(".") === -1) {
+      const aliased = ctx.aliases[finalTarget];
+      if (aliased && aliased.indexOf(".") !== -1) finalTarget = aliased;
+    }
+    if (arity && arity > 0) meta = { ...meta, callArity: arity };
+    if (finalTarget.indexOf(".") !== -1) {
+      const root = finalTarget.split(".")[0];
+      if (root && root.length > 0 && !(root[0] >= "A" && root[0] <= "Z") && root[0] !== ":") return;
+    } else if (declaredScope) {
+      const callScope = currentScope && (currentScope.kind === ASTEngine.SymbolKind.Function || currentScope.kind === ASTEngine.SymbolKind.Macro || currentScope.kind === ASTEngine.SymbolKind.Method) ? currentScope.name : void 0;
+      meta = { ...meta, _declaredScope: declaredScope, _callScope: callScope };
+    }
+    this.pushRel(
+      ctx,
+      currentScope?.name || "Global",
+      finalTarget,
+      ASTEngine.RelationshipType.Calls,
+      0.8,
+      { elixirSpecific: true, reasonCode: finalTarget.indexOf(".") !== -1 ? "elixir_call_qualified_module_receiver" : "elixir_call_local_declared_scope", ...meta },
+      line
+    );
+  }
+  recordInstantiates(structName, ctx, currentScope, line) {
+    if (!structName) return;
+    if (structName === currentScope?.name) return;
+    this.pushRel(ctx, currentScope?.name || "Global", structName, ASTEngine.RelationshipType.Instantiates, 0.9, { elixirSpecific: true, isStruct: true }, line);
+  }
+  // ==========================================================================
+  // Call-skip predicates (the noise-elimination contract).
+  // ==========================================================================
+  // Everything inside a `quote do ... end` block is data (macro AST), not
+  // executable code — the Clojure quoted-data rule for Elixir.
+  isInQuotedCode(node) {
+    let cur = node.parent;
+    while (cur) {
+      if (cur.type === "call") {
+        const id = this.findChild(cur, (c) => c?.type === "identifier");
+        if (id?.text === "quote") return true;
+        if (id?.text === "unquote" || id?.text === "unquote_splicing") return false;
+      }
+      cur = cur.parent;
+    }
+    return false;
+  }
+  // EX-A14: does this `def` have a BODY? Two shapes, both real: a `do_block`
+  // child, and the single-line `, do: body` pair — which the grammar nests
+  // INSIDE the def's `arguments`, so it is not a sibling of it (the first
+  // version of this check looked for a direct `pair` child and read every
+  // `def f(x), do: y` as bodiless, which is how a definition ended up carrying
+  // isDeclaration). The walk stays inside `arguments` and never descends into
+  // a nested `do_block`, which is a body of some inner construct, not this def's.
+  hasDefBody(node) {
+    if (this.findChild(node, (c) => c?.type === "do_block") !== null) return true;
+    const args = this.findChild(node, (c) => c?.type === "arguments");
+    if (!args) return false;
+    const stack = [args];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n !== args && n.type === "do_block") continue;
+      if (n.type === "pair") {
+        const kw = this.findChild(n, (c) => c?.type === "keyword");
+        if (kw && this.stripAfterColon(kw.text) === "do") return true;
+      }
+      for (let i = 0; i < n.childCount; i++) {
+        const c = n.child(i);
+        if (c) stack.push(c);
+      }
+    }
+    return false;
+  }
+  // Inside a module attribute (@foo ...) — the attribute's inner call is the
+  // attribute declaration, never a runtime invocation.
+  isInAttribute(node) {
+    let cur = node.parent;
+    while (cur) {
+      if (cur.type === "unary_operator") {
+        const op = cur.child(0);
+        if (op?.text === "@") return true;
+      }
+      cur = cur.parent;
+    }
+    return false;
+  }
+  // EX-A17: the attribute's OWN call node is its NAME (`@section ...` is
+  // call[section, arguments[...]]), never an invocation of `section`. The
+  // blanket isInAttribute gate hid that correctly, so the relaxation below has
+  // to keep naming it explicitly or every attribute publishes a phantom
+  // lowercase call.
+  isAttributeNameCall(node) {
+    const p = node.parent;
+    return !!(p && p.type === "unary_operator" && p.child(0)?.text === "@" && p.child(1)?.id === node.id);
+  }
+  // EX-A17: a module attribute's VALUE is COMPILE-TIME CODE. `@section
+  // %Spark.Dsl.Section{build: Spark.Dsl.build(:x)}` builds that struct while
+  // the module compiles, `@deferred fn -> Helper.later() end` names a real
+  // remote call, and `@raised raise Helper.Error` raises a real exception —
+  // the whole DSL ecosystem (Ash/Spark, Ecto.Migration, Quantum) is built on
+  // it. The blanket gate silenced every edge inside an attribute value, so a
+  // DSL section named no dependency at all: 21 attributes carrying 21 struct
+  // literals in a 250-file sample of ash, 0 elsewhere in 938 files — and the
+  // SAME walk already counted `case` inside an attribute toward cyclomatic
+  // complexity and set its pattern flags, so the gate contradicted the
+  // analyzer's own treatment of the same subtree. The DECLARATION attributes
+  // keep their silence; `isInAttribute` still guards the directive and
+  // member-read walks, because a `use`/`alias` cannot legitimately appear in
+  // an attribute value.
+  isInDeclarationAttributeValue(node) {
+    let cur = node.parent;
+    while (cur) {
+      if (cur.type === "unary_operator" && cur.child(0)?.text === "@") {
+        const value = cur.child(1);
+        if (!value || value.type !== "call") return true;
+        const id = this.findChild(value, (c) => c?.type === "identifier");
+        return DECLARATION_ATTRIBUTES.has(id?.text ?? "");
+      }
+      cur = cur.parent;
+    }
+    return false;
+  }
+  // The signature call (and its pattern-position arguments) nested in a
+  // def/defp/defmacro/defmacrop `arguments` is the declaration head, not a call
+  // site. Stops at both the do_block boundary AND the single-line `, do: body`
+  // pair so calls in the body are never misclassified as heads. The pair
+  // check matches exactly `do:` — keyword pairs like `domain:` in signature
+  // patterns must not end the head walk (deep-review hygiene).
+  // ELIXIR_FIX2-P2 — a def-shaped call inside a def-shaped BODY is a CALL.
+  //
+  // Elixir requires `def`/`defp`/`defmacro`/… to sit at module level; a
+  // definition inside a definition body is a macro invocation of the same name
+  // (the one legal way to generate definitions — inside a `quote` — is already
+  // excluded by isInQuotedCode). Found by the contains oracle, not by reading:
+  //
+  //   lib/elixir/lib/kernel/utils.ex:317-319
+  //     defmacro defguard(args, expr) do
+  //       defguard(args, expr, __CALLER__)
+  //     end
+  //
+  // published a MACRO symbol named `args`, owned by `Kernel.Utils.defguard/2`.
+  // The shape is `call > identifier(defguard) + arguments(identifier,
+  // identifier, identifier)` — with bare arguments there is NO nested `call`
+  // node, so the existing signature read takes `arguments`' first named child
+  // and the argument becomes the name. `isDefHead` cannot see it: it returns
+  // false on the enclosing `do_block` before it ever reaches the outer call,
+  // which is the correct answer to "is this a signature head" and the wrong
+  // question to ask here.
+  isInsideDefBody(node) {
+    let cur = node.parent;
+    while (cur) {
+      if (cur.type === "do_block") {
+        const owner = cur.parent;
+        if (owner && owner.type === "call") {
+          const id = this.findChild(owner, (c) => c?.type === "identifier");
+          if (id && DEF_CONSTRUCTS.has(id.text)) return true;
+        }
+      }
+      if (cur.type === "pair") {
+        const kw = this.findChild(cur, (c) => c?.type === "keyword");
+        const kwt = kw?.text ?? "";
+        const owner = cur.parent;
+        if ((kwt === "do" || kwt.startsWith("do:")) && owner && owner.type === "call") {
+          const id = this.findChild(owner, (c) => c?.type === "identifier");
+          if (id && DEF_CONSTRUCTS.has(id.text)) return true;
+        }
+      }
+      cur = cur.parent;
+    }
+    return false;
+  }
+  isDefHead(node) {
+    const startIndex = node.startIndex;
+    let cur = node.parent;
+    while (cur) {
+      if (cur.type === "do_block") return false;
+      if (cur.type === "pair") {
+        const kw = this.findChild(cur, (c) => c?.type === "keyword");
+        const kwt = kw?.text ?? "";
+        if (kwt === "do" || kwt.startsWith("do:")) return false;
+      }
+      if (cur.type === "binary_operator" && cur.childCount > 2 && cur.child(1)?.text === "\\\\") {
+        const rhs = cur.child(2);
+        if (rhs && startIndex >= rhs.startIndex) return false;
+      }
+      if (cur.type === "call") {
+        const id = this.findChild(cur, (c) => c?.type === "identifier");
+        if (id && DEF_CONSTRUCTS.has(id.text)) return true;
+      }
+      cur = cur.parent;
+    }
+    return false;
+  }
+  // X2 (adversarial): PATTERN positions are never constructions. A struct
+  // literal in a case/fn/receive clause pattern, or on the left of `=` or
+  // `<-`, is a destructure — 43+16 live corpus sites each emitted a false
+  // instantiates (e.g. `fn %Mix.Dep{app: app} = dep ->`). The arrow token in
+  // a stab_clause separates pattern from body; the operators separate the
+  // match subject from the built value. (A `cond` clause test evaluates —
+  // structs there are nonsense code and are treated as patterns uniformly.)
+  isPatternPosition(node) {
+    let cur = node;
+    while (cur && cur.parent) {
+      const p = cur.parent;
+      if (p.type === "stab_clause") {
+        const arrow = this.findChild(p, (c) => c?.type === "->");
+        return arrow ? node.startIndex < arrow.startIndex : false;
+      }
+      if (p.type === "binary_operator" && (p.child(1)?.text === "=" || p.child(1)?.text === "<-")) {
+        const left = p.child(0);
+        return !!(left && node.startIndex >= left.startIndex && node.endIndex <= left.endIndex);
+      }
+      cur = p;
+    }
+    return false;
+  }
+  // Member/property access: `order.side` is a call whose target is a `dot`
+  // node with no arguments — a field read, not an invocation. Module calls
+  // like `Map.put(...)` carry arguments and are real invocations. A bare
+  // remote reference (`Enum.map`, `&Mod.fun/2`, `:lists.member`) also has no
+  // arguments but names a real remote function — only a lowercase root is a
+  // variable receiver or field read; anything else emits (ELXD18).
+  isMemberAccess(node) {
+    const target = this.findChild(node, (c) => c?.type === "identifier" || c?.type === "dot");
+    if (target?.type !== "dot") return false;
+    if (this.findChild(node, (c) => c?.type === "arguments")) return false;
+    const root = target.text.split(".")[0] ?? "";
+    return root.length > 0 && root[0] >= "a" && root[0] <= "z";
+  }
+  // ELIXIR_FIX2-O1 — record `defoverridable`. Two shapes, both on the corpus:
+  //
+  //   defoverridable child_spec: 1, code_change: 3     named function/arity
+  //   defoverridable EEx.Engine                         a whole module
+  //
+  // The name/arity list arrives as `keywords` or as a `list` of `pair`s /
+  // bare `keyword`s, and the arity is irrelevant to the edge — the edge names
+  // the FUNCTION, and Elixir's own `Module.overridable?/2` keys on name+arity,
+  // so the arity is carried in the recorded string for readability only. No
+  // pattern: a colon is found with indexOf and the head is a slice.
+  recordOverridable(node, ctx, currentScope) {
+    const owner = currentScope?.name || "";
+    if (owner.length === 0) return;
+    const argsNode = this.findChild(node, (c) => c?.type === "arguments");
+    if (!argsNode) return;
+    const addName = (name) => {
+      if (name.length === 0) return;
+      let set = ctx.overridableNames.get(owner);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        ctx.overridableNames.set(owner, set);
+      }
+      set.add(name);
+    };
+    const namedKids = (n) => {
+      const res = [];
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) res.push(c);
+      }
+      return res;
+    };
+    const addModule = (m) => {
+      if (m.length === 0) return;
+      let set = ctx.overridableModules.get(owner);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        ctx.overridableModules.set(owner, set);
+      }
+      set.add(this.resolveAlias(m, ctx));
+    };
+    const takePair = (pair) => {
+      const kw = this.findChild(pair, (c) => c?.type === "keyword");
+      if (!kw) return;
+      const colon = kw.text.indexOf(":");
+      if (colon <= 0) return;
+      const name = kw.text.slice(0, colon);
+      const rest = kw.text.slice(colon + 1);
+      let digits = "";
+      for (let i = 0; i < rest.length; i++) {
+        const c = rest.charCodeAt(i);
+        if (c >= 48 && c <= 57) digits += rest[i];
+      }
+      addName(digits.length > 0 ? `${name}/${digits}` : name);
+      let arityText = digits;
+      for (let j = 0; j < pair.namedChildCount; j++) {
+        const v = pair.namedChild(j);
+        if (v?.type === "integer") {
+          arityText = v.text;
+          break;
+        }
+      }
+      let marks = ctx.overridable.get(owner);
+      if (!marks) {
+        marks = /* @__PURE__ */ new Map();
+        ctx.overridable.set(owner, marks);
+      }
+      marks.set(arityText.length > 0 ? `${name}/${arityText}` : `${name}/?`, node.startPosition.row + 1);
+    };
+    const visit = (n, depth) => {
+      if (depth > 4) return;
+      const t = String(n.type);
+      if (t === "pair") {
+        takePair(n);
+        return;
+      }
+      if (t === "keyword") {
+        const colon = n.text.indexOf(":");
+        if (colon > 0) addName(n.text.slice(0, colon));
+        return;
+      }
+      if (t === "alias") {
+        addModule(n.text);
+        return;
+      }
+      if (t === "identifier") {
+        addName(n.text);
+        return;
+      }
+      for (const c of namedKids(n)) visit(c, depth + 1);
+    };
+    visit(argsNode, 0);
+  }
+  // EX-EX9/EX-EX14 — the `overrides` edge Elixir actually has IN one file. The
+  // overriding definition lives in the module that `use`s the provider (a
+  // different file, and this analyzer publishes OUTGOING edges only), so the
+  // shape both endpoints can name here is: this module DECLARED `name/arity`
+  // (first declaration at `priorLine`), then marked it `defoverridable` (at
+  // `marked`), then DECLARED it again (the redefinition, at `line`). Elixir has no
+  // classes and no superclass, so — exactly like the bash lane's BD8b — both
+  // endpoints name the SAME function and `overridesLine` carries the prior
+  // declaration; `contains` publishes both declarations, so both endpoints
+  // resolve.
+  //
+  // The mark must come AFTER the declaration it marks (`defoverridable` appears
+  // below its functions at every one of the corpus sites), and the redefinition
+  // after the mark: a mark with nothing before it describes an extension point,
+  // not an override. Promoted from analyzer/ELIXIR_EXPORTS2 (which measured the
+  // corpus shape) and analyzer/ELIXIR4; main recorded the marks and emitted
+  // nothing, which is why `overrides-defoverridable`'s six rows were missing.
+  recordOverride(ctx, owner, name, arity, priorLine, line) {
+    if (!owner || this.isPlaceholderName(name)) return;
+    const marks = ctx.overridable.get(owner);
+    if (!marks) return;
+    const marked = marks.get(`${name}/${arity}`);
+    if (marked === void 0) return;
+    if (priorLine === void 0) return;
+    if (priorLine >= line) return;
+    this.pushRel(ctx, `${owner}.${name}/${arity}`, name, ASTEngine.RelationshipType.Overrides, 1, {
+      elixirSpecific: true,
+      redefinition: true,
+      via: "defoverridable",
+      overridesLine: priorLine,
+      markedLine: marked
+    }, line);
+  }
+  // ELIXIR_FIX2-U1 — the SAME predicate isMemberAccess uses, returning the two Kept next to it on purpose: if the two ever
+  // disagree, a field read is either double-labelled (edge here AND a call) or
+  // silently dropped (neither), and the only way to notice is the two sitting in
+  // one file. Pure char scan — `charCodeAt` against a-z — not a pattern.
+  memberReadLeaf(node) {
+    const target = this.findChild(node, (c) => c?.type === "identifier" || c?.type === "dot");
+    if (target?.type !== "dot") return void 0;
+    if (this.findChild(node, (c) => c?.type === "arguments")) return void 0;
+    const parts = target.text.split(".");
+    if (parts.length < 2) return void 0;
+    const root = parts[0] ?? "";
+    if (root.length === 0) return void 0;
+    const c0 = root.charCodeAt(0);
+    if (!(c0 >= 97 && c0 <= 122 || c0 === 37)) return void 0;
+    const leaf = parts[parts.length - 1] ?? "";
+    if (leaf.length === 0 || leaf === "unknown") return void 0;
+    return { leaf, receiver: root };
+  }
+  // EX-EX12 — the variables this DEFINITION binds to a MAP, by shape (no
+  // patterns, no regexes):
+  //   `%{} = m`         a match whose map side is a bare map  -> m
+  //   `%{a: a} = m`     a destructuring match                 -> m and a
+  //   `m = %{a: a}`     the same match written the other way   -> m and a
+  //   `%Mod{} = u`      NOT a map (the map side carries a `struct` child) -> none
+  // A NESTED definition owns its own bindings, so its subtree is not scanned
+  // here — its own `processFunction` call records them under its own scope.
+  mapBoundVariables(within) {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    const add = (name) => {
+      if (name.length === 0 || seen.has(name)) return;
+      seen.add(name);
+      out.push(name);
+    };
+    const scan = (n) => {
+      if (n !== within && n.type === "call") {
+        const kwt = this.findChild(n, (c) => c?.type === "identifier")?.text ?? "";
+        if (DEF_CONSTRUCTS.has(kwt) && !this.isDefHead(n)) return;
+      }
+      if (n.type === "binary_operator" && this.binaryPart(n, "operator")?.text === "=") {
+        const left = this.binaryPart(n, "left");
+        const right = this.binaryPart(n, "right");
+        const leftIsMap = left?.type === "map" && this.findChild(left, (c) => c?.type === "struct") === null;
+        const rightIsMap = right?.type === "map" && this.findChild(right, (c) => c?.type === "struct") === null;
+        if (leftIsMap || rightIsMap) {
+          const pattern = leftIsMap ? left : right;
+          const bound = leftIsMap ? right : left;
+          for (const name of this.identifiersIn(pattern)) add(name);
+          if (bound?.type === "identifier") add(bound.text);
+          else if (bound) for (const name of this.identifiersIn(bound)) add(name);
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) scan(c);
+      }
+    };
+    scan(within);
+    return out;
+  }
+  /** The identifiers a subtree names — the keys of `%{a: a, b: b}` bind `a`/`b`.
+   *  A `pair`'s key (`:day` in `%{day: day}`) is a NAME, not a binding, so the
+   *  key child is skipped and only the value side is walked. */
+  identifiersIn(n) {
+    const out = [];
+    const stack = [n];
+    while (stack.length > 0) {
+      const cur = stack.pop();
+      if (cur.type === "identifier" && cur.text) out.push(cur.text);
+      if (cur.type === "pair") {
+        const key = this.findChild(cur, (c) => c?.type === "keyword");
+        if (key) {
+          for (let i = 0; i < cur.namedChildCount; i++) {
+            const c = cur.namedChild(i);
+            if (c && c !== key) stack.push(c);
+          }
+          continue;
+        }
+      }
+      for (let i = 0; i < cur.namedChildCount; i++) {
+        const c = cur.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return out;
+  }
+  // X6 companion: the right-hand side of `|>` is consumed by the pipe
+  // branch (thread-adjusted arity) — its own walk must not re-emit the
+  // written arity as a second edge once arity joins the dedupe key.
+  // Same for the function head of a `&fun/arity` capture (the capture
+  // branch emits it with the declared arity; the bare head is not a
+  // zero-arity invocation).
+  isPipeStep(node) {
+    const p = node.parent;
+    return !!(p && p.type === "binary_operator" && p.child(1)?.text === "|>" && p.child(2) && p.child(2).startIndex === node.startIndex);
+  }
+  isCaptureHead(node) {
+    const p = node.parent;
+    if (!p || p.type !== "binary_operator" || p.child(1)?.text !== "/") return false;
+    const g = p.parent;
+    return !!(g && g.type === "unary_operator" && g.child(0)?.text === "&");
+  }
+  shouldSkipCall(node, t) {
+    if (SPECIAL_FORMS.has(t)) return true;
+    if (KERNEL_FUNCTIONS.has(t)) return true;
+    if (this.isInQuotedCode(node)) return true;
+    if (this.isAttributeNameCall(node)) return true;
+    if (this.isInDeclarationAttributeValue(node)) return true;
+    if (this.isDefHead(node)) return true;
+    if (this.isMemberAccess(node)) return true;
+    if (t.length > 0 && (t.charCodeAt(0) === 37 || t.indexOf("{") !== -1)) return true;
+    return false;
+  }
+  // ==========================================================================
+  // Pure-string helpers (no regexes).
+  // ==========================================================================
+  stripQuotes(text) {
+    let out = "";
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (ch === '"' || ch === "'") continue;
+      out += ch;
+    }
+    return out;
+  }
+  stripParens(text) {
+    let out = "";
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (ch === "(" || ch === ")") continue;
+      out += ch;
+    }
+    return out.trim();
+  }
+  stripAfterColon(text) {
+    const colon = text.indexOf(":");
+    return (colon >= 0 ? text.slice(0, colon) : text).trim();
+  }
+  // Documentation-chunk text of a string node: the grammar already excludes
+  // delimiters (heredoc fences included) from quoted_content leaves, so
+  // concatenating them is exact — no quote stripping that would eat
+  // interior apostrophes (ELXD14).
+  docContent(node) {
+    if (node.type !== "string" && node.type !== "sigil") return "";
+    let out = "";
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && (c.type === "quoted_content" || c.type === "interpolation")) out += c.text;
+    }
+    return out;
+  }
+  // ==========================================================================
+  // Node helpers.
+  // ==========================================================================
+  findChild(node, predicate) {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child && predicate(child)) return child;
+    }
+    return null;
+  }
+  filterChildren(node, predicate) {
+    const res = [];
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child && predicate(child)) res.push(child);
+    }
+    return res;
+  }
+  // ELIXIR_FIX2-P3 — a `defmodule`/`defprotocol`/`defimpl` name must come from
+  // an `alias` / `dot` / `identifier` node. `extractName` FALLS BACK to the
+  // node's raw text, which is right for a directive argument (`import Foo` is
+  // an alias, but `alias Foo.{Bar, Baz}` is a dot) and wrong for a module
+  // declaration: found by the contains oracle at
+  //   lib/elixir/test/elixir/kernel_test.exs:906  `defmodule 1 + 2, do: :ok`
+  //   lib/elixir/test/elixir/kernel_test.exs:924  `defmodule :"foo/bar", do: :ok`
+  //   lib/elixir/test/elixir/kernel_test.exs:928  `defmodule :"foo\bar", do: :ok`
+  // which published module symbols named `KernelTest.1 + 2, do: :ok`,
+  // `KernelTest.:"foo/bar", do: :ok` and `KernelTest.:"foo\bar", do: :ok`. All
+  // three are Elixir code that RAISES (the surrounding test is an
+  // `assert_raise ArgumentError`), so the construct is a computed module name,
+  // not a declaration, and the honest reading is silence. A name this reader
+  // cannot produce is a name the analyzer must not invent.
+  // R7-NAMES — a MODULE's own name, read off the first argument's node ONLY.
+  // Promoted from `analyzer/ELIXIR4`'s `moduleNameOf` (measured there, refused
+  // from main only by a union-parse fault): main's reader accepted `alias`/`dot`
+  // but not the two spellings a module name can really take, so
+  // `defmodule :"Elixir.R7Names.RawModule"` (a QUOTED ATOM carrying an absolute
+  // name) and `defmodule :atom_named` (an Erlang module named by an ATOM)
+  // published no module at all and left their members unowned; and
+  // `defmodule __MODULE__.Relative` published `Parent.__MODULE__.Relative`.
+  // `r7-module-names` pins all three shapes.
+  //
+  // Still rejected, and deliberately: a bare `identifier` (a VARIABLE — see
+  // `declarationName`, whose measurement main keeps) and any computed
+  // expression, whose "name" would be its own source text.
+  moduleNameOf(argsNode) {
+    const first = argsNode.namedChildCount > 0 ? argsNode.namedChild(0) : void 0;
+    if (!first) return "";
+    if (first.type === "atom") return first.text;
+    if (first.type === "quoted_atom") {
+      const inner = this.findChild(first, (c) => c?.type === "quoted_content")?.text ?? "";
+      return this.isAliasPath(inner) ? inner : "";
+    }
+    if (first.type !== "alias" && first.type !== "dot") return "";
+    const txt = first.text;
+    if (txt.length === 0) return "";
+    return this.isAliasPath(txt) ? txt : "";
+  }
+  // `__MODULE__` is not an alias segment, so it is accepted here; the caller
+  // resolves the prefix (joinModuleName). Every other segment must begin with an
+  // uppercase letter, which is what separates a real module name from source
+  // text that leaked in (`1 + 2`, `:"foo/bar"`).
+  isAliasPath(txt) {
+    if (txt.startsWith("__MODULE__")) {
+      const rest = txt.slice("__MODULE__".length);
+      if (rest.length === 0) return true;
+      if (!rest.startsWith(".")) return false;
+      return rest.slice(1).length > 0;
+    }
+    let start = 0;
+    while (start <= txt.length) {
+      let end = txt.indexOf(".", start);
+      if (end === -1) end = txt.length;
+      const seg = txt.slice(start, end);
+      if (!seg) return false;
+      const c = seg.charAt(0);
+      if (c !== c.toUpperCase() || c === c.toLowerCase()) return false;
+      start = end + 1;
+    }
+    return true;
+  }
+  // R7-NAMES: a nested module is `Scope.Name`, but a name the source wrote in
+  // FULL is already absolute and re-prefixing it doubles the namespace
+  // (`defmodule :"Elixir.ModuleTest.RawModule"` inside ModuleTest published
+  // `ModuleTest.:"Elixir.ModuleTest.RawModule"`), and a `__MODULE__`-relative
+  // name resolves against the enclosing module (`defmodule __MODULE__.Relative`
+  // published `Parent.__MODULE__.Relative`). Both shapes are pinned by
+  // `r7-module-names` and both were measured on the corpus by analyzer/ELIXIR4.
+  joinModuleName(scope, name) {
+    if (!scope) return name;
+    if (name.startsWith("__MODULE__.")) return `${scope}${name.slice("__MODULE__".length)}`;
+    if (name.startsWith("Elixir.") || name.startsWith(":")) return name;
+    if (name === scope || name.startsWith(scope + ".")) return name;
+    return `${scope}.${name}`;
+  }
+  declarationName(argsNode) {
+    const aliasNode = this.findChild(argsNode, (c) => c?.type === "alias" || c?.type === "dot");
+    if (!aliasNode) return "";
+    const txt = aliasNode.text;
+    if (txt.length === 0) return "";
+    for (let i = 0; i < txt.length; i++) {
+      const c = txt.charCodeAt(i);
+      const ok = c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95 || c === 46 || c === 33;
+      if (!ok) return "";
+    }
+    return txt;
+  }
+  extractName(node) {
+    let aliasNode = this.findChild(node, (c) => c?.type === "alias");
+    if (aliasNode) return aliasNode.text;
+    if (node.namedChildCount > 0) {
+      const first = node.namedChild(0);
+      if (first?.type === "alias" || first?.type === "identifier") return first.text;
+      if (first?.type === "dot") return first.text;
+    }
+    return this.stripParens(node.text);
+  }
+  // ==========================================================================
+  // Declaration processors.
+  // ==========================================================================
+  processModule(node, ctx, currentScope, scopeStack) {
+    if (this.isDefHead(node) || this.isInAttribute(node) || this.isInQuotedCode(node)) return false;
+    const argsNode = this.findChild(node, (c) => c?.type !== "identifier" && c?.type !== "do_block");
+    if (!argsNode) return false;
+    if (this.isInsideDefBody(node)) return false;
+    const name = this.moduleNameOf(argsNode);
+    if (name.length === 0) {
+      scopeStack.push({ node, name: currentScope?.name ?? "", kind: ASTEngine.SymbolKind.Module, complexity: 0, unnamedModule: true, savedAliases: ctx.aliases });
+      ctx.aliases = Object.create(ctx.aliases);
+      return true;
+    }
+    const fullName = this.joinModuleName(currentScope?.name, name);
+    const isAbsoluteName = name.length > 1 && name.charCodeAt(0) === 58;
+    const lexicalOwner = isAbsoluteName ? void 0 : currentScope?.name;
+    const symbol = {
+      name: fullName,
+      kind: ASTEngine.SymbolKind.Module,
+      range: this.nodeToRange(node),
+      scope: lexicalOwner || "",
+      ownerName: lexicalOwner,
+      ownerKind: lexicalOwner ? currentScope?.kind : void 0,
+      visibility: "public",
+      metadata: { elixirSpecific: true }
+    };
+    ctx.symbols.push(symbol);
+    ctx.symbolByName.set(fullName, symbol);
+    ctx.pendingDoc = void 0;
+    ctx.pendingImpl = void 0;
+    scopeStack.push({ node, name: fullName, kind: ASTEngine.SymbolKind.Module, complexity: 0, symbol, savedAliases: ctx.aliases });
+    ctx.aliases = Object.create(ctx.aliases);
+    return true;
+  }
+  processProtocol(node, ctx, currentScope, scopeStack) {
+    if (this.isDefHead(node) || this.isInAttribute(node) || this.isInQuotedCode(node)) return false;
+    const argsNode = this.findChild(node, (c) => c?.type !== "identifier" && c?.type !== "do_block");
+    if (!argsNode) return false;
+    if (this.isInsideDefBody(node)) return false;
+    const name = this.moduleNameOf(argsNode);
+    if (name.length === 0) {
+      scopeStack.push({ node, name: currentScope?.name ?? "", kind: ASTEngine.SymbolKind.Module, complexity: 0, unnamedModule: true, savedAliases: ctx.aliases });
+      ctx.aliases = Object.create(ctx.aliases);
+      return true;
+    }
+    const fullName = this.joinModuleName(currentScope?.name, name);
+    const protocolSym = { name: fullName, kind: ASTEngine.SymbolKind.Interface, range: this.nodeToRange(node), scope: currentScope?.name || "", ownerName: currentScope?.name, ownerKind: currentScope?.kind, visibility: "public", metadata: { elixirSpecific: true, isProtocol: true } };
+    ctx.symbols.push(protocolSym);
+    ctx.symbolByName.set(fullName, protocolSym);
+    ctx.pendingImpl = void 0;
+    ctx.pendingDoc = void 0;
+    scopeStack.push({ node, name: fullName, kind: ASTEngine.SymbolKind.Interface, complexity: 0, symbol: protocolSym, savedAliases: ctx.aliases });
+    ctx.aliases = Object.create(ctx.aliases);
+    return true;
+  }
+  processImpl(node, ctx, currentScope, scopeStack) {
+    ctx.pendingImpl = void 0;
+    if (this.isDefHead(node) || this.isInAttribute(node) || this.isInQuotedCode(node)) return false;
+    const argsNode = this.findChild(node, (c) => c?.type !== "identifier" && c?.type !== "do_block");
+    if (!argsNode) return false;
+    const aliases = this.filterChildren(argsNode, (c) => c?.type === "alias");
+    const protocol = aliases.length > 0 && aliases[0] ? this.resolveAlias(aliases[0].text, ctx) : "Unknown";
+    let forType = "Unknown";
+    const forTypeList = [];
+    let forTypeListNode = null;
+    const keywordsNode = this.findChild(argsNode, (c) => c?.type === "keywords");
+    if (keywordsNode) {
+      for (let i = 0; i < keywordsNode.namedChildCount; i++) {
+        const pair = keywordsNode.namedChild(i);
+        if (!pair || pair.type !== "pair") continue;
+        const kw = this.findChild(pair, (c) => c?.type === "keyword");
+        if (kw && this.stripAfterColon(kw.text) === "for" && pair.namedChildCount > 1) {
+          const val = pair.namedChild(1);
+          if (!val) continue;
+          if (val.type === "list") {
+            forTypeListNode = val;
+            for (let k = 0; k < val.namedChildCount; k++) {
+              const el = val.namedChild(k);
+              if (el && el.type === "alias") forTypeList.push(this.resolveAlias(el.text, ctx));
+            }
+            forType = forTypeList.length > 0 ? forTypeList[0] : "Unknown";
+          } else {
+            forType = this.resolveAlias(val.text, ctx);
+          }
+        }
+      }
+    }
+    const forTypeAlias = aliases.length > 1 ? this.resolveAlias(aliases[1].text, ctx) : forType;
+    const implName = forTypeAlias && forTypeAlias !== "Unknown" ? forTypeAlias : currentScope ? currentScope.name : protocol;
+    const fullName = implName;
+    const resolvedForType = forTypeList.length > 0 ? forTypeList : forType !== "Unknown" ? forType : implName !== protocol ? implName : void 0;
+    const implSym = { name: fullName, kind: ASTEngine.SymbolKind.Class, range: this.nodeToRange(node), scope: currentScope?.name || "", visibility: "public", metadata: { elixirSpecific: true, isProtocolImplementation: true, protocol, ...resolvedForType !== void 0 ? { forType: resolvedForType } : {} } };
+    ctx.symbols.push(implSym);
+    ctx.symbolByName.set(fullName, implSym);
+    if (forTypeList.length > 1) {
+      for (let ti = 1; ti < forTypeList.length; ti++) {
+        const tSym = { name: forTypeList[ti], kind: ASTEngine.SymbolKind.Class, range: this.nodeToRange(node), scope: currentScope?.name || "", visibility: "public", metadata: { elixirSpecific: true, isProtocolImplementation: true, protocol, forType: forTypeList[ti] } };
+        ctx.symbols.push(tSym);
+        ctx.symbolByName.set(forTypeList[ti], tSym);
+      }
+    }
+    const implLineNode = aliases.length > 1 ? aliases[1] : aliases[0];
+    if (forTypeListNode && forTypeList.length > 0) {
+      for (let k = 0; k < forTypeListNode.namedChildCount; k++) {
+        const el = forTypeListNode.namedChild(k);
+        if (!el || el.type !== "alias") continue;
+        const t = this.resolveAlias(el.text, ctx);
+        if (t && t !== "Unknown" && t !== protocol) this.pushRel(ctx, t, protocol, ASTEngine.RelationshipType.Implements, 1, { reasonCode: "elixir_defimpl_for_type" }, el.startPosition.row + 1);
+      }
+    } else if (fullName !== protocol) {
+      this.pushRel(ctx, fullName, protocol, ASTEngine.RelationshipType.Implements, 1, { reasonCode: "elixir_defimpl_protocol" }, implLineNode ? implLineNode.startPosition.row + 1 : node.startPosition.row + 1);
+    }
+    ctx.pendingDoc = void 0;
+    scopeStack.push({ node, name: fullName, kind: ASTEngine.SymbolKind.Class, complexity: 0, symbol: implSym, savedAliases: ctx.aliases });
+    ctx.aliases = Object.create(ctx.aliases);
+    return true;
+  }
+  processStruct(node, ctx, currentScope) {
+    if (this.isDefHead(node) || this.isInAttribute(node) || this.isInQuotedCode(node)) return;
+    if (!currentScope) return;
+    if (currentScope.unnamedModule) return;
+    const structName = currentScope.name;
+    const structSym = { name: structName, kind: ASTEngine.SymbolKind.Struct, range: this.nodeToRange(node), scope: currentScope.name, ownerName: currentScope.name, ownerKind: currentScope.kind, visibility: "public", metadata: { elixirSpecific: true, isStruct: true } };
+    ctx.symbols.push(structSym);
+    if (ctx.pendingDoc) {
+      structSym.comments = [ctx.pendingDoc];
+      structSym.docstring = ctx.pendingDoc;
+      ctx.pendingDoc = void 0;
+    }
+    const argsNode = this.findChild(node, (c) => c?.type === "arguments");
+    if (argsNode) {
+      for (let i = 0; i < argsNode.namedChildCount; i++) {
+        const child = argsNode.namedChild(i);
+        if (!child) continue;
+        const kwGroups = child.type === "keywords" ? [child] : child.type === "list" ? this.filterChildren(child, (c) => c?.type === "keywords") : [];
+        if (child.type === "list") {
+          for (let j = 0; j < child.namedChildCount; j++) {
+            const el = child.namedChild(j);
+            if (!el || el.type !== "atom") continue;
+            const fieldName = el.text.startsWith(":") ? el.text.slice(1) : el.text;
+            if (!fieldName) continue;
+            ctx.symbols.push({ name: fieldName, kind: ASTEngine.SymbolKind.Property, range: this.nodeToRange(el), ownerName: currentScope.name, ownerKind: currentScope.kind, scope: currentScope.name, visibility: "public", metadata: { elixirSpecific: true, isStructField: true } });
+          }
+        }
+        for (const kwGroup of kwGroups) {
+          for (let j = 0; j < kwGroup.namedChildCount; j++) {
+            const pair = kwGroup.namedChild(j);
+            if (!pair || pair.type !== "pair") continue;
+            const kwNode = this.findChild(pair, (c) => c?.type === "keyword" || c?.type === "quoted_keyword");
+            if (!kwNode?.text) continue;
+            const fieldName = this.stripQuotes(this.stripAfterColon(kwNode.text));
+            if (!fieldName) continue;
+            ctx.symbols.push({ name: fieldName, kind: ASTEngine.SymbolKind.Property, range: this.nodeToRange(pair), ownerName: currentScope.name, ownerKind: currentScope.kind, scope: currentScope.name, visibility: "public", metadata: { elixirSpecific: true, isStructField: true } });
+          }
+        }
+      }
+    }
+  }
+  /**
+   * M60 (#924, elixir E): the parts of a binary_operator read RELATIVE TO ITS OPERATOR
+   * TOKEN, never by absolute child index. A comment between a definition head and its
+   * `when` guard is an extra node that lands at index 1, so `child(1)` published the
+   * COMMENT as the function name (measured: list.ex:783; node shape in
+   * script/m14/tmp/c924-elixir-head-shape.ts — [0]left call, [1] comment,
+   * [2]operator `when`, [3]right guard).
+   */
+  binaryPart(node, part) {
+    let opIdx = -1;
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && !c.isNamed) {
+        opIdx = i;
+        break;
+      }
+    }
+    if (opIdx === -1) return null;
+    if (part === "operator") return node.child(opIdx);
+    const isTrivia = (c) => c.type === "comment";
+    if (part === "left") {
+      for (let i = opIdx - 1; i >= 0; i--) {
+        const c = node.child(i);
+        if (c && c.isNamed && !isTrivia(c)) return c;
+      }
+      return null;
+    }
+    for (let i = opIdx + 1; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && c.isNamed && !isTrivia(c)) return c;
+    }
+    return null;
+  }
+  processFunction(node, defType, ctx, currentScope, scopeStack) {
+    if (this.isDefHead(node) || this.isInAttribute(node) || this.isInQuotedCode(node)) return false;
+    if (this.isInsideDefBody(node)) return false;
+    const sigNodes = this.filterChildren(node, (c) => c?.type !== "identifier" && c?.type !== "do_block");
+    if (sigNodes.length === 0) return false;
+    let actualCall;
+    let guardList = [];
+    let name = "Unknown";
+    let hasPattern = false;
+    const parameters = [];
+    let sigNode = sigNodes[0];
+    if (sigNode && sigNode.type === "arguments" && sigNode.namedChildCount > 0) {
+      const first = sigNode.namedChild(0);
+      if (first) sigNode = first;
+    }
+    if (sigNode) {
+      if (sigNode.type === "binary_operator" && this.binaryPart(sigNode, "operator")?.text === "when") {
+        const guardExpr = this.binaryPart(sigNode, "right");
+        if (guardExpr) guardList.push(guardExpr.text);
+        actualCall = this.binaryPart(sigNode, "left") || void 0;
+        ctx.patterns["Pattern Matching"] = true;
+        hasPattern = true;
+      } else {
+        actualCall = sigNode;
+      }
+    }
+    if (actualCall) {
+      if (actualCall.type === "call") {
+        const innerId = this.findChild(actualCall, (c) => c?.type === "identifier");
+        if (innerId) name = innerId.text;
+        const innerArgs = this.findChild(actualCall, (c) => c?.type === "arguments");
+        if (innerArgs) {
+          for (let i = 0; i < innerArgs.namedChildCount; i++) {
+            const argChild = innerArgs.namedChild(i);
+            if (!argChild) continue;
+            let paramName = "_";
+            if (argChild.type === "identifier") paramName = argChild.text;
+            else if (argChild.type === "binary_operator" && argChild.childCount > 0 && argChild.child(0)?.type === "identifier") paramName = argChild.child(0).text;
+            parameters.push({ name: paramName, type: "dynamic" });
+            if (argChild.text.indexOf(":") !== -1 || argChild.text.indexOf("%") !== -1 || argChild.text.indexOf("_") !== -1 || argChild.text.startsWith("[")) {
+              hasPattern = true;
+              ctx.patterns["Pattern Matching"] = true;
+            }
+          }
+        }
+      } else if (actualCall.type === "identifier") {
+        name = actualCall.text;
+      } else if (actualCall.type === "binary_operator") {
+        name = actualCall.childCount > 1 ? actualCall.child(1)?.text || "Unknown" : "Unknown";
+        parameters.push({ name: actualCall.childCount > 0 ? actualCall.child(0)?.text || "left" : "left", type: "dynamic" });
+        parameters.push({ name: actualCall.childCount > 2 ? actualCall.child(2)?.text || "right" : "right", type: "dynamic" });
+      } else if (actualCall.type === "block" || this.findChild(actualCall, (c) => c?.type === "operator_identifier") !== null) {
+        const opNode = this.findChild(actualCall, (c) => c?.type === "operator_identifier");
+        if (opNode?.text) {
+          name = opNode.text;
+          const siblingArgs = this.filterChildren(actualCall.parent ?? { namedChildCount: 0, namedChild: () => null }, (c) => c?.type === "arguments")[0];
+          if (siblingArgs) {
+            for (let i = 0; i < siblingArgs.namedChildCount; i++) {
+              const a = siblingArgs.namedChild(i);
+              if (a) parameters.push({ name: a.type === "identifier" ? a.text : "_", type: "dynamic" });
+            }
+          } else {
+            parameters.push({ name: "operand", type: "dynamic" });
+          }
+        } else {
+          name = this.binaryPart(actualCall, "operator")?.text || "Unknown";
+          parameters.push({ name: this.binaryPart(actualCall, "left")?.text || "left", type: "dynamic" });
+          parameters.push({ name: this.binaryPart(actualCall, "right")?.text || "right", type: "dynamic" });
+        }
+      } else if (actualCall.type === "unary_operator") {
+        for (let i = 0; i < actualCall.childCount; i++) {
+          const c = actualCall.child(i);
+          if (c && !c.isNamed) {
+            name = c.text;
+            break;
+          }
+        }
+        const operand = this.findChild(actualCall, (c) => c?.type === "identifier");
+        parameters.push({ name: operand?.text || "operand", type: "dynamic" });
+      }
+    }
+    const isDeclaration = !this.hasDefBody(node) && defType === "def";
+    const visibility = defType === "defp" || defType === "defmacrop" || defType === "defguardp" ? "private" : "public";
+    let isGenCallback = false, isSupCallback = false;
+    if (name === "init" || name === "handle_call" || name === "handle_cast" || name === "handle_info" || name === "terminate") isGenCallback = true;
+    let isSupervisor = false;
+    if (currentScope) {
+      const ownerSym = ctx.symbolByName.get(currentScope.name);
+      if (ownerSym?.metadata?.isSupervisor) isSupervisor = true;
+    }
+    if (name === "init" && isSupervisor) isSupCallback = true;
+    const arity = parameters.length;
+    const fnId = `${currentScope?.name || ""}.${name}/${arity}`;
+    const declLine = node.startPosition.row + 1;
+    this.recordOverride(ctx, currentScope?.name, name, arity, ctx.lastDeclLine.get(fnId), declLine);
+    ctx.lastDeclLine.set(fnId, declLine);
+    const pendingImpl = ctx.pendingImpl;
+    ctx.pendingImpl = void 0;
+    if (pendingImpl && name !== "Unknown" && !isDeclaration) {
+      const implOwner = currentScope?.name ?? "";
+      let contract = "";
+      if (pendingImpl.candidates.length === 1) contract = pendingImpl.candidates[0];
+      else {
+        const declared = ctx.moduleCallbacks[implOwner] ?? [];
+        if (declared.includes(name)) {
+          const owners = pendingImpl.candidates.filter((b) => (ctx.moduleCallbacks[b] ?? []).includes(name));
+          if (owners.length === 1) contract = owners[0];
+        }
+      }
+      if (contract) {
+        this.pushRel(
+          ctx,
+          fnId,
+          `${contract}.${name}`,
+          ASTEngine.RelationshipType.Overrides,
+          1,
+          { elixirSpecific: true, evidenceClass: "structural", overrideForm: pendingImpl.form, reasonCode: "elixir_impl_annotation" },
+          declLine
+        );
+      }
+    }
+    let symbolKind = ASTEngine.SymbolKind.Function;
+    if (defType === "defmacro" || defType === "defmacrop" || defType === "defguard" || defType === "defguardp") {
+      symbolKind = ASTEngine.SymbolKind.Macro;
+    } else if (currentScope && (currentScope.kind === ASTEngine.SymbolKind.Interface || currentScope.kind === ASTEngine.SymbolKind.Class)) {
+      symbolKind = ASTEngine.SymbolKind.Method;
+    }
+    const specKey = `${currentScope?.name ?? ""}/${name}/${arity}`;
+    const parkedSpec = ctx.callbackSpecs[specKey];
+    const parkedOptional = currentScope?.name ? ctx.optionalCallbacks[currentScope.name] : void 0;
+    if (ctx.functionHeads[fnId]) {
+      const existing = ctx.functionHeads[fnId];
+      if (!isDeclaration) existing.metadata.heads = existing.metadata.heads + 1;
+      if (parkedSpec) existing.metadata.callbackSpec = parkedSpec;
+      if (isDeclaration) {
+        if (!existing.isDeclaration) {
+          existing.isDeclaration = true;
+          existing.metadata.isBodylessDeclaration = true;
+        }
+        existing.metadata.isDeclaration = true;
+      } else {
+        existing.isDeclaration = void 0;
+        existing.metadata.isBodylessDeclaration = void 0;
+        if (parkedSpec) existing.metadata.isCallbackDeclaration = true;
+      }
+      this.extendRange(existing, this.nodeToRange(node));
+      let clauseRanges = existing.metadata.clauseRanges;
+      if (!clauseRanges) {
+        clauseRanges = [];
+        existing.metadata.clauseRanges = clauseRanges;
+      }
+      clauseRanges.push(this.nodeToRange(node));
+      if (hasPattern) existing.metadata.hasPatternMatching = true;
+      if (guardList.length > 0) {
+        let existingGuards = existing.metadata.guards || [];
+        for (let i = 0; i < guardList.length; i++) {
+          existingGuards.push(guardList[i]);
+        }
+        existing.metadata.guards = existingGuards;
+      }
+    } else {
+      const symbol = {
+        name,
+        kind: symbolKind,
+        range: this.nodeToRange(node),
+        scope: currentScope?.unnamedModule ? "" : currentScope?.name || "",
+        ownerName: currentScope?.unnamedModule ? void 0 : currentScope?.name,
+        ownerKind: currentScope?.unnamedModule ? void 0 : currentScope?.kind,
+        visibility,
+        parameters,
+        ...isDeclaration ? { isDeclaration: true } : {},
+        metadata: {
+          elixirSpecific: true,
+          isMacro: defType.indexOf("macro") !== -1,
+          arity,
+          heads: 1,
+          clauseRanges: [this.nodeToRange(node)],
+          // ELIXIR_FIX2-P6: the declaration is real, its OWNER is not
+          // knowable (the enclosing defmodule's name is a variable or a
+          // computed expression). Recorded so a consumer can see WHY the
+          // symbol has no owner, instead of inferring a bug.
+          ...currentScope?.unnamedModule ? { elixirOwnerUnknown: "un-nameable enclosing defmodule/defprotocol" } : {},
+          hasPatternMatching: hasPattern,
+          guards: guardList,
+          isGenServerCallback: isGenCallback,
+          isSupervisorCallback: isSupCallback,
+          ...isDeclaration ? { isBodylessDeclaration: true, isDeclaration: true } : {},
+          ...parkedSpec ? { callbackSpec: parkedSpec, isCallbackDeclaration: true } : {},
+          ...parkedOptional && parkedOptional.includes(name) ? { isOptionalCallback: true } : {}
+        }
+      };
+      ctx.symbols.push(symbol);
+      ctx.functionHeads[fnId] = symbol;
+    }
+    const fnSym = ctx.functionHeads[fnId];
+    if (ctx.pendingDoc) {
+      if (!fnSym.comments) fnSym.comments = [ctx.pendingDoc];
+      if (!fnSym.docstring) fnSym.docstring = ctx.pendingDoc;
+      ctx.pendingDoc = void 0;
+    }
+    if (defType === "defdelegate" && name !== "Unknown") {
+      let toMod = "";
+      let asName = "";
+      let toLine = node.startPosition.row + 1;
+      const dscan = [node];
+      while (dscan.length > 0) {
+        const x = dscan.pop();
+        if (x.type === "pair") {
+          const kw = this.findChild(x, (c) => c?.type === "keyword");
+          const kt = kw ? this.stripAfterColon(kw.text) : "";
+          if (kt === "to" && x.namedChildCount > 1) {
+            const v = x.namedChild(1);
+            if (v?.type === "alias") {
+              toMod = v.text;
+              toLine = v.startPosition.row + 1;
+            }
+          } else if (kt === "as" && x.namedChildCount > 1) {
+            const v = x.namedChild(1);
+            if (v?.type === "atom") asName = v.text.startsWith(":") ? v.text.slice(1) : v.text;
+          }
+          continue;
+        }
+        if (x !== node && (x.type === "do_block" || x.type === "anonymous_function")) continue;
+        for (let i = x.namedChildCount - 1; i >= 0; i--) {
+          const c = x.namedChild(i);
+          if (c) dscan.push(c);
+        }
+      }
+      if (toMod) {
+        const resolved = this.resolveAlias(toMod, ctx);
+        const delScope = currentScope ? `${currentScope.name}.${name}/${arity}` : `${name}/${arity}`;
+        this.pushRel(ctx, delScope, `${resolved}.${asName || name}`, ASTEngine.RelationshipType.Calls, 0.9, { elixirSpecific: true, isDelegate: true, reasonCode: "elixir_defdelegate_remote_target" }, toLine);
+      }
+    }
+    const scopeName = currentScope ? `${currentScope.name}.${name}/${arity}` : `${name}/${arity}`;
+    scopeStack.push({ node, name: scopeName, kind: symbolKind, complexity: 0, symbol: fnSym, savedAliases: ctx.aliases });
+    if (ctx.content.includes("%{")) {
+      const bound = this.mapBoundVariables(node);
+      if (bound.length > 0) {
+        let set = ctx.mapBoundByScope.get(scopeName);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          ctx.mapBoundByScope.set(scopeName, set);
+        }
+        for (const b of bound) set.add(b);
+      }
+    }
+    ctx.aliases = Object.create(ctx.aliases);
+    return true;
+  }
+  processDirective(node, target, ctx, currentScope, scopeStack) {
+    if (this.isDefHead(node)) return;
+    if (this.isInAttribute(node)) return;
+    const argsNode = this.findChild(node, (c) => c?.type !== "identifier");
+    if (!argsNode) return;
+    const rawModuleName = this.extractDirectiveName(argsNode);
+    if (!rawModuleName) return;
+    let modScope;
+    for (let i = scopeStack.length - 1; i >= 0; i--) {
+      const k = scopeStack[i].kind;
+      if (k === ASTEngine.SymbolKind.Module || k === ASTEngine.SymbolKind.Interface) {
+        modScope = scopeStack[i].name;
+        break;
+      }
+    }
+    const resolveSelf = (name) => {
+      if (!name.startsWith("__MODULE__") || !modScope) return name;
+      return modScope + name.slice("__MODULE__".length);
+    };
+    const moduleName = this.resolveAlias(resolveSelf(rawModuleName), ctx);
+    if (target === "use" && modScope && moduleName.length > 0) {
+      let set = ctx.moduleUses.get(modScope);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        ctx.moduleUses.set(modScope, set);
+      }
+      set.add(moduleName);
+    }
+    let deps = [{ name: moduleName, line: argsNode.startPosition.row + 1 }];
+    if (target !== "alias") {
+      const groupDot = this.findChild(argsNode, (c) => c?.type === "dot" && !!this.findChild(c, (d) => d?.type === "tuple"));
+      const groupTuple = groupDot ? this.findChild(groupDot, (c) => c?.type === "tuple") : void 0;
+      if (groupDot && groupTuple) {
+        deps = [];
+        const rawPrefix = this.findChild(groupDot, (c) => c?.type === "alias")?.text ?? this.findChild(groupDot, (c) => c?.type === "identifier" && c.text === "__MODULE__")?.text ?? "";
+        const prefix = this.resolveAlias(resolveSelf(rawPrefix), ctx);
+        for (const kid of this.filterChildren(groupTuple, (c) => c?.type === "alias" || c?.type === "dot")) {
+          const full = prefix ? `${prefix}.${kid.text}` : kid.text;
+          if (full) deps.push({ name: full, line: kid.startPosition.row + 1 });
+        }
+      }
+    }
+    if (target === "alias") {
+      const multiDot = this.findChild(argsNode, (c) => c?.type === "dot" && !!this.findChild(c, (d) => d?.type === "tuple"));
+      const tuple = multiDot ? this.findChild(multiDot, (c) => c?.type === "tuple") : void 0;
+      if (tuple) {
+        deps = [];
+        const rawPrefix = this.findChild(multiDot, (c) => c?.type === "alias")?.text ?? this.findChild(multiDot, (c) => c?.type === "identifier" && c.text === "__MODULE__")?.text ?? "";
+        const prefix = this.resolveAlias(resolveSelf(rawPrefix), ctx);
+        for (const kid of this.filterChildren(tuple, (c) => c?.type === "alias" || c?.type === "dot" || c?.type === "identifier")) {
+          const full = prefix ? `${prefix}.${kid.text}` : kid.text;
+          const key = kid.text.split(".").pop();
+          if (key && full) {
+            ctx.aliases[key] = full;
+            deps.push({ name: full, line: kid.startPosition.row + 1 });
+          }
+        }
+      } else {
+        let asName = null;
+        const keywordsNode = this.findChild(argsNode, (c) => c?.type === "keywords");
+        if (keywordsNode) {
+          for (let i = 0; i < keywordsNode.namedChildCount; i++) {
+            const pair = keywordsNode.namedChild(i);
+            if (!pair || pair.type !== "pair") continue;
+            const kw = this.findChild(pair, (c) => c?.type === "keyword");
+            if (kw && this.stripAfterColon(kw.text) === "as" && pair.namedChildCount > 1) {
+              const val = pair.namedChild(1);
+              if (val) asName = val.text;
+            }
+          }
+        }
+        const parts = moduleName.split(".");
+        const defaultAs = parts[parts.length - 1];
+        const key = asName ?? defaultAs;
+        if (key) ctx.aliases[key] = moduleName;
+      }
+    } else if (target === "use") {
+      const fwRoot = moduleName.split(".")[0];
+      if (fwRoot === "Plug") ctx.frameworks["Plug"] = true;
+      if (fwRoot === "Phoenix") ctx.frameworks["Phoenix"] = true;
+      if (moduleName === "Phoenix.LiveView" || moduleName.startsWith("Phoenix.LiveView.")) ctx.frameworks["Phoenix LiveView"] = true;
+      if (fwRoot === "Ecto") ctx.frameworks["Ecto"] = true;
+      if (moduleName.indexOf("Phoenix.PubSub") !== -1 || moduleName.indexOf("Phoenix.Channel") !== -1) ctx.frameworks["Phoenix Channels"] = true;
+      if (fwRoot === "Broadway") ctx.frameworks["Broadway"] = true;
+      if (moduleName.split(".")[0] === "GenServer") {
+        ctx.patterns["Actor Model (OTP)"] = true;
+        const sym = currentScope ? ctx.symbolByName.get(currentScope.name) : void 0;
+        if (sym && sym.metadata) {
+          sym.metadata.isGenServer = true;
+          sym.metadata.otpBehavior = "GenServer";
+        }
+      }
+      if (moduleName.split(".")[0] === "Supervisor") {
+        ctx.patterns["Supervision Trees"] = true;
+        ctx.patterns["Actor Model (OTP)"] = true;
+        const sym = currentScope ? ctx.symbolByName.get(currentScope.name) : void 0;
+        if (sym && sym.metadata) {
+          sym.metadata.isSupervisor = true;
+          sym.metadata.otpBehavior = "Supervisor";
+        }
+      }
+    } else if (target === "import") {
+      const fwRoot = moduleName.split(".")[0];
+      if (fwRoot === "Plug") ctx.frameworks["Plug"] = true;
+      if (fwRoot === "Phoenix") ctx.frameworks["Phoenix"] = true;
+      if (fwRoot === "Ecto") ctx.frameworks["Ecto"] = true;
+      if (moduleName) {
+        let only;
+        const kwNode = this.findChild(argsNode, (c) => c?.type === "keywords");
+        if (kwNode) {
+          for (let i = 0; i < kwNode.namedChildCount; i++) {
+            const pair = kwNode.namedChild(i);
+            if (!pair || pair.type !== "pair") continue;
+            const kw = this.findChild(pair, (c) => c?.type === "keyword");
+            if (!kw || this.stripAfterColon(kw.text) !== "only" || pair.namedChildCount < 2) continue;
+            const val = pair.namedChild(1);
+            if (val?.type !== "list") continue;
+            const names = /* @__PURE__ */ new Set();
+            for (const kwGroup of this.filterChildren(val, (c) => c?.type === "keywords")) {
+              for (let j = 0; j < kwGroup.namedChildCount; j++) {
+                const fp = kwGroup.namedChild(j);
+                if (!fp || fp.type !== "pair") continue;
+                const fk = this.findChild(fp, (c) => c?.type === "keyword");
+                if (fk?.text) names.add(this.stripAfterColon(fk.text));
+              }
+            }
+            if (names.size > 0) only = names;
+          }
+        }
+        ctx.importList.push({ module: moduleName, only, scope: currentScope?.name ?? "" });
+      }
+    }
+    if (target === "use" || target === "import" || target === "alias" || target === "require") {
+      for (const dep of deps) {
+        if (!dep.name) continue;
+        ctx.imports.push({ module: dep.name, source: dep.name, imported: ["*"], isTypeOnly: false, range: this.nodeToRange(node) });
+        if (dep.name !== currentScope?.name) this.pushRel(
+          ctx,
+          currentScope?.name || "Global",
+          dep.name,
+          ASTEngine.RelationshipType.References,
+          0.9,
+          { reasonCode: `elixir_directive_${target}`, directive: target },
+          dep.line
+        );
+        if (target === "use" && dep.name !== currentScope?.name) {
+          this.pushRel(
+            ctx,
+            currentScope?.name || "Global",
+            dep.name,
+            ASTEngine.RelationshipType.MixesIn,
+            0.9,
+            { elixirSpecific: true, isMixin: true, via: "use", evidenceClass: "structural", reasonCode: "elixir_use_mixin_application" },
+            dep.line
+          );
+        }
+        if (target === "import" && dep.name !== currentScope?.name) {
+          this.pushRel(
+            ctx,
+            currentScope?.name || "Global",
+            dep.name,
+            ASTEngine.RelationshipType.Imports,
+            1,
+            { elixirSpecific: true, via: "import", reasonCode: "elixir_import_directive" },
+            dep.line
+          );
+        }
+      }
+    }
+  }
+  // EX-EX11/EX-EX11b: the placeholder spellings an edge ENDPOINT may not take.
+  // R7's rule is that an edge endpoint is a SYMBOL NAME; `Unknown` is this
+  // analyzer's own "I could not read it" sentinel, so an edge that names it names
+  // nothing. `global` is the file-level pseudo-scope and is a legal SOURCE (a
+  // directive at the top of a script has no module), never a legal TARGET.
+  // `unknown` (lowercase) is deliberately NOT here: that is a name the source
+  // really wrote (EX-EX11b).
+  isPlaceholderName(name) {
+    return name === "Unknown" || name === "global";
+  }
+  // R7-NAMES: the module name of a `use`/`import`/`alias`/`require` directive,
+  // read from its FIRST ARGUMENT NODE only. `alias :lists, as: MyList` names the
+  // Erlang module `:lists` — the atom's own text is the name and the options are
+  // options. A group form (`import Foo.{Bar, Baz}`) is an EXPRESSION, so the
+  // prefix alone is not a module and the caller expands it per member; a computed
+  // name (`alias Module.concat(A, B)`) is unreadable and returns "".
+  extractDirectiveName(node) {
+    const first = node.namedChildCount > 0 ? node.namedChild(0) : void 0;
+    if (!first) return "";
+    if (first.type === "alias" || first.type === "identifier") return first.text;
+    if (first.type === "atom") return first.text;
+    if (first.type === "dot") {
+      const part = (n) => {
+        if (!n) return "";
+        if (n.type === "dot") return part(n.childForFieldName("left")) + "." + part(n.childForFieldName("right"));
+        return n.text;
+      };
+      const left = first.childForFieldName("left");
+      const right = first.childForFieldName("right");
+      if (left && right) return part(left) + "." + part(right);
+      return "";
+    }
+    return "";
+  }
+  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 };
+  }
+  // EX-A8: grow a symbol's range to include a later declaration of the SAME
+  // definition (a merged multi-clause head). The start never moves — the
+  // declaration site is what every id and name-line consumer is built on — and
+  // endColumn is only meaningful together with its endLine, so a clause ending
+  // on a later line replaces the column and a clause ending on the same line
+  // takes the larger one. endIndex follows the same max rule.
+  extendRange(symbol, r) {
+    const cur = symbol.range;
+    if (r.endLine > cur.endLine) {
+      cur.endLine = r.endLine;
+      cur.endColumn = r.endColumn;
+    } else if (r.endLine === cur.endLine && r.endColumn > cur.endColumn) cur.endColumn = r.endColumn;
+    if (typeof r.endIndex === "number" && typeof cur.endIndex === "number" && r.endIndex > cur.endIndex) cur.endIndex = r.endIndex;
+  }
+};
+export {
+  RealElixirAnalyzer
+};