@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-zig-analyzer-HIQLZMGY.js

@@ -0,0 +1,2430 @@
+import {
+  FILE_CLAIM_MAX_BYTES,
+  fileClaimForTarget
+} from "./chunk-EWMWK7WN.js";
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-zig-analyzer.ts
+var ZIG_ADMITTED_EXTENSIONS = ["zig"];
+var ZIG_TYPE_RHS = /* @__PURE__ */ new Set([
+  "builtin_type",
+  "pointer_type",
+  "slice_type",
+  "array_type",
+  "nullable_type",
+  "error_union_type",
+  "anyframe_type",
+  "opaque_declaration",
+  "function_signature"
+]);
+var ANONYMOUS_CONTAINER_NODES = /* @__PURE__ */ new Set([
+  "struct_declaration",
+  "union_declaration",
+  "enum_declaration",
+  "error_set_declaration",
+  "opaque_declaration"
+]);
+var ENUM_MEMBER_NAME_NODE_TYPES = /* @__PURE__ */ new Set([
+  "builtin_type",
+  "boolean",
+  "null",
+  "undefined"
+]);
+var ZIG_VALUE_RHS = /* @__PURE__ */ new Set([
+  "integer",
+  "float",
+  "string",
+  "multiline_string",
+  "boolean",
+  "character",
+  "binary_expression",
+  "unary_expression",
+  "null_coercion_expression",
+  "index_expression",
+  "catch_expression",
+  "block",
+  "initializer_list",
+  "range_expression",
+  "assignment_expression",
+  "error_type",
+  "anonymous_struct_initializer",
+  "dereference_expression"
+]);
+var ZIG_FILE_SCOPE_NAMES = /* @__PURE__ */ new WeakMap();
+function zigFileScopeNames(root) {
+  const cached = ZIG_FILE_SCOPE_NAMES.get(root);
+  if (cached) return cached;
+  const BARRIERS = /* @__PURE__ */ new Set([
+    "function_declaration",
+    "test_declaration",
+    "block",
+    "if_statement",
+    "if_expression",
+    "for_statement",
+    "for_expression",
+    "while_statement",
+    "while_expression",
+    "switch_statement",
+    "switch_expression",
+    "catch_expression",
+    "defer_statement",
+    "expression_statement",
+    "comptime_statement",
+    "errdefer_statement"
+  ]);
+  const out = /* @__PURE__ */ new Set();
+  const stack = [root];
+  let guard = 0;
+  while (stack.length > 0 && guard++ < 4e5) {
+    const n = stack.pop();
+    if (n.type === "variable_declaration" || n.type === "function_declaration" || n.type === "container_field") {
+      const c0 = n.namedChildCount > 0 ? n.namedChild(0) : null;
+      if (c0 && c0.type === "identifier") {
+        let q = n.parent;
+        let fileScope = true;
+        let hops = 0;
+        while (q && hops++ < 40) {
+          if (BARRIERS.has(q.type)) {
+            fileScope = false;
+            break;
+          }
+          q = q.parent;
+        }
+        if (fileScope) out.add(stripZigQuoting(c0.text));
+      }
+    }
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const c = n.namedChild(i);
+      if (c) stack.push(c);
+    }
+  }
+  ZIG_FILE_SCOPE_NAMES.set(root, out);
+  return out;
+}
+var ZIG_IMPORT_ALIASES = /* @__PURE__ */ new WeakMap();
+function zigImportAliases(root) {
+  const cached = ZIG_IMPORT_ALIASES.get(root);
+  if (cached) return cached;
+  const imports = /* @__PURE__ */ new Map();
+  const shadowed = /* @__PURE__ */ new Set();
+  const stack = [root];
+  let guard = 0;
+  while (stack.length > 0 && guard++ < 4e5) {
+    const n = stack.pop();
+    if (n.type === "variable_declaration") {
+      const kids = zigNamedChildren(n);
+      const nameNode = kids.length > 0 && kids[0].type === "identifier" ? kids[0] : null;
+      const rhs = kids.length > 0 ? kids[kids.length - 1] : null;
+      const bound = nameNode ? stripZigQuoting(nameNode.text) : "";
+      if (bound) {
+        const lit = zigImportModuleLiteral(rhs);
+        if (lit) imports.set(bound, { module: lit.module, external: zigModuleIsExternal(lit.module) });
+        else shadowed.add(bound);
+      }
+    }
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const c = n.namedChild(i);
+      if (c) stack.push(c);
+    }
+  }
+  for (const s of shadowed) imports.delete(s);
+  ZIG_IMPORT_ALIASES.set(root, imports);
+  return imports;
+}
+function zigModuleIsExternal(modulePath) {
+  if (modulePath.startsWith(".") || modulePath.startsWith("/")) return false;
+  if (modulePath.includes("/") || modulePath.includes("\\")) return false;
+  if (modulePath.endsWith(".zig") || modulePath.endsWith(".zon")) return false;
+  return true;
+}
+function zigImportModuleLiteral(rhs) {
+  if (!rhs) return null;
+  const host = rhs.type === "call_expression" || rhs.type === "builtin_function" ? rhs : null;
+  if (!host) return null;
+  let isImport = false;
+  for (let i = 0; i < host.namedChildCount; i++) {
+    const c = host.namedChild(i);
+    if (c && (c.type === "builtin_identifier" || c.type === "identifier")) {
+      const t = String(c.text ?? "");
+      if (t === "@import" || t === "@cImport" || t === "import") {
+        isImport = true;
+        break;
+      }
+    }
+  }
+  if (!isImport) return null;
+  const firstString = (h) => {
+    if (!h) return null;
+    for (let i = 0; i < h.namedChildCount; i++) {
+      const c = h.namedChild(i);
+      if (c && (c.type === "string" || c.type === "string_content")) return c;
+    }
+    return null;
+  };
+  let args = null;
+  for (let i = 0; i < host.namedChildCount; i++) {
+    const c = host.namedChild(i);
+    if (c && c.type === "arguments") {
+      args = c;
+      break;
+    }
+  }
+  let strNode = firstString(host) ?? firstString(args);
+  if (strNode && strNode.type === "string") {
+    for (let i = 0; i < strNode.namedChildCount; i++) {
+      const sc = strNode.namedChild(i);
+      if (sc && sc.type === "string_content") {
+        strNode = sc;
+        break;
+      }
+    }
+  }
+  if (!strNode) return null;
+  let out = String(strNode.text ?? "");
+  if (out.startsWith('"') && out.endsWith('"') || out.startsWith("'") && out.endsWith("'")) out = out.substring(1, out.length - 1);
+  return out.length > 0 ? { module: out, node: strNode } : null;
+}
+function zigNamedChildren(n) {
+  const out = [];
+  for (let i = 0; i < n.namedChildCount; i++) {
+    const c = n.namedChild(i);
+    if (c) out.push(c);
+  }
+  return out;
+}
+function zigModuleSymbol(specifier) {
+  const slash = specifier.lastIndexOf("/");
+  const base = slash >= 0 ? specifier.slice(slash + 1) : specifier;
+  const dot = base.lastIndexOf(".");
+  const stem = dot > 0 ? base.slice(0, dot) : base;
+  return stem.trim();
+}
+function zigImportModuleInSubtree(node) {
+  let found = null;
+  const walk = (n) => {
+    if (found !== null) return;
+    if (n.type === "builtin_function") {
+      const lit = zigImportModuleLiteral(n);
+      if (lit) {
+        found = lit.module;
+        return;
+      }
+    }
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const c = n.namedChild(i);
+      if (c) walk(c);
+    }
+  };
+  walk(node);
+  return found;
+}
+function zigMergedMemberLeaf(expr) {
+  if (expr.type === "identifier") return stripZigQuoting(String(expr.text ?? ""));
+  if (expr.type === "field_expression") {
+    const last = expr.namedChildCount > 0 ? expr.namedChild(expr.namedChildCount - 1) : null;
+    return last ? zigMergedMemberLeaf(last) : null;
+  }
+  if (expr.type === "parenthesized_expression") {
+    for (let i = expr.namedChildCount - 1; i >= 0; i--) {
+      const c = expr.namedChild(i);
+      const leaf = c ? zigMergedMemberLeaf(c) : null;
+      if (leaf) return leaf;
+    }
+  }
+  return null;
+}
+function zigUsingNamespaceMergedUnit(node) {
+  let arg = null;
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (c && c.type !== "comment") {
+      arg = c;
+      break;
+    }
+  }
+  if (!arg) return null;
+  if (arg.type === "builtin_function") {
+    let builtin = "";
+    for (let i = 0; i < arg.namedChildCount; i++) {
+      const c = arg.namedChild(i);
+      if (c && c.type === "builtin_identifier") {
+        builtin = String(c.text ?? "");
+        break;
+      }
+    }
+    if (builtin !== "@import") return null;
+    const lit = zigImportModuleLiteral(arg);
+    if (!lit) return null;
+    const target2 = zigModuleSymbol(lit.module);
+    return target2 ? { target: target2, form: "import", module: lit.module } : null;
+  }
+  if (arg.type === "identifier") {
+    const target2 = stripZigQuoting(String(arg.text ?? ""));
+    return target2 ? { target: target2, form: "identifier" } : null;
+  }
+  const target = zigMergedMemberLeaf(arg);
+  if (!target) return null;
+  const module = zigImportModuleInSubtree(arg);
+  return { target, form: module ? "import_member" : "identifier", ...module ? { module } : {} };
+}
+var ZIG_DECLARED_TYPE_BUILTINS = /* @__PURE__ */ new Set([
+  "void",
+  "bool",
+  "f16",
+  "f32",
+  "f64",
+  "f80",
+  "f128",
+  "c_longdouble",
+  "i8",
+  "i16",
+  "i32",
+  "i64",
+  "i128",
+  "isize",
+  "u8",
+  "u16",
+  "u32",
+  "u64",
+  "u128",
+  "usize",
+  "anytype",
+  "comptime_int",
+  "comptime_float",
+  "noreturn",
+  "type",
+  "anyerror",
+  "c_char",
+  "c_short",
+  "c_int",
+  "c_long",
+  "c_longlong",
+  "c_uint",
+  "c_ulong",
+  "c_ulonglong",
+  "c_void",
+  "error",
+  "test"
+]);
+function stripZigQuoting(text) {
+  if (!text.includes('@"')) return text;
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text.charCodeAt(i) === 64 && text[i + 1] === '"') {
+      const close = text.indexOf('"', i + 2);
+      if (close === -1) {
+        out += text.slice(i);
+        break;
+      }
+      out += text.slice(i + 2, close);
+      i = close + 1;
+    } else {
+      out += text[i];
+      i++;
+    }
+  }
+  return out;
+}
+function ownerPathOf(container) {
+  if (!container) return void 0;
+  return container.zigOwnerPath ?? container.name;
+}
+function publishedSpelling(s) {
+  const name = String(s.name ?? "");
+  const owner = s.ownerName;
+  return owner ? `${owner}.${name}` : name;
+}
+var RealZigAnalyzer = class {
+  analyze(rootNode, content, filePath, context) {
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    const projectRoot = typeof context?.projectRoot === "string" ? context.projectRoot : void 0;
+    const walkStack = [
+      { node: rootNode, container: null, inFunction: false, anonContainer: false }
+    ];
+    const fileContainerName = this.zigThisBindingName(rootNode);
+    while (walkStack.length > 0) {
+      const item = walkStack.pop();
+      const { node, container, inFunction, anonContainer } = item;
+      const type = node.type;
+      const nodeText = this.nodeText(node);
+      if (type === "variable_declaration") {
+        if (inFunction || anonContainer) {
+          const lchildren = this.getAllNamedChildren(node);
+          const lrhs = lchildren[lchildren.length - 1];
+          const lrhsType = lrhs?.type || "";
+          const lbuiltin = lrhsType === "call_expression" || lrhsType === "builtin_function" ? this.anyChild(lrhs, (n) => n.type === "builtin_identifier") : null;
+          if (lbuiltin && (lbuiltin.text === "@import" || lbuiltin.text === "@cImport")) {
+            const largs = this.anyChild(lrhs, (n) => n.type === "arguments");
+            const lstr = largs ? this.anyChild(largs, (n) => n.type === "string" || n.type === "string_content") : null;
+            if (lstr) {
+              let ltarget = lstr.text;
+              if (ltarget.startsWith('"') && ltarget.endsWith('"') || ltarget.startsWith("'") && ltarget.endsWith("'")) {
+                ltarget = ltarget.substring(1, ltarget.length - 1);
+              }
+              imports.push({
+                module: ltarget,
+                isDefaultImport: false,
+                range: this.nodeRange(node),
+                metadata: { zigImport: true, builtin: lbuiltin.text }
+              });
+              relationships.push({
+                source: "(global)",
+                target: ltarget,
+                type: ASTEngine.RelationshipType.References,
+                confidence: 1,
+                // M59.A7 (#825): an import dependency occurs where its TARGET is
+                // written — the path literal, not the declaration statement.
+                ...this.nodeLine(lstr) ? { line_number: this.nodeLine(lstr) } : {},
+                metadata: { relationshipType: "zig_import", isImport: true }
+              });
+            }
+          }
+          const localKids = this.getAllNamedChildren(node);
+          const localRhs = localKids[localKids.length - 1];
+          this.pushChildren(
+            node,
+            walkStack,
+            container,
+            inFunction,
+            anonContainer || !!localRhs && ANONYMOUS_CONTAINER_NODES.has(localRhs.type)
+          );
+          continue;
+        }
+        const identNode = this.anyChild(node, (n) => n.type === "identifier");
+        const varName = identNode ? identNode.text : "";
+        if (!varName || varName.length > 80) {
+          this.pushChildren(node, walkStack, container, inFunction, anonContainer);
+          continue;
+        }
+        if (varName === "_") {
+          this.pushChildren(node, walkStack, container, inFunction, anonContainer);
+          continue;
+        }
+        const isExported = this.hasToken(node, "pub") || this.hasToken(node, "export");
+        const children = this.getAllNamedChildren(node);
+        const rhs = children[children.length - 1];
+        const rhsType = rhs?.type || "";
+        const rhsText = rhs ? this.nodeText(rhs) : "";
+        const builtin = rhsType === "call_expression" || rhsType === "builtin_function" ? this.anyChild(rhs, (n) => n.type === "builtin_identifier") : null;
+        if (builtin && (builtin.text === "@import" || builtin.text === "@cImport")) {
+          const argsNode = this.anyChild(rhs, (n) => n.type === "arguments");
+          const strNode = argsNode ? this.anyChild(argsNode, (n) => n.type === "string" || n.type === "string_content") : null;
+          if (strNode) {
+            let importTarget = strNode.text;
+            if (importTarget.startsWith('"') && importTarget.endsWith('"') || importTarget.startsWith("'") && importTarget.endsWith("'")) {
+              importTarget = importTarget.substring(1, importTarget.length - 1);
+            }
+            if (!importTarget) {
+              this.pushChildren(node, walkStack, container, inFunction, anonContainer);
+              continue;
+            }
+            imports.push({
+              module: importTarget,
+              isDefaultImport: false,
+              range: this.nodeRange(node),
+              metadata: { zigImport: true, builtin: builtin.text }
+            });
+            relationships.push({
+              source: "(global)",
+              target: importTarget,
+              type: ASTEngine.RelationshipType.References,
+              confidence: 1,
+              // M59.A7 (#825): the line of the module path as written.
+              ...this.nodeLine(strNode) ? { line_number: this.nodeLine(strNode) } : {},
+              metadata: { relationshipType: "zig_import", isImport: true }
+            });
+          }
+          if (inFunction) {
+            this.pushChildren(node, walkStack, container, inFunction, anonContainer);
+            continue;
+          }
+        }
+        const isVar = this.hasToken(node, "var");
+        let kind = isVar ? ASTEngine.SymbolKind.Variable : ASTEngine.SymbolKind.Constant;
+        const isContainer = rhsType === "struct_declaration" || rhsType === "enum_declaration" || rhsType === "union_declaration" || rhsType === "error_set_declaration" || rhsType === "opaque_declaration";
+        if (rhsType === "struct_declaration") kind = ASTEngine.SymbolKind.Struct;
+        else if (rhsType === "enum_declaration") kind = ASTEngine.SymbolKind.Enum;
+        else if (rhsType === "union_declaration") kind = ASTEngine.SymbolKind.Union;
+        else if (rhsType === "error_set_declaration") kind = ASTEngine.SymbolKind.Enum;
+        else if (rhsType === "opaque_declaration") kind = ASTEngine.SymbolKind.Type;
+        else if (ZIG_TYPE_RHS.has(rhsType)) {
+          kind = ASTEngine.SymbolKind.Type;
+        } else if (ZIG_VALUE_RHS.has(rhsType) || rhsType === "labeled_type_expression" && this.isLabeledBlockValue(rhs)) {
+          if (!isVar) kind = ASTEngine.SymbolKind.Constant;
+        } else if (rhsType === "struct_initializer" && !this.isTypeValuedInitializer(rhs)) {
+          if (!isVar) kind = ASTEngine.SymbolKind.Constant;
+        } else if (varName[0] === varName[0].toUpperCase() && varName[0] !== varName[0].toLowerCase()) {
+          kind = ASTEngine.SymbolKind.Type;
+        }
+        const sym = {
+          name: varName,
+          kind,
+          visibility: isExported ? "public" : "private",
+          range: this.nodeRange(node),
+          scope: ownerPathOf(container),
+          ownerName: ownerPathOf(container),
+          ownerKind: container?.kind,
+          metadata: {
+            zigDeclaration: kind,
+            ...rhsType === "error_set_declaration" ? { zigErrorSet: true } : {},
+            // Z35: a NAMESPACE IMPORT BINDING is a distinct fact from any other
+            // const, and a consumer asking "which names in this file are modules"
+            // cannot ask without it. It is also what makes the regression
+            // reconstructible by a MARKER rather than by a list of names.
+            ...this.isZigImportBinding(rhs) ? { zigImportBinding: true } : {}
+          }
+        };
+        symbols.push(sym);
+        if (isExported && !container) exports.push({ name: varName, kind, range: this.nodeRange(node) });
+        if (isContainer) {
+          const own = stripZigQuoting(varName);
+          const parentPath = ownerPathOf(container);
+          sym.zigOwnerPath = parentPath ? `${parentPath}.${own}` : own;
+        }
+        const newContainer = isContainer ? sym : container;
+        this.pushChildren(node, walkStack, newContainer, inFunction, anonContainer);
+        continue;
+      }
+      if (type === "test_declaration" || type === "comptime_declaration") {
+        this.pushChildren(node, walkStack, container, true, anonContainer);
+        continue;
+      }
+      if (type === "using_namespace_declaration") {
+        {
+          const merged = zigUsingNamespaceMergedUnit(node);
+          const mixinSource = !inFunction && !anonContainer ? container ? container.name : "(global)" : null;
+          if (merged && mixinSource) {
+            relationships.push({
+              source: mixinSource,
+              target: merged.target,
+              type: ASTEngine.RelationshipType.MixesIn,
+              confidence: 1,
+              ...this.nodeLine(node) ? { line_number: this.nodeLine(node) } : {},
+              metadata: {
+                relationshipType: "zig_usingnamespace",
+                isMixin: true,
+                mixinForm: merged.form,
+                ...merged.module ? { module: merged.module } : {},
+                ...mixinSource === "(global)" ? { fileLevel: true } : {}
+              }
+            });
+          }
+        }
+        const bf = this.anyChild(node, (n) => n.type === "builtin_function");
+        const bi = bf ? this.anyChild(bf, (n) => n.type === "builtin_identifier") : null;
+        if (bf && bi && (bi.text === "@import" || bi.text === "@cImport")) {
+          const argsNode = this.anyChild(bf, (n) => n.type === "arguments");
+          const strNode = argsNode ? this.anyChild(argsNode, (n) => n.type === "string" || n.type === "string_content") : null;
+          if (strNode) {
+            let importTarget = strNode.text;
+            if (importTarget.startsWith('"') && importTarget.endsWith('"') || importTarget.startsWith("'") && importTarget.endsWith("'")) {
+              importTarget = importTarget.substring(1, importTarget.length - 1);
+            }
+            if (!importTarget) {
+              relationships.push({
+                source: "(global)",
+                target: "@import",
+                type: ASTEngine.RelationshipType.References,
+                confidence: 1,
+                metadata: { relationshipType: "zig_import", isImport: true, emptyImportPath: true }
+              });
+              continue;
+            }
+            imports.push({
+              module: importTarget,
+              isDefaultImport: false,
+              range: this.nodeRange(node),
+              metadata: { zigImport: true, builtin: bi.text, usingnamespace: true }
+            });
+            relationships.push({
+              source: "(global)",
+              target: importTarget,
+              type: ASTEngine.RelationshipType.References,
+              confidence: 1,
+              // M59.A7 (#825): the module path as written.
+              ...this.nodeLine(strNode) ? { line_number: this.nodeLine(strNode) } : {},
+              metadata: { relationshipType: "zig_import", isImport: true }
+            });
+          }
+        }
+        this.pushChildren(node, walkStack, container, inFunction, anonContainer);
+        continue;
+      }
+      if (type === "function_signature") {
+        this.pushChildren(node, walkStack, container, inFunction, anonContainer);
+        continue;
+      }
+      if (type === "function_declaration") {
+        const firstNamed = node.namedChildCount > 0 ? node.namedChild(0) : null;
+        const identNode = firstNamed && firstNamed.type === "identifier" ? firstNamed : this.anyChild(node, (n) => n.type === "identifier");
+        const fnName = identNode ? identNode.text : "";
+        const isExported = this.hasToken(node, "pub") || this.hasToken(node, "export");
+        const isInline = this.hasToken(node, "inline");
+        const isAnonymousContainerMember = anonContainer || !container && inFunction;
+        if (fnName && fnName.length < 100 && !isAnonymousContainerMember) {
+          const params = [];
+          const paramsNode = this.anyChild(node, (n) => n.type === "parameters");
+          if (paramsNode) {
+            for (let i = 0; i < paramsNode.namedChildCount; i++) {
+              const child = paramsNode.namedChild(i);
+              if (!child || child.type !== "parameter") continue;
+              const pNameNode = this.namedFieldOf(child, "name") ?? this.anyChild(child, (n) => n.type === "identifier");
+              const pTypeNode = this.typeFieldOf(child);
+              if (pNameNode) {
+                params.push({
+                  name: pNameNode.text,
+                  type: pTypeNode ? this.nodeText(pTypeNode) : void 0
+                });
+              }
+            }
+          }
+          const isMethod = container !== null;
+          const sym = {
+            name: fnName,
+            kind: isMethod ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Function,
+            visibility: isExported ? "public" : "private",
+            range: this.nodeRange(node),
+            scope: ownerPathOf(container),
+            parameters: params,
+            ownerName: ownerPathOf(container),
+            ownerKind: container?.kind,
+            // Per-symbol cyclomatic complexity (family standard — go/c/rust
+            // emit symbol.complexity; zig did NOT, so completeness section C
+            // was impossible). Added zig wave 2026-08-29.
+            complexity: this.zigBodyComplexity(node),
+            metadata: {
+              zigFunction: true,
+              inline: isInline,
+              paramCount: params.length,
+              // #612 store-phase: DECLARATION vs DEFINITION. Measured against
+              // this grammar (tree dump, 2026-09-25): `extern fn run_engine()
+              // c_int;` and `pub fn call_it() c_int { … }` BOTH parse as
+              // `function_declaration`, and the grammar hands the difference
+              // over as a FIELD — 35,692 of the corpus's 37,129 functions carry
+              // a `body` child under the `body` field name, the rest declare
+              // nothing. So the discriminator is read off the field, with the
+              // node-type test kept as the fallback for a grammar variant that
+              // does not name it. Without the flag an `extern` declaration
+              // competed on equal footing with the definition implementing it in
+              // another file.
+              ...this.functionBody(node) === null ? { isDeclaration: true } : {}
+            }
+          };
+          symbols.push(sym);
+          if (isExported && !isMethod) exports.push({ name: fnName, kind: ASTEngine.SymbolKind.Function, range: this.nodeRange(node) });
+        }
+        this.pushChildren(node, walkStack, container, true, anonContainer);
+        continue;
+      }
+      if (ANONYMOUS_CONTAINER_NODES.has(type)) {
+        const parent = node.parent;
+        const isDeclRhs = !!parent && parent.type === "variable_declaration" && parent.namedChildCount > 0 && parent.namedChild(parent.namedChildCount - 1)?.id === node.id;
+        if (!isDeclRhs) {
+          this.pushChildren(node, walkStack, container, inFunction, true);
+          continue;
+        }
+      }
+      if (type === "container_field") {
+        if (!container && !anonContainer && node.parent?.type === "source_file") {
+          this.zigFileLevelField(node, fileContainerName, symbols);
+          this.pushChildren(node, walkStack, container, inFunction, anonContainer);
+          continue;
+        }
+        if (!container || anonContainer) {
+          this.pushChildren(node, walkStack, container, inFunction, anonContainer);
+          continue;
+        }
+        const nameField = node.childForFieldName?.("name");
+        const isEnumMember = container?.kind === ASTEngine.SymbolKind.Enum;
+        const enumPrimitiveName = isEnumMember && nameField && ENUM_MEMBER_NAME_NODE_TYPES.has(nameField.type) ? nameField : null;
+        const nameNode = nameField && nameField.type === "identifier" ? nameField : enumPrimitiveName ?? this.anyChild(node, (n) => n.type === "identifier");
+        const fieldName = nameNode ? nameNode.text : "";
+        if (fieldName && fieldName !== "_" && fieldName.length < 200) {
+          const typeField = this.typeFieldOf(node);
+          symbols.push({
+            name: fieldName,
+            kind: isEnumMember ? ASTEngine.SymbolKind.EnumMember : ASTEngine.SymbolKind.Property,
+            visibility: "public",
+            range: this.nodeRange(node),
+            scope: ownerPathOf(container),
+            ownerName: ownerPathOf(container),
+            ownerKind: container?.kind,
+            returnType: typeField ? this.nodeText(typeField) : void 0,
+            metadata: { zigField: true, ...isEnumMember ? { zigEnumMember: true } : {} }
+          });
+        }
+        this.pushChildren(node, walkStack, container, inFunction, anonContainer);
+        continue;
+      }
+      if (type === "identifier" && container && container.metadata?.zigErrorSet && node.parent?.type === "error_set_declaration") {
+        const identText = node.text;
+        if (identText && identText.length < 50) {
+          symbols.push({
+            name: identText,
+            kind: ASTEngine.SymbolKind.EnumMember,
+            visibility: "public",
+            range: this.nodeRange(node),
+            scope: ownerPathOf(container),
+            ownerName: ownerPathOf(container),
+            ownerKind: container.kind,
+            metadata: { zigErrorSetMember: true }
+          });
+        }
+        continue;
+      }
+      if (node.type === "ERROR" || node.isMissing) {
+        const snippet = nodeText.substring(0, 50);
+        errors.push({
+          message: `Zig syntax error: ${snippet}`,
+          range: {
+            // Z2 (zig review): 1-based columns like every other range in
+            // this file (nodeRange +1s) — the raw 0-based columns leaked
+            // through here (svelte-wave class).
+            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
+          },
+          severity: "error"
+        });
+      }
+      this.pushChildren(node, walkStack, container, inFunction || type === "block", anonContainer);
+    }
+    for (const s of symbols) {
+      if (s.ownerName) {
+        relationships.push({
+          source: s.ownerName,
+          // M60 cause A — the target is the member's own PUBLISHED SPELLING, which
+          // is what Z-p22 above already established for the SOURCE and this edge
+          // never followed on the target half.
+          //
+          // The projection spells a symbol `scope ? scope + "." + name : name`
+          // (pool-worker.ts:997) and `scope` is this symbol's `ownerName`
+          // (see `mkSymbol`'s `scope: ownerName ?? undefined`). So the string this
+          // edge targets IS the member's published `qualified_name`, and the store
+          // resolves it on its FIRST strategy: `target_external = qualified_name`
+          // is an exact JOIN (parallel-indexer.ts:4483-4495, `_res_qname` PRIMARY
+          // KEY), which binds one declaration by construction.
+          //
+          // A BARE member name reaches only strategy 2, which fires
+          // `_res_name.cnt = 1` — the name must be unique across the WHOLE project
+          // (parallel-indexer.ts:4506). No container member name ever is: the
+          // fleet's own corpus declares `init`, `deinit`, `assert` and `release`
+          // in dozens of files each. So the bare target was not merely imprecise,
+          // it was the one spelling guaranteed to fail the only strategy that
+          // could have carried it.
+          //
+          // MEASURED, 600-file stride sample, production `parseFile`, incoming-gate
+          // (which counts ambiguity by DECLARATION and indexes name + qualifiedName
+          // aliases): `contains` 13,690 edges — 8,993 resolved, 4,697 AMBIGUOUS,
+          // 0 unresolved. That 4,697 was the largest single ambiguous bucket in the
+          // lane, 24.6% of the 19,084 total. Priced over the FULL population first
+          // (3,834 files, 80,876 contains edges, `contains-qualify-control.ts`):
+          // FIX 31,800 / RISK 5 / LOST 797 / NEUTRAL 48,274 — i.e. +31,800 edges
+          // that resolve to exactly one declaration against 5 that stop doing so.
+          //
+          // The name SURFACE is untouched: `symbols.push({ name: s.name })` still
+          // publishes the bare member, so hover, navigation and every expectation
+          // file that reads `name` are unaffected. Only the edge endpoint changes.
+          // `source` still carries the owner, so containment survives independently
+          // of the target — the two halves are redundant by design, and this makes
+          // them agree.
+          target: publishedSpelling(s),
+          type: ASTEngine.RelationshipType.Contains,
+          confidence: 1,
+          // M59.A7 (#825): a containment edge has no call site, but it has a
+          // navigable one — the member's own declaration line. Omitted, never
+          // written as 0, when the symbol carries no range (#820).
+          ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+          // Z44: a reason code, so every class in this analyzer answers the same
+          // question — "why does this edge exist?" — the same way. `contains` is
+          // built from the SYMBOL TABLE at the end of the walk rather than at the
+          // member's site, which is why it carried an EMPTY metadata object and
+          // was invisible to any consumer that reads the reason. It is the
+          // largest class in the corpus (261 of the 300-file draw) and it was the
+          // one that said nothing. `zigField`/`zigEnumMember` are already on the
+          // SYMBOL; here the reason is that the edge is ownership.
+          metadata: { relationshipType: "zig_ownership" }
+        });
+      }
+    }
+    this.analyzeZigCodeRelationships(rootNode, relationships, symbols);
+    this.collectZigImportSites(rootNode, imports, relationships, projectRoot, filePath);
+    this.analyzeZigInstantiation(rootNode, relationships);
+    this.emitZigExportEdges(relationships, exports);
+    this.analyzeZigBareIdentifierUses(rootNode, relationships, symbols);
+    {
+      const bestUses = /* @__PURE__ */ new Map();
+      const order = [];
+      for (const r of relationships) {
+        if (r.type !== ASTEngine.RelationshipType.Uses) {
+          order.push(r);
+          continue;
+        }
+        const key = `${r.source}|${r.target}`;
+        const prior = bestUses.get(key);
+        if (!prior) {
+          bestUses.set(key, r);
+          order.push(r);
+        } else if ((r.confidence ?? 0) > (prior.confidence ?? 0)) {
+          order[order.indexOf(prior)] = r;
+          bestUses.set(key, r);
+        }
+      }
+      relationships.length = 0;
+      relationships.push(...order);
+    }
+    this.extractZigDeclaredTypeRefs(rootNode, relationships);
+    this.classifyEvidenceTier(relationships);
+    this.annotateTargetScope(symbols, relationships);
+    this.canonicalizePublishedNames(symbols, relationships, exports);
+    const fileComplexity = this.zigBodyComplexity(rootNode);
+    const zigDeclaredHere = /* @__PURE__ */ new Set();
+    for (const sym of symbols) {
+      if (sym.name) zigDeclaredHere.add(sym.name);
+      const q = sym.qualifiedName;
+      if (typeof q === "string" && q.length > 0) zigDeclaredHere.add(q);
+    }
+    let zigNamespaceClaims = 0;
+    for (const rel of relationships) {
+      if (rel.type !== ASTEngine.RelationshipType.Uses) continue;
+      const tgt = String(rel.target ?? "");
+      if (!tgt.startsWith("std.")) continue;
+      if (zigDeclaredHere.has(tgt)) continue;
+      const md = rel.metadata;
+      if (!md || typeof md !== "object") continue;
+      if (md.zigExternalRef === true || md.isExternal === true) continue;
+      md.languageNamespace = ["std"];
+      zigNamespaceClaims++;
+    }
+    return {
+      language: "zig",
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        namespaceClaims: zigNamespaceClaims,
+        complexity: fileComplexity,
+        cyclomaticComplexity: fileComplexity,
+        linesOfCode: content.split("\n").length,
+        patterns: [],
+        framework: "Zig",
+        hasFrameworkIntelligence: true,
+        hasTypeInference: true
+      }
+    };
+  }
+  /**
+   * Calls + Uses (family contract, zig wave 2026-08-29).
+   * Walks the tree tracking the enclosing function/method name; a
+   * call_expression whose callee is an identifier or a field_expression emits
+   * a `calls` edge to the callee LEAF (Rust/Go contract — shared callee
+   * `self.repository.add` -> `add`); a field_expression that is NOT a call
+   * callee emits a `uses` edge to its field leaf. Builtin calls (@import,
+   * @intCast, ...) are compile-time intrinsics, NOT user symbols — skipped.
+   */
+  /**
+   * Z59 — does this analyzer publish a SYMBOL for `fnNode`, so that naming it as
+   * an edge SOURCE resolves?
+   *
+   * ## The defect this answers
+   *
+   * A `function_declaration` can be a MEMBER of a container the analyzer
+   * deliberately publishes nothing for: a container written inside a function or
+   * test body, a container with no name (`fn GenericStack(…) type { return
+   * struct { fn push(…) } }`), or a container nested in an anonymous one. That is
+   * the Z22 / C-negative contract and it is correct — such a type has no
+   * file-scope identity.
+   *
+   * The three edge passes each took the nearest `function_declaration` /
+   * `test_declaration` identifier as the source name WITHOUT asking whether a
+   * symbol was published for it. So 5.05% of `calls` + `uses` + `instantiates`
+   * edges over the full corpus (11,332 of 224,599) carried a source naming a
+   * declaration the index does not hold: a caller that resolves to nothing.
+   * Measured by `validation/m14/fixtures/zig/dangling-source-census.ts`, whose
+   * residual class is 0, so this is the whole population and not a sample of it.
+   *
+   * ## The rule
+   *
+   * A function is published when it has NO container ancestor (a top-level `fn`),
+   * or when its nearest container ancestor is bound to an identifier at FILE
+   * SCOPE. Named is not sufficient: `const S = struct { … }` inside a test body is
+   * a named LOCAL container and is not published either.
+   *
+   * `test_declaration` is answered separately by the callers: a named test is a
+   * scope with a name (Z39) and NO symbol is published for one, so that class is
+   * still dangling and is declared as a limitation rather than silently reverted.
+   */
+  zigFunctionScopeIsPublished(fnNode) {
+    let cur = fnNode.parent;
+    while (cur) {
+      if (ANONYMOUS_CONTAINER_NODES.has(cur.type)) {
+        const binding = cur.parent;
+        if (!binding || binding.type !== "variable_declaration") return false;
+        let named = false;
+        for (let i = 0; i < binding.namedChildCount; i++) {
+          const c = binding.namedChild(i);
+          if (c && c.type === "identifier") {
+            named = true;
+            break;
+          }
+        }
+        if (!named) return false;
+        let up = binding.parent;
+        while (up) {
+          if (up.type === "function_declaration" || up.type === "test_declaration" || up.type === "comptime_declaration") return false;
+          if (ANONYMOUS_CONTAINER_NODES.has(up.type)) return false;
+          up = up.parent;
+        }
+        return true;
+      }
+      cur = cur.parent;
+    }
+    return true;
+  }
+  analyzeZigCodeRelationships(rootNode, relationships, symbols) {
+    const emittedCalls = /* @__PURE__ */ new Set();
+    const emittedUses = /* @__PURE__ */ new Set();
+    const importAliases = zigImportAliases(rootNode);
+    const stack = [{ node: rootNode, fn: null, inFn: false }];
+    while (stack.length > 0) {
+      const { node: n, fn, inFn } = stack.pop();
+      let nextFn = fn;
+      let nextInFn = inFn;
+      if (n.type === "function_declaration" || n.type === "test_declaration") {
+        const nameNode = this.anyChild(n, (c) => c.type === "identifier");
+        if (nameNode) {
+          nextInFn = true;
+          if (n.type === "test_declaration" || this.zigFunctionScopeIsPublished(n)) {
+            nextFn = nameNode.text;
+          }
+        }
+      }
+      if (n.type === "call_expression") {
+        const leafNode = this.zigCalleeLeafNode(n);
+        const leaf = leafNode?.text;
+        if (leaf) {
+          const source = nextInFn && nextFn ? nextFn : "(global)";
+          const calleeExpr = n.namedChildCount > 0 ? n.namedChild(0) : null;
+          const ext = this.zigExternalReceiverPath(
+            calleeExpr?.type === "field_expression" ? calleeExpr : void 0,
+            importAliases
+          );
+          const target = ext ? ext.target : leaf;
+          const k = `${source}->${target}`;
+          if (!emittedCalls.has(k)) {
+            emittedCalls.add(k);
+            relationships.push({
+              source,
+              target,
+              type: ASTEngine.RelationshipType.Calls,
+              confidence: 0.85,
+              // M59.A7 (#825): the callee LEAF as written — the name-bearing
+              // node, not the call expression (which a receiver can precede).
+              ...this.nodeLine(leafNode) ? { line_number: this.nodeLine(leafNode) } : {},
+              metadata: {
+                relationshipType: "zig_function_call",
+                callExpression: n.text.slice(0, 60),
+                ...this.zigExternalMetadata(ext)
+              }
+            });
+          }
+        }
+      }
+      if (n.type === "field_expression" && !this.isCallCallee(n)) {
+        const fieldNode = this.zigFieldLeafNode(n);
+        const field = fieldNode?.text;
+        const notBuiltinAccess = this.anyChild(n, (c) => c.type === "identifier") !== null;
+        const isAssignLhs = this.isWriteLhs(n);
+        const isEnumLiteral = n.namedChildCount < 2;
+        const p = n.parent;
+        const isTypePosition = (() => {
+          const VALUE_BOUNDARY = /* @__PURE__ */ new Set([
+            "call_expression",
+            "block",
+            "block_expression",
+            "arguments",
+            "assignment_expression",
+            "assignment_statement",
+            "compound_assignment_statement",
+            "struct_initializer",
+            "anonymous_struct_initializer",
+            "initializer_list",
+            "composite_literal",
+            "variable_declaration",
+            "return_expression",
+            "if_expression",
+            "switch_expression",
+            "while_expression",
+            "for_expression"
+          ]);
+          let cur = p;
+          let arrivedFrom = n;
+          let hops = 0;
+          while (cur && hops < 8) {
+            if (cur.type === "parameter" || cur.type === "container_field" || cur.type === "function_declaration" || cur.type === "function_signature") return true;
+            if (cur.type === "variable_declaration") {
+              return this.zigArrivedAtTypeAnnotation(cur, arrivedFrom);
+            }
+            if (VALUE_BOUNDARY.has(cur.type)) return false;
+            arrivedFrom = cur;
+            cur = cur.parent;
+            hops++;
+          }
+          return false;
+        })();
+        if (field && notBuiltinAccess && !isAssignLhs && !isEnumLiteral && !isTypePosition) {
+          const source = nextInFn && nextFn ? nextFn : "(global)";
+          const ext = this.zigExternalReceiverPath(n, importAliases);
+          const target = ext ? ext.target : field;
+          const k = `${source}->${target}`;
+          if (!emittedUses.has(k)) {
+            emittedUses.add(k);
+            relationships.push({
+              source,
+              target,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.75,
+              // M59.A7 (#825): the field LEAF as written.
+              ...this.nodeLine(fieldNode) ? { line_number: this.nodeLine(fieldNode) } : {},
+              metadata: {
+                relationshipType: "zig_field_access",
+                fieldAccessExpression: n.text.slice(0, 60),
+                ...this.zigExternalMetadata(ext)
+              }
+            });
+          }
+        }
+      }
+      const reflectedName = this.zigReflectionFieldName(n);
+      if (reflectedName) {
+        const source = nextInFn && nextFn ? nextFn : "(global)";
+        const k = `${source}->${reflectedName.text}`;
+        if (!emittedUses.has(k)) {
+          emittedUses.add(k);
+          relationships.push({
+            source,
+            target: reflectedName.text,
+            type: ASTEngine.RelationshipType.Uses,
+            confidence: 0.75,
+            // M59.A7 (#825): the line of the NAME, matching `zig_field_access`.
+            ...this.nodeLine(reflectedName) ? { line_number: this.nodeLine(reflectedName) } : {},
+            metadata: {
+              relationshipType: "zig_field_reflection",
+              reflectedMember: reflectedName.text
+            }
+          });
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push({ node: c, fn: nextFn, inFn: nextInFn });
+      }
+    }
+  }
+  /**
+   * Z3: bare-identifier value reads (`return MAX`, `g(D)`, `m[k]` keys,
+   * return operands). Every bare `identifier` naming a file-visible VALUE
+   * (file-scope const/var/fn/enum-member) is a Uses edge, with:
+   * - a lexical scope stack: function params bind at entry; block locals
+   *   (variable_declaration names), payload captures (`|x|`), for/if/while
+   *   payloads bind in walk order (reads before any binding still resolve
+   *   outward — C-family flow discipline);
+   * - declaration positions never read (first-identifier rule for
+   *   variable_declaration; entity names; composite-literal keys are
+   *   field_identifier-typed and auto-skip; labels/package/import paths/
+   *   blank `_` excluded);
+   * - call callees (span-matched; the calls branch owns them), member
+   *   leaves (field path owns them; objects stay readable), qualified
+   *   non-leaves, assignment LHS writes, test/comptime-exempt contexts all
+   *   excluded;
+   * - resolvability required: unknown names (std/dot-imported/external,
+   *   macro-template `$x`) stay silent — no junk edges.
+   */
+  /**
+   * M60 (#924, zig half): canonicalize the PUBLISHED name surface.
+   *
+   * Zig builds its symbols inline (no factory), so the strip lands here, at the
+   * publish boundary — after every analysis pass, so nothing internal ever sees a
+   * canonical spelling mid-walk (the bare-use inventory and the shadowing frames
+   * are keyed on the SOURCE's own spellings and stay consistent with the tree),
+   * and before the result leaves the analyzer.
+   */
+  /** Z35: is this right-hand side a module import? The two shapes the import
+   *  branches recognise, in one place so three sites cannot disagree. */
+  isZigImportBinding(rhs) {
+    if (!rhs) return false;
+    const host = rhs.type === "call_expression" || rhs.type === "builtin_function" ? rhs : null;
+    if (!host) return false;
+    for (let i = 0; i < host.namedChildCount; i++) {
+      const c = host.namedChild(i);
+      if (c && (c.type === "builtin_identifier" || c.type === "identifier")) {
+        const t = String(c.text ?? "");
+        return t === "@import" || t === "@cImport" || t === "import";
+      }
+    }
+    return false;
+  }
+  /**
+   * Z30: every `@import("path")` / `@cImport(…)` SITE, whether or not the import
+   * is the whole right-hand side.
+   *
+   * The three shape branches each ask "is the RHS exactly an @import?", so
+   * `const v = @import("build.zig.zon").version;` (a .zon manifest read),
+   * `const c = @import("c.zig").c;` (a module's C bindings) and
+   * `try @import("apple_sdk").addPaths(b, lib);` (a call ON a module, not even a
+   * declaration) fell through all of them: no fact, no edge, no symbol — 460 of
+   * 1,918 sites, 24% of the class. It is a SITE PASS rather than a fourth shape
+   * test, which is the lesson of this wave written down: a rule that enumerates
+   * the shapes it has seen keeps losing the one it has not.
+   *
+   * Measured shape: `builtin_function[builtin_identifier, arguments]`, the path in
+   * `arguments[string[string_content]]`. `@cImport({ @cInclude(…) })` nests its
+   * include strings and has no module path of its own, so it records the fact and
+   * publishes no edge — the same asymmetry the shape branches have.
+   *
+   * Dedupe key `(line, target)` against what the branches already pushed, so a
+   * site they handled is not recorded twice.
+   */
+  collectZigImportSites(rootNode, imports, relationships, projectRoot, filePath) {
+    const stack = [rootNode];
+    const seenFacts = /* @__PURE__ */ new Set();
+    for (const f of imports) seenFacts.add(`${f.range?.startLine ?? 0}|${f.module ?? ""}`);
+    const refEdgesAt = /* @__PURE__ */ new Map();
+    const importEdgesAt = /* @__PURE__ */ new Map();
+    for (const r of relationships) {
+      if (r.metadata?.isImport && typeof r.line_number === "number") {
+        const k = `${r.line_number}|${r.target}`;
+        if (r.type === ASTEngine.RelationshipType.Imports) importEdgesAt.set(k, r);
+        else refEdgesAt.set(k, r);
+      }
+    }
+    const attachFileClaim = (edge, claim) => {
+      if (claim === null) return;
+      const md = edge.metadata ?? (edge.metadata = {});
+      if (md.importProjectFile === void 0) md.importProjectFile = claim;
+    };
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "builtin_function" || n.type === "call_expression") {
+        let id = null;
+        if (n.type === "builtin_function") {
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c && (c.type === "builtin_identifier" || c.type === "identifier")) {
+              id = c;
+              break;
+            }
+          }
+        } else {
+          id = n.namedChildCount > 0 ? n.namedChild(0) : null;
+        }
+        const text = String(id?.text ?? "");
+        if (text === "@import" || text === "@cImport" || text === "import") {
+          const lit = zigImportModuleLiteral(n);
+          if (lit) {
+            const target = lit.module;
+            const line = this.nodeLine(lit.node) ?? 0;
+            const isUsingNamespace = n.parent?.type === "using_namespace_declaration";
+            if (target && line > 0) {
+              const k = `${line}|${target}`;
+              const fileClaim = projectRoot === void 0 ? null : fileClaimForTarget({
+                projectRoot,
+                filePath,
+                written: target,
+                admittedExtensions: ZIG_ADMITTED_EXTENSIONS,
+                // THE SIZE CLAUSE IS THE GUARD'S NOW (`ba04c6b4c`), not this lane's: a file over
+                // the indexer's own limit is never admitted, so a claim naming it cannot verify
+                // while a miss still REFUTES. Measured before it existed: adopting the claim
+                // without it took whole-population `extFAIL` 0 -> 17, all of them oversized
+                // `.zig` files, and all 15 of the corpus's `@import("….zig")` cap cases.
+                maxFileSizeBytes: FILE_CLAIM_MAX_BYTES
+              });
+              if (!seenFacts.has(k)) {
+                seenFacts.add(k);
+                imports.push({
+                  module: target,
+                  isDefaultImport: false,
+                  range: this.nodeRange(n),
+                  metadata: { zigImport: true, builtin: text, ...isUsingNamespace ? { usingnamespace: true } : {} }
+                });
+              }
+              const existingImport = importEdgesAt.get(k);
+              if (existingImport) {
+                attachFileClaim(existingImport, fileClaim);
+              } else {
+                const edge = {
+                  source: "(global)",
+                  target,
+                  type: ASTEngine.RelationshipType.Imports,
+                  confidence: 0.9,
+                  line_number: line,
+                  metadata: {
+                    relationshipType: "zig_import",
+                    isImport: true,
+                    zigImportDep: true,
+                    // THE FILE CLAIM, ONCE PER EDGE AND ON BOTH LABELS. See the block comment
+                    // above `collectZigImportSites`' call site for why it is on both.
+                    ...fileClaim ? { importProjectFile: fileClaim } : {}
+                  }
+                };
+                relationships.push(edge);
+                importEdgesAt.set(k, edge);
+              }
+              const existingRef = refEdgesAt.get(k);
+              if (existingRef) {
+                attachFileClaim(existingRef, fileClaim);
+              } else {
+                const edge = {
+                  source: "(global)",
+                  target,
+                  type: ASTEngine.RelationshipType.References,
+                  confidence: 1,
+                  line_number: line,
+                  metadata: {
+                    relationshipType: "zig_import",
+                    isImport: true,
+                    ...fileClaim ? { importProjectFile: fileClaim } : {}
+                  }
+                };
+                relationships.push(edge);
+                refEdgesAt.set(k, edge);
+              }
+            }
+          }
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  /**
+   * Z32: `instantiates` for the two statically derivable classes — a call to an
+   * in-file `fn … type`, and a construction of an in-file type (`TypeName{ … }`,
+   * bare or QUALIFIED: `Color.C{ .r = 1 }`). The inventory is the tree's own
+   * declarations, so the class needs no inference. `.{ … }` is an
+   * anonymous_struct_initializer with no name and instantiates nothing (Z21).
+   */
+  analyzeZigInstantiation(rootNode, relationships) {
+    const typeNames = /* @__PURE__ */ new Set();
+    const typeFns = /* @__PURE__ */ new Set();
+    const inventory = (n) => {
+      if (n.type === "function_declaration" || n.type === "function_signature") {
+        const t = n.childForFieldName?.("type");
+        if (t && (t.type === "builtin_type" || t.type === "identifier") && String(t.text) === "type") {
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c && c.type === "identifier") {
+              typeFns.add(String(c.text));
+              break;
+            }
+          }
+        }
+      }
+      if (n.type === "struct_declaration" || n.type === "enum_declaration" || n.type === "union_declaration" || n.type === "opaque_declaration") {
+        const p = n.parent;
+        const p0 = p?.namedChild(0);
+        if (p && p.type === "variable_declaration" && p.namedChildCount > 0 && p0?.type === "identifier") {
+          typeNames.add(String(p0.text));
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) inventory(c);
+      }
+    };
+    inventory(rootNode);
+    if (typeNames.size === 0 && typeFns.size === 0) return;
+    const seen = /* @__PURE__ */ new Set();
+    const enclosingName = (n) => {
+      let cur = n.parent;
+      while (cur) {
+        if (cur.type === "function_declaration" || cur.type === "test_declaration") {
+          for (let i = 0; i < cur.namedChildCount; i++) {
+            const c = cur.namedChild(i);
+            if (c && c.type === "identifier") {
+              if (cur.type === "test_declaration" || this.zigFunctionScopeIsPublished(cur)) {
+                return String(c.text);
+              }
+              break;
+            }
+          }
+        }
+        cur = cur.parent;
+      }
+      return "(global)";
+    };
+    const push = (source, target, line, md) => {
+      if (!target || line <= 0) return;
+      const k = `${source}|${target}|${line}`;
+      if (seen.has(k)) return;
+      seen.add(k);
+      relationships.push({
+        source,
+        target,
+        type: ASTEngine.RelationshipType.Instantiates,
+        confidence: 1,
+        line_number: line,
+        metadata: { relationshipType: "zig_instantiation", zigSpecific: true, isExternalTarget: false, ...md }
+      });
+    };
+    const sites = (n) => {
+      if (n.type === "call_expression") {
+        const callee = n.namedChildCount > 0 ? n.namedChild(0) : null;
+        if (callee && callee.type === "identifier" && typeFns.has(String(callee.text))) {
+          push(enclosingName(n), String(callee.text), this.nodeLine(callee) ?? 0, { isGenericTypeApplication: true });
+        }
+      }
+      if (n.type === "struct_initializer") {
+        const first = n.namedChildCount > 0 ? n.namedChild(0) : null;
+        if (first) {
+          const raw = String(first.text ?? "");
+          const nm = raw.includes(".") ? raw.slice(raw.lastIndexOf(".") + 1) : raw;
+          if (first.type !== "call_expression" && typeNames.has(nm)) {
+            push(enclosingName(n), nm, this.nodeLine(first) ?? 0, { isConstructorApplication: true });
+          }
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) sites(c);
+      }
+    };
+    sites(rootNode);
+  }
+  /**
+   * Z33: one `exports` relationship per exported declaration, GENERATED FROM the
+   * export list so the array and the edges cannot drift — which is the failure the
+   * `imports` twins already paid for once, when they were added to three shapes and
+   * not the fourth and only a bidirectional gate caught it.
+   *
+   * Source is `(file)`, not `(global)`: the exporting entity is the compilation
+   * unit, and `(global)` is this lane's marker for the EXPRESSION scope that reads
+   * and imports are attributed to. Keeping them apart lets a consumer group an API
+   * surface without guessing which convention a row used. The line is omitted —
+   * never written as 0 — when a declaration carries none (#820).
+   */
+  emitZigExportEdges(relationships, exports) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const e of exports) {
+      const name = String(e.name ?? "");
+      if (!name) continue;
+      const line = e.range?.startLine ?? 0;
+      const k = `${name}|${line}`;
+      if (seen.has(k)) continue;
+      seen.add(k);
+      relationships.push({
+        source: "(file)",
+        target: name,
+        type: ASTEngine.RelationshipType.Exports,
+        confidence: 1,
+        ...line > 0 ? { line_number: line } : {},
+        metadata: { relationshipType: "zig_export", zigExport: true, exportKind: String(e.kind ?? "") }
+      });
+    }
+  }
+  canonicalizePublishedNames(symbols, relationships, exports) {
+    for (const s of symbols) {
+      if (typeof s.name === "string") s.name = stripZigQuoting(s.name);
+      if (typeof s.ownerName === "string") s.ownerName = stripZigQuoting(s.ownerName);
+      if (typeof s.id === "string") s.id = stripZigQuoting(s.id);
+      if (typeof s.returnType === "string") s.returnType = stripZigQuoting(s.returnType);
+      for (const p of s.parameters ?? []) {
+        if (typeof p?.type === "string") p.type = stripZigQuoting(p.type);
+        if (typeof p?.name === "string") p.name = stripZigQuoting(p.name);
+      }
+      for (const key of ["genericParameters", "decorators", "comments"]) {
+        const arr = s[key];
+        if (Array.isArray(arr)) s[key] = arr.map((v) => typeof v === "string" ? stripZigQuoting(v) : v);
+      }
+    }
+    for (const r of relationships) {
+      if (typeof r.source === "string") r.source = stripZigQuoting(r.source);
+      if (typeof r.target === "string") r.target = stripZigQuoting(r.target);
+    }
+    for (const e of exports) {
+      if (typeof e.name === "string") e.name = stripZigQuoting(e.name);
+    }
+  }
+  analyzeZigBareIdentifierUses(rootNode, relationships, symbols) {
+    const fileValues = /* @__PURE__ */ new Set();
+    const enumMemberNames = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if (s.kind === ASTEngine.SymbolKind.EnumMember) enumMemberNames.add(s.name);
+      if (!s.ownerName && (s.kind === ASTEngine.SymbolKind.Constant || s.kind === ASTEngine.SymbolKind.Variable || s.kind === ASTEngine.SymbolKind.Function || s.kind === ASTEngine.SymbolKind.EnumMember)) {
+        fileValues.add(s.name);
+      }
+    }
+    const emitted = /* @__PURE__ */ new Set();
+    const scopeStack = [];
+    const isShadowed = (name) => {
+      for (let i = scopeStack.length - 1; i >= 0; i--) {
+        if (scopeStack[i].names.has(name)) return true;
+      }
+      return false;
+    };
+    const bindParamName = (node, frame) => {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && c.type === "identifier") {
+          if (c.text !== "_") frame.names.add(c.text);
+          return;
+        }
+      }
+      const any = this.anyChild(node, (c) => c.type === "identifier");
+      if (any && any.text !== "_") frame.names.add(any.text);
+    };
+    const bindIdentifiersUnder = (node, frame) => {
+      const walk = [node];
+      while (walk.length > 0) {
+        const m = walk.pop();
+        if (m !== node && (m.type === "call_expression" || m.type === "block" || m.type === "block_expression")) {
+          continue;
+        }
+        if (m.type === "identifier" && m.text !== "_") frame.names.add(m.text);
+        for (let i = m.namedChildCount - 1; i >= 0; i--) {
+          const c = m.namedChild(i);
+          if (c) walk.push(c);
+        }
+      }
+    };
+    const isDefiningOccurrence = (node) => {
+      const p = node.parent;
+      if (!p) return false;
+      if (p.type === "variable_declaration" || p.type === "assignment_expression") {
+        if (!this.isPlainAssignment(p)) return false;
+        const lhs = p.namedChildCount > 0 ? p.namedChild(0) : null;
+        return !!lhs && lhs.id === node.id;
+      }
+      if (p.type === "error_set_declaration" && node.type === "identifier") return true;
+      if (p.type === "function_declaration" || p.type === "test_declaration" || p.type === "container_field" || p.type === "error_set_declaration") {
+        for (let i = 0; i < p.namedChildCount; i++) {
+          const c = p.namedChild(i);
+          if (c && c.type === "identifier") {
+            return c.startIndex === node.startIndex && c.endIndex === node.endIndex;
+          }
+        }
+      }
+      return false;
+    };
+    const isCallCallee = (node) => {
+      let top = node;
+      let p = node.parent;
+      while (p && p.type !== "call_expression" && p.type !== "block" && p.type !== "function_declaration") {
+        top = p;
+        p = p.parent;
+      }
+      if (!p || p.type !== "call_expression") return false;
+      const first = p.namedChildCount > 0 ? p.namedChild(0) : null;
+      return !!first && top.startIndex >= first.startIndex && top.endIndex <= first.endIndex;
+    };
+    const stack = [{ node: rootNode, exit: false, pushed: false }];
+    while (stack.length > 0) {
+      const { node, exit, pushed } = stack.pop();
+      if (exit) {
+        if (pushed) scopeStack.pop();
+        continue;
+      }
+      const t = node.type;
+      let pushedScope = false;
+      if (t === "function_declaration" || t === "test_declaration") {
+        const frame = { names: /* @__PURE__ */ new Set(), fnName: null };
+        const params = [node];
+        while (params.length > 0) {
+          const m = params.pop();
+          if (m.type !== "function_declaration" || m === node) {
+            if (m.type === "parameter") bindParamName(m, frame);
+            for (let i = m.namedChildCount - 1; i >= 0; i--) {
+              const c = m.namedChild(i);
+              if (c && c.type !== "block" && c.type !== "block_expression" && c.type !== "function_declaration") params.push(c);
+            }
+          }
+        }
+        const nm = this.anyChild(node, (c) => c.type === "identifier");
+        frame.fnName = nm && (node.type === "test_declaration" || this.zigFunctionScopeIsPublished(node)) ? nm.text : null;
+        scopeStack.push(frame);
+        pushedScope = true;
+      } else if (t === "block" || t === "block_expression") {
+        scopeStack.push({ names: /* @__PURE__ */ new Set(), fnName: null });
+        pushedScope = true;
+      } else if (t === "switch_case") {
+        scopeStack.push({ names: /* @__PURE__ */ new Set(), fnName: null });
+        pushedScope = true;
+      } else if (t === "payload") {
+        const top = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : null;
+        if (top) bindIdentifiersUnder(node, top);
+      } else if (t === "variable_declaration") {
+        const top = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : null;
+        if (top && (this.hasToken(node, "var") || this.hasToken(node, "const"))) {
+          for (let i = 0; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (!c) continue;
+            if (c.type === "identifier") {
+              if (c.text !== "_") top.names.add(c.text);
+              break;
+            }
+            break;
+          }
+        }
+      } else if (t === "identifier") {
+        const name = node.text;
+        const p = node.parent;
+        let inError = false;
+        if (p && p.type === "error_type" && p.namedChildCount > 0) {
+          const last = p.namedChild(p.namedChildCount - 1);
+          if (last && last.startIndex === node.startIndex && last.endIndex === node.endIndex) {
+            let q = p.parent;
+            let typePos = false;
+            while (q) {
+              if (q.type === "parameter" || q.type === "container_field") {
+                typePos = true;
+                break;
+              }
+              if (q.type === "variable_declaration" || q.type === "arguments" || q.type === "return_expression" || q.type === "call_expression" || q.type === "function_declaration" || q.type === "block" || q.type === "block_expression") break;
+              q = q.parent;
+            }
+            if (!typePos) inError = true;
+          }
+        }
+        if (name && name !== "_" && !name.startsWith("$") && !isDefiningOccurrence(node) && !isCallCallee(node) && !(p && p.type === "field_expression") && // F6 audit: the former `label_name` / `continue_label` disjuncts are
+        // rust vocabulary — tree-sitter-zig labels are `block_label` /
+        // `break_label` (both live here) and a `continue :outer` label is an
+        // anonymous token with no identifier child to suppress.
+        !(p && p.type === "labeled_statement" || p && p.type === "block_label" || p && p.type === "break_label") && !isShadowed(name) && (fileValues.has(name) || inError && enumMemberNames.has(name))) {
+          let fnName = null;
+          for (let i = scopeStack.length - 1; i >= 0; i--) {
+            if (scopeStack[i].fnName) {
+              fnName = scopeStack[i].fnName;
+              break;
+            }
+          }
+          const src = fnName ?? "(global)";
+          const key = `${src}::uses::${name}`;
+          if (!emitted.has(key)) {
+            emitted.add(key);
+            relationships.push({
+              source: src,
+              target: name,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 1,
+              // M59.A7 (#825): the read occurs on the identifier's own line.
+              ...this.nodeLine(node) ? { line_number: this.nodeLine(node) } : {},
+              metadata: { relationshipType: "identifier_usage", nodeType: node.type }
+            });
+          }
+        }
+      }
+      stack.push({ node, exit: true, pushed: pushedScope });
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push({ node: child, exit: false, pushed: false });
+      }
+    }
+  }
+  // F6 audit — REMOVED: `hasZigQualifiedAncestor`. Its only `true` return was
+  // `cur.type === "qualified_type"`, and tree-sitter-zig has no such node (a
+  // qualified type `std.mem.Allocator` is a nested `field_expression`,
+  // probe-verified), so the function returned false for every input and the
+  // `!this.hasZigQualifiedAncestor(node)` guard it fed was a no-op. Its
+  // boundary names were equally dead (`field_declaration`, `composite_literal`,
+  // `assignment_statement` are rust/go names; zig uses `container_field`,
+  // `struct_initializer`, `variable_declaration`). The intended suppression of
+  // type-position reads is already done by the direct `field_expression`
+  // parent check at the call site; re-pointing this at `field_expression`
+  // would have dropped genuine receiver reads instead.
+  /** Builtin @-prefixed calls and generic type applications are not user
+   *  call targets. Returns the leaf name for a real user call site, else
+   *  undefined. */
+  zigCalleeLeafNode(call) {
+    const callee = call.namedChildCount > 0 ? call.namedChild(0) : null;
+    if (!callee) return void 0;
+    if (callee.type === "identifier") {
+      if (callee.text === "usingnamespace") return void 0;
+      return callee;
+    }
+    if (callee.type === "field_expression") {
+      return this.zigFieldLeafNode(callee);
+    }
+    return void 0;
+  }
+  // Z17 (deep review) — REMOVED as dead: `zigCalleeLeaf` and `zigFieldLeaf`,
+  // the string-returning wrappers around the two `*Node` accessors below. Every
+  // call site uses the NODE form, because every emitted edge needs the site line
+  // (M59.A7 #825); the string forms had no caller. `zigTypeLeaf` (the same
+  // wrapper for the type leaf) went the same way, and `nameLine` — a helper for
+  // the C/C++ lanes' attribute-line-base rule, never called here, so the zig lane
+  // has no `#920` line rule to claim. Dead code in a review wave is a claim
+  // about a contract that is not implemented, and four of them were sitting in
+  // the file.
+  /** The name-bearing field LEAF of a field_expression (`std.math.abs` ->
+   *  `abs`, `list.items` -> `items`) — the node whose text is the edge's target
+   *  and whose line is the edge's site (M59.A7 #825). */
+  zigFieldLeafNode(expr) {
+    const last = expr.namedChildCount > 0 ? expr.namedChild(expr.namedChildCount - 1) : null;
+    if (last && last.type === "identifier") return last;
+    return void 0;
+  }
+  /** True when this field_expression is the direct callee of a call_expression
+   *  (list.append in `list.append()`) — then the calls edge is the fact, not
+   *  a uses edge. Also skips builtin access `std.foo`. */
+  isCallCallee(expr) {
+    const p = expr.parent;
+    return !!p && p.type === "call_expression";
+  }
+  /**
+   * Z66 — the dotted path a read's receiver spells, when the receiver is an
+   * EXTERNAL `@import` alias, else null. The path is written out of the tree,
+   * segment by segment, so it is a parse fact and not a guess.
+   *
+   * `std.mem.Allocator` reaches the edge layer as the leaf `Allocator` alone; this
+   * walks up the `field_expression` chain to the root identifier and, if that root
+   * is a name this file binds by importing a BARE module path, returns
+   * `std.mem.Allocator`. A chain that breaks anywhere — a call result receiver
+   * (`std.io.getStdOut().writer()`), an anonymous enum literal (`.bad`, one named
+   * child and no base), a computed base — returns null and the edge stays as it
+   * was, because a path this analyzer cannot spell out of the tree is a path it
+   * must not publish.
+   *
+   * The name is emitted in place of the leaf and the receiver is recorded in
+   * metadata, so the edge says which module it names (`zigImportAlias`,
+   * `zigImportModule`) and a consumer can EXCLUDE it from its own unresolved count
+   * with a declared reason instead of inferring one. That is the whole of the
+   * `imports`-module-path defect's cost: `diagnose-incoming` reads 404 / 1,024 /
+   * 2,585 unresolved targets for zig with 0 module-wildcard shaped, because the
+   * target was the leaf, so nothing about the edge said `std`.
+   */
+  zigExternalReceiverPath(expr, aliases) {
+    if (!expr || expr.type !== "field_expression" || aliases.size === 0) return null;
+    if (expr.namedChildCount < 2) return null;
+    const segments = [];
+    let node = expr;
+    let root = "";
+    let depth = 0;
+    while (depth++ < 64) {
+      const fieldNode = node.namedChild(node.namedChildCount - 1);
+      if (!fieldNode || fieldNode.type !== "identifier") return null;
+      segments.push(stripZigQuoting(String(fieldNode.text ?? "")));
+      const base = node.namedChild(0);
+      if (!base) return null;
+      if (base.type === "identifier") {
+        root = stripZigQuoting(String(base.text ?? ""));
+        break;
+      }
+      if (base.type !== "field_expression") return null;
+      node = base;
+    }
+    if (root === "") return null;
+    const hit = aliases.get(root);
+    if (!hit || !hit.external) return null;
+    segments.reverse();
+    return { target: `${root}.${segments.join(".")}`, alias: root, module: hit.module };
+  }
+  /**
+   * THE EXTERNAL CLAIM'S METADATA, and the ONE place the `zigExternalRef` KEY is decided.
+   * Three emission sites (calls, field reads, declared-type references) all call this,
+   * because three copies of "may I claim this" is three rules.
+   *
+   * WHY THE CLAIM IS NOT ALWAYS ADMISSIBLE, measured rather than argued. The incoming
+   * arbiter reads `zigExternalRef` as an OWNER claim — "the target names a declaration
+   * whose OWNER the project does not publish" — and verifies it by looking the owner up
+   * (`script/m14/incoming-rule.ts`, `verifyExternalClaim`). For a target the receiver walk
+   * produced, the owner is everything before the LAST dot, and when the receiver path is
+   * exactly ONE segment long, that owner IS the alias:
+   *
+   *     `std.mem`            owner `std`      -> the file's own `const std = @import("std")`
+   *     `std.mem.Allocator`  owner `std.mem`  -> no declaration carries that name
+   *
+   * Z35 publishes that import binding as a `constant` named for the alias, so the owner of
+   * a one-segment path is ALWAYS a published declaration and the claim is ALWAYS refuted.
+   * MEASURED on the gate's own 60-file stride sample (565 marked edges, via
+   * `validation/m14/fixtures/zig/external-claim-audit.ts`), cross-tabulated by target depth
+   * because `owner === alias` is exactly the one-dot case:
+   *
+   *     1 dot:   extOK   1   extFAIL 259
+   *     2 dots:  extOK 223   extFAIL   0
+   *     3 dots:  extOK  60   extFAIL   0
+   *     4 dots:  extOK  21   extFAIL   0
+   *     5 dots:  extOK   1   extFAIL   0
+   *
+   * and all 259 were answered by a `constant` named for the alias, in the edge's own file.
+   * The key was asserting a claim the project can check and does refute — this lane's own
+   * defect, not a marker-spelling accident — and the fix is to stop asserting it where it
+   * cannot survive the lookup.
+   *
+   * WHAT IS NOT LOST. The QUALIFICATION stays: the target is still `std.mem`, not the bare
+   * leaf `mem`, which is the Z66 defect fix and is untouched by this. The receiver is still
+   * identified on the edge — `zigImportAlias`, `zigImportModule` and the post-pass's
+   * `targetScope: "file-external"` are all still written — so a consumer can still exclude
+   * the edge by a rule instead of by a guess. What is dropped is one key whose meaning the
+   * family defines as "the owner is not published", which is false here.
+   *
+   * THE RESIDUAL RISK, stated rather than hidden: a project that declares a symbol literally
+   * named `std.mem` (a quoted identifier, `@"std.mem"`) would refute a two-segment claim too.
+   * It is not zero, and it is what the arbiter's refutation is FOR — a deep-path claim that
+   * ever reads refuted is a defect this lane can see.
+   */
+  zigExternalMetadata(ext) {
+    if (!ext) return {};
+    const receiver = { zigImportAlias: ext.alias, zigImportModule: ext.module };
+    const dot = ext.target.lastIndexOf(".");
+    if (dot <= 0 || ext.target.slice(0, dot) === ext.alias) return receiver;
+    return { zigExternalRef: true, ...receiver };
+  }
+  /**
+   * Did `from` reach `decl` (a `variable_declaration`) THROUGH its type annotation?
+   *
+   * True for `var x: c.Foo = ...` and `var x: ?c.Bar = null`, false for the two
+   * positions that are value reads: the initializer (`var x = v.baz`) and the
+   * assignment LHS that also parses as a declaration. The test is an ANCESTRY test
+   * rather than an identity test because the grammar's `type` field is the whole
+   * wrapped path — `?c.Bar` is one `field_expression` — so an inner segment of the
+   * chain reaches the declaration from a DESCENDANT of that node.
+   *
+   * It reads the same `type` field the declared-type collector reads, so the pass
+   * that suppresses the duplicate `uses` and the pass that carries the fact as
+   * `references (declared_type)` are keyed off one node by construction. `var d =
+   * v.baz` has no `type` field at all, which is why the initializer is excluded
+   * here and not by a name test.
+   */
+  zigArrivedAtTypeAnnotation(decl, from) {
+    const annotation = this.typeFieldOf(decl);
+    if (!annotation || !from) return false;
+    let cur = from;
+    let hops = 0;
+    while (cur && hops++ < 8) {
+      if (cur.id === annotation.id) return true;
+      const parent = cur.parent;
+      if (!parent || parent.id === decl.id) return false;
+      cur = parent;
+    }
+    return false;
+  }
+  /**
+   * The field_expression a leaf NAME belongs to, when the leaf is the LAST named
+   * child of one — i.e. when the leaf really is the final segment of that access
+   * rather than an identifier found somewhere under it. The declared-type pass reads
+   * leaves by a breadth-first walk (Z19), so for an unnamed fn-TYPE parameter the leaf
+   * can be a BASE segment; qualifying from there would name a path the annotation
+   * does not end at, so that case is refused instead.
+   */
+  zigTrailingFieldExpr(leaf) {
+    if (!leaf) return void 0;
+    const parent = leaf.parent;
+    if (!parent || parent.type !== "field_expression") return void 0;
+    if (parent.namedChild(parent.namedChildCount - 1)?.id !== leaf.id) return void 0;
+    return parent;
+  }
+  /**
+   * Declared-type reference graph (family standard — go/c/rust M14). Collects
+   * the leaf names of parameter types, return types, and struct/union/enum/
+   * error-set field types, emitting `references` edges. Builtins and the bare
+   * `void`/`!void` wrappers are excluded; generic type applications on a var
+   * RHS (std.StringHashMap(usize)) are NOT declared-type deps.
+   */
+  extractZigDeclaredTypeRefs(rootNode, relationships) {
+    const emitted = /* @__PURE__ */ new Set();
+    const importAliases = zigImportAliases(rootNode);
+    const push = (leaf, site) => {
+      if (!leaf) return;
+      const head = leaf;
+      if (!head || ZIG_DECLARED_TYPE_BUILTINS.has(head) && !zigFileScopeNames(rootNode).has(head)) return;
+      const c0 = head.charCodeAt(0);
+      if (c0 >= 48 && c0 <= 57) return;
+      const ext = this.zigExternalReceiverPath(this.zigTrailingFieldExpr(site), importAliases);
+      const target = ext ? ext.target : head;
+      if (!emitted.has(target)) {
+        emitted.add(target);
+        relationships.push({
+          source: "(declared-type)",
+          target,
+          type: ASTEngine.RelationshipType.References,
+          confidence: 0.9,
+          // M59.A7 (#825): the type as written at this site.
+          ...this.nodeLine(site) ? { line_number: this.nodeLine(site) } : {},
+          metadata: {
+            relationshipType: "declared_type",
+            ...this.zigExternalMetadata(ext)
+          }
+        });
+      }
+    };
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "function_declaration" || n.type === "function_signature") {
+        const paramsNode = this.anyChild(n, (c) => c.type === "parameters");
+        if (paramsNode) {
+          for (let i = 0; i < paramsNode.namedChildCount; i++) {
+            const param = paramsNode.namedChild(i);
+            if (param?.type !== "parameter") continue;
+            const tNode = this.zigTypeLeafNode(param);
+            if (tNode) push(tNode.text, tNode);
+          }
+        }
+        const retNode = this.typeFieldOf(n) ?? this.zigFallbackReturnType(n);
+        const retLeafNode = retNode ? this.leafOfTypeNode(retNode) : void 0;
+        if (retLeafNode) push(retLeafNode.text, retLeafNode);
+      }
+      if (n.type === "container_field") {
+        const tNode = this.zigTypeLeafNode(n);
+        if (tNode) push(tNode.text, tNode);
+      }
+      if (n.type === "variable_declaration") {
+        const tField = this.typeFieldOf(n);
+        if (tField) {
+          const leaf = this.leafOfTypeNode(tField);
+          if (leaf) push(leaf.text, leaf);
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  /**
+   * The history this replaced, kept because the field-based version is only
+   * better if the field is really there (deep-review fixes, 2026-08-29):
+   *   (1) builtin_type nodes were dropped because they shadowed the real leaf —
+   *       `map: *std.StringHashMap(usize)` returned `usize`. Z13 keeps that
+   *       exclusion (it is a value filter, in `push`) and fixes the cause: the
+   *       leaf is read from the `type` FIELD, so a generic ARGUMENT can no
+   *       longer be the answer because it is no longer in scope.
+   *   (2) the first identifier was dropped as the declared name. Z13 drops the
+   *       whole guess — the field is the name's sibling, not its predecessor.
+   *   (3) enum members yielded undefined, and still do: a `container_field`
+   *       with no `type` field IS the enum member, which is now the test
+   *       instead of a consequence.
+   */
+  /**
+   * True when a `struct_initializer` initializes an array/slice OF TYPES —
+   * `pub const Implements = [_]type{ gtk.Scrollable };` — so the declaration is
+   * a type, not a value. Measured on the pinned corpora: every one of the 32
+   * upper-case `struct_initializer` declarations is of this form, while the
+   * 467 lower-case ones are ordinary values (`[_]u8{ 1, 2, 3 }`, `Point{}`), and
+   * the element type is a direct child (`array_type` / `slice_type` carrying the
+   * `type`, `comptime_int` or `comptime_float` builtin).
+   */
+  isTypeValuedInitializer(init) {
+    for (let i = 0; i < init.namedChildCount; i++) {
+      const c = init.namedChild(i);
+      if (!c) continue;
+      if (c.type !== "array_type" && c.type !== "slice_type") continue;
+      for (let j = 0; j < c.namedChildCount; j++) {
+        const e = c.namedChild(j);
+        if (e && e.type === "builtin_type" && (e.text === "type" || e.text === "comptime_int" || e.text === "comptime_float")) return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * A `labeled_type_expression` that is really a labeled BLOCK — `const V =
+   * cvalue: { … break :cvalue v; }` — yields a VALUE, whatever the name's case.
+   *
+   * The grammar has ONE node type for both Zig forms (3,900 occurrences in the
+   * pinned corpora): `L: { … break :L v; }` is a labeled block and
+   * `L: T { … return v; }` is a labeled type, and the two differ in the block
+   * they carry — a block leaves by `break :label`, a type by `return`. Measured
+   * over 400 corpus files: 9 of 9 labeled_type_expression right-hand sides
+   * break and none returns, and the six with an upper-case name
+   * (`pub const CValue = cvalue: { … }`, `pub const Key = key: { … }`) were
+   * published as `Type` for what are comptime-computed struct values.
+   */
+  isLabeledBlockValue(rhs) {
+    if (rhs.type !== "labeled_type_expression") return false;
+    let hasBreak = false;
+    let hasReturn = false;
+    const stack = [rhs];
+    let guard = 0;
+    while (stack.length > 0 && guard++ < 500) {
+      const n = stack.pop();
+      if (n.type === "break_label") hasBreak = true;
+      if (n.type === "return_expression") hasReturn = true;
+      if (hasReturn) return false;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return hasBreak;
+  }
+  /**
+   * The identifier NODE that names a declaration's type, so a declared-type
+   * reference can carry the line the type is written on (M59.A7 #825).
+   *
+   * Z13 (deep review, 2026-09-28) — this used to walk EVERY `identifier` under
+   * the declaration node, drop the first (assumed to be the declared name) and
+   * take the last. The grammar does not require that guess: it hands the type
+   * over as a FIELD (`parameter.type` 78,895, `container_field.type` 49,424,
+   * `variable_declaration.type` 43,949, `function_declaration.type` 37,129 in
+   * the pinned corpora), and no TYPE node carries a field of that name, so
+   * preferring it can never pick the wrong side of an `!` or a `.*`.
+   *
+   * The walk was wrong wherever a declaration has a DEFAULT VALUE: the value
+   * contributes its own identifiers, and the LAST one won.
+   *   `size: Size = .byte`   published `byte` — an enum member — and never `Size`
+   *   `mode: Mode = .a`      published `a`
+   *   `normal = @sizeOf(u8)` published `u8`
+   * Measured over the three corpora, the sites where the emitted target changes
+   * are dominated by exactly these shapes (`script/m14/tmp/zigw-decltype.ts`).
+   *
+   * With no `type` field the node is an ENUM MEMBER (`container_field` is the
+   * same node type for `a: u8` and for `north` / `normal = 0`; only the former
+   * has a type), and a member's value is not a type — so that case yields
+   * `undefined` rather than falling back to the walk. The walk survives only
+   * where nothing else exists: an already-extracted type node.
+   */
+  zigTypeLeafNode(node) {
+    const typeField = this.typeFieldOf(node);
+    if (typeField) return this.leafOfTypeNode(typeField);
+    if (node.type === "container_field") return void 0;
+    if (node.type === "variable_declaration") return void 0;
+    const nameField = this.namedFieldOf(node, "name");
+    if (!nameField) return this.leafOfTypeNode(node);
+    const stack = [];
+    for (let i = node.namedChildCount - 1; i >= 0; i--) {
+      const c = node.namedChild(i);
+      if (c && c.id !== nameField.id) stack.push(c);
+    }
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "identifier") return n;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return void 0;
+  }
+  /** The `name` FIELD of a node, or null. `function_declaration` carries one
+   *  37,126 times in the corpus, `container_field` 104,090, `parameter` 77,594
+   *  (the 1,346 that do not are fn-TYPE parameters, which is what the
+   *  name/no-name split above turns on). */
+  namedFieldOf(node, field) {
+    if (typeof node.childForFieldName !== "function") return null;
+    return node.childForFieldName(field) ?? null;
+  }
+  /** The name a TYPE NODE carries, or `undefined` when it carries none.
+   *
+   *  - a container literal in a type position is ANONYMOUS (`fn f(s: struct {
+   *    FLAG: u8 }) void`): it has fields, not a name, and the last identifier
+   *    under it is a FIELD name — the shape that published
+   *    `references (declared-type) -> FLAG` for a type that names nothing;
+   *  - `!T` carries its dependency in the `ok` FIELD (21,353 in the corpus).
+   *    The walk took the LAST identifier under the whole node, which is a
+   *    member of the ERROR set: `fn f() error{A}!u32` published `-> A`, a
+   *    phantom, and never `u32` (correctly, as a builtin);
+   *  - an `error_type` is an unnamed set, for the same reason;
+   *  - a `labeled_type_expression` (`const V = blk: { … break :blk v; }`) has
+   *    no statically knowable name at all: its label and its value are both
+   *    identifiers in the tree, and the last one is the VALUE, not a type.
+   */
+  leafOfTypeNode(t) {
+    if (t.type === "identifier") return t;
+    switch (t.type) {
+      case "struct_declaration":
+      case "union_declaration":
+      case "enum_declaration":
+      case "error_set_declaration":
+      case "error_type":
+      case "labeled_type_expression":
+        return void 0;
+      case "error_union_type": {
+        const ok = this.namedFieldOf(t, "ok");
+        return ok ? this.leafOfTypeNode(ok) : void 0;
+      }
+      default:
+        return this.leafIdentifierUnder(t);
+    }
+  }
+  /** The `type` FIELD of a node, or null when the grammar does not name one.
+   *  `childForFieldName` is guarded because a web-tree-sitter build without
+   *  field access would otherwise throw on the first declaration. */
+  typeFieldOf(node) {
+    if (typeof node.childForFieldName !== "function") return null;
+    return node.childForFieldName("type") ?? null;
+  }
+  /** The LAST `identifier` at or under `node` — the leaf of a qualified type
+   *  (`std.mem.Allocator` → `Allocator`, `MyList(u32)` → `MyList`), the same
+   *  rule the old walk applied, now scoped to the type. Guarded at 200 nodes,
+   *  which the corpus census shows is far above the deepest real type
+   *  (`parameter.type` trees are a handful of nodes). */
+  leafIdentifierUnder(node) {
+    if (node.type === "identifier") return node;
+    let found;
+    let seen = 0;
+    const stack = [node];
+    while (stack.length > 0 && seen++ < 200) {
+      const n = stack.pop();
+      if (n.type === "identifier") found = n;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return found;
+  }
+  /**
+   * The return-type node of a function, WITHOUT the `type` field — the
+   * fallback for a grammar variant that does not name it. Zig's return type is
+   * the last child that is not the body and not the parameter list; a
+   * `callconv(.C)` between them is not the return type, so the node-type list
+   * that used to sit here is replaced by position.
+   */
+  zigFallbackReturnType(fn) {
+    const kids = this.getAllNamedChildren(fn);
+    for (let i = kids.length - 1; i >= 0; i--) {
+      const c = kids[i];
+      if (c.type === "block" || c.type === "parameters" || c.type === "block_expression") continue;
+      if (i === 0 && c.type === "identifier") continue;
+      if (c.type === "calling_convention") continue;
+      return c;
+    }
+    return void 0;
+  }
+  /**
+   * True when `node` is the left-hand side of a WRITE. Zig assignments parse as
+   * `variable_declaration` with the LHS as the first named child, and the
+   * OPERATOR is the discriminator: a plain `=` writes without reading, while
+   * `+=`, `|=`, `*%=` and the rest read their left side as well (Z15).
+   */
+  isWriteLhs(node) {
+    const p = node.parent;
+    if (!p) return false;
+    if (p.type !== "variable_declaration" && p.type !== "assignment_expression") return false;
+    if (p.namedChildCount > 0 && p.namedChild(0)?.id !== node.id) return false;
+    return this.isPlainAssignment(p);
+  }
+  /** A plain `=` assignment: the operator is the anonymous token `=`, which is
+   *  a node type of its own, distinct from `+=`/`-=`/`|=`/`<<=` (140 distinct
+   *  anonymous token types in the corpus census). */
+  isPlainAssignment(node) {
+    return this.hasToken(node, "=");
+  }
+  /** A function's body node, read off the grammar's `body` field, falling back
+   *  to a `block` child for a grammar variant that does not name it. */
+  functionBody(fn) {
+    if (typeof fn.childForFieldName === "function") {
+      const b = fn.childForFieldName("body");
+      if (b) return b;
+      if (fn.namedChildCount > 0) {
+        return null;
+      }
+      return null;
+    }
+    return this.anyChild(fn, (c) => c.type === "block");
+  }
+  /**
+   * M59.A7 (#825): the 1-based line of a syntax node, or `undefined` when the
+   * node is absent. Never 0 — a missing site is OMITTED from the edge (the
+   * #820 rule), so a reader can tell "no line" from "line 1".
+   */
+  nodeLine(node) {
+    if (!node || !node.startPosition || typeof node.startPosition.row !== "number") return void 0;
+    return node.startPosition.row + 1;
+  }
+  /** Per-symbol cyclomatic complexity of a function/method body (family
+   *  standard — go/c/rust all emit symbol.complexity; zig did NOT).
+   *
+   * Deep-review fixes (2026-08-29, final zig pass):
+   *   (1) Expression forms if_expression / for_expression / while_expression
+   *       are Zig's DOMINANT forms (`const a = if (c) 1 else 2;`) and were
+   *       never counted — only the statement forms were. All six now count.
+   *   (2) `else` in expression forms is an ANONYMOUS token inside the
+   *       if_expression (probe-verified), not an else_clause — both are
+   *       counted now (else_clause node OR hasToken "else").
+   *   (3) binary_expression used a substring trap: `t.indexOf("and")`
+   *       falsely matched identifiers (`x + standard + order` -> +2). The
+   *       operator is an anonymous child token (`and`/`or`/`orelse`,
+   *       probe-verified) — we now match the token type exactly. */
+  zigBodyComplexity(node) {
+    let c = 1;
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "if_statement" || n.type === "if_expression" || n.type === "for_statement" || n.type === "for_expression" || n.type === "while_statement" || n.type === "while_expression" || n.type === "switch_expression" || n.type === "else_clause" || n.type === "catch_expression") {
+        c++;
+      }
+      if ((n.type === "if_expression" || n.type === "for_expression" || n.type === "while_expression") && this.hasToken(n, "else")) {
+        c++;
+      }
+      if (n.type === "binary_expression") {
+        for (let i = 0; i < n.childCount; i++) {
+          const op = n.child(i);
+          if (op && !op.isNamed && (op.type === "and" || op.type === "or" || op.type === "orelse")) {
+            c++;
+            break;
+          }
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c2 = n.namedChild(i);
+        if (c2) stack.push(c2);
+      }
+    }
+    return c;
+  }
+  /** #419-D evidence-tier classification for every emitted relationship
+   *  (family rules — rust/c/cpp/go all classify; zig did NOT). */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.evidenceClass) continue;
+      const t = String(r.type ?? "");
+      const conf = typeof r.confidence === "number" ? r.confidence : 1;
+      if (t === "contains") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = md.relationshipType === "declared_type" ? "reference_qualified" : "import_based";
+        continue;
+      }
+      if (t === "instantiates") {
+        md.evidenceClass = conf >= 0.9 && md.isExternalTarget === false ? "structural" : "inferred";
+        continue;
+      }
+      if (t === "imports" || t === "exports") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "mixes_in") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  /**
+   * Z65 — TARGET SCOPE: state, per edge, whether the target name is a symbol THIS
+   * file publishes, and with which kind.
+   *
+   * WHY. A zig relationship carries six keys and both endpoints are NAME STRINGS.
+   * `src/lsp/impact.ts` obtains inbound edges by scanning outgoing edges and
+   * MATCHING TARGETS — no inbound edge is stored — so an edge's name is all a
+   * reverse walk has, and a name two declarations share is attributed to one of
+   * them by a rule nobody chose. Measured over the whole 3,834-file zig corpus
+   * (draw `sha256:2f3545f9…`, production `parseFile`, 392,550 edges):
+   * **265,887 edges (67.73%) name a target 2+ published symbols share**, and of
+   * those **151,004 (56.79%) have a candidate in the edge's OWN file** — a tie a
+   * per-file rule breaks soundly, because within one file the analyzer knows which
+   * declaration it published.
+   *
+   * WHAT IT ADDS. `metadata.targetScope`, plus `targetKind` when the file
+   * publishes exactly one kind under that name:
+   *   `file-local`     the file publishes a symbol with this exact name. A
+   *                    consumer resolves the edge to THAT symbol and needs no
+   *                    cross-file guess.
+   *   `file-external`  the file publishes none. The edge names something outside
+   *                    it — a `std.*` declaration, a builtin, an import path — and
+   *                    no per-file rule can say which. Stated, not guessed.
+   *   `scope-marker`   the endpoint is one of the literal scope markers
+   *                    (`(global)`, `(file)`, `(declared-type)`), which is a fact
+   *                    about the edge's provenance and not a symbol name.
+   *
+   * It adds NO edge, removes NO edge, and changes NO count — it is a label on
+   * edges that already exist, derived from this analyzer's own output rather than
+   * from a guess about the rest of the repository. A consumer that ignores it
+   * behaves exactly as before, which is why it cannot regress a budgeted lane.
+   *
+   * THE LIMIT, stated because it is the part that cannot be fixed here. This says
+   * whether the target is IN this file, not whether it is the declaration the
+   * author meant: `const Self = @This();` is a file-local name, and 240 edges
+   * resolve against it, while `keepSymbol`'s UNIVERSAL denylist
+   * (`src/ast/pool-worker.ts:449`, shared, §8) refuses to publish ANY symbol
+   * named `Self` — so those edges are labelled `file-external` even though the
+   * name is right there in the file. The denylist is the defect, and it is not
+   * this lane's file.
+   */
+  annotateTargetScope(symbols, relationships) {
+    const kindsByName = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      const n = String(s.name ?? "");
+      if (!n) continue;
+      const addKey = (k) => {
+        const set = kindsByName.get(k) ?? /* @__PURE__ */ new Set();
+        set.add(String(s.kind ?? ""));
+        kindsByName.set(k, set);
+      };
+      addKey(n);
+      const qualified = publishedSpelling(s);
+      if (qualified !== n) addKey(qualified);
+    }
+    const MARKERS = /* @__PURE__ */ new Set(["(global)", "(file)", "(declared-type)", "(import)", "(local)"]);
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.targetScope) continue;
+      const t = String(r.target ?? "");
+      if (MARKERS.has(t)) {
+        md.targetScope = "scope-marker";
+        continue;
+      }
+      const kinds = kindsByName.get(t);
+      if (!kinds) {
+        md.targetScope = "file-external";
+        continue;
+      }
+      md.targetScope = "file-local";
+      if (kinds.size === 1) md.targetKind = [...kinds][0];
+      else md.targetKindCount = kinds.size;
+    }
+  }
+  /** The `const X = @This();` binding of a file, or null when the file does not
+   *  name its own container. Read off node types only: a direct
+   *  `variable_declaration` child of the root whose value is a `builtin_function`
+   *  carrying the `builtin_identifier` `@This`.
+   *
+   *  The NAME is `namedChild(0)` when that is an `identifier`, NOT
+   *  `childForFieldName("name")`: this grammar declares no `name` field on
+   *  `variable_declaration` — the walk reads a variable declaration's name the
+   *  same way, and a probe that used the field lookup reported 0 bindings on a
+   *  source that carries one. `container_field` DOES declare `name`, which is
+   *  why `zigFileLevelField` can use the field.
+   *
+   *  Null is a real answer and not a fallback: 10 of the 411 corpus files that
+   *  declare file-level fields never bind `@This()`, and for those the owner of
+   *  those fields is not nameable from the file. */
+  zigThisBindingName(root) {
+    for (let i = 0; i < root.namedChildCount; i++) {
+      const decl = root.namedChild(i);
+      if (!decl || decl.type !== "variable_declaration") continue;
+      for (let j = 0; j < decl.namedChildCount; j++) {
+        const value = decl.namedChild(j);
+        if (!value || value.type !== "builtin_function") continue;
+        const isThis = this.anyChild(value, (n) => n.type === "builtin_identifier" && n.text === "@This");
+        if (!isThis) continue;
+        const name = decl.namedChildCount > 0 ? decl.namedChild(0) : null;
+        if (name && name.type === "identifier") return name.text;
+      }
+    }
+    return null;
+  }
+  /** Publish one `container_field` whose direct parent is the file's root — a
+   *  member of the struct the FILE is, per `zigThisBindingName`.
+   *
+   *  The kind is decided by the field's own `type` FIELD, which is this
+   *  analyzer's discriminator between a struct field and an enum member
+   *  (`:2180`): the grammar uses one node type for `a: u8` and for `north`, and
+   *  only the former carries a type. A named container gets that answer from
+   *  its kind instead; a file-level container has no published kind, because
+   *  `const X = @This()` publishes `X` as a `Type` whether the body is a struct
+   *  or an enum, so the field's own field is the only evidence there is.
+   *
+   *  The owner is set ONLY when the file names it. The 10 corpus files that
+   *  declare file-level fields without a `@This()` binding publish the field
+   *  with no owner: the declaration is real and its reads then resolve, while
+   *  no `contains` edge is emitted for it, because that edge would need a
+   *  source symbol and asserting one would be inventing the container's name.
+   *
+   *  The name guards are the SAME three the named-container branch applies, and
+   *  they are load-bearing here rather than defensive: the corpus's three
+   *  untyped file-level fields are all in `zig/test/cases/compile_errors/`
+   *  (`file_level_tuple.zig` — a file-level tuple, which Zig rejects), and their
+   *  text holds a TYPE where a name belongs (`u32`, `comptime u8 = 123`). A
+   *  symbol named `u32` is a fabrication, so they are refused exactly as an
+   *  unnamed `extern struct` member is. */
+  zigFileLevelField(node, ownerName, symbols) {
+    const nameField = this.namedFieldOf(node, "name");
+    const nameNode = nameField && nameField.type === "identifier" ? nameField : this.anyChild(node, (n) => n.type === "identifier");
+    const fieldName = nameNode ? nameNode.text : "";
+    if (!fieldName || fieldName === "_" || fieldName.length >= 200) return;
+    const typeField = this.typeFieldOf(node);
+    symbols.push({
+      name: fieldName,
+      kind: typeField ? ASTEngine.SymbolKind.Property : ASTEngine.SymbolKind.EnumMember,
+      visibility: "public",
+      range: this.nodeRange(node),
+      scope: ownerName ?? void 0,
+      ownerName: ownerName ?? void 0,
+      ownerKind: ownerName ? ASTEngine.SymbolKind.Type : void 0,
+      returnType: typeField ? this.nodeText(typeField) : void 0,
+      metadata: {
+        zigField: true,
+        zigFileLevelField: true,
+        ...typeField ? {} : { zigEnumMember: true }
+      }
+    });
+  }
+  pushChildren(node, walkStack, container, inFunction, anonContainer) {
+    for (let i = node.namedChildCount - 1; i >= 0; i--) {
+      const child = node.namedChild(i);
+      if (child) walkStack.push({ node: child, container, inFunction, anonContainer });
+    }
+  }
+  // ─── PURE HELPER FUNCTIONS ───
+  nodeRange(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
+    };
+  }
+  nodeText(node) {
+    if (!node) return "";
+    return node.text;
+  }
+  anyChild(node, predicate) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && predicate(child)) return child;
+    }
+    return null;
+  }
+  /**
+   * Z24 (pass 24): the DECLARATION NAME `@field` reads, when it is spelled as a string.
+   *
+   * ## The construct
+   *
+   * Zig can read a container's member by name-as-text rather than by identifier:
+   *
+   *     @field(p, "x")        // the field `x` of whatever `p` holds
+   *     @field(Point, "z")    // the field `z` of the type `Point`
+   *
+   * Measured over the whole zig corpus (`validation/m14/fixtures/zig/reflection-builtin-probe.mts`,
+   * 8 shards, 3,848/3,848 files, 0 parse traps): **779 `@field` and 210 `@hasDecl` call
+   * sites over 242 files**, of which **206 name a declaration as a string**. Before this
+   * pass the analyzer read none of them — `reflection-firing.mts` drove the production
+   * `parseFile` over all 70 files carrying such a site and found **0** edges attributed to
+   * a reflection reason code. The 52 sites whose line carried an edge naming the same
+   * declaration decompose, by the analyzer's own reason codes, into `zig_field_access` 39,
+   * `zig_function_call` 10, `zig_export` 3 and `identifier_usage` 1 — all different
+   * constructs that share a line, since a relationship carries `line_number` and no range.
+   *
+   * Measured AFTER this pass, same instrument, same 70 files: **18 of the 22 named `@field`
+   * sites are represented by a `zig_field_reflection` edge**, and 7 of those 18 have the edge
+   * on their OWN line. The gap between 18 and 7 is Z52's post-pass, which collapses one `uses`
+   * edge per (source, target) keeping the higher confidence: `zig/test/behavior/member_func.zig:77,78`
+   * name `one` and `two`, the reflection edge for each is emitted, and the dot-access edge the
+   * same file already published at lines 39 and 62 wins the tie at the same 0.75. The
+   * site-level number alone would have read 7 and filed a working derivation as 11 misses.
+   *
+   * ## Why `@field` and NOT `@hasDecl`
+   *
+   * `@field(S, "a")` READS `S.a`: the corpus compiles, so `S` has that member and the code
+   * consumes its value. That is exactly the claim the `zig_field_access` pass already makes
+   * for `S.a` written with dots, so it is emitted as `uses` at the same confidence, with a
+   * distinct reason code so the two derivations stay auditable apart.
+   *
+   * `@hasDecl(S, "a")` is an EXISTENCE TEST. Its whole purpose is to ask whether `a` is
+   * there, and the surrounding code handles both answers (`if (@hasDecl(T, "opt")) … else
+   * …`). A hard `uses`/`references` edge would assert a dependency the source deliberately
+   * does not take, which is the fabrication this workstream exists to prevent, so it is NOT
+   * emitted. Its measured population is published instead: 184 named sites, and 128 of the
+   * 184 name a declaration this corpus does not publish at all (a foreign container, a type
+   * parameter, a translate-c struct), so even a permissive reading would have produced 128
+   * edges the graph cannot walk to.
+   *
+   * ## Why the name must be identifier-shaped
+   *
+   * `@field(anyerror, "Expected closing ]")` is a legal Zig read of an error-set member, and
+   * Z18 already recorded what publishing such a text as a bare target does: it produced
+   * targets like `@"ziglib"` for names that were legitimate. The same guard applies — a
+   * `string_content` carrying a character outside `[A-Za-z0-9_]` is an error name, not a
+   * member this file declares, and publishing it would add an edge whose target is junk.
+   * Measured: **2 of the 22 named `@field` sites** carry a non-identifier-shaped name
+   * (`zig/lib/std/fmt.zig:1550,1557`, both `"Expected closing ]"`) and **both are declined**.
+   *
+   * ## WHAT THE SHAPE GUARD DOES NOT DO, because a comment that claimed otherwise was wrong
+   *
+   * An earlier revision of this header read "3 of the 22 resolve to nothing and all 3 are
+   * declined, which is what the arity measurement independently found". The two numbers are
+   * 2 and 3 and they are not the same set. The third zero-resolving site is `NotFound` at
+   * `zig/test/behavior/error.zig:897`, `@field(anyerror, "NotFound")`, and its name IS
+   * identifier-shaped, so it is EMITTED — with `targetScope: file-external`, because nothing in
+   * that 3,000-line file publishes `NotFound`. So the guard is not an error-set detector: it
+   * declines error names containing punctuation and lets identifier-shaped error names
+   * through. That is the intended behaviour and it is stated rather than papered over:
+   *
+   *   - `error.NotFound` IS a legitimate declaration name in Zig, so the edge states a TRUE
+   *     dependency — on a name this particular file's corpus does not publish.
+   *   - `anyerror` is a `builtin_type` node, not an `identifier`, so its member namespace is
+   *     the inferred error set of the whole PROGRAM: unbounded, and bindable by no per-file
+   *     rule.
+   *   - Suppressing it instead would be inconsistent with the sibling pass, which publishes
+   *     `@typeInfo(u8).Int` → `Int` under the same `file-external` label, and `Int` equally
+   *     resolves to nothing in its own file. Dropping one unresolvable read and keeping the
+   *     other would be a fit to a single test line, not a rule.
+   *
+   * So the honest count is: of the 7 `zig_field_reflection` edges the corpus produces, **6
+   * carry a target published in their own file and exactly 1 does not**
+   * (`zig/test/behavior/error.zig:897`), and it says so on the edge.
+   *
+   * No regex: the shape test is a Set of node types and the character test is a
+   * character-code range, both the file's existing zero-regex discipline.
+   */
+  zigReflectionFieldName(node) {
+    if (node.type !== "builtin_function") return null;
+    const bid = this.anyChild(node, (c) => c.type === "builtin_identifier");
+    if (!bid || bid.text !== "@field") return null;
+    const args = this.anyChild(node, (c) => c.type === "arguments");
+    if (!args) return null;
+    let stringArg = null;
+    let seen = 0;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const a = args.namedChild(i);
+      if (!a) continue;
+      seen++;
+      if (seen === 2 && a.type === "string") stringArg = a;
+    }
+    if (!stringArg) return null;
+    const content = this.anyChild(stringArg, (c) => c.type === "string_content");
+    if (!content) return null;
+    const text = content.text;
+    if (!text) return null;
+    const isStart = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95;
+    const isRest = (c) => isStart(c) || c >= 48 && c <= 57;
+    if (!isStart(text.charCodeAt(0))) return null;
+    for (let i = 1; i < text.length; i++) {
+      if (!isRest(text.charCodeAt(i))) return null;
+    }
+    return content;
+  }
+  // The `pub`/`export`/`inline` modifiers are anonymous token children
+  // (`variable_declaration [pub:"pub"] [const:"const"]`) — pure AST, never
+  // source-text scanning.
+  hasToken(node, token) {
+    const count = node.childCount;
+    for (let i = 0; i < count; i++) {
+      const c = node.child(i);
+      if (c && !c.isNamed && c.type === token) return true;
+    }
+    return false;
+  }
+  getAllNamedChildren(node) {
+    const children = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) children.push(child);
+    }
+    return children;
+  }
+};
+export {
+  RealZigAnalyzer,
+  ZIG_DECLARED_TYPE_BUILTINS,
+  stripZigQuoting,
+  zigFileScopeNames,
+  zigImportAliases
+};