gitnexus 1.6.11-rc.8 → 1.6.11

package/dist/core/ingestion/language-config.js

@@ -440,6 +440,724 @@ export async function loadSwiftPackageConfig(repoRoot) {
     }
     return null;
 }
+/**
+ * Load the Zig build configuration a repo's `build.zig.zon` + root `build.zig`
+ * declare: `.path` deps (and the roots their own build.zig names) from the
+ * zon, and the repo's own named modules from the root build.zig. Either file
+ * may be missing — a repo with a `build.zig` but no `build.zig.zon` still
+ * resolves `@import("<own module>")`. Null only when neither contributes.
+ *
+ * `build.zig.zon` is Zig source (an anonymous-struct literal), not JSON.
+ * Rather than pull in a tree-sitter parse for one file, we use a small
+ * regex-based extractor that handles the common shapes:
+ *
+ *   .dependencies = .{
+ *       .ziggit_pkg = .{
+ *           .url = "https://...",
+ *           .hash = "1220...",
+ *       },
+ *       .local_dep = .{
+ *           .path = "../local_dep",
+ *       },
+ *   },
+ *
+ * Limitations (intentional — bail to null on anything weirder):
+ *   - Only the top-level `.dependencies = .{ ... }` block is parsed (brace
+ *     depth 1); a same-named field nested in another struct is ignored.
+ *   - Each dep entry is matched by a single shape: `.<name> = .{ ... }`
+ *     where `<name>` is a bare identifier (no `@"…"` quoted form).
+ *   - Only `.path = "..."` is captured. `.url` deps are left unresolved
+ *     because their unpacked location lives outside the repo
+ *     (.zig-cache/p/<hash>/ or ~/.cache/zig/p/<hash>/) and is therefore
+ *     not in our `allFilePaths` set.
+ *   - `//` line comments are stripped before scanning (string-aware, so a
+ *     `//` inside `.url = "https://…"` survives), and brace matching skips
+ *     string literals — a commented-out `.path` or a `}` inside a comment
+ *     or string cannot declare a dep or truncate the block.
+ */
+export async function loadZigBuildConfig(repoRoot) {
+    let config = null;
+    try {
+        const raw = await fs.readFile(path.join(repoRoot, 'build.zig.zon'), 'utf-8');
+        config = parseZigBuildZon(raw);
+    }
+    catch {
+        // No zon (or unreadable): the root build.zig may still declare modules.
+    }
+    // The repo's own importable modules, from its root build.zig. Independent
+    // of the zon: `@import("<own module>")` is how single-package repos refer
+    // to their root file from every other file.
+    let rootModules;
+    let rootBuildZig = null;
+    try {
+        rootBuildZig = await fs.readFile(path.join(repoRoot, 'build.zig'), 'utf-8');
+        const parsed = parseZigRootModules(rootBuildZig);
+        if (parsed.size > 0)
+            rootModules = parsed;
+    }
+    catch {
+        // No root build.zig — nothing to declare.
+    }
+    if (config === null) {
+        if (rootBuildZig === null)
+            return null;
+        // No zon: no path deps, so `dep.module(…)` operands resolve to nothing.
+        const buildModules = parseZigBuildModules(rootBuildZig);
+        if (!rootModules && buildModules.length === 0)
+            return null;
+        return {
+            pathDeps: new Map(),
+            ...(rootModules ? { rootModules } : {}),
+            ...(buildModules.length > 0 ? { buildModules } : {}),
+        };
+    }
+    // A path dep's importable root is whatever ITS build.zig declares, not a
+    // fixed layout: read `root_source_file` per `addModule` and remember it
+    // repo-relative. Best effort — an unreadable build.zig just leaves the
+    // conventional-layout fallback in place.
+    const moduleRoots = new Map();
+    // Per path dep: the modules its build.zig NAMES (`addModule("core", …)`),
+    // repo-relative — what a root-build.zig `dep.module("core")` operand means.
+    const depModules = new Map();
+    for (const [depName, depPath] of config.pathDeps) {
+        const rel = normalizeZigDepPath(depPath);
+        if (rel === null)
+            continue;
+        let buildZig;
+        try {
+            buildZig = await fs.readFile(path.join(repoRoot, rel, 'build.zig'), 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const prefixed = (r) => (rel === '' ? r : `${rel}/${r}`);
+        const roots = parseZigBuildModuleRoots(buildZig, depName).map(prefixed);
+        if (roots.length > 0)
+            moduleRoots.set(depName, roots);
+        const named = new Map();
+        for (const mod of parseZigBuildModules(buildZig)) {
+            if (mod.name !== undefined && !named.has(mod.name))
+                named.set(mod.name, prefixed(mod.root));
+        }
+        if (named.size > 0)
+            depModules.set(depName, named);
+    }
+    const buildModules = rootBuildZig === null ? [] : parseZigBuildModules(rootBuildZig, depModules);
+    return {
+        ...config,
+        ...(moduleRoots.size > 0 ? { moduleRoots } : {}),
+        ...(rootModules ? { rootModules } : {}),
+        ...(buildModules.length > 0 ? { buildModules } : {}),
+    };
+}
+/**
+ * Normalize a `.path` value from build.zig.zon into a repo-relative form.
+ * Returns null for paths that escape the repo root (start with `..`) or
+ * are absolute — those point to files we don't index. `.` / `./` normalize
+ * to the empty string (the repo root itself). Shared with the import
+ * resolver so both sides agree on which deps are in-repo.
+ */
+export function normalizeZigDepPath(depPath) {
+    // Normalize separators BEFORE the absolute check so every Windows spelling
+    // is visible to it: POSIX (`/x`), drive (`C:\x`, `C:/x`), root-relative
+    // (`\x` → `/x`) and UNC (`\\server\share` → `//server/share`) paths all
+    // point outside the repository.
+    const normalized = depPath.replace(/\\/g, '/');
+    if (normalized.startsWith('/') || /^[A-Za-z]:\//.test(normalized))
+        return null;
+    const parts = [];
+    for (const part of normalized.split('/')) {
+        if (part === '' || part === '.')
+            continue;
+        if (part === '..') {
+            if (parts.length === 0)
+                return null;
+            parts.pop();
+        }
+        else {
+            parts.push(part);
+        }
+    }
+    return parts.join('/');
+}
+/**
+ * The `root_source_file` paths a `build.zig` declares, dep-relative, with the
+ * module whose `addModule("<name>", …)` name equals `preferredName` first.
+ *
+ * Reads two shapes, which between them cover `zig init` output and the
+ * common hand-written build scripts:
+ *   - `b.addModule("name", .{ .root_source_file = b.path("src/root.zig") })`
+ *   - any other `.root_source_file = b.path("…")` (exe/lib/test artifacts),
+ *     kept as unnamed fallbacks in file order.
+ * A `.zig` under `b.path` is required — `.{ .cwd_relative = … }` and
+ * `LazyPath` values computed at build time are not resolvable statically and
+ * are skipped. Duplicates collapse to the first occurrence.
+ */
+export function parseZigBuildModuleRoots(buildZig, preferredName) {
+    const named = [];
+    const unnamed = [];
+    const seen = new Set();
+    const add = (into, p) => {
+        const norm = normalizeZigDepPath(p);
+        if (norm === null || norm === '' || !norm.endsWith('.zig') || seen.has(norm))
+            return;
+        seen.add(norm);
+        into.push(norm);
+    };
+    const rootRe = /\.root_source_file\s*=\s*b\.path\(\s*"([^"\n]+)"\s*\)/;
+    // The named module: scan the whole `addModule(…)` argument list, balanced
+    // on parentheses, so a nested field before `.root_source_file` (`.imports =
+    // &.{ .{ … } }`) does not end the match early — a `[^}]*` regex stopped at
+    // that inner `}` and silently demoted the module to an unnamed fallback.
+    const text = stripZonComments(buildZig);
+    const mask = zonStringMask(text);
+    const callRe = /\baddModule\s*\(/g;
+    let m;
+    while ((m = callRe.exec(text)) !== null) {
+        if (mask[m.index] !== 0)
+            continue;
+        const argsStart = m.index + m[0].length;
+        const argsEnd = findZigParenEnd(text, argsStart);
+        if (argsEnd < 0)
+            break;
+        const args = text.slice(argsStart, argsEnd);
+        const nameMatch = /^\s*"([^"\n]+)"\s*,/.exec(args);
+        if (nameMatch?.[1] !== preferredName)
+            continue;
+        const root = zigTopLevelStaticRoot(args);
+        if (root !== null)
+            add(named, root);
+    }
+    const anyRe = new RegExp(rootRe.source, 'g');
+    while ((m = anyRe.exec(text)) !== null)
+        add(unnamed, m[1]);
+    return [...named, ...unnamed];
+}
+/**
+ * The importable modules a repo's ROOT `build.zig` declares, module name →
+ * repo-relative root source file. Static scan (no execution) of two shapes:
+ *
+ *   - `b.addModule("<name>", .{ .root_source_file = b.path("<p>.zig"), … })`
+ *     names the module directly;
+ *   - `const m = b.createModule(.{ .root_source_file = b.path("<p>.zig"), … })`
+ *     (or `const m = b.addModule(…)`) bound to an identifier and later named
+ *     by `x.addImport("<name>", m)` or `.imports = &.{ .{ .name = "<name>",
+ *     .module = m } }`.
+ *
+ * Deliberately NOT resolved — they are not in-repo source files: modules whose
+ * root is not a static `b.path("….zig")` (generated `opts.createModule()` from
+ * `addOptions`, `translate_c.createModule()`, `.cwd_relative` / computed
+ * LazyPaths), `addImport("<name>", dep.module("…"))` (a `.url` / path dep,
+ * handled through the zon), and aliases whose module operand is anything but a
+ * bare identifier bound above (`config.lp_module`). Comments are stripped and
+ * string literals skipped; the first declaration of a name wins.
+ */
+export function parseZigRootModules(buildZig) {
+    const text = stripZonComments(buildZig);
+    const mask = zonStringMask(text);
+    const modules = new Map();
+    // identifier → repo-relative root, for `const m = b.createModule(…)` /
+    // `const m = b.addModule(…)` bindings later named via addImport.
+    const bindings = new Map();
+    const callRe = /\b(addModule|createModule)\s*\(/g;
+    let m;
+    while ((m = callRe.exec(text)) !== null) {
+        if (mask[m.index] !== 0)
+            continue;
+        const argsStart = m.index + m[0].length;
+        const argsEnd = findZigParenEnd(text, argsStart);
+        if (argsEnd < 0)
+            break;
+        const args = text.slice(argsStart, argsEnd);
+        const root = zigTopLevelStaticRoot(args);
+        if (root === null)
+            continue;
+        if (m[1] === 'addModule') {
+            const nameMatch = /^\s*"([^"\n]+)"\s*,/.exec(args);
+            if (nameMatch && !modules.has(nameMatch[1]))
+                modules.set(nameMatch[1], root);
+        }
+        const binding = ZIG_MODULE_BINDING_RE.exec(text.slice(0, m.index));
+        if (binding && !bindings.has(binding[1]))
+            bindings.set(binding[1], root);
+    }
+    if (bindings.size === 0)
+        return modules;
+    const aliasRes = [
+        /\.addImport\(\s*"([^"\n]+)"\s*,\s*([A-Za-z_]\w*)\s*\)/g,
+        /\.name\s*=\s*"([^"\n]+)"\s*,\s*\.module\s*=\s*([A-Za-z_]\w*)\s*[,}]/g,
+    ];
+    for (const re of aliasRes) {
+        while ((m = re.exec(text)) !== null) {
+            if (mask[m.index] !== 0)
+                continue;
+            const root = bindings.get(m[2]);
+            if (root !== undefined && !modules.has(m[1]))
+                modules.set(m[1], root);
+        }
+    }
+    return modules;
+}
+/**
+ * Every build module the ROOT `build.zig` declares, each with its OWN import
+ * table (`ZigBuildModule`). Static scan (no execution) of:
+ *
+ *   - `b.addModule("<name>", .{ .root_source_file = b.path("<p>.zig"), … })`
+ *     and `const m = b.createModule(.{ .root_source_file = … })` — a module,
+ *     bound to the identifier a preceding `const m =` names;
+ *   - `b.addExecutable` / `addLibrary` / `addStaticLibrary` /
+ *     `addSharedLibrary` / `addTest` / `addObject(.{ .root_source_file =
+ *     b.path("<p>.zig"), … })` — an artifact whose ROOT MODULE is a module of
+ *     its own (reached as `exe.root_module.addImport(…)`), or `.root_module =
+ *     m` / `.root_module = b.createModule(…)` naming one declared inline;
+ *   - `<m>.addImport("<alias>", <operand>)`, `<exe>.root_module.addImport(…)`
+ *     and the `.imports = &.{ .{ .name = "<alias>", .module = <operand> } }`
+ *     field of a module's own arguments — an entry in THAT module's table.
+ *     The operand is a module binding (`m`) or a path dep's named module,
+ *     `dep.module("<name>")` with `const dep = b.dependency("<zon name>", …)`,
+ *     looked up in `depModules` (zon dep name → module name → repo-relative
+ *     root, from the dep's own build.zig).
+ *
+ * Why per module rather than one map (`parseZigRootModules`): an alias is
+ * scoped to the module that declares it. Two executables that each
+ * `addImport("config", …)` their own `config.zig` are the ordinary
+ * multi-target layout, and a single first-wins map sent the second module's
+ * `@import("config")` to the first module's file — a confident wrong
+ * `IMPORTS` edge and every `config.*` call behind it. Deliberately NOT
+ * resolved, as in `parseZigRootModules`: generated roots
+ * (`addOptions().createModule()`, `translate_c.createModule()`, computed
+ * LazyPaths), `.url` deps, and operands that are not a bare identifier or a
+ * `dep.module("…")` on a `b.dependency` binding. Comments stripped, string
+ * literals masked; the first binding of an identifier wins.
+ */
+export function parseZigBuildModules(buildZig, depModules) {
+    const text = stripZonComments(buildZig);
+    const mask = zonStringMask(text);
+    const drafts = [];
+    const bindings = new Map(); // identifier → drafts index
+    const bind = (prefixEnd, idx) => {
+        const binding = ZIG_MODULE_BINDING_RE.exec(text.slice(0, prefixEnd));
+        if (binding && !bindings.has(binding[1]))
+            bindings.set(binding[1], idx);
+    };
+    // Artifact bindings whose `.root_module = <ident>` names a module declared
+    // by another call; resolved once every binding is known.
+    const pendingArtifactAliases = [];
+    const callRe = /\b(addModule|createModule|addExecutable|addLibrary|addStaticLibrary|addSharedLibrary|addTest|addObject)\s*\(/g;
+    let m;
+    while ((m = callRe.exec(text)) !== null) {
+        if (mask[m.index] !== 0)
+            continue;
+        const argsStart = m.index + m[0].length;
+        const argsEnd = findZigParenEnd(text, argsStart);
+        if (argsEnd < 0)
+            break;
+        const args = text.slice(argsStart, argsEnd);
+        const kind = m[1];
+        if (kind === 'addModule' || kind === 'createModule') {
+            const root = zigTopLevelStaticRoot(args);
+            if (root === null)
+                continue;
+            const nameMatch = kind === 'addModule' ? /^\s*"([^"\n]+)"\s*,/.exec(args) : null;
+            drafts.push({
+                ...(nameMatch ? { name: nameMatch[1] } : {}),
+                root,
+                at: m.index,
+                argsStart,
+                argsEnd,
+                imports: new Map(),
+            });
+            bind(m.index, drafts.length - 1);
+            continue;
+        }
+        // An artifact. Its root module is either declared inline by
+        // `.root_source_file`, or handed over through `.root_module = …`.
+        const rootModule = /\.root_module\s*=\s*((?:[A-Za-z_]\w*\.)*)([A-Za-z_]\w*)\s*(\()?/.exec(args);
+        if (rootModule) {
+            if (rootModule[3] === '(' && rootModule[2] === 'createModule') {
+                // Inline `.root_module = b.createModule(.{ … })`: the module is minted
+                // by the createModule call inside these args (a later iteration of
+                // this loop); remember the artifact's binding for it.
+                const nameOffset = rootModule.index + rootModule[0].lastIndexOf('createModule');
+                const binding = ZIG_MODULE_BINDING_RE.exec(text.slice(0, m.index));
+                if (binding) {
+                    pendingArtifactAliases.push({
+                        ident: binding[1],
+                        module: `@${argsStart + nameOffset}`,
+                    });
+                }
+            }
+            else if (rootModule[1] === '' && rootModule[3] === undefined) {
+                const binding = ZIG_MODULE_BINDING_RE.exec(text.slice(0, m.index));
+                if (binding)
+                    pendingArtifactAliases.push({ ident: binding[1], module: rootModule[2] });
+            }
+            continue;
+        }
+        const root = zigTopLevelStaticRoot(args);
+        if (root === null)
+            continue;
+        drafts.push({ root, at: m.index, argsStart, argsEnd, imports: new Map() });
+        bind(m.index, drafts.length - 1);
+    }
+    for (const alias of pendingArtifactAliases) {
+        if (bindings.has(alias.ident))
+            continue;
+        const idx = alias.module.startsWith('@')
+            ? drafts.findIndex((d) => d.at === Number(alias.module.slice(1)))
+            : (bindings.get(alias.module) ?? -1);
+        if (idx >= 0)
+            bindings.set(alias.ident, idx);
+    }
+    if (drafts.length === 0)
+        return [];
+    // `const dep = b.dependency("<zon name>", …)` bindings, for `dep.module("…")`.
+    const dependencyBindings = new Map();
+    const depRe = /(?:const|var)\s+([A-Za-z_]\w*)\s*=\s*(?:[A-Za-z_]\w*\.)*dependency\(\s*"([^"\n]+)"/g;
+    while ((m = depRe.exec(text)) !== null) {
+        if (mask[m.index] !== 0)
+            continue;
+        if (!dependencyBindings.has(m[1]))
+            dependencyBindings.set(m[1], m[2]);
+    }
+    // An import operand → the repo-relative root it names, or null.
+    const operandRoot = (operand) => {
+        const bare = /^([A-Za-z_]\w*)$/.exec(operand);
+        if (bare) {
+            const idx = bindings.get(bare[1]);
+            return idx === undefined ? null : drafts[idx].root;
+        }
+        const viaDep = /^([A-Za-z_]\w*)\.module\(\s*"([^"\n]+)"\s*\)$/.exec(operand);
+        if (viaDep) {
+            const zonName = dependencyBindings.get(viaDep[1]);
+            return zonName === undefined ? null : (depModules?.get(zonName)?.get(viaDep[2]) ?? null);
+        }
+        return null;
+    };
+    const addImport = (idx, alias, operand) => {
+        const root = operandRoot(operand.trim());
+        const table = drafts[idx].imports;
+        if (root !== null && !table.has(alias))
+            table.set(alias, root);
+    };
+    // Pass 2a — `<m>.addImport("<alias>", <operand>)` / `<exe>.root_module.addImport(…)`.
+    const addImportRe = /\b([A-Za-z_]\w*)(?:\.root_module)?\.addImport\s*\(/g;
+    while ((m = addImportRe.exec(text)) !== null) {
+        if (mask[m.index] !== 0)
+            continue;
+        const idx = bindings.get(m[1]);
+        if (idx === undefined)
+            continue;
+        const argsStart = m.index + m[0].length;
+        const argsEnd = findZigParenEnd(text, argsStart);
+        if (argsEnd < 0)
+            break;
+        const args = text.slice(argsStart, argsEnd);
+        const aliasMatch = /^\s*"([^"\n]+)"\s*,/.exec(args);
+        if (!aliasMatch)
+            continue;
+        addImport(idx, aliasMatch[1], args.slice(aliasMatch[0].length));
+    }
+    // Pass 2b — `.imports = &.{ .{ .name = "<alias>", .module = <operand> }, … }`
+    // inside a module's own argument list. The operand runs to the next `,` or
+    // `}` at paren depth 0 (`dep.module("core")` carries parentheses).
+    const entryRe = /\.name\s*=\s*"([^"\n]+)"\s*,\s*\.module\s*=\s*/g;
+    drafts.forEach((draft, idx) => {
+        const args = text.slice(draft.argsStart, draft.argsEnd);
+        let e;
+        while ((e = entryRe.exec(args)) !== null) {
+            if (mask[draft.argsStart + e.index] !== 0)
+                continue;
+            let depth = 0;
+            let end = e.index + e[0].length;
+            for (; end < args.length; end++) {
+                const ch = args[end];
+                if (ch === '(')
+                    depth++;
+                else if (ch === ')') {
+                    if (depth === 0)
+                        break;
+                    depth--;
+                }
+                else if (depth === 0 && (ch === ',' || ch === '}'))
+                    break;
+            }
+            addImport(idx, e[1], args.slice(e.index + e[0].length, end));
+        }
+    });
+    return drafts.map(({ name, root, imports }) => ({
+        ...(name !== undefined ? { name } : {}),
+        root,
+        imports,
+    }));
+}
+/** First `.root_source_file = b.path("….zig")` at the TOP level of a
+ *  module-options `.{ … }` — not a nested `.imports = &.{ .{ … } }` entry. */
+function zigTopLevelStaticRoot(args) {
+    const mask = zonStringMask(args);
+    let structAt = -1;
+    for (let i = 0; i < args.length - 1; i++) {
+        if (mask[i] !== 0)
+            continue;
+        if (args[i] === '.' && args[i + 1] === '{') {
+            structAt = i;
+            break;
+        }
+    }
+    if (structAt < 0)
+        return null;
+    const bodyStart = structAt + 2;
+    const bodyEnd = findZonBlockEnd(args, bodyStart);
+    if (bodyEnd < 0)
+        return null;
+    const match = /\.root_source_file\s*=\s*b\.path\(\s*"([^"\n]+)"\s*\)/.exec(zonBlankNestedBlocks(args.slice(bodyStart, bodyEnd)));
+    if (match === null)
+        return null;
+    const root = normalizeZigDepPath(match[1]);
+    return root === null || root === '' || !root.endsWith('.zig') ? null : root;
+}
+/** `const m = b.createModule` / `const m = b.addModule` — not `config.createModule`. */
+const ZIG_MODULE_BINDING_RE = /(?:const|var)\s+([A-Za-z_]\w*)\s*=\s*b\.$/;
+/**
+ * Index of the `)` matching the `(` that precedes `start`, skipping parens
+ * inside `"…"` literals. -1 when unbalanced. Call on comment-stripped text.
+ */
+function findZigParenEnd(text, start) {
+    let depth = 1;
+    let inString = false;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (ch === '\\')
+                i++;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === '(')
+            depth++;
+        else if (ch === ')' && --depth === 0)
+            return i;
+    }
+    return -1;
+}
+/**
+ * Blank out `//` line comments (and `\\` multiline-string-literal lines) in
+ * ZON source, string-aware: a `//` inside a `"…"` literal (`.url =
+ * "https://…"`) is content, not a comment. Comment bytes are replaced with
+ * spaces so every surviving character keeps its offset.
+ */
+function stripZonComments(raw) {
+    const out = raw.split('');
+    let inString = false;
+    for (let i = 0; i < raw.length; i++) {
+        const ch = raw[i];
+        if (inString) {
+            if (ch === '\\')
+                i++; // skip the escaped char
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        const isLineComment = ch === '/' && raw[i + 1] === '/';
+        const isMultilineLiteral = ch === '\\' &&
+            raw[i + 1] === '\\' &&
+            /^[ \t]*$/.test(raw.slice(raw.lastIndexOf('\n', i) + 1, i));
+        if (isLineComment || isMultilineLiteral) {
+            while (i < raw.length && raw[i] !== '\n')
+                out[i++] = ' ';
+        }
+    }
+    return out.join('');
+}
+/**
+ * Index of the `}` matching the `{` that precedes `start`, skipping braces
+ * inside `"…"` literals. -1 when unbalanced. Call on comment-stripped text.
+ */
+function findZonBlockEnd(text, start) {
+    let depth = 1;
+    let inString = false;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (ch === '\\')
+                i++;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === '{')
+            depth++;
+        else if (ch === '}' && --depth === 0)
+            return i;
+    }
+    return -1;
+}
+/**
+ * `body` with every nested `{ … }` block (string-aware) replaced by spaces of
+ * equal length, so a regex over the result only sees the block's DIRECT
+ * fields and offsets still line up with the original text.
+ */
+function zonBlankNestedBlocks(body) {
+    const out = body.split('');
+    let depth = 0;
+    let inString = false;
+    for (let i = 0; i < body.length; i++) {
+        const ch = body[i];
+        if (inString) {
+            if (ch === '\\') {
+                if (depth > 0 && i + 1 < body.length)
+                    out[i + 1] = ' ';
+                i++;
+            }
+            else if (ch === '"')
+                inString = false;
+            if (depth > 0)
+                out[i] = ' ';
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === '{')
+            depth++;
+        else if (ch === '}' && depth > 0) {
+            depth--;
+            out[i] = ' ';
+            continue;
+        }
+        if (depth > 0)
+            out[i] = ' ';
+    }
+    return out.join('');
+}
+/**
+ * Per-offset "is inside a `"…"` literal" mask for comment-stripped ZON text,
+ * so header regexes can reject a match that merely LOOKS like a field
+ * (`.name = ".dependencies = .{ … }"` is a string, not the dependencies
+ * block). Escaped quotes (`\"`) do not end the literal.
+ */
+function zonStringMask(text) {
+    const mask = new Uint8Array(text.length);
+    let inString = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            mask[i] = 1;
+            if (ch === '\\' && i + 1 < text.length)
+                mask[++i] = 1;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            mask[i] = 1;
+        }
+    }
+    return mask;
+}
+/**
+ * Per-offset brace depth for comment-stripped ZON text, string-aware: the
+ * depth AT an offset is the number of unclosed `{` before it. The file's
+ * top-level `.{` puts every direct field at depth 1.
+ */
+function zonDepthMask(text) {
+    const depth = new Uint8Array(text.length);
+    let d = 0;
+    let inString = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        depth[i] = d;
+        if (inString) {
+            if (ch === '\\' && i + 1 < text.length)
+                depth[++i] = d;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === '{')
+            d++;
+        else if (ch === '}' && d > 0)
+            d--;
+    }
+    return depth;
+}
+/**
+ * First match of a sticky-free global `re` in `text[from, to)` whose start
+ * lies outside a string literal (per `mask`) and, when `depthAt` is given, at
+ * exactly that brace depth (per `depth`). Null when none.
+ */
+function matchZonHeader(text, re, mask, from, to, depth, depthAt) {
+    re.lastIndex = from;
+    let m;
+    while ((m = re.exec(text)) !== null && m.index < to) {
+        if (mask[m.index] !== 0)
+            continue;
+        if (depth !== undefined && depthAt !== undefined && depth[m.index] !== depthAt)
+            continue;
+        return m;
+    }
+    return null;
+}
+/** Pure parser split out for testability. Returns null when no path-deps found. */
+export function parseZigBuildZon(raw) {
+    const text = stripZonComments(raw);
+    const mask = zonStringMask(text);
+    const depth = zonDepthMask(text);
+    // Locate the `.dependencies = .{ ... }` block. Use brace counting because
+    // dep entries are nested anonymous structs and a naive `}` match would stop
+    // early — and only accept a header outside string literals AND at brace
+    // depth 1 (a direct field of the file's top-level `.{`), so neither a
+    // `.name` value spelling `.dependencies = .{` nor a `.dependencies` field
+    // nested in some earlier anonymous struct can hijack it.
+    const depsHeader = matchZonHeader(text, /\.dependencies\s*=\s*\.\{/g, mask, 0, text.length, depth, 1);
+    if (!depsHeader)
+        return null;
+    const start = depsHeader.index + depsHeader[0].length;
+    const end = findZonBlockEnd(text, start);
+    if (end < 0)
+        return null;
+    const pathDeps = new Map();
+    // Walk each `.<name> = .{ ... }` entry inside [start, end); the body ends
+    // at the matching brace (string-aware), not at the first `}` in the text,
+    // and an entry header inside a string (`.url = "…/.x = .{"`) is not an entry.
+    const entryHeaderRe = /\.([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\.\{/g;
+    let cursor = start;
+    let m;
+    while ((m = matchZonHeader(text, entryHeaderRe, mask, cursor, end)) !== null) {
+        const depName = m[1];
+        const bodyStart = m.index + m[0].length;
+        const bodyEnd = findZonBlockEnd(text, bodyStart);
+        if (bodyEnd < 0 || bodyEnd > end)
+            break;
+        cursor = bodyEnd + 1;
+        // Only a `.path` that is a DIRECT field of the entry counts: a nested
+        // object inside the entry (`.foo = .{ .url = "…", .x = .{ .path = "…" } }`)
+        // must not turn a URL dep into a path dep. Blank nested blocks first and
+        // reject a match that starts inside a string literal.
+        const body = zonBlankNestedBlocks(text.slice(bodyStart, bodyEnd));
+        const pathMatch = matchZonHeader(body, /\.path\s*=\s*"([^"\n]+)"/g, mask.subarray(bodyStart, bodyEnd), 0, body.length);
+        if (pathMatch) {
+            pathDeps.set(depName, pathMatch[1]);
+        }
+    }
+    if (pathDeps.size === 0)
+        return null;
+    if (isDev) {
+        logger.info(`📦 Loaded ${pathDeps.size} Zig path-dep(s) from build.zig.zon`);
+    }
+    return { pathDeps };
+}
 /** Load all language-specific configs once for an ingestion run. */
 export async function loadImportConfigs(repoRoot) {
     const csharpScan = await scanCSharpProject(repoRoot);
@@ -450,5 +1168,6 @@ export async function loadImportConfigs(repoRoot) {
         swiftPackageConfig: await loadSwiftPackageConfig(repoRoot),
         csharpConfigs: csharpScan.configs,
         csharpNamespaces: csharpScanToEvidence(csharpScan),
+        zigBuildZon: await loadZigBuildConfig(repoRoot),
     };
 }