build.zig

const std = @import("std");

// Ananke Build System
// Supports multiple targets including native binaries and WASM
pub fn build(b: *std.Build) void {
    // Target options with WASM support
    const target = b.standardTargetOptions(.{
        .default_target = .{
            .cpu_arch = null,
            .os_tag = null,
            .abi = null,
        },
    });

    // Optimization options
    const optimize = b.standardOptimizeOption(.{});

    // Build options for mechanical sympathy optimizations
    // Note: LTO is disabled for tree-sitter parser libraries to prevent symbol stripping
    const cpu_native = b.option(bool, "cpu-native", "Enable native CPU features (-march=native)") orelse false;
    // v0.2.0: Apply strip_symbols to executables (requires updating exe configuration)
    // const strip_symbols = b.option(bool, "strip", "Strip debug symbols from release builds") orelse (optimize == .ReleaseSmall);

    // Build option to enable WASM-specific features
    const wasm_build = b.option(bool, "wasm", "Build for WebAssembly target") orelse false;

    // Build option to enable Claude API integration
    // const enable_claude = b.option(bool, "claude", "Enable Claude API integration") orelse true;
    // It's also possible to define more custom flags to toggle optional features
    // of this build script using `b.option()`. All defined flags (including
    // target and optimize options) will be listed when running `zig build --help`
    // in this directory.

    // Helper function to generate C compiler flags based on optimization level
    // Enables aggressive optimizations for release builds with LTO and CPU-specific features
    const getCFlags = struct {
        fn get(opt: std.builtin.OptimizeMode, lto: bool, native: bool) []const []const u8 {
            return switch (opt) {
                .Debug => &.{ "-std=c11", "-O0", "-g", "-fno-sanitize=undefined" },
                .ReleaseSafe => if (lto)
                    &.{ "-std=c11", "-O2", "-flto", "-fno-omit-frame-pointer", "-fno-sanitize=undefined" }
                else
                    &.{ "-std=c11", "-O2", "-fno-omit-frame-pointer", "-fno-sanitize=undefined" },
                .ReleaseFast => if (lto and native)
                    &.{ "-std=c11", "-O3", "-flto", "-march=native", "-mtune=native", "-fno-sanitize=undefined" }
                else if (lto)
                    &.{ "-std=c11", "-O3", "-flto", "-fno-sanitize=undefined" }
                else if (native)
                    &.{ "-std=c11", "-O3", "-march=native", "-mtune=native", "-fno-sanitize=undefined" }
                else
                    &.{ "-std=c11", "-O3", "-fno-sanitize=undefined" },
                .ReleaseSmall => if (lto)
                    &.{ "-std=c11", "-Os", "-flto", "-fno-sanitize=undefined" }
                else
                    &.{ "-std=c11", "-Os", "-fno-sanitize=undefined" },
            };
        }
    }.get;

    // Tree-sitter support via direct C FFI
    // Note: Requires tree-sitter libraries to be installed via:
    // macOS: brew install tree-sitter
    // Linux: apt-get install libtree-sitter-dev or similar
    //
    // The tree-sitter C library provides the core API for parsing and AST traversal.
    // or /usr/local on Linux. For portability across systems, you may need to adjust
    // these paths or use pkg-config to detect the correct location.

    // Tree-sitter module for direct C FFI bindings
    // CRITICAL: This module must be configured with C include paths and system library linkage
    // so that @cImport in c_api.zig can find tree_sitter/api.h
    const tree_sitter_mod = b.addModule("tree_sitter", .{
        .root_source_file = b.path("src/clew/tree_sitter.zig"),
        .target = target,
        .link_libc = true,
    });

    // Configure tree-sitter system library and include paths
    // This ensures tree_sitter/api.h can be found by @cImport in c_api.zig
    tree_sitter_mod.linkSystemLibrary("tree-sitter", .{});

    // On Linux, explicitly add /usr/local/include for tree-sitter headers
    // This is where our source-built tree-sitter installs headers
    if (target.result.os.tag == .linux) {
        tree_sitter_mod.addSystemIncludePath(.{ .cwd_relative = "/usr/local/include" });
    }

    // Tree-sitter language parsers as static libraries
    // IMPORTANT: Disable LTO for parser libraries to prevent symbol stripping
    // TypeScript parser
    const ts_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-typescript",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    ts_parser_lib.addIncludePath(b.path("vendor/tree-sitter-typescript/typescript/src"));
    // The common scanner needs to find tree_sitter/parser.h from the tsx source dir
    ts_parser_lib.addIncludePath(b.path("vendor/tree-sitter-typescript/tsx/src"));
    ts_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-typescript/typescript/src"),
        .files = &.{ "parser.c", "scanner.c" },
        .flags = getCFlags(optimize, false, cpu_native), // Disable LTO for parsers
    });

    // Python parser
    const py_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-python",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    py_parser_lib.addIncludePath(b.path("vendor/tree-sitter-python/src"));
    py_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-python/src"),
        .files = &.{ "parser.c", "scanner.c" },
        .flags = getCFlags(optimize, false, cpu_native), // Disable LTO for parsers
    });

    // JavaScript parser
    const js_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-javascript",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    js_parser_lib.addIncludePath(b.path("vendor/tree-sitter-javascript/src"));
    js_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-javascript/src"),
        .files = &.{ "parser.c", "scanner.c" },
        .flags = getCFlags(optimize, false, cpu_native), // Disable LTO for parsers
    });

    // Rust parser
    const rust_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-rust",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    rust_parser_lib.addIncludePath(b.path("vendor/tree-sitter-rust/src"));
    rust_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-rust/src"),
        .files = &.{ "parser.c", "scanner.c" },
        .flags = getCFlags(optimize, false, cpu_native), // Disable LTO for parsers
    });

    // Go parser
    const go_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-go",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    go_parser_lib.addIncludePath(b.path("vendor/tree-sitter-go/src"));
    go_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-go/src"),
        .files = &.{"parser.c"},
        .flags = getCFlags(optimize, false, cpu_native), // Disable LTO for parsers
    });

    // Zig parser
    const zig_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-zig",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    zig_parser_lib.addIncludePath(b.path("vendor/tree-sitter-zig/src"));
    zig_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-zig/src"),
        .files = &.{"parser.c"},
        .flags = getCFlags(optimize, false, cpu_native), // Disable LTO for parsers
    });

    // C parser
    const c_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-c",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    c_parser_lib.addIncludePath(b.path("vendor/tree-sitter-c/src"));
    c_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-c/src"),
        .files = &.{"parser.c"},
        .flags = getCFlags(optimize, false, cpu_native), // Disable LTO for parsers
    });

    // C++ parser
    const cpp_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-cpp",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    cpp_parser_lib.addIncludePath(b.path("vendor/tree-sitter-cpp/src"));
    cpp_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-cpp/src"),
        .files = &.{ "parser.c", "scanner.c" },
        .flags = getCFlags(optimize, false, cpu_native), // Disable LTO for parsers
    });

    // Java parser
    const java_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-java",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    java_parser_lib.addIncludePath(b.path("vendor/tree-sitter-java/src"));
    java_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-java/src"),
        .files = &.{"parser.c"},
        .flags = getCFlags(optimize, false, cpu_native), // Disable LTO for parsers
    });

    // Kotlin parser
    const kotlin_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-kotlin",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    kotlin_parser_lib.addIncludePath(b.path("vendor/tree-sitter-kotlin/src"));
    kotlin_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-kotlin/src"),
        .files = &.{ "parser.c", "scanner.c" },
        .flags = getCFlags(optimize, false, cpu_native),
    });

    // C# parser
    const csharp_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-c-sharp",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    csharp_parser_lib.addIncludePath(b.path("vendor/tree-sitter-c-sharp/src"));
    csharp_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-c-sharp/src"),
        .files = &.{ "parser.c", "scanner.c" },
        .flags = getCFlags(optimize, false, cpu_native),
    });

    // Ruby parser
    const ruby_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-ruby",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    ruby_parser_lib.addIncludePath(b.path("vendor/tree-sitter-ruby/src"));
    ruby_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-ruby/src"),
        .files = &.{ "parser.c", "scanner.c" },
        .flags = getCFlags(optimize, false, cpu_native),
    });

    // PHP parser (nested php/src/ structure)
    const php_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-php",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    php_parser_lib.addIncludePath(b.path("vendor/tree-sitter-php/php/src"));
    php_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-php/php/src"),
        .files = &.{ "parser.c", "scanner.c" },
        .flags = getCFlags(optimize, false, cpu_native),
    });

    // Swift parser
    const swift_parser_lib = b.addLibrary(.{
        .name = "tree-sitter-swift",
        .linkage = .static,
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });
    swift_parser_lib.addIncludePath(b.path("vendor/tree-sitter-swift/src"));
    swift_parser_lib.addCSourceFiles(.{
        .root = b.path("vendor/tree-sitter-swift/src"),
        .files = &.{ "parser.c", "scanner.c" },
        .flags = getCFlags(optimize, false, cpu_native),
    });

    // All tree-sitter parser libraries as a tuple for DRY linkage
    const parser_libs = .{
        ts_parser_lib,     py_parser_lib,     js_parser_lib,
        rust_parser_lib,   go_parser_lib,     zig_parser_lib,
        c_parser_lib,      cpp_parser_lib,    java_parser_lib,
        kotlin_parser_lib, csharp_parser_lib, ruby_parser_lib,
        php_parser_lib,    swift_parser_lib,
    };

    // Install all tree-sitter parser libraries so they can be used by examples and other dependents
    inline for (parser_libs) |pl| b.installArtifact(pl);

    // Core Ananke modules
    // Note: We need to create modules first, then add imports after

    // API modules (http and claude)
    const http_mod = b.addModule("http", .{
        .root_source_file = b.path("src/api/http.zig"),
        .target = target,
    });

    const claude_mod = b.addModule("claude", .{
        .root_source_file = b.path("src/api/claude.zig"),
        .target = target,
    });
    claude_mod.addImport("http", http_mod);

    // Main Ananke module (declared first so we can reference it)
    const ananke_mod = b.addModule("ananke", .{
        .root_source_file = b.path("src/root.zig"),
        .target = target,
    });

    // Clew: Constraint extraction engine
    const clew_mod = b.addModule("clew", .{
        .root_source_file = b.path("src/clew/clew.zig"),
        .target = target,
        .link_libc = true,
    });
    clew_mod.addImport("ananke", ananke_mod);
    clew_mod.addImport("http", http_mod);
    clew_mod.addImport("claude", claude_mod);
    clew_mod.addImport("tree_sitter", tree_sitter_mod);

    // Braid: Constraint compilation engine
    const braid_mod = b.addModule("braid", .{
        .root_source_file = b.path("src/braid/braid.zig"),
        .target = target,
    });
    braid_mod.addImport("ananke", ananke_mod);
    braid_mod.addImport("http", http_mod);
    braid_mod.addImport("claude", claude_mod);

    // Ariadne: Optional DSL compiler
    const ariadne_mod = b.addModule("ariadne", .{
        .root_source_file = b.path("src/ariadne/ariadne.zig"),
        .target = target,
    });
    ariadne_mod.addImport("ananke", ananke_mod);

    // Now add imports to ananke_mod
    ananke_mod.addImport("clew", clew_mod);
    ananke_mod.addImport("braid", braid_mod);
    ananke_mod.addImport("ariadne", ariadne_mod);
    ananke_mod.addImport("http", http_mod);
    ananke_mod.addImport("claude", claude_mod);

    // CLI modules (dependent on ananke)
    const cli_args_mod = b.addModule("cli_args", .{
        .root_source_file = b.path("src/cli/args.zig"),
        .target = target,
    });

    const cli_output_mod = b.addModule("cli_output", .{
        .root_source_file = b.path("src/cli/output.zig"),
        .target = target,
    });
    cli_output_mod.addImport("ananke", ananke_mod);

    const security_mod = b.addModule("security", .{
        .root_source_file = b.path("src/security/secure_string.zig"),
        .target = target,
    });

    const path_validator_mod = b.addModule("path_validator", .{
        .root_source_file = b.path("src/cli/path_validator.zig"),
        .target = target,
    });

    const sanitizer_mod = b.addModule("sanitizer", .{
        .root_source_file = b.path("src/braid/sanitizer.zig"),
        .target = target,
    });

    const cli_config_mod = b.addModule("cli_config", .{
        .root_source_file = b.path("src/cli/config.zig"),
        .target = target,
    });
    cli_config_mod.addImport("security", security_mod);

    const cli_error_mod = b.addModule("cli_error", .{
        .root_source_file = b.path("src/cli/error.zig"),
        .target = target,
    });
    cli_error_mod.addImport("cli_output", cli_output_mod);

    const cli_error_help_mod = b.addModule("cli_error_help", .{
        .root_source_file = b.path("src/cli/error_help.zig"),
        .target = target,
    });
    cli_error_help_mod.addImport("cli_output", cli_output_mod);
    cli_error_help_mod.addImport("cli_error", cli_error_mod);

    // CLI command modules
    const cli_extract_mod = b.addModule("cli_extract", .{
        .root_source_file = b.path("src/cli/commands/extract.zig"),
        .target = target,
    });
    cli_extract_mod.addImport("ananke", ananke_mod);
    cli_extract_mod.addImport("cli_args", cli_args_mod);
    cli_extract_mod.addImport("cli_output", cli_output_mod);
    cli_extract_mod.addImport("cli_config", cli_config_mod);
    cli_extract_mod.addImport("cli_error", cli_error_mod);
    cli_extract_mod.addImport("cli_error_help", cli_error_help_mod);
    cli_extract_mod.addImport("path_validator", path_validator_mod);

    const cli_compile_mod = b.addModule("cli_compile", .{
        .root_source_file = b.path("src/cli/commands/compile.zig"),
        .target = target,
    });
    cli_compile_mod.addImport("ananke", ananke_mod);
    cli_compile_mod.addImport("cli_args", cli_args_mod);
    cli_compile_mod.addImport("cli_output", cli_output_mod);
    cli_compile_mod.addImport("cli_config", cli_config_mod);
    cli_compile_mod.addImport("cli_error", cli_error_mod);
    cli_compile_mod.addImport("cli_error_help", cli_error_help_mod);
    cli_compile_mod.addImport("path_validator", path_validator_mod);

    const cli_generate_mod = b.addModule("cli_generate", .{
        .root_source_file = b.path("src/cli/commands/generate.zig"),
        .target = target,
    });
    cli_generate_mod.addImport("ananke", ananke_mod);
    cli_generate_mod.addImport("cli_args", cli_args_mod);
    cli_generate_mod.addImport("cli_output", cli_output_mod);
    cli_generate_mod.addImport("cli_config", cli_config_mod);
    cli_generate_mod.addImport("cli_error", cli_error_mod);

    const cli_export_spec_mod = b.addModule("cli_export_spec", .{
        .root_source_file = b.path("src/cli/commands/export_spec.zig"),
        .target = target,
    });
    cli_export_spec_mod.addImport("ananke", ananke_mod);
    cli_export_spec_mod.addImport("cli_args", cli_args_mod);
    cli_export_spec_mod.addImport("cli_output", cli_output_mod);
    cli_export_spec_mod.addImport("cli_config", cli_config_mod);
    cli_export_spec_mod.addImport("cli_error", cli_error_mod);
    cli_export_spec_mod.addImport("path_validator", path_validator_mod);

    const cli_validate_mod = b.addModule("cli_validate", .{
        .root_source_file = b.path("src/cli/commands/validate.zig"),
        .target = target,
    });
    cli_validate_mod.addImport("ananke", ananke_mod);
    cli_validate_mod.addImport("cli_args", cli_args_mod);
    cli_validate_mod.addImport("cli_output", cli_output_mod);
    cli_validate_mod.addImport("cli_config", cli_config_mod);
    cli_validate_mod.addImport("cli_error", cli_error_mod);
    cli_validate_mod.addImport("cli_error_help", cli_error_help_mod);
    cli_validate_mod.addImport("path_validator", path_validator_mod);

    const cli_init_mod = b.addModule("cli_init", .{
        .root_source_file = b.path("src/cli/commands/init.zig"),
        .target = target,
    });
    cli_init_mod.addImport("cli_args", cli_args_mod);
    cli_init_mod.addImport("cli_config", cli_config_mod);
    cli_init_mod.addImport("cli_error", cli_error_mod);

    const cli_version_mod = b.addModule("cli_version", .{
        .root_source_file = b.path("src/cli/commands/version.zig"),
        .target = target,
    });
    cli_version_mod.addImport("cli_args", cli_args_mod);
    cli_version_mod.addImport("cli_config", cli_config_mod);
    cli_version_mod.addImport("cli_output", cli_output_mod);

    const cli_help_mod = b.addModule("cli_help", .{
        .root_source_file = b.path("src/cli/commands/help.zig"),
        .target = target,
    });
    cli_help_mod.addImport("cli_args", cli_args_mod);
    cli_help_mod.addImport("cli_config", cli_config_mod);
    cli_help_mod.addImport("cli_output", cli_output_mod);
    cli_help_mod.addImport("cli/commands/extract", cli_extract_mod);
    cli_help_mod.addImport("cli/commands/compile", cli_compile_mod);
    cli_help_mod.addImport("cli/commands/generate", cli_generate_mod);
    cli_help_mod.addImport("cli/commands/export_spec", cli_export_spec_mod);
    cli_help_mod.addImport("cli/commands/validate", cli_validate_mod);
    cli_help_mod.addImport("cli/commands/init", cli_init_mod);
    cli_help_mod.addImport("cli/commands/version", cli_version_mod);

    // Build static library for FFI integration with Rust Maze
    const lib = b.addLibrary(.{
        .name = "ananke",
        .linkage = .static,
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/ffi/zig_ffi.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });
    lib.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| lib.linkLibrary(pl);
    b.installArtifact(lib);

    // Build dynamic/shared library for FFI integration with Node.js (VSCode extension)
    const shared_lib = b.addLibrary(.{
        .name = "ananke_shared",
        .linkage = .dynamic,
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/ffi/zig_ffi.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });
    shared_lib.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| shared_lib.linkLibrary(pl);
    b.installArtifact(shared_lib);

    // Build step for VSCode extension shared library
    const vscode_lib_step = b.step("vscode-lib", "Build shared library for VSCode extension FFI");
    vscode_lib_step.dependOn(&shared_lib.step);

    // Here we define an executable. An executable needs to have a root module
    // which needs to expose a `main` function. While we could add a main function
    // to the module defined above, it's sometimes preferable to split business
    // logic and the CLI into two separate modules.
    //
    // If your goal is to create a Zig library for others to use, consider if
    // it might benefit from also exposing a CLI tool. A parser library for a
    // data serialization format could also bundle a CLI syntax checker, for example.
    //
    // If instead your goal is to create an executable, consider if users might
    // be interested in also being able to embed the core functionality of your
    // program in their own executable in order to avoid the overhead involved in
    // subprocessing your CLI tool.
    //
    // If neither case applies to you, feel free to delete the declaration you
    // don't need and to put everything under a single module.
    const exe = b.addExecutable(.{
        .name = "ananke",
        .root_module = b.createModule(.{
            // b.createModule defines a new module just like b.addModule but,
            // unlike b.addModule, it does not expose the module to consumers of
            // this package, which is why in this case we don't have to give it a name.
            .root_source_file = b.path("src/main.zig"),
            // Target and optimization levels must be explicitly wired in when
            // defining an executable or library (in the root module), and you
            // can also hardcode a specific target for an executable or library
            // definition if desireable (e.g. firmware for embedded devices).
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            // List of modules available for import in source files part of the
            // root module.
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "braid", .module = braid_mod },
                .{ .name = "ariadne", .module = ariadne_mod },
                .{ .name = "cli/args", .module = cli_args_mod },
                .{ .name = "cli/output", .module = cli_output_mod },
                .{ .name = "cli/config", .module = cli_config_mod },
                .{ .name = "cli/error", .module = cli_error_mod },
                .{ .name = "cli/error_help", .module = cli_error_help_mod },
                .{ .name = "cli/commands/extract", .module = cli_extract_mod },
                .{ .name = "cli/commands/compile", .module = cli_compile_mod },
                .{ .name = "cli/commands/generate", .module = cli_generate_mod },
                .{ .name = "cli/commands/export_spec", .module = cli_export_spec_mod },
                .{ .name = "cli/commands/validate", .module = cli_validate_mod },
                .{ .name = "cli/commands/init", .module = cli_init_mod },
                .{ .name = "cli/commands/version", .module = cli_version_mod },
                .{ .name = "cli/commands/help", .module = cli_help_mod },
            },
        }),
    });

    // Link tree-sitter libraries
    exe.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| exe.linkLibrary(pl);

    // This declares intent for the executable to be installed into the
    // install prefix when running `zig build` (i.e. when executing the default
    // step). By default the install prefix is `zig-out/` but can be overridden
    // by passing `--prefix` or `-p`.
    b.installArtifact(exe);

    // Example: Claude integration demo
    const claude_example = b.addExecutable(.{
        .name = "claude_integration",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/claude_integration.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "http", .module = http_mod },
                .{ .name = "claude", .module = claude_mod },
            },
        }),
    });
    b.installArtifact(claude_example);

    // Run step for Claude integration example
    const run_claude_example_step = b.step("run-example", "Run the Claude integration example");
    const run_claude_example_cmd = b.addRunArtifact(claude_example);
    run_claude_example_step.dependOn(&run_claude_example_cmd.step);
    run_claude_example_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_claude_example_cmd.addArgs(args);
    }

    // This creates a top level step. Top level steps have a name and can be
    // invoked by name when running `zig build` (e.g. `zig build run`).
    // This will evaluate the `run` step rather than the default step.
    // For a top level step to actually do something, it must depend on other
    // steps (e.g. a Run step, as we will see in a moment).
    const run_step = b.step("run", "Run the app");

    // This creates a RunArtifact step in the build graph. A RunArtifact step
    // invokes an executable compiled by Zig. Steps will only be executed by the
    // runner if invoked directly by the user (in the case of top level steps)
    // or if another step depends on it, so it's up to you to define when and
    // how this Run step will be executed. In our case we want to run it when
    // the user runs `zig build run`, so we create a dependency link.
    const run_cmd = b.addRunArtifact(exe);
    run_step.dependOn(&run_cmd.step);

    // By making the run step depend on the default step, it will be run from the
    // installation directory rather than directly from within the cache directory.
    run_cmd.step.dependOn(b.getInstallStep());

    // This allows the user to pass arguments to the application in the build
    // command itself, like this: `zig build run -- arg1 arg2 etc`
    if (b.args) |args| {
        run_cmd.addArgs(args);
    }

    // WASM library build (if requested)
    // TODO: Implement WASM build when needed
    _ = wasm_build;

    // Creates an executable that will run `test` blocks from the provided module.
    const mod_tests = b.addTest(.{
        .root_module = ananke_mod,
    });

    // A run step that will run the test executable.
    const run_mod_tests = b.addRunArtifact(mod_tests);

    // Creates an executable that will run `test` blocks from the executable's
    // root module. Note that test executables only test one module at a time,
    // hence why we have to create two separate ones.
    const exe_tests = b.addTest(.{
        .root_module = exe.root_module,
    });

    // A run step that will run the second test executable.
    const run_exe_tests = b.addRunArtifact(exe_tests);

    // Creates test executable for Clew Claude integration tests
    const clew_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/clew/claude_integration_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "claude", .module = claude_mod },
            },
        }),
    });
    clew_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| clew_tests.linkLibrary(pl);

    const run_clew_tests = b.addRunArtifact(clew_tests);

    // Cache tests
    const cache_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/clew/cache_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
            },
        }),
    });
    cache_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| cache_tests.linkLibrary(pl);

    const run_cache_tests = b.addRunArtifact(cache_tests);

    // Pattern extraction tests
    const pattern_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/clew/pattern_extraction_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
            },
        }),
    });
    pattern_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| pattern_tests.linkLibrary(pl);

    const run_pattern_tests = b.addRunArtifact(pattern_tests);

    // Tree-sitter FFI tests
    const tree_sitter_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/clew/tree_sitter_test.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "tree_sitter", .module = tree_sitter_mod },
            },
        }),
    });
    tree_sitter_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| tree_sitter_tests.linkLibrary(pl);

    const run_tree_sitter_tests = b.addRunArtifact(tree_sitter_tests);

    // Hybrid extractor integration tests
    const hybrid_extractor_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/clew/hybrid_extractor_test.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "tree_sitter", .module = tree_sitter_mod },
            },
        }),
    });
    hybrid_extractor_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| hybrid_extractor_tests.linkLibrary(pl);

    const run_hybrid_extractor_tests = b.addRunArtifact(hybrid_extractor_tests);

    // Tree-sitter traversal integration tests
    const traversal_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/clew/tree_sitter_traversal_test.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "tree_sitter", .module = tree_sitter_mod },
            },
        }),
    });
    traversal_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| traversal_tests.linkLibrary(pl);

    const run_traversal_tests = b.addRunArtifact(traversal_tests);

    // Phase 3: Rust/Go/Zig extraction tests
    const rust_go_zig_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/clew/rust_go_zig_extraction_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
            },
        }),
    });
    rust_go_zig_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| rust_go_zig_tests.linkLibrary(pl);

    const run_rust_go_zig_tests = b.addRunArtifact(rust_go_zig_tests);

    // Graph algorithm tests for Braid constraint compilation
    const graph_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/braid/graph_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });

    const run_graph_tests = b.addRunArtifact(graph_tests);

    // JSON Schema generation tests for Braid
    const json_schema_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/braid/json_schema_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });

    const run_json_schema_tests = b.addRunArtifact(json_schema_tests);

    // Grammar generation tests for Braid
    const grammar_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/braid/grammar_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });

    const run_grammar_tests = b.addRunArtifact(grammar_tests);

    // Regex pattern extraction tests for Braid
    const regex_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/braid/regex_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });

    const run_regex_tests = b.addRunArtifact(regex_tests);

    // Constraint operations tests for Braid
    const constraint_ops_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/braid/constraint_ops_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });

    const run_constraint_ops_tests = b.addRunArtifact(constraint_ops_tests);

    // Token mask generation tests for Braid
    const token_mask_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/braid/token_mask_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });

    const run_token_mask_tests = b.addRunArtifact(token_mask_tests);

    // Incremental compilation tests for Braid
    const incremental_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/braid/incremental_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });

    const run_incremental_tests = b.addRunArtifact(incremental_tests);

    // Integration tests for Extract -> Compile pipeline
    const integration_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/integration/pipeline_tests.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });
    integration_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| integration_tests.linkLibrary(pl);

    const run_integration_tests = b.addRunArtifact(integration_tests);

    // E2E integration tests for full Zig -> Rust -> Modal pipeline
    const e2e_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/integration/e2e_pipeline_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });
    e2e_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| e2e_tests.linkLibrary(pl);

    const run_e2e_tests = b.addRunArtifact(e2e_tests);

    // New comprehensive E2E test suite with fixtures
    const new_e2e_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/e2e/e2e_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });
    new_e2e_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| new_e2e_tests.linkLibrary(pl);

    const run_new_e2e_tests = b.addRunArtifact(new_e2e_tests);

    // Phase 2 E2E tests: Full pipeline integration
    const phase2_full_pipeline_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/e2e/phase2/full_pipeline_test.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "tree_sitter", .module = tree_sitter_mod },
            },
        }),
    });
    phase2_full_pipeline_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| phase2_full_pipeline_tests.linkLibrary(pl);

    const run_phase2_full_pipeline_tests = b.addRunArtifact(phase2_full_pipeline_tests);

    // Phase 2 E2E tests: Multi-language integration
    const phase2_multi_language_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/e2e/phase2/multi_language_test.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "tree_sitter", .module = tree_sitter_mod },
            },
        }),
    });
    phase2_multi_language_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| phase2_multi_language_tests.linkLibrary(pl);

    const run_phase2_multi_language_tests = b.addRunArtifact(phase2_multi_language_tests);

    // Phase 2 E2E tests: Strategy comparison
    const phase2_strategy_comparison_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/e2e/phase2/strategy_comparison_test.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "tree_sitter", .module = tree_sitter_mod },
            },
        }),
    });
    phase2_strategy_comparison_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| phase2_strategy_comparison_tests.linkLibrary(pl);

    const run_phase2_strategy_comparison_tests = b.addRunArtifact(phase2_strategy_comparison_tests);

    // Phase 2 E2E tests: Constraint quality validation
    const phase2_constraint_quality_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/e2e/phase2/constraint_quality_test.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "tree_sitter", .module = tree_sitter_mod },
            },
        }),
    });
    phase2_constraint_quality_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| phase2_constraint_quality_tests.linkLibrary(pl);

    const run_phase2_constraint_quality_tests = b.addRunArtifact(phase2_constraint_quality_tests);

    // Phase 6 E2E tests: New language validation (Kotlin, C#, Ruby, PHP, Swift)
    const phase6_new_languages_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/e2e/phase6/new_languages_validation_test.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "tree_sitter", .module = tree_sitter_mod },
            },
        }),
    });
    phase6_new_languages_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| phase6_new_languages_tests.linkLibrary(pl);

    const run_phase6_new_languages_tests = b.addRunArtifact(phase6_new_languages_tests);

    // CLI tests
    const cli_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/cli/cli_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{},
        }),
    });

    // Add CLI module imports to CLI tests
    cli_tests.root_module.addImport("args", cli_args_mod);
    cli_tests.root_module.addImport("output", cli_output_mod);
    cli_tests.root_module.addImport("config", cli_config_mod);

    const run_cli_tests = b.addRunArtifact(cli_tests);

    // CLI integration tests
    const cli_integration_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/cli/cli_integration_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{},
        }),
    });

    // Add only the supporting module imports (not command modules)
    cli_integration_tests.root_module.addImport("args", cli_args_mod);
    cli_integration_tests.root_module.addImport("config", cli_config_mod);

    const run_cli_integration_tests = b.addRunArtifact(cli_integration_tests);

    // Security edge case tests
    const security_edge_case_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/security/edge_cases_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{},
        }),
    });

    // Add necessary module imports for security tests
    security_edge_case_tests.root_module.addImport("security", security_mod);
    security_edge_case_tests.root_module.addImport("path_validator", path_validator_mod);
    security_edge_case_tests.root_module.addImport("sanitizer", sanitizer_mod);

    const run_security_edge_case_tests = b.addRunArtifact(security_edge_case_tests);

    // Ariadne DSL tests
    const ariadne_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/ariadne/test_parser.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ariadne", .module = ariadne_mod },
            },
        }),
    });
    ariadne_tests.root_module.addImport("ananke", ananke_mod);

    const run_ariadne_tests = b.addRunArtifact(ariadne_tests);

    // Typed holes tests
    const hole_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/types/hole_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
            },
        }),
    });

    const run_hole_tests = b.addRunArtifact(hole_tests);

    // Hole detector tests (requires tree-sitter links due to semantic detection integration)
    const hole_detector_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/clew/hole_detector_test.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "tree_sitter", .module = tree_sitter_mod },
            },
        }),
    });
    hole_detector_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| hole_detector_tests.linkLibrary(pl);

    const run_hole_detector_tests = b.addRunArtifact(hole_detector_tests);

    // Semantic hole detector tests
    const semantic_hole_detector_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/clew/semantic_hole_detector_test.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "tree_sitter", .module = tree_sitter_mod },
            },
        }),
    });
    semantic_hole_detector_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| semantic_hole_detector_tests.linkLibrary(pl);

    const run_semantic_hole_detector_tests = b.addRunArtifact(semantic_hole_detector_tests);

    // Hole compiler tests
    const hole_compiler_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/braid/hole_compiler_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });

    const run_hole_compiler_tests = b.addRunArtifact(hole_compiler_tests);

    // Type inhabitation tests
    const type_inhabitation_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/braid/type_inhabitation_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });

    const run_type_inhabitation_tests = b.addRunArtifact(type_inhabitation_tests);

    // Property-based fuzz tests
    const fuzz_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/property/fuzz_tests.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
            },
        }),
    });

    const run_fuzz_tests = b.addRunArtifact(fuzz_tests);

    // Braid submodule inline tests.
    // These files are tested standalone because braid.zig's test root creates
    // a circular module dependency (braid.zig → ananke → braid).
    // feasibility.zig requires `ananke` and is tested via integration tests.
    const salience_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/braid/salience.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    const run_salience_tests = b.addRunArtifact(salience_tests);

    const temporal_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/braid/temporal.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    const run_temporal_tests = b.addRunArtifact(temporal_tests);

    const regex_analyzer_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/braid/regex_analyzer.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    const run_regex_analyzer_tests = b.addRunArtifact(regex_analyzer_tests);

    // Braid domain fusion inline tests (distribution-preserving multi-domain composition)
    const domain_fusion_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/braid/domain_fusion.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    const run_domain_fusion_tests = b.addRunArtifact(domain_fusion_tests);

    // Braid FIM inline tests (fill-in-the-middle constrained decoding)
    const fim_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/braid/fim.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    const run_fim_tests = b.addRunArtifact(fim_tests);

    // Clew call graph context inline tests (InlineCoder-style upstream/downstream)
    const call_graph_context_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/clew/call_graph_context.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    const run_call_graph_context_tests = b.addRunArtifact(call_graph_context_tests);

    // Clew conventions inline tests (convention mining → soft constraints)
    const conventions_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/clew/conventions.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    const run_conventions_tests = b.addRunArtifact(conventions_tests);

    // Clew scope context inline tests (cross-file bindings from Homer)
    const scope_context_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/clew/scope_context.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    const run_scope_context_tests = b.addRunArtifact(scope_context_tests);

    // Extractor inline tests (Rust, Java, Python, Kotlin language extractors)
    // The test harness lives in src/clew/extractors/ so that relative @import
    // paths work for test discovery (Zig only discovers inline tests via
    // file-relative imports, not named module re-exports).
    // Uses a minimal "ananke" stub (in src/ tree) to avoid module conflicts
    // with the full ananke module tree (base.zig only needs types.constraint).
    const ananke_test_stub = b.createModule(.{
        .root_source_file = b.path("src/ananke_test_stub.zig"),
        .target = target,
    });
    const extractor_inline_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/clew/extractors/inline_tests.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_test_stub },
            },
        }),
    });
    const run_extractor_inline_tests = b.addRunArtifact(extractor_inline_tests);

    // A top level step for running all tests. dependOn can be called multiple
    // times and since the two run steps do not depend on one another, this will
    // make the two of them run in parallel.
    const test_step = b.step("test", "Run tests");
    test_step.dependOn(&run_mod_tests.step);
    test_step.dependOn(&run_exe_tests.step);
    test_step.dependOn(&run_clew_tests.step);
    test_step.dependOn(&run_cache_tests.step);
    test_step.dependOn(&run_pattern_tests.step);
    test_step.dependOn(&run_tree_sitter_tests.step);
    test_step.dependOn(&run_hybrid_extractor_tests.step);
    test_step.dependOn(&run_traversal_tests.step);
    test_step.dependOn(&run_rust_go_zig_tests.step);
    test_step.dependOn(&run_graph_tests.step);
    test_step.dependOn(&run_json_schema_tests.step);
    test_step.dependOn(&run_grammar_tests.step);
    test_step.dependOn(&run_regex_tests.step);
    test_step.dependOn(&run_constraint_ops_tests.step);
    test_step.dependOn(&run_token_mask_tests.step);
    test_step.dependOn(&run_incremental_tests.step);
    test_step.dependOn(&run_integration_tests.step);
    test_step.dependOn(&run_e2e_tests.step);
    test_step.dependOn(&run_new_e2e_tests.step);
    test_step.dependOn(&run_phase2_full_pipeline_tests.step);
    test_step.dependOn(&run_phase2_multi_language_tests.step);
    test_step.dependOn(&run_phase2_strategy_comparison_tests.step);
    test_step.dependOn(&run_phase2_constraint_quality_tests.step);
    test_step.dependOn(&run_cli_tests.step);
    test_step.dependOn(&run_cli_integration_tests.step);
    test_step.dependOn(&run_security_edge_case_tests.step);
    test_step.dependOn(&run_ariadne_tests.step);
    test_step.dependOn(&run_hole_tests.step);
    test_step.dependOn(&run_hole_detector_tests.step);
    test_step.dependOn(&run_semantic_hole_detector_tests.step);
    test_step.dependOn(&run_hole_compiler_tests.step);
    test_step.dependOn(&run_type_inhabitation_tests.step);
    test_step.dependOn(&run_fuzz_tests.step);
    test_step.dependOn(&run_salience_tests.step);
    test_step.dependOn(&run_temporal_tests.step);
    test_step.dependOn(&run_regex_analyzer_tests.step);
    test_step.dependOn(&run_conventions_tests.step);
    test_step.dependOn(&run_scope_context_tests.step);
    test_step.dependOn(&run_domain_fusion_tests.step);
    test_step.dependOn(&run_fim_tests.step);
    test_step.dependOn(&run_call_graph_context_tests.step);
    test_step.dependOn(&run_phase6_new_languages_tests.step);
    test_step.dependOn(&run_extractor_inline_tests.step);

    // Property-based fuzz test step (run with: zig build test-fuzz -- -ffuzz for continuous fuzzing)
    const fuzz_test_step = b.step("test-fuzz", "Run property-based fuzz tests");
    fuzz_test_step.dependOn(&run_fuzz_tests.step);

    // Phase 8a: TypeScript E2E pipeline tests
    const typescript_pipeline_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/e2e/test_typescript_pipeline.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });
    typescript_pipeline_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| typescript_pipeline_tests.linkLibrary(pl);

    const run_typescript_pipeline_tests = b.addRunArtifact(typescript_pipeline_tests);

    // Phase 8a: Python E2E pipeline tests
    const python_pipeline_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/e2e/test_python_pipeline.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });
    python_pipeline_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| python_pipeline_tests.linkLibrary(pl);

    const run_python_pipeline_tests = b.addRunArtifact(python_pipeline_tests);

    // E2E test step (can be run separately)
    const e2e_test_step = b.step("test-e2e", "Run end-to-end integration tests");
    e2e_test_step.dependOn(&run_e2e_tests.step);
    e2e_test_step.dependOn(&run_new_e2e_tests.step);
    e2e_test_step.dependOn(&run_phase2_full_pipeline_tests.step);
    e2e_test_step.dependOn(&run_phase2_multi_language_tests.step);
    e2e_test_step.dependOn(&run_phase2_strategy_comparison_tests.step);
    e2e_test_step.dependOn(&run_phase2_constraint_quality_tests.step);
    e2e_test_step.dependOn(&run_phase6_new_languages_tests.step);
    e2e_test_step.dependOn(&run_typescript_pipeline_tests.step);
    e2e_test_step.dependOn(&run_python_pipeline_tests.step);

    // ConstraintSpec conformance tests (CLaSH round-trip validation)
    const conformance_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("test/integration/constraint_spec_conformance_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
            },
        }),
    });
    conformance_tests.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| conformance_tests.linkLibrary(pl);

    const run_conformance_tests = b.addRunArtifact(conformance_tests);
    const conformance_test_step = b.step("test-conformance", "Run ConstraintSpec conformance tests");
    conformance_test_step.dependOn(&run_conformance_tests.step);
    e2e_test_step.dependOn(&run_conformance_tests.step);

    // Phase 2 E2E test step (can be run separately)
    const phase2_test_step = b.step("test-phase2", "Run Phase 2 E2E integration tests");
    phase2_test_step.dependOn(&run_phase2_full_pipeline_tests.step);
    phase2_test_step.dependOn(&run_phase2_multi_language_tests.step);
    phase2_test_step.dependOn(&run_phase2_strategy_comparison_tests.step);
    phase2_test_step.dependOn(&run_phase2_constraint_quality_tests.step);

    // CLI test step (can be run separately)
    const cli_test_step = b.step("test-cli", "Run CLI tests");
    cli_test_step.dependOn(&run_cli_tests.step);
    cli_test_step.dependOn(&run_cli_integration_tests.step);

    // CLI integration test step (can be run separately)
    const cli_integration_test_step = b.step("test-cli-integration", "Run CLI integration tests");
    cli_integration_test_step.dependOn(&run_cli_integration_tests.step);

    // Just like flags, top level steps are also listed in the `--help` menu.
    //
    // The Zig build system is entirely implemented in userland, which means
    // that it cannot hook into private compiler APIs. All compilation work
    // orchestrated by the build system will result in other Zig compiler
    // subcommands being invoked with the right flags defined. You can observe
    // these invocations when one fails (or you pass a flag to increase
    // verbosity) to validate assumptions and diagnose problems.
    //
    // Lastly, the Zig build system is relatively simple and self-contained,
    // and reading its source code will allow you to master it.

    // ============================================================================
    // Performance Benchmarks
    // ============================================================================

    // Clew extraction benchmarks
    const clew_bench = b.addExecutable(.{
        .name = "clew_bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("benches/zig/clew_bench.zig"),
            .target = target,
            .optimize = .ReleaseFast, // Always benchmark with optimizations
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
            },
        }),
    });
    b.installArtifact(clew_bench);
    clew_bench.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| clew_bench.linkLibrary(pl);

    const run_clew_bench = b.addRunArtifact(clew_bench);
    const clew_bench_step = b.step("bench-clew", "Run Clew extraction benchmarks");
    clew_bench_step.dependOn(&run_clew_bench.step);

    // Braid compilation benchmarks
    const braid_bench = b.addExecutable(.{
        .name = "braid_bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("benches/zig/braid_bench.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });
    b.installArtifact(braid_bench);

    const run_braid_bench = b.addRunArtifact(braid_bench);
    const braid_bench_step = b.step("bench-braid", "Run Braid compilation benchmarks");
    braid_bench_step.dependOn(&run_braid_bench.step);

    // FFI bridge benchmarks
    const ffi_bench = b.addExecutable(.{
        .name = "ffi_bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("benches/zig/ffi_bench.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "zig_ffi", .module = b.addModule("zig_ffi", .{
                    .root_source_file = b.path("src/ffi/zig_ffi.zig"),
                    .target = target,
                }) },
            },
        }),
    });
    b.installArtifact(ffi_bench);

    const run_ffi_bench = b.addRunArtifact(ffi_bench);
    const ffi_bench_step = b.step("bench-ffi", "Run FFI bridge benchmarks");
    ffi_bench_step.dependOn(&run_ffi_bench.step);

    // Run all Zig benchmarks
    const bench_all_zig_step = b.step("bench-zig", "Run all Zig benchmarks");
    bench_all_zig_step.dependOn(clew_bench_step);
    bench_all_zig_step.dependOn(braid_bench_step);
    bench_all_zig_step.dependOn(ffi_bench_step);

    // Combined benchmark step (Zig + Rust)
    const bench_all_step = b.step("bench", "Run all benchmarks (Zig + Rust)");
    bench_all_step.dependOn(bench_all_zig_step);

    // Add Rust benchmarks via cargo
    const cargo_bench = b.addSystemCommand(&.{
        "cargo",
        "bench",
        "--manifest-path",
        "maze/Cargo.toml",
    });
    const rust_bench_step = b.step("bench-rust", "Run Rust Maze benchmarks");
    rust_bench_step.dependOn(&cargo_bench.step);
    bench_all_step.dependOn(rust_bench_step);
    // ============================================================================
    // Additional Performance Benchmarks
    // ============================================================================

    // Multi-language extraction benchmarks
    const multi_lang_bench = b.addExecutable(.{
        .name = "multi_language_bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("benches/zig/multi_language_bench.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
            },
        }),
    });
    b.installArtifact(multi_lang_bench);
    multi_lang_bench.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| multi_lang_bench.linkLibrary(pl);

    const run_multi_lang_bench = b.addRunArtifact(multi_lang_bench);
    const multi_lang_bench_step = b.step("bench-multi-lang", "Run multi-language extraction benchmarks");
    multi_lang_bench_step.dependOn(&run_multi_lang_bench.step);

    // Constraint density benchmarks
    const density_bench = b.addExecutable(.{
        .name = "constraint_density_bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("benches/zig/constraint_density_bench.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });
    b.installArtifact(density_bench);

    const run_density_bench = b.addRunArtifact(density_bench);
    const density_bench_step = b.step("bench-density", "Run constraint density benchmarks");
    density_bench_step.dependOn(&run_density_bench.step);

    // Memory usage benchmarks
    const memory_bench = b.addExecutable(.{
        .name = "memory_bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("benches/zig/memory_bench.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });
    b.installArtifact(memory_bench);
    memory_bench.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| memory_bench.linkLibrary(pl);

    const run_memory_bench = b.addRunArtifact(memory_bench);
    const memory_bench_step = b.step("bench-memory", "Run memory usage benchmarks");
    memory_bench_step.dependOn(&run_memory_bench.step);

    // FFI roundtrip benchmarks
    const ffi_roundtrip_bench = b.addExecutable(.{
        .name = "ffi_roundtrip_bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("benches/zig/ffi_roundtrip_bench.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "zig_ffi", .module = b.addModule("zig_ffi", .{
                    .root_source_file = b.path("src/ffi/zig_ffi.zig"),
                    .target = target,
                }) },
            },
        }),
    });
    b.installArtifact(ffi_roundtrip_bench);

    const run_ffi_roundtrip_bench = b.addRunArtifact(ffi_roundtrip_bench);
    const ffi_roundtrip_bench_step = b.step("bench-ffi-roundtrip", "Run FFI roundtrip benchmarks");
    ffi_roundtrip_bench_step.dependOn(&run_ffi_roundtrip_bench.step);

    // End-to-end pipeline benchmarks
    const pipeline_bench = b.addExecutable(.{
        .name = "pipeline_bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("benches/zig/pipeline_bench.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });
    b.installArtifact(pipeline_bench);
    pipeline_bench.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| pipeline_bench.linkLibrary(pl);

    const run_pipeline_bench = b.addRunArtifact(pipeline_bench);
    const pipeline_bench_step = b.step("bench-pipeline", "Run end-to-end pipeline benchmarks");
    pipeline_bench_step.dependOn(&run_pipeline_bench.step);

    // Regression test suite
    const regression_test = b.addExecutable(.{
        .name = "regression_test",
        .root_module = b.createModule(.{
            .root_source_file = b.path("benches/zig/regression_test.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "braid", .module = braid_mod },
            },
        }),
    });
    b.installArtifact(regression_test);
    regression_test.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| regression_test.linkLibrary(pl);

    const run_regression_test = b.addRunArtifact(regression_test);
    const regression_test_step = b.step("bench-regression", "Run performance regression tests");
    regression_test_step.dependOn(&run_regression_test.step);

    // Update comprehensive Zig benchmarks step
    bench_all_zig_step.dependOn(multi_lang_bench_step);
    bench_all_zig_step.dependOn(density_bench_step);
    bench_all_zig_step.dependOn(memory_bench_step);
    bench_all_zig_step.dependOn(ffi_roundtrip_bench_step);
    bench_all_zig_step.dependOn(pipeline_bench_step);

    // ============================================================================
    // Phase 8b: Comprehensive Performance Benchmark Suite
    // ============================================================================

    // Phase 8b benchmark modules
    const extraction_bench_mod = b.addModule("extraction_benchmarks", .{
        .root_source_file = b.path("bench/extraction_benchmarks.zig"),
        .target = target,
    });
    extraction_bench_mod.addImport("ananke", ananke_mod);
    extraction_bench_mod.addImport("clew", clew_mod);

    const compilation_bench_mod = b.addModule("compilation_benchmarks", .{
        .root_source_file = b.path("bench/compilation_benchmarks.zig"),
        .target = target,
    });
    compilation_bench_mod.addImport("ananke", ananke_mod);
    compilation_bench_mod.addImport("braid", braid_mod);

    const cache_bench_mod = b.addModule("cache_benchmarks", .{
        .root_source_file = b.path("bench/cache_benchmarks.zig"),
        .target = target,
    });
    cache_bench_mod.addImport("ananke", ananke_mod);
    cache_bench_mod.addImport("braid", braid_mod);

    const e2e_bench_mod = b.addModule("e2e_benchmarks", .{
        .root_source_file = b.path("bench/e2e_benchmarks.zig"),
        .target = target,
    });
    e2e_bench_mod.addImport("ananke", ananke_mod);
    e2e_bench_mod.addImport("clew", clew_mod);
    e2e_bench_mod.addImport("braid", braid_mod);

    // Phase 8b main benchmark runner
    const phase8b_bench = b.addExecutable(.{
        .name = "benchmark_runner",
        .root_module = b.createModule(.{
            .root_source_file = b.path("bench/benchmark_runner.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .link_libc = true,
            .imports = &.{
                .{ .name = "extraction_benchmarks", .module = extraction_bench_mod },
                .{ .name = "compilation_benchmarks", .module = compilation_bench_mod },
                .{ .name = "ananke", .module = ananke_mod },
                .{ .name = "clew", .module = clew_mod },
                .{ .name = "braid", .module = braid_mod },
                .{ .name = "cache_benchmarks", .module = cache_bench_mod },
                .{ .name = "e2e_benchmarks", .module = e2e_bench_mod },
            },
        }),
    });
    b.installArtifact(phase8b_bench);
    phase8b_bench.linkSystemLibrary("tree-sitter");
    inline for (parser_libs) |pl| phase8b_bench.linkLibrary(pl);

    const run_phase8b_bench = b.addRunArtifact(phase8b_bench);
    const phase8b_bench_step = b.step("bench-phase8b", "Run Phase 8b comprehensive benchmark suite");
    phase8b_bench_step.dependOn(&run_phase8b_bench.step);

    // Add Phase 8b benchmarks to main bench step
    bench_all_step.dependOn(phase8b_bench_step);
}