@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/real-makefile-analyzer-YJKAHNAS.js

@@ -0,0 +1,920 @@
+import {
+  ASTEngine
+} from "./chunk-V44PGPA6.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-makefile-analyzer.ts
+var GNU_MAKE_NAMESPACE = /* @__PURE__ */ new Set([
+  // builtin and implicit variables (the same spellings the analyzer's inner list uses)
+  "MAKE",
+  "MAKEFILE_LIST",
+  "MAKEFILES",
+  "MAKEFLAGS",
+  "MAKECMDGOALS",
+  "MAKELEVEL",
+  "CURDIR",
+  "SUFFIXES",
+  ".DEFAULT_GOAL",
+  "VPATH",
+  "SHELL",
+  "MFLAGS",
+  "CC",
+  "CXX",
+  "CPP",
+  "AR",
+  "ARFLAGS",
+  "AS",
+  "ASFLAGS",
+  "LD",
+  "LDFLAGS",
+  "LDLIBS",
+  "RM",
+  "CFLAGS",
+  "CXXFLAGS",
+  "CPPFLAGS",
+  "YFLAGS",
+  "LEX",
+  "YACC",
+  "AWK",
+  "FC",
+  "GET",
+  "PC",
+  "TEX",
+  "TEXI2DVI",
+  "WEAVE",
+  "CWEAVE",
+  "CTANGLE",
+  // automatic variables, as emitted
+  "$@",
+  "$%",
+  "$<",
+  "$?",
+  "$^",
+  "$+",
+  "$*",
+  "$|",
+  "$(@D)",
+  "$(@F)",
+  "$(%D)",
+  "$(%F)",
+  "$(<D)",
+  "$(<F)",
+  "$(?D)",
+  "$(?F)",
+  "$(^D)",
+  "$(^F)",
+  "$(+D)",
+  "$(+F)",
+  "$(*D)",
+  "$(*F)",
+  "$(|D)",
+  "$(|F)"
+]);
+var GNU_MAKE_NAMESPACE_ROOTS = [...GNU_MAKE_NAMESPACE];
+function isBareMakeName(s) {
+  if (s.length === 0) return false;
+  const first = s.charCodeAt(0);
+  if (!(first >= 65 && first <= 90 || first >= 97 && first <= 122 || first === 95)) return false;
+  for (let i = 1; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (!(c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 95)) return false;
+  }
+  return true;
+}
+function makeExternalClaim(kind, target, evidenceClass) {
+  if (kind !== ASTEngine.RelationshipType.Uses) return {};
+  if (GNU_MAKE_NAMESPACE.has(target)) return { languageNamespace: GNU_MAKE_NAMESPACE_ROOTS };
+  if (evidenceClass === "external" && isBareMakeName(target)) return { isExternal: true };
+  return {};
+}
+var RealMakefileAnalyzer = class {
+  analyze(rootNode, content, filePath) {
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    const patterns = [];
+    const moduleName = this.moduleName(filePath);
+    const byKey = /* @__PURE__ */ new Map();
+    const relSeen = /* @__PURE__ */ new Set();
+    const declared = /* @__PURE__ */ new Set();
+    const localBinders = /* @__PURE__ */ new Set();
+    const declaredTargets = /* @__PURE__ */ new Set();
+    const valuesByName = /* @__PURE__ */ new Map();
+    const edgeCount = { references: 0, uses: 0, calls: 0, contains: 0, exports: 0, imports: 0 };
+    let conditionals = 0;
+    const declareSymbol = (name, kind, node, metadata) => {
+      if (!name) return null;
+      declared.add(name);
+      const key = `${name}\0${kind}`;
+      const existing = byKey.get(key);
+      if (existing) {
+        const m = existing.metadata;
+        if (metadata.value !== void 0) m.value = metadata.value;
+        if (metadata.operator !== void 0) m.operator = metadata.operator;
+        if (metadata.redeclared) m.redeclared = true;
+        return existing;
+      }
+      const sym = {
+        name,
+        kind,
+        range: this.nodeToRange(node),
+        visibility: "global",
+        metadata
+      };
+      byKey.set(key, sym);
+      symbols.push(sym);
+      return sym;
+    };
+    const addRel = (source, type, target, line, metadata) => {
+      if (!source || !target || source === target) return;
+      const key = `${source}\0${type}\0${target}\0${line}`;
+      if (relSeen.has(key)) return;
+      relSeen.add(key);
+      edgeCount[type] = (edgeCount[type] ?? 0) + 1;
+      relationships.push({
+        source,
+        target,
+        type,
+        confidence: 1,
+        metadata: metadata ?? {},
+        line_number: line,
+        line
+      });
+    };
+    const moduleSymbol = declareSymbol(moduleName, ASTEngine.SymbolKind.Module, rootNode, {
+      nodeType: "makefile",
+      isMakeModule: true,
+      filePath
+    });
+    const module = moduleName;
+    const staged = [];
+    const BUILTIN_VARIABLES = /* @__PURE__ */ new Set([
+      "MAKE",
+      "MAKEFILE_LIST",
+      "MAKEFILES",
+      "MAKEFLAGS",
+      "MAKECMDGOALS",
+      "MAKELEVEL",
+      "CURDIR",
+      "SUFFIXES",
+      ".DEFAULT_GOAL",
+      "VPATH",
+      "SHELL",
+      "MFLAGS",
+      "CC",
+      "CXX",
+      "CPP",
+      "AR",
+      "ARFLAGS",
+      "AS",
+      "ASFLAGS",
+      "LD",
+      "LDFLAGS",
+      "LDLIBS",
+      "RM",
+      "CFLAGS",
+      "CXXFLAGS",
+      "CPPFLAGS",
+      "YFLAGS",
+      "LEX",
+      "YACC",
+      "AWK",
+      "FC",
+      "GET",
+      "PC",
+      "TEX",
+      "TEXI2DVI",
+      "WEAVE",
+      "CWEAVE",
+      "CTANGLE"
+    ]);
+    const BUILTIN_FUNCTIONS = /* @__PURE__ */ new Set([
+      "subst",
+      "patsubst",
+      "strip",
+      "findstring",
+      "filter",
+      "filter-out",
+      "sort",
+      "word",
+      "wordlist",
+      "words",
+      "firstword",
+      "lastword",
+      "dir",
+      "notdir",
+      "suffix",
+      "basename",
+      "addsuffix",
+      "addprefix",
+      "join",
+      "wildcard",
+      "realpath",
+      "abspath",
+      "if",
+      "or",
+      "and",
+      "foreach",
+      "file",
+      "call",
+      "value",
+      "eval",
+      "origin",
+      "flavor",
+      "shell",
+      "error",
+      "warning",
+      "info"
+    ]);
+    const KEYWORDS = /* @__PURE__ */ new Set([
+      "export",
+      "unexport",
+      "override",
+      "private",
+      "define",
+      "endef",
+      "include",
+      "-include",
+      "sinclude",
+      "vpath",
+      "undefine",
+      "ifeq",
+      "ifneq",
+      "ifdef",
+      "ifndef",
+      "else",
+      "endif",
+      "silent",
+      "quiet"
+    ]);
+    const stack = [{ node: rootNode, owner: module }];
+    const trimOperator = (raw) => {
+      let end = raw.length;
+      while (end > 0) {
+        const c = raw.charCodeAt(end - 1);
+        if (c === 63 || c === 43 || c === 61 || c === 33 || c === 58) end--;
+        else break;
+      }
+      return raw.slice(0, end).trim();
+    };
+    const normaliseExpression = (raw) => {
+      const t = raw.trim();
+      const braced = t.length > 3 && t.startsWith("$(") && t.endsWith(")");
+      const curly = t.length > 3 && t.startsWith("${") && t.endsWith("}");
+      if (braced || curly) {
+        const inner = t.slice(2, -1).trim();
+        if (inner.length > 0 && this.isPlainIdentifier(inner)) return { name: inner, isExpression: false };
+        return { name: inner, isExpression: true };
+      }
+      return { name: t, isExpression: false };
+    };
+    const declaredName = (node) => {
+      const w = this.firstChildOfType(node, /* @__PURE__ */ new Set(["word"]));
+      if (!w) return "";
+      const raw = w.text.trim();
+      if (!raw) return "";
+      const trimmed = trimOperator(raw);
+      if (!trimmed || KEYWORDS.has(trimmed)) return "";
+      return trimmed;
+    };
+    const markExported = (name, node, via) => {
+      if (!name) return;
+      const existing = symbols.find((s) => s.name === name);
+      if (existing) existing.metadata.isExported = true;
+      exports.push({
+        name,
+        kind: existing?.kind ?? ASTEngine.SymbolKind.Constant,
+        range: this.nodeToRange(node),
+        metadata: { via }
+      });
+      addRel(module, ASTEngine.RelationshipType.Exports, name, node.startPosition.row + 1, { via, evidenceClass: "export_directive" });
+    };
+    const deferred = [];
+    const declaredAtLines = /* @__PURE__ */ new Map();
+    const overrideSites = [];
+    while (stack.length > 0) {
+      const frame = stack.pop();
+      const node = frame.node;
+      const owner = frame.owner;
+      const type = node.type;
+      const line = node.startPosition.row + 1;
+      let childOwner = owner;
+      switch (type) {
+        // ---- variables --------------------------------------------------
+        case "variable_assignment":
+        case "shell_assignment": {
+          const name = declaredName(node);
+          if (name) {
+            const valueNode = this.firstChildOfType(node, /* @__PURE__ */ new Set(["text", "shell_command"]));
+            const value = valueNode?.text?.trim() ?? "";
+            if (!valuesByName.has(name)) valuesByName.set(name, value);
+            declareSymbol(name, ASTEngine.SymbolKind.Constant, node, {
+              nodeType: type,
+              isMakeVariable: true,
+              operator: this.assignmentOperator(node),
+              value: value || void 0
+            });
+            patterns.push("Make variables");
+            addRel(module, ASTEngine.RelationshipType.Contains, name, line, { role: "declaration", evidenceClass: "declared_in_file" });
+            declaredAtLines.set(name, [...declaredAtLines.get(name) ?? [], line]);
+            childOwner = name;
+          }
+          break;
+        }
+        // A macro is a FUNCTION, not a constant: `$(call NAME)` is a call, and a
+        // call that resolves to a Constant is a callee that cannot be called.
+        case "define_directive": {
+          const name = declaredName(node);
+          if (name) {
+            const body = this.firstChildOfType(node, /* @__PURE__ */ new Set(["raw_text"]));
+            if (!valuesByName.has(name)) valuesByName.set(name, body?.text ?? "");
+            declareSymbol(name, ASTEngine.SymbolKind.Function, node, {
+              nodeType: type,
+              isMakeMacro: true,
+              operator: "define",
+              value: body?.text?.trim() || void 0
+            });
+            patterns.push("Make macros");
+            addRel(module, ASTEngine.RelationshipType.Contains, name, line, { role: "declaration", evidenceClass: "declared_in_file" });
+            childOwner = name;
+          }
+          break;
+        }
+        // ---- rules ------------------------------------------------------
+        case "rule": {
+          const targetsNode = this.firstChildOfType(node, /* @__PURE__ */ new Set(["targets"]));
+          const literalTargets = [];
+          if (targetsNode) {
+            for (let i = 0; i < targetsNode.namedChildCount; i++) {
+              const child = targetsNode.namedChild(i);
+              if (!child) continue;
+              const raw = child.text.trim();
+              if (!raw) continue;
+              if (child.type === "word") {
+                if (KEYWORDS.has(raw)) continue;
+                if (raw.startsWith(".")) continue;
+                literalTargets.push(raw);
+                declaredTargets.add(raw);
+                declareSymbol(raw, ASTEngine.SymbolKind.Function, node, {
+                  nodeType: "rule",
+                  isMakeTarget: true,
+                  targetName: raw
+                });
+                addRel(module, ASTEngine.RelationshipType.Contains, raw, line, { role: "declaration", evidenceClass: "declared_in_file" });
+                patterns.push("Make rules");
+              } else {
+                this.collectFrom(
+                  child,
+                  (refName, intent, refLine) => {
+                    const { name: norm } = normaliseExpression(refName);
+                    staged.push({ source: module, target: norm || refName, line: refLine, intent, role: "computed_target", node: child });
+                  },
+                  (binder) => localBinders.add(binder)
+                );
+              }
+            }
+          }
+          for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type !== "prerequisites") continue;
+            for (let j = 0; j < child.namedChildCount; j++) {
+              const prereq = child.namedChild(j);
+              if (!prereq) continue;
+              const raw = prereq.text.trim();
+              if (!raw) continue;
+              const { name } = normaliseExpression(raw);
+              if (!name || KEYWORDS.has(name)) continue;
+              for (const t of literalTargets.length ? literalTargets : [module]) {
+                staged.push({ source: t, target: name, line: prereq.startPosition.row + 1, intent: "ref", role: "prerequisite", node: prereq });
+              }
+            }
+          }
+          if (literalTargets.length > 0) childOwner = literalTargets[0];
+          break;
+        }
+        // ---- includes ---------------------------------------------------
+        case "include_directive": {
+          const isOptional = node.text.trim().startsWith("-") || node.text.trim().startsWith("s");
+          const listNode = this.firstChildOfType(node, /* @__PURE__ */ new Set(["list"]));
+          if (listNode) {
+            for (let i = 0; i < listNode.namedChildCount; i++) {
+              const child = listNode.namedChild(i);
+              if (!child) continue;
+              if (child.type === "word") {
+                const lit = child.text.trim();
+                if (lit && !KEYWORDS.has(lit)) {
+                  const litLine = child.startPosition.row + 1;
+                  imports.push({ module: lit, items: [], importType: "make_include", lineNumber: litLine, line: litLine, range: this.nodeToRange(node), isExternal: false, isOptional });
+                  addRel(module, ASTEngine.RelationshipType.Imports, lit, litLine, { isMakeInclude: true, isOptional });
+                  this.addIncludePartOf(addRel, module, lit, litLine, { isOptional, evidenceClass: "include_literal" });
+                }
+                continue;
+              }
+              if (child.type === "function_call" || child.type === "variable_reference" || child.type === "shell_function") {
+                const expr = child.text.trim();
+                const eLine = child.startPosition.row + 1;
+                if (expr) {
+                  imports.push({ module: expr, items: [], importType: "make_include", lineNumber: eLine, line: eLine, range: this.nodeToRange(node), isExternal: false, isOptional, isComputed: true });
+                  addRel(module, ASTEngine.RelationshipType.Imports, expr, eLine, { isMakeInclude: true, isOptional, isComputed: true, evidenceClass: "include_computed" });
+                }
+                continue;
+              }
+              this.collectFrom(child, (refName, _intent, refLine) => {
+                const mod = refName.trim();
+                if (!mod || KEYWORDS.has(mod)) return;
+                imports.push({
+                  module: mod,
+                  items: [],
+                  importType: "make_include",
+                  lineNumber: refLine,
+                  line: refLine,
+                  range: this.nodeToRange(node),
+                  isExternal: false,
+                  isOptional
+                });
+                addRel(module, ASTEngine.RelationshipType.Imports, mod, refLine, { isMakeInclude: true, isOptional, evidenceClass: "include_literal" });
+              });
+            }
+          } else {
+            this.collectFrom(node, () => {
+            });
+            const expr = listNode ? "" : node.text.trim();
+            if (expr) {
+              const eLine = node.startPosition.row + 1;
+              imports.push({ module: expr, items: [], importType: "make_include", lineNumber: eLine, line: eLine, range: this.nodeToRange(node), isExternal: false, isOptional, isComputed: true });
+              addRel(module, ASTEngine.RelationshipType.Imports, expr, eLine, { isMakeInclude: true, isOptional, isComputed: true });
+            }
+            this.collectFrom(node, (refName, _intent, refLine) => {
+              const mod = refName.trim();
+              if (!mod || KEYWORDS.has(mod)) return;
+              imports.push({ module: mod, items: [], importType: "make_include", lineNumber: refLine, line: refLine, range: this.nodeToRange(node), isExternal: false, isOptional });
+              addRel(module, ASTEngine.RelationshipType.Imports, mod, refLine, { isMakeInclude: true, isOptional });
+            });
+          }
+          patterns.push("Make includes");
+          break;
+        }
+        // ---- export -----------------------------------------------------
+        // `export FOO = 1` wraps an assignment (the generic walk already reaches
+        // it); `export FOO` wraps a `list` and is the ONLY place that name
+        // appears, so without this branch the export is invisible entirely.
+        case "export_directive": {
+          const listNode = this.firstChildOfType(node, /* @__PURE__ */ new Set(["list"]));
+          if (listNode) {
+            for (let i = 0; i < listNode.namedChildCount; i++) {
+              const w = listNode.namedChild(i);
+              if (!w) continue;
+              const name = trimOperator(w.text.trim());
+              if (!name || KEYWORDS.has(name)) continue;
+              if (!declared.has(name)) {
+                declareSymbol(name, ASTEngine.SymbolKind.Constant, w, { nodeType: "export_directive", isMakeVariable: true, declaredBy: "export" });
+                patterns.push("Make variables");
+                addRel(module, ASTEngine.RelationshipType.Contains, name, w.startPosition.row + 1, { role: "declaration", evidenceClass: "declared_in_file" });
+              }
+              markExported(name, w, "export_directive");
+            }
+          } else {
+            const inner = this.firstChildOfType(node, /* @__PURE__ */ new Set(["variable_assignment", "shell_assignment"]));
+            const name = inner ? declaredName(inner) : "";
+            if (name) markExported(name, node, "export_directive");
+          }
+          break;
+        }
+        case "unexport_directive": {
+          const listNode = this.firstChildOfType(node, /* @__PURE__ */ new Set(["list"]));
+          for (let i = 0; listNode && i < listNode.namedChildCount; i++) {
+            const w = listNode.namedChild(i);
+            if (!w) continue;
+            const name = trimOperator(w.text.trim());
+            if (!name) continue;
+            const s = symbols.find((x) => x.name === name);
+            if (s) s.metadata.isExported = false;
+            for (let k = exports.length - 1; k >= 0; k--) {
+              if (exports[k].name === name) exports.splice(k, 1);
+            }
+            for (let k = relationships.length - 1; k >= 0; k--) {
+              const r = relationships[k];
+              if (r.type === ASTEngine.RelationshipType.Exports && r.target === name) {
+                relationships.splice(k, 1);
+                edgeCount[ASTEngine.RelationshipType.Exports] = (edgeCount[ASTEngine.RelationshipType.Exports] ?? 1) - 1;
+                relSeen.delete(`${r.source}\0${r.type}\0${r.target}\0${r.line_number}`);
+              }
+            }
+          }
+          break;
+        }
+        case "vpath_directive": {
+          patterns.push("Make vpath");
+          break;
+        }
+        // MAKE-G1, closed. `VPATH = src:include` is the ASSIGNMENT spelling of the
+        // search path; the sibling `vpath %.c src` DIRECTIVE has been recorded all
+        // along, so the two spellings of one feature were deliberately asymmetric
+        // pending corpus evidence, and the corpus had none (0 occurrences in the
+        // 100 pinned files).
+        //
+        // What was actually lost is not a "coverage" gap in the abstract: because
+        // `VPATH` was never declared, a reference to it fell to `uses` — the class
+        // this lane reserves for names nothing can declare — even though THIS file
+        // is the thing that declares it. `exports := $(VPATH)` in a file that sets
+        // `VPATH = src` was published as a read of something undeclared.
+        //
+        // So it is declared, as a `constant`: `VPATH` is a GNU Make builtin whose
+        // value a makefile may set, exactly like `CURDIR` or `MAKEFILE_LIST`, and
+        // recording it as an ordinary assignment is what makes the reference to it
+        // a `references` edge. The search directories are kept in metadata as a
+        // list, because the value text is colon-separated and a consumer asking
+        // "where does this makefile look for `foo.o`?" wants the list, not the
+        // string it was written as.
+        case "VPATH_assignment": {
+          const pathsNode = this.firstChildOfType(node, /* @__PURE__ */ new Set(["paths"]));
+          const dirs = [];
+          if (pathsNode) {
+            for (let i = 0; i < pathsNode.namedChildCount; i++) {
+              const w = pathsNode.namedChild(i);
+              if (w?.type === "word") {
+                const d = w.text.trim();
+                if (d) dirs.push(d);
+              }
+            }
+          }
+          const value = dirs.join(":");
+          if (!declared.has("VPATH")) {
+            declareSymbol("VPATH", ASTEngine.SymbolKind.Constant, node, {
+              nodeType: "VPATH_assignment",
+              isMakeVariable: true,
+              isMakeSearchPath: true,
+              operator: this.assignmentOperator(node),
+              value: value || void 0,
+              searchPaths: dirs.length ? dirs : void 0
+            });
+            patterns.push("Make vpath");
+            addRel(module, ASTEngine.RelationshipType.Contains, "VPATH", node.startPosition.row + 1, {
+              role: "declaration",
+              evidenceClass: "declared_in_file"
+            });
+          }
+          break;
+        }
+        // ---- control flow ------------------------------------------------
+        case "conditional":
+        case "ifeq_directive":
+        case "ifneq_directive":
+        case "ifdef_directive":
+        case "ifndef_directive":
+        case "else_directive":
+        case "elsif_directive": {
+          conditionals++;
+          break;
+        }
+        case "override_directive":
+        case "private_directive":
+        case "undefine_directive": {
+          let name = "";
+          if (type === "undefine_directive") {
+            const operand = node.childForFieldName("variable");
+            name = operand ? trimOperator(operand.text.trim()) : "";
+          } else {
+            const inner = this.firstChildOfType(node, /* @__PURE__ */ new Set(["variable_assignment", "shell_assignment"]));
+            name = inner ? declaredName(inner) : "";
+          }
+          if (name) {
+            const key = type === "private_directive" ? "isPrivate" : type === "override_directive" ? "isOverride" : "isUndefine";
+            deferred.push({ name, key, line: node.startPosition.row + 1 });
+            if (type === "override_directive") overrideSites.push({ name, line: node.startPosition.row + 1 });
+            const s = symbols.find((x) => x.name === name);
+            if (s) s.metadata[key] = true;
+          }
+          childOwner = name || owner;
+          break;
+        }
+        // ---- references --------------------------------------------------
+        // Handled wherever they appear, not only beneath an assignment or a
+        // rule. A bare top-level `$(foreach t,… $(eval $(call mk,$(t))))` — the
+        // idiom nomad/GNUmakefile uses to reify its package targets — is a
+        // `function_call` directly under `makefile`, and because the old walk
+        // only asked for references from two branches, that line contributed
+        // nothing at all.
+        case "variable_reference":
+        case "substitution_reference":
+        case "automatic_variable":
+        case "function_call": {
+          const parentType = this.parentType(node);
+          if (parentType !== "prerequisites" && parentType !== "targets") {
+            this.collectFrom(
+              node,
+              (refName, intent, refLine) => {
+                staged.push({ source: owner, target: refName, line: refLine, intent, role: type, node });
+              },
+              (binder) => localBinders.add(binder)
+            );
+          }
+          break;
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push({ node: child, owner: childOwner });
+      }
+    }
+    for (const d of deferred) {
+      const s = symbols.find((x) => x.name === d.name);
+      if (s) s.metadata[d.key] = true;
+    }
+    for (const site of overrideSites) {
+      const base = (declaredAtLines.get(site.name) ?? []).filter((l) => l !== site.line);
+      if (base.length === 0) continue;
+      addRel(module, ASTEngine.RelationshipType.Overrides, site.name, site.line, {
+        role: "redefinition",
+        via: "override_directive",
+        overrideLine: site.line,
+        baseLine: Math.min(...base),
+        evidenceClass: "redefinition"
+      });
+    }
+    for (const e of staged) {
+      if (!e.target) continue;
+      const isBuiltinVar = BUILTIN_VARIABLES.has(e.target);
+      let kind;
+      let label;
+      if (e.intent === "call") {
+        kind = ASTEngine.RelationshipType.Calls;
+        label = "call";
+      } else if (declared.has(e.target)) {
+        kind = ASTEngine.RelationshipType.References;
+        label = "reference";
+      } else {
+        kind = ASTEngine.RelationshipType.Uses;
+        label = e.target.startsWith("$$") ? "shell_variable" : e.role === "automatic_variable" ? "automatic" : localBinders.has(e.target) ? "local_binding" : isBuiltinVar ? "builtin" : e.role === "prerequisite" ? "external_prerequisite" : "external";
+      }
+      addRel(e.source, kind, e.target, e.line, {
+        role: e.role,
+        evidenceClass: label,
+        isBuiltin: isBuiltinVar,
+        ...makeExternalClaim(kind, e.target, label)
+      });
+    }
+    for (const t of declaredTargets) {
+      if (symbols.some((s) => s.name === t && s.metadata?.isExported === true)) continue;
+      const sym = symbols.find((s) => s.name === t);
+      exports.push({ name: t, kind: ASTEngine.SymbolKind.Function, range: sym?.range, metadata: { via: "target" } });
+      addRel(module, ASTEngine.RelationshipType.Exports, t, sym?.range?.startLine ?? 1, { via: "target", evidenceClass: "export_target" });
+    }
+    return {
+      language: "make",
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        // A Make-specific, RELATIVE complexity: buildable targets plus decision
+        // points. Absolute timings are meaningless across 99 files of very
+        // different sizes, and this is only ever compared within the analyzer
+        // family, so it is documented as a count and not as a cost.
+        complexity: declaredTargets.size + conditionals,
+        linesOfCode: content.split("\n").length,
+        patterns: [...new Set(patterns)],
+        framework: "Make",
+        variableCount: valuesByName.size,
+        targetCount: declaredTargets.size,
+        conditionalCount: conditionals,
+        moduleName,
+        edgeCount
+      }
+    };
+  }
+  /** The assignment operator between name and value, from node positions. */
+  assignmentOperator(node) {
+    const nameNode = this.firstChildOfType(node, /* @__PURE__ */ new Set(["word"]));
+    const valueNode = this.firstChildOfType(node, /* @__PURE__ */ new Set(["text", "shell_command"]));
+    if (nameNode && valueNode) {
+      const text = node.text ?? "";
+      const gap = text.slice(nameNode.endIndex - node.startIndex, valueNode.startIndex - node.startIndex).trim();
+      if (gap) return gap;
+    }
+    return "=";
+  }
+  /**
+   * Every reference inside `node`, as (name, intent, line).
+   *
+   * Handles the four reference-bearing node types the grammar produces and
+   * nothing else. `substitution_reference` is a sibling of `variable_reference`,
+   * not a child of it, so reading only the latter loses `$(VAR:.c=.o)`.
+   */
+  collectFrom(node, emit, onForeachBinder = () => {
+  }) {
+    const BUILTIN_FUNCTIONS = /* @__PURE__ */ new Set([
+      "subst",
+      "patsubst",
+      "strip",
+      "findstring",
+      "filter",
+      "filter-out",
+      "sort",
+      "word",
+      "wordlist",
+      "words",
+      "firstword",
+      "lastword",
+      "dir",
+      "notdir",
+      "suffix",
+      "basename",
+      "addsuffix",
+      "addprefix",
+      "join",
+      "wildcard",
+      "realpath",
+      "abspath",
+      "if",
+      "or",
+      "and",
+      "foreach",
+      "file",
+      "call",
+      "value",
+      "eval",
+      "origin",
+      "flavor",
+      "shell",
+      "error",
+      "warning",
+      "info"
+    ]);
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      const line = n.startPosition.row + 1;
+      if (n.type === "variable_reference" || n.type === "substitution_reference") {
+        if (n.text.startsWith("$$")) {
+          for (let i = n.namedChildCount - 1; i >= 0; i--) {
+            const c = n.namedChild(i);
+            if (c) stack.push(c);
+          }
+          continue;
+        }
+        const w = this.firstChildOfType(n, /* @__PURE__ */ new Set(["word"]));
+        const name = w?.text?.trim() ?? "";
+        if (name) {
+          if (!this.isAllDigits(name)) emit(name, "ref", line);
+        } else {
+          const cat = this.firstChildOfType(n, /* @__PURE__ */ new Set(["concatenation"]));
+          const catName = cat?.text?.trim() ?? "";
+          if (catName && !this.isAllDigits(catName)) emit(catName, "ref", line);
+        }
+      } else if (n.type === "automatic_variable") {
+        const w = this.firstChildOfType(n, /* @__PURE__ */ new Set(["word"]));
+        emit(w?.text?.trim() || n.text.trim(), "ref", line);
+      } else if (n.type === "function_call") {
+        const argsNode = this.firstChildOfType(n, /* @__PURE__ */ new Set(["arguments"]));
+        const nameEnd = argsNode ? argsNode.startIndex - n.startIndex : Math.max(0, n.text.length - 1);
+        const name = this.firstToken(n.text.slice(2, nameEnd).trim());
+        if (name === "foreach" && argsNode) {
+          const binder = (argsNode.text ?? "").split(",")[0]?.trim() ?? "";
+          if (binder) onForeachBinder(binder);
+        }
+        if (name === "call") {
+          const callee = (argsNode?.text ?? "").split(",")[0]?.trim() ?? "";
+          if (callee && !BUILTIN_FUNCTIONS.has(callee) && !this.isAllDigits(callee)) emit(callee, "call", line);
+        } else if (name && !BUILTIN_FUNCTIONS.has(name)) {
+          emit(name, "ref", line);
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  parentType(node) {
+    const p = node.parent;
+    return p ? String(p.type) : "";
+  }
+  /**
+   * The module symbol's name: the file's own name.
+   *
+   * The path is split by CHARACTER CODE, not by a pattern. This function used
+   * to end in a `String.prototype.split` on a two-character regular expression,
+   * which was the only regex literal in the file, and
+   * `script/m12/make-contract-probe.ts`'s "analyzer source has no regex
+   * literals" check found it — a gate that existed, ran, and had simply never
+   * been executed for this lane. A rule that is never run is not a rule.
+   *
+   * (The comment above used to quote the old expression verbatim, which made the
+   * detector fire on the COMMENT. The detector only exempts `//` line comments,
+   * and that strictness is correct: a regex quoted in a doc comment reads to the
+   * next maintainer as a regex in the file.)
+   */
+  moduleName(filePath) {
+    if (!filePath) return "makefile";
+    let end = filePath.length;
+    while (end > 0) {
+      const c = filePath.charCodeAt(end - 1);
+      if (c === 47 || c === 92) break;
+      end--;
+    }
+    return filePath.slice(end) || "makefile";
+  }
+  /**
+   * The module-symbol name an included path would carry, or "" when the path's
+   * last segment is an expression or syntax rather than a name.
+   *
+   * Every makefile is given ONE module symbol named for its file (the same
+   * spelling `moduleName()` produces), so the symbol-shaped target for an
+   * include is the INCLUDED FILE'S BASENAME — never the written path, which
+   * the resolver has no space for. The path is kept in `metadata.partPath`
+   * where a reader can check it against the source line. A glob (`*.mk`) or a
+   * path whose last segment contains `$`, quotes or shell metacharacters names
+   * no file this parse can know, so it is refused rather than guessed at.
+   */
+  includePartSymbol(pathText) {
+    const slash = pathText.lastIndexOf("/");
+    const base = slash >= 0 ? pathText.slice(slash + 1) : pathText;
+    if (base.length === 0) return "";
+    for (let i = 0; i < base.length; i++) {
+      const c = base.charCodeAt(i);
+      if (c <= 32 || c === 34 || c === 39 || c === 96 || c === 36 || c === 40 || c === 41 || c === 123 || c === 125 || c === 91 || c === 93 || c === 42 || c === 63 || c === 59 || c === 124 || c === 38 || c === 60 || c === 62 || c === 92 || c === 126) {
+        return "";
+      }
+    }
+    return base;
+  }
+  /**
+   * `include` IS the textual-inclusion construct: make splices the included
+   * file's text into THIS make instance's scope — the same single-shared-scope
+   * fact bash's `source` asserts — so a literal include earns a `part_of` edge
+   * from this file's module to the INCLUDED file's module symbol.
+   *
+   * Computed includes (`include $(shell …)`) and glob operands name no file
+   * this parse can know, so they earn no edge here: the `imports` row already
+   * records the expression, and a `part_of` whose target is an expression
+   * string would be an edge to nothing.
+   */
+  addIncludePartOf(addRel, source, pathText, line, extra) {
+    const partSymbol = this.includePartSymbol(pathText);
+    if (!partSymbol) return;
+    addRel(source, ASTEngine.RelationshipType.PartOf, partSymbol, line, {
+      // MANDATORY on every `part_of` row: the direction is the directive's own,
+      // and this file carries it and names the part.
+      partRole: "library",
+      partPath: pathText,
+      partSymbol,
+      isMakeIncludePart: true,
+      ...extra
+    });
+  }
+  isPlainIdentifier(s) {
+    if (s.length === 0) return false;
+    const first = s.charCodeAt(0);
+    const okFirst = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95;
+    if (!okFirst(first)) return false;
+    for (let i = 1; i < s.length; i++) {
+      const c = s.charCodeAt(i);
+      if (!okFirst(c) && !(c >= 48 && c <= 57) && c !== 46 && c !== 45 && c !== 47) return false;
+    }
+    return true;
+  }
+  firstChildOfType(node, types) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && types.has(child.type)) return child;
+    }
+    return null;
+  }
+  isAllDigits(name) {
+    if (name.length === 0) return false;
+    for (let i = 0; i < name.length; i++) {
+      const c = name.charCodeAt(i);
+      if (c < 48 || c > 57) return false;
+    }
+    return true;
+  }
+  firstToken(raw) {
+    for (let i = 0; i < raw.length; i++) {
+      const c = raw[i];
+      if (c === " " || c === "	" || c === "," || c === "(") return raw.slice(0, i);
+    }
+    return raw;
+  }
+  nodeToRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+};
+export {
+  RealMakefileAnalyzer
+};