gitnexus 1.6.11-rc.8 → 1.6.11

package/dist/core/ingestion/utils/ast-helpers.js

@@ -260,6 +260,9 @@ export const FUNCTION_NODE_TYPES = new Set([
     // Dart
     'function_signature',
     'method_signature',
+    // Zig: `test "…" { }` bodies are callable scopes — calls inside attribute
+    // to the test, not the file. Named via methodExtractor.extractFunctionName.
+    'test_declaration',
 ]);
 /**
  * AST node types that represent a class-like container (for HAS_METHOD edge extraction).
@@ -308,6 +311,9 @@ export const CLASS_CONTAINER_TYPES = new Set([
     // Go
     'struct_type',
     'interface_type',
+    // Zig
+    'union_declaration',
+    'opaque_declaration',
 ]);
 /**
  * Node types whose OWN node id must not be re-keyed by an enclosing-scope
@@ -374,6 +380,12 @@ export const CONTAINER_TYPE_TO_LABEL = {
     companion_object: 'Class',
     struct_type: 'Struct',
     interface_type: 'Interface',
+    // Zig: tagged and untagged unions are class-like containers, and so is
+    // the fieldless `opaque {}` (may own methods; labelled Struct, see
+    // ZIG_QUERIES). `struct_declaration` and `enum_declaration` are already
+    // present (Dart / generic).
+    union_declaration: 'Union',
+    opaque_declaration: 'Struct',
 };
 /**
  * Pre-order walk over a node and all its named descendants, invoking `cb` on
@@ -397,6 +409,24 @@ export function walkNamedTree(node, cb) {
             walkNamedTree(child, cb);
     }
 }
+/**
+ * True when a node is, or contains, tree-sitter error recovery.
+ *
+ * After a syntax error the parser keeps going by guessing node boundaries, so
+ * the surviving tree stays WELL FORMED while describing text that was never
+ * written that way: an unterminated argument list can absorb the source of the
+ * next declaration into an `ERROR` child, and an assignment with no right-hand
+ * side gets a `MISSING` value node whose text is invented. A capture that reads
+ * such a subtree emits facts that look ordinary and are false, which is worse
+ * than emitting nothing — so callers that record source text verbatim should
+ * check this first and fail closed.
+ *
+ * `hasError` covers the subtree; `isMissing` is checked as well because a node
+ * inserted by recovery is the one case where the node itself carries the flag.
+ */
+export function hasRecoveredSyntax(node) {
+    return node.hasError || node.isMissing;
+}
 /** Return the first matching ancestor unless a boundary ancestor is reached first. */
 export function findAncestorBeforeBoundary(node, targetTypes, boundaryTypes) {
     let current = node.parent;
@@ -484,13 +514,16 @@ export function getLabelFromCaptures(captureMap, provider) {
         return null;
     const hasDefaultExportHocNameSeed = captureMap['definition.function'] !== undefined &&
         (captureMap['hoc'] !== undefined || captureMap['callee'] !== undefined);
-    // Nameless `definition.class` passes through: a class extractor may
-    // synthesize the name (Java anonymous class bodies → `Worker$N`, #2550).
-    // Downstream stays safe — parse-worker skips any nameless definition the
-    // extractor could not name (its `!nameNode && !extractedClassSymbol` gate).
+    // Nameless `definition.class` / `definition.struct` pass through: a class
+    // extractor may synthesize the name (Java anonymous class bodies →
+    // `Worker$N`, #2550; a file-level type named after its file — the
+    // extractor receives the file path for exactly this). Downstream stays
+    // safe — parse-worker skips any nameless definition the extractor could
+    // not name (its `!nameNode && !extractedClassSymbol` gate).
     if (!captureMap['name'] &&
         !captureMap['definition.constructor'] &&
         !captureMap['definition.class'] &&
+        !captureMap['definition.struct'] &&
         !hasDefaultExportHocNameSeed)
         return null;
     if (captureMap['definition.function']) {
@@ -691,6 +724,31 @@ const javaBinaryNameOfType = (node) => {
     const enclosingName = javaBinaryNameOfType(enclosing);
     return enclosingName === undefined ? undefined : `${enclosingName}$${simpleName}`;
 };
+/**
+ * For a container node that is the direct `return` value of a function whose
+ * declared return type is the literal `type` (`fn List(comptime T: type) type
+ * { return struct {…}; }`), the function's `name` node; undefined otherwise.
+ * Language-agnostic by shape — today only tree-sitter-zig produces it.
+ */
+function typeConstructorNameNode(container) {
+    const ret = container.parent;
+    if (ret?.type !== 'return_expression')
+        return undefined;
+    const stmt = ret.parent;
+    if (stmt?.type !== 'expression_statement')
+        return undefined;
+    const block = stmt.parent;
+    if (block?.type !== 'block')
+        return undefined;
+    const fn = block.parent;
+    if (fn?.type !== 'function_declaration')
+        return undefined;
+    if (fn.childForFieldName?.('body')?.id !== block.id)
+        return undefined;
+    if (fn.childForFieldName?.('type')?.text !== 'type')
+        return undefined;
+    return fn.childForFieldName?.('name') ?? undefined;
+}
 /**
  * Authoritative Java local/anonymous type identity.
  *
@@ -756,7 +814,24 @@ export const findEnclosingClassInfo = (node, filePath, resolveEnclosingOwner,
  * class-container branch to compute `qualifiedClassId` from the SAME function
  * the node-id is built from, guaranteeing owner-id == node-id by construction.
  */
-getQualifiedOwnerName) => {
+getQualifiedOwnerName, 
+/**
+ * Optional: the type the whole FILE declares (`LanguageProvider.resolveFileTypeOwner`).
+ * Consulted only when the walk reaches the tree root without meeting a
+ * container, so a member declared at file level can be owned by the file's
+ * own type (Zig file-structs). The name is what the definition phase names
+ * the class-like node, so owner id == node id by construction.
+ */
+resolveFileTypeOwner, 
+/**
+ * Optional: the type a CONTAINER node declares
+ * (`LanguageProvider.resolveContainerTypeOwner`). Consulted for every
+ * `CLASS_CONTAINER_TYPES` node the walk meets, before the generic name-child
+ * derivation, for languages whose containers are named from context (a
+ * binding wrapper, an enclosing callable, an anonymous ordinal). Null falls
+ * through to the generic derivation.
+ */
+resolveContainerTypeOwner) => {
     let current = node.parent;
     let iterations = 0;
     // Tracks container nodes already visited via the hook so a misbehaving hook
@@ -850,6 +925,18 @@ getQualifiedOwnerName) => {
                     continue;
                 }
             }
+            // A container the PROVIDER names from context (binding wrapper,
+            // enclosing callable, anonymous ordinal — Zig). The name is what the
+            // class-like node is minted under, so owner id == node id.
+            if (resolveContainerTypeOwner !== undefined) {
+                const containerOwner = resolveContainerTypeOwner(current, filePath);
+                if (containerOwner !== null) {
+                    return {
+                        classId: generateId(containerOwner.label, `${filePath}:${containerOwner.name}`),
+                        className: containerOwner.name,
+                    };
+                }
+            }
             // Rust impl_item: for `impl Trait for Struct {}`, pick the type after `for`
             // NOTE: This impl_item ownership logic is mirrored in
             // method-extractors/configs/rust.ts (extractOwnerName, metadata only).
@@ -926,7 +1013,27 @@ getQualifiedOwnerName) => {
                 current.children?.find((c) => c.type === 'type_identifier' ||
                     c.type === 'identifier' ||
                     c.type === 'name' ||
-                    c.type === 'constant');
+                    c.type === 'constant') ??
+                // An ANONYMOUS container bound by the enclosing declaration —
+                // `const Point = struct { … }` (tree-sitter-zig: struct/enum/union/
+                // opaque nodes carry no name; the binding identifier is the first
+                // named child of the parent `variable_declaration`). Same shape as the
+                // Go `type_spec` branch above: the name lives one level up. Without it
+                // the walk climbed past every Zig container and no member ever got a
+                // HAS_METHOD / HAS_PROPERTY owner. The definition phase names the
+                // container node from the same binding (`@name` on the wrapper), so
+                // the owner id and the node id agree by construction.
+                (current.parent?.type === 'variable_declaration'
+                    ? current.parent.namedChildren?.find((c) => c.type === 'identifier')
+                    : undefined) ??
+                // An anonymous container RETURNED by a type-constructor function —
+                // `pub fn List(comptime T: type) type { return struct { … }; }`
+                // (Zig's only spelling of a generic type). The container's name is
+                // the function's, which is what the definition phase uses too
+                // (`@name` on the fn identifier, anchor on the container), so the
+                // owner id and the node id agree by construction. Only the literal
+                // `return <container>` of a fn returning `type` qualifies.
+                typeConstructorNameNode(current);
             if (nameNode) {
                 let label = CONTAINER_TYPE_TO_LABEL[current.type] || 'Class';
                 // Kotlin: class_declaration with an anonymous "interface" keyword child
@@ -976,6 +1083,17 @@ getQualifiedOwnerName) => {
                 };
             }
         }
