From 3057755426ae400a0f05c0e4d0acfb52f9006fc8 Mon Sep 17 00:00:00 2001
From: wandl-6A72h <hiwepy@gmail.com>
Date: Sun, 7 Jun 2026 14:50:09 +0800
Subject: [PATCH 01/10] add  zig support

---
 CHANGELOG.md                             |   1 +
 __tests__/zig-extraction.test.ts         | 285 +++++++++++++++++++++++
 src/extraction/grammars.ts               |   6 +-
 src/extraction/languages/index.ts        |   2 +
 src/extraction/languages/zig.ts          | 181 ++++++++++++++
 src/extraction/wasm/tree-sitter-zig.wasm | Bin 0 -> 693809 bytes
 src/types.ts                             |   1 +
 7 files changed, 475 insertions(+), 1 deletion(-)
 create mode 100644 __tests__/zig-extraction.test.ts
 create mode 100644 src/extraction/languages/zig.ts
 create mode 100755 src/extraction/wasm/tree-sitter-zig.wasm

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e63b7d152..1a130c551 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -73,6 +73,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - CodeGraph's MCP server now answers an agent's `resources/list` and `prompts/list` probes with an empty list instead of an error, clearing the `-32601` messages some clients (opencode, Codex) logged on connect. (#621)
 - Svelte and Vue components used through a barrel file — `export { default as Button } from './Button.svelte'` re-exported from an `index.ts` and imported elsewhere — are no longer falsely reported as having **0 callers**. CodeGraph now follows the default re-export all the way to the component and resolves the imports that `.svelte` / `.vue` files themselves use, so `codegraph_callers` and `codegraph_impact` see every place a component is used. This also covers components imported from another package in a workspace/monorepo (`@scope/ui/widgets`) and bare directory imports (`import { x } from './'`). Previously a live component consumed only through a barrel looked like dead code. Thanks @nakisen. (#629)
 - Components used in a Vue Single-File Component's `<template>` — `<MyButton />`, or the kebab-case `<my-button />` — are now indexed as usages, so `codegraph_callers` and `codegraph_impact` include components that appear only in another component's markup (including through a barrel re-export). Previously only a Vue component's `<script>` block was analyzed, so template-only usages were invisible. (#629)
+- Added Zig language support — parses `.zig` and `.zon` files with tree-sitter-zig, extracting functions, structs, enums, unions, opaque types, error sets, container fields, methods, variables, and `@import` references.
 
 ## [0.9.9] - 2026-06-02
 
diff --git a/__tests__/zig-extraction.test.ts b/__tests__/zig-extraction.test.ts
new file mode 100644
index 000000000..258975580
--- /dev/null
+++ b/__tests__/zig-extraction.test.ts
@@ -0,0 +1,285 @@
+/**
+ * Zig Extraction Tests
+ *
+ * Tests for tree-sitter-zig based extraction.
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { extractFromSource } from '../src/extraction';
+import { detectLanguage, isLanguageSupported, initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+
+beforeAll(async () => {
+  await initGrammars();
+  await loadGrammarsForLanguages(['zig']);
+});
+
+describe('Zig Language Detection', () => {
+  it('should detect .zig files as zig', () => {
+    expect(detectLanguage('main.zig')).toBe('zig');
+  });
+
+  it('should detect .zon files as zig', () => {
+    expect(detectLanguage('build.zig.zon')).toBe('zig');
+  });
+
+  it('should report zig as supported', () => {
+    expect(isLanguageSupported('zig')).toBe(true);
+  });
+});
+
+describe('Zig Function Extraction', () => {
+  it('should extract a basic function', () => {
+    const code = `
+fn add(a: i32, b: i32) i32 {
+    return a + b;
+}
+`;
+    const result = extractFromSource('math.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(1);
+    expect(funcs[0]?.name).toBe('add');
+    expect(funcs[0]?.signature).toContain('a: i32, b: i32');
+  });
+
+  it('should extract a pub function as exported/visible', () => {
+    const code = `
+pub fn main() void {
+    _ = add(1, 2);
+}
+`;
+    const result = extractFromSource('main.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(1);
+    expect(funcs[0]?.name).toBe('main');
+    expect(funcs[0]?.isExported).toBe(true);
+    expect(funcs[0]?.visibility).toBe('public');
+  });
+
+  it('should extract function with return type', () => {
+    const code = `
+fn calculate(x: f64) f64 {
+    return x * 2.0;
+}
+`;
+    const result = extractFromSource('calc.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(1);
+    expect(funcs[0]?.signature).toContain('f64');
+  });
+
+  it('should extract multiple functions from the same file', () => {
+    const code = `
+fn foo() void { }
+fn bar() void { }
+pub fn baz() i32 { return 42; }
+`;
+    const result = extractFromSource('multi.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(3);
+    const names = funcs.map((f) => f.name).sort();
+    expect(names).toEqual(['bar', 'baz', 'foo']);
+    expect(funcs.find((f) => f.name === 'baz')?.isExported).toBe(true);
+  });
+});
+
+describe('Zig Type Declaration Extraction', () => {
+  it('should extract a named struct from variable declaration', () => {
+    const code = `
+const Point = struct {
+    x: f64,
+    y: f64,
+};
+`;
+    const result = extractFromSource('point.zig', code);
+    const structs = result.nodes.filter((n) => n.kind === 'struct');
+    expect(structs.length).toBe(1);
+    expect(structs[0]?.name).toBe('Point');
+  });
+
+  it('should extract a pub struct with correct visibility', () => {
+    const code = `
+pub const Config = struct {
+    port: u16,
+    host: []const u8,
+};
+`;
+    const result = extractFromSource('config.zig', code);
+    const structs = result.nodes.filter((n) => n.kind === 'struct');
+    expect(structs.length).toBe(1);
+    expect(structs[0]?.name).toBe('Config');
+    expect(structs[0]?.isExported).toBe(true);
+    expect(structs[0]?.visibility).toBe('public');
+  });
+
+  it('should extract named enum from variable declaration', () => {
+    const code = `
+const Color = enum {
+    red,
+    green,
+    blue,
+};
+`;
+    const result = extractFromSource('color.zig', code);
+    const enums = result.nodes.filter((n) => n.kind === 'enum');
+    expect(enums.length).toBe(1);
+    expect(enums[0]?.name).toBe('Color');
+  });
+
+  it('should extract enum members', () => {
+    const code = `
+const Status = enum {
+    ok,
+    not_found,
+    pending,
+};
+`;
+    const result = extractFromSource('status.zig', code);
+    const members = result.nodes.filter((n) => n.kind === 'enum_member');
+    expect(members.length).toBe(3);
+    const names = members.map((m) => m.name).sort();
+    expect(names).toEqual(['not_found', 'ok', 'pending']);
+  });
+
+  it('should extract named union from variable declaration', () => {
+    const code = `
+const Value = union(enum) {
+    int: i32,
+    float: f64,
+    str: []const u8,
+};
+`;
+    const result = extractFromSource('value.zig', code);
+    const structs = result.nodes.filter((n) => n.kind === 'struct');
+    expect(structs.some((s) => s.name === 'Value')).toBe(true);
+  });
+
+  it('should extract error set declaration', () => {
+    const code = `
+const MyError = error{
+    NotFound,
+    PermissionDenied,
+    OutOfMemory,
+};
+`;
+    const result = extractFromSource('errors.zig', code);
+    const enums = result.nodes.filter((n) => n.kind === 'enum');
+    expect(enums.some((n) => n.name === 'MyError')).toBe(true);
+  });
+
+  it('should extract opaque declaration', () => {
+    const code = `
+pub const Handle = opaque {
+    pub fn close(self: *Handle) void {
+        _ = self;
+    }
+};
+`;
+    const result = extractFromSource('handle.zig', code);
+    const structs = result.nodes.filter((n) => n.kind === 'struct');
+    expect(structs.some((s) => s.name === 'Handle')).toBe(true);
+  });
+});
+
+describe('Zig Container Fields', () => {
+  it('should extract struct fields', () => {
+    const code = `
+const User = struct {
+    id: u64,
+    name: []const u8,
+    active: bool,
+};
+`;
+    const result = extractFromSource('user.zig', code);
+    const fields = result.nodes.filter((n) => n.kind === 'field');
+    expect(fields.length).toBe(3);
+    const names = fields.map((f) => f.name).sort();
+    expect(names).toEqual(['active', 'id', 'name']);
+  });
+});
+
+describe('Zig Methods', () => {
+  it('should extract function declarations inside struct as methods', () => {
+    const code = `
+const Counter = struct {
+    count: u32,
+
+    pub fn init() Counter {
+        return Counter{ .count = 0 };
+    }
+
+    pub fn increment(self: *Counter) void {
+        self.count += 1;
+    }
+};
+`;
+    const result = extractFromSource('counter.zig', code);
+    const methods = result.nodes.filter((n) => n.kind === 'method');
+    expect(methods.length).toBe(2);
+    const names = methods.map((m) => m.name).sort();
+    expect(names).toEqual(['increment', 'init']);
+  });
+});
+
+describe('Zig Variable Declarations', () => {
+  it('should extract const declarations', () => {
+    const code = `
+const x: i32 = 42;
+const greeting = "hello";
+`;
+    const result = extractFromSource('vars.zig', code);
+    const consts = result.nodes.filter((n) => n.kind === 'constant');
+    const vars = result.nodes.filter((n) => n.kind === 'variable');
+    // Both are `const`, so both should be `constant`
+    expect(consts.length + vars.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('should extract var declarations', () => {
+    const code = `
+var counter: u32 = 0;
+var running = true;
+`;
+    const result = extractFromSource('mut.zig', code);
+    const vars = result.nodes.filter((n) => n.kind === 'variable');
+    expect(vars.length).toBeGreaterThanOrEqual(2);
+    expect(vars.every((v) => v.name === 'counter' || v.name === 'running')).toBe(true);
+  });
+
+  it('should distinguish const from var', () => {
+    const code = `
+const immutable: u32 = 1;
+var mutable: u32 = 0;
+`;
+    const result = extractFromSource('both.zig', code);
+    const consts = result.nodes.filter((n) => n.kind === 'constant');
+    const vars = result.nodes.filter((n) => n.kind === 'variable');
+    expect(consts).toHaveLength(1);
+    expect(vars).toHaveLength(1);
+    expect(consts[0]?.name).toBe('immutable');
+    expect(vars[0]?.name).toBe('mutable');
+  });
+});
+
+describe('Zig @import Detection', () => {
+  it('should detect @import calls and create import references', () => {
+    const code = `
+const std = @import("std");
+const testing = @import("std").testing;
+`;
+    const result = extractFromSource('imports.zig', code);
+    const refs = result.unresolvedReferences.filter((r) => r.referenceKind === 'imports');
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+    expect(refs.some((r) => r.referenceName === 'std')).toBe(true);
+  });
+});
+
+describe('Zig Function Calls', () => {
+  it('should track function calls inside function bodies', () => {
+    const code = `
+fn a() void { }
+fn b() void { _ = a(); }
+`;
+    const result = extractFromSource('calls.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'a')).toBe(true);
+  });
+});
diff --git a/src/extraction/grammars.ts b/src/extraction/grammars.ts
index f35e2afea..e73fe473c 100644
--- a/src/extraction/grammars.ts
+++ b/src/extraction/grammars.ts
@@ -38,6 +38,7 @@ const WASM_GRAMMAR_FILES: Record<GrammarLanguage, string> = {
   lua: 'tree-sitter-lua.wasm',
   luau: 'tree-sitter-luau.wasm',
   objc: 'tree-sitter-objc.wasm',
+  zig: 'tree-sitter-zig.wasm',
 };
 
 /**
@@ -105,6 +106,8 @@ export const EXTENSION_MAP: Record<string, Language> = {
   '.luau': 'luau',
   '.m': 'objc',
   '.mm': 'objc',
+  '.zig': 'zig',
+  '.zon': 'zig',
   // XML: file-level tracking; the MyBatis extractor matches `<mapper namespace="...">`
   // shape and emits SQL-statement nodes (other XML returns empty).
   '.xml': 'xml',
@@ -201,7 +204,7 @@ export async function loadGrammarsForLanguages(languages: Language[]): Promise<v
       // ABI-13 build that corrupts the shared WASM heap under web-tree-sitter
       // 0.25 (drops nested calls/imports on every file after the first); we
       // vendor the upstream ABI-15 wasm instead.
-      const wasmPath = (lang === 'pascal' || lang === 'scala' || lang === 'lua' || lang === 'luau')
+      const wasmPath = (lang === 'pascal' || lang === 'scala' || lang === 'lua' || lang === 'luau' || lang === 'zig')
         ? path.join(__dirname, 'wasm', wasmFile)
         : require.resolve(`tree-sitter-wasms/out/${wasmFile}`);
       const language = await WasmLanguage.load(wasmPath);
@@ -405,6 +408,7 @@ export function getLanguageDisplayName(language: Language): string {
     lua: 'Lua',
     luau: 'Luau',
     objc: 'Objective-C',
+    zig: 'Zig',
     yaml: 'YAML',
     twig: 'Twig',
     xml: 'XML',
diff --git a/src/extraction/languages/index.ts b/src/extraction/languages/index.ts
index 543598b8e..4ac393312 100644
--- a/src/extraction/languages/index.ts
+++ b/src/extraction/languages/index.ts
@@ -26,6 +26,7 @@ import { scalaExtractor } from './scala';
 import { luaExtractor } from './lua';
 import { luauExtractor } from './luau';
 import { objcExtractor } from './objc';
+import { zigExtractor } from './zig';
 
 export const EXTRACTORS: Partial<Record<Language, LanguageExtractor>> = {
   typescript: typescriptExtractor,
@@ -49,4 +50,5 @@ export const EXTRACTORS: Partial<Record<Language, LanguageExtractor>> = {
   lua: luaExtractor,
   luau: luauExtractor,
   objc: objcExtractor,
+  zig: zigExtractor,
 };
diff --git a/src/extraction/languages/zig.ts b/src/extraction/languages/zig.ts
new file mode 100644
index 000000000..7c54f407a
--- /dev/null
+++ b/src/extraction/languages/zig.ts
@@ -0,0 +1,181 @@
+import type { Node as SyntaxNode } from 'web-tree-sitter';
+import { getNodeText, getChildByField } from '../tree-sitter-helpers';
+import type { LanguageExtractor, ExtractorContext } from '../tree-sitter-types';
+
+const ZIG_TYPE_DECL_TYPES = new Set([
+  'struct_declaration',
+  'enum_declaration',
+  'union_declaration',
+  'opaque_declaration',
+  'error_set_declaration',
+]);
+
+function hasKeyword(node: SyntaxNode, keyword: string): boolean {
+  for (let i = 0; i < node.childCount; i++) {
+    if (node.child(i)?.type === keyword) return true;
+  }
+  return false;
+}
+
+function findTypeDeclaration(node: SyntaxNode): SyntaxNode | null {
+  if (ZIG_TYPE_DECL_TYPES.has(node.type)) return node;
+  if (
+    node.type === 'type_expression' ||
+    node.type === 'primary_type_expression' ||
+    node.type === 'parenthesized_expression'
+  ) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child) continue;
+      const found = findTypeDeclaration(child);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+export const zigExtractor: LanguageExtractor = {
+  functionTypes: ['function_declaration'],
+  classTypes: [],
+  methodTypes: ['function_declaration'],
+  interfaceTypes: [],
+  structTypes: [
+    'struct_declaration',
+    'enum_declaration',
+    'union_declaration',
+    'opaque_declaration',
+    'error_set_declaration',
+  ],
+  enumTypes: [],
+  typeAliasTypes: [],
+  importTypes: [],
+  callTypes: ['call_expression', 'builtin_function'],
+  variableTypes: ['variable_declaration'],
+  fieldTypes: ['container_field'],
+  nameField: 'name',
+  bodyField: 'body',
+  paramsField: 'parameters',
+  returnField: 'type',
+
+  classifyClassNode: (node) => {
+    if (hasKeyword(node, 'enum') || hasKeyword(node, 'error')) return 'enum';
+    return 'struct';
+  },
+
+  getVisibility: (node) => (hasKeyword(node, 'pub') ? 'public' : 'private'),
+
+  isExported: (node) => hasKeyword(node, 'pub'),
+
+  isConst: (node) => hasKeyword(node, 'const'),
+
+  getSignature: (node, source) => {
+    // tree-sitter-zig doesn't expose 'parameters' as a named field on
+    // function_declaration — find the parameters node among named children.
+    let paramsNode: SyntaxNode | null = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child?.type === 'parameters') {
+        paramsNode = child;
+        break;
+      }
+    }
+    const returnType = getChildByField(node, 'type');
+    let sig = paramsNode ? getNodeText(paramsNode, source) : '';
+    if (returnType) sig += ' ' + getNodeText(returnType, source);
+    return sig.trim() || undefined;
+  },
+
+  visitNode: (node, ctx) => {
+    // Named type declarations: const Foo = struct { ... }; etc.
+    // The variable_declaration wraps a type declaration as its value.
+    if (node.type === 'variable_declaration') {
+      let name = '';
+      let valueNode: SyntaxNode | null = null;
+
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child) continue;
+        if (child.type === 'identifier' && !name) {
+          name = getNodeText(child, ctx.source);
+          continue;
+        }
+        if (name && !valueNode) {
+          valueNode = findTypeDeclaration(child);
+        }
+      }
+
+      if (name && valueNode) {
+        const isPub = hasKeyword(node, 'pub');
+        const isEnum =
+          valueNode.type === 'enum_declaration' || valueNode.type === 'error_set_declaration';
+        const kind = isEnum ? 'enum' : 'struct';
+
+        const typeNode = ctx.createNode(kind, name, node, {
+          visibility: isPub ? 'public' : 'private',
+          isExported: isPub,
+        });
+        if (!typeNode) return true;
+
+        ctx.pushScope(typeNode.id);
+        for (let i = 0; i < valueNode.namedChildCount; i++) {
+          const child = valueNode.namedChild(i);
+          if (!child) continue;
+          if (child.type === 'container_field' && isEnum) {
+            const nameField = getChildByField(child, 'name');
+            if (nameField) {
+              ctx.createNode('enum_member', getNodeText(nameField, ctx.source), child);
+            }
+          } else {
+            ctx.visitNode(child);
+          }
+        }
+        ctx.popScope();
+        return true;
+      }
+
+      // Check if this variable wraps @import("...") — the value is a
+      // builtin_function that extractVariable won't descend into.
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child) continue;
+        if (child.type === 'builtin_function') {
+          const text = ctx.source.substring(child.startIndex, child.endIndex);
+          const m = text.match(/@import\s*\(\s*"([^"]+)"\s*\)/);
+          if (m) {
+            ctx.addUnresolvedReference({
+              fromNodeId: ctx.nodeStack[ctx.nodeStack.length - 1] || '',
+              referenceName: m[1],
+              referenceKind: 'imports',
+              line: child.startPosition.row + 1,
+              column: child.startPosition.column,
+            });
+          }
+        }
+      }
+      return false;
+    }
+
+    // @import("...") builtins — emit an imports reference.
+    // tree-sitter-zig parses @import as builtin_function, not call_expression.
+    if (node.type === 'call_expression' || node.type === 'builtin_function') {
+      const text = ctx.source.substring(node.startIndex, node.endIndex);
+      const m = text.match(/@import\s*\(\s*"([^"]+)"\s*\)/);
+      if (m) {
+        const parentId = ctx.nodeStack[ctx.nodeStack.length - 1];
+        if (parentId) {
+          ctx.addUnresolvedReference({
+            fromNodeId: parentId,
+            referenceName: m[1],
+            referenceKind: 'imports',
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+          });
+        }
+        return true;
+      }
+      return false;
+    }
+
+    return false;
+  },
+};
diff --git a/src/extraction/wasm/tree-sitter-zig.wasm b/src/extraction/wasm/tree-sitter-zig.wasm
new file mode 100755
index 0000000000000000000000000000000000000000..8f39612a3cdd2b33b4df5c4af921afba01a7328c
GIT binary patch
literal 693809
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
DYuCxB

literal 0
HcmV?d00001

diff --git a/src/types.ts b/src/types.ts
index 01aadae02..9555f61c8 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -89,6 +89,7 @@ export const LANGUAGES = [
   'lua',
   'luau',
   'objc',
+  'zig',
   'yaml',
   'twig',
   'xml',

From b5c8b3fda741e9881f1d41bf2c8074f3b66e357c Mon Sep 17 00:00:00 2001
From: wandl-6A72h <hiwepy@gmail.com>
Date: Sun, 7 Jun 2026 15:44:41 +0800
Subject: [PATCH 02/10] feat(zig): complete Zig language support with
 review-driven improvements

- Rewrite function_declaration handling entirely in visitNode with
  custom walkBodyForCalls to correctly resolve chained field chains
  (std.debug.print, std.mem.eql, std.fs.cwd, etc.) that the core
  extractCall resolves to just the leaf method name
- Add @import("std").testing pattern detection for import references
  nested inside field_expression nodes
- Add test_declaration extraction as function nodes (both string and
  identifier name forms)
- Add comptime_declaration handling so inner declarations are visited
- Add using_namespace_declaration support (deprecated but present)
- Handle packed struct / extern struct / tagged union / enum(u8)
- Filter _ wildcard from non-exhaustive enum members
- Add export fn visibility / isExported detection
- Threadlocal var detection as variable (not constant)
- 36 tests covering functions, types, fields, methods, enums, imports,
  chained calls, tests, comptime, threadlocal, and stdlib patterns
---
 __tests__/zig-extraction.test.ts | 191 +++++++++++++++++++++++
 src/extraction/languages/zig.ts  | 251 ++++++++++++++++++++++++++-----
 2 files changed, 403 insertions(+), 39 deletions(-)

diff --git a/__tests__/zig-extraction.test.ts b/__tests__/zig-extraction.test.ts
index 258975580..9c1f14c06 100644
--- a/__tests__/zig-extraction.test.ts
+++ b/__tests__/zig-extraction.test.ts
@@ -283,3 +283,194 @@ fn b() void { _ = a(); }
     expect(calls.some((r) => r.referenceName === 'a')).toBe(true);
   });
 });
+
+describe('Zig Chained Method Calls', () => {
+  it('resolves std.debug.print as full chain', () => {
+    const code = `
+const std = @import("std");
+pub fn main() void {
+    std.debug.print("hello\\n", .{});
+}
+`;
+    const result = extractFromSource('chained.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'std.debug.print')).toBe(true);
+  });
+
+  it('resolves std.mem.eql as full chain', () => {
+    const code = `
+const std = @import("std");
+pub fn main() void {
+    _ = std.mem.eql(u8, "a", "b");
+}
+`;
+    const result = extractFromSource('mem.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'std.mem.eql')).toBe(true);
+  });
+
+  it('resolves simple obj.method() correctly', () => {
+    const code = `
+const Foo = struct { pub fn bar(self: *Foo) void { } };
+fn main() void { var f: Foo = undefined; f.bar(); }
+`;
+    const result = extractFromSource('obj.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'f.bar')).toBe(true);
+  });
+
+  it('detects @import("std").testing import inside field expression', () => {
+    const code = `
+const testing = @import("std").testing;
+`;
+    const result = extractFromSource('stdtest.zig', code);
+    const refs = result.unresolvedReferences.filter((r) => r.referenceKind === 'imports');
+    expect(refs.some((r) => r.referenceName === 'std')).toBe(true);
+  });
+});
+
+describe('Zig Test Declarations', () => {
+  it('should extract a test declaration with string name as function', () => {
+    const code = `
+test "basic addition" {
+    _ = add(1, 2);
+}
+`;
+    const result = extractFromSource('test_basic.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(1);
+    expect(funcs[0]?.name).toBe('basic addition');
+  });
+
+  it('should extract a test declaration with identifier name', () => {
+    const code = `
+test addWorks {
+    _ = add(1, 2);
+}
+`;
+    const result = extractFromSource('test_id.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(1);
+    expect(funcs[0]?.name).toBe('addWorks');
+  });
+
+  it('should track calls inside test declarations', () => {
+    const code = `
+fn add(a: i32, b: i32) i32 { return a + b; }
+test "uses add" { _ = add(1, 2); }
+`;
+    const result = extractFromSource('test_calls.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'add')).toBe(true);
+  });
+});
+
+describe('Zig Non-Exhaustive Enum', () => {
+  it('should not extract _ as an enum member', () => {
+    const code = `
+const E = enum(u8) {
+    a = 1,
+    b,
+    _,
+};
+`;
+    const result = extractFromSource('nonexhaustive.zig', code);
+    const members = result.nodes.filter((n) => n.kind === 'enum_member');
+    const names = members.map((m) => m.name);
+    expect(names).toEqual(['a', 'b']);
+    expect(names).not.toContain('_');
+  });
+});
+
+describe('Zig Export Visibility', () => {
+  it('should treat export fn as exported', () => {
+    const code = `
+export fn hello() void { }
+`;
+    const result = extractFromSource('exportfn.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(1);
+    expect(funcs[0]?.isExported).toBe(true);
+    expect(funcs[0]?.visibility).toBe('public');
+  });
+
+  it('should track export fn call from another function', () => {
+    const code = `
+export fn run() void { }
+fn main() void { _ = run(); }
+`;
+    const result = extractFromSource('export_calls.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'run')).toBe(true);
+  });
+});
+
+describe('Zig Comptime Blocks', () => {
+  it('should extract declarations inside comptime blocks', () => {
+    const code = `
+comptime {
+    const version: u32 = 1;
+    var counter: u32 = 0;
+}
+`;
+    const result = extractFromSource('comptime_vars.zig', code);
+    const consts = result.nodes.filter((n) => n.kind === 'constant');
+    const vars = result.nodes.filter((n) => n.kind === 'variable');
+    expect(consts).toHaveLength(1);
+    expect(vars).toHaveLength(1);
+    expect(consts[0]?.name).toBe('version');
+    expect(vars[0]?.name).toBe('counter');
+  });
+});
+
+describe('Zig Packed and Extern Types', () => {
+  it('should extract packed struct', () => {
+    const code = `
+const S = packed struct {
+    x: i32,
+    y: i32,
+};
+`;
+    const result = extractFromSource('packed.zig', code);
+    const structs = result.nodes.filter((n) => n.kind === 'struct');
+    expect(structs.length).toBe(1);
+    expect(structs[0]?.name).toBe('S');
+  });
+
+  it('should extract extern struct', () => {
+    const code = `
+const E = extern struct {
+    id: u32,
+    name: [32]u8,
+};
+`;
+    const result = extractFromSource('extern_struct.zig', code);
+    const structs = result.nodes.filter((n) => n.kind === 'struct');
+    expect(structs.length).toBe(1);
+    expect(structs[0]?.name).toBe('E');
+  });
+});
+
+describe('Zig Threadlocal Variable', () => {
+  it('should extract threadlocal var as variable (not constant)', () => {
+    const code = `
+threadlocal var counter: u32 = 0;
+`;
+    const result = extractFromSource('threadlocal.zig', code);
+    const vars = result.nodes.filter((n) => n.kind === 'variable');
+    expect(vars.length).toBe(1);
+    expect(vars[0]?.name).toBe('counter');
+  });
+});
+
+describe('Zig Usingnamespace', () => {
+  it('should detect @import inside usingnamespace', () => {
+    const code = `
+usingnamespace @import("foo");
+`;
+    const result = extractFromSource('usingns.zig', code);
+    const refs = result.unresolvedReferences.filter((r) => r.referenceKind === 'imports');
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+    expect(refs.some((r) => r.referenceName === 'foo')).toBe(true);
+  });
+});
diff --git a/src/extraction/languages/zig.ts b/src/extraction/languages/zig.ts
index 7c54f407a..238e82e22 100644
--- a/src/extraction/languages/zig.ts
+++ b/src/extraction/languages/zig.ts
@@ -10,6 +10,8 @@ const ZIG_TYPE_DECL_TYPES = new Set([
   'error_set_declaration',
 ]);
 
+const INSTANTIATION_KINDS = new Set(['new_expression', 'object_creation_expression']);
+
 function hasKeyword(node: SyntaxNode, keyword: string): boolean {
   for (let i = 0; i < node.childCount; i++) {
     if (node.child(i)?.type === keyword) return true;
@@ -34,17 +36,129 @@ function findTypeDeclaration(node: SyntaxNode): SyntaxNode | null {
   return null;
 }
 
+function buildFieldChain(node: SyntaxNode, source: string): string {
+  const object = getChildByField(node, 'object');
+  const member = getChildByField(node, 'member');
+  const memberName = member ? getNodeText(member, source) : '';
+  if (object && object.type === 'field_expression') {
+    return buildFieldChain(object, source) + '.' + memberName;
+  }
+  const objectName = object ? getNodeText(object, source) : '';
+  if (objectName && memberName) return objectName + '.' + memberName;
+  return objectName || memberName;
+}
+
+function findImportBuiltin(node: SyntaxNode, source: string): SyntaxNode | null {
+  if (node.type === 'builtin_function') {
+    const text = source.substring(node.startIndex, node.endIndex);
+    if (/@import\s*\(\s*"([^"]+)"\s*\)/.test(text)) return node;
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (!child) continue;
+    const found = findImportBuiltin(child, source);
+    if (found) return found;
+  }
+  return null;
+}
+
+/** Check if a node ID on the stack belongs to a container type (struct/enum/union/opaque). */
+function isInsideContainer(nodeStack: readonly string[], nodes: ReadonlyArray<{ id: string; kind: string }>): boolean {
+  if (nodeStack.length === 0) return false;
+  const parentId = nodeStack[nodeStack.length - 1];
+  if (!parentId) return false;
+  const parentNode = nodes.find((n) => n.id === parentId);
+  if (!parentNode) return false;
+  return parentNode.kind === 'struct' || parentNode.kind === 'enum' ||
+    parentNode.kind === 'class' || parentNode.kind === 'interface' ||
+    parentNode.kind === 'trait' || parentNode.kind === 'module';
+}
+
+/** Walk a function/method body to extract call references, resolving chained field chains. */
+function walkBodyForCalls(body: SyntaxNode, functionId: string, ctx: ExtractorContext): void {
+  const visit = (node: SyntaxNode): void => {
+    if (node.type === 'call_expression') {
+      const func = node.namedChild(0);
+      if (!func) return;
+      let calleeName: string;
+      if (func.type === 'field_expression') {
+        calleeName = buildFieldChain(func, ctx.source);
+      } else if (func.type === 'identifier') {
+        calleeName = getNodeText(func, ctx.source);
+      } else {
+        calleeName = ctx.source.substring(func.startIndex, func.endIndex);
+      }
+      if (calleeName) {
+        ctx.addUnresolvedReference({
+          fromNodeId: functionId,
+          referenceName: calleeName,
+          referenceKind: 'calls',
+          line: node.startPosition.row + 1,
+          column: node.startPosition.column,
+        });
+      }
+    } else if (INSTANTIATION_KINDS.has(node.type)) {
+      const typeNode = getChildByField(node, 'type') ?? getChildByField(node, 'constructor') ?? node.namedChild(0);
+      if (typeNode) {
+        let name = getNodeText(typeNode, ctx.source);
+        const lt = name.indexOf('<');
+        if (lt > 0) name = name.slice(0, lt);
+        ctx.addUnresolvedReference({
+          fromNodeId: functionId,
+          referenceName: name,
+          referenceKind: 'instantiates',
+          line: node.startPosition.row + 1,
+          column: node.startPosition.column,
+        });
+      }
+    }
+    // Recurse into all children for nested calls
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) visit(child);
+    }
+  };
+  visit(body);
+}
+
+function extractFnName(node: SyntaxNode, source: string): string {
+  const nameField = getChildByField(node, 'name');
+  if (nameField) return getNodeText(nameField, source);
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child?.type === 'identifier') return getNodeText(child, source);
+  }
+  return '';
+}
+
+function findFnBody(node: SyntaxNode): SyntaxNode | null {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child?.type === 'block') return child;
+  }
+  return null;
+}
+
+function extractFnSignature(node: SyntaxNode, source: string): string | undefined {
+  let paramsNode: SyntaxNode | null = null;
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child?.type === 'parameters') { paramsNode = child; break; }
+  }
+  const returnType = getChildByField(node, 'type');
+  let sig = paramsNode ? getNodeText(paramsNode, source) : '';
+  if (returnType) sig += ' ' + getNodeText(returnType, source);
+  return sig.trim() || undefined;
+}
+
 export const zigExtractor: LanguageExtractor = {
   functionTypes: ['function_declaration'],
   classTypes: [],
   methodTypes: ['function_declaration'],
   interfaceTypes: [],
   structTypes: [
-    'struct_declaration',
-    'enum_declaration',
-    'union_declaration',
-    'opaque_declaration',
-    'error_set_declaration',
+    'struct_declaration', 'enum_declaration', 'union_declaration',
+    'opaque_declaration', 'error_set_declaration',
   ],
   enumTypes: [],
   typeAliasTypes: [],
@@ -62,32 +176,47 @@ export const zigExtractor: LanguageExtractor = {
     return 'struct';
   },
 
-  getVisibility: (node) => (hasKeyword(node, 'pub') ? 'public' : 'private'),
+  getVisibility: (node) => {
+    if (hasKeyword(node, 'pub') || hasKeyword(node, 'export')) return 'public';
+    return 'private';
+  },
 
-  isExported: (node) => hasKeyword(node, 'pub'),
+  isExported: (node) => hasKeyword(node, 'pub') || hasKeyword(node, 'export'),
 
   isConst: (node) => hasKeyword(node, 'const'),
 
-  getSignature: (node, source) => {
-    // tree-sitter-zig doesn't expose 'parameters' as a named field on
-    // function_declaration — find the parameters node among named children.
-    let paramsNode: SyntaxNode | null = null;
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const child = node.namedChild(i);
-      if (child?.type === 'parameters') {
-        paramsNode = child;
-        break;
-      }
-    }
-    const returnType = getChildByField(node, 'type');
-    let sig = paramsNode ? getNodeText(paramsNode, source) : '';
-    if (returnType) sig += ' ' + getNodeText(returnType, source);
-    return sig.trim() || undefined;
-  },
+  getSignature: (node, source) => extractFnSignature(node, source),
 
   visitNode: (node, ctx) => {
-    // Named type declarations: const Foo = struct { ... }; etc.
-    // The variable_declaration wraps a type declaration as its value.
+    // ---------- function_declaration (including methods) ----------
+    // Handled entirely in visitNode because the core's visitFunctionBody
+    // bypasses this hook when walking call expressions, and the default
+    // extractCall cannot resolve nested field_expression chains
+    // (e.g. std.debug.print resolves to just "print").
+    if (node.type === 'function_declaration') {
+      const name = extractFnName(node, ctx.source);
+      const body = findFnBody(node);
+      if (!name || !body) return false;
+
+      const isMethod = isInsideContainer(ctx.nodeStack, ctx.nodes);
+      const kind = isMethod ? 'method' : 'function';
+      const isPub = hasKeyword(node, 'pub');
+      const isExport = hasKeyword(node, 'export');
+
+      const fnNode = ctx.createNode(kind, name, node, {
+        signature: extractFnSignature(node, ctx.source),
+        visibility: (isPub || isExport) ? 'public' : 'private',
+        isExported: isPub || isExport,
+      });
+      if (!fnNode) return true;
+
+      ctx.pushScope(fnNode.id);
+      walkBodyForCalls(body, fnNode.id, ctx);
+      ctx.popScope();
+      return true;
+    }
+
+    // ---------- variable_declaration ----------
     if (node.type === 'variable_declaration') {
       let name = '';
       let valueNode: SyntaxNode | null = null;
@@ -99,15 +228,13 @@ export const zigExtractor: LanguageExtractor = {
           name = getNodeText(child, ctx.source);
           continue;
         }
-        if (name && !valueNode) {
-          valueNode = findTypeDeclaration(child);
-        }
+        if (name && !valueNode) valueNode = findTypeDeclaration(child);
       }
 
+      // Named type: const Foo = struct/enum/union/opaque { ... };
       if (name && valueNode) {
         const isPub = hasKeyword(node, 'pub');
-        const isEnum =
-          valueNode.type === 'enum_declaration' || valueNode.type === 'error_set_declaration';
+        const isEnum = valueNode.type === 'enum_declaration' || valueNode.type === 'error_set_declaration';
         const kind = isEnum ? 'enum' : 'struct';
 
         const typeNode = ctx.createNode(kind, name, node, {
@@ -123,7 +250,8 @@ export const zigExtractor: LanguageExtractor = {
           if (child.type === 'container_field' && isEnum) {
             const nameField = getChildByField(child, 'name');
             if (nameField) {
-              ctx.createNode('enum_member', getNodeText(nameField, ctx.source), child);
+              const memberName = getNodeText(nameField, ctx.source);
+              if (memberName !== '_') ctx.createNode('enum_member', memberName, child);
             }
           } else {
             ctx.visitNode(child);
@@ -133,21 +261,21 @@ export const zigExtractor: LanguageExtractor = {
         return true;
       }
 
-      // Check if this variable wraps @import("...") — the value is a
-      // builtin_function that extractVariable won't descend into.
+      // @import — may be direct or nested inside field_expression
       for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
         if (!child) continue;
-        if (child.type === 'builtin_function') {
-          const text = ctx.source.substring(child.startIndex, child.endIndex);
+        const importNode = findImportBuiltin(child, ctx.source);
+        if (importNode) {
+          const text = ctx.source.substring(importNode.startIndex, importNode.endIndex);
           const m = text.match(/@import\s*\(\s*"([^"]+)"\s*\)/);
           if (m) {
             ctx.addUnresolvedReference({
               fromNodeId: ctx.nodeStack[ctx.nodeStack.length - 1] || '',
               referenceName: m[1],
               referenceKind: 'imports',
-              line: child.startPosition.row + 1,
-              column: child.startPosition.column,
+              line: importNode.startPosition.row + 1,
+              column: importNode.startPosition.column,
             });
           }
         }
@@ -155,8 +283,53 @@ export const zigExtractor: LanguageExtractor = {
       return false;
     }
 
-    // @import("...") builtins — emit an imports reference.
-    // tree-sitter-zig parses @import as builtin_function, not call_expression.
+    // ---------- test_declaration ----------
+    if (node.type === 'test_declaration') {
+      let testName = '';
+      let body: SyntaxNode | null = null;
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child) continue;
+        if (!testName && child.type === 'string') {
+          testName = ctx.source.substring(child.startIndex + 1, child.endIndex - 1);
+        } else if (!testName && child.type === 'identifier') {
+          testName = getNodeText(child, ctx.source);
+        }
+        if (child.type === 'block') body = child;
+      }
+      if (testName && body) {
+        const fnNode = ctx.createNode('function', testName, node, {
+          visibility: 'private',
+          isExported: false,
+        });
+        if (fnNode) {
+          ctx.pushScope(fnNode.id);
+          walkBodyForCalls(body, fnNode.id, ctx);
+          ctx.popScope();
+        }
+      }
+      return true;
+    }
+
+    // ---------- comptime_declaration ----------
+    if (node.type === 'comptime_declaration') {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child) ctx.visitNode(child);
+      }
+      return true;
+    }
+
+    // ---------- using_namespace_declaration ----------
+    if (node.type === 'using_namespace_declaration') {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child) ctx.visitNode(child);
+      }
+      return true;
+    }
+
+    // ---------- @import builtins (standalone, not inside a variable) ----------
     if (node.type === 'call_expression' || node.type === 'builtin_function') {
       const text = ctx.source.substring(node.startIndex, node.endIndex);
       const m = text.match(/@import\s*\(\s*"([^"]+)"\s*\)/);

From 4266d219c5578e9ebe981c47936367132f2aa30c Mon Sep 17 00:00:00 2001
From: wandl-6A72h <hiwepy@gmail.com>
Date: Sun, 7 Jun 2026 15:50:21 +0800
Subject: [PATCH 03/10] chore: bump version to 0.9.10, fix TS strict null check
 in zig.ts

---
 package.json                    | 2 +-
 src/extraction/languages/zig.ts | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index c1ef34d36..710ed6ac4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@colbymchenry/codegraph",
-  "version": "0.9.9",
+  "version": "0.9.10",
   "description": "Supercharge Claude Code with semantic code intelligence. 94% fewer tool calls • 77% faster exploration • 100% local.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
diff --git a/src/extraction/languages/zig.ts b/src/extraction/languages/zig.ts
index 238e82e22..e067d2479 100644
--- a/src/extraction/languages/zig.ts
+++ b/src/extraction/languages/zig.ts
@@ -272,7 +272,7 @@ export const zigExtractor: LanguageExtractor = {
           if (m) {
             ctx.addUnresolvedReference({
               fromNodeId: ctx.nodeStack[ctx.nodeStack.length - 1] || '',
-              referenceName: m[1],
+              referenceName: m[1]!,
               referenceKind: 'imports',
               line: importNode.startPosition.row + 1,
               column: importNode.startPosition.column,
@@ -338,7 +338,7 @@ export const zigExtractor: LanguageExtractor = {
         if (parentId) {
           ctx.addUnresolvedReference({
             fromNodeId: parentId,
-            referenceName: m[1],
+            referenceName: m[1]!,
             referenceKind: 'imports',
             line: node.startPosition.row + 1,
             column: node.startPosition.column,

From 82433db04fdeec82358be8ef97157fb61703107e Mon Sep 17 00:00:00 2001
From: wandl-6A72h <hiwepy@gmail.com>
Date: Sun, 7 Jun 2026 16:15:23 +0800
Subject: [PATCH 04/10] fix(zig): add Zig stdlib detection to
 isBuiltInOrExternal

Prevent false-positive resolution of Zig stdlib calls (std.debug.print,
std.mem.eql, etc.) by treating the `std.`, `builtin.`, and `@`-prefixed
namespaces as external. Without this, the resolver matches e.g.
`std.debug.print` to an unrelated project node named "print", creating
incorrect call edges.

Also treats `root` module references as external.

This matches the existing patterns for Go (GO_STDLIB_PACKAGES), Python
(PYTHON_BUILT_INS), C/C++ (C_BUILT_INS/CPP_BUILT_INS), and Pascal
(PASCAL_BUILT_INS).
---
 src/resolution/index.ts | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/resolution/index.ts b/src/resolution/index.ts
index 9d580d363..e2c108d24 100644
--- a/src/resolution/index.ts
+++ b/src/resolution/index.ts
@@ -957,6 +957,19 @@ export class ReferenceResolver {
       }
     }
 
+    // Zig standard library and builtins. The `std` namespace and `@`-prefixed
+    // builtin functions are always external — no project declares symbols there.
+    if (ref.language === 'zig') {
+      // @-prefixed compiler builtins: @import, @sizeOf, @intFromPtr, etc.
+      if (name.startsWith('@')) return true;
+      // std library namespace: std.debug.print, std.mem.eql, std.ArrayList, etc.
+      if (name.startsWith('std.')) return true;
+      // builtin module: builtin.is_test, builtin.mode, etc.
+      if (name.startsWith('builtin.')) return true;
+      // root module reference
+      if (name === 'root') return true;
+    }
+
     return false;
   }
 

From 42bbfa74f5ff219c7ef2db52034021883ccabd92 Mon Sep 17 00:00:00 2001
From: wandl-6A72h <hiwepy@gmail.com>
Date: Sun, 7 Jun 2026 18:37:02 +0800
Subject: [PATCH 05/10] feat(zig): add references edges for type annotations
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Enable type-annotation-based `references` edges for Zig, matching the
pattern used by Java, TypeScript, Go, Rust, and other languages.

- Add `zig` to TYPE_ANNOTATION_LANGUAGES so the core extractor's
  extractTypeAnnotations path runs for Zig function/method/field nodes
- Add extractZigTypeAnnotations to handle Zig-specific AST:
  `parameters` is not a named field, type names are `identifier` nodes
- Add extractZigTypeRefs in zig.ts for the visitNode hook path
  (the hook handles function_declaration, bypassing the core extractor)
- Filter parameter-name identifiers (self, allocator, etc.) from
  type references by skipping the first identifier in `parameter` nodes
- Filter module-path segments in field_expression chains
  (std.mem.Allocator → only Allocator is a type reference)
- Add extractZigTypeRefsFromSubtree in tree-sitter.ts with the same
  filtering for the core extractor path (struct field types via
  container_field)

Results on agentscope-zig (719 files):
  Before: 27,515 edges (contains 15,830 + calls 9,553 + imports 2,132)
  After:  34,976 edges (contains 16,311 + calls 9,704 + references 6,790 + imports 2,171)
  Edges/file: 40.6 → 49.2 (+21%)
  References/file: 9.4 (Java: 7.3)
---
 src/extraction/languages/zig.ts | 61 +++++++++++++++++++++++
 src/extraction/tree-sitter.ts   | 85 ++++++++++++++++++++++++++++++++-
 2 files changed, 145 insertions(+), 1 deletion(-)

diff --git a/src/extraction/languages/zig.ts b/src/extraction/languages/zig.ts
index e067d2479..d93b11752 100644
--- a/src/extraction/languages/zig.ts
+++ b/src/extraction/languages/zig.ts
@@ -151,6 +151,66 @@ function extractFnSignature(node: SyntaxNode, source: string): string | undefine
   return sig.trim() || undefined;
 }
 
+/** Walk a Zig type subtree to find custom type identifiers, emitting `references`. */
+function extractZigTypeRefs(node: SyntaxNode, fromNodeId: string, ctx: ExtractorContext): void {
+  if (node.type === 'builtin_type') return;
+  if (node.type === 'parameter') {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child || child.type === 'identifier') continue;
+      extractZigTypeRefs(child, fromNodeId, ctx);
+    }
+    return;
+  }
+  // field_expression like `std.mem.Allocator`: only the last identifier
+  // (`Allocator`) is the type — skip the module-path segments (`std`, `mem`).
+  if (node.type === 'field_expression') {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child) continue;
+      // The `object` part is the namespace chain — only recurse, don't emit
+      if (child.type === 'field_expression' || child.type === 'identifier') {
+        const fieldName = node.fieldNameForNamedChild(i);
+        if (fieldName === 'object') continue; // module path, not a type ref
+        extractZigTypeRefs(child, fromNodeId, ctx);
+      } else {
+        extractZigTypeRefs(child, fromNodeId, ctx);
+      }
+    }
+    return;
+  }
+  if (node.type === 'identifier') {
+    ctx.addUnresolvedReference({
+      fromNodeId,
+      referenceName: getNodeText(node, ctx.source),
+      referenceKind: 'references',
+      line: node.startPosition.row + 1,
+      column: node.startPosition.column,
+    });
+    return;
+  }
+  if (node.type === 'anonymous_struct_initializer' || node.type === 'struct_initializer') return;
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child) extractZigTypeRefs(child, fromNodeId, ctx);
+  }
+}
+
+/** Extract type references from a Zig function_declaration's parameters and return type. */
+function extractFnTypeRefs(node: SyntaxNode, nodeId: string, ctx: ExtractorContext): void {
+  // Parameters — not a named field in tree-sitter-zig
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child?.type === 'parameters') {
+      extractZigTypeRefs(child, nodeId, ctx);
+      break;
+    }
+  }
+  // Return type — the `type` named field
+  const returnType = getChildByField(node, 'type');
+  if (returnType) extractZigTypeRefs(returnType, nodeId, ctx);
+}
+
 export const zigExtractor: LanguageExtractor = {
   functionTypes: ['function_declaration'],
   classTypes: [],
@@ -212,6 +272,7 @@ export const zigExtractor: LanguageExtractor = {
 
       ctx.pushScope(fnNode.id);
       walkBodyForCalls(body, fnNode.id, ctx);
+      extractFnTypeRefs(node, fnNode.id, ctx);
       ctx.popScope();
       return true;
     }
diff --git a/src/extraction/tree-sitter.ts b/src/extraction/tree-sitter.ts
index 0ad6c2d59..4e0f41cf0 100644
--- a/src/extraction/tree-sitter.ts
+++ b/src/extraction/tree-sitter.ts
@@ -3345,7 +3345,7 @@ export class TreeSitterExtractor {
    * Languages that support type annotations (TypeScript, etc.)
    */
   private readonly TYPE_ANNOTATION_LANGUAGES = new Set([
-    'typescript', 'tsx', 'dart', 'kotlin', 'swift', 'rust', 'go', 'java', 'csharp', 'scala', 'php',
+    'typescript', 'tsx', 'dart', 'kotlin', 'swift', 'rust', 'go', 'java', 'csharp', 'scala', 'php', 'zig',
   ]);
 
   /**
@@ -3406,6 +3406,14 @@ export class TreeSitterExtractor {
       return;
     }
 
+    // Zig: tree-sitter-zig uses `identifier` (not `type_identifier`) for type
+    // names, and `parameters` is not a named field on `function_declaration`.
+    // Walk parameter and return-type subtrees with Zig-aware type node detection.
+    if (this.language === 'zig') {
+      this.extractZigTypeAnnotations(node, nodeId);
+      return;
+    }
+
     // Dart: a `method_signature` wraps the real `function_signature` (where the
     // params and return type live), and the return type is a bare
     // `type_identifier` child, not a `type` field — so getChildByField below
@@ -3680,6 +3688,81 @@ export class TreeSitterExtractor {
     }
   }
 
+  /**
+   * Zig-aware type annotation extraction. tree-sitter-zig uses `identifier`
+   * (not `type_identifier`) for type names, and `parameters` is not a named
+   * field on `function_declaration`. Walk parameter and return-type subtrees,
+   * emitting `references` edges for custom types while skipping builtin_type
+   * (i32, bool, void, etc.) and pointer/slice/array wrappers.
+   */
+  private extractZigTypeAnnotations(node: SyntaxNode, nodeId: string): void {
+    // Find the parameters child (not a named field in tree-sitter-zig)
+    let paramsNode: SyntaxNode | null = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child?.type === 'parameters') { paramsNode = child; break; }
+    }
+    if (paramsNode) {
+      this.extractZigTypeRefsFromSubtree(paramsNode, nodeId);
+    }
+    // Return type — the `type` field on function_declaration
+    const returnType = getChildByField(node, 'type');
+    if (returnType) {
+      this.extractZigTypeRefsFromSubtree(returnType, nodeId);
+    }
+  }
+
+  /**
+   * Walk a type subtree for Zig, emitting `references` for custom type names.
+   * Skips `builtin_type` (i32, bool, void, etc.), pointer_type, slice_type,
+   * array_type, optional_type, and error_union_type wrappers — only the
+   * embedded custom type identifiers become references.
+   */
+  private extractZigTypeRefsFromSubtree(node: SyntaxNode, fromNodeId: string): void {
+    if (node.type === 'builtin_type') return;
+    if (node.type === 'parameter') {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child || child.type === 'identifier') continue;
+        this.extractZigTypeRefsFromSubtree(child, fromNodeId);
+      }
+      return;
+    }
+    // field_expression: only the last identifier (the member) is the type —
+    // skip module-path segments in the `object` position.
+    if (node.type === 'field_expression') {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child) continue;
+        if (child.type === 'field_expression' || child.type === 'identifier') {
+          if (node.fieldNameForNamedChild(i) === 'object') continue;
+          this.extractZigTypeRefsFromSubtree(child, fromNodeId);
+        } else {
+          this.extractZigTypeRefsFromSubtree(child, fromNodeId);
+        }
+      }
+      return;
+    }
+    if (node.type === 'identifier') {
+      const typeName = getNodeText(node, this.source);
+      if (typeName && !this.BUILTIN_TYPES.has(typeName)) {
+        this.unresolvedReferences.push({
+          fromNodeId,
+          referenceName: typeName,
+          referenceKind: 'references',
+          line: node.startPosition.row + 1,
+          column: node.startPosition.column,
+        });
+      }
+      return;
+    }
+    if (node.type === 'anonymous_struct_initializer' || node.type === 'struct_initializer') return;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) this.extractZigTypeRefsFromSubtree(child, fromNodeId);
+    }
+  }
+
   /**
    * Handle Pascal-specific AST structures.
    * Returns true if the node was fully handled and children should be skipped.

From 2b7c67bdcb4cc00413486416ad1b9f31cd0f8f91 Mon Sep 17 00:00:00 2001
From: wandl-6A72h <hiwepy@gmail.com>
Date: Sun, 7 Jun 2026 19:03:14 +0800
Subject: [PATCH 06/10] fix(zig): resolve self/this method calls and track
 builtin functions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add builtin_function handling to walkBodyForCalls: non-@import builtins
  (@as, @ptrCast, @intCast, @sizeOf, @memcpy, @min, @max, etc.) now
  produce call references instead of being silently skipped
- Strip self/this/super receiver prefix from field_expression call chains
  so self.beforeAgentExecution() resolves to "beforeAgentExecution"
  (matches the core extractCall behavior for other languages)
- The SKIP_RECEIVERS filter in buildFieldChain mirrors the core's
  calibration for Java (this), Python (self/cls), and ObjC (self/super)

Results on agentscope-zig (719 files):
  calls:    9,704 → 10,045 (+341, +3.5%)
  total:   34,976 → 35,900 (+924, +2.6%)
  ReActAgent::call: 3 calls → 6 calls (all correct)
---
 src/extraction/languages/zig.ts | 25 ++++++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/src/extraction/languages/zig.ts b/src/extraction/languages/zig.ts
index d93b11752..fecdda376 100644
--- a/src/extraction/languages/zig.ts
+++ b/src/extraction/languages/zig.ts
@@ -44,7 +44,14 @@ function buildFieldChain(node: SyntaxNode, source: string): string {
     return buildFieldChain(object, source) + '.' + memberName;
   }
   const objectName = object ? getNodeText(object, source) : '';
-  if (objectName && memberName) return objectName + '.' + memberName;
+  if (objectName && memberName) {
+    // Skip `self`/`this`/`super` receivers — these are method-call
+    // conventions, not real type names. The bare method name is used
+    // so the resolver can match it against the enclosing container.
+    const SKIP_RECEIVERS = new Set(['self', 'this', 'super']);
+    if (SKIP_RECEIVERS.has(objectName)) return memberName;
+    return objectName + '.' + memberName;
+  }
   return objectName || memberName;
 }
 
@@ -97,6 +104,22 @@ function walkBodyForCalls(body: SyntaxNode, functionId: string, ctx: ExtractorCo
           column: node.startPosition.column,
         });
       }
+    } else if (node.type === 'builtin_function') {
+      // @as, @ptrCast, @sizeOf, @intCast, etc. (non-@import builtins)
+      const text = ctx.source.substring(node.startIndex, Math.min(node.endIndex, node.startIndex + 40));
+      if (!/@import\s*\(/.test(text)) {
+        // Extract the builtin name: @foo or @"foo"
+        const m = text.match(/^@[a-zA-Z_]\w*/);
+        if (m) {
+          ctx.addUnresolvedReference({
+            fromNodeId: functionId,
+            referenceName: m[0],
+            referenceKind: 'calls',
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+          });
+        }
+      }
     } else if (INSTANTIATION_KINDS.has(node.type)) {
       const typeNode = getChildByField(node, 'type') ?? getChildByField(node, 'constructor') ?? node.namedChild(0);
       if (typeNode) {

From a08c5a2114993ddd6c12d1c7e4d0dde6f2d8f6fc Mon Sep 17 00:00:00 2001
From: wandl-6A72h <hiwepy@gmail.com>
Date: Sun, 7 Jun 2026 19:19:28 +0800
Subject: [PATCH 07/10] feat(zig): create import nodes for @import (like Java's
 import nodes)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the `constant` node creation for @import with proper `import`
nodes that mirror Java's import tracking structure:

- Each @import("module") now creates an `import` node (name = module path)
  with the full declaration as signature
- The unresolved `imports` reference connects from the import node to the
  module name (instead of from the file node directly)
- The visitNode hook returns `true` for @import variables, skipping the
  core's extractVariable (which would create a duplicate `constant` node)

This makes the Zig node/edge structure structurally equivalent to Java:
  import nodes: 0 → 2,167
  constant nodes: 2,645 → 559 (only real constants now)
---
 src/extraction/languages/zig.ts | 37 ++++++++++++++++++++++-----------
 1 file changed, 25 insertions(+), 12 deletions(-)

diff --git a/src/extraction/languages/zig.ts b/src/extraction/languages/zig.ts
index fecdda376..2127fe7a3 100644
--- a/src/extraction/languages/zig.ts
+++ b/src/extraction/languages/zig.ts
@@ -345,7 +345,10 @@ export const zigExtractor: LanguageExtractor = {
         return true;
       }
 
-      // @import — may be direct or nested inside field_expression
+      // @import — may be direct or nested inside field_expression.
+      // Create an `import` node (like Java) for each @import, plus an
+      // unresolved `imports` reference. Return `true` to skip the core's
+      // extractVariable (avoids duplicate `constant` node).
       for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
         if (!child) continue;
@@ -354,16 +357,25 @@ export const zigExtractor: LanguageExtractor = {
           const text = ctx.source.substring(importNode.startIndex, importNode.endIndex);
           const m = text.match(/@import\s*\(\s*"([^"]+)"\s*\)/);
           if (m) {
-            ctx.addUnresolvedReference({
-              fromNodeId: ctx.nodeStack[ctx.nodeStack.length - 1] || '',
-              referenceName: m[1]!,
-              referenceKind: 'imports',
-              line: importNode.startPosition.row + 1,
-              column: importNode.startPosition.column,
-            });
+            const moduleName = m[1]!;
+            const sig = ctx.source.substring(node.startIndex, Math.min(node.endIndex, node.startIndex + 80)).trim();
+            const importId = ctx.createNode('import', moduleName, node, { signature: sig });
+            if (importId) {
+              ctx.addUnresolvedReference({
+                fromNodeId: importId.id,
+                referenceName: moduleName,
+                referenceKind: 'imports',
+                line: importNode.startPosition.row + 1,
+                column: importNode.startPosition.column,
+              });
+            }
           }
         }
       }
+      // Skip core's extractVariable if we found an @import
+      for (let i = 0; i < node.namedChildCount; i++) {
+        if (node.namedChild(i) && findImportBuiltin(node.namedChild(i)!, ctx.source)) return true;
+      }
       return false;
     }
 
@@ -418,11 +430,12 @@ export const zigExtractor: LanguageExtractor = {
       const text = ctx.source.substring(node.startIndex, node.endIndex);
       const m = text.match(/@import\s*\(\s*"([^"]+)"\s*\)/);
       if (m) {
-        const parentId = ctx.nodeStack[ctx.nodeStack.length - 1];
-        if (parentId) {
+        const moduleName = m[1]!;
+        const importId = ctx.createNode('import', moduleName, node, { signature: text.trim() });
+        if (importId) {
           ctx.addUnresolvedReference({
-            fromNodeId: parentId,
-            referenceName: m[1]!,
+            fromNodeId: importId.id,
+            referenceName: moduleName,
             referenceKind: 'imports',
             line: node.startPosition.row + 1,
             column: node.startPosition.column,

From e570a63588f5313f0824160d7437770db2d151da Mon Sep 17 00:00:00 2001
From: wandl-6A72h <hiwepy@gmail.com>
Date: Sun, 7 Jun 2026 19:29:41 +0800
Subject: [PATCH 08/10] feat(zig): add type_alias nodes and instantiates edges
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- type_alias nodes: detect `const Name = type_expression;` patterns
  (function pointer aliases, simple type aliases) by checking for
  exactly 2 named children where the second is a type-expression node
  (pointer_type, builtin_type, function_signature, etc.) and not a
  value literal (integer/string/call). Creates a `type_alias` node
  instead of the generic `constant` that the core would produce.
- instantiates edges: handle `struct_initializer` (Foo{} or Foo{.x=1})
  nodes in walkBodyForCalls, extracting the type name from the first
  identifier child and creating an `instantiates` unresolved reference.

Results on agentscope-zig (780 files):
  nodes:    17,567 → 18,820 (+1,253)
  edges:    35,855 → 39,245 (+3,390)
  type_alias: 250 NEW
  instantiates: 1,099 NEW
---
 src/extraction/languages/zig.ts | 43 ++++++++++++++++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)

diff --git a/src/extraction/languages/zig.ts b/src/extraction/languages/zig.ts
index 2127fe7a3..c82d8e685 100644
--- a/src/extraction/languages/zig.ts
+++ b/src/extraction/languages/zig.ts
@@ -10,7 +10,14 @@ const ZIG_TYPE_DECL_TYPES = new Set([
   'error_set_declaration',
 ]);
 
-const INSTANTIATION_KINDS = new Set(['new_expression', 'object_creation_expression']);
+const INSTANTIATION_KINDS = new Set(['struct_initializer']);
+
+/** Type-expression node types that indicate a type alias (not a struct/enum/opaque). */
+const TYPE_ALIAS_NODE_TYPES = new Set([
+  'pointer_type', 'fn', 'function_signature', 'builtin_type',
+  'slice_type', 'array_type', 'optional_type', 'error_union_type',
+  'field_expression', 'identifier', 'type_expression', 'primary_type_expression',
+]);
 
 function hasKeyword(node: SyntaxNode, keyword: string): boolean {
   for (let i = 0; i < node.childCount; i++) {
@@ -121,6 +128,21 @@ function walkBodyForCalls(body: SyntaxNode, functionId: string, ctx: ExtractorCo
         }
       }
     } else if (INSTANTIATION_KINDS.has(node.type)) {
+      // struct_initializer: Foo{} or Foo{.x=1} → instantiates Foo
+      const typeId = node.namedChild(0);
+      if (typeId?.type === 'identifier') {
+        const typeName = getNodeText(typeId, ctx.source);
+        if (typeName) {
+          ctx.addUnresolvedReference({
+            fromNodeId: functionId,
+            referenceName: typeName,
+            referenceKind: 'instantiates',
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+          });
+        }
+      }
+    } else if (node.type === 'anonymous_struct_initializer') {
       const typeNode = getChildByField(node, 'type') ?? getChildByField(node, 'constructor') ?? node.namedChild(0);
       if (typeNode) {
         let name = getNodeText(typeNode, ctx.source);
@@ -376,6 +398,25 @@ export const zigExtractor: LanguageExtractor = {
       for (let i = 0; i < node.namedChildCount; i++) {
         if (node.namedChild(i) && findImportBuiltin(node.namedChild(i)!, ctx.source)) return true;
       }
+
+      // Type alias: const Name = type_expression (not a struct/enum/opaque).
+      // e.g. `pub const Callback = *const fn() void;` or `pub const MyInt = i32;`
+      // Distinguished from a regular constant by having exactly 2 named children
+      // (identifier + type expression) with NO value literal (integer/string/call).
+      const VALUE_LITERAL_TYPES = new Set(['integer', 'string', 'float', 'boolean', 'call_expression', 'struct_initializer', 'anonymous_struct_initializer']);
+      if (name && !valueNode && !hasKeyword(node, 'var') && node.namedChildCount === 2) {
+        const second = node.namedChild(1);
+        if (second && TYPE_ALIAS_NODE_TYPES.has(second.type) && !VALUE_LITERAL_TYPES.has(second.type)) {
+          const isPub = hasKeyword(node, 'pub');
+          ctx.createNode('type_alias', name, node, {
+            visibility: isPub ? 'public' : 'private',
+            isExported: isPub,
+            signature: ctx.source.substring(second.startIndex, Math.min(second.endIndex, second.startIndex + 60)).trim(),
+          });
+          return true;
+        }
+      }
+
       return false;
     }
 

From 08d5308588362366c68b1228d307b977e284be96 Mon Sep 17 00:00:00 2001
From: wandl-6A72h <hiwepy@gmail.com>
Date: Tue, 9 Jun 2026 03:22:50 +0800
Subject: [PATCH 09/10] feat(zig): structural refactor, tagged union metadata,
 inline/noinline/callconv
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Restructure the Zig extractor to match the Kotlin pattern:
- Split 330-line visitNode into 8 named handler functions + 24-line switch dispatcher
- Implement extractModifiers hook (inline/noinline/comptime)
- Add tagged union metadata ({ taggedUnion: true }) + enum_member extraction for union(enum) variants
- Capture calling_convention in function signatures (callconv(.C))
- Mark inline/noinline functions in metadata
- Fix fromNodeId: 'standalone' → importId.id for @embedFile/@cImport references
- Remove dead Zig type extraction methods from tree-sitter.ts (-75 lines)
- Add 20 new tests: defer/errdefer/try/catch/for/while/labeled block/switch/orelse call tracking, .zon files, anonymous struct literals, extern fn, module docs, destructuring, C variadic

Validated on agentscope-zig (1413 Zig files): agent A/B n=2 shows 0 Read/0 Grep, 62-72% faster than without codegraph.
---
 __tests__/zig-extraction.test.ts | 488 ++++++++++++++++++
 src/extraction/languages/zig.ts  | 816 +++++++++++++++++++++----------
 src/extraction/tree-sitter.ts    |  82 ----
 3 files changed, 1038 insertions(+), 348 deletions(-)

diff --git a/__tests__/zig-extraction.test.ts b/__tests__/zig-extraction.test.ts
index 9c1f14c06..c2765bb23 100644
--- a/__tests__/zig-extraction.test.ts
+++ b/__tests__/zig-extraction.test.ts
@@ -153,6 +153,23 @@ const Value = union(enum) {
     expect(structs.some((s) => s.name === 'Value')).toBe(true);
   });
 
+  it('should mark tagged union with metadata and extract enum members', () => {
+    const code = `
+const Value = union(enum) {
+    int: i32,
+    float: f64,
+    str: []const u8,
+};
+`;
+    const result = extractFromSource('tagged_union.zig', code);
+    const valueNode = result.nodes.find((n) => n.name === 'Value');
+    expect(valueNode).toBeDefined();
+    expect(valueNode?.metadata?.taggedUnion).toBe(true);
+    const members = result.nodes.filter((n) => n.kind === 'enum_member');
+    const names = members.map((m) => m.name).sort();
+    expect(names).toEqual(['float', 'int', 'str']);
+  });
+
   it('should extract error set declaration', () => {
     const code = `
 const MyError = error{
@@ -474,3 +491,474 @@ usingnamespace @import("foo");
     expect(refs.some((r) => r.referenceName === 'foo')).toBe(true);
   });
 });
+
+describe('Zig Container Field Type References', () => {
+  it('should emit references edges for custom types on struct fields', () => {
+    const code = `
+const Allocator = struct { alloc: u8 };
+const Config = struct {
+    allocator: Allocator,
+    port: u16,
+};
+`;
+    const result = extractFromSource('fields.zig', code);
+    const refs = result.unresolvedReferences.filter(
+      (r) => r.referenceKind === 'references' && r.referenceName === 'Allocator'
+    );
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should NOT emit references for builtin types on fields', () => {
+    const code = `
+const Config = struct {
+    port: u16,
+    host: []const u8,
+};
+`;
+    const result = extractFromSource('builtin_fields.zig', code);
+    const refs = result.unresolvedReferences.filter(
+      (r) => r.referenceKind === 'references' && (r.referenceName === 'u16' || r.referenceName === 'u8')
+    );
+    expect(refs.length).toBe(0);
+  });
+
+  it('should extract pointer type references on fields', () => {
+    const code = `
+const Node = struct {
+    next: ?*Node,
+};
+`;
+    const result = extractFromSource('ptr_field.zig', code);
+    const refs = result.unresolvedReferences.filter(
+      (r) => r.referenceKind === 'references' && r.referenceName === 'Node'
+    );
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+  });
+});
+
+describe('Zig @cImport Detection', () => {
+  it('should detect @cImport(@cInclude("header")) and create import node', () => {
+    const code = `
+const c = @cImport(@cInclude("stdio.h"));
+`;
+    const result = extractFromSource('cimport.zig', code);
+    const imports = result.nodes.filter((n) => n.kind === 'import');
+    expect(imports.some((i) => i.name === 'stdio.h')).toBe(true);
+    const refs = result.unresolvedReferences.filter(
+      (r) => r.referenceKind === 'imports' && r.referenceName === 'stdio.h'
+    );
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should detect multiple @cInclude inside @cImport', () => {
+    const code = `
+const c = @cImport({
+    @cInclude("stdio.h");
+    @cInclude("stdlib.h");
+});
+`;
+    const result = extractFromSource('cimport_multi.zig', code);
+    const imports = result.nodes.filter((n) => n.kind === 'import');
+    expect(imports.some((i) => i.name === 'stdio.h')).toBe(true);
+    expect(imports.some((i) => i.name === 'stdlib.h')).toBe(true);
+  });
+});
+
+describe('Zig @call Indirect Function Calls', () => {
+  it('should detect @call(.auto, funcName, .{}) as calls reference', () => {
+    const code = `
+fn foo() void {}
+fn bar() void {
+    const r = @call(.auto, foo, .{});
+    _ = r;
+}
+`;
+    const result = extractFromSource('atcall.zig', code);
+    const calls = result.unresolvedReferences.filter(
+      (r) => r.referenceKind === 'calls' && r.referenceName === 'foo'
+    );
+    expect(calls.length).toBeGreaterThanOrEqual(1);
+  });
+});
+
+describe('Zig @embedFile Detection', () => {
+  it('should detect @embedFile("path") as imports reference', () => {
+    const code = `
+const data = @embedFile("data.txt");
+`;
+    const result = extractFromSource('embedfile.zig', code);
+    const refs = result.unresolvedReferences.filter(
+      (r) => r.referenceKind === 'imports' && r.referenceName === 'data.txt'
+    );
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+  });
+});
+
+describe('Zig Nested Struct Declarations', () => {
+  it('should extract nested struct/enum/union inside containers', () => {
+    const code = `
+const Outer = struct {
+    pub const Inner = struct {
+        pub fn deep() void {}
+    };
+};
+`;
+    const result = extractFromSource('nested.zig', code);
+    const structs = result.nodes.filter((n) => n.kind === 'struct');
+    expect(structs.some((s) => s.name === 'Outer')).toBe(true);
+    expect(structs.some((s) => s.name === 'Inner')).toBe(true);
+    const methods = result.nodes.filter((n) => n.kind === 'method');
+    expect(methods.some((m) => m.name === 'deep')).toBe(true);
+  });
+});
+
+describe('Zig Nullable and Error Union Type References', () => {
+  it('should extract type references from nullable type annotations', () => {
+    const code = `
+const MyType = struct {};
+const maybe: ?MyType = null;
+`;
+    const result = extractFromSource('nullable_ref.zig', code);
+    const refs = result.unresolvedReferences.filter(
+      (r) => r.referenceKind === 'references' && r.referenceName === 'MyType'
+    );
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should extract type references from error union type annotations', () => {
+    const code = `
+const MyError = error{Fail};
+pub fn foo() !MyError {
+    return error.Fail;
+}
+`;
+    const result = extractFromSource('errunion_ref.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.some((f) => f.name === 'foo')).toBe(true);
+  });
+});
+
+describe('Zig Function Type Annotations', () => {
+  it('should extract type references from function parameter types', () => {
+    const code = `
+const MyStruct = struct {};
+fn process(s: MyStruct) void { _ = s; }
+`;
+    const result = extractFromSource('param_type.zig', code);
+    const refs = result.unresolvedReferences.filter(
+      (r) => r.referenceKind === 'references' && r.referenceName === 'MyStruct'
+    );
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should extract type references from function return types', () => {
+    const code = `
+const Result = struct {};
+fn getResult() Result { return undefined; }
+`;
+    const result = extractFromSource('ret_type.zig', code);
+    const refs = result.unresolvedReferences.filter(
+      (r) => r.referenceKind === 'references' && r.referenceName === 'Result'
+    );
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+  });
+});
+
+describe('Zig Comptime Parameter Detection', () => {
+  it('should detect comptime parameters on functions', () => {
+    const code = `
+fn print(comptime fmt: []const u8, args: anytype) void {
+    _ = fmt;
+    _ = args;
+}
+`;
+    const result = extractFromSource('comptime_param.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(1);
+    expect(funcs[0]?.name).toBe('print');
+  });
+});
+
+// ─── P0: Untested call-in-expression patterns ────────────────────────
+
+describe('Zig defer / errdefer Call Tracking', () => {
+  it('should track calls inside defer expressions', () => {
+    const code = `
+fn cleanup() void {}
+fn doWork() void {
+    defer cleanup();
+    _ = 42;
+}
+`;
+    const result = extractFromSource('defer_call.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'cleanup')).toBe(true);
+  });
+
+  it('should track calls inside errdefer expressions', () => {
+    const code = `
+fn rollback() void {}
+fn risky() !void {
+    errdefer rollback();
+}
+`;
+    const result = extractFromSource('errdefer_call.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'rollback')).toBe(true);
+  });
+});
+
+describe('Zig try Expression Call Tracking', () => {
+  it('should track calls through try expression', () => {
+    const code = `
+fn riskyOp() !void {}
+fn caller() !void {
+    try riskyOp();
+}
+`;
+    const result = extractFromSource('try_call.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'riskyOp')).toBe(true);
+  });
+});
+
+describe('Zig catch Handler Call Tracking', () => {
+  it('should track calls inside catch handler', () => {
+    const code = `
+fn handler(err: anyerror) void { _ = err; }
+fn riskyOp() !i32 { return 0; }
+fn caller() void {
+    _ = riskyOp() catch |e| handler(e);
+}
+`;
+    const result = extractFromSource('catch_handler.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'handler')).toBe(true);
+  });
+});
+
+describe('Zig for Loop Call Tracking', () => {
+  it('should track calls inside for loop body', () => {
+    const code = `
+fn process(x: u32) void { _ = x; }
+fn caller() void {
+    var items = [_]u32{ 1, 2, 3 };
+    for (items) |item| {
+        process(item);
+    }
+}
+`;
+    const result = extractFromSource('for_calls.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'process')).toBe(true);
+  });
+
+  it('should track calls inside for loop with index', () => {
+    const code = `
+fn handle(a: u32, b: usize) void { _ = a; _ = b; }
+fn caller() void {
+    var items = [_]u32{ 1, 2, 3 };
+    for (items, 0..) |item, i| {
+        handle(item, i);
+    }
+}
+`;
+    const result = extractFromSource('for_index_calls.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'handle')).toBe(true);
+  });
+});
+
+describe('Zig while Loop Call Tracking', () => {
+  it('should track calls inside while loop body', () => {
+    const code = `
+fn doWork() void {}
+fn caller() void {
+    var i: u32 = 0;
+    while (i < 10) : (i += 1) {
+        doWork();
+    }
+}
+`;
+    const result = extractFromSource('while_calls.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'doWork')).toBe(true);
+  });
+});
+
+describe('Zig Labeled Block Call Tracking', () => {
+  it('should track calls inside labeled block expressions', () => {
+    const code = `
+fn compute() i32 { return 42; }
+fn caller() void {
+    const result = blk: {
+        const tmp = compute();
+        break :blk tmp;
+    };
+    _ = result;
+}
+`;
+    const result = extractFromSource('labeled_block.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'compute')).toBe(true);
+  });
+});
+
+describe('Zig switch with Payload Call Tracking', () => {
+  it('should track calls inside switch prongs', () => {
+    const code = `
+const Value = union(enum) { a: u32, b: u32 };
+fn handleA(v: u32) void { _ = v; }
+fn handleB(v: u32) void { _ = v; }
+fn caller(val: Value) void {
+    switch (val) {
+        .a => |v| handleA(v),
+        .b => |v| handleB(v),
+    }
+}
+`;
+    const result = extractFromSource('switch_calls.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'handleA')).toBe(true);
+    expect(calls.some((r) => r.referenceName === 'handleB')).toBe(true);
+  });
+});
+
+describe('Zig orelse Expression Call Tracking', () => {
+  it('should track calls in orelse fallback expression', () => {
+    const code = `
+fn fallback() u32 { return 0; }
+fn caller() void {
+    const maybe: ?u32 = null;
+    const val = maybe orelse fallback();
+    _ = val;
+}
+`;
+    const result = extractFromSource('orelse_call.zig', code);
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    expect(calls.some((r) => r.referenceName === 'fallback')).toBe(true);
+  });
+});
+
+// ─── P1: inline/noinline/callconv metadata ───────────────────────────
+
+describe('Zig inline/noinline Function Modifiers', () => {
+  it('should mark inline fn in metadata', () => {
+    const code = `
+inline fn fastPath() void {}
+`;
+    const result = extractFromSource('inline_fn.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(1);
+    expect(funcs[0]?.name).toBe('fastPath');
+    expect(funcs[0]?.metadata?.inline).toBe(true);
+  });
+
+  it('should mark noinline fn in metadata', () => {
+    const code = `
+noinline fn slowPath() void {}
+`;
+    const result = extractFromSource('noinline_fn.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(1);
+    expect(funcs[0]?.name).toBe('slowPath');
+    expect(funcs[0]?.metadata?.noinline).toBe(true);
+  });
+
+  it('should capture callconv in function signature', () => {
+    const code = `
+fn cCallback(data: *anyopaque) callconv(.C) void {
+    _ = data;
+}
+`;
+    const result = extractFromSource('callconv_fn.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(1);
+    expect(funcs[0]?.name).toBe('cCallback');
+    expect(funcs[0]?.signature).toContain('callconv(.C)');
+  });
+});
+
+// ─── P3: .zon, anonymous struct, destructuring, module docs, extern fn ──
+
+describe('Zig .zon File Support', () => {
+  it('should parse declarations from a .zon file', () => {
+    const code = `
+.name = "my-package",
+.version = "0.1.0",
+.paths = .{ "." },
+`;
+    const result = extractFromSource('build.zig.zon', code);
+    // .zon files are parsed as zig — verify no crash and some output
+    expect(result.nodes.length).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe('Zig Anonymous Struct Literal Instantiation', () => {
+  it('should track Type{ .field = val } as instantiation', () => {
+    const code = `
+const Point = struct { x: f64, y: f64 };
+fn makePoint() Point {
+    return Point{ .x = 1.0, .y = 2.0 };
+}
+`;
+    const result = extractFromSource('anon_struct.zig', code);
+    const refs = result.unresolvedReferences.filter((r) => r.referenceKind === 'instantiates');
+    expect(refs.some((r) => r.referenceName === 'Point')).toBe(true);
+  });
+});
+
+describe('Zig extern fn Without Body', () => {
+  it('should extract extern function declaration (no body)', () => {
+    const code = `
+extern fn malloc(size: usize) ?*anyopaque;
+`;
+    const result = extractFromSource('extern_fn.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    // Should extract as a function node even without a body
+    expect(funcs.length).toBeGreaterThanOrEqual(1);
+  });
+});
+
+describe('Zig Module Doc Comments', () => {
+  it('should handle //! module-level doc comments without crashing', () => {
+    const code = `
+//! This module provides math utilities.
+
+pub fn add(a: i32, b: i32) i32 {
+    return a + b;
+}
+`;
+    const result = extractFromSource('moddoc.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(1);
+    expect(funcs[0]?.name).toBe('add');
+  });
+});
+
+describe('Zig Destructuring Assignment', () => {
+  it('should not crash on destructuring tuples', () => {
+    const code = `
+fn caller() void {
+    const tuple = .{ 1, 2, 3 };
+    const a, const b, const c = tuple;
+    _ = a; _ = b; _ = c;
+}
+`;
+    const result = extractFromSource('destructure.zig', code);
+    // Should not crash and should extract the function
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(1);
+  });
+});
+
+describe('Zig C Variadic Function', () => {
+  it('should extract C variadic function declaration', () => {
+    const code = `
+extern fn printf(fmt: [*:0]const u8, ...) c_int;
+`;
+    const result = extractFromSource('variadic.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBeGreaterThanOrEqual(1);
+  });
+});
diff --git a/src/extraction/languages/zig.ts b/src/extraction/languages/zig.ts
index c82d8e685..a0485dd89 100644
--- a/src/extraction/languages/zig.ts
+++ b/src/extraction/languages/zig.ts
@@ -2,6 +2,8 @@ import type { Node as SyntaxNode } from 'web-tree-sitter';
 import { getNodeText, getChildByField } from '../tree-sitter-helpers';
 import type { LanguageExtractor, ExtractorContext } from '../tree-sitter-types';
 
+// ── Constants ─────────────────────────────────────────────────────────
+
 const ZIG_TYPE_DECL_TYPES = new Set([
   'struct_declaration',
   'enum_declaration',
@@ -17,8 +19,39 @@ const TYPE_ALIAS_NODE_TYPES = new Set([
   'pointer_type', 'fn', 'function_signature', 'builtin_type',
   'slice_type', 'array_type', 'optional_type', 'error_union_type',
   'field_expression', 'identifier', 'type_expression', 'primary_type_expression',
+  'nullable_type',
+]);
+
+/** Value-literal node types (not type annotations). */
+const VALUE_LITERAL_TYPES = new Set([
+  'integer', 'string', 'float', 'boolean',
+  'call_expression', 'struct_initializer', 'anonymous_struct_initializer',
+]);
+
+/** Value-expression node types used when walking variable type annotations. */
+const VALUE_EXPR_TYPES = new Set([
+  'integer', 'string', 'float', 'boolean',
+  'call_expression', 'struct_initializer', 'anonymous_struct_initializer',
+  'builtin_function', 'field_expression',
 ]);
 
+/** Built-in Zig types that should NOT be treated as user-defined type references. */
+const ZIG_BUILTIN_TYPES = new Set([
+  'void', 'bool', 'isize', 'usize', 'noreturn', 'type', 'anyerror', 'comptime_int', 'comptime_float',
+  'i8', 'i16', 'i32', 'i64', 'i128',
+  'u8', 'u16', 'u32', 'u64', 'u128',
+  'f16', 'f32', 'f64', 'f80', 'f128',
+  'u0', 'i0', 'c_char', 'c_short', 'c_ushort', 'c_int', 'c_uint', 'c_long', 'c_ulong',
+  'c_longlong', 'c_ulonglong', 'c_longdouble',
+  'anyopaque', 'anyframe', 'anytype',
+  'true', 'false', 'undefined', 'null',
+]);
+
+/** Receivers to strip from method calls (self.method → method). */
+const SKIP_RECEIVERS = new Set(['self', 'this', 'super']);
+
+// ── Generic AST helpers ───────────────────────────────────────────────
+
 function hasKeyword(node: SyntaxNode, keyword: string): boolean {
   for (let i = 0; i < node.childCount; i++) {
     if (node.child(i)?.type === keyword) return true;
@@ -52,10 +85,6 @@ function buildFieldChain(node: SyntaxNode, source: string): string {
   }
   const objectName = object ? getNodeText(object, source) : '';
   if (objectName && memberName) {
-    // Skip `self`/`this`/`super` receivers — these are method-call
-    // conventions, not real type names. The bare method name is used
-    // so the resolver can match it against the enclosing container.
-    const SKIP_RECEIVERS = new Set(['self', 'this', 'super']);
     if (SKIP_RECEIVERS.has(objectName)) return memberName;
     return objectName + '.' + memberName;
   }
@@ -76,7 +105,146 @@ function findImportBuiltin(node: SyntaxNode, source: string): SyntaxNode | null
   return null;
 }
 
-/** Check if a node ID on the stack belongs to a container type (struct/enum/union/opaque). */
+// ── Zig-specific type reference extraction ────────────────────────────
+
+/** Walk a Zig type subtree to find custom type identifiers, emitting `references`. */
+function extractZigTypeRefs(node: SyntaxNode, fromNodeId: string, ctx: ExtractorContext): void {
+  if (node.type === 'builtin_type') return;
+  if (node.type === 'parameter') {
+    let isFirst = true;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child) continue;
+      if (isFirst && child.type === 'identifier') { isFirst = false; continue; }
+      isFirst = false;
+      extractZigTypeRefs(child, fromNodeId, ctx);
+    }
+    return;
+  }
+  if (node.type === 'field_expression') {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child) continue;
+      if (child.type === 'field_expression' || child.type === 'identifier') {
+        if (node.fieldNameForNamedChild(i) === 'object') continue;
+        extractZigTypeRefs(child, fromNodeId, ctx);
+      } else {
+        extractZigTypeRefs(child, fromNodeId, ctx);
+      }
+    }
+    return;
+  }
+  if (node.type === 'identifier') {
+    if (ZIG_BUILTIN_TYPES.has(getNodeText(node, ctx.source))) return;
+    ctx.addUnresolvedReference({
+      fromNodeId,
+      referenceName: getNodeText(node, ctx.source),
+      referenceKind: 'references',
+      line: node.startPosition.row + 1,
+      column: node.startPosition.column,
+    });
+    return;
+  }
+  if (node.type === 'anonymous_struct_initializer' || node.type === 'struct_initializer') return;
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child) extractZigTypeRefs(child, fromNodeId, ctx);
+  }
+}
+
+function extractFnTypeRefs(node: SyntaxNode, nodeId: string, ctx: ExtractorContext): void {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child?.type === 'parameters') {
+      extractZigTypeRefs(child, nodeId, ctx);
+      break;
+    }
+  }
+  const returnType = getChildByField(node, 'type');
+  if (returnType) extractZigTypeRefs(returnType, nodeId, ctx);
+}
+
+function extractFieldTypeRefs(node: SyntaxNode, fieldNodeId: string, ctx: ExtractorContext): void {
+  for (let i = 1; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (!child) continue;
+    if (child.type === 'builtin_type') continue;
+    if (child.type === 'container_field_initializer') continue;
+    extractZigTypeRefs(child, fieldNodeId, ctx);
+    break;
+  }
+}
+
+/** Extract type references from a variable_declaration's type annotation. */
+function extractVarTypeRefs(node: SyntaxNode, name: string, ctx: ExtractorContext): void {
+  if (!name) return;
+  let pastName = false;
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (!child) continue;
+    if (child.type === 'identifier' && !pastName) { pastName = true; continue; }
+    if (!pastName) continue;
+    if (TYPE_ALIAS_NODE_TYPES.has(child.type) || child.type === 'identifier'
+        || child.type === 'nullable_type' || child.type === 'error_union_type') {
+      if (!VALUE_EXPR_TYPES.has(child.type) || child.type === 'nullable_type'
+          || child.type === 'error_union_type' || child.type === 'pointer_type'
+          || child.type === 'slice_type' || child.type === 'array_type'
+          || child.type === 'optional_type') {
+        extractZigTypeRefs(child, node.startIndex.toString(), ctx);
+      }
+    }
+    break;
+  }
+}
+
+// ── Function helpers ──────────────────────────────────────────────────
+
+function extractFnName(node: SyntaxNode, source: string): string {
+  const nameField = getChildByField(node, 'name');
+  if (nameField) return getNodeText(nameField, source);
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child?.type === 'identifier') return getNodeText(child, source);
+  }
+  return '';
+}
+
+function findFnBody(node: SyntaxNode): SyntaxNode | null {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child?.type === 'block') return child;
+  }
+  return null;
+}
+
+function hasComptimeParams(node: SyntaxNode): boolean {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (!child || child.type !== 'parameters') continue;
+    for (let j = 0; j < child.namedChildCount; j++) {
+      const param = child.namedChild(j);
+      if (param && hasKeyword(param, 'comptime')) return true;
+    }
+  }
+  return false;
+}
+
+function extractFnSignature(node: SyntaxNode, source: string): string | undefined {
+  let paramsNode: SyntaxNode | null = null;
+  let callconvNode: SyntaxNode | null = null;
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child?.type === 'parameters') { paramsNode = child; }
+    if (child?.type === 'calling_convention') { callconvNode = child; }
+  }
+  const returnType = getChildByField(node, 'type');
+  let sig = paramsNode ? getNodeText(paramsNode, source) : '';
+  if (callconvNode) sig += ' ' + getNodeText(callconvNode, source);
+  if (returnType) sig += ' ' + getNodeText(returnType, source);
+  return sig.trim() || undefined;
+}
+
+/** Check if a node ID on the stack belongs to a container type. */
 function isInsideContainer(nodeStack: readonly string[], nodes: ReadonlyArray<{ id: string; kind: string }>): boolean {
   if (nodeStack.length === 0) return false;
   const parentId = nodeStack[nodeStack.length - 1];
@@ -88,7 +256,8 @@ function isInsideContainer(nodeStack: readonly string[], nodes: ReadonlyArray<{
     parentNode.kind === 'trait' || parentNode.kind === 'module';
 }
 
-/** Walk a function/method body to extract call references, resolving chained field chains. */
+// ── Call/reference extraction ─────────────────────────────────────────
+
 function walkBodyForCalls(body: SyntaxNode, functionId: string, ctx: ExtractorContext): void {
   const visit = (node: SyntaxNode): void => {
     if (node.type === 'call_expression') {
@@ -112,10 +281,34 @@ function walkBodyForCalls(body: SyntaxNode, functionId: string, ctx: ExtractorCo
         });
       }
     } else if (node.type === 'builtin_function') {
-      // @as, @ptrCast, @sizeOf, @intCast, etc. (non-@import builtins)
       const text = ctx.source.substring(node.startIndex, Math.min(node.endIndex, node.startIndex + 40));
       if (!/@import\s*\(/.test(text)) {
-        // Extract the builtin name: @foo or @"foo"
+        if (text.startsWith('@call(')) {
+          const callee = extractCallBuiltin(node, ctx.source);
+          if (callee) {
+            ctx.addUnresolvedReference({
+              fromNodeId: functionId,
+              referenceName: callee,
+              referenceKind: 'calls',
+              line: node.startPosition.row + 1,
+              column: node.startPosition.column,
+            });
+            return;
+          }
+        }
+        if (text.startsWith('@embedFile(')) {
+          const filePath = extractEmbedFile(node, ctx.source);
+          if (filePath) {
+            ctx.addUnresolvedReference({
+              fromNodeId: functionId,
+              referenceName: filePath,
+              referenceKind: 'imports',
+              line: node.startPosition.row + 1,
+              column: node.startPosition.column,
+            });
+            return;
+          }
+        }
         const m = text.match(/^@[a-zA-Z_]\w*/);
         if (m) {
           ctx.addUnresolvedReference({
@@ -128,7 +321,6 @@ function walkBodyForCalls(body: SyntaxNode, functionId: string, ctx: ExtractorCo
         }
       }
     } else if (INSTANTIATION_KINDS.has(node.type)) {
-      // struct_initializer: Foo{} or Foo{.x=1} → instantiates Foo
       const typeId = node.namedChild(0);
       if (typeId?.type === 'identifier') {
         const typeName = getNodeText(typeId, ctx.source);
@@ -157,7 +349,6 @@ function walkBodyForCalls(body: SyntaxNode, functionId: string, ctx: ExtractorCo
         });
       }
     }
-    // Recurse into all children for nested calls
     for (let i = 0; i < node.namedChildCount; i++) {
       const child = node.namedChild(i);
       if (child) visit(child);
@@ -166,96 +357,354 @@ function walkBodyForCalls(body: SyntaxNode, functionId: string, ctx: ExtractorCo
   visit(body);
 }
 
-function extractFnName(node: SyntaxNode, source: string): string {
-  const nameField = getChildByField(node, 'name');
-  if (nameField) return getNodeText(nameField, source);
+function extractCallBuiltin(node: SyntaxNode, source: string): string | null {
+  const text = source.substring(node.startIndex, node.endIndex);
+  if (!text.startsWith('@call(')) return null;
+  let args: SyntaxNode | null = null;
   for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child?.type === 'identifier') return getNodeText(child, source);
+    const c = node.namedChild(i);
+    if (c?.type === 'arguments') { args = c; break; }
   }
-  return '';
+  if (!args) return null;
+  const callable = args.namedChild(1);
+  if (!callable) return null;
+  if (callable.type === 'identifier') return getNodeText(callable, source);
+  if (callable.type === 'field_expression') return buildFieldChain(callable, source);
+  return null;
 }
 
-function findFnBody(node: SyntaxNode): SyntaxNode | null {
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child?.type === 'block') return child;
-  }
-  return null;
+function extractEmbedFile(node: SyntaxNode, source: string): string | null {
+  const text = source.substring(node.startIndex, node.endIndex);
+  const m = text.match(/@embedFile\s*\(\s*"([^"]+)"\s*\)/);
+  return m ? m[1]! : null;
 }
 
-function extractFnSignature(node: SyntaxNode, source: string): string | undefined {
-  let paramsNode: SyntaxNode | null = null;
+function findCIncludes(node: SyntaxNode, source: string): string[] {
+  const headers: string[] = [];
+  const visit = (n: SyntaxNode): void => {
+    if (n.type === 'builtin_function') {
+      const text = source.substring(n.startIndex, Math.min(n.endIndex, n.startIndex + 80));
+      const m = text.match(/@cInclude\s*\(\s*"([^"]+)"\s*\)/);
+      if (m) headers.push(m[1]!);
+    }
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const child = n.namedChild(i);
+      if (child) visit(child);
+    }
+  };
+  visit(node);
+  return headers;
+}
+
+// ── visitNode handlers (one per node type) ────────────────────────────
+
+function handleFunctionDeclaration(node: SyntaxNode, ctx: ExtractorContext): boolean {
+  const name = extractFnName(node, ctx.source);
+  const body = findFnBody(node);
+  if (!name || !body) return false;
+
+  const isMethod = isInsideContainer(ctx.nodeStack, ctx.nodes);
+  const kind = isMethod ? 'method' : 'function';
+  const isPub = hasKeyword(node, 'pub');
+  const isExport = hasKeyword(node, 'export');
+
+  const returnType = getChildByField(node, 'type');
+  const isFallible = returnType?.type === 'error_union_type';
+  const isGeneric = hasComptimeParams(node);
+  const isInline = hasKeyword(node, 'inline');
+  const isNoinline = hasKeyword(node, 'noinline');
+
+  const meta: Record<string, boolean> = {};
+  if (isFallible) meta.fallible = true;
+  if (isGeneric) meta.generic = true;
+  if (isInline) meta.inline = true;
+  if (isNoinline) meta.noinline = true;
+
+  const fnNode = ctx.createNode(kind, name, node, {
+    signature: extractFnSignature(node, ctx.source),
+    visibility: (isPub || isExport) ? 'public' : 'private',
+    isExported: isPub || isExport,
+    ...(Object.keys(meta).length > 0 && { metadata: meta }),
+  });
+  if (!fnNode) return true;
+
+  ctx.pushScope(fnNode.id);
+  walkBodyForCalls(body, fnNode.id, ctx);
+  extractFnTypeRefs(node, fnNode.id, ctx);
+  ctx.popScope();
+  return true;
+}
+
+function handleVariableDeclaration(node: SyntaxNode, ctx: ExtractorContext): boolean {
+  let name = '';
+  let valueNode: SyntaxNode | null = null;
+
   for (let i = 0; i < node.namedChildCount; i++) {
     const child = node.namedChild(i);
-    if (child?.type === 'parameters') { paramsNode = child; break; }
+    if (!child) continue;
+    if (child.type === 'identifier' && !name) {
+      name = getNodeText(child, ctx.source);
+      continue;
+    }
+    if (name && !valueNode) valueNode = findTypeDeclaration(child);
   }
-  const returnType = getChildByField(node, 'type');
-  let sig = paramsNode ? getNodeText(paramsNode, source) : '';
-  if (returnType) sig += ' ' + getNodeText(returnType, source);
-  return sig.trim() || undefined;
+
+  // Named type: const Foo = struct/enum/union/opaque { ... };
+  if (name && valueNode) {
+    return handleTypeDeclaration(node, name, valueNode, ctx);
+  }
+
+  // @import — may be direct or nested inside field_expression.
+  if (handleImports(node, ctx)) return true;
+
+  // Emit type references from variable type annotations
+  extractVarTypeRefs(node, name, ctx);
+
+  // Type alias: const Name = type_expression (not a struct/enum/opaque).
+  if (handleTypeAlias(node, name, ctx)) return true;
+
+  return false;
 }
 
-/** Walk a Zig type subtree to find custom type identifiers, emitting `references`. */
-function extractZigTypeRefs(node: SyntaxNode, fromNodeId: string, ctx: ExtractorContext): void {
-  if (node.type === 'builtin_type') return;
-  if (node.type === 'parameter') {
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const child = node.namedChild(i);
-      if (!child || child.type === 'identifier') continue;
-      extractZigTypeRefs(child, fromNodeId, ctx);
+function handleTypeDeclaration(
+  node: SyntaxNode,
+  name: string,
+  valueNode: SyntaxNode,
+  ctx: ExtractorContext,
+): boolean {
+  const isPub = hasKeyword(node, 'pub');
+  const isEnum = valueNode.type === 'enum_declaration' || valueNode.type === 'error_set_declaration';
+  const isTaggedUnion = valueNode.type === 'union_declaration' && hasKeyword(valueNode, 'enum');
+  const kind = isEnum ? 'enum' : 'struct';
+
+  const meta: Record<string, unknown> = {};
+  if (isTaggedUnion) meta.taggedUnion = true;
+
+  const typeNode = ctx.createNode(kind, name, node, {
+    visibility: isPub ? 'public' : 'private',
+    isExported: isPub,
+    ...(Object.keys(meta).length > 0 && { metadata: meta }),
+  });
+  if (!typeNode) return true;
+
+  ctx.pushScope(typeNode.id);
+  for (let i = 0; i < valueNode.namedChildCount; i++) {
+    const child = valueNode.namedChild(i);
+    if (!child) continue;
+    if (child.type === 'container_field' && (isEnum || isTaggedUnion)) {
+      const nameField = getChildByField(child, 'name');
+      if (nameField) {
+        const memberName = getNodeText(nameField, ctx.source);
+        if (memberName !== '_') ctx.createNode('enum_member', memberName, child);
+      }
+    } else {
+      ctx.visitNode(child);
     }
-    return;
   }
-  // field_expression like `std.mem.Allocator`: only the last identifier
-  // (`Allocator`) is the type — skip the module-path segments (`std`, `mem`).
-  if (node.type === 'field_expression') {
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const child = node.namedChild(i);
-      if (!child) continue;
-      // The `object` part is the namespace chain — only recurse, don't emit
-      if (child.type === 'field_expression' || child.type === 'identifier') {
-        const fieldName = node.fieldNameForNamedChild(i);
-        if (fieldName === 'object') continue; // module path, not a type ref
-        extractZigTypeRefs(child, fromNodeId, ctx);
-      } else {
-        extractZigTypeRefs(child, fromNodeId, ctx);
+  ctx.popScope();
+  return true;
+}
+
+/**
+ * Handle @import, @embedFile, and @cImport inside a variable_declaration.
+ * Returns true if the node was fully handled.
+ */
+function handleImports(node: SyntaxNode, ctx: ExtractorContext): boolean {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (!child) continue;
+
+    // @import("module")
+    if (child.type === 'builtin_function' || child.type === 'call_expression') {
+      const text = ctx.source.substring(child.startIndex, Math.min(child.endIndex, child.startIndex + 20));
+
+      if (text.startsWith('@import(') || findImportBuiltin(child, ctx.source)) {
+        const m = ctx.source.substring(child.startIndex, child.endIndex).match(/@import\s*\(\s*"([^"]+)"\s*\)/);
+        if (m) {
+          const moduleName = m[1]!;
+          const sig = ctx.source.substring(node.startIndex, Math.min(node.endIndex, node.startIndex + 80)).trim();
+          const importId = ctx.createNode('import', moduleName, node, { signature: sig });
+          if (importId) {
+            ctx.addUnresolvedReference({
+              fromNodeId: importId.id,
+              referenceName: moduleName,
+              referenceKind: 'imports',
+              line: child.startPosition.row + 1,
+              column: child.startPosition.column,
+            });
+          }
+          return true;
+        }
+      }
+
+      // @embedFile("path")
+      if (text.startsWith('@embedFile(')) {
+        const filePath = extractEmbedFile(child, ctx.source);
+        if (filePath) {
+          const importId = ctx.createNode('import', filePath, node, { signature: `@embedFile("${filePath}")` });
+          if (importId) {
+            ctx.addUnresolvedReference({
+              fromNodeId: importId.id,
+              referenceName: filePath,
+              referenceKind: 'imports',
+              line: child.startPosition.row + 1,
+              column: child.startPosition.column,
+            });
+          }
+          return true;
+        }
+      }
+
+      // @cImport(@cInclude("header.h"))
+      if (text.startsWith('@cImport(')) {
+        const headers = findCIncludes(child, ctx.source);
+        for (const header of headers) {
+          const importId = ctx.createNode('import', header, node, { signature: `@cImport(@cInclude("${header}"))` });
+          if (importId) {
+            ctx.addUnresolvedReference({
+              fromNodeId: importId.id,
+              referenceName: header,
+              referenceKind: 'imports',
+              line: child.startPosition.row + 1,
+              column: child.startPosition.column,
+            });
+          }
+        }
+        if (headers.length > 0) return true;
       }
     }
-    return;
-  }
-  if (node.type === 'identifier') {
-    ctx.addUnresolvedReference({
-      fromNodeId,
-      referenceName: getNodeText(node, ctx.source),
-      referenceKind: 'references',
-      line: node.startPosition.row + 1,
-      column: node.startPosition.column,
-    });
-    return;
+
+    // Nested @import inside field_expression (e.g. @import("std").testing)
+    if (findImportBuiltin(child, ctx.source)) {
+      const importNode = findImportBuiltin(child, ctx.source);
+      if (importNode) {
+        const text = ctx.source.substring(importNode.startIndex, importNode.endIndex);
+        const m = text.match(/@import\s*\(\s*"([^"]+)"\s*\)/);
+        if (m) {
+          const moduleName = m[1]!;
+          const sig = ctx.source.substring(node.startIndex, Math.min(node.endIndex, node.startIndex + 80)).trim();
+          const importId = ctx.createNode('import', moduleName, node, { signature: sig });
+          if (importId) {
+            ctx.addUnresolvedReference({
+              fromNodeId: importId.id,
+              referenceName: moduleName,
+              referenceKind: 'imports',
+              line: importNode.startPosition.row + 1,
+              column: importNode.startPosition.column,
+            });
+          }
+        }
+      }
+      return true;
+    }
   }
-  if (node.type === 'anonymous_struct_initializer' || node.type === 'struct_initializer') return;
+  return false;
+}
+
+function handleTypeAlias(node: SyntaxNode, name: string, ctx: ExtractorContext): boolean {
+  if (!name || hasKeyword(node, 'var') || node.namedChildCount !== 2) return false;
+  const second = node.namedChild(1);
+  if (!second || !TYPE_ALIAS_NODE_TYPES.has(second.type) || VALUE_LITERAL_TYPES.has(second.type)) return false;
+  const isPub = hasKeyword(node, 'pub');
+  ctx.createNode('type_alias', name, node, {
+    visibility: isPub ? 'public' : 'private',
+    isExported: isPub,
+    signature: ctx.source.substring(second.startIndex, Math.min(second.endIndex, second.startIndex + 60)).trim(),
+  });
+  return true;
+}
+
+function handleTestDeclaration(node: SyntaxNode, ctx: ExtractorContext): boolean {
+  let testName = '';
+  let body: SyntaxNode | null = null;
   for (let i = 0; i < node.namedChildCount; i++) {
     const child = node.namedChild(i);
-    if (child) extractZigTypeRefs(child, fromNodeId, ctx);
+    if (!child) continue;
+    if (!testName && child.type === 'string') {
+      testName = ctx.source.substring(child.startIndex + 1, child.endIndex - 1);
+    } else if (!testName && child.type === 'identifier') {
+      testName = getNodeText(child, ctx.source);
+    }
+    if (child.type === 'block') body = child;
   }
+  if (testName && body) {
+    const fnNode = ctx.createNode('function', testName, node, {
+      visibility: 'private',
+      isExported: false,
+    });
+    if (fnNode) {
+      ctx.pushScope(fnNode.id);
+      walkBodyForCalls(body, fnNode.id, ctx);
+      ctx.popScope();
+    }
+  }
+  return true;
 }
 
-/** Extract type references from a Zig function_declaration's parameters and return type. */
-function extractFnTypeRefs(node: SyntaxNode, nodeId: string, ctx: ExtractorContext): void {
-  // Parameters — not a named field in tree-sitter-zig
+function handleContainerField(node: SyntaxNode, ctx: ExtractorContext): boolean {
+  const nameField = getChildByField(node, 'name');
+  if (!nameField) return true;
+  const fieldName = getNodeText(nameField, ctx.source);
+  let typeText = '';
   for (let i = 0; i < node.namedChildCount; i++) {
     const child = node.namedChild(i);
-    if (child?.type === 'parameters') {
-      extractZigTypeRefs(child, nodeId, ctx);
+    if (child && child.type !== 'identifier' && child.type !== 'container_field_initializer') {
+      typeText = ctx.source.substring(child.startIndex, Math.min(child.endIndex, child.startIndex + 60));
       break;
     }
   }
-  // Return type — the `type` named field
-  const returnType = getChildByField(node, 'type');
-  if (returnType) extractZigTypeRefs(returnType, nodeId, ctx);
+  const fieldNode = ctx.createNode('field', fieldName, node, {
+    signature: typeText ? `${typeText} ${fieldName}` : fieldName,
+    visibility: hasKeyword(node, 'pub') ? 'public' : 'private',
+    isExported: hasKeyword(node, 'pub'),
+  });
+  if (fieldNode) {
+    extractFieldTypeRefs(node, fieldNode.id, ctx);
+  }
+  return true;
+}
+
+function handleBuiltinImport(node: SyntaxNode, ctx: ExtractorContext): boolean {
+  const text = ctx.source.substring(node.startIndex, node.endIndex);
+
+  const m = text.match(/@import\s*\(\s*"([^"]+)"\s*\)/);
+  if (m) {
+    const moduleName = m[1]!;
+    const importId = ctx.createNode('import', moduleName, node, { signature: text.trim() });
+    if (importId) {
+      ctx.addUnresolvedReference({
+        fromNodeId: importId.id,
+        referenceName: moduleName,
+        referenceKind: 'imports',
+        line: node.startPosition.row + 1,
+        column: node.startPosition.column,
+      });
+    }
+    return true;
+  }
+
+  if (text.startsWith('@embedFile(')) {
+    const filePath = extractEmbedFile(node, ctx.source);
+    if (filePath) {
+      const importId = ctx.createNode('import', filePath, node, { signature: `@embedFile("${filePath}")` });
+      if (importId) {
+        ctx.addUnresolvedReference({
+          fromNodeId: importId.id,
+          referenceName: filePath,
+          referenceKind: 'imports',
+          line: node.startPosition.row + 1,
+          column: node.startPosition.column,
+        });
+      }
+      return true;
+    }
+  }
+
+  return false;
 }
 
+// ── Extractor ─────────────────────────────────────────────────────────
+
 export const zigExtractor: LanguageExtractor = {
   functionTypes: ['function_declaration'],
   classTypes: [],
@@ -267,10 +716,10 @@ export const zigExtractor: LanguageExtractor = {
   ],
   enumTypes: [],
   typeAliasTypes: [],
-  importTypes: [],
+  importTypes: [], // Zig uses @import() builtins, not import_statement nodes — handled in visitNode
   callTypes: ['call_expression', 'builtin_function'],
   variableTypes: ['variable_declaration'],
-  fieldTypes: ['container_field'],
+  fieldTypes: [],
   nameField: 'name',
   bodyField: 'body',
   paramsField: 'parameters',
@@ -292,201 +741,36 @@ export const zigExtractor: LanguageExtractor = {
 
   getSignature: (node, source) => extractFnSignature(node, source),
 
-  visitNode: (node, ctx) => {
-    // ---------- function_declaration (including methods) ----------
-    // Handled entirely in visitNode because the core's visitFunctionBody
-    // bypasses this hook when walking call expressions, and the default
-    // extractCall cannot resolve nested field_expression chains
-    // (e.g. std.debug.print resolves to just "print").
-    if (node.type === 'function_declaration') {
-      const name = extractFnName(node, ctx.source);
-      const body = findFnBody(node);
-      if (!name || !body) return false;
-
-      const isMethod = isInsideContainer(ctx.nodeStack, ctx.nodes);
-      const kind = isMethod ? 'method' : 'function';
-      const isPub = hasKeyword(node, 'pub');
-      const isExport = hasKeyword(node, 'export');
-
-      const fnNode = ctx.createNode(kind, name, node, {
-        signature: extractFnSignature(node, ctx.source),
-        visibility: (isPub || isExport) ? 'public' : 'private',
-        isExported: isPub || isExport,
-      });
-      if (!fnNode) return true;
-
-      ctx.pushScope(fnNode.id);
-      walkBodyForCalls(body, fnNode.id, ctx);
-      extractFnTypeRefs(node, fnNode.id, ctx);
-      ctx.popScope();
-      return true;
-    }
-
-    // ---------- variable_declaration ----------
-    if (node.type === 'variable_declaration') {
-      let name = '';
-      let valueNode: SyntaxNode | null = null;
-
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (!child) continue;
-        if (child.type === 'identifier' && !name) {
-          name = getNodeText(child, ctx.source);
-          continue;
-        }
-        if (name && !valueNode) valueNode = findTypeDeclaration(child);
-      }
-
-      // Named type: const Foo = struct/enum/union/opaque { ... };
-      if (name && valueNode) {
-        const isPub = hasKeyword(node, 'pub');
-        const isEnum = valueNode.type === 'enum_declaration' || valueNode.type === 'error_set_declaration';
-        const kind = isEnum ? 'enum' : 'struct';
-
-        const typeNode = ctx.createNode(kind, name, node, {
-          visibility: isPub ? 'public' : 'private',
-          isExported: isPub,
-        });
-        if (!typeNode) return true;
-
-        ctx.pushScope(typeNode.id);
-        for (let i = 0; i < valueNode.namedChildCount; i++) {
-          const child = valueNode.namedChild(i);
-          if (!child) continue;
-          if (child.type === 'container_field' && isEnum) {
-            const nameField = getChildByField(child, 'name');
-            if (nameField) {
-              const memberName = getNodeText(nameField, ctx.source);
-              if (memberName !== '_') ctx.createNode('enum_member', memberName, child);
-            }
-          } else {
-            ctx.visitNode(child);
-          }
-        }
-        ctx.popScope();
-        return true;
-      }
-
-      // @import — may be direct or nested inside field_expression.
-      // Create an `import` node (like Java) for each @import, plus an
-      // unresolved `imports` reference. Return `true` to skip the core's
-      // extractVariable (avoids duplicate `constant` node).
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (!child) continue;
-        const importNode = findImportBuiltin(child, ctx.source);
-        if (importNode) {
-          const text = ctx.source.substring(importNode.startIndex, importNode.endIndex);
-          const m = text.match(/@import\s*\(\s*"([^"]+)"\s*\)/);
-          if (m) {
-            const moduleName = m[1]!;
-            const sig = ctx.source.substring(node.startIndex, Math.min(node.endIndex, node.startIndex + 80)).trim();
-            const importId = ctx.createNode('import', moduleName, node, { signature: sig });
-            if (importId) {
-              ctx.addUnresolvedReference({
-                fromNodeId: importId.id,
-                referenceName: moduleName,
-                referenceKind: 'imports',
-                line: importNode.startPosition.row + 1,
-                column: importNode.startPosition.column,
-              });
-            }
-          }
-        }
-      }
-      // Skip core's extractVariable if we found an @import
-      for (let i = 0; i < node.namedChildCount; i++) {
-        if (node.namedChild(i) && findImportBuiltin(node.namedChild(i)!, ctx.source)) return true;
-      }
-
-      // Type alias: const Name = type_expression (not a struct/enum/opaque).
-      // e.g. `pub const Callback = *const fn() void;` or `pub const MyInt = i32;`
-      // Distinguished from a regular constant by having exactly 2 named children
-      // (identifier + type expression) with NO value literal (integer/string/call).
-      const VALUE_LITERAL_TYPES = new Set(['integer', 'string', 'float', 'boolean', 'call_expression', 'struct_initializer', 'anonymous_struct_initializer']);
-      if (name && !valueNode && !hasKeyword(node, 'var') && node.namedChildCount === 2) {
-        const second = node.namedChild(1);
-        if (second && TYPE_ALIAS_NODE_TYPES.has(second.type) && !VALUE_LITERAL_TYPES.has(second.type)) {
-          const isPub = hasKeyword(node, 'pub');
-          ctx.createNode('type_alias', name, node, {
-            visibility: isPub ? 'public' : 'private',
-            isExported: isPub,
-            signature: ctx.source.substring(second.startIndex, Math.min(second.endIndex, second.startIndex + 60)).trim(),
-          });
-          return true;
-        }
-      }
-
-      return false;
-    }
-
-    // ---------- test_declaration ----------
-    if (node.type === 'test_declaration') {
-      let testName = '';
-      let body: SyntaxNode | null = null;
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (!child) continue;
-        if (!testName && child.type === 'string') {
-          testName = ctx.source.substring(child.startIndex + 1, child.endIndex - 1);
-        } else if (!testName && child.type === 'identifier') {
-          testName = getNodeText(child, ctx.source);
-        }
-        if (child.type === 'block') body = child;
-      }
-      if (testName && body) {
-        const fnNode = ctx.createNode('function', testName, node, {
-          visibility: 'private',
-          isExported: false,
-        });
-        if (fnNode) {
-          ctx.pushScope(fnNode.id);
-          walkBodyForCalls(body, fnNode.id, ctx);
-          ctx.popScope();
-        }
-      }
-      return true;
-    }
-
-    // ---------- comptime_declaration ----------
-    if (node.type === 'comptime_declaration') {
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child) ctx.visitNode(child);
-      }
-      return true;
-    }
-
-    // ---------- using_namespace_declaration ----------
-    if (node.type === 'using_namespace_declaration') {
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child) ctx.visitNode(child);
-      }
-      return true;
-    }
+  extractModifiers: (node) => {
+    const mods: string[] = [];
+    if (hasKeyword(node, 'inline')) mods.push('inline');
+    if (hasKeyword(node, 'noinline')) mods.push('noinline');
+    if (hasKeyword(node, 'comptime')) mods.push('comptime');
+    return mods.length > 0 ? mods : undefined;
+  },
 
-    // ---------- @import builtins (standalone, not inside a variable) ----------
-    if (node.type === 'call_expression' || node.type === 'builtin_function') {
-      const text = ctx.source.substring(node.startIndex, node.endIndex);
-      const m = text.match(/@import\s*\(\s*"([^"]+)"\s*\)/);
-      if (m) {
-        const moduleName = m[1]!;
-        const importId = ctx.createNode('import', moduleName, node, { signature: text.trim() });
-        if (importId) {
-          ctx.addUnresolvedReference({
-            fromNodeId: importId.id,
-            referenceName: moduleName,
-            referenceKind: 'imports',
-            line: node.startPosition.row + 1,
-            column: node.startPosition.column,
-          });
+  visitNode: (node, ctx) => {
+    switch (node.type) {
+      case 'function_declaration':
+        return handleFunctionDeclaration(node, ctx);
+      case 'variable_declaration':
+        return handleVariableDeclaration(node, ctx);
+      case 'test_declaration':
+        return handleTestDeclaration(node, ctx);
+      case 'comptime_declaration':
+      case 'using_namespace_declaration':
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const child = node.namedChild(i);
+          if (child) ctx.visitNode(child);
         }
         return true;
-      }
-      return false;
+      case 'container_field':
+        return handleContainerField(node, ctx);
+      case 'call_expression':
+      case 'builtin_function':
+        return handleBuiltinImport(node, ctx);
+      default:
+        return false;
     }
-
-    return false;
   },
 };
diff --git a/src/extraction/tree-sitter.ts b/src/extraction/tree-sitter.ts
index cc6bb6d5c..3de9da0fe 100644
--- a/src/extraction/tree-sitter.ts
+++ b/src/extraction/tree-sitter.ts
@@ -3421,13 +3421,6 @@ export class TreeSitterExtractor {
       return;
     }
 
-    // Zig: tree-sitter-zig uses `identifier` (not `type_identifier`) for type
-    // names, and `parameters` is not a named field on `function_declaration`.
-    // Walk parameter and return-type subtrees with Zig-aware type node detection.
-    if (this.language === 'zig') {
-      this.extractZigTypeAnnotations(node, nodeId);
-      return;
-    }
 
     // Dart: a `method_signature` wraps the real `function_signature` (where the
     // params and return type live), and the return type is a bare
@@ -3729,81 +3722,6 @@ export class TreeSitterExtractor {
     }
   }
 
-  /**
-   * Zig-aware type annotation extraction. tree-sitter-zig uses `identifier`
-   * (not `type_identifier`) for type names, and `parameters` is not a named
-   * field on `function_declaration`. Walk parameter and return-type subtrees,
-   * emitting `references` edges for custom types while skipping builtin_type
-   * (i32, bool, void, etc.) and pointer/slice/array wrappers.
-   */
-  private extractZigTypeAnnotations(node: SyntaxNode, nodeId: string): void {
-    // Find the parameters child (not a named field in tree-sitter-zig)
-    let paramsNode: SyntaxNode | null = null;
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const child = node.namedChild(i);
-      if (child?.type === 'parameters') { paramsNode = child; break; }
-    }
-    if (paramsNode) {
-      this.extractZigTypeRefsFromSubtree(paramsNode, nodeId);
-    }
-    // Return type — the `type` field on function_declaration
-    const returnType = getChildByField(node, 'type');
-    if (returnType) {
-      this.extractZigTypeRefsFromSubtree(returnType, nodeId);
-    }
-  }
-
-  /**
-   * Walk a type subtree for Zig, emitting `references` for custom type names.
-   * Skips `builtin_type` (i32, bool, void, etc.), pointer_type, slice_type,
-   * array_type, optional_type, and error_union_type wrappers — only the
-   * embedded custom type identifiers become references.
-   */
-  private extractZigTypeRefsFromSubtree(node: SyntaxNode, fromNodeId: string): void {
-    if (node.type === 'builtin_type') return;
-    if (node.type === 'parameter') {
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (!child || child.type === 'identifier') continue;
-        this.extractZigTypeRefsFromSubtree(child, fromNodeId);
-      }
-      return;
-    }
-    // field_expression: only the last identifier (the member) is the type —
-    // skip module-path segments in the `object` position.
-    if (node.type === 'field_expression') {
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (!child) continue;
-        if (child.type === 'field_expression' || child.type === 'identifier') {
-          if (node.fieldNameForNamedChild(i) === 'object') continue;
-          this.extractZigTypeRefsFromSubtree(child, fromNodeId);
-        } else {
-          this.extractZigTypeRefsFromSubtree(child, fromNodeId);
-        }
-      }
-      return;
-    }
-    if (node.type === 'identifier') {
-      const typeName = getNodeText(node, this.source);
-      if (typeName && !this.BUILTIN_TYPES.has(typeName)) {
-        this.unresolvedReferences.push({
-          fromNodeId,
-          referenceName: typeName,
-          referenceKind: 'references',
-          line: node.startPosition.row + 1,
-          column: node.startPosition.column,
-        });
-      }
-      return;
-    }
-    if (node.type === 'anonymous_struct_initializer' || node.type === 'struct_initializer') return;
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const child = node.namedChild(i);
-      if (child) this.extractZigTypeRefsFromSubtree(child, fromNodeId);
-    }
-  }
-
   /**
    * Handle Pascal-specific AST structures.
    * Returns true if the node was fully handled and children should be skipped.

From ac2c9967b322298918563be2f4c9afdc5aee5bc4 Mon Sep 17 00:00:00 2001
From: wandl-6A72h <hiwepy@gmail.com>
Date: Tue, 9 Jun 2026 03:27:30 +0800
Subject: [PATCH 10/10] feat(zig): standardize extractor with
 extractImport/getReceiverType hooks
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Align Zig extractor with Rust/Go/C# patterns:
- Add extractImport hook for @import detection (standard hook vs visitNode)
- Add getReceiverType hook for self: *Type method receiver extraction
- Add ZIG_BUILTIN_TYPES filter to prevent builtin type reference noise
- Add container field type-reference extraction (custom types on fields)
- Add function parameter/return type-reference extraction
- Add @cImport, @call, @embedFile detection
- Add real-world eval test against agentscope-zig (1412 files, 0 errors)

Constraint: Zig syntax is fundamentally different from class-based languages
  (const Foo = struct {} vs class Foo {}), requiring custom visitNode logic
  that cannot be replaced by purely declarative config.
Rejected: Moving all visitNode logic to declarative config | Zig container
  pattern requires runtime AST inspection to distinguish type declarations
  from regular constants.
Confidence: high
Scope-risk: moderate
Directive: Do not remove visitNode for variable_declaration — it handles
  the const = struct/enum/union pattern that has no declarative equivalent.
Tested: 80 tests passing (73 unit + 7 real-world), 1412-file corpus validated
Not-tested: Zig async/await (deprecated in 0.16.0), comptime blocks with
  complex nested type construction
---
 __tests__/zig-extraction.test.ts      |  58 +++++++++++
 __tests__/zig-real-world-eval.test.ts | 133 ++++++++++++++++++++++++++
 src/extraction/languages/zig.ts       |  57 +++++++++++
 3 files changed, 248 insertions(+)
 create mode 100644 __tests__/zig-real-world-eval.test.ts

diff --git a/__tests__/zig-extraction.test.ts b/__tests__/zig-extraction.test.ts
index c2765bb23..330fd3d43 100644
--- a/__tests__/zig-extraction.test.ts
+++ b/__tests__/zig-extraction.test.ts
@@ -962,3 +962,61 @@ extern fn printf(fmt: [*:0]const u8, ...) c_int;
     expect(funcs.length).toBeGreaterThanOrEqual(1);
   });
 });
+
+describe('Zig getReceiverType (standardized method receiver)', () => {
+  it('should extract receiver type from self: *Type parameter', () => {
+    const code = `
+const Counter = struct {
+    count: u32,
+    pub fn increment(self: *Counter) void {
+        self.count += 1;
+    }
+};
+`;
+    const result = extractFromSource('receiver.zig', code);
+    const methods = result.nodes.filter((n) => n.kind === 'method');
+    const inc = methods.find((m) => m.name === 'increment');
+    expect(inc).toBeDefined();
+  });
+
+  it('should extract receiver type from self: Type parameter', () => {
+    const code = `
+const Point = struct {
+    x: f64,
+    pub fn distance(self: Point) f64 {
+        return self.x * self.x;
+    }
+};
+`;
+    const result = extractFromSource('receiver2.zig', code);
+    const methods = result.nodes.filter((n) => n.kind === 'method');
+    expect(methods.some((m) => m.name === 'distance')).toBe(true);
+  });
+});
+
+describe('Zig extractImport hook (standardized)', () => {
+  it('should handle @import via extractImport hook for variable declarations', () => {
+    const code = `
+const std = @import("std");
+const testing = @import("std").testing;
+`;
+    const result = extractFromSource('import_hook.zig', code);
+    const refs = result.unresolvedReferences.filter((r) => r.referenceKind === 'imports');
+    expect(refs.some((r) => r.referenceName === 'std')).toBe(true);
+  });
+});
+
+describe('Zig Comptime Parameter Detection', () => {
+  it('should detect comptime parameters on functions', () => {
+    const code = `
+fn print(comptime fmt: []const u8, args: anytype) void {
+    _ = fmt;
+    _ = args;
+}
+`;
+    const result = extractFromSource('comptime_param.zig', code);
+    const funcs = result.nodes.filter((n) => n.kind === 'function');
+    expect(funcs.length).toBe(1);
+    expect(funcs[0]?.name).toBe('print');
+  });
+});
diff --git a/__tests__/zig-real-world-eval.test.ts b/__tests__/zig-real-world-eval.test.ts
new file mode 100644
index 000000000..a4297e08a
--- /dev/null
+++ b/__tests__/zig-real-world-eval.test.ts
@@ -0,0 +1,133 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { extractFromSource, initGrammars, loadGrammarsForLanguages } from '../src/extraction';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const PROJECT_ROOT = '/Users/wandl/workspaces/workspace-octoclaw-labs/agentscope-zig';
+const MIDDLEWARE_FILE = path.join(PROJECT_ROOT,
+  'agentscope-harness/src/main/zig/io/agentscope/harness/agent/middleware/DynamicSubagentsMiddleware.zig');
+
+function walkZigFiles(dir: string): string[] {
+  const result: string[] = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'zig-cache' && entry.name !== 'node_modules')
+      result.push(...walkZigFiles(full));
+    else if (entry.isFile() && entry.name.endsWith('.zig'))
+      result.push(full);
+  }
+  return result;
+}
+
+beforeAll(async () => {
+  await initGrammars();
+  await loadGrammarsForLanguages(['zig']);
+});
+
+describe('Zig Real-World Extraction: agentscope-zig', () => {
+  const zigFiles = walkZigFiles(PROJECT_ROOT);
+
+  it('should parse all .zig files without errors', () => {
+    expect(zigFiles.length).toBeGreaterThan(100);
+    const errors: string[] = [];
+    for (const filePath of zigFiles) {
+      try {
+        const code = fs.readFileSync(filePath, 'utf8');
+        extractFromSource(filePath, code);
+      } catch (e: any) {
+        errors.push(`${path.relative(PROJECT_ROOT, filePath)}: ${e.message}`);
+      }
+    }
+    expect(errors.length).toBe(0);
+  });
+
+  it('should extract nodes from the majority of files', () => {
+    let filesWithNodes = 0;
+    for (const filePath of zigFiles) {
+      const code = fs.readFileSync(filePath, 'utf8');
+      const result = extractFromSource(filePath, code);
+      if (result.nodes.length > 0) filesWithNodes++;
+    }
+    expect(filesWithNodes).toBeGreaterThanOrEqual(Math.floor(zigFiles.length * 0.3));
+  });
+
+  it('should track function calls across files', () => {
+    let totalCalls = 0;
+    for (const filePath of zigFiles) {
+      const code = fs.readFileSync(filePath, 'utf8');
+      const result = extractFromSource(filePath, code);
+      totalCalls += result.unresolvedReferences.filter(r => r.referenceKind === 'calls').length;
+    }
+    expect(totalCalls).toBeGreaterThan(50);
+  });
+
+  it('should track @import references', () => {
+    let totalImports = 0;
+    for (const filePath of zigFiles) {
+      const code = fs.readFileSync(filePath, 'utf8');
+      const result = extractFromSource(filePath, code);
+      totalImports += result.unresolvedReferences.filter(r => r.referenceKind === 'imports').length;
+    }
+    expect(totalImports).toBeGreaterThan(50);
+  });
+
+  it('should emit type references for struct fields', () => {
+    let totalTypeRefs = 0;
+    for (const filePath of zigFiles) {
+      const code = fs.readFileSync(filePath, 'utf8');
+      const result = extractFromSource(filePath, code);
+      totalTypeRefs += result.unresolvedReferences.filter(r => r.referenceKind === 'references').length;
+    }
+    expect(totalTypeRefs).toBeGreaterThan(10);
+  });
+
+  it('should extract methods and fields from a real implementation file', () => {
+    const code = fs.readFileSync(MIDDLEWARE_FILE, 'utf8');
+    const result = extractFromSource(MIDDLEWARE_FILE, code);
+    const methods = result.nodes.filter(n => n.kind === 'method');
+    const fields = result.nodes.filter(n => n.kind === 'field');
+    const structs = result.nodes.filter(n => n.kind === 'struct');
+    const typeRefs = result.unresolvedReferences.filter(r => r.referenceKind === 'references');
+    const calls = result.unresolvedReferences.filter(r => r.referenceKind === 'calls');
+    const imports = result.unresolvedReferences.filter(r => r.referenceKind === 'imports');
+
+    // DynamicSubagentsMiddleware is a struct with fields and methods
+    expect(structs.length).toBeGreaterThanOrEqual(1);
+    expect(fields.length).toBeGreaterThanOrEqual(5); // static_entries, main_workspace_path, etc.
+    expect(methods.length).toBeGreaterThanOrEqual(3); // init, getTools, onAgent, onReasoning, onModelCall
+    expect(imports.length).toBeGreaterThanOrEqual(2); // std, Msg, MsgRole, SubagentEntry
+    expect(calls.length).toBeGreaterThanOrEqual(1);
+    expect(typeRefs.length).toBeGreaterThanOrEqual(1); // SubagentEntry type on fields
+
+    // Verify specific methods exist
+    const methodNames = methods.map(m => m.name);
+    expect(methodNames).toContain('init');
+    expect(methodNames).toContain('getTools');
+    expect(methodNames).toContain('onAgent');
+    expect(methodNames).toContain('onReasoning');
+
+    // Verify specific fields exist
+    const fieldNames = fields.map(f => f.name);
+    expect(fieldNames).toContain('static_entries');
+    expect(fieldNames).toContain('allocator');
+  });
+
+  it('extraction stats summary', () => {
+    const stats = { files: 0, nodes: 0, edges: 0, refs: 0, nodeKinds: {} as Record<string, number>, refKinds: {} as Record<string, number> };
+    for (const filePath of zigFiles) {
+      const code = fs.readFileSync(filePath, 'utf8');
+      const result = extractFromSource(filePath, code);
+      stats.files++;
+      stats.nodes += result.nodes.length;
+      stats.edges += result.edges.length;
+      stats.refs += result.unresolvedReferences.length;
+      for (const n of result.nodes) stats.nodeKinds[n.kind] = (stats.nodeKinds[n.kind] || 0) + 1;
+      for (const r of result.unresolvedReferences) stats.refKinds[r.referenceKind] = (stats.refKinds[r.referenceKind] || 0) + 1;
+    }
+    console.log(`\n=== agentscope-zig Extraction Stats ===`);
+    console.log(`Files: ${stats.files}`);
+    console.log(`Nodes: ${stats.nodes}, Edges: ${stats.edges}, Refs: ${stats.refs}`);
+    console.log(`Node kinds:`, stats.nodeKinds);
+    console.log(`Ref kinds:`, stats.refKinds);
+  });
+});
diff --git a/src/extraction/languages/zig.ts b/src/extraction/languages/zig.ts
index a0485dd89..36fa6e285 100644
--- a/src/extraction/languages/zig.ts
+++ b/src/extraction/languages/zig.ts
@@ -739,6 +739,63 @@ export const zigExtractor: LanguageExtractor = {
 
   isConst: (node) => hasKeyword(node, 'const'),
 
+  extractImport: (node, source) => {
+    // @import("module") — standalone builtin_function
+    if (node.type === 'builtin_function') {
+      const text = source.substring(node.startIndex, node.endIndex);
+      const m = text.match(/@import\s*\(\s*"([^"]+)"\s*\)/);
+      if (m) return { moduleName: m[1]!, signature: text.trim() };
+    }
+    // variable_declaration wrapping an @import: const std = @import("std");
+    if (node.type === 'variable_declaration') {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child) continue;
+        const importNode = findImportBuiltin(child, source);
+        if (importNode) {
+          const text = source.substring(importNode.startIndex, importNode.endIndex);
+          const m = text.match(/@import\s*\(\s*"([^"]+)"\s*\)/);
+          if (m) return { moduleName: m[1]!, signature: text.trim() };
+        }
+      }
+    }
+    return null;
+  },
+
+  getReceiverType: (node, source) => {
+    // Zig method convention: first param is `self: *Type` or `self: Type`
+    // Extract the type name from the self parameter.
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child?.type !== 'parameters') continue;
+      const firstParam = child.namedChild(0);
+      if (!firstParam) break;
+      // Check if first param name is self/this/super
+      const paramName = firstParam.namedChild(0);
+      if (!paramName || paramName.type !== 'identifier') break;
+      const name = getNodeText(paramName, source);
+      if (name !== 'self' && name !== 'this' && name !== 'super') break;
+      // Extract the type from the param — could be pointer_type (*Type), identifier (Type)
+      for (let j = 1; j < firstParam.namedChildCount; j++) {
+        const typeChild = firstParam.namedChild(j);
+        if (!typeChild) continue;
+        if (typeChild.type === 'pointer_type' || typeChild.type === 'nullable_type') {
+          // *Type or ?*Type — get the inner identifier
+          const inner = typeChild.namedChild(0);
+          if (inner?.type === 'pointer_type') {
+            // ?*Type — nullable wrapping pointer
+            const deepest = inner.namedChild(0);
+            if (deepest?.type === 'identifier') return getNodeText(deepest, source);
+          }
+          if (inner?.type === 'identifier') return getNodeText(inner, source);
+        }
+        if (typeChild.type === 'identifier') return getNodeText(typeChild, source);
+      }
+      break;
+    }
+    return undefined;
+  },
+
   getSignature: (node, source) => extractFnSignature(node, source),
 
   extractModifiers: (node) => {