+        if (current.parent === null && resolveFileTypeOwner !== undefined) {
+            // Tree root reached with no container on the way: ask the provider
+            // whether the file itself is the owner.
+            const fileOwner = resolveFileTypeOwner(current, filePath);
+            if (fileOwner !== null) {
+                return {
+                    classId: generateId(fileOwner.label, `${filePath}:${fileOwner.name}`),
+                    className: fileOwner.name,
+                };
+            }
+        }
         current = current.parent;
     }
     return null;

package/dist/core/ingestion/utils/callable-flow-captures.d.ts

@@ -111,6 +111,15 @@ export interface CallableFlowCaptureOptions {
         readonly source: SyntaxNode;
     }[] | undefined;
     readonly extractFunctionParameters?: (node: SyntaxNode) => readonly SyntaxNode[] | undefined;
+    /**
+     * Provider-owned call-argument extraction, for grammars whose call node
+     * carries its arguments as DIRECT children with no argument-list wrapper
+     * (tree-sitter-zig's `call_expression`). Without a wrapper node the shared
+     * `arguments`/`parameterListNodeTypes` lookup finds nothing, so every
+     * `argument` fact is lost. Returning `undefined` falls back to the shared
+     * path (mirrors `extractFunctionParameters`).
+     */
+    readonly extractCallArguments?: (call: SyntaxNode) => readonly SyntaxNode[] | undefined;
     readonly extractCallCallee?: (node: SyntaxNode) => SyntaxNode | undefined;
     readonly isCallNode?: (node: SyntaxNode) => boolean;
     /**

package/dist/core/ingestion/utils/callable-flow-captures.js

@@ -165,6 +165,7 @@ function collectAssignments(nodes, options) {
 }
 function buildValueBindingIndex(nodes, assignments, functions, options) {
     const assignmentRegionIdsByName = new Map();
+    const memberStoreRegionIdsByName = new Map();
     const formalByOwner = new Map();
     const signatureByNameAndRegion = new Map();
     const add = (index, owner, name) => {
@@ -187,20 +188,28 @@ function buildValueBindingIndex(nodes, assignments, functions, options) {
         const terminal = terminalIdentifier(assignment.destination, options);
         if (terminal !== undefined)
             destinationNames.add(terminal.text);
-        for (const name of destinationNames) {
-            const region = nearestLexicalRegion(assignment.container, options);
-            let regionIds = assignmentRegionIdsByName.get(name);
+        // A destination whose binding identifier and terminal identifier are two
+        // different nodes spans a member path (`o->run`, `self.slot.f`); a bare
+        // name or a declarator (`void (*fp)(int)`) resolves both to the same leaf.
+        const memberStoreName = terminal !== undefined && terminal.id !== destination?.node.id ? terminal.text : undefined;
+        const region = nearestLexicalRegion(assignment.container, options);
+        const functionOwner = options.functionScopedValueBindings === true
+            ? nearestFunctionOwner(assignment.container, options)
+            : undefined;
+        const record = (index, name) => {
+            let regionIds = index.get(name);
             if (regionIds === undefined) {
                 regionIds = new Set();
-                assignmentRegionIdsByName.set(name, regionIds);
+                index.set(name, regionIds);
             }
             regionIds.add(region.id);
-            if (options.functionScopedValueBindings === true) {
-                const functionOwner = nearestFunctionOwner(assignment.container, options);
-                if (functionOwner !== undefined)
-                    regionIds.add(functionOwner.id);
-            }
-        }
+            if (functionOwner !== undefined)
+                regionIds.add(functionOwner.id);
+        };
+        for (const name of destinationNames)
+            record(assignmentRegionIdsByName, name);
+        if (memberStoreName !== undefined)
+            record(memberStoreRegionIdsByName, memberStoreName);
     }
     for (const fn of functions) {
         for (const parameter of fn.parameters) {
@@ -241,7 +250,12 @@ function buildValueBindingIndex(nodes, assignments, functions, options) {
                 byRegion.set(functionOwner.id, signature);
         }
     }
-    return { assignmentRegionIdsByName, formalByOwner, signatureByNameAndRegion };
+    return {
+        assignmentRegionIdsByName,
+        memberStoreRegionIdsByName,
+        formalByOwner,
+        signatureByNameAndRegion,
+    };
 }
 /** True when a pointer/parenthesized declarator sits between the declaration
  *  and its binding identifier — the shape of a callable-typed variable, never
@@ -312,6 +326,30 @@ function isVisibleValueBinding(input, name, bindings, options) {
     // function call emitted no invoke fact at all (#2522 review, H1).
     return visibleCallableSignature(input, name, bindings, options) !== undefined;
 }
+/**
+ * Member-call gate: the member's name-cell was written by a visible MEMBER
+ * store, or is a declared callable-typed binding (C struct field
+ * `void (*cb)(int);`, whose stores may live in other functions). Plain-name
+ * bindings and formals are deliberately NOT consulted — `x.f()` reads the
+ * member `f` of `x`, not a same-named local, and gating on the local minted an
+ * invoke through the wrong cell (a Zig `pub const release = deinit;` alias
+ * turned `self.slot.release()` into a `deinit → deinit` self-loop).
+ */
+function isVisibleMemberStore(input, name, bindings, options) {
+    const regionIds = bindings.memberStoreRegionIdsByName.get(name);
+    if (regionIds !== undefined) {
+        const providerOwner = options.lexicalFunctionOwner?.(input);
+        if (providerOwner !== undefined && regionIds.has(providerOwner.id))
+            return true;
+        let node = input;
+        while (node !== null) {
+            if (regionIds.has(node.id))
+                return true;
+            node = node.parent;
+        }
+    }
+    return visibleCallableSignature(input, name, bindings, options) !== undefined;
+}
 function visibleCallableSignature(input, name, bindings, options) {
     const byRegion = bindings.signatureByNameAndRegion.get(name);
     if (byRegion === undefined)
@@ -472,9 +510,15 @@ function emitCallFacts(call, knownCallableNames, valueBindings, options, out) {
     const member = directCallMemberParts(call, options) ?? memberParts(calleeNode, options);
     const callee = operandSyntax(calleeNode, options);
     const calleeIsValueBinding = callee !== undefined && isVisibleValueBinding(call, callee.name, valueBindings, options);
+    // A direct callee NAME exists only when the call spells its callee as a
+    // designator (`f(x)`, `ns.f(x)`). A receiver-less member (Zig's decl
+    // literal `.init(x)`, whose receiver is an inferred type) or a computed
+    // callee names nothing the solver may seed by simple name — doing so
+    // fanned each argument out to every same-named callable in the repo.
     const directCalleeName = member === undefined &&
         callee !== undefined &&
         callee.indirection === 0 &&
+        callee.directDesignator &&
         !calleeIsValueBinding
         ? callee.name
         : undefined;
@@ -551,7 +595,7 @@ function emitCallFacts(call, knownCallableNames, valueBindings, options, out) {
         // name-keyed field collapse matches the solver's store/load model.
         // ponytail: same-region joins only — cross-function vtable installs need
         // a field-sensitive cell model.
-        if (isVisibleValueBinding(call, member.member.name, valueBindings, options)) {
+        if (isVisibleMemberStore(call, member.member.name, valueBindings, options)) {
             emitInvoke(callSite, member.member, 'indirect', args.length, out, options, member.receiver);
         }
         return;
@@ -605,6 +649,9 @@ function emitInvoke(call, callee, invocationKind, arity, out, options, receiver)
     }
 }
 function callArguments(call, options) {
+    const providerArguments = options.extractCallArguments?.(call);
+    if (providerArguments !== undefined)
+        return providerArguments;
     const list = call.childForFieldName('arguments') ??
         call.childForFieldName('argument') ??
         call.namedChildren.find((child) => child !== null && options.parameterListNodeTypes.has(child.type)) ??
@@ -645,9 +692,17 @@ function memberParts(input, options) {
     const receiverNode = node.childForFieldName('object') ??
         node.childForFieldName('argument') ??
         node.childForFieldName('receiver');
+    // `member` is the field name tree-sitter grammars use when the receiver
+    // field is `object` (Zig `field_expression`). It is only read once a
+    // receiver field matched: the other grammars that expose a `member` field
+    // (C/C++ `offsetof_expression`, JS `class_body`) carry no receiver field and
+    // stay unaffected. Without it every `x.f(arg)` in such a grammar collapsed
+    // to a DIRECT call named `f` and the flow solver fanned the argument out to
+    // every same-named callable.
     const memberNode = node.childForFieldName('property') ??
         node.childForFieldName('field') ??
-        node.childForFieldName('method');
+        node.childForFieldName('method') ??
+        node.childForFieldName('member');
     if (receiverNode === null || memberNode === null)
         return undefined;
     const receiver = operandSyntax(receiverNode, options);
@@ -751,7 +806,13 @@ function wrappedExpression(node) {
         node.childForFieldName('value');
     if (field !== null && field.id !== node.id && node.namedChildCount === 1)
         return field;
-    if (node.type.includes('parenthesized') ||
+    // `await` is a wrapper, not a callee: tree-sitter-typescript parses
+    // `await f<T>(x)` as `call_expression(function: await_expression(f), …)`,
+    // and `await_expression` carries its operand without a field name, so the
+    // field-based unwrap above misses it. Unwrapping keeps `f` a direct
+    // designator (`direct-callee-name`), as it is for the un-awaited spelling.
+    if (node.type.includes('await_expression') ||
+        node.type.includes('parenthesized') ||
         node.type.includes('reference_expression') ||
         node.type.includes('pointer_expression') ||
         node.type.includes('unary_expression') ||

package/dist/core/ingestion/utils/test-file-path.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Test-file path classification — the single source of truth.
+ *
+ * WHY THIS MODULE EXISTS
+ *
+ * Two independent copies of this predicate existed and had drifted apart:
+ *
+ *   - `core/ingestion/entry-point-scoring.ts` `isTestFile`  — excludes test
+ *     files from process entry-point detection.
+ *   - `mcp/local/local-backend.ts` `isTestFilePath`         — backs the
+ *     `includeTests` flag on `impact` / `trace` / `context`.
+ *
+ * They answered "is this a test file?" differently, so the same path could be a
+ * test in one code path and not the other. The MCP copy recognized no C#, Java,
+ * or Swift test convention at all, meaning `includeTests: false` silently failed
+ * to filter them; the scoring copy missed `/conftest.` (it already matched
+ * `/test/`, so `/test/fixtures/` was never a scoring gap).
+ *
+ * The duplication was not gratuitous: `entry-point-scoring.ts` imports the
+ * language-provider registry, and #2802 deliberately cut that closure out of MCP
+ * server startup. Importing it back into `local-backend.ts` would reintroduce
+ * that cost. So the shared predicate lives here instead, with NO imports — pure
+ * string matching — and both callers delegate to it.
+ *
+ * Keep it dependency-free. Anything imported here lands in MCP startup.
+ */
+/** Absent / empty paths are not test paths. */
+export declare function isTestFilePath(filePath: string | null | undefined): boolean;

package/dist/core/ingestion/utils/test-file-path.js

@@ -0,0 +1,87 @@
+/**
+ * Test-file path classification — the single source of truth.
+ *
+ * WHY THIS MODULE EXISTS
+ *
+ * Two independent copies of this predicate existed and had drifted apart:
+ *
+ *   - `core/ingestion/entry-point-scoring.ts` `isTestFile`  — excludes test
+ *     files from process entry-point detection.
+ *   - `mcp/local/local-backend.ts` `isTestFilePath`         — backs the
+ *     `includeTests` flag on `impact` / `trace` / `context`.
+ *
+ * They answered "is this a test file?" differently, so the same path could be a
+ * test in one code path and not the other. The MCP copy recognized no C#, Java,
+ * or Swift test convention at all, meaning `includeTests: false` silently failed
+ * to filter them; the scoring copy missed `/conftest.` (it already matched
+ * `/test/`, so `/test/fixtures/` was never a scoring gap).
+ *
+ * The duplication was not gratuitous: `entry-point-scoring.ts` imports the
+ * language-provider registry, and #2802 deliberately cut that closure out of MCP
+ * server startup. Importing it back into `local-backend.ts` would reintroduce
+ * that cost. So the shared predicate lives here instead, with NO imports — pure
+ * string matching — and both callers delegate to it.
+ *
+ * Keep it dependency-free. Anything imported here lands in MCP startup.
+ */
+/**
+ * Lowercase forward-slash path substrings. Directory needles include a leading
+ * slash so they match path components after the caller slash-prefixes relative
+ * paths. `/test/` already covers Maven `src/test` and `/test/fixtures/`;
+ * `/tests/` covers Laravel `tests/Feature` and `/tests/fixtures/`.
+ */
+const TEST_PATH_SUBSTRINGS = [
+    '.test.',
+    '.spec.',
+    '__tests__/',
+    '__mocks__/',
+    '/test/',
+    '/tests/',
+    '/testing/',
+    '/spec/',
+    '/test_',
+    '/conftest.',
+    '/uitests/',
+    '.tests/',
+    '.test/',
+    '.integrationtests/',
+    '.unittests/',
+    '/testproject/',
+];
+/** Case-insensitive suffixes that already include a delimiter (`_test.py`, not `test.py`). */
+const TEST_PATH_DELIMITED_SUFFIXES = [
+    '_test.py',
+    '_test.go',
+    '_spec.rb',
+    '_test.rb',
+];
+/**
+ * Case-sensitive `Test`/`Tests`/`Spec` suffixes. Lowercasing first would also
+ * match production names such as `Contest.swift` and `Latest.php`.
+ */
+const TEST_PATH_CASED_SUFFIXES = [
+    'Tests.swift',
+    'Test.swift',
+    'Tests.cs',
+    'Test.cs',
+    'Test.php',
+    'Spec.php',
+];
+/** Absent / empty paths are not test paths. */
+export function isTestFilePath(filePath) {
+    if (!filePath)
+        return false;
+    const slashed = filePath.replace(/\\/g, '/');
+    const prefixed = slashed.startsWith('/') ? slashed : `/${slashed}`;
+    const lower = prefixed.toLowerCase();
+    if (TEST_PATH_SUBSTRINGS.some((needle) => lower.includes(needle)))
+        return true;
+    if (TEST_PATH_DELIMITED_SUFFIXES.some((suffix) => lower.endsWith(suffix)))
+        return true;
+    // Xcode `{Product}UITests` targets. Slash-anchored `/uitests/` does not match
+    // `MyAppUITests`; an unanchored `uitests/` substring also matches `fruitests`.
+    if (prefixed.split('/').some((seg) => seg.endsWith('UITests')))
+        return true;
+    const basename = prefixed.slice(prefixed.lastIndexOf('/') + 1);
+    return TEST_PATH_CASED_SUFFIXES.some((suffix) => basename.endsWith(suffix));
+}

package/dist/core/ingestion/variable-extractors/configs/zig.d.ts

@@ -0,0 +1,2 @@
+import type { VariableExtractionConfig } from '../../variable-types.js';
+export declare const zigVariableConfig: VariableExtractionConfig;

package/dist/core/ingestion/variable-extractors/configs/zig.js

@@ -0,0 +1,71 @@
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { hasZigPubKeyword } from '../../export-detection.js';
+import { isZigKeywordDeclaration, isZigTypeShadowingBinding, } from '../../languages/zig/captures.js';
+/**
+ * Zig variable extraction — enriches the Const / Variable nodes minted by
+ * ZIG_QUERIES' `@definition.const` / `@definition.variable` rules.
+ *
+ * tree-sitter-zig uses a single `variable_declaration` node for both `const`
+ * and `var` bindings — AND for statement assignments (`x = 5;`), which carry
+ * no keyword. The keyword is exposed as an unnamed token child
+ * (`type === 'const'` or `type === 'var'`).
+ *
+ * Excludes variable_declarations whose value is a struct/enum/union or an
+ * `@import(...)` builtin — those are handled by the class extractor / import
+ * pipeline, and a Variable record beside the Struct/Enum/Union node (or the
+ * import edge) would be a duplicate. `extractName` returns undefined for them,
+ * which is the generic extractor's skip signal (see `generic.ts`, and Python's
+ * broad `expression_statement` config for the same pattern).
+ */
+const isVarKeyword = (node) => {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child?.type === 'var')
+            return true;
+    }
+    return false;
+};
+export const zigVariableConfig = {
+    language: SupportedLanguages.Zig,
+    constNodeTypes: ['variable_declaration'],
+    staticNodeTypes: [],
+    variableNodeTypes: [],
+    extractName(node) {
+        if (isZigTypeShadowingBinding(node))
+            return undefined;
+        // Statement assignments share the node type and have no keyword — not a
+        // declaration (belt to the query's literal `"const"` / `"var"` brace).
+        if (!isZigKeywordDeclaration(node))
+            return undefined;
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'identifier')
+                return child.text;
+        }
+        return undefined;
+    },
+    extractType(node) {
+        // tree-sitter-zig 1.1.2 exposes the annotation as the `type:` field of
+        // variable_declaration (its only field; verified by AST dump: `const p:
+        // *Foo = …` → `pointer_type [type]`, `extern var f: T;` → `identifier
+        // [type]`). Reading the field covers every annotation shape (builtin,
+        // identifier, pointer/optional/slice/array/fn types) and, just as
+        // importantly, never mistakes an initializer for a type: `const f =
+        // target;` has no `type:` field, so it is untyped — the old positional
+        // fallback returned `target` as its type.
+        return node.childForFieldName('type')?.text?.trim();
+    },
+    extractVisibility(node) {
+        // `pub` only — `export var` is C linkage, private to other Zig files.
+        return hasZigPubKeyword(node) ? 'public' : 'private';
+    },
+    isConst(node) {
+        return !isVarKeyword(node);
+    },
+    isStatic() {
+        return false;
+    },
+    isMutable(node) {
+        return isVarKeyword(node);
+    },
+};