diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..4219a59
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,31 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Setup Zig
+        uses: mlugg/setup-zig@v2.2.1
+        with:
+          version: 0.16.0
+
+      - name: Run test suite
+        run: zig build test --summary all
diff --git a/README.md b/README.md
index 4548e32..a52380a 100644
--- a/README.md
+++ b/README.md
@@ -1,255 +1,184 @@
 # zbuild
 
-An opinionated build tool for Zig projects.
+Declarative `std.Build` graphs generated from `build.zig.zon` at comptime.
 
-## Introduction
+zbuild reads `@import("build.zig.zon")` as a typed value and turns it into normal `std.Build` calls. There is no runtime parser, and the graph is generated directly inside the build, not by an external codegen phase. It is a library that sits on top of Zig's native build graph.
 
-`zbuild` is a command-line build tool designed to simplify and enhance the build process for Zig projects. It leverages a ZON-based configuration file (`zbuild.zon`) to define project builds declaratively, generating a corresponding `build.zig` and `build.zig.zon` file that integrates seamlessly with Zig’s native build system. This approach reduces the complexity of writing and maintaining Zig build scripts manually, offering a structured alternative for managing dependencies, modules, executables, libraries, tests, and more.
+## Start Here
 
-Note: `zbuild` is under active development. Some features are incomplete or subject to change. Check the `docs/TODO.md` file for planned enhancements.
+- Want to try it immediately: use the quickstart below.
+- Want the mental model first: read [Conceptual Model](docs/concepts.md).
+- Want exact field-by-field details: read [Schema Reference](docs/schema.md).
+- Want the rationale and tradeoffs: read [Why zbuild?](docs/motivation.md).
 
-## Features
+## Quickstart
 
-- **ZON-based Configuration**: Define your build in a `zbuild.zon` file instead of writing Zig code directly.
-- **Automatic build.zig Generation**: Create a `build.zig` and `build.zig.zon` file from your configuration.
-- **Comprehensive Build Support**: Manage dependencies, modules, executables, libraries, objects, tests, formatting, and run commands.
-- **Command-Line Interface**: Execute common build tasks like compiling executables, running tests, and formatting code.
+### 1. Add zbuild as a dependency
 
-## Installation
+```bash
+zig fetch --save=zbuild <zbuild-url-or-path>
+```
 
-Currently, zbuild must be built from source:
+That writes the `.dependencies.zbuild` entry for you.
 
-1. Clone the repository:
-```bash
-git clone https://github.com/chainsafe/zbuild.git
-cd zbuild
+### 2. Create `build.zig`
+
+```zig
+const zbuild = @import("zbuild");
+const std = @import("std");
+
+pub fn build(b: *std.Build) !void {
+    _ = try zbuild.configureBuild(b, @import("build.zig.zon"), .{});
+}
 ```
 
-2. Build the executable:
-```bash
-zig build -Doptimize=ReleaseFast
+### 3. Add zbuild-owned fields to `build.zig.zon`
+
+```zig
+.executables = .{
+    .myapp = .{
+        .root_module = .{
+            .root_source_file = "src/main.zig",
+        },
+    },
+},
 ```
 
-3. (Optional) Install it globally:
+Assume the rest of `build.zig.zon` is the normal Zig package metadata from your project or `zig init`.
+
+### 4. Build it
+
 ```bash
-zig build install --prefix ~/.local
+zig build
+zig build run:myapp
+zig build help
 ```
 
-A pre-built binary distribution is planned for future releases once sufficient feature-completeness is achieved.
+### 5. Expand from there
 
-## Usage
+Once the first executable works, add modules, tests, runs, fmts, options modules, or libraries as needed. The [simple example](examples/simple/) shows the minimal shape. The [full example](examples/full/) shows most of the library in one place.
 
-`zbuild` provides a command-line interface with various commands to manage your Zig projects. Below is the general syntax and a list of available commands:
+## What zbuild gives you
 
-```
-Usage: zbuild [global_options] [command] [options]
-```
+- `modules` for reusable Zig modules with imports, include paths, and dependency libraries
+- `executables`, `libraries`, and `objects`
+- `tests` with per-test steps and an aggregate `test` step
+- `fmts` with per-target steps and an aggregate `fmt` step
+- `runs` for arbitrary system commands
+- `aliases` for named aggregate steps such as `check`, `ci`, or `release`
+- `options_modules` that become importable Zig config modules and `-Dmodule.option` CLI flags
+- `presets` for named bundles of `options_modules` defaults, selected with `-Dpreset=<name>`
+- comptime dependency args forwarded to `b.dependency(...)`
+- a built-in help step (`help` by default, configurable via `Options.help_step`)
+- two-phase validation so local graph mistakes fail early
 
-### Commands
-
-- `init`: Initialize a new Zig project with a basic `zbuild.zon`, `build.zig`, `build.zig.zon`, and `src/main.zig` in the current directory.
-- `fetch`: Copy a package into the global cache  and optionally add it to `zbuild.zon` and `build.zig.zon`
-- `install`: Install all artifacts defined in `zbuild.zon`.
-- `uninstall`: Uninstall all artifacts.
-- `sync`: Synchronize `build.zig` and `build.zig.zon` with `zbuild.zon`.
-- `build`: Run `zig build` with the generated `build.zig`.
-- `build-exe <name>`: Build a specific executable defined in `zbuild.zon`.
-- `build-lib <name>`: Build a specific library.
-- `build-obj <name>`: Build a specific object file.
-- `build-test <name>`: Build a specific test into an executable.
-- `run <name>`: Run an executable or a custom run script.
-- `test [name]`: Run all tests or a specific test.
-- `fmt [name]`: Format code for all or a specific formatting target.
-- `help`: Print the help message and exit.
-- `version`: Print the version number and exit.
-
-### Global Options
-
-- `--project-dir <path>`: Set the project directory (default: `.`).
-- `--zbuild-file <path>`: Specify the configuration file (default: `zbuild.zon`).
-- `--no-sync`: Skip automatic synchronization of `build.zig` and `build.zig.zon`.
-
-### General Options
-
-- `-h, --help`: Print command-specific usage.
-
-For command-specific options (e.g., `fetch`), use zbuild <command> --help.
-
-## Configuration
-
-The `zbuild.zon` file is the heart of the zbuild system. It defines your project’s structure and build settings. Below is an example configuration:
-
-```zon
-.{
-    .name = .example_project,
-    .version = "1.2.3",
-    .description = "A comprehensive example",
-    .fingerprint = 0x90797553773ca567,
-    .minimum_zig_version = "0.14.0",
-    .paths = .{ "build.zig", "build.zig.zon", "src" },
-    .keywords = .{"example"},
-    .dependencies = .{
-        .mathlib = .{
-            .path = "deps/mathlib",
-        },
-        .network = .{
-            .url = "https://github.com/example/network/archive/v1.0.0.tar.gz",
-        },
-    },
-    .options_modules = .{
-        .build_options = .{
-            .max_depth = .{
-                .type = "usize",
-                .default = 100,
-            },
-        },
-    },
-    .modules = .{
-        .utils = .{
-            .root_source_file = "src/utils/main.zig",
-            .imports = .{.mathlib, .build_options},
-            .link_libc = true,
-        },
-        .core = .{
-            .root_source_file = "src/core/core.zig",
-            .imports = .{.utils},
-        },
-    },
-    .executables = .{
-        .main_app = .{
-            .root_module = .{
-                .root_source_file = "src/main.zig",
-                .imports = .{.core, .network},
-            },
-        },
-    },
-    .libraries = .{
-        .libmath = .{
-            .version = "0.1.0",
-            .root_module = .utils,
-            .linkage = .static,
-        },
-    },
-    .tests = .{
-        .unit_tests = .{
-            .root_module = .{
-                .root_source_file = "tests/unit.zig",
-                .imports = .{.core, .utils},
-            },
-        },
-    },
-    .fmts = .{
-        .source = .{
-            .paths = .{"src", "tests"},
-            .exclude_paths = .{"src/generated"},
-            .check = true,
-        },
-    },
-    .runs = .{
-        .start_server = "zig run src/server.zig",
-        .build_docs = "scripts/build_docs.sh",
-    },
-}
-```
+## First Mental Model
 
-### Key Sections
+zbuild becomes easy to use once you keep three rules in your head:
 
-- `name`, `version`, `fingerprint`, `minimum_zig_version`, `paths`: Project metadata (required).
-- `dependencies`: External packages (path or URL).
-- `options_modules`: Configurable build options bundled into modules.
-- `modules`: Reusable code units with optional imports and build settings.
-- `executables`, `libraries`, `objects`: Build targets with root modules.
-- `tests`: Test targets with optional filters.
-- `fmts`: Code formatting rules.
-- `runs`: Custom shell commands.
+1. `build.zig.zon` declares graph nodes.
+   `modules`, `executables`, `libraries`, `tests`, `runs`, `fmts`, and `aliases` each map to a different kind of `std.Build` node or step.
 
-## Hello World Example
+2. Ownership is encoded in syntax.
+   Enum literals like `.core`, `.config`, and `.myapp` mean "this belongs to the zbuild-owned graph".
+   Bare strings like `"shared"` and `"gen:prep"` mean "this is manual `build.zig` state registered before `configureBuild`".
 
-Here’s a step-by-step example to create and build a simple Zig project with zbuild:
+3. Validation happens in two phases.
+   Local manifest structure and manifest-owned refs fail at comptime.
+   Manual refs and dependency exports fail during configure, after zbuild can actually inspect them.
 
-1. Initialize the project:
+If you want the full model, including namespace rules and why those syntax splits exist, read [docs/concepts.md](docs/concepts.md).
 
-```bash
-mkdir myproject
-cd myproject
-zbuild init
-```
+## Named Presets
 
-2. (Optional) Inspect `zbuild.zon`
-
-```zon
-.{
-    .name = .myproject,
-    .version = "0.1.0",
-    .fingerprint = 0x<generated>,
-    .minimum_zig_version = "0.14.0",
-    .paths = .{ "build.zig", "build.zig.zon", "src" },
-    .executables = .{
-        .myproject = .{
-            .root_module = .{
-                .root_source_file = "src/main.zig",
-            },
-        },
-    },
-}
-```
+If you have a recurring bundle of option values, keep the types in `options_modules` and add a named preset on top:
 
-3. Update `src/main.zig`
 ```zig
-const std = @import("std");
-pub fn main() !void {
-    const allocator = std.heap.page_allocator;
-    const args = try std.process.argsAlloc(allocator);
-    defer std.process.argsFree(allocator, args);
-
-    const arg = if (args.len >= 2) args[1] else "zbuild";
-    std.debug.print("Hello {s}!\n", .{arg});
-}
+.options_modules = .{
+    .app = .{
+        .log_level = .{
+            .type = .@"enum",
+            .values = .{ .debug, .info, .warn },
+            .default = .info,
+        },
+        .asset_dir = .{
+            .type = .string,
+        },
+    },
+},
+.presets = .{
+    .dev = .{
+        .app = .{
+            .log_level = .debug,
+        },
+    },
+    .prod = .{
+        .app = .{
+            .log_level = .warn,
+            .asset_dir = "dist/prod",
+        },
+    },
+},
 ```
 
-4. (Optional) Build the Executable:
+Then select one explicitly:
 
 ```bash
-zbuild build-exe myproject
+zig build run:myapp -Dpreset=prod
+zig build run:myapp -Dpreset=prod -Dapp.log_level=debug
 ```
-This builds the `myproject` executable into `zig-out/bin`.
 
-5. Run the Executable:
+Presets only override `options_modules`. They do not create a second config API, and per-option `-Dmodule.option=...` flags still win.
 
-```bash
-zbuild run myproject -- world
-```
+## Working With Manual `build.zig` Code
 
-Outputs: `Hello, world!`
+zbuild does not replace `build.zig`. It owns the declarative 90%, and you keep Zig for the rest.
 
-## Fetching Dependencies
+Register manual modules or steps before `configureBuild`:
 
-Add a dependency to your project:
-```bash
-zbuild fetch --save=example https://github.com/example/repo/archive/v1.0.0.tar.gz
-```
+```zig
+const zbuild = @import("zbuild");
+const std = @import("std");
 
-This updates `zbuild.zon` with:
-```zon
-.dependencies = .{
-    .example = {
-        .url = "https://github.com/example/repo/archive/v1.0.0.tar.gz,
-    }
+pub fn build(b: *std.Build) !void {
+    _ = b.addModule("shared", .{
+        .root_source_file = b.path("src/shared.zig"),
+        .target = b.resolveTargetQuery(.{}),
+        .optimize = .Debug,
+    });
+    _ = b.step("gen:prep", "manual prep step");
+
+    _ = try zbuild.configureBuild(b, @import("build.zig.zon"), .{});
 }
 ```
 
-And synchronizes `build.zig.zon` with the fetched hash.
+Then reference those manual nodes from the manifest with bare strings:
 
+```zig
+.executables = .{
+    .app = .{
+        .root_module = "shared",
+    },
+},
+.runs = .{
+    .demo = .{
+        .cmd = .{ "echo", "ok" },
+        .depends_on = .{ "gen:prep" },
+    },
+},
+```
 
-## Contributing
+## Documentation Map
 
-Contributions are welcome! To contribute:
+- [Conceptual Model](docs/concepts.md): the bottom-up explanation of how the graph, namespaces, and validation fit together
+- [Schema Reference](docs/schema.md): exact field types, syntax, and generated step names
+- [Why zbuild?](docs/motivation.md): the problem it solves and the design constraints it follows
+- [Simple Example](examples/simple/): the smallest useful project
+- [Full Example](examples/full/): modules, tests, runs, fmts, and options modules together
 
-1. Fork the repository on GitHub: https://github.com/chainsafe/zbuild.
-2. Create a branch for your changes.
-3. Submit a pull request with a clear description of your improvements.
+## Requirements
 
-Please open an issue first to discuss significant changes or report bugs.
+Zig `0.16.0+`
 
 ## License
 
diff --git a/build.zig b/build.zig
index f229088..884837c 100644
--- a/build.zig
+++ b/build.zig
@@ -1,70 +1,203 @@
-// This file is generated by zbuild. Do not edit manually.
-
 const std = @import("std");
+const build_runner = @import("src/build_runner.zig");
+
+// Re-export the zbuild API so dependents can use @import("zbuild").configureBuild
+pub const configureBuild = build_runner.configureBuild;
+pub const Options = build_runner.Options;
+pub const BuildResult = build_runner.BuildResult;
+
+const FixtureCommand = struct {
+    name: []const u8,
+    cwd: []const u8,
+    build_args: []const []const u8 = &.{},
+    expect_exit: u8 = 0,
+    stdout_match: ?[]const u8 = null,
+    stderr_match: ?[]const u8 = null,
+};
+
+fn addFixtureCommand(b: *std.Build, aggregate: *std.Build.Step, command: FixtureCommand) void {
+    const run = b.addSystemCommand(&.{ b.graph.zig_exe, "build" });
+    run.has_side_effects = true;
+    run.addArgs(command.build_args);
+    run.setCwd(b.path(command.cwd));
+    run.expectExitCode(command.expect_exit);
+    if (command.stdout_match) |expected| run.expectStdOutMatch(expected);
+    if (command.stderr_match) |expected| run.expectStdErrMatch(expected);
+
+    const step = b.step(
+        b.fmt("test:fixture:{s}", .{command.name}),
+        b.fmt("Run fixture check {s}", .{command.name}),
+    );
+    step.dependOn(&run.step);
+    aggregate.dependOn(&run.step);
+}
 
 pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    const module_zbuild = b.createModule(.{
-        .root_source_file = b.path("src/main.zig"),
+    // zbuild library module (for use by zbuild-powered projects)
+    const zbuild_module = b.addModule("zbuild", .{
+        .root_source_file = b.path("src/build_runner.zig"),
         .target = target,
         .optimize = optimize,
     });
-    b.modules.put(b.dupe("zbuild"), module_zbuild) catch @panic("OOM");
-
-    const exe_zbuild = b.addExecutable(.{
-        .name = "zbuild",
-        .root_module = module_zbuild,
-    });
-
-    const install_exe_zbuild = b.addInstallArtifact(exe_zbuild, .{});
-
-    const tls_install_exe_zbuild = b.step("build-exe:zbuild", "Install the zbuild executable");
-    tls_install_exe_zbuild.dependOn(&install_exe_zbuild.step);
-    b.getInstallStep().dependOn(&install_exe_zbuild.step);
-
-    const run_exe_zbuild = b.addRunArtifact(exe_zbuild);
-    if (b.args) |args| run_exe_zbuild.addArgs(args);
-    const tls_run_exe_zbuild = b.step("run:zbuild", "Run the zbuild executable");
-    tls_run_exe_zbuild.dependOn(&run_exe_zbuild.step);
 
+    // Tests
     const tls_run_test = b.step("test", "Run all tests");
 
     const test_zbuild = b.addTest(.{
         .name = "zbuild",
-        .root_module = module_zbuild,
-        .filters = b.option([][]const u8, "zbuild.filters", "zbuild test filters") orelse &[_][]const u8{},
+        .root_module = zbuild_module,
+        .filters = b.option([]const []const u8, "zbuild.filters", "zbuild test filters") orelse &.{},
     });
-    const install_test_zbuild = b.addInstallArtifact(test_zbuild, .{});
-    const tls_install_test_zbuild = b.step("build-test:zbuild", "Install the zbuild test");
-    tls_install_test_zbuild.dependOn(&install_test_zbuild.step);
-
     const run_test_zbuild = b.addRunArtifact(test_zbuild);
-    const tls_run_test_zbuild = b.step("test:zbuild", "Run the zbuild test");
-    tls_run_test_zbuild.dependOn(&run_test_zbuild.step);
+    const tls_test_zbuild = b.step("test:zbuild", "Run the zbuild tests");
+    tls_test_zbuild.dependOn(&run_test_zbuild.step);
     tls_run_test.dependOn(&run_test_zbuild.step);
 
-    const module_sync = b.createModule(.{
-        .root_source_file = b.path("test/sync.zig"),
-        .target = target,
-        .optimize = optimize,
-    });
-    b.modules.put(b.dupe("sync"), module_sync) catch @panic("OOM");
-
-    const test_sync = b.addTest(.{
-        .name = "sync",
-        .root_module = module_sync,
-        .filters = b.option([][]const u8, "sync.filters", "sync test filters") orelse &[_][]const u8{},
-    });
-    const install_test_sync = b.addInstallArtifact(test_sync, .{});
-    const tls_install_test_sync = b.step("build-test:sync", "Install the sync test");
-    tls_install_test_sync.dependOn(&install_test_sync.step);
+    const tls_test_fixtures = b.step("test:fixtures", "Run fixture integration tests");
+    tls_run_test.dependOn(tls_test_fixtures);
 
-    const run_test_sync = b.addRunArtifact(test_sync);
-    const tls_run_test_sync = b.step("test:sync", "Run the sync test");
-    tls_run_test_sync.dependOn(&run_test_sync.step);
-    tls_run_test.dependOn(&run_test_sync.step);
-
-    module_sync.addImport("zbuild", module_zbuild);
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "examples-full-build",
+        .cwd = "examples/full",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "examples-full-info",
+        .cwd = "examples/full",
+        .build_args = &.{"info"},
+        .stdout_match = "full_example v1.0.0",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "manual-interop-build",
+        .cwd = "test/fixtures/manual_interop",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "manual-interop-run",
+        .cwd = "test/fixtures/manual_interop",
+        .build_args = &.{"run:myapp"},
+        .stderr_match = "manual manual",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "manual-interop-cmd",
+        .cwd = "test/fixtures/manual_interop",
+        .build_args = &.{"cmd:demo"},
+        .stdout_match = "manual interop ok",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "undeclared-external-module",
+        .cwd = "test/fixtures/undeclared_external_module",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "undeclared-external-step",
+        .cwd = "test/fixtures/undeclared_external_step",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "manual-step-named-test",
+        .cwd = "test/fixtures/manual_step_named_test",
+        .build_args = &.{"cmd:demo"},
+        .stdout_match = "manual test step ok",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "aliases-nested",
+        .cwd = "test/fixtures/aliases_nested",
+        .build_args = &.{"check"},
+        .stderr_match = "alias fixture ok",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "presets-prod",
+        .cwd = "test/fixtures/presets",
+        .build_args = &.{ "run:demo", "-Dpreset=prod" },
+        .stderr_match = "level=warn tracing=false asset=dist/prod",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "presets-cli-override",
+        .cwd = "test/fixtures/presets",
+        .build_args = &.{ "run:demo", "-Dpreset=prod", "-Dconfig.log_level=debug" },
+        .stderr_match = "level=debug tracing=false asset=dist/prod",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "presets-invalid-name",
+        .cwd = "test/fixtures/presets",
+        .build_args = &.{ "run:demo", "-Dpreset=missing" },
+        .expect_exit = 1,
+        .stderr_match = "invalid value for -Dpreset: 'missing'",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "manual-module-collision",
+        .cwd = "test/fixtures/manual_module_collision",
+        .expect_exit = 1,
+        .stderr_match = "named module 'core' collides with an existing module registered before configureBuild",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "manual-step-collision",
+        .cwd = "test/fixtures/manual_step_collision",
+        .expect_exit = 1,
+        .stderr_match = "run command step 'cmd:demo' collides with an existing top-level step registered before configureBuild",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "import-namespace-named-options-collision",
+        .cwd = "test/fixtures/import_namespace_named_options_collision",
+        .expect_exit = 1,
+        .stderr_match = "options module 'config' collides with another zbuild-owned import name (named module)",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "import-namespace-dependency-default-collision",
+        .cwd = "test/fixtures/import_namespace_dependency_default_collision",
+        .expect_exit = 1,
+        .stderr_match = "dependency default module 'dep_pkg' collides with another zbuild-owned import name (options module)",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "inline-name-collision",
+        .cwd = "test/fixtures/inline_name_collision",
+        .expect_exit = 2,
+        .stderr_match = "collides with named module",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "dependency-bad-import",
+        .cwd = "test/fixtures/dependency_bad_import",
+        .expect_exit = 1,
+        .stderr_match = "could not resolve module 'missing' from dependency 'dep_pkg'",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "dependency-bad-lazy-path",
+        .cwd = "test/fixtures/dependency_bad_lazy_path",
+        .expect_exit = 1,
+        .stderr_match = "could not resolve named lazy path 'missing' from dependency 'dep_pkg'",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "root-module-string-options-module",
+        .cwd = "test/fixtures/root_module_string_options_module",
+        .expect_exit = 2,
+        .stderr_match = "options module 'config' is import-only and cannot be used as root_module",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "duplicate-installable-artifact-name",
+        .cwd = "test/fixtures/duplicate_installable_artifact_name",
+        .expect_exit = 2,
+        .stderr_match = "installable artifact names must be unique",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "alias-empty-depends-on",
+        .cwd = "test/fixtures/alias_empty_depends_on",
+        .expect_exit = 2,
+        .stderr_match = "aliases 'check': depends_on must not be empty",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "preset-unknown-option",
+        .cwd = "test/fixtures/preset_unknown_option",
+        .expect_exit = 2,
+        .stderr_match = "presets 'dev.config': unknown option 'missing'",
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "stdlib-passthrough-library",
+        .cwd = "test/fixtures/stdlib_passthrough",
+        .build_args = &.{"build-lib:mylib"},
+    });
+    addFixtureCommand(b, tls_test_fixtures, .{
+        .name = "stdlib-passthrough-test",
+        .cwd = "test/fixtures/stdlib_passthrough",
+        .build_args = &.{"build-test:unit"},
+    });
 }
diff --git a/build.zig.zon b/build.zig.zon
index 5a55a88..ff9127d 100644
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -1,10 +1,9 @@
-// This file is generated by zbuild. Do not edit manually.
-
 .{
     .name = .zbuild,
-    .version = "0.2.0",
+    .version = "0.4.0",
     .fingerprint = 0x60f98ac2bf5a915c,
-    .minimum_zig_version = "0.14.0",
-    .dependencies = .{},
+    .minimum_zig_version = "0.16.0",
     .paths = .{ "build.zig", "build.zig.zon", "src" },
+    .description = "Declarative build configuration for Zig projects",
+    .dependencies = .{},
 }
diff --git a/docs/AdvancedFeatures.md b/docs/AdvancedFeatures.md
deleted file mode 100644
index a0fd193..0000000
--- a/docs/AdvancedFeatures.md
+++ /dev/null
@@ -1,102 +0,0 @@
-# Advanced Features
-
-## WriteFiles: Managing Generated Files
-
-The `write_files` feature in `zbuild` allows you to define sets of files or directories to be copied or generated during the build process. This is particularly useful for managing assets, configuration files, or generated code that your project depends on. The `write_files` section in `zbuild.zon` lets you specify these resources declaratively, and `zbuild` will generate the corresponding `build.zig` code to handle them.
-
-### Configuration
-The `write_files` field is an object where each key is a named set of files, and the value defines the files or directories to include. Each entry can be marked as `private` (accessible only within the build script) or public (installable as part of the build output). The `items` field specifies the source paths and their destinations.
-Here’s an example `zbuild.zon` snippet:
-
-```zon
-.{
-    .name = .myproject,
-    .version = "0.1.0",
-    .fingerprint = 0x90797553773ca567,
-    .minimum_zig_version = "0.14.0",
-    .paths = .{ "build.zig", "build.zig.zon", "src" },
-    .write_files = .{
-        .assets = .{
-            .items = .{
-                .@"logo.png" = .{
-                    .type = "file",
-                    .path = "resources/logo.png",
-                },
-                .config = .{
-                    .type = "dir",
-                    .path = "resources/config",
-                    .exclude_extensions = .{".tmp"},
-                },
-            },
-        },
-    },
-    .executables = .{
-        .myapp = .{
-            .root_module = .{
-                .root_source_file = "src/main.zig",
-            },
-        },
-    },
-}
-```
-
-#### How It Works
-- `private`: If `true`, the files are added via `b.addWriteFiles()`, making them available only within the build script. If `false` or omitted, `b.addNamedWriteFiles()` is used, and the files are installable.
-- `items`: A map of destination paths to source specifications:
-  - `file`: Copies a single file (e.g., `resources/logo.png` to `logo.png` in the write files directory).
-
-  - `dir`: Copies a directory, with optional `exclude_extensions` or `include_extensions` filters.
-
-In the generated `build.zig`, this translates to:
-
-```zig
-const write_files_assets = b.addNamedWriteFiles();
-
-...
-
-_ = write_files_assets.addCopyFile(b.path("resources/logo.png"), "logo.png");
-_ = write_files_assets.addCopyDirectory(b.path("resources/config"), "config", .{ .exclude_extensions = &[_][]const u8{"tmp"} });
-```
-
-## LazyPath Resolution: Flexible File References
-`LazyPath` resolution enhances `zbuild` by allowing you to reference files dynamically across different sources (e.g., project files, `write_files`, `dependencies`, or `options`) using a colon-delimited syntax. This feature provides a flexible way to manage file paths without hardcoding them, making your build configuration more portable and maintainable.
-
-### Syntax
-Paths in zbuild.zon can use the following format:
-- Simple Path: `src/main.zig` – A direct filesystem path relative to the project root.
-- Prefixed Path: `<source>[:<path>]` – Specifies the source of the path, such as the name of a write_files, dependency, or option.
-
-Supported sources include:
-- writefiles: `<name>:<path>`: References a file or directory from a `write_files` set.
-- dependency named lazy path: `<name>:<path>`: References a file from a dependency’s named lazy paths.
-- dependency named writefiles: `<name>:<writefile>:<path>`: References a file from a dependency’s named write files.
-- options: `<name>`: References a `LazyPath` option value from the `options` section.
-
-### Configuration Example
-Here’s an extended `zbuild.zon` showcasing `LazyPath` resolution:
-
-```zon
-.{
-    .name = .myproject,
-    .version = "0.1.0",
-    .fingerprint = 0x90797553773ca567,
-    .minimum_zig_version = "0.14.0",
-    .paths = .{ "build.zig", "build.zig.zon", "src" },
-    .dependencies = .{
-        .bar = .{
-            .url = "git+https://github.com/org/bar",
-        },
-    },
-    .modules = .{
-        .foo = .{
-            .root_source_file = "bar:some_output",
-        },
-    },
-}
-```
-
-#### How It Works
-- `bar:some_output`: Resolves to the named lazy file `some_output` from the `bar` dependency.
-
-### Usage
-- Extensibility: The `LazyPath` system supports additional sources like dependencies or options, making it adaptable to complex workflows.
diff --git a/docs/MOTIVATION.md b/docs/MOTIVATION.md
deleted file mode 100644
index e9b1d5f..0000000
--- a/docs/MOTIVATION.md
+++ /dev/null
@@ -1,145 +0,0 @@
-# Motivation for zbuild
-
-## Why zbuild?
-
-The Zig programming language offers a powerful and flexible build system integrated directly into its toolchain via `build.zig` files. This system, while highly customizable and programmatic, can become complex and verbose for larger projects or for developers who prefer a declarative approach to configuration. `zbuild` was created to address these challenges by providing an opinionated, ZON-based alternative to Zig's native build system, aiming to streamline the build process while retaining the power of Zig’s capabilities.
-
-The motivation behind `zbuild` stems from a desire to improve the developer experience for Zig projects, making it easier to define, manage, and share build configurations without sacrificing the language’s strengths. Here’s why `zbuild` exists and what it seeks to achieve:
-
----
-
-## Problems with the Status Quo
-
-### 1. Complexity of `build.zig`
-Zig’s build system is a full-fledged programming environment written in Zig itself. While this offers unparalleled flexibility—allowing dynamic build logic, conditional compilation, and custom steps—it comes with a steep learning curve:
-- Developers must write and maintain imperative Zig code for tasks like adding executables, libraries, or dependencies.
-- Common build patterns (e.g., adding an executable with a test) require repetitive boilerplate code.
-- Debugging build scripts can be challenging due to their programmatic nature.
-
-For small projects, this might be manageable, but as projects grow, the `build.zig` file can become a maintenance burden, especially for teams or newcomers unfamiliar with Zig’s build internals.
-
-### 2. Lack of Declarative Configuration
-Many modern build tools (e.g., `Cargo` for Rust, `npm`/`package.json` for Node.js) offer declarative configuration files that define what to build rather than how to build it. Zig’s `build.zig` requires developers to specify both, which can feel overly hands-on for straightforward projects. There’s no built-in way to define a project’s structure in a simple, human-readable format without writing code.
-
-### 3. Inconsistent Build Patterns
-Without a standardized structure, different Zig projects may adopt wildly different `build.zig` conventions. This inconsistency makes it harder for developers to:
-- Quickly understand a new project’s build setup.
-- Reuse build logic across projects.
-- Share build configurations with the community.
-
-### 4. Limited Tooling Integration
-While Zig’s build system is powerful, its programmatic nature doesn’t lend itself easily to integration with external tools like IDEs or CI/CD pipelines, which often expect structured configuration files (e.g., JSON or YAML) for validation, autocompletion, or automation. While ZON is still nascent, its smaller feature surface fits well.
-
----
-
-## Goals of zbuild
-
-`zbuild` aims to address these issues by introducing a layer of abstraction over Zig’s build system, guided by the following goals:
-
-### 1. Simplify Build Definition
-By using a ZON-based configuration file (`zbuild.zon`), `zbuild` allows developers to declaratively specify their project’s components—dependencies, modules, executables, libraries, tests, and more—without writing Zig code. This reduces the cognitive load and makes build setup accessible to developers who may not be Zig experts.
-
-For example, instead of writing:
-
-```zig
-const std = @import("std");
-
-pub fn build(b: *std.Build) void {
-    const module_myapp = b.createModule(.{
-        .root_source_file = b.path("src/main.zig"),
-        .target = b.standardTargetOptions(.{}),
-    });
-    b.modules.put(b.dupe("myapp"), module_myapp) catch @panic("OOM");
-
-    const exe_myapp = b.addExecutable(.{
-        .name = "myapp",
-        .root_module = module_myapp,
-    });
-
-    const install_exe_myapp = b.addInstallArtifact(exe_myapp, .{});
-    const install_tls_exe_myapp = b.step("build-exe:myapp", "Install the myapp executable");
-    install_tls_exe_myapp.dependOn(&install_exe_myapp.step);
-    b.getInstallStep().dependOn(&install_exe_myapp.step);
-
-    const run_exe_myapp = b.addRunArtifact(exe_myapp);
-    if (b.args) |args| run_exe_myapp.addArgs(args);
-    const run_tls_exe_myapp = b.step("run:myapp", "Run the myapp executable");
-    run_tls_exe_myapp.dependOn(&run_exe_myapp.step);
-
-    const test_myapp = b.addTest(.{
-        .name = "myapp",
-        .root_module = module_myapp,
-    });
-    const install_test_myapp = b.addInstallArtifact(test_myapp, .{});
-    const install_tls_test_myapp = b.step("build-test:myapp", "Install the myapp test");
-    install_tls_test_myapp.dependOn(&install_test_myapp.step);
-
-    const run_test_myapp = b.addRunArtifact(test_myapp);
-    const run_tls_test_myapp = b.step("test:myapp", "Run the myapp test");
-    run_tls_test_myapp.dependOn(&run_test_myapp.step);
-}
-```
-
-
-You can define:
-```zon
-.{
-    .name = .project,
-    .version = "0.1.0",
-    .fingerprint = 0xdeadbeefdeadbeef,
-    .minimum_zig_version = "0.14.0",
-    .paths = .{ "build.zig", "build.zig.zon", "src" },
-    .executables = .{
-        .myapp = .{
-            .root_module = .{
-                .root_source_file = "src/main.zig",
-            }
-        }
-    }
-}
-```
-
-And let `zbuild` generate the necessary `build.zig`.
-
-### 2. Reduce Boilerplate
-`zbuild` automates repetitive tasks like creating install steps, run commands, and tests for each target. It enforces a consistent structure, eliminating the need to manually replicate common patterns across projects.
-
-### 3. Enhance Readability and Maintainability
-A ZON configuration is inherently more readable and diff-friendly than a programmatic script. It’s easier to see at a glance what a project builds, what it depends on, and how it’s configured. This also simplifies maintenance, as changes to the build setup are more predictable and less error-prone.
-
-### 4. Preserve Zig’s Power
-While zbuild introduces a declarative layer, it doesn’t abandon Zig’s flexibility. It generates a build.zig file that can be customized further if needed, allowing developers to drop down to the native build system for advanced use cases. The generated file serves as a starting point, not a limitation.
-
-### 5. Foster a Standard Build Workflow
-By providing an opinionated structure, zbuild encourages a consistent build workflow across Zig projects. This standardization can lower the barrier to entry for new contributors and make it easier to share build configurations or adopt best practices.
-
-## Usecases
-
-`zbuild` is particularly valuable for:
-- **Beginners**: Developers new to Zig can define builds without learning the intricacies of build.zig.
-- **Large Projects**: Teams managing multiple targets (executables, libraries, tests) benefit from a centralized, declarative configuration.
-- **Open-Source Projects**: A readable `zbuild.zon` makes it easier for contributors to understand and modify the build setup.
-
-## Trade-Offs
-Introducing `zbuild` comes with trade-offs:
-- **Opinionation**: The tool enforces a specific structure, which may not suit every project’s needs. Developers requiring full control may prefer raw `build.zig`.
-- **Maturity**: Incomplete features limit its scope, but the foundation is solid.
-
-For many, the benefits—simplicity, consistency, and tooling—outweigh these drawbacks.
-
-## Inspiration
-`zbuild` draws inspiration from:
-- **npm (Node.js)**: `package.json` provides a structured way to define scripts, dependencies, and metadata.
-- **Cargo (Rust)**: A declarative Cargo.toml simplifies Rust project builds while retaining flexibility via `build.rs`.
-
-Unlike these tools, `zbuild` is tailored to Zig’s unique ecosystem, leveraging its native build system rather than replacing it.
-
-## Future Vision
-`zbuild` aspires to become an indispensable companion in the Zig ecosystem, evolving beyond its current foundation to empower developers at every level. Its high-level ambitions include:
-
-- **Democratizing Zig Development**: Lower the barrier to entry with an intuitive, welcoming build experience, empowering newcomers and seasoned developers alike to embrace Zig’s potential.
-- **Full Feature Parity**: Support all build.zig capabilities (e.g., depends_on, custom steps).
-- **Seamless Build Excellence**: Evolve into a tool that effortlessly harnesses Zig’s full build capabilities, turning complexity into simplicity and fueling rapid project creation.
-- **Thriving Zig Ecosystem**: Catalyze a flourishing community by streamlining dependency management and fostering collaboration, driving widespread adoption 
-
-By alleviating the complexities of Zig’s build system while embracing its strengths, zbuild seeks to empower developers, making project setup and maintenance intuitive and efficient.
diff --git a/docs/TODO.md b/docs/TODO.md
deleted file mode 100644
index f3a48e9..0000000
--- a/docs/TODO.md
+++ /dev/null
@@ -1,22 +0,0 @@
-- [x] add test, fmt tls
-- [x] add options to Config
-- [x] single code path for Config processing
-  - always use codegen build.zig
-- [x] compact union json parsing
-- [x] fix how build_runner_path is set in cli
-  - will be resolved by only using build.zig
-- [x] robust generate cli command
-  - write build.zig.zon
-  - read file / write directory flags
-- [x] add init command
-- [x] add fetch command
-- [x] add named write files to Config
-- [x] make ~~json~~zon parsing errors friendly
-
-- add named lazy paths to Config
-- add fuzz to Config
-- add additional module options, eg. addIncludePath
-- conditionals? template strings?
-- implement depends_on and test_runner
-- lots of tests
-
diff --git a/docs/concepts.md b/docs/concepts.md
new file mode 100644
index 0000000..8dac753
--- /dev/null
+++ b/docs/concepts.md
@@ -0,0 +1,258 @@
+# Conceptual Model
+
+This page answers the question the README does not try to answer in full: what is zbuild actually doing?
+
+If the README is the top-down path, this is the bottom-up path. The goal here is not to teach every field. The goal is to make the whole library feel coherent.
+
+## 1. zbuild is a translation layer
+
+zbuild is not a new build system. It is a compile-time translation layer on top of `std.Build`.
+
+The pipeline is:
+
+1. Zig evaluates `@import("build.zig.zon")` as a typed anonymous struct.
+2. zbuild validates that value.
+3. zbuild emits ordinary `std.Build` modules, artifacts, and steps from it.
+
+That has three consequences:
+
+- The compiler is the parser.
+- The manifest type is the schema.
+- The escape hatch is always just normal `build.zig` code.
+
+## 2. The manifest is a graph declaration
+
+Different sections create different kinds of graph nodes:
+
+| Section | Produces | Main public names |
+|---|---|---|
+| `modules` | reusable Zig modules | enum-literal import names like `.core` |
+| `options_modules` | generated Zig config modules | enum-literal import names like `.config`; CLI flags like `-Dconfig.verbose` |
+| `executables` | installable executable artifacts | `.myapp`, `build-exe:myapp`, `run:myapp` |
+| `libraries` | installable library artifacts | `.mylib`, `build-lib:mylib` |
+| `objects` | installable object artifacts | `.myobj`, `build-obj:myobj` |
+| `tests` | test artifacts plus run/install steps | `test`, `test:unit`, `build-test:unit` |
+| `fmts` | formatting steps | `fmt`, `fmt:src` |
+| `runs` | arbitrary command steps | `cmd:deploy` |
+| `aliases` | named aggregate top-level steps | `check`, `ci`, `release` |
+| `dependencies` | loaded dependency build graphs | default module refs like `.zlib`, submodule refs like `"zlib:zlib"` |
+
+This is the first important idea: zbuild sections are not random manifest blobs. Each section exists because it corresponds to a specific class of `std.Build` node.
+
+`presets` are the exception on purpose: they do not create graph nodes. They are named bundles of `options_modules` overrides layered on top of the option schema.
+
+## 3. Ownership lives in syntax
+
+The cleanest part of zbuild's design is that reference syntax encodes ownership.
+
+### `root_module`
+
+- `.core` means a zbuild-owned named module
+- `"shared"` means a manual module created with `b.addModule(...)` before `configureBuild`
+- inline struct means define the module right here
+
+### `imports`
+
+- `.core` means a named module
+- `.config` means an options module
+- `.zlib` means a dependency default module
+- `"shared"` means a manual module
+- `"zlib:zlib"` means a dependency submodule
+
+### `depends_on`
+
+- `.myapp` means the install step for artifact `myapp`
+- `"run:myapp"` means the exact generated step named `run:myapp`
+- `"gen:prep"` means the exact manual top-level step named `gen:prep`
+
+That syntax split is the main reason the API can stay terse without becoming ambiguous everywhere.
+
+## 4. There are multiple namespaces, on purpose
+
+zbuild does not have one universal bag of names. It has several namespaces with different rules.
+
+### Import namespace
+
+Named modules, options modules, and dependency default modules all share one enum-literal import namespace.
+
+Examples:
+
+- `.core`
+- `.config`
+- `.zlib`
+
+Those names must be unique across those categories. zbuild rejects collisions instead of picking one by precedence.
+
+### Manual-module namespace
+
+Bare strings in `root_module` and `imports` are reserved for manual modules registered before `configureBuild`.
+
+Example:
+
+- `"shared"`
+
+This is a separate namespace on purpose. If a name belongs to zbuild, you should use the zbuild syntax for it.
+
+### Artifact shorthand namespace
+
+Executables, libraries, and objects share one shorthand namespace for `depends_on`.
+
+Example:
+
+- `.myapp`
+- `.mylib`
+
+That shorthand maps to exactly one install step, so installable artifact names must be unique across those sections.
+
+### Top-level step namespace
+
+Generated step names and manual top-level steps live together in the top-level step namespace.
+
+Examples:
+
+- `build-exe:myapp`
+- `run:myapp`
+- `test`
+- `cmd:deploy`
+- `check`
+- `gen:prep`
+
+Strings in `depends_on` target exact step names in this namespace.
+
+Some bare names are only reserved conditionally: `"test"` and `"fmt"` are zbuild-owned only when the manifest actually defines `tests` or `fmts`; otherwise those names remain available for manual top-level steps.
+
+## 5. Private modules are still zbuild modules
+
+`modules.<name>.private = true` means "do not export this module to `b.modules`", not "pretend it does not exist".
+
+Private named modules are still:
+
+- part of the zbuild-owned graph
+- referenceable from other zbuild manifest entries
+- subject to the same zbuild namespace rules
+
+The difference is visibility to outside `build.zig` consumers, not visibility inside the manifest.
+
+## 6. Validation splits by what is actually knowable
+
+zbuild validates in two phases because some facts are available at comptime and some are not.
+
+### Compile time
+
+These fail with `@compileError`:
+
+- unknown fields inside zbuild-owned sections
+- bad local refs to zbuild-owned modules, artifacts, and generated steps
+- namespace collisions within the zbuild-owned graph
+- malformed reference syntax
+- typed option schema mistakes
+
+### Configure time
+
+These fail while `configureBuild` runs, before the build graph executes:
+
+- missing manual modules or steps
+- missing dependency exports
+- missing dependency-backed lazy paths
+- dependency artifact lookup failures
+
+This is not an arbitrary split. It follows ownership and knowability:
+
+- manifest-owned graph: knowable at comptime
+- manual/dependency state: only knowable after `build.zig` and `b.dependency(...)` have run
+
+## 7. Options modules are generated config APIs
+
+`options_modules` are not just CLI flags. Each entry creates an importable Zig module.
+
+```zig
+.options_modules = .{
+    .config = .{
+        .verbose = .{
+            .type = .bool,
+            .default = false,
+        },
+        .log_level = .{
+            .type = .@"enum",
+            .values = .{ .debug, .info, .warn },
+            .default = .info,
+        },
+    },
+},
+```
+
+Users set values with:
+
+```bash
+zig build -Dconfig.verbose=true -Dconfig.log_level=warn
+```
+
+And Zig code imports:
+
+```zig
+const config = @import("config");
+```
+
+That is why `options_modules` live in the import namespace but are not valid `root_module` targets: they are config surfaces, not compilation roots.
+
+`presets` sit on top of that system, not beside it. A preset:
+
+- is selected explicitly with `-Dpreset=<name>`
+- only overrides `options_modules`
+- does not redefine types
+- does not create another imported module
+
+The precedence is:
+
+1. explicit `-Dmodule.option=...`
+2. selected preset override
+3. declared option default
+4. `null`
+
+That keeps presets as a convenience layer for repeated option bundles, not a second configuration system.
+
+## 8. Interop is explicit, not magical
+
+Manual `build.zig` code still matters. The rule is simple:
+
+- register manual modules and manual top-level steps before `configureBuild`
+- reference them from the manifest with bare strings
+
+Example:
+
+```zig
+_ = b.addModule("shared", .{
+    .root_source_file = b.path("src/shared.zig"),
+    .target = b.resolveTargetQuery(.{}),
+    .optimize = .Debug,
+});
+_ = b.step("gen:prep", "manual prep step");
+```
+
+Manifest side:
+
+```zig
+.root_module = "shared"
+.imports = .{"shared"}
+.depends_on = .{"gen:prep"}
+```
+
+Aliases use that same `depends_on` model, but only create a named grouping step. They do not introduce a command or artifact of their own.
+
+That model stays understandable because the syntax tells you when you are leaving the zbuild-owned world.
+
+## 9. Why this feels coherent
+
+zbuild gets leverage from using Zig's own semantics instead of fighting them:
+
+- `build.zig.zon` is already typed
+- `std.Build` is already the backend
+- `build.zig` is already the escape hatch
+
+So the library only needs to add:
+
+- a graph-oriented manifest surface
+- a consistent reference model
+- early validation
+
+That is the whole design in one sentence: zbuild makes the static parts of a Zig build graph declarative without pretending the dynamic parts are declarative too.
diff --git a/docs/motivation.md b/docs/motivation.md
new file mode 100644
index 0000000..a522e8a
--- /dev/null
+++ b/docs/motivation.md
@@ -0,0 +1,60 @@
+# Why zbuild?
+
+zbuild exists for a specific kind of Zig project:
+
+- the build graph is mostly static
+- the same `std.Build` patterns repeat across many targets
+- the team wants earlier, clearer failures than "some code in `build.zig` did the wrong thing"
+
+It is not trying to remove Zig from the build story. It is trying to remove repetitive graph wiring from the parts that are already declarative in practice.
+
+## The problem it attacks
+
+Zig's build system is powerful because it is just Zig. That is also the source of the friction:
+
+- a small executable often turns into a surprising amount of `build.zig`
+- adding tests, runs, install steps, and module wiring scales linearly in boilerplate
+- newcomers must learn a large API before they can express a simple graph
+
+For a lot of projects, that is the wrong abstraction level. The graph is static. The code is just encoding structure.
+
+## The design bet
+
+zbuild makes one strong bet:
+
+> `build.zig.zon` plus comptime is already enough structure to describe most static build graphs.
+
+That bet only works because Zig already gives zbuild the important pieces:
+
+- `@import("build.zig.zon")` returns a typed value at comptime
+- `std.Build` is the real backend
+- `build.zig` remains available for everything dynamic
+
+So zbuild does not need a runtime parser, a custom IR, or a replacement toolchain. It only needs a coherent manifest surface and a disciplined translation into `std.Build`.
+
+## What zbuild optimizes for
+
+zbuild is trying to maximize four things at once:
+
+- **Terseness** for the common static graph cases
+- **Coherence** through explicit ownership and naming rules
+- **Early failure** for manifest-owned mistakes
+- **Interop** with manual `build.zig` code when the graph stops being static
+
+That is why the library uses syntax splits like enum literals vs strings instead of trying to infer intent from arbitrary names. The API is smaller and more learnable when "what kind of thing is this?" has a visible answer.
+
+## What it does not try to be
+
+zbuild is not:
+
+- a replacement for `build.zig`
+- a universal abstraction over every `std.Build` feature
+- a promise that all validation can happen at comptime
+
+If you need platform-conditional logic, generated inputs, custom discovery, or one-off graph surgery, write that in `build.zig`. zbuild is meant to coexist with that code, not ban it.
+
+## How to read the docs
+
+- Start with the [README](../README.md) if you want the fastest path from zero to a working build.
+- Read [Conceptual Model](concepts.md) if you want the bottom-up explanation of namespaces, ownership, and validation phases.
+- Keep [Schema Reference](schema.md) open when you need exact field types and generated step names.
diff --git a/docs/schema.md b/docs/schema.md
new file mode 100644
index 0000000..e96c501
--- /dev/null
+++ b/docs/schema.md
@@ -0,0 +1,477 @@
+# ZON Schema Reference
+
+This page is the bottom-most reference. If you are new to zbuild, read the [README](../README.md) first for the quickstart and [Conceptual Model](concepts.md) second for the mental model.
+
+This is the complete reference for zbuild's manifest fields. These fields are added to your standard `build.zig.zon` alongside Zig's own fields (`name`, `version`, `fingerprint`, `minimum_zig_version`, `paths`, `description`, `dependencies`).
+
+Unknown fields inside zbuild-owned sections are compile errors. Unknown top-level fields are left alone so Zig itself can evolve `build.zig.zon` without zbuild shadowing it.
+
+## `modules`
+
+Reusable code units registered with the build system. Modules can be referenced by name from executables, libraries, and tests via their `root_module` field.
+
+```zig
+.modules = .{
+    .core = .{
+        .root_source_file = "src/core.zig",
+        .imports = .{ .utils, .zlib },
+        .link_libc = true,
+    },
+},
+```
+
+### Fields
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `root_source_file` | string | — | Path to the root source file |
+| `target` | string | host | `"native"` or arch-os-abi triple (e.g. `"x86_64-linux-gnu"`) |
+| `optimize` | enum literal | project default | `.Debug`, `.ReleaseSafe`, `.ReleaseFast`, `.ReleaseSmall` |
+| `imports` | tuple | — | Modules, options_modules, or dependencies to import |
+| `link_libraries` | tuple of strings | — | Dependency library artifacts to link (see below) |
+| `include_paths` | tuple of strings | — | Include paths for C/C++ headers |
+| `private` | bool | `false` | When `true`, not exported to `b.modules` |
+
+### Passthrough fields
+
+These map directly to `std.Build.Module.CreateOptions`:
+
+`link_libc`, `link_libcpp`, `single_threaded`, `strip`, `unwind_tables`, `dwarf_format`, `code_model`, `error_tracing`, `omit_frame_pointer`, `pic`, `red_zone`, `sanitize_c`, `sanitize_thread`, `stack_check`, `stack_protector`, `fuzz`, `valgrind`, `no_builtin`
+
+### `link_libraries` syntax
+
+Format: `"dep_name"` or `"dep_name:artifact_name"`. Resolves a library artifact from a declared dependency. This is distinct from LazyPath resolution.
+
+```zig
+.link_libraries = .{ "zlib", "openssl:libssl" },
+```
+
+### `imports` syntax
+
+Import entries can reference:
+- **Named modules:** `.core`
+- **Options modules:** `.config`
+- **Dependency default modules:** `.zlib`
+- **Dependency sub-modules:** `"zlib:zlib"` (imports a specific module from a dependency)
+- **Manual modules:** `"shared"` resolved from `b.addModule(...)` before `configureBuild`
+
+Named modules, options modules, and dependency default modules share one enum-literal import namespace. Duplicate names across those categories are rejected during `configureBuild`.
+
+## `executables`
+
+Build targets that produce executable binaries. Each entry creates `build-exe:<name>` (install) and `run:<name>` (execute) steps.
+
+```zig
+.executables = .{
+    .myapp = .{
+        .root_module = .core,          // reference a named module
+        .version = "1.0.0",
+    },
+},
+```
+
+### Root module forms
+
+The `root_module` field accepts three forms:
+
+1. **Enum literal** — references a named zbuild module: `.root_module = .core`
+2. **String** — references a manual `b.addModule(...)` module registered before `configureBuild`:
+   ```zig
+   .root_module = "shared"
+   ```
+3. **Inline struct** — defines the module inline, with an optional `name` override:
+   ```zig
+   .root_module = .{
+       .root_source_file = "src/main.zig",
+       .imports = .{ .core, .config, "shared" },
+       .name = "custom_name",  // optional: internal inline-module name used for import wiring
+   },
+   ```
+
+Inline root modules are not importable targets in the manifest. If provided, `root_module.name` must be unique across all inline root modules and must not collide with a named module.
+
+`root_module` string refs are reserved for manual modules only. Names that belong to zbuild-owned modules or `options_modules` are rejected.
+
+### Fields
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `root_module` | ref or struct | required | See root module forms above |
+| `version` | string | — | Semantic version (e.g. `"1.0.0"`) |
+| `linkage` | enum literal | — | `.static` or `.dynamic` |
+| `dest_sub_path` | string | — | Custom install subdirectory |
+| `depends_on` | tuple | — | Steps that must complete first (artifact install step or exact top-level step name) |
+| `max_rss` | int | — | Maximum RSS for the build step |
+| `use_llvm` | bool | — | Use LLVM backend |
+| `use_lld` | bool | — | Use LLD linker |
+| `zig_lib_dir` | string | — | Custom Zig lib directory (LazyPath resolved) |
+| `win32_manifest` | string | — | Win32 manifest file (LazyPath resolved) |
+
+## `libraries`
+
+Same fields as executables, plus `win32_module_definition` and `linker_allow_shlib_undefined`. Each entry creates a `build-lib:<name>` step.
+
+```zig
+.libraries = .{
+    .mylib = .{
+        .root_module = .core,
+        .linkage = .static,
+        .version = "0.1.0",
+    },
+},
+```
+
+| Additional Field | Type | Default | Description |
+|------------------|------|---------|-------------|
+| `win32_module_definition` | string | — | Win32 module definition file (LazyPath resolved) |
+| `linker_allow_shlib_undefined` | bool | — | Allow undefined symbols in shared libs |
+
+## `objects`
+
+Compiled object files. Simpler subset — no `version`, `linkage`, `dest_sub_path`, or `win32_manifest`. Each entry creates a `build-obj:<name>` step.
+
+```zig
+.objects = .{
+    .myobj = .{
+        .root_module = .core,
+    },
+},
+```
+
+Supported fields: `root_module`, `max_rss`, `use_llvm`, `use_lld`, `zig_lib_dir`.
+
+## `tests`
+
+Test targets. Each entry creates `test:<name>` (run) and `build-test:<name>` (install) steps. All tests also join the aggregate `test` step.
+
+```zig
+.tests = .{
+    .unit = .{
+        .root_module = .{
+            .root_source_file = "src/test.zig",
+            .imports = .{.core},
+        },
+        .filters = .{ "specific_test_name" },
+    },
+},
+```
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `root_module` | ref or struct | required | See root module forms |
+| `filters` | tuple of strings | — | Test name filters |
+| `max_rss` | int | — | Maximum RSS |
+| `use_llvm` | bool | — | Use LLVM backend |
+| `use_lld` | bool | — | Use LLD linker |
+| `zig_lib_dir` | string | — | Custom Zig lib directory |
+| `test_runner` | struct | — | Custom test runner struct with `path` and `mode` (`.simple` or `.server`) |
+| `emit_object` | bool | `false` | Emit a test object file instead of a runnable test binary |
+| `linker_allow_shlib_undefined` | bool | — | Allow undefined symbols in shared libs the test links against (e.g. napi C symbols Node provides at dlopen time) |
+
+Filters can be overridden from the CLI: `-D<test_name>.filters=specific_test`.
+
+## `fmts`
+
+Wraps `zig fmt`. Each entry creates `fmt:<name>` and joins the aggregate `fmt` step.
+
+```zig
+.fmts = .{
+    .src = .{
+        .paths = .{ "src", "tests" },
+        .exclude_paths = .{ "src/generated" },
+        .check = true,
+    },
+},
+```
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `paths` | tuple of strings | `&.{}` | Paths to format |
+| `exclude_paths` | tuple of strings | `&.{}` | Paths to exclude |
+| `check` | bool | `false` | Check formatting without modifying |
+
+## `runs`
+
+System commands. Each entry creates a `cmd:<name>` step. Two syntax forms:
+
+### Short form
+
+Bare tuple of strings — becomes `addSystemCommand` args:
+
+```zig
+.runs = .{
+    .fmt = .{ "zig", "fmt", "src" },
+},
+```
+
+### Long form
+
+Struct with `cmd` plus optional fields:
+
+```zig
+.runs = .{
+    .deploy = .{
+        .cmd = .{ "./scripts/deploy.sh", "--env", "staging" },
+        .cwd = "scripts",
+        .env = .{ .NODE_ENV = "production" },
+        .inherit_stdio = true,
+        .depends_on = .{.myapp},
+    },
+},
+```
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `cmd` | tuple of strings | required | Command and arguments |
+| `cwd` | string | inherit | Working directory (LazyPath resolved) |
+| `env` | struct | inherit | Environment variables (field name = key, value = value) |
+| `inherit_stdio` | bool | `false` | Forward stdio to terminal |
+| `stdin` | string | — | Bytes piped to stdin |
+| `stdin_file` | string | — | File piped to stdin (LazyPath resolved) |
+| `depends_on` | tuple | — | Steps that must complete first (artifact install step or exact top-level step name) |
+
+`stdin` and `stdin_file` are mutually exclusive.
+
+`depends_on` accepts both enum literals and strings:
+- **Enum literals:** `.myapp` resolves to the install step for artifact `myapp`
+- **Strings with zbuild-owned names:** `"run:myapp"`, `"test:unit"`, `"cmd:demo"`, `"test"`, or `"fmt"` resolve to exact manifest-owned top-level steps when zbuild generates those step names
+- **Other strings:** `"gen:prep"` resolves to a manual top-level step created before `configureBuild`
+
+If the manifest has no `tests` or `fmts`, bare `"test"` and `"fmt"` remain available for manual top-level steps registered before `configureBuild`.
+
+Installable artifact names across `executables`, `libraries`, and `objects` must be unique. This keeps enum-literal shorthand unambiguous: `.myapp` always means exactly one artifact install step.
+
+Manual top-level steps must be created with `b.step(...)` before calling `configureBuild`.
+
+## `aliases`
+
+Named aggregate top-level steps. Aliases do not execute commands or create artifacts; they only group existing steps under a human-facing name such as `check`, `ci`, or `release`.
+
+```zig
+.aliases = .{
+    .check = .{
+        .description = "Run the main verification steps",
+        .depends_on = .{
+            "test",
+            "fmt",
+        },
+    },
+},
+```
+
+Each alias entry creates a top-level step with exactly that name.
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `depends_on` | tuple | required | Non-empty list of artifact install-step shorthands or exact top-level step names |
+| `description` | string | `"Run the <name> alias"` | Top-level step description |
+
+`depends_on` uses the same syntax and resolution rules as `runs.depends_on`:
+- **Enum literals:** `.myapp` resolves to the install step for artifact `myapp`
+- **Strings with manifest-owned names:** `"test"`, `"fmt"`, `"run:myapp"`, `"cmd:deploy"`, or another alias name resolve to exact zbuild-owned top-level steps
+- **Other strings:** `"gen:prep"` resolves to a manual top-level step created before `configureBuild`
+
+Alias names live in the top-level step namespace. They must not collide with generated zbuild steps, manual steps registered before `configureBuild`, or installable artifact shorthand names such as `.myapp`.
+
+## `options_modules`
+
+Configurable build options exposed as importable Zig modules. Users set values via `-D<module>.<option>=<value>`.
+
+```zig
+.options_modules = .{
+    .config = .{
+        .verbose = .{
+            .type = .bool,
+            .default = false,
+            .description = "Enable verbose output",
+        },
+        .log_level = .{
+            .type = .@"enum",
+            .values = .{ .debug, .info, .warn },
+            .default = .info,
+            .description = "Log level",
+        },
+        .output_dir = .{
+            .type = .string,
+            .description = "Optional output directory",
+        },
+    },
+},
+```
+
+Access in Zig source:
+
+```zig
+const config = @import("config");
+
+if (config.output_dir) |dir| {
+    _ = dir;
+}
+
+switch (config.log_level) {
+    .debug => {},
+    .info => {},
+    .warn => {},
+}
+```
+
+### Option fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `type` | enum literal or string | Required. See supported types below |
+| `default` | varies | Default value (type must match) |
+| `values` | tuple | Required for `.@"enum"` and `.enum_list`; must be non-empty |
+| `type_name` | string | Optional for enum kinds. Defaults to PascalCase of the option name |
+| `description` | string | Shown in `zig build --help` |
+
+### Supported types
+
+The `type` field accepts either enum literals (`.bool`) or strings (`"bool"`). Enum literals are preferred.
+
+If an option has a `default`, the generated field type is `T`. Without a `default`, the generated field type is `?T`.
+
+| Type | Generated Zig type | Default type |
+|------|---------------------|--------------|
+| `.bool` | `bool` / `?bool` | `bool` |
+| `.string` | `[]const u8` / `?[]const u8` | `[]const u8` |
+| `.list` | `[]const []const u8` / `?[]const []const u8` | tuple of strings |
+| `.@"enum"` | `<TypeName>` / `?<TypeName>` | enum literal or string |
+| `.enum_list` | `[]const <TypeName>` / `?[]const <TypeName>` | tuple of enum literals or strings |
+| `.i8` .. `.u64`, `.isize`, `.usize` | corresponding int / optional int | int literal |
+| `.c_int`, `.c_uint`, etc. | corresponding C int / optional C int | int literal |
+| `.f16` .. `.f128`, `.c_longdouble` | corresponding float / optional float | float literal |
+
+Enum kinds generate a public Zig enum type in the imported module:
+
+```zig
+pub const LogLevel = enum {
+    debug,
+    info,
+    warn,
+};
+
+pub const log_level: LogLevel = .info;
+```
+
+## `presets`
+
+Named bundles of `options_modules` overrides. Presets are opt-in only: nothing changes unless the user passes `-Dpreset=<name>`.
+
+```zig
+.presets = .{
+    .dev = .{
+        .app = .{
+            .log_level = .debug,
+            .enable_tracing = true,
+        },
+    },
+    .prod = .{
+        .app = .{
+            .log_level = .warn,
+            .asset_dir = "dist/prod",
+        },
+    },
+},
+```
+
+Select a preset from the CLI:
+
+```bash
+zig build -Dpreset=prod
+zig build -Dpreset=prod -Dapp.log_level=debug
+```
+
+### Structure
+
+- Each top-level preset name is a CLI-selectable preset.
+- Each preset field must name an existing `options_modules` entry.
+- Each override field inside that module must name an existing option.
+- Override values are raw values only. They do not repeat `type`.
+
+### Resolution rules
+
+Presets only affect `options_modules`. They do not modify modules, artifacts, runs, aliases, or dependencies.
+
+For each option, zbuild resolves values in this order:
+
+1. explicit `-D<module>.<option>=...`
+2. selected preset override
+3. option `default`
+4. `null`
+
+If an option declares a `default`, its generated field type remains `T` even when a preset overrides that default. If an option has no `default`, its generated field type remains `?T` even when a preset supplies a value.
+
+## `dependencies`
+
+Standard Zig dependencies declared in `build.zig.zon`. zbuild adds support for an `args` field to forward comptime arguments:
+
+```zig
+.dependencies = .{
+    .zlib = .{
+        .url = "https://example.com/zlib.tar.gz",
+        .hash = "...",
+        .args = .{ .shared = true },  // forwarded to b.dependency("zlib", .{ .shared = true })
+    },
+},
+```
+
+Without `args`, dependencies are resolved with `b.dependency(name, .{})`.
+
+## LazyPath resolution
+
+String paths in fields like `root_source_file`, `cwd`, `zig_lib_dir`, and `include_paths` are resolved via colon-delimited syntax:
+
+| Format | Resolves to |
+|--------|-------------|
+| `"src/main.zig"` | Local file: `b.path("src/main.zig")` |
+| `"dep:path"` | Named lazy path from dependency `dep` |
+| `"dep:wf_name:path"` | File `path` within dependency `dep`'s named WriteFiles step `wf_name` |
+
+**Note:** Avoid naming dependencies the same as local directories (e.g., `src`). A path like `"src:file.zig"` would resolve as a dependency reference rather than a local path.
+
+## Validation
+
+zbuild validates in two phases:
+
+- **Compile time (`@compileError`)** for local graph structure and manifest syntax
+- **Configure time (hard build failure before graph execution)** for manual and dependency state that is only knowable after `build.zig` and `b.dependency(...)` have run
+
+Compile-time validation covers:
+
+- `root_module` and `imports` reference syntax, including manual-module strings, dependency-module strings, and zbuild-owned enum refs
+- `depends_on` enum artifact refs and manifest-owned step names
+- `link_libraries` syntax and dependency base names
+- semantic version strings on executables and libraries
+- unique installable artifact names across `executables`, `libraries`, and `objects`
+- dependency-backed LazyPath syntax (`"dep:path"` / `"dep:wf_name:path"`)
+- target strings on modules
+- `stdin` and `stdin_file` on the same run are mutually exclusive
+
+Configure-time validation covers:
+
+- manual modules referenced from `root_module` and `imports`
+- manual top-level steps referenced from `depends_on`
+- dependency default modules and sub-modules referenced from `imports`
+- dependency artifacts referenced from `link_libraries`
+- dependency named lazy paths and named `WriteFile` steps referenced from LazyPath fields
+
+These configure-time failures stop `zig build` before the graph runs; they do not degrade into stdlib panics.
+
+Unknown fields inside zbuild-managed sections are compile errors. Unknown top-level fields are passed through unchanged so future Zig manifest fields remain usable.
+
+## `configureBuild` options
+
+The third argument to `configureBuild` is a comptime `Options` struct:
+
+```zig
+zbuild.configureBuild(b, @import("build.zig.zon"), .{
+    .help_step = "info",  // default: "help", null to disable
+});
+```
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `help_step` | `?[]const u8` | `"help"` | Step name for the help command, or `null` to disable |
+
+The help step prints a formatted overview of your project, reading `name`, `version`, and `description` from the standard `build.zig.zon` metadata.
diff --git a/examples/full/build.zig b/examples/full/build.zig
new file mode 100644
index 0000000..cd9325b
--- /dev/null
+++ b/examples/full/build.zig
@@ -0,0 +1,8 @@
+const zbuild = @import("zbuild");
+const std = @import("std");
+
+pub fn build(b: *std.Build) !void {
+    _ = try zbuild.configureBuild(b, @import("build.zig.zon"), .{
+        .help_step = "info", // custom help step name
+    });
+}
diff --git a/examples/full/build.zig.zon b/examples/full/build.zig.zon
new file mode 100644
index 0000000..fadd51f
--- /dev/null
+++ b/examples/full/build.zig.zon
@@ -0,0 +1,69 @@
+.{
+    .name = .full_example,
+    .version = "1.0.0",
+    .fingerprint = 0x3dc5c2f38908b4dc,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+    .description = "A comprehensive zbuild example showcasing all features",
+    .dependencies = .{
+        .zbuild = .{ .path = "../.." },
+    },
+    .modules = .{
+        .math = .{
+            .root_source_file = "src/lib.zig",
+        },
+    },
+    .executables = .{
+        .demo = .{
+            .root_module = .{
+                .root_source_file = "src/main.zig",
+                .imports = .{ .math, .config },
+            },
+        },
+    },
+    .libraries = .{
+        .mathlib = .{
+            .root_module = .math,
+        },
+    },
+    .tests = .{
+        .unit = .{
+            .root_module = .{
+                .root_source_file = "src/test.zig",
+                .imports = .{.math},
+            },
+        },
+    },
+    .fmts = .{
+        .src = .{
+            .paths = .{"src"},
+        },
+    },
+    .runs = .{
+        .@"echo-version" = .{ "echo", "full_example v1.0.0" },
+        .greet = .{
+            .cmd = .{ "echo", "hello from zbuild" },
+            .env = .{ .GREETING = "hello" },
+            .inherit_stdio = true,
+        },
+    },
+    .options_modules = .{
+        .config = .{
+            .verbose = .{
+                .type = .bool,
+                .default = false,
+                .description = "Enable verbose output",
+            },
+            .log_level = .{
+                .type = .@"enum",
+                .values = .{ .debug, .info, .warn },
+                .default = .info,
+                .description = "Log level",
+            },
+            .output_dir = .{
+                .type = .string,
+                .description = "Optional output directory",
+            },
+        },
+    },
+}
diff --git a/examples/full/src/lib.zig b/examples/full/src/lib.zig
new file mode 100644
index 0000000..33d4d29
--- /dev/null
+++ b/examples/full/src/lib.zig
@@ -0,0 +1,8 @@
+/// A simple math module to demonstrate zbuild's module system.
+pub fn add(a: i32, b: i32) i32 {
+    return a + b;
+}
+
+pub fn multiply(a: i32, b: i32) i32 {
+    return a * b;
+}
diff --git a/examples/full/src/main.zig b/examples/full/src/main.zig
new file mode 100644
index 0000000..8d3bf6a
--- /dev/null
+++ b/examples/full/src/main.zig
@@ -0,0 +1,19 @@
+const std = @import("std");
+const math = @import("math");
+const config = @import("config");
+
+pub fn main() void {
+    const result = math.add(2, 3);
+    std.debug.print("2 + 3 = {d}\n", .{result});
+    if (config.verbose)
+        std.debug.print("(verbose mode enabled)\n", .{});
+
+    switch (config.log_level) {
+        .debug => std.debug.print("log level: debug\n", .{}),
+        .info => std.debug.print("log level: info\n", .{}),
+        .warn => std.debug.print("log level: warn\n", .{}),
+    }
+
+    if (config.output_dir) |dir|
+        std.debug.print("output dir: {s}\n", .{dir});
+}
diff --git a/examples/full/src/test.zig b/examples/full/src/test.zig
new file mode 100644
index 0000000..1f8864f
--- /dev/null
+++ b/examples/full/src/test.zig
@@ -0,0 +1,12 @@
+const std = @import("std");
+const math = @import("math");
+
+test "add" {
+    try std.testing.expectEqual(@as(i32, 5), math.add(2, 3));
+    try std.testing.expectEqual(@as(i32, 0), math.add(-1, 1));
+}
+
+test "multiply" {
+    try std.testing.expectEqual(@as(i32, 6), math.multiply(2, 3));
+    try std.testing.expectEqual(@as(i32, 0), math.multiply(0, 42));
+}
diff --git a/examples/simple/build.zig b/examples/simple/build.zig
new file mode 100644
index 0000000..5c45f5f
--- /dev/null
+++ b/examples/simple/build.zig
@@ -0,0 +1,6 @@
+const zbuild = @import("zbuild");
+const std = @import("std");
+
+pub fn build(b: *std.Build) !void {
+    _ = try zbuild.configureBuild(b, @import("build.zig.zon"), .{});
+}
diff --git a/examples/simple/build.zig.zon b/examples/simple/build.zig.zon
new file mode 100644
index 0000000..f314d5c
--- /dev/null
+++ b/examples/simple/build.zig.zon
@@ -0,0 +1,18 @@
+.{
+    .name = .simple_example,
+    .version = "0.1.0",
+    .fingerprint = 0x24a585649eafbb78,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+    .description = "A minimal zbuild example",
+    .dependencies = .{
+        .zbuild = .{ .path = "../.." },
+    },
+    .executables = .{
+        .hello = .{
+            .root_module = .{
+                .root_source_file = "src/main.zig",
+            },
+        },
+    },
+}
diff --git a/examples/simple/src/main.zig b/examples/simple/src/main.zig
new file mode 100644
index 0000000..404d45a
--- /dev/null
+++ b/examples/simple/src/main.zig
@@ -0,0 +1,5 @@
+const std = @import("std");
+
+pub fn main() void {
+    std.debug.print("Hello from zbuild!\n", .{});
+}
diff --git a/src/Args.zig b/src/Args.zig
deleted file mode 100644
index 536afc1..0000000
--- a/src/Args.zig
+++ /dev/null
@@ -1,86 +0,0 @@
-//! Parse, iterate over command-line arguments
-const std = @import("std");
-
-const Args = @This();
-
-args: std.ArrayList([]const u8),
-index: usize = 0,
-
-pub fn deinit(self: Args) void {
-    for (self.args.items) |arg| {
-        self.args.allocator.free(arg);
-    }
-    self.args.deinit();
-}
-
-pub fn initFromProcessArgs(allocator: std.mem.Allocator) !Args {
-    var it = try std.process.argsWithAllocator(allocator);
-    defer it.deinit();
-    return try initFromIterator(allocator, &it);
-}
-
-pub fn initFromString(allocator: std.mem.Allocator, input: []const u8) !Args {
-    var it = try std.process.ArgIteratorGeneral(.{ .single_quotes = true }).init(allocator, input);
-    defer it.deinit();
-    return try initFromIterator(allocator, &it);
-}
-
-pub fn initFromIterator(allocator: std.mem.Allocator, it: anytype) !Args {
-    var args = std.ArrayList([]const u8).init(allocator);
-    while (it.next()) |arg| {
-        try args.append(try allocator.dupe(u8, arg));
-    }
-
-    return .{ .args = args };
-}
-
-pub fn next(self: *Args) ?[]const u8 {
-    if (self.index == self.args.items.len) return null;
-
-    const arg = self.args.items[self.index];
-    self.index += 1;
-    return arg;
-}
-
-pub fn peek(self: *Args) ?[]const u8 {
-    if (self.index == self.args.items.len) return null;
-
-    return self.args.items[self.index];
-}
-
-pub fn rest(self: *Args) []const []const u8 {
-    return self.args.items[self.index..];
-}
-
-const TestCase = struct {
-    input: []const u8,
-    expected: []const []const u8,
-};
-const test_cases = &[_]TestCase{
-    .{
-        .input =
-        \\name=Alice "age=30 years" "quoted \"text\""
-        ,
-        .expected = &[_][]const u8{
-            \\name=Alice
-            ,
-            \\age=30 years
-            ,
-            \\quoted "text"
-            ,
-        },
-    },
-};
-
-test "parse" {
-    const allocator = std.testing.allocator;
-    for (test_cases) |tc| {
-        var args = try Args.parse(allocator, tc.input);
-        defer args.deinit();
-
-        const actual = args.args.items;
-        const expected = tc.expected;
-
-        try std.testing.expectEqualDeep(expected, actual);
-    }
-}
diff --git a/src/Config.zig b/src/Config.zig
deleted file mode 100644
index 19ee04d..0000000
--- a/src/Config.zig
+++ /dev/null
@@ -1,1636 +0,0 @@
-//! Configuration file (aka `zbuild.zon`) format for the Zig build system.
-//! This file is meant to be a superset of the `build.zig.zon` manifest file format.
-
-const std = @import("std");
-const ArrayHashMap = std.StringArrayHashMap;
-
-const Config = @This();
-
-name: []const u8,
-version: []const u8,
-fingerprint: []const u8,
-minimum_zig_version: []const u8,
-paths: [][]const u8,
-description: ?[]const u8 = null,
-keywords: ?[][]const u8 = null,
-dependencies: ?ArrayHashMap(Dependency) = null,
-write_files: ?ArrayHashMap(WriteFile) = null,
-options: ?ArrayHashMap(Option) = null,
-options_modules: ?ArrayHashMap(OptionsModule) = null,
-modules: ?ArrayHashMap(Module) = null,
-executables: ?ArrayHashMap(Executable) = null,
-libraries: ?ArrayHashMap(Library) = null,
-objects: ?ArrayHashMap(Object) = null,
-tests: ?ArrayHashMap(Test) = null,
-fmts: ?ArrayHashMap(Fmt) = null,
-runs: ?ArrayHashMap(Run) = null,
-
-pub const Dependency = struct {
-    typ: enum { path, url },
-    value: []const u8,
-    hash: ?[]const u8 = null,
-    lazy: ?bool = null,
-    args: ?ArrayHashMap(Arg) = null,
-
-    const Arg = union(enum) {
-        bool: bool,
-        int: i64,
-        float: f64,
-        @"enum": []const u8,
-        string: []const u8,
-        null: void,
-    };
-
-    pub fn deinit(self: *Dependency, gpa: std.mem.Allocator) void {
-        gpa.free(self.value);
-        if (self.hash) |h| gpa.free(h);
-        if (self.args) |a| {
-            for (a.values()) |arg| switch (arg) {
-                .@"enum" => |e| gpa.free(e),
-                .string => |s| gpa.free(s),
-                else => {},
-            };
-            for (a.keys()) |k| gpa.free(k);
-            a.deinit();
-        }
-    }
-};
-
-pub const Option = union(enum) {
-    bool: Bool,
-    int: Int,
-    float: Float,
-    @"enum": Enum,
-    enum_list: EnumList,
-    string: String,
-    list: List,
-    build_id: BuildId,
-    lazy_path: LazyPath,
-    lazy_path_list: LazyPathList,
-
-    pub const Bool = struct {
-        default: ?bool = null,
-        type: []const u8,
-        description: ?[]const u8 = null,
-    };
-    pub const Int = struct {
-        default: ?i64 = null,
-        type: []const u8,
-        description: ?[]const u8 = null,
-    };
-    pub const Float = struct {
-        default: ?f64 = null,
-        type: []const u8,
-        description: ?[]const u8 = null,
-    };
-    pub const Enum = struct {
-        default: ?[]const u8 = null,
-        enum_options: [][]const u8,
-        type: []const u8,
-        description: ?[]const u8 = null,
-    };
-    pub const EnumList = struct {
-        default: ?[][]const u8 = null,
-        enum_options: [][]const u8,
-        type: []const u8,
-        description: ?[]const u8 = null,
-    };
-    pub const String = struct {
-        default: ?[]const u8 = null,
-        type: []const u8,
-        description: ?[]const u8 = null,
-    };
-    pub const List = struct {
-        default: ?[][]const u8 = null,
-        type: []const u8,
-        description: ?[]const u8 = null,
-    };
-    pub const BuildId = struct {
-        default: ?[]const u8 = null,
-        type: []const u8,
-        description: ?[]const u8 = null,
-    };
-    pub const LazyPath = struct {
-        default: ?[]const u8 = null,
-        type: []const u8,
-        description: ?[]const u8 = null,
-    };
-    pub const LazyPathList = struct {
-        default: ?[][]const u8 = null,
-        type: []const u8,
-        description: ?[]const u8 = null,
-    };
-
-    pub fn deinit(self: *Option, gpa: std.mem.Allocator) void {
-        switch (self.*) {
-            .bool,
-            => |b| {
-                gpa.free(b.type);
-                if (b.description) |d| gpa.free(d);
-            },
-            .int => |i| {
-                gpa.free(i.type);
-                if (i.description) |d| gpa.free(d);
-            },
-            .float => |f| {
-                gpa.free(f.type);
-                if (f.description) |d| gpa.free(d);
-            },
-            .@"enum" => |e| {
-                gpa.free(e.type);
-                if (e.description) |d| gpa.free(d);
-                for (e.enum_options) |eo| gpa.free(eo);
-                gpa.free(e.enum_options);
-                if (e.default) |d| gpa.free(d);
-            },
-            .enum_list => |e| {
-                gpa.free(e.type);
-                if (e.description) |d| gpa.free(d);
-                for (e.enum_options) |eo| gpa.free(eo);
-                gpa.free(e.enum_options);
-                if (e.default) |d| {
-                    for (d) |dd| gpa.free(dd);
-                    gpa.free(d);
-                }
-            },
-            .string,
-            => |s| {
-                gpa.free(s.type);
-                if (s.description) |d| gpa.free(d);
-                if (s.default) |d| gpa.free(d);
-            },
-            .build_id => |s| {
-                gpa.free(s.type);
-                if (s.description) |d| gpa.free(d);
-                if (s.default) |d| gpa.free(d);
-            },
-            .lazy_path => |s| {
-                gpa.free(s.type);
-                if (s.description) |d| gpa.free(d);
-                if (s.default) |d| gpa.free(d);
-            },
-            .list => |l| {
-                gpa.free(l.type);
-                if (l.description) |d| gpa.free(d);
-                if (l.default) |d| {
-                    for (d) |dd| gpa.free(dd);
-                    gpa.free(d);
-                }
-            },
-            .lazy_path_list => |l| {
-                gpa.free(l.type);
-                if (l.description) |d| gpa.free(d);
-                if (l.default) |d| {
-                    for (d) |dd| gpa.free(dd);
-                    gpa.free(d);
-                }
-            },
-        }
-    }
-
-    pub fn isValidIntType(t: []const u8) bool {
-        return std.mem.eql(u8, t, "i8") or
-            std.mem.eql(u8, t, "u8") or
-            std.mem.eql(u8, t, "i16") or
-            std.mem.eql(u8, t, "u16") or
-            std.mem.eql(u8, t, "i32") or
-            std.mem.eql(u8, t, "u32") or
-            std.mem.eql(u8, t, "i64") or
-            std.mem.eql(u8, t, "u64") or
-            std.mem.eql(u8, t, "i128") or
-            std.mem.eql(u8, t, "u128") or
-            std.mem.eql(u8, t, "isize") or
-            std.mem.eql(u8, t, "usize") or
-            std.mem.eql(u8, t, "c_short") or
-            std.mem.eql(u8, t, "c_ushort") or
-            std.mem.eql(u8, t, "c_int") or
-            std.mem.eql(u8, t, "c_uint") or
-            std.mem.eql(u8, t, "c_long") or
-            std.mem.eql(u8, t, "c_ulong") or
-            std.mem.eql(u8, t, "c_longlong") or
-            std.mem.eql(u8, t, "c_ulonglong");
-    }
-
-    pub fn isValidFloatType(t: []const u8) bool {
-        return std.mem.eql(u8, t, "f16") or
-            std.mem.eql(u8, t, "f32") or
-            std.mem.eql(u8, t, "f64") or
-            std.mem.eql(u8, t, "f80") or
-            std.mem.eql(u8, t, "f128") or
-            std.mem.eql(u8, t, "c_longdouble");
-    }
-};
-
-pub const OptionsModule = ArrayHashMap(Option);
-
-pub const WriteFile = struct {
-    private: ?bool = null,
-    items: ?ArrayHashMap(Path) = null,
-
-    pub const Path = union(enum) {
-        file: File,
-        dir: Dir,
-
-        pub const File = struct {
-            type: []const u8,
-            path: []const u8,
-        };
-
-        pub const Dir = struct {
-            type: []const u8,
-            path: []const u8,
-            exclude_extensions: ?[][]const u8 = null,
-            include_extensions: ?[][]const u8 = null,
-        };
-    };
-
-    pub fn deinit(self: *WriteFile, gpa: std.mem.Allocator) void {
-        if (self.items) |*i| {
-            for (i.values()) |*v| {
-                switch (v.*) {
-                    .file => |f| {
-                        gpa.free(f.type);
-                        gpa.free(f.path);
-                    },
-                    .dir => |d| {
-                        gpa.free(d.type);
-                        gpa.free(d.path);
-                        if (d.exclude_extensions) |e| {
-                            for (e) |ee| gpa.free(ee);
-                            gpa.free(e);
-                        }
-                        if (d.include_extensions) |e| {
-                            for (e) |ee| gpa.free(ee);
-                            gpa.free(e);
-                        }
-                    },
-                }
-            }
-            for (i.keys()) |k| gpa.free(k);
-            i.deinit();
-        }
-    }
-};
-
-pub const Module = struct {
-    name: ?[]const u8 = null,
-    root_source_file: ?[]const u8 = null,
-    imports: ?[][]const u8 = null,
-    private: ?bool = null,
-
-    target: ?[]const u8 = null,
-    optimize: ?std.builtin.OptimizeMode = null,
-    link_libc: ?bool = null,
-    link_libcpp: ?bool = null,
-    single_threaded: ?bool = null,
-    strip: ?bool = null,
-    unwind_tables: ?std.builtin.UnwindTables = null,
-    dwarf_format: ?std.dwarf.Format = null,
-    code_model: ?std.builtin.CodeModel = null,
-    stack_protector: ?bool = null,
-    stack_check: ?bool = null,
-    sanitize_c: ?bool = null,
-    sanitize_thread: ?bool = null,
-    fuzz: ?bool = null,
-    valgrind: ?bool = null,
-    pic: ?bool = null,
-    red_zone: ?bool = null,
-    omit_frame_pointer: ?bool = null,
-    error_tracing: ?bool = null,
-    include_paths: ?[][]const u8 = null,
-    link_libraries: ?[][]const u8 = null,
-
-    pub fn deinit(self: *Module, gpa: std.mem.Allocator) void {
-        if (self.name) |n| gpa.free(n);
-        if (self.root_source_file) |r| gpa.free(r);
-        if (self.imports) |i| {
-            for (i) |ii| gpa.free(ii);
-            gpa.free(i);
-        }
-        if (self.link_libraries) |l| {
-            for (l) |ll| gpa.free(ll);
-            gpa.free(l);
-        }
-        if (self.target) |t| gpa.free(t);
-    }
-};
-
-pub const ModuleLink = union(enum) {
-    name: []const u8,
-    module: Module,
-
-    pub fn deinit(self: *ModuleLink, gpa: std.mem.Allocator) void {
-        switch (self.*) {
-            .name => |n| gpa.free(n),
-            .module => |*m| m.deinit(gpa),
-        }
-    }
-};
-
-pub const Executable = struct {
-    name: ?[]const u8 = null,
-    version: ?[]const u8 = null,
-    root_module: ModuleLink,
-    linkage: ?std.builtin.LinkMode = null,
-    max_rss: ?usize = null,
-    use_llvm: ?bool = null,
-    use_lld: ?bool = null,
-    zig_lib_dir: ?[]const u8 = null,
-    win32_manifest: ?[]const u8 = null,
-
-    // install artifact options
-    dest_sub_path: ?[]const u8 = null,
-
-    depends_on: ?[][]const u8 = null,
-
-    pub fn deinit(self: *Executable, gpa: std.mem.Allocator) void {
-        if (self.name) |n| gpa.free(n);
-        if (self.version) |v| gpa.free(v);
-        self.root_module.deinit(gpa);
-        if (self.zig_lib_dir) |z| gpa.free(z);
-        if (self.win32_manifest) |w| gpa.free(w);
-        if (self.depends_on) |d| {
-            for (d) |dd| gpa.free(dd);
-            gpa.free(d);
-        }
-    }
-};
-
-pub const Library = struct {
-    name: ?[]const u8 = null,
-    version: ?[]const u8 = null,
-    root_module: ModuleLink,
-    linkage: ?std.builtin.LinkMode = null,
-    max_rss: ?usize = null,
-    use_llvm: ?bool = null,
-    use_lld: ?bool = null,
-    zig_lib_dir: ?[]const u8 = null,
-    win32_manifest: ?[]const u8 = null,
-    linker_allow_shlib_undefined: ?bool = null,
-
-    // install artifact options
-    dest_sub_path: ?[]const u8 = null,
-
-    depends_on: ?[][]const u8 = null,
-
-    pub fn deinit(self: *Library, gpa: std.mem.Allocator) void {
-        if (self.name) |n| gpa.free(n);
-        if (self.version) |v| gpa.free(v);
-        self.root_module.deinit(gpa);
-        if (self.zig_lib_dir) |z| gpa.free(z);
-        if (self.win32_manifest) |w| gpa.free(w);
-        if (self.depends_on) |d| {
-            for (d) |dd| gpa.free(dd);
-            gpa.free(d);
-        }
-    }
-};
-
-pub const Object = struct {
-    name: ?[]const u8 = null,
-    root_module: ModuleLink,
-    max_rss: ?usize = null,
-    use_llvm: ?bool = null,
-    use_lld: ?bool = null,
-    zig_lib_dir: ?[]const u8 = null,
-
-    depends_on: ?[][]const u8 = null,
-
-    pub fn deinit(self: *Object, gpa: std.mem.Allocator) void {
-        if (self.name) |n| gpa.free(n);
-        self.root_module.deinit(gpa);
-        if (self.zig_lib_dir) |z| gpa.free(z);
-        if (self.depends_on) |d| {
-            for (d) |dd| gpa.free(dd);
-            gpa.free(d);
-        }
-    }
-};
-
-pub const Test = struct {
-    name: ?[]const u8 = null,
-    root_module: ModuleLink,
-    max_rss: ?usize = null,
-    use_llvm: ?bool = null,
-    use_lld: ?bool = null,
-    zig_lib_dir: ?[]const u8 = null,
-
-    filters: []const []const u8 = &.{},
-    test_runner: ?[]const u8 = null,
-
-    pub fn deinit(self: *Test, gpa: std.mem.Allocator) void {
-        if (self.name) |n| gpa.free(n);
-        self.root_module.deinit(gpa);
-        if (self.zig_lib_dir) |z| gpa.free(z);
-        for (self.filters) |f| gpa.free(f);
-        gpa.free(self.filters);
-        if (self.test_runner) |t| gpa.free(t);
-    }
-};
-
-pub const Fmt = struct {
-    paths: ?[][]const u8 = null,
-    exclude_paths: ?[][]const u8 = null,
-    check: ?bool = false,
-
-    pub fn deinit(self: *Fmt, gpa: std.mem.Allocator) void {
-        if (self.paths) |p| {
-            for (p) |pp| gpa.free(pp);
-            gpa.free(p);
-        }
-        if (self.exclude_paths) |e| {
-            for (e) |ee| gpa.free(ee);
-            gpa.free(e);
-        }
-    }
-};
-
-pub const Run = []const u8;
-
-pub fn deinit(config: *Config, gpa: std.mem.Allocator) void {
-    gpa.free(config.name);
-    gpa.free(config.version);
-    gpa.free(config.fingerprint);
-    gpa.free(config.minimum_zig_version);
-    for (config.paths) |path| gpa.free(path);
-    gpa.free(config.paths);
-    if (config.description) |desc| gpa.free(desc);
-    if (config.keywords) |kws| {
-        for (kws) |kw| gpa.free(kw);
-        gpa.free(kws);
-    }
-
-    if (config.write_files) |*wfs| {
-        for (wfs.values()) |*wf| wf.deinit(gpa);
-        for (wfs.keys()) |k| gpa.free(k);
-        wfs.deinit();
-    }
-    if (config.options) |*opts| {
-        for (opts.values()) |*o| o.deinit(gpa);
-        for (opts.keys()) |k| gpa.free(k);
-        opts.deinit();
-    }
-    if (config.options_modules) |*opts| {
-        for (opts.values()) |*o| {
-            for (o.values()) |*oo| oo.deinit(gpa);
-            for (o.keys()) |k| gpa.free(k);
-            o.deinit();
-        }
-        for (opts.keys()) |k| gpa.free(k);
-        opts.deinit();
-    }
-    if (config.modules) |*mods| {
-        for (mods.values()) |*m| m.deinit(gpa);
-        for (mods.keys()) |k| gpa.free(k);
-        mods.deinit();
-    }
-    if (config.dependencies) |*deps| {
-        for (deps.values()) |*d| d.deinit(gpa);
-        for (deps.keys()) |k| gpa.free(k);
-        deps.deinit();
-    }
-    if (config.executables) |*execs| {
-        for (execs.values()) |*e| e.deinit(gpa);
-        for (execs.keys()) |k| gpa.free(k);
-        execs.deinit();
-    }
-    if (config.libraries) |*libs| {
-        for (libs.values()) |*l| l.deinit(gpa);
-        for (libs.keys()) |k| gpa.free(k);
-        libs.deinit();
-    }
-    if (config.objects) |*objs| {
-        for (objs.values()) |*o| o.deinit(gpa);
-        for (objs.keys()) |k| gpa.free(k);
-        objs.deinit();
-    }
-    if (config.tests) |*tests| {
-        for (tests.values()) |*t| t.deinit(gpa);
-        for (tests.keys()) |k| gpa.free(k);
-        tests.deinit();
-    }
-    if (config.fmts) |*fmts| {
-        for (fmts.values()) |*f| f.deinit(gpa);
-        for (fmts.keys()) |k| gpa.free(k);
-        fmts.deinit();
-    }
-    if (config.runs) |*runs| {
-        for (runs.values()) |r| gpa.free(r);
-        for (runs.keys()) |k| gpa.free(k);
-        runs.deinit();
-    }
-    config.* = undefined;
-}
-
-pub fn addDependency(config: *Config, gpa: std.mem.Allocator, name: []const u8, dependency: Dependency) !void {
-    if (config.dependencies == null) {
-        config.dependencies = ArrayHashMap(Dependency).init(gpa);
-    }
-    try config.dependencies.?.put(name, dependency);
-}
-
-pub fn addExecutable(config: *Config, gpa: std.mem.Allocator, name: []const u8, executable: Executable) !void {
-    if (config.executables == null) {
-        config.executables = ArrayHashMap(Executable).init(gpa);
-    }
-    try config.executables.?.put(name, executable);
-}
-
-pub fn parseFromFile(gpa: std.mem.Allocator, zbuild_file: []const u8, wip_bundle: ?*std.zig.ErrorBundle.Wip) !Config {
-    const source = try std.fs.cwd().readFileAllocOptions(gpa, zbuild_file, 16_000, null, @alignOf(u8), 0);
-    defer gpa.free(source);
-
-    var ast = try std.zig.Ast.parse(gpa, source, .zon);
-    defer ast.deinit(gpa);
-
-    var zoir = try std.zig.ZonGen.generate(gpa, ast, .{});
-    defer zoir.deinit(gpa);
-
-    if (zoir.hasCompileErrors()) {
-        if (wip_bundle) |wip| {
-            try wip.addZoirErrorMessages(zoir, ast, source, zbuild_file);
-        }
-
-        return error.ParseZoir;
-    }
-
-    return parseFromZoir(gpa, zbuild_file, zoir, ast, wip_bundle);
-}
-
-pub fn parseFromZoir(gpa: std.mem.Allocator, zbuild_file: []const u8, zoir: std.zig.Zoir, ast: std.zig.Ast, wip_bundle: ?*std.zig.ErrorBundle.Wip) Parser.Error!Config {
-    var status = std.zon.parse.Status{};
-    var parser = Parser.init(gpa, zoir, ast, &status);
-
-    return parser.parse() catch |e| {
-        if (status.type_check) |err| {
-            const err_span = ast.tokenToSpan(err.token);
-            const err_loc = std.zig.findLineColumn(ast.source, err_span.main);
-
-            if (wip_bundle) |wip| {
-                try wip.addRootErrorMessage(.{
-                    .msg = try wip.addString(err.message),
-                    .src_loc = try wip.addSourceLocation(.{
-                        .src_path = try wip.addString(zbuild_file),
-                        .line = @intCast(err_loc.line),
-                        .column = @intCast(err_loc.column),
-                        .span_start = err_span.start,
-                        .span_end = err_span.end,
-                        .span_main = err_span.main,
-                        .source_line = try wip.addString(err_loc.source_line),
-                    }),
-                });
-            }
-        }
-        return e;
-    };
-}
-
-const Parser = struct {
-    gpa: std.mem.Allocator,
-    zoir: std.zig.Zoir,
-    ast: std.zig.Ast,
-    status: *std.zon.parse.Status,
-    config: Config,
-
-    const Self = @This();
-
-    pub const Error = error{ OutOfMemory, ParseZon, NegativeIntoUnsigned, TargetTooSmall };
-
-    pub fn init(gpa: std.mem.Allocator, zoir: std.zig.Zoir, ast: std.zig.Ast, status: *std.zon.parse.Status) Parser {
-        return Parser{
-            .gpa = gpa,
-            .zoir = zoir,
-            .ast = ast,
-            .status = status,
-            .config = Config{
-                .name = "",
-                .version = "",
-                .fingerprint = "",
-                .minimum_zig_version = "",
-                .paths = &.{},
-            },
-        };
-    }
-
-    pub fn parse(self: *Self) Error!Config {
-        // required fields
-        var has_name = false;
-        var has_version = false;
-        var has_fingerprint = false;
-        var has_minimum_zig_version = false;
-        var has_paths = false;
-        const r = try self.parseStructLiteral(.root);
-        for (r.names, 0..) |n, i| {
-            const field_name = n.get(self.zoir);
-            const field_value = r.vals.at(@intCast(i));
-            if (std.mem.eql(u8, field_name, "name")) {
-                has_name = true;
-                self.config.name = try self.parseEnumLiteral(field_value);
-            } else if (std.mem.eql(u8, field_name, "version")) {
-                has_version = true;
-                self.config.version = try self.parseVersionString(field_value);
-            } else if (std.mem.eql(u8, field_name, "fingerprint")) {
-                has_fingerprint = true;
-                const fingerprint_int = try self.parseT(u64, field_value);
-                self.config.fingerprint = try std.fmt.allocPrint(self.gpa, "0x{x}", .{fingerprint_int});
-            } else if (std.mem.eql(u8, field_name, "minimum_zig_version")) {
-                has_minimum_zig_version = true;
-                self.config.minimum_zig_version = try self.parseVersionString(field_value);
-            } else if (std.mem.eql(u8, field_name, "paths")) {
-                has_paths = true;
-                self.config.paths = try self.parseT([][]const u8, field_value);
-            } else if (std.mem.eql(u8, field_name, "description")) {
-                self.config.description = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "keywords")) {
-                self.config.keywords = try self.parseT(?[][]const u8, field_value);
-            } else if (std.mem.eql(u8, field_name, "dependencies")) {
-                self.config.dependencies = try self.parseOptionalHashMap(Dependency, parseDependency, field_value);
-            } else if (std.mem.eql(u8, field_name, "write_files")) {
-                // config.write_files = ;
-            } else if (std.mem.eql(u8, field_name, "options")) {
-                self.config.options = try self.parseOptionalHashMap(Option, parseOption, field_value);
-            } else if (std.mem.eql(u8, field_name, "options_modules")) {
-                self.config.options_modules = try self.parseOptionalHashMap(OptionsModule, parseOptionsModule, field_value);
-            } else if (std.mem.eql(u8, field_name, "modules")) {
-                self.config.modules = try self.parseOptionalHashMap(Module, parseModule, field_value);
-            } else if (std.mem.eql(u8, field_name, "executables")) {
-                self.config.executables = try self.parseOptionalHashMap(Executable, parseExecutable, field_value);
-            } else if (std.mem.eql(u8, field_name, "libraries")) {
-                self.config.libraries = try self.parseOptionalHashMap(Library, parseLibrary, field_value);
-            } else if (std.mem.eql(u8, field_name, "objects")) {
-                self.config.objects = try self.parseOptionalHashMap(Object, parseObject, field_value);
-            } else if (std.mem.eql(u8, field_name, "tests")) {
-                self.config.tests = try self.parseOptionalHashMap(Test, parseTest, field_value);
-            } else if (std.mem.eql(u8, field_name, "fmts")) {
-                self.config.fmts = try self.parseOptionalHashMap(Fmt, parseFmt, field_value);
-            } else if (std.mem.eql(u8, field_name, "runs")) {
-                self.config.runs = try self.parseOptionalHashMap(Run, parseRun, field_value);
-            } else {
-                try self.returnParseErrorFmt("unknown field '{s}'", .{field_name}, field_value.getAstNode(self.zoir));
-            }
-        }
-        if (!has_name) {
-            try self.returnParseError("missing required field 'name'", self.ast.rootDecls()[0]);
-        }
-        if (!has_version) {
-            try self.returnParseError("missing required field 'version'", self.ast.rootDecls()[0]);
-        }
-        if (!has_fingerprint) {
-            try self.returnParseError("missing required field 'fingerprint'", self.ast.rootDecls()[0]);
-        }
-        if (!has_minimum_zig_version) {
-            try self.returnParseError("missing required field 'minimum_zig_version'", self.ast.rootDecls()[0]);
-        }
-        if (!has_paths) {
-            try self.returnParseError("missing required field 'paths'", self.ast.rootDecls()[0]);
-        }
-        return self.config;
-    }
-
-    fn parseDependency(self: *Self, index: std.zig.Zoir.Node.Index) Error!Dependency {
-        const n = try self.parseStructLiteral(index);
-        var dep = Dependency{
-            .typ = undefined,
-            .value = undefined,
-        };
-        var has_type_field = false;
-        for (n.names, 0..) |name, i| {
-            const field_name = name.get(self.zoir);
-            const field_value = n.vals.at(@intCast(i));
-            if (std.mem.eql(u8, field_name, "path")) {
-                dep.typ = .path;
-                dep.value = try self.parseString(field_value);
-                has_type_field = true;
-            } else if (std.mem.eql(u8, field_name, "url")) {
-                dep.typ = .url;
-                dep.value = try self.parseString(field_value);
-                has_type_field = true;
-            } else if (std.mem.eql(u8, field_name, "args")) {
-                dep.args = try self.parseOptionalHashMap(Dependency.Arg, parseDependencyArg, field_value);
-            }
-        }
-        if (!has_type_field) {
-            try self.returnParseError("missing required field 'path' or 'url'", index.getAstNode(self.zoir));
-        }
-        return dep;
-    }
-
-    fn parseDependencyArg(self: *Self, index: std.zig.Zoir.Node.Index) Error!Dependency.Arg {
-        const node = index.get(self.zoir);
-        switch (node) {
-            .true => {
-                return .{
-                    .bool = true,
-                };
-            },
-            .false => {
-                return .{
-                    .bool = false,
-                };
-            },
-            .int_literal => |i| {
-                return .{
-                    .int = switch (i) {
-                        .small => |s| s,
-                        .big => |b| try b.toInt(i64),
-                    },
-                };
-            },
-            .float_literal => |f| {
-                return .{
-                    .float = @floatCast(f),
-                };
-            },
-            .enum_literal => |e| {
-                return .{
-                    .@"enum" = try self.gpa.dupe(u8, e.get(self.zoir)),
-                };
-            },
-            .string_literal => |s| {
-                return .{
-                    .string = try self.gpa.dupe(u8, s),
-                };
-            },
-            .null => {
-                return .{ .null = {} };
-            },
-            else => {
-                try self.returnParseError("expected a boo, int, float, string literal, or enum literal", index.getAstNode(self.zoir));
-            },
-        }
-    }
-
-    fn parseWriteFile(self: *Self, index: std.zig.Zoir.Node.Index) Error!WriteFile {
-        const n = try self.parseStructLiteral(index);
-        var write_file = WriteFile{};
-        for (n.names) |name| {
-            const field_name = name.get(self.zoir);
-            if (std.mem.eql(u8, field_name, "private")) {
-                write_file.private = try self.parseT(?bool);
-            } else if (std.mem.eql(u8, field_name, "items")) {
-                write_file.items = try self.parseOptionalHashMap(WriteFile.Path, parseWriteFilePath, index);
-            }
-        }
-        return write_file;
-    }
-
-    fn parseWriteFilePath(self: *Self, index: std.zig.Zoir.Node.Index) Error!WriteFile.Path {
-        const n = try self.parseStructLiteral(index);
-        for (n.names, 0..) |name, i| {
-            const field_name = name.get(self.zoir);
-            const field_value = n.vals.at(@intCast(i));
-            if (std.mem.eql(u8, field_name, "type")) {
-                const t = try self.parseString(field_value);
-                if (std.mem.eql(u8, t, "file")) {
-                    return .{ .file = try self.parseT(WriteFile.File) };
-                } else if (std.mem.eql(u8, t, "dir")) {
-                    return .{ .dir = try self.parseT(WriteFile.Dir) };
-                } else {
-                    try self.returnParseErrorFmt("invalid type '{s}'", .{t}, field_value);
-                }
-            }
-        }
-        try self.returnParseError("missing required field 'type'", index.getAstNode(self.zoir));
-    }
-
-    fn parseOption(self: *Self, index: std.zig.Zoir.Node.Index) Error!Option {
-        const n = try self.parseStructLiteral(index);
-        for (n.names, 0..) |name, i| {
-            const field_name = name.get(self.zoir);
-            const field_value = n.vals.at(@intCast(i));
-            if (std.mem.eql(u8, field_name, "type")) {
-                const t = try self.parseString(field_value);
-                if (Option.isValidIntType(t)) {
-                    return .{ .int = try self.parseT(Option.Int, index) };
-                } else if (Option.isValidFloatType(t)) {
-                    return .{ .float = try self.parseT(Option.Float, index) };
-                } else if (std.mem.eql(u8, t, "bool")) {
-                    return .{ .bool = try self.parseT(Option.Bool, index) };
-                } else if (std.mem.eql(u8, t, "enum")) {
-                    return .{ .@"enum" = try self.parseOptionEnum(index) };
-                } else if (std.mem.eql(u8, t, "enum_list")) {
-                    return .{ .enum_list = try self.parseOptionEnumList(index) };
-                } else if (std.mem.eql(u8, t, "string")) {
-                    return .{ .string = try self.parseT(Option.String, index) };
-                } else if (std.mem.eql(u8, t, "list")) {
-                    return .{ .list = try self.parseT(Option.List, index) };
-                } else if (std.mem.eql(u8, t, "build_id")) {
-                    return .{ .build_id = try self.parseT(Option.BuildId, index) };
-                } else if (std.mem.eql(u8, t, "lazy_path")) {
-                    return .{ .lazy_path = try self.parseT(Option.LazyPath, index) };
-                } else if (std.mem.eql(u8, t, "lazy_path_list")) {
-                    return .{ .lazy_path_list = try self.parseT(Option.LazyPathList, index) };
-                } else {
-                    try self.returnParseErrorFmt("invalid type '{s}'", .{t}, field_value.getAstNode(self.zoir));
-                }
-            }
-        }
-        try self.returnParseError("missing required field 'type'", index.getAstNode(self.zoir));
-    }
-
-    fn parseOptionEnum(self: *Self, index: std.zig.Zoir.Node.Index) Error!Option.Enum {
-        const n = try self.parseStructLiteral(index);
-        var option = Option.Enum{
-            .enum_options = &.{},
-            .type = "",
-        };
-        var has_type = false;
-        var has_enum_options = false;
-        for (n.names, 0..) |name, i| {
-            const field_name = name.get(self.zoir);
-            const field_value = n.vals.at(@intCast(i));
-            if (std.mem.eql(u8, field_name, "type")) {
-                has_type = true;
-                option.type = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "enum_options")) {
-                has_enum_options = true;
-                option.enum_options = try self.parseSlice([]const u8, parseEnumLiteral, field_value);
-            } else if (std.mem.eql(u8, field_name, "description")) {
-                option.description = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "default")) {
-                option.default = try self.parseEnumLiteral(field_value);
-            }
-        }
-        if (!has_type) {
-            try self.returnParseError("missing required field 'type'", index.getAstNode(self.zoir));
-        }
-        if (!has_enum_options) {
-            try self.returnParseError("missing required field 'enum_options'", index.getAstNode(self.zoir));
-        }
-        return option;
-    }
-
-    fn parseOptionEnumList(self: *Self, index: std.zig.Zoir.Node.Index) Error!Option.EnumList {
-        const n = try self.parseStructLiteral(index);
-        var option = Option.EnumList{
-            .enum_options = &.{},
-            .type = "",
-        };
-        var has_type = false;
-        var has_enum_options = false;
-        for (n.names, 0..) |name, i| {
-            const field_name = name.get(self.zoir);
-            const field_value = n.vals.at(@intCast(i));
-            if (std.mem.eql(u8, field_name, "type")) {
-                has_type = true;
-                option.type = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "enum_options")) {
-                has_enum_options = true;
-                option.enum_options = try self.parseSlice([]const u8, parseEnumLiteral, field_value);
-            } else if (std.mem.eql(u8, field_name, "description")) {
-                option.description = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "default")) {
-                option.default = try self.parseSlice([]const u8, parseEnumLiteral, field_value);
-            }
-        }
-        if (!has_type) {
-            try self.returnParseError("missing required field 'type'", index.getAstNode(self.zoir));
-        }
-        if (!has_enum_options) {
-            try self.returnParseError("missing required field 'enum_options'", index.getAstNode(self.zoir));
-        }
-        return option;
-    }
-
-    fn parseOptionsModule(self: *Self, index: std.zig.Zoir.Node.Index) Error!OptionsModule {
-        return try self.parseHashMap(Option, parseOption, index);
-    }
-
-    fn parseModule(self: *Self, index: std.zig.Zoir.Node.Index) Error!Module {
-        const n = try self.parseStructLiteral(index);
-        var module = Module{};
-        for (n.names, 0..) |name, i| {
-            const field_name = name.get(self.zoir);
-            const field_value = n.vals.at(@intCast(i));
-            // each field in Module
-            if (std.mem.eql(u8, field_name, "name")) {
-                module.name = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "root_source_file")) {
-                module.root_source_file = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "imports")) {
-                module.imports = try self.parseOptionalSlice([]const u8, parseStringOrEnumLiteral, field_value);
-            } else if (std.mem.eql(u8, field_name, "private")) {
-                module.private = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "target")) {
-                module.target = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "optimize")) {
-                module.optimize = try self.parseT(std.builtin.OptimizeMode, field_value);
-            } else if (std.mem.eql(u8, field_name, "link_libc")) {
-                module.link_libc = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "link_libcpp")) {
-                module.link_libcpp = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "single_threaded")) {
-                module.single_threaded = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "strip")) {
-                module.strip = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "unwind_tables")) {
-                module.unwind_tables = try self.parseT(std.builtin.UnwindTables, field_value);
-            } else if (std.mem.eql(u8, field_name, "dwarf_format")) {
-                module.dwarf_format = try self.parseT(std.dwarf.Format, field_value);
-            } else if (std.mem.eql(u8, field_name, "code_model")) {
-                module.code_model = try self.parseT(std.builtin.CodeModel, field_value);
-            } else if (std.mem.eql(u8, field_name, "stack_protector")) {
-                module.stack_protector = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "stack_check")) {
-                module.stack_check = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "sanitize_c")) {
-                module.sanitize_c = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "sanitize_thread")) {
-                module.sanitize_thread = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "fuzz")) {
-                module.fuzz = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "valgrind")) {
-                module.valgrind = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "pic")) {
-                module.pic = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "red_zone")) {
-                module.red_zone = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "omit_frame_pointer")) {
-                module.omit_frame_pointer = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "error_tracing")) {
-                module.error_tracing = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "include_paths")) {
-                module.include_paths = try self.parseOptionalSlice([]const u8, parseString, field_value);
-            } else if (std.mem.eql(u8, field_name, "link_libraries")) {
-                module.link_libraries = try self.parseOptionalSlice([]const u8, parseString, field_value);
-            }
-        }
-        return module;
-    }
-
-    fn parseModuleLink(self: *Self, index: std.zig.Zoir.Node.Index) Error!ModuleLink {
-        const node = index.get(self.zoir);
-        switch (node) {
-            .struct_literal => {
-                return .{ .module = try self.parseModule(index) };
-            },
-            .string_literal => |n| {
-                return .{ .name = try self.gpa.dupe(u8, n) };
-            },
-            .enum_literal => |n| {
-                return .{ .name = try self.gpa.dupe(u8, n.get(self.zoir)) };
-            },
-            else => {
-                try self.returnParseError("expected a string, enum literal, struct literal", index.getAstNode(self.zoir));
-            },
-        }
-    }
-
-    fn parseExecutable(self: *Self, index: std.zig.Zoir.Node.Index) Error!Executable {
-        const n = try self.parseStructLiteral(index);
-        var executable = Executable{ .root_module = .{ .name = "" } };
-        var has_root_module = false;
-        for (n.names, 0..) |name, i| {
-            const field_name = name.get(self.zoir);
-            const field_value = n.vals.at(@intCast(i));
-            if (std.mem.eql(u8, field_name, "name")) {
-                executable.name = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "version")) {
-                executable.version = try self.parseVersionString(field_value);
-            } else if (std.mem.eql(u8, field_name, "root_module")) {
-                executable.root_module = try self.parseModuleLink(field_value);
-                has_root_module = true;
-            } else if (std.mem.eql(u8, field_name, "linkage")) {
-                executable.linkage = try self.parseT(std.builtin.LinkMode, field_value);
-            } else if (std.mem.eql(u8, field_name, "max_rss")) {
-                executable.max_rss = try self.parseT(usize, field_value);
-            } else if (std.mem.eql(u8, field_name, "use_llvm")) {
-                executable.use_llvm = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "use_lld")) {
-                executable.use_lld = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "zig_lib_dir")) {
-                executable.zig_lib_dir = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "win32_manifest")) {
-                executable.win32_manifest = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "dest_sub_path")) {
-                executable.dest_sub_path = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "depends_on")) {
-                executable.depends_on = try self.parseOptionalSlice([]const u8, parseStringOrEnumLiteral, field_value);
-            }
-        }
-        if (!has_root_module) {
-            try self.returnParseError("missing required field 'root_module'", index.getAstNode(self.zoir));
-        }
-        return executable;
-    }
-
-    fn parseLibrary(self: *Self, index: std.zig.Zoir.Node.Index) Error!Library {
-        const n = try self.parseStructLiteral(index);
-        var library = Library{ .root_module = .{ .name = "" } };
-        var has_root_module = false;
-        for (n.names, 0..) |name, i| {
-            const field_name = name.get(self.zoir);
-            const field_value = n.vals.at(@intCast(i));
-            if (std.mem.eql(u8, field_name, "name")) {
-                library.name = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "root_module")) {
-                has_root_module = true;
-                library.root_module = try self.parseModuleLink(field_value);
-            } else if (std.mem.eql(u8, field_name, "linkage")) {
-                library.linkage = try self.parseT(std.builtin.LinkMode, field_value);
-            } else if (std.mem.eql(u8, field_name, "max_rss")) {
-                library.max_rss = try self.parseT(usize, field_value);
-            } else if (std.mem.eql(u8, field_name, "use_llvm")) {
-                library.use_llvm = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "use_lld")) {
-                library.use_lld = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "zig_lib_dir")) {
-                library.zig_lib_dir = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "win32_manifest")) {
-                library.win32_manifest = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "dest_sub_path")) {
-                library.dest_sub_path = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "depends_on")) {
-                library.depends_on = try self.parseOptionalSlice([]const u8, parseStringOrEnumLiteral, field_value);
-            } else if (std.mem.eql(u8, field_name, "linker_allow_shlib_undefined")) {
-                library.linker_allow_shlib_undefined = try self.parseBool(field_value);
-            }
-        }
-        if (!has_root_module) {
-            try self.returnParseError("missing required field 'root_module'", index.getAstNode(self.zoir));
-        }
-        return library;
-    }
-
-    fn parseObject(self: *Self, index: std.zig.Zoir.Node.Index) Error!Object {
-        const n = try self.parseStructLiteral(index);
-        var object = Object{ .root_module = .{ .name = "" } };
-        var has_root_module = false;
-        for (n.names, 0..) |name, i| {
-            const field_name = try self.gpa.dupe(u8, name.get(self.zoir));
-            const field_value = n.vals.at(@intCast(i));
-            if (std.mem.eql(u8, field_name, "name")) {
-                object.name = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "root_module")) {
-                has_root_module = true;
-                object.root_module = try self.parseModuleLink(field_value);
-            } else if (std.mem.eql(u8, field_name, "max_rss")) {
-                object.max_rss = try self.parseT(usize, field_value);
-            } else if (std.mem.eql(u8, field_name, "use_llvm")) {
-                object.use_llvm = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "use_lld")) {
-                object.use_lld = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "zig_lib_dir")) {
-                object.zig_lib_dir = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "depends_on")) {
-                object.depends_on = try self.parseOptionalSlice([]const u8, parseStringOrEnumLiteral, field_value);
-            }
-        }
-        if (!has_root_module) {
-            try self.returnParseError("missing required field 'root_module'", index.getAstNode(self.zoir));
-        }
-        return object;
-    }
-
-    fn parseTest(self: *Self, index: std.zig.Zoir.Node.Index) Error!Test {
-        const n = try self.parseStructLiteral(index);
-        var t = Test{ .root_module = .{ .name = "" } };
-        var has_root_module = false;
-        for (n.names, 0..) |name, i| {
-            const field_name = name.get(self.zoir);
-            const field_value = n.vals.at(@intCast(i));
-            if (std.mem.eql(u8, field_name, "name")) {
-                t.name = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "root_module")) {
-                has_root_module = true;
-                t.root_module = try self.parseModuleLink(field_value);
-            } else if (std.mem.eql(u8, field_name, "max_rss")) {
-                t.max_rss = try self.parseT(usize, field_value);
-            } else if (std.mem.eql(u8, field_name, "use_llvm")) {
-                t.use_llvm = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "use_lld")) {
-                t.use_lld = try self.parseBool(field_value);
-            } else if (std.mem.eql(u8, field_name, "zig_lib_dir")) {
-                t.zig_lib_dir = try self.parseString(field_value);
-            } else if (std.mem.eql(u8, field_name, "filters")) {
-                t.filters = try self.parseOptionalSlice([]const u8, parseString, field_value) orelse &.{};
-            }
-        }
-        if (!has_root_module) {
-            try self.returnParseError("missing required field 'root_module'", index.getAstNode(self.zoir));
-        }
-        return t;
-    }
-
-    fn parseFmt(self: *Self, index: std.zig.Zoir.Node.Index) Error!Fmt {
-        return try self.parseT(Fmt, index);
-    }
-
-    fn parseRun(self: *Self, index: std.zig.Zoir.Node.Index) Error!Run {
-        return try self.parseT(Run, index);
-    }
-
-    fn parseHashMap(
-        self: *Self,
-        comptime T: type,
-        comptime parseItem: fn (self: *Self, index: std.zig.Zoir.Node.Index) Error!T,
-        index: std.zig.Zoir.Node.Index,
-    ) Error!ArrayHashMap(T) {
-        const n = try self.parseStructLiteral(index);
-        var items = ArrayHashMap(T).init(self.gpa);
-        for (n.names, 0..) |name, i| {
-            const field_name = try self.gpa.dupe(u8, name.get(self.zoir));
-            const field_value = n.vals.at(@intCast(i));
-            const item = try parseItem(self, field_value);
-            try items.put(field_name, item);
-        }
-        return items;
-    }
-
-    fn parseOptionalHashMap(
-        self: *Self,
-        comptime T: type,
-        comptime parseItem: fn (self: *Self, index: std.zig.Zoir.Node.Index) Error!T,
-        index: std.zig.Zoir.Node.Index,
-    ) Error!?ArrayHashMap(T) {
-        const node = index.get(self.zoir);
-        switch (node) {
-            .struct_literal => |n| {
-                var items = ArrayHashMap(T).init(self.gpa);
-                for (n.names, 0..) |name, i| {
-                    const field_name = try self.gpa.dupe(u8, name.get(self.zoir));
-                    const field_value = n.vals.at(@intCast(i));
-                    const item = try parseItem(self, field_value);
-                    try items.put(field_name, item);
-                }
-                return items;
-            },
-            .empty_literal => {
-                return null;
-            },
-            else => {
-                try self.returnParseError("expected a struct literal", index.getAstNode(self.zoir));
-            },
-        }
-    }
-
-    fn parseSlice(
-        self: *Self,
-        comptime T: type,
-        comptime parseItem: fn (self: *Self, index: std.zig.Zoir.Node.Index) Error!T,
-        index: std.zig.Zoir.Node.Index,
-    ) Error![]T {
-        const node = index.get(self.zoir);
-        switch (node) {
-            .array_literal => |a| {
-                const slice = try self.gpa.alloc(T, a.len);
-                for (0..a.len) |i| {
-                    const item = a.at(@intCast(i));
-                    slice[i] = try parseItem(self, item);
-                }
-                return slice;
-            },
-            else => {
-                try self.returnParseError("expected an array literal", index.getAstNode(self.zoir));
-            },
-        }
-    }
-
-    fn parseOptionalSlice(
-        self: *Self,
-        comptime T: type,
-        comptime parseItem: fn (self: *Self, index: std.zig.Zoir.Node.Index) Error!T,
-        index: std.zig.Zoir.Node.Index,
-    ) Error!?[]T {
-        const node = index.get(self.zoir);
-        switch (node) {
-            .array_literal => |a| {
-                const slice = try self.gpa.alloc(T, a.len);
-                for (0..a.len) |i| {
-                    const item = a.at(@intCast(i));
-                    slice[i] = try parseItem(self, item);
-                }
-                return slice;
-            },
-            .empty_literal => {
-                return null;
-            },
-            else => {
-                try self.returnParseError("expected an array literal", index.getAstNode(self.zoir));
-            },
-        }
-    }
-
-    fn parseT(self: *Self, comptime T: type, index: std.zig.Zoir.Node.Index) Error!T {
-        @setEvalBranchQuota(2_000);
-        self.status.* = .{};
-        return try std.zon.parse.fromZoirNode(T, self.gpa, self.ast, self.zoir, index, self.status, .{});
-    }
-
-    fn parseEnumLiteral(self: *Self, index: std.zig.Zoir.Node.Index) Error![]const u8 {
-        const node = index.get(self.zoir);
-        switch (node) {
-            .enum_literal => |n| {
-                return try self.gpa.dupe(u8, n.get(self.zoir));
-            },
-            else => {
-                try self.returnParseError("expected an enum literal", index.getAstNode(self.zoir));
-            },
-        }
-    }
-
-    fn parseString(self: *Self, index: std.zig.Zoir.Node.Index) Error![]const u8 {
-        const node = index.get(self.zoir);
-        switch (node) {
-            .string_literal => |n| {
-                return try self.gpa.dupe(u8, n);
-            },
-            else => {
-                try self.returnParseError("expected a string literal", index.getAstNode(self.zoir));
-            },
-        }
-    }
-
-    fn parseStringOrEnumLiteral(self: *Self, index: std.zig.Zoir.Node.Index) Error![]const u8 {
-        const node = index.get(self.zoir);
-        switch (node) {
-            .string_literal => |n| {
-                return try self.gpa.dupe(u8, n);
-            },
-            .enum_literal => |n| {
-                return try self.gpa.dupe(u8, n.get(self.zoir));
-            },
-            else => {
-                try self.returnParseError("expected a string literal or enum literal", index.getAstNode(self.zoir));
-            },
-        }
-    }
-
-    fn parseVersionString(self: *Self, index: std.zig.Zoir.Node.Index) Error![]const u8 {
-        const node = index.get(self.zoir);
-        switch (node) {
-            .string_literal => |n| {
-                _ = std.SemanticVersion.parse(n) catch {
-                    try self.returnParseError("invalid version string", index.getAstNode(self.zoir));
-                };
-                return try self.gpa.dupe(u8, n);
-            },
-            else => {
-                try self.returnParseError("expected an string literal", index.getAstNode(self.zoir));
-            },
-        }
-    }
-
-    fn parseBool(self: *Self, index: std.zig.Zoir.Node.Index) Error!bool {
-        const node = index.get(self.zoir);
-        switch (node) {
-            .true => {
-                return true;
-            },
-            .false => {
-                return false;
-            },
-            else => {
-                try self.returnParseError("expected a boolean literal", index.getAstNode(self.zoir));
-            },
-        }
-    }
-
-    fn parseStructLiteral(self: *Self, index: std.zig.Zoir.Node.Index) Error!std.meta.TagPayload(std.zig.Zoir.Node, .struct_literal) {
-        const node = index.get(self.zoir);
-        switch (node) {
-            .struct_literal => |n| {
-                return n;
-            },
-            else => {
-                try self.returnParseError("expected a struct literal", index.getAstNode(self.zoir));
-            },
-        }
-    }
-
-    fn returnParseErrorFmt(self: *Self, comptime fmt: []const u8, args: anytype, node_index: std.zig.Ast.Node.Index) Error!noreturn {
-        const message = try std.fmt.allocPrint(self.gpa, fmt, args);
-        try self.returnParseError(message, node_index);
-    }
-
-    fn returnParseError(self: *Self, message: []const u8, node_index: std.zig.Ast.Node.Index) Error!noreturn {
-        self.status.* = .{
-            .ast = self.ast,
-            .zoir = self.zoir,
-            .type_check = .{
-                .message = message,
-                .owned = false,
-                .token = self.ast.firstToken(node_index),
-                .offset = 0,
-                .note = null,
-            },
-        };
-        return error.ParseZon;
-    }
-};
-
-pub fn serialize(config: Config, writer: anytype) !void {
-    var serializer = Serializer(@TypeOf(writer)).init(config, writer);
-    try serializer.serialize();
-}
-
-pub fn serializeToFile(config: Config, file_path: []const u8) !void {
-    const file = try std.fs.cwd().createFile(file_path, .{});
-    defer file.close();
-    try serialize(config, file.writer());
-}
-
-fn Serializer(Writer: type) type {
-    return struct {
-        config: Config,
-        writer: Writer,
-
-        const Self = @This();
-
-        pub fn init(config: Config, writer: Writer) Self {
-            return Self{
-                .config = config,
-                .writer = writer,
-            };
-        }
-
-        pub fn serialize(self: *Self) !void {
-            var serializer = std.zon.stringify.serializer(self.writer, .{});
-            var top_level = try serializer.beginStruct(.{});
-            try top_level.field("name", self.config.name, .{});
-            try top_level.field("version", self.config.version, .{});
-            try top_level.fieldPrefix("fingerprint");
-            try self.writer.print("0x{x}", .{self.config.fingerprint});
-            try top_level.field("minimum_zig_version", self.config.minimum_zig_version, .{});
-            try top_level.field("paths", self.config.paths, .{});
-            if (self.config.description) |desc| {
-                try top_level.field("description", desc, .{});
-            }
-            if (self.config.keywords) |keywords| {
-                try top_level.field("keywords", keywords, .{});
-            }
-            if (self.config.dependencies) |dependencies| {
-                var deps = try top_level.beginStructField("dependencies", .{});
-                for (dependencies.keys(), dependencies.values()) |name, item| {
-                    try serializeDependency(&deps, name, item);
-                }
-                try deps.end();
-            }
-            if (self.config.write_files) |write_files| {
-                var wf = try top_level.beginStructField("write_files", .{});
-                for (write_files.keys(), write_files.values()) |name, item| {
-                    try serializeWriteFile(&wf, name, item);
-                }
-                try wf.end();
-            }
-            if (self.config.options) |options| {
-                var opts = try top_level.beginStructField("options", .{});
-                for (options.keys(), options.values()) |name, item| {
-                    try serializeOption(&opts, name, item);
-                }
-                try opts.end();
-            }
-            if (self.config.options_modules) |options_modules| {
-                var opt_modules = try top_level.beginStructField("options_modules", .{});
-                for (options_modules.keys(), options_modules.values()) |opt_module_name, opt_module| {
-                    var opts = try opt_modules.beginStructField(opt_module_name, .{});
-                    for (opt_module.keys(), opt_module.values()) |name, item| {
-                        try serializeOption(&opts, name, item);
-                    }
-                    try opts.end();
-                }
-                try opt_modules.end();
-            }
-            if (self.config.modules) |modules| {
-                var mods = try top_level.beginStructField("modules", .{});
-                for (modules.keys(), modules.values()) |name, item| {
-                    try serializeModule(&mods, name, item);
-                }
-                try mods.end();
-            }
-            if (self.config.executables) |executables| {
-                var exes = try top_level.beginStructField("executables", .{});
-                for (executables.keys(), executables.values()) |name, item| {
-                    try serializeExecutable(&exes, name, item);
-                }
-                try exes.end();
-            }
-            // if (self.config.libraries) |libraries| {
-            //     const libs = try top_level.beginStructField("libraries", .{});
-            //     for (libraries.keys(), libraries.values()) |name, item| {
-            //         try self.serializeLibrary(libs, name, item);
-            //     }
-            //     try libs.end();
-            // }
-            // if (self.config.objects) |objects| {
-            //     const objs = try top_level.beginStructField("objects", .{});
-            //     for (objects.keys(), objects.values()) |name, item| {
-            //         try self.serializeObject(objs, name, item);
-            //     }
-            //     try objs.end();
-            // }
-            // if (self.config.tests) |tests| {
-            //     const tsts = try top_level.beginStructField("tests", .{});
-            //     for (tests.keys(), tests.values()) |name, item| {
-            //         try self.serializeTest(tsts, name, item);
-            //     }
-            //     try tsts.end();
-            // }
-            // if (self.config.fmts) |fmts| {
-            //     const f = try top_level.beginStructField("fmts", .{});
-            //     for (fmts.keys(), fmts.values()) |name, item| {
-            //         try self.serializeFmt(f, name, item);
-            //     }
-            //     try f.end();
-            // }
-            // if (self.config.runs) |runs| {
-            //     const r = try top_level.beginStructField("runs", .{});
-            //     for (runs.keys(), runs.values()) |name, item| {
-            //         try self.serializeRun(r, name, item);
-            //     }
-            //     try r.end();
-            // }
-            try top_level.end();
-        }
-
-        fn serializeDependency(
-            outer: *std.zon.stringify.Serializer(Writer).Struct,
-            name: []const u8,
-            item: Dependency,
-        ) !void {
-            var inner = try outer.beginStructField(name, .{});
-            switch (item.typ) {
-                .path => try inner.field("path", item.value, .{}),
-                .url => try inner.field("url", item.value, .{}),
-            }
-            if (item.args) |args| {
-                var args_inner = try inner.beginStructField("args", .{});
-                for (args.keys(), args.values()) |arg_name, arg_value| {
-                    switch (arg_value) {
-                        .bool => |b| {
-                            try args_inner.field(arg_name, b, .{});
-                        },
-                        .int => |i| {
-                            try args_inner.field(arg_name, i, .{});
-                        },
-                        .float => |f| {
-                            try args_inner.field(arg_name, f, .{});
-                        },
-                        .string => |s| {
-                            try args_inner.field(arg_name, s, .{});
-                        },
-                        .@"enum" => |e| {
-                            try args_inner.fieldPrefix(arg_name);
-                            try args_inner.container.serializer.writer.print(".{}", .{std.zig.fmtId(e)});
-                        },
-                        .null => {
-                            try args_inner.field(arg_name, null, .{});
-                        },
-                    }
-                }
-                try args_inner.end();
-            }
-            try inner.end();
-        }
-
-        fn serializeWriteFile(
-            outer: *std.zon.stringify.Serializer(Writer).Struct,
-            name: []const u8,
-            item: WriteFile,
-        ) !void {
-            var inner = try outer.beginStructField(name, .{});
-            if (item.private) |p| {
-                try inner.field("private", p, .{});
-            }
-            if (item.items) |items| {
-                var items_struct = try inner.beginStructField("items", .{});
-                for (items.keys(), items.values()) |item_name, item_value| {
-                    var item_struct = try items_struct.beginStructField(item_name, .{});
-                    switch (item_value) {
-                        .file => |f| {
-                            try item_struct.field("type", f.type, .{});
-                            try item_struct.field("path", f.path, .{});
-                        },
-                        .dir => |d| {
-                            try item_struct.field("type", d.type, .{});
-                            try item_struct.field("path", d.path, .{});
-                            if (d.exclude_extensions) |exclude_extensions| {
-                                try item_struct.field("exclude_extensions", exclude_extensions, .{});
-                            }
-                            if (d.include_extensions) |include_extensions| {
-                                try item_struct.field("include_extensions", include_extensions, .{});
-                            }
-                        },
-                    }
-                    try item_struct.end();
-                }
-                try items_struct.end();
-            }
-            try inner.end();
-        }
-
-        fn serializeOption(
-            outer: *std.zon.stringify.Serializer(Writer).Struct,
-            name: []const u8,
-            item: Option,
-        ) !void {
-            switch (item) {
-                .int => |i| {
-                    try outer.field(name, i, .{ .emit_default_optional_fields = false });
-                },
-                .float => |f| {
-                    try outer.field(name, f, .{ .emit_default_optional_fields = false });
-                },
-                .bool => |b| {
-                    try outer.field(name, b, .{ .emit_default_optional_fields = false });
-                },
-                .@"enum" => |e| {
-                    _ = e;
-                    // TODO
-                    // try opts.field(name, e, .{ .emit_default_optional_fields = false });
-                },
-                .enum_list => |el| {
-                    _ = el;
-                    // TODO
-                    // try opts.field(name, el, .{ .emit_default_optional_fields = false });
-                },
-                .string => |s| {
-                    try outer.field(name, s, .{ .emit_default_optional_fields = false });
-                },
-                .list => |l| {
-                    try outer.field(name, l, .{ .emit_default_optional_fields = false });
-                },
-                .build_id => |b| {
-                    try outer.field(name, b, .{ .emit_default_optional_fields = false });
-                },
-                .lazy_path => |lp| {
-                    try outer.field(name, lp, .{ .emit_default_optional_fields = false });
-                },
-                .lazy_path_list => |lpl| {
-                    try outer.field(name, lpl, .{ .emit_default_optional_fields = false });
-                },
-            }
-        }
-
-        fn serializeModule(
-            outer: *std.zon.stringify.Serializer(Writer).Struct,
-            name: []const u8,
-            item: Module,
-        ) !void {
-            try outer.field(name, item, .{ .emit_default_optional_fields = false });
-        }
-
-        fn serializeExecutable(
-            outer: *std.zon.stringify.Serializer(Writer).Struct,
-            name: []const u8,
-            item: Executable,
-        ) !void {
-            var inner = try outer.beginStructField(name, .{});
-            if (item.name) |n| {
-                try inner.field("name", n, .{});
-            }
-            if (item.version) |version| {
-                try inner.field("version", version, .{});
-            }
-            switch (item.root_module) {
-                .name => |n| {
-                    try inner.field("root_module", n, .{});
-                },
-                .module => |m| {
-                    try serializeModule(&inner, "root_module", m);
-                },
-            }
-            if (item.linkage) |linkage| {
-                try inner.field("linkage", linkage, .{});
-            }
-            if (item.max_rss) |max_rss| {
-                try inner.field("max_rss", max_rss, .{});
-            }
-            if (item.use_llvm) |use_llvm| {
-                try inner.field("use_llvm", use_llvm, .{});
-            }
-            if (item.use_lld) |use_lld| {
-                try inner.field("use_lld", use_lld, .{});
-            }
-            if (item.zig_lib_dir) |zig_lib_dir| {
-                try inner.field("zig_lib_dir", zig_lib_dir, .{});
-            }
-            if (item.win32_manifest) |win32_manifest| {
-                try inner.field("win32_manifest", win32_manifest, .{});
-            }
-            if (item.depends_on) |depends_on| {
-                try inner.field("depends_on", depends_on, .{});
-            }
-            try inner.end();
-        }
-    };
-}
-
-test {
-    const gpa = std.testing.allocator;
-    var status = std.zon.parse.Status{};
-    var config = Config.parseFromFile(gpa, "foo.zon", &status) catch |err| {
-        try status.format("error: {s}", .{}, std.io.getStdErr().writer());
-        return err;
-    };
-    defer config.deinit(gpa);
-    defer status.deinit(gpa);
-
-    std.debug.print("{any}\n", .{config});
-
-    // Check that the required fields are set
-    // try std.testing.expect(config.name != null);
-    // try std.testing.expect(config.version != null);
-    // try std.testing.expect(config.fingerprint != null);
-    // try std.testing.expect(config.minimum_zig_version != null);
-}
diff --git a/src/ConfigBuildgen.zig b/src/ConfigBuildgen.zig
deleted file mode 100644
index 4600cab..0000000
--- a/src/ConfigBuildgen.zig
+++ /dev/null
@@ -1,1281 +0,0 @@
-//! Generate a build.zig file from a Config
-
-const std = @import("std");
-
-const Config = @import("Config.zig");
-const ConfigBuildgen = @This();
-
-const Writer = std.io.AnyWriter;
-
-allocator: std.mem.Allocator,
-config: Config,
-writer: Writer,
-
-write_files: std.StringArrayHashMap(Config.WriteFile),
-options: std.StringArrayHashMap(Option),
-options_modules: std.StringArrayHashMap(Config.OptionsModule),
-modules: std.StringArrayHashMap(Config.Module),
-dependencies: std.StringArrayHashMap(void),
-executables: std.StringArrayHashMap(Config.Executable),
-runs: std.StringArrayHashMap(Config.Run),
-
-const Option = struct {
-    type_name: []const u8,
-    optional: bool,
-};
-
-pub fn init(allocator: std.mem.Allocator, config: Config, writer: Writer) ConfigBuildgen {
-    return ConfigBuildgen{
-        .allocator = allocator,
-        .config = config,
-        .writer = writer,
-        .write_files = std.StringArrayHashMap(Config.WriteFile).init(allocator),
-        .options = std.StringArrayHashMap(Option).init(allocator),
-        .options_modules = std.StringArrayHashMap(Config.OptionsModule).init(allocator),
-        .modules = std.StringArrayHashMap(Config.Module).init(allocator),
-        .dependencies = std.StringArrayHashMap(void).init(allocator),
-        .executables = std.StringArrayHashMap(Config.Executable).init(allocator),
-        .runs = std.StringArrayHashMap(Config.Run).init(allocator),
-    };
-}
-
-pub fn deinit(self: *ConfigBuildgen) void {
-    self.write_files.deinit();
-    self.options.deinit();
-    self.options_modules.deinit();
-    self.modules.deinit();
-    self.dependencies.deinit();
-    self.executables.deinit();
-    self.runs.deinit();
-}
-
-pub fn write(self: *ConfigBuildgen) !void {
-    try self.writeLn(
-        \\// This file is generated by zbuild. Do not edit manually.
-        \\
-        \\const std = @import("std");
-        \\
-        \\pub fn build(b: *std.Build) void {{
-        \\    const target = b.standardTargetOptions(.{{}});
-        \\    const optimize = b.standardOptimizeOption(.{{}});
-        \\
-    ,
-        .{},
-        .{ .indent = 0 },
-    );
-
-    // add all config items without linking depends_on, lazy paths, or imports
-
-    if (self.config.options) |options| {
-        try self.writeItems(Config.Option, writeOption, options);
-    }
-    if (self.config.options_modules) |options_modules| {
-        try self.writeItems(Config.OptionsModule, writeOptionsModule, options_modules);
-    }
-    if (self.config.dependencies) |dependencies| {
-        try self.writeItems(Config.Dependency, writeDependency, dependencies);
-    }
-    if (self.config.write_files) |write_files| {
-        try self.writeItems(Config.WriteFile, writeWriteFile, write_files);
-    }
-    if (self.config.modules) |modules| {
-        try self.writeItems(Config.Module, writeModule, modules);
-    }
-    if (self.config.executables) |executables| {
-        try self.writeItems(Config.Executable, writeExecutable, executables);
-    }
-    if (self.config.libraries) |libraries| {
-        try self.writeItems(Config.Library, writeLibrary, libraries);
-    }
-    if (self.config.objects) |objects| {
-        try self.writeItems(Config.Object, writeObject, objects);
-    }
-
-    if ((self.config.tests != null and self.config.tests.?.count() > 0) or self.modules.count() > 0) {
-        try self.writeLn(
-            \\const tls_run_test = b.step("test", "Run all tests");
-            \\
-        , .{}, .{});
-    }
-    // ensure a test is created for every module in the project, not just explicitly defined tests
-    for (self.modules.keys()) |name| {
-        if (self.config.tests == null or !self.config.tests.?.contains(name)) {
-            try self.writeTest(name, .{
-                .root_module = .{ .name = name },
-                .filters = &.{},
-            });
-            try self.writer.writeAll("\n");
-        }
-    }
-    if (self.config.tests) |tests| {
-        try self.writeItems(Config.Test, writeTest, tests);
-    }
-    if (self.config.fmts) |fmts| {
-        try self.writeLn(
-            \\const tls_run_fmt = b.step("fmt", "Run all fmts");
-            \\
-        , .{}, .{});
-        try self.writeItems(Config.Fmt, writeFmt, fmts);
-    }
-    if (self.config.runs) |runs| {
-        try self.writeItems(Config.Run, writeRun, runs);
-    }
-
-    // add files/dirs to write files
-
-    if (self.config.write_files) |write_files| {
-        try self.writeItems(Config.WriteFile, writeWriteFileItems, write_files);
-    }
-
-    // link all imports
-
-    if (self.config.modules) |modules| {
-        try self.writeImports(Config.Module, modules);
-    }
-    if (self.config.executables) |executables| {
-        try self.writeImports(Config.Executable, executables);
-    }
-    if (self.config.libraries) |libraries| {
-        try self.writeImports(Config.Library, libraries);
-    }
-    if (self.config.objects) |objects| {
-        try self.writeImports(Config.Object, objects);
-    }
-    if (self.config.tests) |tests| {
-        try self.writeImports(Config.Test, tests);
-    }
-    // make sure all unused variables are used
-    // target and optimize that aren't used (when all modules define them)
-    var target_unused = true;
-    var optimize_unused = true;
-    for (self.modules.values()) |module| {
-        if (module.target == null) {
-            target_unused = false;
-        }
-        if (module.optimize == null) {
-            optimize_unused = false;
-        }
-    }
-    if (target_unused) {
-        try self.writeLn("_ = target;", .{}, .{});
-    }
-    if (optimize_unused) {
-        try self.writeLn("_ = optimize;", .{}, .{});
-    }
-    // options modules and dependencies that aren't imported
-    for (self.options_modules.keys()) |name| {
-        var options_module_unused = true;
-        blk: for (self.modules.values()) |module| {
-            if (module.imports) |imports| {
-                for (imports) |import| {
-                    if (std.mem.eql(u8, name, import)) {
-                        options_module_unused = false;
-                        break :blk;
-                    }
-                }
-            }
-        }
-        if (options_module_unused) {
-            try self.writeLn("_ = {s};", .{try fmtId("options_module", name)}, .{});
-        }
-    }
-    for (self.dependencies.keys()) |name| {
-        var dependency_unused = true;
-        blk: for (self.modules.values()) |module| {
-            if (module.imports) |imports| {
-                for (imports) |import| {
-                    var parts = std.mem.splitScalar(u8, import, ':');
-                    const first = parts.first();
-                    if (std.mem.eql(u8, name, first)) {
-                        dependency_unused = false;
-                        break :blk;
-                    }
-                }
-            }
-            if (module.link_libraries) |link_libraries| {
-                for (link_libraries) |link_library| {
-                    var parts = std.mem.splitScalar(u8, link_library, ':');
-                    const dep_name = parts.first();
-                    if (std.mem.eql(u8, name, dep_name)) {
-                        dependency_unused = false;
-                        break :blk;
-                    }
-                }
-            }
-        }
-        if (dependency_unused) {
-            try self.writeLn("_ = {s};", .{try fmtId("dep", name)}, .{});
-        }
-    }
-
-    try self.writeLn("}}", .{}, .{ .indent = 0 });
-}
-
-fn writeItems(
-    self: *ConfigBuildgen,
-    comptime T: type,
-    comptime writeItem: fn (*ConfigBuildgen, []const u8, T) anyerror!void,
-    items: std.StringArrayHashMap(T),
-) !void {
-    const names = items.keys();
-    const values = items.values();
-    for (names, values) |name, item| {
-        try writeItem(self, name, item);
-        try self.writer.writeAll("\n");
-    }
-}
-
-fn writeImports(
-    self: *ConfigBuildgen,
-    comptime T: type,
-    items: std.StringArrayHashMap(T),
-) !void {
-    const keys = items.keys();
-    const values = items.values();
-    for (keys, values) |name, item| {
-        const imports = switch (T) {
-            Config.Module => item.imports orelse continue,
-            else => blk: {
-                const module_config = switch (item.root_module) {
-                    .module => |m| m,
-                    .name => continue,
-                };
-                break :blk if (module_config.imports) |imports| imports else continue;
-            },
-        };
-
-        try self.writeImport(name, imports);
-        try self.writer.writeAll("\n");
-    }
-}
-
-pub fn writeWriteFile(self: *ConfigBuildgen, name: []const u8, item: Config.WriteFile) !void {
-    const write_files_id = try allocFmtId(self.allocator, "write_files", name);
-    defer self.allocator.free(write_files_id);
-
-    try self.writeLn(
-        \\const {s} = b.{s}();
-    ,
-        .{
-            write_files_id,
-            if (item.private orelse false) "addWriteFiles" else "addNamedWriteFiles",
-        },
-        .{},
-    );
-    try self.write_files.put(name, item);
-}
-
-pub fn writeWriteFileItems(self: *ConfigBuildgen, name: []const u8, item: Config.WriteFile) !void {
-    const write_files_id = try allocFmtId(self.allocator, "write_files", name);
-    defer self.allocator.free(write_files_id);
-
-    if (item.items) |items| {
-        for (items.keys(), items.values()) |key, value| {
-            switch (value) {
-                .file => |f| {
-                    try self.writeLn(
-                        \\_ = {s}.addCopyFile({s}, "{s}");
-                    ,
-                        .{ write_files_id, try self.resolveLazyPath(f.path, SourcesForWriteFiles), key },
-                        .{},
-                    );
-                },
-                .dir => |d| {
-                    try self.writeLn(
-                        \\_ = {s}.addCopyDirectory({s}, "{s}", .{{ .exclude_extensions = {s}, include_extensions = {s} }});
-                    ,
-                        .{
-                            write_files_id,
-                            try self.resolveLazyPath(d.path, SourcesForWriteFiles),
-                            key,
-                            try strSliceLiteral(d.exclude_extensions) orelse "&.{}",
-                            try strSliceLiteral(d.include_extensions) orelse "null",
-                        },
-                        .{},
-                    );
-                },
-            }
-        }
-    }
-}
-
-pub fn writeOption(self: *ConfigBuildgen, name: []const u8, item: Config.Option) !void {
-    const t, const default, const description = blk: switch (item) {
-        .bool => |b| {
-            break :blk .{
-                "bool",
-                if (b.default) |d| try std.fmt.allocPrint(self.allocator, "{}", .{d}) else null,
-                b.description,
-            };
-        },
-        .@"enum" => |e| {
-            break :blk .{
-                try std.fmt.allocPrint(self.allocator, "enum {s}", .{e.enum_options}),
-                if (e.default) |d| try std.fmt.allocPrint(self.allocator, ".{s}", .{d}) else null,
-                e.description,
-            };
-        },
-        .enum_list => |e| {
-            const enum_id = try allocFmtId(self.allocator, "Enum", name);
-            try self.writeLn("const {s} = enum {s};", .{ enum_id, e.enum_options }, .{});
-            break :blk .{
-                enum_id,
-                if (e.default) |d| try std.fmt.allocPrint(self.allocator, "{s}", .{try enumSliceLiteral(enum_id, d)}) else null,
-                e.description,
-            };
-        },
-        .string => |s| {
-            break :blk .{
-                "[]const u8",
-                if (s.default) |d| try std.fmt.allocPrint(self.allocator, "\"{s}\"", .{d}) else null,
-                s.description,
-            };
-        },
-        .list => |l| {
-            break :blk .{
-                "[]const []const u8",
-                try allocStrSliceLiteral(self.allocator, l.default),
-                l.description,
-            };
-        },
-        .lazy_path => |l| {
-            break :blk .{
-                "std.Build.LazyPath",
-                if (l.default) |d| try self.resolveLazyPath(d, SourcesForOptions) else null,
-                l.description,
-            };
-        },
-        .lazy_path_list => |l| {
-            break :blk .{
-                "[]std.Build.LazyPath",
-                try lazyPathSlice(l.default),
-                l.description,
-            };
-        },
-        .build_id => |b| {
-            break :blk .{
-                "std.zig.BuildId",
-                try buildId(b.default),
-                b.description,
-            };
-        },
-        .int => |i| {
-            break :blk .{
-                i.type,
-                if (i.default) |d| try std.fmt.allocPrint(self.allocator, "{}", .{d}) else null,
-                i.description,
-            };
-        },
-        .float => |i| {
-            break :blk .{
-                i.type,
-                if (i.default) |d| try std.fmt.allocPrint(self.allocator, "{}", .{d}) else null,
-                i.description,
-            };
-        },
-    };
-
-    const option_id = try allocFmtId(self.allocator, "option", name);
-    defer self.allocator.free(option_id);
-
-    if (default) |d| {
-        try self.writeLn(
-            \\const {s} = b.option({s}, "{s}", "{s}") orelse {s};
-        ,
-            .{ option_id, t, name, description orelse "", d },
-            .{},
-        );
-    } else {
-        try self.writeLn(
-            \\const {s} = b.option({s}, "{s}", "{s}");
-        ,
-            .{ option_id, t, name, description orelse "" },
-            .{},
-        );
-    }
-
-    try self.options.put(name, .{ .type_name = t, .optional = default == null });
-}
-
-pub fn writeOptionsModule(self: *ConfigBuildgen, name: []const u8, item: Config.OptionsModule) !void {
-    const options_id = try allocFmtId(self.allocator, "options", name);
-    defer self.allocator.free(options_id);
-
-    try self.writeLn(
-        "const {s} = b.addOptions();",
-        .{options_id},
-        .{},
-    );
-
-    for (item.keys(), item.values()) |option_name, value| {
-        try self.writeOption(option_name, value);
-        const option = self.options.get(option_name) orelse return error.MissingOption;
-        const option_id = try allocFmtId(self.allocator, "option", option_name);
-        defer self.allocator.free(option_id);
-        try self.writeLn(
-            \\{s}.addOption({s}{s}, "{s}", {s});
-        ,
-            .{
-                options_id,
-                if (option.optional) "?" else "",
-                option.type_name,
-                option_name,
-                option_id,
-            },
-            .{},
-        );
-    }
-
-    try self.writeLn(
-        \\const {s} = {s}.createModule();
-    ,
-        .{ try fmtId("options_module", name), options_id },
-        .{},
-    );
-
-    try self.options_modules.put(name, item);
-}
-
-pub fn writeModule(self: *ConfigBuildgen, name: []const u8, item: Config.Module) !void {
-    const module_id = try allocFmtId(self.allocator, "module", name);
-    defer self.allocator.free(module_id);
-
-    try self.writeLn(
-        \\const {s} = b.createModule(.{{
-    ,
-        .{module_id},
-        .{},
-    );
-
-    try self.writeField(
-        "root_source_file",
-        if (item.root_source_file) |f| try self.resolveLazyPath(f, SourcesForModules) else null,
-        .{ .str = .no_quote },
-    );
-    try self.writeField("target", try resolvedTarget(item.target), .{ .str = .no_quote });
-    try self.writeField("optimize", try optimize(item.optimize), .{ .str = .no_quote });
-    try self.writeField("link_libc", item.link_libc, .{});
-    try self.writeField("link_libcpp", item.link_libcpp, .{});
-    try self.writeField("single_threaded", item.single_threaded, .{});
-    try self.writeField("strip", item.strip, .{});
-    try self.writeField("unwind_tables", item.unwind_tables, .{});
-    try self.writeField("dwarf_format", item.dwarf_format, .{});
-    try self.writeField("code_model", item.code_model, .{});
-    try self.writeField("stack_protector", item.stack_protector, .{});
-    try self.writeField("stack_check", item.stack_check, .{});
-    try self.writeField("sanitize_c", item.sanitize_c, .{});
-    try self.writeField("sanitize_thread", item.sanitize_thread, .{});
-    try self.writeField("fuzz", item.fuzz, .{});
-    try self.writeField("valgrind", item.valgrind, .{});
-    try self.writeField("pic", item.pic, .{});
-    try self.writeField("red_zone", item.red_zone, .{});
-    try self.writeField("omit_frame_pointer", item.omit_frame_pointer, .{});
-    try self.writeField("error_tracing", item.error_tracing, .{});
-
-    try self.writeLn("}});", .{}, .{});
-
-    if (item.include_paths) |include_paths| {
-        for (include_paths) |path| {
-            try self.writeLn(
-                \\{s}.addIncludePath({s});
-            ,
-                .{ module_id, try self.resolveLazyPath(path, SourcesForModules) },
-                .{},
-            );
-        }
-    }
-
-    if (item.link_libraries) |link_libraries| {
-        for (link_libraries) |link_library| {
-            var parts = std.mem.splitScalar(u8, link_library, ':');
-            const dep_name = parts.first();
-            const artifact_name = if (parts.next()) |rest| rest else dep_name;
-
-            const dep_id = try allocFmtId(self.allocator, "dep", dep_name);
-            defer self.allocator.free(dep_id);
-
-            try self.writeLn(
-                \\{s}.linkLibrary({s}.artifact("{s}"));
-            ,
-                .{ module_id, dep_id, artifact_name },
-                .{},
-            );
-        }
-    }
-
-    if (item.private orelse true) {
-        try self.writeLn(
-            \\b.modules.put(b.dupe("{s}"), {s}) catch @panic("OOM");
-        ,
-            .{ name, module_id },
-            .{},
-        );
-    }
-    try self.modules.put(name, item);
-}
-
-pub fn writeExecutable(self: *ConfigBuildgen, name: []const u8, item: Config.Executable) !void {
-    const module_id = try self.allocModuleId(name, item.root_module);
-    defer self.allocator.free(module_id);
-
-    const exe_id = try allocFmtId(self.allocator, "exe", name);
-    defer self.allocator.free(exe_id);
-
-    try self.writeLn(
-        "const {s} = b.addExecutable(.{{",
-        .{exe_id},
-        .{},
-    );
-
-    try self.writeField("name", name, .{});
-    try self.writeField("version", try semanticVersion(item.version), .{ .str = .no_quote });
-    try self.writeField("root_module", module_id, .{ .str = .no_quote });
-    try self.writeField("linkage", item.linkage, .{});
-    try self.writeField("max_rss", item.max_rss, .{});
-    try self.writeField("use_llvm", item.use_llvm, .{});
-    try self.writeField("use_lld", item.use_lld, .{});
-    try self.writeField(
-        "zig_lib_dir",
-        if (item.zig_lib_dir) |f| try self.resolveLazyPath(f, SourcesForModules) else null,
-        .{ .str = .no_quote },
-    );
-    try self.writeField(
-        "win32_manifest",
-        if (item.win32_manifest) |f| try self.resolveLazyPath(f, SourcesForModules) else null,
-        .{ .str = .no_quote },
-    );
-
-    try self.writeLn("}});", .{}, .{});
-    try self.writer.writeAll("\n");
-
-    const install_exe_id = try allocFmtId(self.allocator, "install_exe", name);
-    defer self.allocator.free(install_exe_id);
-
-    const tls_install_exe_id = try allocFmtId(self.allocator, "tls_install_exe", name);
-    defer self.allocator.free(tls_install_exe_id);
-
-    const run_exe_id = try allocFmtId(self.allocator, "run_exe", name);
-    defer self.allocator.free(run_exe_id);
-
-    const tls_run_exe_id = try allocFmtId(self.allocator, "tls_run_exe", name);
-    defer self.allocator.free(tls_run_exe_id);
-
-    try self.writeLn(
-        \\const {s} = b.addInstallArtifact({s}, .{{
-    ,
-        .{ install_exe_id, exe_id },
-        .{},
-    );
-    try self.writeField("dest_sub_path", item.dest_sub_path, .{});
-    try self.writeLn("}});", .{}, .{});
-    try self.writer.writeAll("\n");
-
-    try self.writeLn(
-        \\const {s} = b.step("build-exe:{s}", "Install the {s} executable");
-        \\{s}.dependOn(&{s}.step);
-        \\b.getInstallStep().dependOn(&{s}.step);
-        \\
-        \\const {s} = b.addRunArtifact({s});
-        \\if (b.args) |args| {s}.addArgs(args);
-        \\const {s} = b.step("run:{s}", "Run the {s} executable");
-        \\{s}.dependOn(&{s}.step);
-    ,
-        .{
-            tls_install_exe_id,
-            name,
-            name,
-            tls_install_exe_id,
-            install_exe_id,
-            install_exe_id,
-            run_exe_id,
-            exe_id,
-            run_exe_id,
-            tls_run_exe_id,
-            name,
-            name,
-            tls_run_exe_id,
-            run_exe_id,
-        },
-        .{},
-    );
-    try self.executables.put(name, item);
-}
-
-pub fn writeLibrary(self: *ConfigBuildgen, name: []const u8, item: Config.Library) !void {
-    const module_id = try self.allocModuleId(name, item.root_module);
-    defer self.allocator.free(module_id);
-
-    const lib_id = try allocFmtId(self.allocator, "lib", name);
-    defer self.allocator.free(lib_id);
-
-    try self.writeLn(
-        "const {s} = b.addLibrary(.{{",
-        .{lib_id},
-        .{},
-    );
-
-    try self.writeField("name", name, .{});
-    try self.writeField("version", try semanticVersion(item.version), .{ .str = .no_quote });
-    try self.writeField("root_module", module_id, .{ .str = .no_quote });
-    try self.writeField("linkage", item.linkage, .{});
-    try self.writeField("max_rss", item.max_rss, .{});
-    try self.writeField("use_llvm", item.use_llvm, .{});
-    try self.writeField("use_lld", item.use_lld, .{});
-    try self.writeField(
-        "zig_lib_dir",
-        if (item.zig_lib_dir) |f| try self.resolveLazyPath(f, SourcesForModules) else null,
-        .{ .str = .no_quote },
-    );
-    try self.writeField(
-        "win32_manifest",
-        if (item.win32_manifest) |f| try self.resolveLazyPath(f, SourcesForModules) else null,
-        .{ .str = .no_quote },
-    );
-
-    try self.writeLn("}});", .{}, .{});
-    try self.writer.writeAll("\n");
-
-    if (item.linker_allow_shlib_undefined) |linker_allow_shlib_undefined| {
-        try self.writeLn(
-            "{s}.linker_allow_shlib_undefined = {};",
-            .{ lib_id, linker_allow_shlib_undefined },
-            .{},
-        );
-    }
-
-    const install_lib_id = try allocFmtId(self.allocator, "install_lib", name);
-    defer self.allocator.free(install_lib_id);
-
-    const tls_install_lib_id = try allocFmtId(self.allocator, "tls_install_lib", name);
-    defer self.allocator.free(tls_install_lib_id);
-
-    try self.writeLn(
-        \\const {s} = b.addInstallArtifact({s}, .{{
-    ,
-        .{ install_lib_id, lib_id },
-        .{},
-    );
-    try self.writeField("dest_sub_path", item.dest_sub_path, .{});
-    try self.writeLn("}});", .{}, .{});
-    try self.writer.writeAll("\n");
-
-    try self.writeLn(
-        \\const {s} = b.step("build-lib:{s}", "Install the {s} library");
-        \\{s}.dependOn(&{s}.step);
-        \\b.getInstallStep().dependOn(&{s}.step);
-    ,
-        .{
-            tls_install_lib_id,
-            name,
-            name,
-            tls_install_lib_id,
-            install_lib_id,
-            install_lib_id,
-        },
-        .{},
-    );
-}
-
-pub fn writeObject(self: *ConfigBuildgen, name: []const u8, item: Config.Object) !void {
-    const module_id = try self.allocModuleId(name, item.root_module);
-    defer self.allocator.free(module_id);
-
-    const obj_id = try allocFmtId(self.allocator, "obj", name);
-    defer self.allocator.free(obj_id);
-
-    try self.writeLn(
-        "const {s} = b.addObject(.{{",
-        .{obj_id},
-        .{},
-    );
-
-    try self.writeField("name", name, .{});
-    try self.writeField("root_module", module_id, .{ .str = .no_quote });
-    try self.writeField("max_rss", item.max_rss, .{});
-    try self.writeField("use_llvm", item.use_llvm, .{});
-    try self.writeField("use_lld", item.use_lld, .{});
-    try self.writeField(
-        "zig_lib_dir",
-        if (item.zig_lib_dir) |f| try self.resolveLazyPath(f, SourcesForModules) else null,
-        .{ .str = .no_quote },
-    );
-
-    try self.writeLn("}});", .{}, .{});
-    try self.writer.writeAll("\n");
-
-    const install_obj_id = try allocFmtId(self.allocator, "install_obj", name);
-    defer self.allocator.free(install_obj_id);
-
-    const tls_install_obj_id = try allocFmtId(self.allocator, "tls_install_obj", name);
-    defer self.allocator.free(tls_install_obj_id);
-
-    try self.writeLn(
-        \\const {s} = b.addInstallArtifact({s}, .{{}});
-        \\const {s} = b.step("build-obj:{s}", "Install the {s} object");
-        \\{s}.dependOn(&{s}.step);
-        \\b.getInstallStep().dependOn(&{s}.step);
-    ,
-        .{
-            install_obj_id,
-            obj_id,
-            tls_install_obj_id,
-            name,
-            name,
-            tls_install_obj_id,
-            install_obj_id,
-            install_obj_id,
-        },
-        .{},
-    );
-}
-
-pub fn writeTest(self: *ConfigBuildgen, name: []const u8, item: Config.Test) !void {
-    const module_id = try self.allocModuleId(name, item.root_module);
-    defer self.allocator.free(module_id);
-
-    const test_id = try allocFmtId(self.allocator, "test", name);
-    defer self.allocator.free(test_id);
-
-    try self.writeLn(
-        "const {s} = b.addTest(.{{",
-        .{test_id},
-        .{},
-    );
-
-    try self.writeField("name", name, .{});
-    try self.writeField("root_module", module_id, .{ .str = .no_quote });
-    try self.writeField("max_rss", item.max_rss, .{});
-    try self.writeField("use_llvm", item.use_llvm, .{});
-    try self.writeField("use_lld", item.use_lld, .{});
-    try self.writeField(
-        "zig_lib_dir",
-        if (item.zig_lib_dir) |f| try self.resolveLazyPath(f, SourcesForModules) else null,
-        .{ .str = .no_quote },
-    );
-    const filters = try std.fmt.allocPrint(
-        self.allocator,
-        \\b.option([][]const u8, "{s}.filters", "{s} test filters") orelse {s}
-    ,
-        .{
-            name,
-            name,
-            (try strSliceLiteral(item.filters)) orelse "&.{}",
-        },
-    );
-    defer self.allocator.free(filters);
-    try self.writeField("filters", filters, .{ .str = .no_quote });
-
-    try self.writeLn("}});", .{}, .{});
-
-    const install_test_id = try allocFmtId(self.allocator, "install_test", name);
-    defer self.allocator.free(install_test_id);
-
-    const tls_install_test_id = try allocFmtId(self.allocator, "tls_install_test", name);
-    defer self.allocator.free(tls_install_test_id);
-
-    const run_test_id = try allocFmtId(self.allocator, "run_test", name);
-    defer self.allocator.free(run_test_id);
-
-    const tls_run_test_id = try allocFmtId(self.allocator, "tls_run_test", name);
-    defer self.allocator.free(tls_run_test_id);
-
-    try self.writeLn(
-        \\const {s} = b.addInstallArtifact({s}, .{{}});
-        \\const {s} = b.step("build-test:{s}", "Install the {s} test");
-        \\{s}.dependOn(&{s}.step);
-        \\
-        \\const {s} = b.addRunArtifact({s});
-        \\const {s} = b.step("test:{s}", "Run the {s} test");
-        \\{s}.dependOn(&{s}.step);
-        \\tls_run_test.dependOn(&{s}.step);
-    ,
-        .{
-            install_test_id,
-            test_id,
-            tls_install_test_id,
-            name,
-            name,
-            tls_install_test_id,
-            install_test_id,
-            run_test_id,
-            test_id,
-            tls_run_test_id,
-            name,
-            name,
-            tls_run_test_id,
-            run_test_id,
-            run_test_id,
-        },
-        .{},
-    );
-}
-
-pub fn writeFmt(self: *ConfigBuildgen, name: []const u8, item: Config.Fmt) !void {
-    const fmt_id = try allocFmtId(self.allocator, "fmt", name);
-    defer self.allocator.free(fmt_id);
-
-    try self.writeLn(
-        \\const {s} = b.addFmt(.{{
-    ,
-        .{fmt_id},
-        .{},
-    );
-
-    try self.writeField("paths", try strSliceLiteral(item.paths) orelse "&.{}", .{ .str = .no_quote });
-    try self.writeField("exclude_paths", try strSliceLiteral(item.exclude_paths) orelse "&.{}", .{ .str = .no_quote });
-    try self.writeField("check", item.check, .{});
-
-    try self.writeLn("}});", .{}, .{});
-    try self.writer.writeAll("\n");
-
-    const tls_run_fmt_id = try allocFmtId(self.allocator, "tls_run_fmt", name);
-    defer self.allocator.free(tls_run_fmt_id);
-
-    try self.writeLn(
-        \\const {s} = b.step("fmt:{s}", "Run the {s} fmt");
-        \\{s}.dependOn(&{s}.step);
-        \\tls_run_fmt.dependOn(&{s}.step);
-    ,
-        .{ tls_run_fmt_id, name, name, tls_run_fmt_id, fmt_id, fmt_id },
-        .{},
-    );
-}
-
-pub fn writeRun(self: *ConfigBuildgen, name: []const u8, item: Config.Run) !void {
-    const Args = @import("Args.zig");
-
-    const args = try Args.initFromString(self.allocator, item);
-    defer args.deinit();
-
-    const run_id = try allocFmtId(self.allocator, "run", name);
-    defer self.allocator.free(run_id);
-
-    const tls_run_id = try allocFmtId(self.allocator, "tls_run", name);
-    defer self.allocator.free(tls_run_id);
-
-    try self.writeLn(
-        \\const {s} = b.addSystemCommand({s});
-        \\const {s} = b.step("run:{s}", "Run the {s} run");
-        \\{s}.dependOn(&{s}.step);
-    ,
-        .{
-            run_id,
-            (try strSliceLiteral(args.args.items)).?,
-            tls_run_id,
-            name,
-            name,
-            tls_run_id,
-            run_id,
-        },
-        .{},
-    );
-    try self.runs.put(name, item);
-}
-
-pub fn writeDependency(self: *ConfigBuildgen, name: []const u8, item: Config.Dependency) !void {
-    if (item.args) |args| {
-        try self.writeLn(
-            \\const {s} = b.dependency("{s}", .{{
-        ,
-            .{ try fmtId("dep", name), name },
-            .{},
-        );
-        for (args.keys(), args.values()) |key, value| {
-            switch (value) {
-                .bool => |b| try self.writeField(key, b, .{}),
-                .int => |i| try self.writeField(key, i, .{}),
-                .float => |f| try self.writeField(key, f, .{}),
-                .@"enum" => |e| if (std.mem.eql(u8, e, "optimize") or std.mem.eql(u8, e, "target")) {
-                    try self.writeField(key, e, .{ .str = .no_quote });
-                } else if (self.options.contains(e)) {
-                    const option_id = try allocFmtId(self.allocator, "option", e);
-                    defer self.allocator.free(option_id);
-                    try self.writeField(key, option_id, .{ .str = .no_quote });
-                } else {
-                    try self.writeField(key, e, .{ .str = .enum_literal });
-                },
-                .string => |s| try self.writeField(key, s, .{}),
-                .null => {
-                    // skip
-                },
-            }
-        }
-        try self.writeLn("}});", .{}, .{});
-    } else {
-        try self.writeLn(
-            \\const {s} = b.dependency("{s}", .{{
-            \\    .optimize = optimize,
-            \\    .target = target,
-            \\}});
-        ,
-            .{ try fmtId("dep", name), name },
-            .{},
-        );
-    }
-    try self.dependencies.put(name, undefined);
-}
-
-pub fn writeImport(self: *ConfigBuildgen, name: []const u8, imports: [][]const u8) !void {
-    for (imports) |import| {
-        const module_id = try allocFmtId(self.allocator, "module", name);
-        defer self.allocator.free(module_id);
-
-        try self.writeLn(
-            \\{s}.addImport("{s}", {s});
-        ,
-            .{ module_id, import, try self.resolveImport(import) },
-            .{},
-        );
-    }
-}
-
-const WriteOpts = struct {
-    indent: u8 = 4,
-};
-
-fn writeLn(self: *ConfigBuildgen, comptime fmt: []const u8, args: anytype, comptime opts: WriteOpts) !void {
-    // first format the string
-    const str = try std.fmt.allocPrint(self.allocator, fmt, args);
-    defer self.allocator.free(str);
-
-    // then add indentation + newlines
-    var it = std.mem.splitScalar(u8, str, '\n');
-    while (it.next()) |line| {
-        if (line.len == 0) {
-            try self.writer.writeAll("\n");
-        } else {
-            try self.writer.print("{s}{s}\n", .{ [_]u8{' '} ** opts.indent, line });
-        }
-    }
-}
-
-const WriteFieldOpts = struct {
-    indent: u8 = 8,
-    str: enum { quote, no_quote, enum_literal } = .quote,
-};
-
-fn writeFields(self: *ConfigBuildgen, kvs: anytype, comptime opts: WriteFieldOpts) !void {
-    for (kvs) |kv| {
-        self.writeField(kv[0], kv[1], opts);
-    }
-}
-
-fn writeField(self: *ConfigBuildgen, key: []const u8, value: anytype, comptime opts: WriteFieldOpts) !void {
-    const value_typ1 = @typeInfo(@TypeOf(value));
-    const value_typ, const value_ = if (value_typ1 == .optional) blk: {
-        if (value == null) {
-            return;
-        }
-        break :blk .{ @typeInfo(value_typ1.optional.child), value.? };
-    } else .{ value_typ1, value };
-
-    const value_str = switch (value_typ) {
-        .@"enum" => try std.fmt.allocPrint(self.allocator, ".{}", .{std.zig.fmtId(@tagName(value_))}),
-        .bool => if (value_) "true" else "false",
-        .int => try std.fmt.allocPrint(self.allocator, "{d}", .{value_}),
-        // string
-        .pointer => |p| blk: {
-            if (p.size == .slice) {
-                const childInfo = @typeInfo(p.child);
-                if (childInfo == .int and childInfo.int.bits == 8) {
-                    switch (opts.str) {
-                        .quote => break :blk try std.fmt.allocPrint(self.allocator, "\"{s}\"", .{value_}),
-                        .no_quote => break :blk value_,
-                        .enum_literal => break :blk try std.fmt.allocPrint(self.allocator, ".{}", .{std.zig.fmtId(value_)}),
-                    }
-                }
-            }
-            return error.InvalidType;
-        },
-        else => return error.InvalidType,
-    };
-
-    try self.writeLn(
-        ".{s} = {s},",
-        .{
-            key,
-            value_str,
-        },
-        .{ .indent = opts.indent },
-    );
-}
-
-/// return the module name, writing the module definition first if necessary
-fn allocModuleId(self: *ConfigBuildgen, name: []const u8, item: Config.ModuleLink) ![]const u8 {
-    return try allocFmtId(
-        self.allocator,
-        "module",
-        switch (item) {
-            .name => |n| n,
-            .module => |m| blk: {
-                const n = m.name orelse name;
-                try self.writeModule(n, m);
-                try self.writer.writeAll("\n");
-                break :blk n;
-            },
-        },
-    );
-}
-
-/// used for temp strings
-/// This is safe because only a single consumer of scratch exists at a time
-threadlocal var scratch: [4096]u8 = undefined;
-
-fn lazyPathSlice(paths_maybe: ?[][]const u8) !?[]u8 {
-    if (paths_maybe) |paths| {
-        var w = std.io.fixedBufferStream(&scratch);
-        const writer = w.writer();
-
-        try writer.writeAll("&[_]std.Build.LazyPath{ ");
-
-        for (paths, 0..) |path, i| {
-            try writer.print("b.path(\"{s}\")", .{path});
-            if (i != paths.len - 1) {
-                try writer.writeAll(", ");
-            }
-        }
-
-        try writer.writeAll(" }");
-        return w.getWritten();
-    } else {
-        return null;
-    }
-}
-fn buildId(build_id: ?[]const u8) !?[]const u8 {
-    if (build_id) |b| {
-        return try std.fmt.bufPrint(
-            &scratch,
-            \\std.zig.BuildId.parse("{s}") catch @panic("invalid build id")
-        ,
-            .{b},
-        );
-    } else {
-        return null;
-    }
-}
-
-fn resolvedTarget(target: ?[]const u8) ![]const u8 {
-    if (target) |t| {
-        return try std.fmt.bufPrint(
-            &scratch,
-            \\b.resolveTargetQuery(std.Target.Query.parse(.{{.arch_os_abi = "{s}"}}) catch @panic("invalid target"))
-        ,
-            .{t},
-        );
-    } else {
-        return @constCast("target");
-    }
-}
-
-fn optimize(opt: ?std.builtin.OptimizeMode) ![]const u8 {
-    if (opt) |o| {
-        return try std.fmt.bufPrint(
-            &scratch,
-            \\.{s}
-        ,
-            .{@tagName(o)},
-        );
-    } else {
-        return @constCast("optimize");
-    }
-}
-
-fn semanticVersion(version: ?[]const u8) !?[]u8 {
-    if (version) |v| {
-        return try std.fmt.bufPrint(
-            &scratch,
-            "std.SemanticVersion.parse(\"{s}\") catch @panic(\"invalid version\")",
-            .{v},
-        );
-    } else {
-        return null;
-    }
-}
-
-pub fn strSliceLiteral(str_slice_maybe: ?[]const []const u8) !?[]u8 {
-    if (str_slice_maybe) |str_slice| {
-        var w = std.io.fixedBufferStream(&scratch);
-        const writer = w.writer();
-
-        try writer.writeAll("&[_][]const u8{ ");
-
-        for (str_slice, 0..) |str, i| {
-            try writer.print("\"{s}\"", .{str});
-            if (i != str_slice.len - 1) {
-                try writer.writeAll(", ");
-            }
-        }
-
-        try writer.writeAll(" }");
-        return w.getWritten();
-    } else {
-        return null;
-    }
-}
-
-pub fn allocStrSliceLiteral(allocator: std.mem.Allocator, str_slice_maybe: ?[]const []const u8) !?[]u8 {
-    return try allocator.dupe(u8, try strSliceLiteral(str_slice_maybe) orelse return null);
-}
-
-pub fn strTupleLiteral(str_slice_maybe: ?[]const []const u8) !?[]u8 {
-    if (str_slice_maybe) |str_slice| {
-        var w = std.io.fixedBufferStream(&scratch);
-        const writer = w.writer();
-
-        try writer.writeAll(".{ ");
-
-        for (str_slice, 0..) |str, i| {
-            try writer.print("\"{s}\"", .{str});
-            if (i != str_slice.len - 1) {
-                try writer.writeAll(", ");
-            }
-        }
-
-        try writer.writeAll(" }");
-        return w.getWritten();
-    } else {
-        return null;
-    }
-}
-
-fn enumSliceLiteral(enum_name: []const u8, enum_slice: []const []const u8) ![]u8 {
-    var w = std.io.fixedBufferStream(&scratch);
-    const writer = w.writer();
-
-    try writer.print("&[_]{s}{{ ", .{enum_name});
-
-    for (enum_slice, 0..) |enum_value, i| {
-        try writer.print(".{s}", .{enum_value});
-        if (i != enum_slice.len - 1) {
-            try writer.writeAll(", ");
-        }
-    }
-
-    try writer.writeAll(" }");
-    return w.getWritten();
-}
-
-fn resolveImport(self: *ConfigBuildgen, import: []const u8) ![]const u8 {
-    if (self.modules.contains(import)) {
-        return try fmtId("module", import);
-    } else if (self.options_modules.contains(import)) {
-        return try fmtId("options_module", import);
-    } else if (self.dependencies.contains(import)) {
-        const dep_id = try allocFmtId(self.allocator, "dep", import);
-        defer self.allocator.free(dep_id);
-
-        return try std.fmt.bufPrint(&scratch, "{s}.module(\"{s}\")", .{ dep_id, import });
-    } else {
-        // one last try, maybe it's a dependency with a custom module, eg "dep:module_a"
-        var parts = std.mem.splitScalar(u8, import, ':');
-        const first = parts.first();
-        if (self.dependencies.contains(first)) {
-            const dep_id = try allocFmtId(self.allocator, "dep", first);
-            defer self.allocator.free(dep_id);
-            return try std.fmt.bufPrint(&scratch, "{s}.module(\"{s}\")", .{ dep_id, parts.rest() });
-        }
-
-        return try std.fmt.bufPrint(&scratch, "@panic(\"missing import {s}\")", .{import});
-    }
-}
-
-const SourcesForWriteFiles = .{ .write_files, .dependencies, .options };
-const SourcesForOptions = .{ .write_files, .dependencies };
-const SourcesForModules = .{ .write_files, .dependencies, .options };
-
-/// Use colon delimiters to differentiate between
-/// - simple paths, eg "src/main.zig"
-/// - writefiles paths, eg "writefiles:src/main.zig"
-/// - TODO options paths, eg "options:foo"
-/// - dependency paths, both
-///   - named writefiles paths, eg "dep:writefiles:src/main.zig"
-///   - named lazypath paths, eg "dep:src/main.zig"
-/// Use sources to limit and order which sources to try
-/// - write_files, options, dependencies, runs_output
-fn resolveLazyPath(self: *ConfigBuildgen, path: []const u8, comptime sources: anytype) ![]const u8 {
-    comptime {
-        for (sources) |source| {
-            switch (source) {
-                .write_files, .options, .dependencies, .runs_output => {},
-                else => @compileError("Invalid source"),
-            }
-        }
-    }
-    var parts = std.mem.splitScalar(u8, path, ':');
-    const first = parts.first();
-    inline for (sources) |source| {
-        switch (source) {
-            .write_files => if (self.write_files.contains(first)) {
-                const write_files_id = try allocFmtId(self.allocator, "write_files", first);
-                defer self.allocator.free(write_files_id);
-
-                return try std.fmt.bufPrint(
-                    &scratch,
-                    "{s}.getDirectory().path(b, \"{s}\")",
-                    .{ write_files_id, parts.rest() },
-                );
-            },
-            .options => if (self.options.get(first)) |option| blk: {
-                if (!std.mem.eql(u8, option.type_name, "std.Build.LazyPath")) {
-                    break :blk;
-                }
-
-                const option_id = try allocFmtId(self.allocator, "option", first);
-                defer self.allocator.free(option_id);
-
-                if (option.optional) {
-                    return try std.fmt.bufPrint(
-                        &scratch,
-                        "{s} orelse @panic(\"missing option {s}\")",
-                        .{ option_id, first },
-                    );
-                } else {
-                    return try std.fmt.bufPrint(
-                        &scratch,
-                        "{s}",
-                        .{option_id},
-                    );
-                }
-            },
-            .dependencies => if (self.dependencies.contains(first)) blk: {
-                const dep_id = try allocFmtId(self.allocator, "dep", first);
-                defer self.allocator.free(dep_id);
-
-                const next = parts.next() orelse break :blk;
-                const last = parts.next();
-                // TODO there should be an error if there's even more data after?, eg dep:writefiles:src/main.zig:wtf_is_this
-
-                if (last) |l| {
-                    return try std.fmt.bufPrint(
-                        &scratch,
-                        "{s}.namedWriteFiles(\"{s}\").getDirectory().path(b, \"{s}\")",
-                        .{ dep_id, next, l },
-                    );
-                } else {
-                    return try std.fmt.bufPrint(
-                        &scratch,
-                        "{s}.namedLazyPath(\"{s}\")",
-                        .{ dep_id, next },
-                    );
-                }
-            },
-            else => unreachable,
-        }
-    }
-    return try std.fmt.bufPrint(
-        &scratch,
-        "b.path(\"{s}\")",
-        .{path},
-    );
-}
-
-/// wrapper around std.zig.fmtId that includes a prefix string
-fn fmtId(prefix: []const u8, name: []const u8) ![]const u8 {
-    var fmt_scratch: [4096]u8 = undefined;
-    return try std.fmt.bufPrint(&scratch, "{}", .{std.zig.fmtId(try std.fmt.bufPrint(&fmt_scratch, "{s}_{s}", .{ prefix, name }))});
-}
-
-/// wrapper around std.zig.fmtId that includes a prefix string, consumer is responsible for freeing
-fn allocFmtId(allocator: std.mem.Allocator, prefix: []const u8, name: []const u8) ![]const u8 {
-    return try allocator.dupe(u8, try fmtId(prefix, name));
-}
diff --git a/src/GlobalOptions.zig b/src/GlobalOptions.zig
deleted file mode 100644
index 47862ba..0000000
--- a/src/GlobalOptions.zig
+++ /dev/null
@@ -1,123 +0,0 @@
-//! Collects options from the environment, `zig env`, and command line arguments.
-
-const std = @import("std");
-const mem = std.mem;
-const Allocator = std.mem.Allocator;
-const Args = @import("Args.zig");
-const ZigEnv = @import("ZigEnv.zig");
-const fatal = std.process.fatal;
-
-const GlobalOptions = @This();
-
-zig_exe: []const u8,
-lib_dir: []const u8,
-std_dir: []const u8,
-global_cache_dir: []const u8,
-version: []const u8,
-
-project_dir: []const u8,
-zbuild_file: []const u8,
-no_sync: bool,
-
-const GlobalArgs = enum {
-    zig_exe,
-    lib_dir,
-    std_dir,
-    global_cache_dir,
-    project_dir,
-    zbuild_file,
-    no_sync,
-};
-
-pub fn deinit(self: GlobalOptions, allocator: Allocator) void {
-    allocator.free(self.zig_exe);
-    allocator.free(self.lib_dir);
-    allocator.free(self.std_dir);
-    allocator.free(self.global_cache_dir);
-    allocator.free(self.version);
-    allocator.free(self.project_dir);
-    allocator.free(self.zbuild_file);
-}
-
-pub fn parseArgs(allocator: Allocator, args: *Args) !GlobalOptions {
-    const zig_env = try ZigEnv.parse(allocator);
-
-    var opts = GlobalOptions{
-        .zig_exe = zig_env.zig_exe,
-        .lib_dir = zig_env.lib_dir,
-        .std_dir = zig_env.std_dir,
-        .global_cache_dir = zig_env.global_cache_dir,
-        .version = zig_env.version,
-        .project_dir = try allocator.dupe(u8, "."),
-        .zbuild_file = try allocator.dupe(u8, "zbuild.zon"),
-        .no_sync = false,
-    };
-
-    iter: while (args.peek()) |arg| {
-        if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
-            return opts;
-        }
-
-        const arg_type = if (mem.eql(u8, arg, "--zig-exe"))
-            GlobalArgs.zig_exe
-        else if (mem.eql(u8, arg, "--global-cache-dir"))
-            GlobalArgs.global_cache_dir
-        else if (mem.eql(u8, arg, "--zig-lib-dir"))
-            GlobalArgs.lib_dir
-        else if (mem.eql(u8, arg, "--zig-std-dir"))
-            GlobalArgs.std_dir
-        else if (mem.eql(u8, arg, "--project-dir"))
-            GlobalArgs.project_dir
-        else if (mem.eql(u8, arg, "--zbuild-file"))
-            GlobalArgs.zbuild_file
-        else if (mem.eql(u8, arg, "--no-sync")) {
-            opts.no_sync = true;
-            continue;
-        } else {
-            break :iter;
-        };
-
-        _ = args.next();
-        const arg_next = args.next() orelse fatal("expected argument after '{s}'", .{arg});
-        const arg_value = try allocator.dupe(u8, arg_next);
-        switch (arg_type) {
-            .zig_exe => {
-                allocator.free(opts.zig_exe);
-                opts.zig_exe = arg_value;
-            },
-            .global_cache_dir => {
-                allocator.free(opts.global_cache_dir);
-                opts.global_cache_dir = arg_value;
-            },
-            .lib_dir => {
-                allocator.free(opts.lib_dir);
-                opts.lib_dir = arg_value;
-            },
-            .std_dir => {
-                allocator.free(opts.std_dir);
-                opts.std_dir = arg_value;
-            },
-            .project_dir => {
-                allocator.free(opts.project_dir);
-                opts.project_dir = arg_value;
-            },
-            .zbuild_file => {
-                allocator.free(opts.zbuild_file);
-                opts.zbuild_file = arg_value;
-            },
-            else => unreachable,
-        }
-    }
-
-    return opts;
-}
-
-pub fn getZigEnv(self: GlobalOptions) ZigEnv {
-    return .{
-        .zig_exe = self.zig_exe,
-        .lib_dir = self.lib_dir,
-        .std_dir = self.std_dir,
-        .global_cache_dir = self.global_cache_dir,
-        .version = self.version,
-    };
-}
diff --git a/src/Manifest.zig b/src/Manifest.zig
deleted file mode 100644
index 96a9b18..0000000
--- a/src/Manifest.zig
+++ /dev/null
@@ -1,781 +0,0 @@
-//! Mostly copy-pasted from zig/src/Package/Manifest.zig
-const Manifest = @This();
-const std = @import("std");
-const mem = std.mem;
-const Allocator = std.mem.Allocator;
-const assert = std.debug.assert;
-const Ast = std.zig.Ast;
-const Color = std.zig.Color;
-const testing = std.testing;
-const Package = @import("Package.zig");
-
-pub const max_bytes = 10 * 1024 * 1024;
-pub const max_name_len = 32;
-pub const max_version_len = 32;
-
-pub const Dependency = struct {
-    location: Location,
-    location_tok: Ast.TokenIndex,
-    location_node: Ast.Node.Index,
-    hash: ?[]const u8,
-    hash_tok: Ast.TokenIndex,
-    hash_node: Ast.Node.Index,
-    node: Ast.Node.Index,
-    name_tok: Ast.TokenIndex,
-    lazy: bool,
-
-    pub const Location = union(enum) {
-        url: []const u8,
-        path: []const u8,
-    };
-};
-
-pub const ErrorMessage = struct {
-    msg: []const u8,
-    tok: Ast.TokenIndex,
-    off: u32,
-};
-
-ast: Ast,
-name: []const u8,
-name_node: Ast.Node.Index,
-id: u32,
-version: std.SemanticVersion,
-version_node: Ast.Node.Index,
-dependencies: std.StringArrayHashMapUnmanaged(Dependency),
-dependencies_node: Ast.Node.Index,
-paths: std.StringArrayHashMapUnmanaged(void),
-minimum_zig_version: ?std.SemanticVersion,
-
-errors: []ErrorMessage,
-arena_state: std.heap.ArenaAllocator.State,
-
-pub const ParseOptions = struct {
-    allow_missing_paths_field: bool = false,
-    /// Deprecated, to be removed after 0.14.0 is tagged.
-    allow_name_string: bool = true,
-    /// Deprecated, to be removed after 0.14.0 is tagged.
-    allow_missing_fingerprint: bool = true,
-};
-
-pub const Error = Allocator.Error;
-
-pub const LoadManifestOptions = struct {
-    dir: std.fs.Dir,
-    basename: []const u8,
-    color: Color,
-};
-
-pub fn load(
-    gpa: Allocator,
-    arena: Allocator,
-    options: LoadManifestOptions,
-) !?Manifest {
-    const manifest_bytes = options.dir.readFileAllocOptions(
-        arena,
-        options.basename,
-        Manifest.max_bytes,
-        null,
-        1,
-        0,
-    ) catch |err| switch (err) {
-        error.FileNotFound => return null,
-        else => return err,
-    };
-    var ast = try Ast.parse(gpa, manifest_bytes, .zon);
-    errdefer ast.deinit(gpa);
-
-    if (ast.errors.len > 0) {
-        try std.zig.printAstErrorsToStderr(gpa, ast, options.basename, options.color);
-        return error.InvalidManifest;
-    }
-
-    var manifest = try Manifest.parse(gpa, ast, .{});
-    errdefer manifest.deinit(gpa);
-
-    if (manifest.errors.len > 0) {
-        var wip_errors: std.zig.ErrorBundle.Wip = undefined;
-        try wip_errors.init(gpa);
-        defer wip_errors.deinit();
-
-        const src_path = try wip_errors.addString(options.basename);
-        try manifest.copyErrorsIntoBundle(ast, src_path, &wip_errors);
-
-        var error_bundle = try wip_errors.toOwnedBundle("");
-        defer error_bundle.deinit(gpa);
-        error_bundle.renderToStdErr(options.color.renderOptions());
-
-        return error.InvalidManifest;
-    }
-    return manifest;
-}
-
-pub fn parse(gpa: Allocator, ast: Ast, options: ParseOptions) Error!Manifest {
-    const node_tags = ast.nodes.items(.tag);
-    const node_datas = ast.nodes.items(.data);
-    assert(node_tags[0] == .root);
-    const main_node_index = node_datas[0].lhs;
-
-    var arena_instance = std.heap.ArenaAllocator.init(gpa);
-    errdefer arena_instance.deinit();
-
-    var p: Parse = .{
-        .gpa = gpa,
-        .ast = ast,
-        .arena = arena_instance.allocator(),
-        .errors = .{},
-
-        .name = undefined,
-        .name_node = 0,
-        .id = 0,
-        .version = undefined,
-        .version_node = 0,
-        .dependencies = .{},
-        .dependencies_node = 0,
-        .paths = .{},
-        .allow_missing_paths_field = options.allow_missing_paths_field,
-        .allow_name_string = options.allow_name_string,
-        .allow_missing_fingerprint = options.allow_missing_fingerprint,
-        .minimum_zig_version = null,
-        .buf = .{},
-    };
-    defer p.buf.deinit(gpa);
-    defer p.errors.deinit(gpa);
-    defer p.dependencies.deinit(gpa);
-    defer p.paths.deinit(gpa);
-
-    p.parseRoot(main_node_index) catch |err| switch (err) {
-        error.ParseFailure => assert(p.errors.items.len > 0),
-        else => |e| return e,
-    };
-
-    return .{
-        .ast = ast,
-        .name = p.name,
-        .name_node = p.name_node,
-        .id = p.id,
-        .version = p.version,
-        .version_node = p.version_node,
-        .dependencies = try p.dependencies.clone(p.arena),
-        .dependencies_node = p.dependencies_node,
-        .paths = try p.paths.clone(p.arena),
-        .minimum_zig_version = p.minimum_zig_version,
-        .errors = try p.arena.dupe(ErrorMessage, p.errors.items),
-        .arena_state = arena_instance.state,
-    };
-}
-
-pub fn deinit(man: *Manifest, gpa: Allocator) void {
-    man.arena_state.promote(gpa).deinit();
-    man.* = undefined;
-}
-
-pub fn copyErrorsIntoBundle(
-    man: Manifest,
-    ast: Ast,
-    /// ErrorBundle null-terminated string index
-    src_path: u32,
-    eb: *std.zig.ErrorBundle.Wip,
-) Allocator.Error!void {
-    const token_starts = ast.tokens.items(.start);
-
-    for (man.errors) |msg| {
-        const start_loc = ast.tokenLocation(0, msg.tok);
-
-        try eb.addRootErrorMessage(.{
-            .msg = try eb.addString(msg.msg),
-            .src_loc = try eb.addSourceLocation(.{
-                .src_path = src_path,
-                .span_start = token_starts[msg.tok],
-                .span_end = @intCast(token_starts[msg.tok] + ast.tokenSlice(msg.tok).len),
-                .span_main = token_starts[msg.tok] + msg.off,
-                .line = @intCast(start_loc.line),
-                .column = @intCast(start_loc.column),
-                .source_line = try eb.addString(ast.source[start_loc.line_start..start_loc.line_end]),
-            }),
-        });
-    }
-}
-
-const Parse = struct {
-    gpa: Allocator,
-    ast: Ast,
-    arena: Allocator,
-    buf: std.ArrayListUnmanaged(u8),
-    errors: std.ArrayListUnmanaged(ErrorMessage),
-
-    name: []const u8,
-    name_node: Ast.Node.Index,
-    id: u32,
-    version: std.SemanticVersion,
-    version_node: Ast.Node.Index,
-    dependencies: std.StringArrayHashMapUnmanaged(Dependency),
-    dependencies_node: Ast.Node.Index,
-    paths: std.StringArrayHashMapUnmanaged(void),
-    allow_missing_paths_field: bool,
-    allow_name_string: bool,
-    allow_missing_fingerprint: bool,
-    minimum_zig_version: ?std.SemanticVersion,
-
-    const InnerError = error{ ParseFailure, OutOfMemory };
-
-    fn parseRoot(p: *Parse, node: Ast.Node.Index) !void {
-        const ast = p.ast;
-        const main_tokens = ast.nodes.items(.main_token);
-        const main_token = main_tokens[node];
-
-        var buf: [2]Ast.Node.Index = undefined;
-        const struct_init = ast.fullStructInit(&buf, node) orelse {
-            return fail(p, main_token, "expected top level expression to be a struct", .{});
-        };
-
-        var have_name = false;
-        var have_version = false;
-        var have_included_paths = false;
-        var fingerprint: ?Package.Fingerprint = null;
-
-        for (struct_init.ast.fields) |field_init| {
-            const name_token = ast.firstToken(field_init) - 2;
-            const field_name = try identifierTokenString(p, name_token);
-            // We could get fancy with reflection and comptime logic here but doing
-            // things manually provides an opportunity to do any additional verification
-            // that is desirable on a per-field basis.
-            if (mem.eql(u8, field_name, "dependencies")) {
-                p.dependencies_node = field_init;
-                try parseDependencies(p, field_init);
-            } else if (mem.eql(u8, field_name, "paths")) {
-                have_included_paths = true;
-                try parseIncludedPaths(p, field_init);
-            } else if (mem.eql(u8, field_name, "name")) {
-                p.name_node = field_init;
-                p.name = try parseName(p, field_init);
-                have_name = true;
-            } else if (mem.eql(u8, field_name, "fingerprint")) {
-                fingerprint = try parseFingerprint(p, field_init);
-            } else if (mem.eql(u8, field_name, "version")) {
-                p.version_node = field_init;
-                const version_text = try parseString(p, field_init);
-                if (version_text.len > max_version_len) {
-                    try appendError(p, main_tokens[field_init], "version string length {d} exceeds maximum of {d}", .{ version_text.len, max_version_len });
-                }
-                p.version = std.SemanticVersion.parse(version_text) catch |err| v: {
-                    try appendError(p, main_tokens[field_init], "unable to parse semantic version: {s}", .{@errorName(err)});
-                    break :v undefined;
-                };
-                have_version = true;
-            } else if (mem.eql(u8, field_name, "minimum_zig_version")) {
-                const version_text = try parseString(p, field_init);
-                p.minimum_zig_version = std.SemanticVersion.parse(version_text) catch |err| v: {
-                    try appendError(p, main_tokens[field_init], "unable to parse semantic version: {s}", .{@errorName(err)});
-                    break :v null;
-                };
-            } else {
-                // Ignore unknown fields so that we can add fields in future zig
-                // versions without breaking older zig versions.
-            }
-        }
-
-        if (!have_name) {
-            try appendError(p, main_token, "missing top-level 'name' field", .{});
-        } else {
-            if (fingerprint) |n| {
-                if (!n.validate(p.name)) {
-                    return fail(p, main_token, "invalid fingerprint: 0x{x}; if this is a new or forked package, use this value: 0x{x}", .{
-                        n.int(), Package.Fingerprint.generate(p.name).int(),
-                    });
-                }
-                p.id = n.id;
-            } else if (!p.allow_missing_fingerprint) {
-                try appendError(p, main_token, "missing top-level 'fingerprint' field; suggested value: 0x{x}", .{
-                    Package.Fingerprint.generate(p.name).int(),
-                });
-            } else {
-                p.id = 0;
-            }
-        }
-
-        if (!have_version) {
-            try appendError(p, main_token, "missing top-level 'version' field", .{});
-        }
-
-        if (!have_included_paths) {
-            if (p.allow_missing_paths_field) {
-                try p.paths.put(p.gpa, "", {});
-            } else {
-                try appendError(p, main_token, "missing top-level 'paths' field", .{});
-            }
-        }
-    }
-
-    fn parseDependencies(p: *Parse, node: Ast.Node.Index) !void {
-        const ast = p.ast;
-        const main_tokens = ast.nodes.items(.main_token);
-
-        var buf: [2]Ast.Node.Index = undefined;
-        const struct_init = ast.fullStructInit(&buf, node) orelse {
-            const tok = main_tokens[node];
-            return fail(p, tok, "expected dependencies expression to be a struct", .{});
-        };
-
-        for (struct_init.ast.fields) |field_init| {
-            const name_token = ast.firstToken(field_init) - 2;
-            const dep_name = try identifierTokenString(p, name_token);
-            const dep = try parseDependency(p, field_init);
-            try p.dependencies.put(p.gpa, dep_name, dep);
-        }
-    }
-
-    fn parseDependency(p: *Parse, node: Ast.Node.Index) !Dependency {
-        const ast = p.ast;
-        const main_tokens = ast.nodes.items(.main_token);
-
-        var buf: [2]Ast.Node.Index = undefined;
-        const struct_init = ast.fullStructInit(&buf, node) orelse {
-            const tok = main_tokens[node];
-            return fail(p, tok, "expected dependency expression to be a struct", .{});
-        };
-
-        var dep: Dependency = .{
-            .location = undefined,
-            .location_tok = 0,
-            .location_node = undefined,
-            .hash = null,
-            .hash_tok = 0,
-            .hash_node = undefined,
-            .node = node,
-            .name_tok = 0,
-            .lazy = false,
-        };
-        var has_location = false;
-
-        for (struct_init.ast.fields) |field_init| {
-            const name_token = ast.firstToken(field_init) - 2;
-            dep.name_tok = name_token;
-            const field_name = try identifierTokenString(p, name_token);
-            // We could get fancy with reflection and comptime logic here but doing
-            // things manually provides an opportunity to do any additional verification
-            // that is desirable on a per-field basis.
-            if (mem.eql(u8, field_name, "url")) {
-                if (has_location) {
-                    return fail(p, main_tokens[field_init], "dependency should specify only one of 'url' and 'path' fields.", .{});
-                }
-                dep.location = .{
-                    .url = parseString(p, field_init) catch |err| switch (err) {
-                        error.ParseFailure => continue,
-                        else => |e| return e,
-                    },
-                };
-                has_location = true;
-                dep.location_tok = main_tokens[field_init];
-                dep.location_node = field_init;
-            } else if (mem.eql(u8, field_name, "path")) {
-                if (has_location) {
-                    return fail(p, main_tokens[field_init], "dependency should specify only one of 'url' and 'path' fields.", .{});
-                }
-                dep.location = .{
-                    .path = parseString(p, field_init) catch |err| switch (err) {
-                        error.ParseFailure => continue,
-                        else => |e| return e,
-                    },
-                };
-                has_location = true;
-                dep.location_tok = main_tokens[field_init];
-                dep.location_node = field_init;
-            } else if (mem.eql(u8, field_name, "hash")) {
-                dep.hash = parseHash(p, field_init) catch |err| switch (err) {
-                    error.ParseFailure => continue,
-                    else => |e| return e,
-                };
-                dep.hash_tok = main_tokens[field_init];
-                dep.hash_node = field_init;
-            } else if (mem.eql(u8, field_name, "lazy")) {
-                dep.lazy = parseBool(p, field_init) catch |err| switch (err) {
-                    error.ParseFailure => continue,
-                    else => |e| return e,
-                };
-            } else {
-                // Ignore unknown fields so that we can add fields in future zig
-                // versions without breaking older zig versions.
-            }
-        }
-
-        if (!has_location) {
-            try appendError(p, main_tokens[node], "dependency requires location field, one of 'url' or 'path'.", .{});
-        }
-
-        return dep;
-    }
-
-    fn parseIncludedPaths(p: *Parse, node: Ast.Node.Index) !void {
-        const ast = p.ast;
-        const main_tokens = ast.nodes.items(.main_token);
-
-        var buf: [2]Ast.Node.Index = undefined;
-        const array_init = ast.fullArrayInit(&buf, node) orelse {
-            const tok = main_tokens[node];
-            return fail(p, tok, "expected paths expression to be a list of strings", .{});
-        };
-
-        for (array_init.ast.elements) |elem_node| {
-            const path_string = try parseString(p, elem_node);
-            // This is normalized so that it can be used in string comparisons
-            // against file system paths.
-            const normalized = try std.fs.path.resolve(p.arena, &.{path_string});
-            try p.paths.put(p.gpa, normalized, {});
-        }
-    }
-
-    fn parseBool(p: *Parse, node: Ast.Node.Index) !bool {
-        const ast = p.ast;
-        const node_tags = ast.nodes.items(.tag);
-        const main_tokens = ast.nodes.items(.main_token);
-        if (node_tags[node] != .identifier) {
-            return fail(p, main_tokens[node], "expected identifier", .{});
-        }
-        const ident_token = main_tokens[node];
-        const token_bytes = ast.tokenSlice(ident_token);
-        if (mem.eql(u8, token_bytes, "true")) {
-            return true;
-        } else if (mem.eql(u8, token_bytes, "false")) {
-            return false;
-        } else {
-            return fail(p, ident_token, "expected boolean", .{});
-        }
-    }
-
-    fn parseFingerprint(p: *Parse, node: Ast.Node.Index) !Package.Fingerprint {
-        const ast = p.ast;
-        const node_tags = ast.nodes.items(.tag);
-        const main_tokens = ast.nodes.items(.main_token);
-        const main_token = main_tokens[node];
-        if (node_tags[node] != .number_literal) {
-            return fail(p, main_token, "expected integer literal", .{});
-        }
-        const token_bytes = ast.tokenSlice(main_token);
-        const parsed = std.zig.parseNumberLiteral(token_bytes);
-        switch (parsed) {
-            .int => |n| return @bitCast(n),
-            .big_int, .float => return fail(p, main_token, "expected u64 integer literal, found {s}", .{
-                @tagName(parsed),
-            }),
-            .failure => |err| return fail(p, main_token, "bad integer literal: {s}", .{@tagName(err)}),
-        }
-    }
-
-    fn parseName(p: *Parse, node: Ast.Node.Index) ![]const u8 {
-        const ast = p.ast;
-        const node_tags = ast.nodes.items(.tag);
-        const main_tokens = ast.nodes.items(.main_token);
-        const main_token = main_tokens[node];
-
-        if (p.allow_name_string and node_tags[node] == .string_literal) {
-            const name = try parseString(p, node);
-            if (!std.zig.isValidId(name))
-                return fail(p, main_token, "name must be a valid bare zig identifier (hint: switch from string to enum literal)", .{});
-
-            if (name.len > max_name_len)
-                return fail(p, main_token, "name '{}' exceeds max length of {d}", .{
-                    std.zig.fmtId(name), max_name_len,
-                });
-
-            return name;
-        }
-
-        if (node_tags[node] != .enum_literal)
-            return fail(p, main_token, "expected enum literal", .{});
-
-        const ident_name = ast.tokenSlice(main_token);
-        if (mem.startsWith(u8, ident_name, "@"))
-            return fail(p, main_token, "name must be a valid bare zig identifier", .{});
-
-        if (ident_name.len > max_name_len)
-            return fail(p, main_token, "name '{}' exceeds max length of {d}", .{
-                std.zig.fmtId(ident_name), max_name_len,
-            });
-
-        return ident_name;
-    }
-
-    fn parseString(p: *Parse, node: Ast.Node.Index) ![]const u8 {
-        const ast = p.ast;
-        const node_tags = ast.nodes.items(.tag);
-        const main_tokens = ast.nodes.items(.main_token);
-        if (node_tags[node] != .string_literal) {
-            return fail(p, main_tokens[node], "expected string literal", .{});
-        }
-        const str_lit_token = main_tokens[node];
-        const token_bytes = ast.tokenSlice(str_lit_token);
-        p.buf.clearRetainingCapacity();
-        try parseStrLit(p, str_lit_token, &p.buf, token_bytes, 0);
-        const duped = try p.arena.dupe(u8, p.buf.items);
-        return duped;
-    }
-
-    fn parseHash(p: *Parse, node: Ast.Node.Index) ![]const u8 {
-        const ast = p.ast;
-        const main_tokens = ast.nodes.items(.main_token);
-        const tok = main_tokens[node];
-        const h = try parseString(p, node);
-
-        if (h.len > Package.Hash.max_len) {
-            return fail(p, tok, "hash length exceeds maximum: {d}", .{h.len});
-        }
-
-        return h;
-    }
-
-    /// TODO: try to DRY this with AstGen.identifierTokenString
-    fn identifierTokenString(p: *Parse, token: Ast.TokenIndex) InnerError![]const u8 {
-        const ast = p.ast;
-        const token_tags = ast.tokens.items(.tag);
-        assert(token_tags[token] == .identifier);
-        const ident_name = ast.tokenSlice(token);
-        if (!mem.startsWith(u8, ident_name, "@")) {
-            return ident_name;
-        }
-        p.buf.clearRetainingCapacity();
-        try parseStrLit(p, token, &p.buf, ident_name, 1);
-        const duped = try p.arena.dupe(u8, p.buf.items);
-        return duped;
-    }
-
-    /// TODO: try to DRY this with AstGen.parseStrLit
-    fn parseStrLit(
-        p: *Parse,
-        token: Ast.TokenIndex,
-        buf: *std.ArrayListUnmanaged(u8),
-        bytes: []const u8,
-        offset: u32,
-    ) InnerError!void {
-        const raw_string = bytes[offset..];
-        var buf_managed = buf.toManaged(p.gpa);
-        const result = std.zig.string_literal.parseWrite(buf_managed.writer(), raw_string);
-        buf.* = buf_managed.moveToUnmanaged();
-        switch (try result) {
-            .success => {},
-            .failure => |err| try p.appendStrLitError(err, token, bytes, offset),
-        }
-    }
-
-    /// TODO: try to DRY this with AstGen.failWithStrLitError
-    fn appendStrLitError(
-        p: *Parse,
-        err: std.zig.string_literal.Error,
-        token: Ast.TokenIndex,
-        bytes: []const u8,
-        offset: u32,
-    ) Allocator.Error!void {
-        const raw_string = bytes[offset..];
-        switch (err) {
-            .invalid_escape_character => |bad_index| {
-                try p.appendErrorOff(
-                    token,
-                    offset + @as(u32, @intCast(bad_index)),
-                    "invalid escape character: '{c}'",
-                    .{raw_string[bad_index]},
-                );
-            },
-            .expected_hex_digit => |bad_index| {
-                try p.appendErrorOff(
-                    token,
-                    offset + @as(u32, @intCast(bad_index)),
-                    "expected hex digit, found '{c}'",
-                    .{raw_string[bad_index]},
-                );
-            },
-            .empty_unicode_escape_sequence => |bad_index| {
-                try p.appendErrorOff(
-                    token,
-                    offset + @as(u32, @intCast(bad_index)),
-                    "empty unicode escape sequence",
-                    .{},
-                );
-            },
-            .expected_hex_digit_or_rbrace => |bad_index| {
-                try p.appendErrorOff(
-                    token,
-                    offset + @as(u32, @intCast(bad_index)),
-                    "expected hex digit or '}}', found '{c}'",
-                    .{raw_string[bad_index]},
-                );
-            },
-            .invalid_unicode_codepoint => |bad_index| {
-                try p.appendErrorOff(
-                    token,
-                    offset + @as(u32, @intCast(bad_index)),
-                    "unicode escape does not correspond to a valid unicode scalar value",
-                    .{},
-                );
-            },
-            .expected_lbrace => |bad_index| {
-                try p.appendErrorOff(
-                    token,
-                    offset + @as(u32, @intCast(bad_index)),
-                    "expected '{{', found '{c}",
-                    .{raw_string[bad_index]},
-                );
-            },
-            .expected_rbrace => |bad_index| {
-                try p.appendErrorOff(
-                    token,
-                    offset + @as(u32, @intCast(bad_index)),
-                    "expected '}}', found '{c}",
-                    .{raw_string[bad_index]},
-                );
-            },
-            .expected_single_quote => |bad_index| {
-                try p.appendErrorOff(
-                    token,
-                    offset + @as(u32, @intCast(bad_index)),
-                    "expected single quote ('), found '{c}",
-                    .{raw_string[bad_index]},
-                );
-            },
-            .invalid_character => |bad_index| {
-                try p.appendErrorOff(
-                    token,
-                    offset + @as(u32, @intCast(bad_index)),
-                    "invalid byte in string or character literal: '{c}'",
-                    .{raw_string[bad_index]},
-                );
-            },
-            .empty_char_literal => {
-                try p.appendErrorOff(token, offset, "empty character literal", .{});
-            },
-        }
-    }
-
-    fn fail(
-        p: *Parse,
-        tok: Ast.TokenIndex,
-        comptime fmt: []const u8,
-        args: anytype,
-    ) InnerError {
-        try appendError(p, tok, fmt, args);
-        return error.ParseFailure;
-    }
-
-    fn appendError(p: *Parse, tok: Ast.TokenIndex, comptime fmt: []const u8, args: anytype) !void {
-        return appendErrorOff(p, tok, 0, fmt, args);
-    }
-
-    fn appendErrorOff(
-        p: *Parse,
-        tok: Ast.TokenIndex,
-        byte_offset: u32,
-        comptime fmt: []const u8,
-        args: anytype,
-    ) Allocator.Error!void {
-        try p.errors.append(p.gpa, .{
-            .msg = try std.fmt.allocPrint(p.arena, fmt, args),
-            .tok = tok,
-            .off = byte_offset,
-        });
-    }
-};
-
-test "basic" {
-    const gpa = testing.allocator;
-
-    const example =
-        \\.{
-        \\    .name = "foo",
-        \\    .version = "3.2.1",
-        \\    .paths = .{""},
-        \\    .dependencies = .{
-        \\        .bar = .{
-        \\            .url = "https://example.com/baz.tar.gz",
-        \\            .hash = "1220f1b680b6065fcfc94fe777f22e73bcb7e2767e5f4d99d4255fe76ded69c7a35f",
-        \\        },
-        \\    },
-        \\}
-    ;
-
-    var ast = try Ast.parse(gpa, example, .zon);
-    defer ast.deinit(gpa);
-
-    try testing.expect(ast.errors.len == 0);
-
-    var manifest = try Manifest.parse(gpa, ast, .{});
-    defer manifest.deinit(gpa);
-
-    try testing.expect(manifest.errors.len == 0);
-    try testing.expectEqualStrings("foo", manifest.name);
-
-    try testing.expectEqual(@as(std.SemanticVersion, .{
-        .major = 3,
-        .minor = 2,
-        .patch = 1,
-    }), manifest.version);
-
-    try testing.expect(manifest.dependencies.count() == 1);
-    try testing.expectEqualStrings("bar", manifest.dependencies.keys()[0]);
-    try testing.expectEqualStrings(
-        "https://example.com/baz.tar.gz",
-        manifest.dependencies.values()[0].location.url,
-    );
-    try testing.expectEqualStrings(
-        "1220f1b680b6065fcfc94fe777f22e73bcb7e2767e5f4d99d4255fe76ded69c7a35f",
-        manifest.dependencies.values()[0].hash orelse return error.TestFailed,
-    );
-
-    try testing.expect(manifest.minimum_zig_version == null);
-}
-
-test "minimum_zig_version" {
-    const gpa = testing.allocator;
-
-    const example =
-        \\.{
-        \\    .name = "foo",
-        \\    .version = "3.2.1",
-        \\    .paths = .{""},
-        \\    .minimum_zig_version = "0.11.1",
-        \\}
-    ;
-
-    var ast = try Ast.parse(gpa, example, .zon);
-    defer ast.deinit(gpa);
-
-    try testing.expect(ast.errors.len == 0);
-
-    var manifest = try Manifest.parse(gpa, ast, .{});
-    defer manifest.deinit(gpa);
-
-    try testing.expect(manifest.errors.len == 0);
-    try testing.expect(manifest.dependencies.count() == 0);
-
-    try testing.expect(manifest.minimum_zig_version != null);
-
-    try testing.expectEqual(@as(std.SemanticVersion, .{
-        .major = 0,
-        .minor = 11,
-        .patch = 1,
-    }), manifest.minimum_zig_version.?);
-}
-
-test "minimum_zig_version - invalid version" {
-    const gpa = testing.allocator;
-
-    const example =
-        \\.{
-        \\    .name = "foo",
-        \\    .version = "3.2.1",
-        \\    .minimum_zig_version = "X.11.1",
-        \\    .paths = .{""},
-        \\}
-    ;
-
-    var ast = try Ast.parse(gpa, example, .zon);
-    defer ast.deinit(gpa);
-
-    try testing.expect(ast.errors.len == 0);
-
-    var manifest = try Manifest.parse(gpa, ast, .{});
-    defer manifest.deinit(gpa);
-
-    try testing.expect(manifest.errors.len == 1);
-    try testing.expect(manifest.dependencies.count() == 0);
-
-    try testing.expect(manifest.minimum_zig_version == null);
-}
diff --git a/src/Package.zig b/src/Package.zig
deleted file mode 100644
index ece4685..0000000
--- a/src/Package.zig
+++ /dev/null
@@ -1,192 +0,0 @@
-//! mostly copy-pasted from zig/src/Package.zig
-const std = @import("std");
-const assert = std.debug.assert;
-
-pub const multihash_len = 1 + 1 + Hash.Algo.digest_length;
-pub const multihash_hex_digest_len = 2 * multihash_len;
-pub const MultiHashHexDigest = [multihash_hex_digest_len]u8;
-
-pub const Fingerprint = packed struct(u64) {
-    id: u32,
-    checksum: u32,
-
-    pub fn generate(name: []const u8) Fingerprint {
-        return .{
-            .id = std.crypto.random.intRangeLessThan(u32, 1, 0xffffffff),
-            .checksum = std.hash.Crc32.hash(name),
-        };
-    }
-
-    pub fn validate(n: Fingerprint, name: []const u8) bool {
-        switch (n.id) {
-            0x00000000, 0xffffffff => return false,
-            else => return std.hash.Crc32.hash(name) == n.checksum,
-        }
-    }
-
-    pub fn int(n: Fingerprint) u64 {
-        return @bitCast(n);
-    }
-};
-
-/// A user-readable, file system safe hash that identifies an exact package
-/// snapshot, including file contents.
-///
-/// The hash is not only to prevent collisions but must resist attacks where
-/// the adversary fully controls the contents being hashed. Thus, it contains
-/// a full SHA-256 digest.
-///
-/// This data structure can be used to store the legacy hash format too. Legacy
-/// hash format is scheduled to be removed after 0.14.0 is tagged.
-///
-/// There's also a third way this structure is used. When using path rather than
-/// hash, a unique hash is still needed, so one is computed based on the path.
-pub const Hash = struct {
-    /// Maximum size of a package hash. Unused bytes at the end are
-    /// filled with zeroes.
-    bytes: [max_len]u8,
-
-    pub const Algo = std.crypto.hash.sha2.Sha256;
-    pub const Digest = [Algo.digest_length]u8;
-
-    /// Example: "nnnn-vvvv-hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"
-    pub const max_len = 32 + 1 + 32 + 1 + (32 + 32 + 200) / 6;
-
-    pub fn fromSlice(s: []const u8) Hash {
-        assert(s.len <= max_len);
-        var result: Hash = undefined;
-        @memcpy(result.bytes[0..s.len], s);
-        @memset(result.bytes[s.len..], 0);
-        return result;
-    }
-
-    pub fn toSlice(ph: *const Hash) []const u8 {
-        var end: usize = ph.bytes.len;
-        while (true) {
-            end -= 1;
-            if (ph.bytes[end] != 0) return ph.bytes[0 .. end + 1];
-        }
-    }
-
-    pub fn eql(a: *const Hash, b: *const Hash) bool {
-        return std.mem.eql(u8, &a.bytes, &b.bytes);
-    }
-
-    /// Distinguishes whether the legacy multihash format is being stored here.
-    pub fn isOld(h: *const Hash) bool {
-        if (h.bytes.len < 2) return false;
-        const their_multihash_func = std.fmt.parseInt(u8, h.bytes[0..2], 16) catch return false;
-        if (@as(MultihashFunction, @enumFromInt(their_multihash_func)) != multihash_function) return false;
-        if (h.toSlice().len != multihash_hex_digest_len) return false;
-        return std.mem.indexOfScalar(u8, &h.bytes, '-') == null;
-    }
-
-    test isOld {
-        const h: Hash = .fromSlice("1220138f4aba0c01e66b68ed9e1e1e74614c06e4743d88bc58af4f1c3dd0aae5fea7");
-        try std.testing.expect(h.isOld());
-    }
-
-    /// Produces "$name-$semver-$hashplus".
-    /// * name is the name field from build.zig.zon, asserted to be at most 32
-    ///   bytes and assumed be a valid zig identifier
-    /// * semver is the version field from build.zig.zon, asserted to be at
-    ///   most 32 bytes
-    /// * hashplus is the following 33-byte array, base64 encoded using -_ to make
-    ///   it filesystem safe:
-    ///   - (4 bytes) LE u32 Package ID
-    ///   - (4 bytes) LE u32 total decompressed size in bytes, overflow saturated
-    ///   - (25 bytes) truncated SHA-256 digest of hashed files of the package
-    pub fn init(digest: Digest, name: []const u8, ver: []const u8, id: u32, size: u32) Hash {
-        assert(name.len <= 32);
-        assert(ver.len <= 32);
-        var result: Hash = undefined;
-        var buf: std.ArrayListUnmanaged(u8) = .initBuffer(&result.bytes);
-        buf.appendSliceAssumeCapacity(name);
-        buf.appendAssumeCapacity('-');
-        buf.appendSliceAssumeCapacity(ver);
-        buf.appendAssumeCapacity('-');
-        var hashplus: [33]u8 = undefined;
-        std.mem.writeInt(u32, hashplus[0..4], id, .little);
-        std.mem.writeInt(u32, hashplus[4..8], size, .little);
-        hashplus[8..].* = digest[0..25].*;
-        _ = std.base64.url_safe_no_pad.Encoder.encode(buf.addManyAsArrayAssumeCapacity(44), &hashplus);
-        @memset(buf.unusedCapacitySlice(), 0);
-        return result;
-    }
-
-    /// Produces a unique hash based on the path provided. The result should
-    /// not be user-visible.
-    pub fn initPath(sub_path: []const u8, is_global: bool) Hash {
-        var result: Hash = .{ .bytes = @splat(0) };
-        var i: usize = 0;
-        if (is_global) {
-            result.bytes[0] = '/';
-            i += 1;
-        }
-        if (i + sub_path.len <= result.bytes.len) {
-            @memcpy(result.bytes[i..][0..sub_path.len], sub_path);
-            return result;
-        }
-        var bin_digest: [Algo.digest_length]u8 = undefined;
-        Algo.hash(sub_path, &bin_digest, .{});
-        _ = std.fmt.bufPrint(result.bytes[i..], "{}", .{std.fmt.fmtSliceHexLower(&bin_digest)}) catch unreachable;
-        return result;
-    }
-};
-
-pub const MultihashFunction = enum(u16) {
-    identity = 0x00,
-    sha1 = 0x11,
-    @"sha2-256" = 0x12,
-    @"sha2-512" = 0x13,
-    @"sha3-512" = 0x14,
-    @"sha3-384" = 0x15,
-    @"sha3-256" = 0x16,
-    @"sha3-224" = 0x17,
-    @"sha2-384" = 0x20,
-    @"sha2-256-trunc254-padded" = 0x1012,
-    @"sha2-224" = 0x1013,
-    @"sha2-512-224" = 0x1014,
-    @"sha2-512-256" = 0x1015,
-    @"blake2b-256" = 0xb220,
-    _,
-};
-
-pub const multihash_function: MultihashFunction = switch (Hash.Algo) {
-    std.crypto.hash.sha2.Sha256 => .@"sha2-256",
-    else => unreachable,
-};
-
-pub fn multiHashHexDigest(digest: Hash.Digest) MultiHashHexDigest {
-    const hex_charset = std.fmt.hex_charset;
-
-    var result: MultiHashHexDigest = undefined;
-
-    result[0] = hex_charset[@intFromEnum(multihash_function) >> 4];
-    result[1] = hex_charset[@intFromEnum(multihash_function) & 15];
-
-    result[2] = hex_charset[Hash.Algo.digest_length >> 4];
-    result[3] = hex_charset[Hash.Algo.digest_length & 15];
-
-    for (digest, 0..) |byte, i| {
-        result[4 + i * 2] = hex_charset[byte >> 4];
-        result[5 + i * 2] = hex_charset[byte & 15];
-    }
-    return result;
-}
-
-comptime {
-    // We avoid unnecessary uleb128 code in hexDigest by asserting here the
-    // values are small enough to be contained in the one-byte encoding.
-    assert(@intFromEnum(multihash_function) < 127);
-    assert(Hash.Algo.digest_length < 127);
-}
-
-test Hash {
-    const example_digest: Hash.Digest = .{
-        0xc7, 0xf5, 0x71, 0xb7, 0xb4, 0xe7, 0x6f, 0x3c, 0xdb, 0x87, 0x7a, 0x7f, 0xdd, 0xf9, 0x77, 0x87,
-        0x9d, 0xd3, 0x86, 0xfa, 0x73, 0x57, 0x9a, 0xf7, 0x9d, 0x1e, 0xdb, 0x8f, 0x3a, 0xd9, 0xbd, 0x9f,
-    };
-    const result: Hash = .init(example_digest, "nasm", "2.16.1-3", 0xcafebabe, 10 * 1024 * 1024);
-    try std.testing.expectEqualStrings("nasm-2.16.1-3-vrr-ygAAoADH9XG3tOdvPNuHen_d-XeHndOG-nNXmved", result.toSlice());
-}
diff --git a/src/ZigEnv.zig b/src/ZigEnv.zig
deleted file mode 100644
index 96e9fa5..0000000
--- a/src/ZigEnv.zig
+++ /dev/null
@@ -1,60 +0,0 @@
-//! Used to determine the current zig exe, version, and other information.
-//! Simply calls `zig env` and parses the output
-
-const std = @import("std");
-
-zig_exe: []const u8,
-lib_dir: []const u8,
-std_dir: []const u8,
-global_cache_dir: []const u8,
-version: []const u8,
-
-pub fn deinit(self: @This(), allocator: std.mem.Allocator) void {
-    allocator.free(self.zig_exe);
-    allocator.free(self.lib_dir);
-    allocator.free(self.std_dir);
-    allocator.free(self.global_cache_dir);
-    allocator.free(self.version);
-}
-
-/// Simply calls `zig env` and parses the output
-pub fn parse(allocator: std.mem.Allocator) !@This() {
-    var env_map = try std.process.getEnvMap(allocator);
-    defer env_map.deinit();
-
-    const result = try std.process.Child.run(.{
-        .allocator = allocator,
-        .argv = &[_][]const u8{ "zig", "env" },
-        .env_map = &env_map,
-    });
-    defer allocator.free(result.stdout);
-    defer allocator.free(result.stderr);
-
-    if (result.term != .Exited and result.term.Exited != 0) {
-        return error.UnexpectedExitCode;
-    }
-
-    const env = try std.json.parseFromSlice(@This(), allocator, result.stdout, .{ .ignore_unknown_fields = true });
-    defer env.deinit();
-
-    return .{
-        .zig_exe = try allocator.dupe(u8, env.value.zig_exe),
-        .lib_dir = try allocator.dupe(u8, env.value.lib_dir),
-        .std_dir = try allocator.dupe(u8, env.value.std_dir),
-        .global_cache_dir = try allocator.dupe(u8, env.value.global_cache_dir),
-        .version = try allocator.dupe(u8, env.value.version),
-    };
-}
-
-test "ZigEnv.parse" {
-    const allocator = std.testing.allocator;
-
-    const env = try parse(allocator);
-    defer env.deinit(allocator);
-
-    std.debug.print("{s}\n", .{env.zig_exe});
-    std.debug.print("{s}\n", .{env.lib_dir});
-    std.debug.print("{s}\n", .{env.std_dir});
-    std.debug.print("{s}\n", .{env.global_cache_dir});
-    std.debug.print("{s}\n", .{env.version});
-}
diff --git a/src/build_runner.zig b/src/build_runner.zig
new file mode 100644
index 0000000..3d6db83
--- /dev/null
+++ b/src/build_runner.zig
@@ -0,0 +1,3196 @@
+//! Configures a Zig build graph from a comptime ZON manifest.
+//!
+//! The manifest is obtained via @import("build.zig.zon") in the user's build.zig:
+//!
+//!     const zbuild = @import("zbuild");
+//!
+//!     pub fn build(b: *std.Build) !void {
+//!         _ = try zbuild.configureBuild(b, @import("build.zig.zon"), .{});
+//!     }
+
+const std = @import("std");
+
+pub const Options = struct {
+    /// Step name for the help command, or null to disable. Default: "help".
+    help_step: ?[]const u8 = "help",
+};
+
+pub fn configureBuild(b: *std.Build, comptime manifest: anytype, comptime opts: Options) !BuildResult {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    var runner = BuildRunner{
+        .b = b,
+        .target = target,
+        .optimize = optimize,
+        .result = .{
+            .executables = std.StringHashMap(*std.Build.Step.Compile).init(b.allocator),
+            .libraries = std.StringHashMap(*std.Build.Step.Compile).init(b.allocator),
+            .objects = std.StringHashMap(*std.Build.Step.Compile).init(b.allocator),
+            .tests = std.StringHashMap(*std.Build.Step.Compile).init(b.allocator),
+            .modules = std.StringHashMap(*std.Build.Module).init(b.allocator),
+            .dependencies = std.StringHashMap(*std.Build.Dependency).init(b.allocator),
+            .options_modules = std.StringHashMap(*std.Build.Module).init(b.allocator),
+            .runs = std.StringHashMap(*std.Build.Step.Run).init(b.allocator),
+            .fmts = std.StringHashMap(*std.Build.Step.Fmt).init(b.allocator),
+        },
+        .install_steps = std.StringHashMap(*std.Build.Step).init(b.allocator),
+        .inline_modules = std.StringHashMap(*std.Build.Module).init(b.allocator),
+        .manual_modules = std.StringHashMap(void).init(b.allocator),
+        .manual_steps = std.StringHashMap(void).init(b.allocator),
+        .active_preset = null,
+    };
+    defer runner.manual_modules.deinit();
+    defer runner.manual_steps.deinit();
+
+    try runner.snapshotPreexistingNamespaces();
+    comptime validateManifest(manifest, opts);
+    runner.active_preset = runner.resolveActivePreset(manifest);
+
+    // Phase 1: Resolve dependencies (comptime args forwarding)
+    //
+    // When a dependency declaration has no explicit `.args`, forward the
+    // parent's resolved `target` and `optimize` to the child build. Without
+    // this, `b.dependency(name, .{})` spawns child builds that fall back to
+    // host target + Debug optimize regardless of the parent's CLI flags,
+    // which breaks C-heavy deps: Debug's default `sanitize_c=.full` emits
+    // `__ubsan_handle_*` calls into the dep's object files, leaving
+    // unresolved symbols in the final link (and crashing at dlopen time
+    // for shared libraries like Node NAPI `.node` files).
+    //
+    // If the user supplies `.args`, they are passed through unchanged so
+    // the user can fully control dep build options (target, optimize, or
+    // dep-specific switches).
+    if (@hasField(@TypeOf(manifest), "dependencies")) {
+        inline for (@typeInfo(@TypeOf(manifest.dependencies)).@"struct".fields) |field| {
+            const decl = @field(manifest.dependencies, field.name);
+            const dep = if (@hasField(@TypeOf(decl), "args"))
+                b.dependency(field.name, decl.args)
+            else
+                b.dependency(field.name, .{
+                    .target = runner.target,
+                    .optimize = runner.optimize,
+                });
+            try runner.result.dependencies.put(field.name, dep);
+        }
+    }
+
+    if (runner.validateResolvedManifest(manifest)) return error.InvalidManifest;
+    if (try runner.validateNamespaceReservations(manifest, opts)) return error.InvalidManifest;
+
+    // Phase 2: Create options modules
+    if (@hasField(@TypeOf(manifest), "options_modules")) {
+        inline for (@typeInfo(@TypeOf(manifest.options_modules)).@"struct".fields) |field| {
+            try runner.createOptionsModule(manifest, field.name, @field(manifest.options_modules, field.name));
+        }
+    }
+
+    // Phase 3: Create named modules
+    if (@hasField(@TypeOf(manifest), "modules")) {
+        inline for (@typeInfo(@TypeOf(manifest.modules)).@"struct".fields) |field| {
+            const mod = @field(manifest.modules, field.name);
+            const m = try runner.createModule(mod, field.name, &runner.result.modules);
+            const is_private = @hasField(@TypeOf(mod), "private") and mod.private;
+            if (!is_private) {
+                try runner.registerPublicModule(field.name, m);
+            }
+        }
+    }
+
+    // Phase 4: Create executables
+    if (@hasField(@TypeOf(manifest), "executables")) {
+        inline for (@typeInfo(@TypeOf(manifest.executables)).@"struct".fields) |field| {
+            try runner.createExecutable(field.name, @field(manifest.executables, field.name));
+        }
+    }
+
+    // Phase 5: Create libraries
+    if (@hasField(@TypeOf(manifest), "libraries")) {
+        inline for (@typeInfo(@TypeOf(manifest.libraries)).@"struct".fields) |field| {
+            try runner.createLibrary(field.name, @field(manifest.libraries, field.name));
+        }
+    }
+
+    // Phase 6: Create objects
+    if (@hasField(@TypeOf(manifest), "objects")) {
+        inline for (@typeInfo(@TypeOf(manifest.objects)).@"struct".fields) |field| {
+            try runner.createObject(field.name, @field(manifest.objects, field.name));
+        }
+    }
+
+    // Phase 7: Create tests
+    if (@hasField(@TypeOf(manifest), "tests")) {
+        const tls_run_test = try runner.createTopLevelStep("test", "Run all tests");
+        inline for (@typeInfo(@TypeOf(manifest.tests)).@"struct".fields) |field| {
+            try runner.createTest(field.name, @field(manifest.tests, field.name), tls_run_test);
+        }
+    }
+
+    // Phase 8: Create fmts
+    if (@hasField(@TypeOf(manifest), "fmts")) {
+        const tls_run_fmt = try runner.createTopLevelStep("fmt", "Run all fmts");
+        inline for (@typeInfo(@TypeOf(manifest.fmts)).@"struct".fields) |field| {
+            try runner.createFmt(field.name, @field(manifest.fmts, field.name), tls_run_fmt);
+        }
+    }
+
+    // Phase 9: Create runs
+    if (@hasField(@TypeOf(manifest), "runs")) {
+        inline for (@typeInfo(@TypeOf(manifest.runs)).@"struct".fields) |field| {
+            try runner.createRun(field.name, @field(manifest.runs, field.name));
+        }
+    }
+
+    // Phase 10: Create aliases
+    if (@hasField(@TypeOf(manifest), "aliases")) {
+        inline for (@typeInfo(@TypeOf(manifest.aliases)).@"struct".fields) |field| {
+            try runner.createAlias(field.name, @field(manifest.aliases, field.name));
+        }
+    }
+
+    // Phase 11: Wire imports
+    try runner.wireAllImports(manifest);
+
+    // Phase 12: Add help step
+    if (opts.help_step) |step_name| {
+        const tls = try runner.createTopLevelStep(step_name, "Show project build information");
+        const help_step_impl = try b.allocator.create(std.Build.Step);
+        const S = struct {
+            fn make(step: *std.Build.Step, _: std.Build.Step.MakeOptions) anyerror!void {
+                var stdout_buffer: [256]u8 = undefined;
+                var stdout_writer = std.Io.File.stdout().writerStreaming(step.owner.graph.io, &stdout_buffer);
+                try stdout_writer.interface.writeAll(comptime help.buildHelpText(manifest));
+                try stdout_writer.interface.flush();
+            }
+        };
+        help_step_impl.* = std.Build.Step.init(.{
+            .id = .custom,
+            .name = "help",
+            .owner = b,
+            .makeFn = S.make,
+        });
+        tls.dependOn(help_step_impl);
+    }
+
+    // Phase 13: Wire depends_on
+    try runner.wireDependsOn(manifest, opts);
+
+    return runner.result;
+}
+
+// --- Manifest validation ---
+//
+// Cross-reference checks run at comptime for manifest-owned targets so typos in
+// local module names, dependency references, and artifact names become compile
+// errors. Manual build.zig modules and steps are validated during configure.
+
+fn validateManifest(comptime manifest: anytype, comptime opts: Options) void {
+    validateInlineModuleNames(manifest);
+    validateUniqueInstallableArtifactNames(manifest);
+
+    // Validate artifact sections: root_module refs, depends_on, and inline module imports
+    inline for (.{ "executables", "libraries", "objects", "tests" }) |section| {
+        if (@hasField(@TypeOf(manifest), section)) {
+            inline for (@typeInfo(@TypeOf(@field(manifest, section))).@"struct".fields) |field| {
+                const item = @field(@field(manifest, section), field.name);
+                validateArtifactSectionFields(section, field.name, item);
+                validateRootModuleRef(manifest, item.root_module, section, field.name);
+                validateArtifactFields(manifest, item, section, field.name);
+                if (@hasField(@TypeOf(item), "depends_on"))
+                    validateDependsOn(manifest, opts, item.depends_on, section, field.name);
+                if (isInlineRootModuleType(@TypeOf(item.root_module))) {
+                    validateModuleDefinition(manifest, item.root_module, section, field.name, true, false);
+                }
+            }
+        }
+    }
+
+    // Validate named module imports
+    if (@hasField(@TypeOf(manifest), "modules")) {
+        inline for (@typeInfo(@TypeOf(manifest.modules)).@"struct".fields) |field| {
+            validateModuleDefinition(manifest, @field(manifest.modules, field.name), "modules", field.name, false, true);
+        }
+    }
+
+    if (@hasField(@TypeOf(manifest), "fmts")) {
+        inline for (@typeInfo(@TypeOf(manifest.fmts)).@"struct".fields) |field| {
+            validateFmtFields(field.name, @field(manifest.fmts, field.name));
+        }
+    }
+
+    validateOptionsModules(manifest);
+    validatePresets(manifest);
+
+    // Validate runs: depends_on refs and stdin/stdin_file exclusion
+    if (@hasField(@TypeOf(manifest), "runs")) {
+        inline for (@typeInfo(@TypeOf(manifest.runs)).@"struct".fields) |field| {
+            const run = @field(manifest.runs, field.name);
+            if (@hasField(@TypeOf(run), "cmd")) {
+                validateRunFields(field.name, run);
+                if (@hasField(@TypeOf(run), "depends_on"))
+                    validateDependsOn(manifest, opts, run.depends_on, "runs", field.name);
+                if (@hasField(@TypeOf(run), "stdin") and @hasField(@TypeOf(run), "stdin_file"))
+                    @compileError("runs '" ++ field.name ++ "': stdin and stdin_file are mutually exclusive");
+                if (@hasField(@TypeOf(run), "cwd"))
+                    validateLazyPathSyntax(manifest, run.cwd, "runs", field.name, "cwd");
+                if (@hasField(@TypeOf(run), "stdin_file"))
+                    validateLazyPathSyntax(manifest, run.stdin_file, "runs", field.name, "stdin_file");
+            }
+        }
+    }
+
+    if (@hasField(@TypeOf(manifest), "aliases")) {
+        inline for (@typeInfo(@TypeOf(manifest.aliases)).@"struct".fields) |field| {
+            const alias = @field(manifest.aliases, field.name);
+            validateAliasFields(manifest, opts, field.name, alias);
+        }
+    }
+}
+
+fn validateArtifactSectionFields(comptime section: []const u8, comptime name: []const u8, comptime item: anytype) void {
+    inline for (@typeInfo(@TypeOf(item)).@"struct".fields) |field| {
+        if (!isKnownArtifactField(section, field.name)) {
+            @compileError(section ++ " '" ++ name ++ "': unknown field '" ++ field.name ++ "'");
+        }
+    }
+}
+
+const UpstreamFieldBinding = enum {
+    passthrough,
+    adapted,
+    ignored,
+};
+
+fn isKnownArtifactField(comptime section: []const u8, comptime field_name: []const u8) bool {
+    if (artifactOptionsFieldBinding(section, field_name)) |binding| {
+        return binding != .ignored;
+    }
+
+    if (comptime std.mem.eql(u8, field_name, "depends_on")) return true;
+
+    if ((comptime std.mem.eql(u8, section, "executables") or std.mem.eql(u8, section, "libraries")) and
+        comptime std.mem.eql(u8, field_name, "dest_sub_path"))
+    {
+        return true;
+    }
+
+    if ((comptime std.mem.eql(u8, section, "libraries") or std.mem.eql(u8, section, "tests")) and
+        comptime std.mem.eql(u8, field_name, "linker_allow_shlib_undefined"))
+    {
+        return true;
+    }
+
+    return false;
+}
+
+fn validateFmtFields(comptime name: []const u8, comptime fmt: anytype) void {
+    inline for (@typeInfo(@TypeOf(fmt)).@"struct".fields) |field| {
+        if (!std.mem.eql(u8, field.name, "paths") and
+            !std.mem.eql(u8, field.name, "exclude_paths") and
+            !std.mem.eql(u8, field.name, "check"))
+        {
+            @compileError("fmts '" ++ name ++ "': unknown field '" ++ field.name ++ "'");
+        }
+    }
+}
+
+fn validateRunFields(comptime name: []const u8, comptime run: anytype) void {
+    inline for (@typeInfo(@TypeOf(run)).@"struct".fields) |field| {
+        if (!std.mem.eql(u8, field.name, "cmd") and
+            !std.mem.eql(u8, field.name, "cwd") and
+            !std.mem.eql(u8, field.name, "env") and
+            !std.mem.eql(u8, field.name, "inherit_stdio") and
+            !std.mem.eql(u8, field.name, "stdin") and
+            !std.mem.eql(u8, field.name, "stdin_file") and
+            !std.mem.eql(u8, field.name, "depends_on"))
+        {
+            @compileError("runs '" ++ name ++ "': unknown field '" ++ field.name ++ "'");
+        }
+    }
+}
+
+fn validateAliasFields(comptime manifest: anytype, comptime opts: Options, comptime name: []const u8, comptime alias: anytype) void {
+    const Alias = @TypeOf(alias);
+    const alias_info = @typeInfo(Alias).@"struct";
+    if (alias_info.is_tuple) {
+        @compileError("aliases '" ++ name ++ "': expected a struct with depends_on and optional description");
+    }
+
+    if (!@hasField(Alias, "depends_on")) {
+        @compileError("aliases '" ++ name ++ "': missing required field 'depends_on'");
+    }
+
+    inline for (alias_info.fields) |field| {
+        if (!std.mem.eql(u8, field.name, "depends_on") and
+            !std.mem.eql(u8, field.name, "description"))
+        {
+            @compileError("aliases '" ++ name ++ "': unknown field '" ++ field.name ++ "'");
+        }
+    }
+
+    if (@typeInfo(@TypeOf(alias.depends_on)).@"struct".fields.len == 0) {
+        @compileError("aliases '" ++ name ++ "': depends_on must not be empty");
+    }
+
+    if (@hasField(Alias, "description")) {
+        const description: []const u8 = alias.description;
+        _ = description;
+    }
+
+    if (hasArtifact(manifest, name)) {
+        @compileError("aliases '" ++ name ++ "': alias name collides with artifact shorthand ." ++ name ++ "; choose a different alias name");
+    }
+
+    validateDependsOn(manifest, opts, alias.depends_on, "aliases", name);
+}
+
+fn validateInlineModuleNames(comptime manifest: anytype) void {
+    inline for (.{ "executables", "libraries", "objects", "tests" }) |section| {
+        if (!@hasField(@TypeOf(manifest), section)) continue;
+
+        const items = @field(manifest, section);
+        const item_fields = @typeInfo(@TypeOf(items)).@"struct".fields;
+        inline for (item_fields, 0..) |field, i| {
+            const item = @field(items, field.name);
+            if (!isInlineRootModuleType(@TypeOf(item.root_module))) continue;
+
+            const inline_name = inlineRootModuleName(field.name, item.root_module);
+            if (hasModule(manifest, inline_name)) {
+                @compileError(section ++ " '" ++ field.name ++ "': inline root_module name '" ++ inline_name ++ "' collides with named module '" ++ inline_name ++ "'");
+            }
+
+            inline for (item_fields[i + 1 ..]) |other_field| {
+                const other_item = @field(items, other_field.name);
+                if (!isInlineRootModuleType(@TypeOf(other_item.root_module))) continue;
+                const other_name = inlineRootModuleName(other_field.name, other_item.root_module);
+                if (comptime std.mem.eql(u8, inline_name, other_name)) {
+                    @compileError(section ++ " '" ++ field.name ++ "': inline root_module name '" ++ inline_name ++ "' collides with " ++ section ++ " '" ++ other_field.name ++ "'");
+                }
+            }
+
+            inline for (.{ "executables", "libraries", "objects", "tests" }) |other_section| {
+                if (comptime std.mem.eql(u8, section, other_section)) continue;
+                if (!@hasField(@TypeOf(manifest), other_section)) continue;
+
+                inline for (@typeInfo(@TypeOf(@field(manifest, other_section))).@"struct".fields) |other_field| {
+                    const other_item = @field(@field(manifest, other_section), other_field.name);
+                    if (!isInlineRootModuleType(@TypeOf(other_item.root_module))) continue;
+                    const other_name = inlineRootModuleName(other_field.name, other_item.root_module);
+                    if (comptime std.mem.eql(u8, inline_name, other_name)) {
+                        @compileError(section ++ " '" ++ field.name ++ "': inline root_module name '" ++ inline_name ++ "' collides with " ++ other_section ++ " '" ++ other_field.name ++ "'");
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn validateUniqueInstallableArtifactNames(comptime manifest: anytype) void {
+    const sections = .{ "executables", "libraries", "objects" };
+
+    inline for (sections, 0..) |section, i| {
+        if (!@hasField(@TypeOf(manifest), section)) continue;
+
+        const items = @field(manifest, section);
+        inline for (@typeInfo(@TypeOf(items)).@"struct".fields) |field| {
+            inline for (sections, 0..) |other_section, j| {
+                if (j <= i) continue;
+                if (!@hasField(@TypeOf(manifest), other_section)) continue;
+                if (@hasField(@TypeOf(@field(manifest, other_section)), field.name)) {
+                    @compileError(section ++ " '" ++ field.name ++ "': artifact name '" ++ field.name ++ "' collides with " ++ other_section ++ " '" ++ field.name ++ "'; installable artifact names must be unique because depends_on shorthand ." ++ field.name ++ " resolves to one artifact install step");
+                }
+            }
+        }
+    }
+}
+
+fn inlineRootModuleName(comptime artifact_name: []const u8, comptime root_module: anytype) []const u8 {
+    return if (@hasField(@TypeOf(root_module), "name")) root_module.name else artifact_name;
+}
+
+fn validateRootModuleRef(
+    comptime manifest: anytype,
+    comptime root_module: anytype,
+    comptime section: []const u8,
+    comptime name: []const u8,
+) void {
+    const ti = @typeInfo(@TypeOf(root_module));
+    if (ti == .@"struct") return; // inline module, nothing to cross-reference
+
+    const ref_name = if (ti == .enum_literal)
+        @tagName(root_module)
+    else if (ti == .pointer)
+        @as([]const u8, root_module)
+    else
+        @compileError("root_module must be a string, enum literal, or struct");
+
+    if (ti == .enum_literal) {
+        if (!hasModule(manifest, ref_name)) {
+            @compileError(section ++ " '" ++ name ++ "': root_module references unknown module '" ++ ref_name ++ "'");
+        }
+        return;
+    }
+
+    if (ref_name.len == 0) {
+        @compileError(section ++ " '" ++ name ++ "': root_module cannot reference an empty manual module name");
+    }
+    if (countSeparators(ref_name, ':') != 0) {
+        @compileError(section ++ " '" ++ name ++ "': root_module string refs are reserved for bare manual module names");
+    }
+    if (hasModule(manifest, ref_name)) {
+        @compileError(section ++ " '" ++ name ++ "': root_module string refs are reserved for manual modules; use ." ++ ref_name ++ " for zbuild modules");
+    }
+    if (hasOptionsModule(manifest, ref_name)) {
+        @compileError(section ++ " '" ++ name ++ "': root_module string refs are reserved for manual modules; options module '" ++ ref_name ++ "' is import-only and cannot be used as root_module");
+    }
+}
+
+fn validateDependsOn(
+    comptime manifest: anytype,
+    comptime opts: Options,
+    comptime deps: anytype,
+    comptime section: []const u8,
+    comptime name: []const u8,
+) void {
+    inline for (@typeInfo(@TypeOf(deps)).@"struct".fields) |field| {
+        const raw = @field(deps, field.name);
+        const ti = @typeInfo(@TypeOf(raw));
+        const dep_name = toComptimeString(raw);
+
+        if (ti == .enum_literal) {
+            if (!hasArtifact(manifest, dep_name)) {
+                @compileError(section ++ " '" ++ name ++ "': depends_on references unknown artifact '" ++ dep_name ++ "'");
+            }
+            continue;
+        }
+
+        if (ti != .pointer) {
+            @compileError(section ++ " '" ++ name ++ "': depends_on entries must be strings or enum literals");
+        }
+
+        if (dep_name.len == 0) {
+            @compileError(section ++ " '" ++ name ++ "': depends_on cannot contain an empty step reference");
+        }
+
+        if (countSeparators(dep_name, ':') == 0 and hasArtifact(manifest, dep_name)) {
+            @compileError(section ++ " '" ++ name ++ "': depends_on string refs are reserved for top-level steps; use ." ++ dep_name ++ " for artifact install steps");
+        }
+
+        if (isManifestStepRef(manifest, opts, dep_name)) {
+            continue; // manifest-owned top-level step
+        }
+
+        if (isReservedGeneratedStepName(manifest, opts, dep_name)) {
+            @compileError(section ++ " '" ++ name ++ "': depends_on references unknown step '" ++ dep_name ++ "'");
+        }
+    }
+}
+
+fn validateImports(
+    comptime manifest: anytype,
+    comptime imports: anytype,
+    comptime section: []const u8,
+    comptime name: []const u8,
+) void {
+    inline for (@typeInfo(@TypeOf(imports)).@"struct".fields) |field| {
+        const raw = @field(imports, field.name);
+        const ti = @typeInfo(@TypeOf(raw));
+        const import_name = toComptimeString(raw);
+
+        if (ti == .enum_literal) {
+            if (isImportable(manifest, import_name)) continue;
+            @compileError(section ++ " '" ++ name ++ "': import references unknown target '" ++ import_name ++ "'");
+        }
+
+        if (import_name.len == 0) {
+            @compileError(section ++ " '" ++ name ++ "': import references cannot be empty");
+        }
+
+        const separator_count = countSeparators(import_name, ':');
+        if (separator_count == 0) {
+            if (isImportable(manifest, import_name)) {
+                @compileError(section ++ " '" ++ name ++ "': import string refs are reserved for manual modules; use ." ++ import_name ++ " for zbuild modules, options modules, and dependency default modules");
+            }
+            continue;
+        }
+
+        if (separator_count != 1) {
+            @compileError(section ++ " '" ++ name ++ "': import references must be a bare manual module name or 'dependency:module'");
+        }
+
+        const dep_name = comptimeBaseName(import_name);
+        const mod_name = comptimeAfterSep(import_name);
+        if (!hasDependency(manifest, dep_name) or mod_name.len == 0) {
+            @compileError(section ++ " '" ++ name ++ "': import references unknown target '" ++ import_name ++ "'");
+        }
+    }
+}
+
+fn validateModuleDefinition(
+    comptime manifest: anytype,
+    comptime mod: anytype,
+    comptime section: []const u8,
+    comptime name: []const u8,
+    comptime allow_name: bool,
+    comptime allow_private: bool,
+) void {
+    validateModuleFields(mod, section, name, allow_name, allow_private);
+
+    const Mod = @TypeOf(mod);
+    if (@hasField(Mod, "imports"))
+        validateImports(manifest, mod.imports, section, name);
+    if (@hasField(Mod, "link_libraries"))
+        validateLinkLibraries(manifest, mod.link_libraries, section, name);
+    if (@hasField(Mod, "root_source_file"))
+        validateLazyPathSyntax(manifest, mod.root_source_file, section, name, "root_source_file");
+    if (@hasField(Mod, "target"))
+        validateTargetString(section, name, mod.target);
+    if (@hasField(Mod, "include_paths")) {
+        inline for (@typeInfo(@TypeOf(mod.include_paths)).@"struct".fields) |field| {
+            validateLazyPathSyntax(manifest, @field(mod.include_paths, field.name), section, name, "include_paths");
+        }
+    }
+}
+
+fn validateModuleFields(comptime mod: anytype, comptime section: []const u8, comptime name: []const u8, comptime allow_name: bool, comptime allow_private: bool) void {
+    inline for (@typeInfo(@TypeOf(mod)).@"struct".fields) |field| {
+        if (!isKnownModuleField(field.name, allow_name, allow_private)) {
+            const context = if (allow_name)
+                section ++ " '" ++ name ++ "' root_module"
+            else
+                section ++ " '" ++ name ++ "'";
+            @compileError(context ++ ": unknown field '" ++ field.name ++ "'");
+        }
+    }
+}
+
+fn isKnownModuleField(comptime field_name: []const u8, comptime allow_name: bool, comptime allow_private: bool) bool {
+    if (moduleCreateOptionsFieldBinding(field_name) != null) return true;
+    if (comptime std.mem.eql(u8, field_name, "link_libraries") or std.mem.eql(u8, field_name, "include_paths"))
+        return true;
+
+    if (allow_name and comptime std.mem.eql(u8, field_name, "name")) return true;
+    if (allow_private and comptime std.mem.eql(u8, field_name, "private")) return true;
+
+    return false;
+}
+
+fn hasStructField(comptime T: type, comptime field_name: []const u8) bool {
+    return @hasField(T, field_name);
+}
+
+fn moduleCreateOptionsFieldBinding(comptime field_name: []const u8) ?UpstreamFieldBinding {
+    if (!hasStructField(std.Build.Module.CreateOptions, field_name)) return null;
+
+    if (comptime std.mem.eql(u8, field_name, "root_source_file") or
+        std.mem.eql(u8, field_name, "imports") or
+        std.mem.eql(u8, field_name, "target") or
+        std.mem.eql(u8, field_name, "optimize"))
+    {
+        return .adapted;
+    }
+
+    return .passthrough;
+}
+
+fn executableOptionsFieldBinding(comptime field_name: []const u8) ?UpstreamFieldBinding {
+    if (!hasStructField(std.Build.ExecutableOptions, field_name)) return null;
+
+    if (comptime std.mem.eql(u8, field_name, "name")) return .ignored;
+    if (comptime std.mem.eql(u8, field_name, "root_module") or
+        std.mem.eql(u8, field_name, "version") or
+        std.mem.eql(u8, field_name, "zig_lib_dir") or
+        std.mem.eql(u8, field_name, "win32_manifest"))
+    {
+        return .adapted;
+    }
+
+    return .passthrough;
+}
+
+fn libraryOptionsFieldBinding(comptime field_name: []const u8) ?UpstreamFieldBinding {
+    if (!hasStructField(std.Build.LibraryOptions, field_name)) return null;
+
+    if (comptime std.mem.eql(u8, field_name, "name")) return .ignored;
+    if (comptime std.mem.eql(u8, field_name, "root_module") or
+        std.mem.eql(u8, field_name, "version") or
+        std.mem.eql(u8, field_name, "zig_lib_dir") or
+        std.mem.eql(u8, field_name, "win32_manifest") or
+        std.mem.eql(u8, field_name, "win32_module_definition"))
+    {
+        return .adapted;
+    }
+
+    return .passthrough;
+}
+
+fn objectOptionsFieldBinding(comptime field_name: []const u8) ?UpstreamFieldBinding {
+    if (!hasStructField(std.Build.ObjectOptions, field_name)) return null;
+
+    if (comptime std.mem.eql(u8, field_name, "name")) return .ignored;
+    if (comptime std.mem.eql(u8, field_name, "root_module") or
+        std.mem.eql(u8, field_name, "zig_lib_dir"))
+    {
+        return .adapted;
+    }
+
+    return .passthrough;
+}
+
+fn testOptionsFieldBinding(comptime field_name: []const u8) ?UpstreamFieldBinding {
+    if (!hasStructField(std.Build.TestOptions, field_name)) return null;
+
+    if (comptime std.mem.eql(u8, field_name, "name")) return .ignored;
+    if (comptime std.mem.eql(u8, field_name, "root_module") or
+        std.mem.eql(u8, field_name, "filters") or
+        std.mem.eql(u8, field_name, "test_runner") or
+        std.mem.eql(u8, field_name, "zig_lib_dir"))
+    {
+        return .adapted;
+    }
+
+    return .passthrough;
+}
+
+fn artifactOptionsFieldBinding(comptime section: []const u8, comptime field_name: []const u8) ?UpstreamFieldBinding {
+    if (comptime std.mem.eql(u8, section, "executables")) return executableOptionsFieldBinding(field_name);
+    if (comptime std.mem.eql(u8, section, "libraries")) return libraryOptionsFieldBinding(field_name);
+    if (comptime std.mem.eql(u8, section, "objects")) return objectOptionsFieldBinding(field_name);
+    if (comptime std.mem.eql(u8, section, "tests")) return testOptionsFieldBinding(field_name);
+    @compileError("unknown artifact section '" ++ section ++ "'");
+}
+
+fn copyModulePassthroughFields(comptime Mod: type, mod: Mod, opts: *std.Build.Module.CreateOptions) void {
+    inline for (@typeInfo(Mod).@"struct".fields) |field| {
+        if (comptime moduleCreateOptionsFieldBinding(field.name) == .passthrough) {
+            @field(opts.*, field.name) = @field(mod, field.name);
+        }
+    }
+}
+
+fn copyArtifactPassthroughFields(comptime section: []const u8, comptime Item: type, item: Item, opts: anytype) void {
+    inline for (@typeInfo(Item).@"struct".fields) |field| {
+        if (comptime artifactOptionsFieldBinding(section, field.name) == .passthrough) {
+            @field(opts.*, field.name) = @field(item, field.name);
+        }
+    }
+}
+
+fn assertModuleCreateOptionsCoverage() void {
+    inline for (@typeInfo(std.Build.Module.CreateOptions).@"struct".fields) |field| {
+        if (moduleCreateOptionsFieldBinding(field.name) == null) {
+            @compileError("unhandled std.Build.Module.CreateOptions field '" ++ field.name ++ "'");
+        }
+    }
+}
+
+fn assertExecutableOptionsCoverage() void {
+    inline for (@typeInfo(std.Build.ExecutableOptions).@"struct".fields) |field| {
+        if (executableOptionsFieldBinding(field.name) == null) {
+            @compileError("unhandled std.Build.ExecutableOptions field '" ++ field.name ++ "'");
+        }
+    }
+}
+
+fn assertLibraryOptionsCoverage() void {
+    inline for (@typeInfo(std.Build.LibraryOptions).@"struct".fields) |field| {
+        if (libraryOptionsFieldBinding(field.name) == null) {
+            @compileError("unhandled std.Build.LibraryOptions field '" ++ field.name ++ "'");
+        }
+    }
+}
+
+fn assertObjectOptionsCoverage() void {
+    inline for (@typeInfo(std.Build.ObjectOptions).@"struct".fields) |field| {
+        if (objectOptionsFieldBinding(field.name) == null) {
+            @compileError("unhandled std.Build.ObjectOptions field '" ++ field.name ++ "'");
+        }
+    }
+}
+
+fn assertTestOptionsCoverage() void {
+    inline for (@typeInfo(std.Build.TestOptions).@"struct".fields) |field| {
+        if (testOptionsFieldBinding(field.name) == null) {
+            @compileError("unhandled std.Build.TestOptions field '" ++ field.name ++ "'");
+        }
+    }
+}
+
+comptime {
+    assertModuleCreateOptionsCoverage();
+    assertExecutableOptionsCoverage();
+    assertLibraryOptionsCoverage();
+    assertObjectOptionsCoverage();
+    assertTestOptionsCoverage();
+}
+
+fn validateArtifactFields(
+    comptime manifest: anytype,
+    comptime item: anytype,
+    comptime section: []const u8,
+    comptime name: []const u8,
+) void {
+    const Item = @TypeOf(item);
+    if (@hasField(Item, "version"))
+        validateSemverString(section, name, item.version);
+    if (@hasField(Item, "zig_lib_dir"))
+        validateLazyPathSyntax(manifest, item.zig_lib_dir, section, name, "zig_lib_dir");
+    if (@hasField(Item, "win32_manifest"))
+        validateLazyPathSyntax(manifest, item.win32_manifest, section, name, "win32_manifest");
+    if (@hasField(Item, "win32_module_definition"))
+        validateLazyPathSyntax(manifest, item.win32_module_definition, section, name, "win32_module_definition");
+    if (@hasField(Item, "test_runner"))
+        validateTestRunner(manifest, section, name, item.test_runner);
+    if (@hasField(Item, "emit_object")) {
+        const emit_object_check: bool = item.emit_object;
+        _ = emit_object_check;
+    }
+}
+
+fn validateTestRunner(comptime manifest: anytype, comptime section: []const u8, comptime name: []const u8, comptime test_runner: anytype) void {
+    const Runner = @TypeOf(test_runner);
+    inline for (@typeInfo(Runner).@"struct".fields) |field| {
+        if (!std.mem.eql(u8, field.name, "path") and !std.mem.eql(u8, field.name, "mode")) {
+            @compileError(section ++ " '" ++ name ++ "': test_runner: unknown field '" ++ field.name ++ "'");
+        }
+    }
+
+    if (!@hasField(Runner, "path")) {
+        @compileError(section ++ " '" ++ name ++ "': test_runner is missing required field 'path'");
+    }
+    if (!@hasField(Runner, "mode")) {
+        @compileError(section ++ " '" ++ name ++ "': test_runner is missing required field 'mode'");
+    }
+
+    validateLazyPathSyntax(manifest, test_runner.path, section, name, "test_runner.path");
+    const mode_check: enum { simple, server } = test_runner.mode;
+    _ = mode_check;
+}
+
+fn validateSemverString(comptime section: []const u8, comptime name: []const u8, comptime version: []const u8) void {
+    _ = std.SemanticVersion.parse(version) catch |err| {
+        @compileError(section ++ " '" ++ name ++ "': invalid semantic version '" ++ version ++ "' (" ++ @errorName(err) ++ ")");
+    };
+}
+
+fn validateLinkLibraries(comptime manifest: anytype, comptime links: anytype, comptime section: []const u8, comptime name: []const u8) void {
+    inline for (@typeInfo(@TypeOf(links)).@"struct".fields) |field| {
+        const spec = toComptimeString(@field(links, field.name));
+        const dep_name = comptimeBaseName(spec);
+        const separator_count = comptime countSeparators(spec, ':');
+
+        if (separator_count > 1 or dep_name.len == 0 or (separator_count == 1 and comptimeAfterSep(spec).len == 0)) {
+            @compileError(section ++ " '" ++ name ++ "': link_libraries entry '" ++ spec ++ "' must be 'dep_name' or 'dep_name:artifact_name'");
+        }
+        if (!hasDependency(manifest, dep_name)) {
+            @compileError(section ++ " '" ++ name ++ "': link_libraries references unknown dependency '" ++ dep_name ++ "'");
+        }
+    }
+}
+
+fn validateLazyPathSyntax(comptime manifest: anytype, comptime path: []const u8, comptime section: []const u8, comptime name: []const u8, comptime field_name: []const u8) void {
+    const separator_count = comptime countSeparators(path, ':');
+    if (separator_count == 0) return;
+
+    const dep_name = comptimeBaseName(path);
+    if (!hasDependency(manifest, dep_name)) return;
+
+    if (separator_count > 2) {
+        @compileError(section ++ " '" ++ name ++ "': " ++ field_name ++ " path '" ++ path ++ "' must be 'dep:path' or 'dep:wf_name:path'");
+    }
+
+    const rest = comptimeAfterSep(path);
+    if (rest.len == 0) {
+        @compileError(section ++ " '" ++ name ++ "': " ++ field_name ++ " path '" ++ path ++ "' is missing the dependency export name");
+    }
+
+    if (separator_count == 2 and comptime std.mem.indexOfScalar(u8, rest, ':') == 0) {
+        @compileError(section ++ " '" ++ name ++ "': " ++ field_name ++ " path '" ++ path ++ "' is missing the WriteFiles name");
+    }
+
+    if (separator_count == 2 and comptime lastSegment(path).len == 0) {
+        @compileError(section ++ " '" ++ name ++ "': " ++ field_name ++ " path '" ++ path ++ "' is missing the generated sub-path");
+    }
+}
+
+fn validateTargetString(comptime section: []const u8, comptime name: []const u8, comptime target_str: []const u8) void {
+    if (std.mem.eql(u8, target_str, "native")) return;
+    _ = std.Target.Query.parse(.{ .arch_os_abi = target_str }) catch |err| {
+        @compileError(section ++ " '" ++ name ++ "': invalid target '" ++ target_str ++ "' (" ++ @errorName(err) ++ ")");
+    };
+}
+
+fn validateOptionsModules(comptime manifest: anytype) void {
+    if (!@hasField(@TypeOf(manifest), "options_modules")) return;
+
+    inline for (@typeInfo(@TypeOf(manifest.options_modules)).@"struct".fields) |module_field| {
+        validateOptionsModule(module_field.name, @field(manifest.options_modules, module_field.name));
+    }
+}
+
+fn validatePresets(comptime manifest: anytype) void {
+    if (!@hasField(@TypeOf(manifest), "presets")) return;
+
+    if (!@hasField(@TypeOf(manifest), "options_modules")) {
+        @compileError("presets requires options_modules");
+    }
+
+    const preset_fields = @typeInfo(@TypeOf(manifest.presets)).@"struct".fields;
+    if (preset_fields.len == 0) {
+        @compileError("presets must not be empty");
+    }
+
+    inline for (preset_fields) |preset_field| {
+        validatePreset(manifest, preset_field.name, @field(manifest.presets, preset_field.name));
+    }
+}
+
+fn validatePreset(comptime manifest: anytype, comptime preset_name: []const u8, comptime preset: anytype) void {
+    const Preset = @TypeOf(preset);
+    const preset_info = @typeInfo(Preset).@"struct";
+    if (preset_info.is_tuple) {
+        @compileError("presets '" ++ preset_name ++ "': expected a struct of options_modules overrides");
+    }
+
+    if (preset_info.fields.len == 0) {
+        @compileError("presets '" ++ preset_name ++ "': must override at least one options module");
+    }
+
+    inline for (preset_info.fields) |module_field| {
+        if (!hasOptionsModule(manifest, module_field.name)) {
+            @compileError("presets '" ++ preset_name ++ "': unknown options module '" ++ module_field.name ++ "'");
+        }
+        validatePresetModule(
+            manifest,
+            preset_name,
+            module_field.name,
+            @field(preset, module_field.name),
+        );
+    }
+}
+
+fn validatePresetModule(
+    comptime manifest: anytype,
+    comptime preset_name: []const u8,
+    comptime module_name: []const u8,
+    comptime overrides: anytype,
+) void {
+    const Overrides = @TypeOf(overrides);
+    const overrides_info = @typeInfo(Overrides).@"struct";
+    if (overrides_info.is_tuple) {
+        @compileError("presets '" ++ preset_name ++ "." ++ module_name ++ "': expected a struct of option overrides");
+    }
+
+    if (overrides_info.fields.len == 0) {
+        @compileError("presets '" ++ preset_name ++ "." ++ module_name ++ "': must override at least one option");
+    }
+
+    const options_module = @field(manifest.options_modules, module_name);
+    inline for (overrides_info.fields) |field| {
+        if (!@hasField(@TypeOf(options_module), field.name)) {
+            @compileError("presets '" ++ preset_name ++ "." ++ module_name ++ "': unknown option '" ++ field.name ++ "'");
+        }
+        validatePresetOptionOverride(
+            preset_name,
+            module_name,
+            field.name,
+            @field(options_module, field.name),
+            @field(overrides, field.name),
+        );
+    }
+}
+
+fn validatePresetOptionOverride(
+    comptime preset_name: []const u8,
+    comptime module_name: []const u8,
+    comptime option_name: []const u8,
+    comptime opt: anytype,
+    comptime value: anytype,
+) void {
+    const type_str = comptime optionTypeString(opt);
+    if (comptime std.mem.eql(u8, type_str, "bool")) {
+        const value_check: bool = value;
+        _ = value_check;
+    } else if (comptime std.mem.eql(u8, type_str, "string")) {
+        const value_check: []const u8 = value;
+        _ = value_check;
+    } else if (comptime std.mem.eql(u8, type_str, "list")) {
+        _ = comptime toStringSlice(value);
+    } else if (comptime std.mem.eql(u8, type_str, "enum")) {
+        validatePresetEnumChoice(preset_name, module_name, option_name, toComptimeString(value), enumOptionValues(opt));
+    } else if (comptime std.mem.eql(u8, type_str, "enum_list")) {
+        inline for (comptime toComptimeStringSlice(value)) |entry| {
+            validatePresetEnumChoice(preset_name, module_name, option_name, entry, enumOptionValues(opt));
+        }
+    } else if (comptime isIntType(type_str)) {
+        validateNumericValue(optionValueType(type_str), value, "preset override");
+    } else if (comptime isFloatType(type_str)) {
+        validateNumericValue(optionValueType(type_str), value, "preset override");
+    } else {
+        @compileError("presets '" ++ preset_name ++ "." ++ module_name ++ "." ++ option_name ++ "': unsupported option type '" ++ type_str ++ "'");
+    }
+}
+
+fn validatePresetEnumChoice(
+    comptime preset_name: []const u8,
+    comptime module_name: []const u8,
+    comptime option_name: []const u8,
+    comptime value: []const u8,
+    comptime allowed: []const []const u8,
+) void {
+    if (!comptime stringSliceContains(allowed, value)) {
+        @compileError("presets '" ++ preset_name ++ "." ++ module_name ++ "." ++ option_name ++ "': override value '" ++ value ++ "' is not present in the option's 'values'");
+    }
+}
+
+fn validateOptionsModule(comptime module_name: []const u8, comptime options: anytype) void {
+    const fields = @typeInfo(@TypeOf(options)).@"struct".fields;
+
+    inline for (fields) |field| {
+        validateOption(module_name, field.name, @field(options, field.name));
+    }
+
+    inline for (fields) |field| {
+        const opt = @field(options, field.name);
+        if (!comptime isEnumOptionType(optionTypeString(opt))) continue;
+
+        const type_name = comptime resolvedOptionTypeName(field.name, opt);
+        inline for (fields) |other_field| {
+            if (comptime std.mem.eql(u8, type_name, other_field.name)) {
+                @compileError("options_modules '" ++ module_name ++ "': generated type name '" ++ type_name ++ "' collides with option '" ++ other_field.name ++ "'");
+            }
+        }
+    }
+
+    inline for (fields, 0..) |field, i| {
+        const opt = @field(options, field.name);
+        if (!comptime isEnumOptionType(optionTypeString(opt))) continue;
+
+        const type_name = comptime resolvedOptionTypeName(field.name, opt);
+        const values = comptime enumOptionValues(opt);
+        inline for (fields[i + 1 ..]) |other_field| {
+            const other_opt = @field(options, other_field.name);
+            if (!comptime isEnumOptionType(optionTypeString(other_opt))) continue;
+            if (!comptime std.mem.eql(u8, type_name, resolvedOptionTypeName(other_field.name, other_opt))) continue;
+            if (!comptime stringSlicesEql(values, enumOptionValues(other_opt))) {
+                @compileError("options_modules '" ++ module_name ++ "': generated type name '" ++ type_name ++ "' is reused with different enum values");
+            }
+        }
+    }
+}
+
+fn validateOption(comptime module_name: []const u8, comptime option_name: []const u8, comptime opt: anytype) void {
+    const Opt = @TypeOf(opt);
+    inline for (@typeInfo(Opt).@"struct".fields) |field| {
+        if (!std.mem.eql(u8, field.name, "type") and
+            !std.mem.eql(u8, field.name, "default") and
+            !std.mem.eql(u8, field.name, "description") and
+            !std.mem.eql(u8, field.name, "values") and
+            !std.mem.eql(u8, field.name, "type_name"))
+        {
+            @compileError("options_modules '" ++ module_name ++ "." ++ option_name ++ "': unknown field '" ++ field.name ++ "'");
+        }
+    }
+
+    if (!@hasField(Opt, "type")) {
+        @compileError("options_modules '" ++ module_name ++ "." ++ option_name ++ "': missing required field 'type'");
+    }
+
+    const type_str = comptime optionTypeString(opt);
+    if (!comptime isSupportedOptionType(type_str)) {
+        @compileError("options_modules '" ++ module_name ++ "." ++ option_name ++ "': unsupported option type '" ++ type_str ++ "'");
+    }
+
+    if (@hasField(Opt, "description")) {
+        const description_check: []const u8 = opt.description;
+        _ = description_check;
+    }
+
+    if (comptime isEnumOptionType(type_str)) {
+        if (!@hasField(Opt, "values")) {
+            @compileError("options_modules '" ++ module_name ++ "." ++ option_name ++ "': enum options require a non-empty 'values' field");
+        }
+        _ = comptime enumOptionValues(opt);
+
+        if (@hasField(Opt, "type_name")) {
+            const type_name: []const u8 = opt.type_name;
+            if (!std.zig.isValidId(type_name) or std.zig.isPrimitive(type_name) or std.zig.isUnderscore(type_name)) {
+                @compileError("options_modules '" ++ module_name ++ "." ++ option_name ++ "': type_name '" ++ type_name ++ "' must be a valid non-primitive Zig identifier");
+            }
+        }
+    } else {
+        if (@hasField(Opt, "values")) {
+            @compileError("options_modules '" ++ module_name ++ "." ++ option_name ++ "': only enum options may declare 'values'");
+        }
+        if (@hasField(Opt, "type_name")) {
+            @compileError("options_modules '" ++ module_name ++ "." ++ option_name ++ "': only enum options may declare 'type_name'");
+        }
+    }
+
+    if (@hasField(Opt, "default")) {
+        validateOptionDefault(module_name, option_name, opt);
+    }
+}
+
+fn validateOptionDefault(comptime module_name: []const u8, comptime option_name: []const u8, comptime opt: anytype) void {
+    const type_str = comptime optionTypeString(opt);
+    if (comptime std.mem.eql(u8, type_str, "bool")) {
+        const default_check: bool = opt.default;
+        _ = default_check;
+    } else if (comptime std.mem.eql(u8, type_str, "string")) {
+        const default_check: []const u8 = opt.default;
+        _ = default_check;
+    } else if (comptime std.mem.eql(u8, type_str, "list")) {
+        _ = comptime toStringSlice(opt.default);
+    } else if (comptime std.mem.eql(u8, type_str, "enum")) {
+        validateEnumChoice(module_name, option_name, toComptimeString(opt.default), enumOptionValues(opt));
+    } else if (comptime std.mem.eql(u8, type_str, "enum_list")) {
+        inline for (comptime toComptimeStringSlice(opt.default)) |value| {
+            validateEnumChoice(module_name, option_name, value, enumOptionValues(opt));
+        }
+    } else if (comptime isIntType(type_str)) {
+        validateNumericValue(optionValueType(type_str), opt.default, "default");
+    } else if (comptime isFloatType(type_str)) {
+        validateNumericValue(optionValueType(type_str), opt.default, "default");
+    } else {
+        @compileError("options_modules '" ++ module_name ++ "." ++ option_name ++ "': unsupported option type '" ++ type_str ++ "'");
+    }
+}
+
+fn validateNumericValue(comptime T: type, comptime value: anytype, comptime source: []const u8) void {
+    switch (@typeInfo(@TypeOf(value))) {
+        .int, .comptime_int, .float, .comptime_float => {
+            const default_check: T = value;
+            _ = default_check;
+        },
+        else => @compileError("expected a numeric " ++ source ++ " value"),
+    }
+}
+
+fn validateEnumChoice(comptime module_name: []const u8, comptime option_name: []const u8, comptime value: []const u8, comptime allowed: []const []const u8) void {
+    if (!comptime stringSliceContains(allowed, value)) {
+        @compileError("options_modules '" ++ module_name ++ "." ++ option_name ++ "': default value '" ++ value ++ "' is not present in 'values'");
+    }
+}
+
+fn hasModule(comptime manifest: anytype, comptime name: []const u8) bool {
+    if (@hasField(@TypeOf(manifest), "modules")) {
+        if (@hasField(@TypeOf(manifest.modules), name)) return true;
+    }
+    return false;
+}
+
+fn hasArtifact(comptime manifest: anytype, comptime name: []const u8) bool {
+    inline for (.{ "executables", "libraries", "objects" }) |section| {
+        if (@hasField(@TypeOf(manifest), section)) {
+            if (@hasField(@TypeOf(@field(manifest, section)), name)) return true;
+        }
+    }
+    return false;
+}
+
+fn hasDependency(comptime manifest: anytype, comptime name: []const u8) bool {
+    if (@hasField(@TypeOf(manifest), "dependencies")) {
+        if (@hasField(@TypeOf(manifest.dependencies), name)) return true;
+    }
+    return false;
+}
+
+fn hasOptionsModule(comptime manifest: anytype, comptime name: []const u8) bool {
+    if (@hasField(@TypeOf(manifest), "options_modules")) {
+        if (@hasField(@TypeOf(manifest.options_modules), name)) return true;
+    }
+    return false;
+}
+
+fn hasAlias(comptime manifest: anytype, comptime name: []const u8) bool {
+    if (@hasField(@TypeOf(manifest), "aliases")) {
+        if (@hasField(@TypeOf(manifest.aliases), name)) return true;
+    }
+    return false;
+}
+
+fn structHasFieldNamed(comptime T: type, name: []const u8) bool {
+    inline for (@typeInfo(T).@"struct".fields) |field| {
+        if (std.mem.eql(u8, field.name, name)) return true;
+    }
+    return false;
+}
+
+fn isInlineRootModuleType(comptime T: type) bool {
+    return @typeInfo(T) == .@"struct";
+}
+
+fn hasStepTarget(comptime manifest: anytype, comptime step_ref: []const u8) bool {
+    if (comptime std.mem.startsWith(u8, step_ref, "build-exe:")) {
+        const target_name = comptimeAfterSep(step_ref);
+        if (@hasField(@TypeOf(manifest), "executables")) {
+            return structHasFieldNamed(@TypeOf(manifest.executables), target_name);
+        }
+        return false;
+    }
+    if (comptime std.mem.startsWith(u8, step_ref, "run:")) {
+        const target_name = comptimeAfterSep(step_ref);
+        if (@hasField(@TypeOf(manifest), "executables")) {
+            return structHasFieldNamed(@TypeOf(manifest.executables), target_name);
+        }
+        return false;
+    }
+    if (comptime std.mem.startsWith(u8, step_ref, "build-lib:")) {
+        const target_name = comptimeAfterSep(step_ref);
+        if (@hasField(@TypeOf(manifest), "libraries")) {
+            return structHasFieldNamed(@TypeOf(manifest.libraries), target_name);
+        }
+        return false;
+    }
+    if (comptime std.mem.startsWith(u8, step_ref, "build-obj:")) {
+        const target_name = comptimeAfterSep(step_ref);
+        if (@hasField(@TypeOf(manifest), "objects")) {
+            return structHasFieldNamed(@TypeOf(manifest.objects), target_name);
+        }
+        return false;
+    }
+    if (comptime std.mem.startsWith(u8, step_ref, "build-test:")) {
+        const target_name = comptimeAfterSep(step_ref);
+        if (@hasField(@TypeOf(manifest), "tests")) {
+            return structHasFieldNamed(@TypeOf(manifest.tests), target_name);
+        }
+        return false;
+    }
+    if (comptime std.mem.startsWith(u8, step_ref, "test:")) {
+        const target_name = comptimeAfterSep(step_ref);
+        if (@hasField(@TypeOf(manifest), "tests")) {
+            return structHasFieldNamed(@TypeOf(manifest.tests), target_name);
+        }
+        return false;
+    }
+    if (comptime std.mem.startsWith(u8, step_ref, "cmd:")) {
+        const target_name = comptimeAfterSep(step_ref);
+        if (@hasField(@TypeOf(manifest), "runs")) {
+            return structHasFieldNamed(@TypeOf(manifest.runs), target_name);
+        }
+        return false;
+    }
+    if (comptime std.mem.startsWith(u8, step_ref, "fmt:")) {
+        const target_name = comptimeAfterSep(step_ref);
+        if (@hasField(@TypeOf(manifest), "fmts")) {
+            return structHasFieldNamed(@TypeOf(manifest.fmts), target_name);
+        }
+        return false;
+    }
+    return false;
+}
+
+fn isAggregateStepRef(comptime manifest: anytype, comptime opts: Options, comptime step_ref: []const u8) bool {
+    if (comptime std.mem.eql(u8, step_ref, "test")) return @hasField(@TypeOf(manifest), "tests");
+    if (comptime std.mem.eql(u8, step_ref, "fmt")) return @hasField(@TypeOf(manifest), "fmts");
+    if (opts.help_step) |help_step| {
+        if (comptime std.mem.eql(u8, step_ref, help_step)) return true;
+    }
+    return false;
+}
+
+fn hasReservedGeneratedStepPrefix(comptime step_ref: []const u8) bool {
+    inline for (.{ "build-exe:", "build-lib:", "build-obj:", "build-test:", "run:", "test:", "cmd:", "fmt:" }) |prefix| {
+        if (comptime std.mem.startsWith(u8, step_ref, prefix)) return true;
+    }
+    return false;
+}
+
+fn isReservedGeneratedStepName(comptime manifest: anytype, comptime opts: Options, comptime step_ref: []const u8) bool {
+    if (isAggregateStepRef(manifest, opts, step_ref)) return true;
+    return hasReservedGeneratedStepPrefix(step_ref);
+}
+
+fn isManifestStepRef(comptime manifest: anytype, comptime opts: Options, comptime step_ref: []const u8) bool {
+    return hasStepTarget(manifest, step_ref) or isAggregateStepRef(manifest, opts, step_ref) or hasAlias(manifest, step_ref);
+}
+
+fn isImportable(comptime manifest: anytype, comptime name: []const u8) bool {
+    if (hasModule(manifest, name)) return true;
+    if (hasOptionsModule(manifest, name)) return true;
+    if (hasDependency(manifest, comptimeBaseName(name))) {
+        const separator_count = countSeparators(name, ':');
+        if (separator_count == 0) return true;
+        if (separator_count == 1) return comptimeAfterSep(name).len != 0;
+    }
+    return false;
+}
+
+fn comptimeBaseName(comptime name: []const u8) []const u8 {
+    for (name, 0..) |c, i| {
+        if (c == ':') return name[0..i];
+    }
+    return name;
+}
+
+fn comptimeAfterSep(comptime name: []const u8) []const u8 {
+    for (name, 0..) |c, i| {
+        if (c == ':') return name[i + 1 ..];
+    }
+    return name;
+}
+
+fn lastSegment(comptime name: []const u8) []const u8 {
+    var start: usize = 0;
+    for (name, 0..) |c, i| {
+        if (c == ':') start = i + 1;
+    }
+    return name[start..];
+}
+
+fn countSeparators(name: []const u8, separator: u8) usize {
+    var count: usize = 0;
+    for (name) |c| {
+        if (c == separator) count += 1;
+    }
+    return count;
+}
+
+pub fn toComptimeString(comptime val: anytype) []const u8 {
+    const ti = @typeInfo(@TypeOf(val));
+    if (ti == .enum_literal) return @tagName(val);
+    if (ti == .pointer) return val;
+    @compileError("expected string or enum literal");
+}
+
+const help = @import("help.zig");
+
+// --- BuildResult ---
+
+pub const BuildResult = struct {
+    executables: std.StringHashMap(*std.Build.Step.Compile),
+    libraries: std.StringHashMap(*std.Build.Step.Compile),
+    objects: std.StringHashMap(*std.Build.Step.Compile),
+    tests: std.StringHashMap(*std.Build.Step.Compile),
+    modules: std.StringHashMap(*std.Build.Module),
+    dependencies: std.StringHashMap(*std.Build.Dependency),
+    options_modules: std.StringHashMap(*std.Build.Module),
+    runs: std.StringHashMap(*std.Build.Step.Run),
+    fmts: std.StringHashMap(*std.Build.Step.Fmt),
+
+    pub fn executable(self: BuildResult, name: []const u8) ?*std.Build.Step.Compile {
+        return self.executables.get(name);
+    }
+    pub fn library(self: BuildResult, name: []const u8) ?*std.Build.Step.Compile {
+        return self.libraries.get(name);
+    }
+    pub fn object(self: BuildResult, name: []const u8) ?*std.Build.Step.Compile {
+        return self.objects.get(name);
+    }
+    pub fn testArtifact(self: BuildResult, name: []const u8) ?*std.Build.Step.Compile {
+        return self.tests.get(name);
+    }
+    pub fn module(self: BuildResult, name: []const u8) ?*std.Build.Module {
+        return self.modules.get(name);
+    }
+    pub fn dependency(self: BuildResult, name: []const u8) ?*std.Build.Dependency {
+        return self.dependencies.get(name);
+    }
+    pub fn optionsModule(self: BuildResult, name: []const u8) ?*std.Build.Module {
+        return self.options_modules.get(name);
+    }
+    pub fn run(self: BuildResult, name: []const u8) ?*std.Build.Step.Run {
+        return self.runs.get(name);
+    }
+    pub fn fmt(self: BuildResult, name: []const u8) ?*std.Build.Step.Fmt {
+        return self.fmts.get(name);
+    }
+};
+
+// --- BuildRunner ---
+
+const BuildRunner = struct {
+    b: *std.Build,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+    result: BuildResult,
+    install_steps: std.StringHashMap(*std.Build.Step), // internal: depends_on wiring
+    inline_modules: std.StringHashMap(*std.Build.Module), // internal: inline root modules only
+    manual_modules: std.StringHashMap(void),
+    manual_steps: std.StringHashMap(void),
+    active_preset: ?[]const u8,
+
+    const Error = error{ OutOfMemory, ModuleNotFound, NameCollision };
+    const DependencyArtifactLookup = union(enum) {
+        missing,
+        ambiguous,
+        found: *std.Build.Step.Compile,
+    };
+
+    fn snapshotPreexistingNamespaces(self: *BuildRunner) !void {
+        var module_it = self.b.modules.iterator();
+        while (module_it.next()) |entry| {
+            try self.manual_modules.put(entry.key_ptr.*, {});
+        }
+
+        var step_it = self.b.top_level_steps.iterator();
+        while (step_it.next()) |entry| {
+            try self.manual_steps.put(entry.key_ptr.*, {});
+        }
+    }
+
+    fn resolveActivePreset(self: *BuildRunner, comptime manifest: anytype) ?[]const u8 {
+        if (!@hasField(@TypeOf(manifest), "presets")) return null;
+
+        const selected = self.b.option([]const u8, "preset", "Named preset used to override options_modules defaults") orelse
+            return null;
+
+        inline for (@typeInfo(@TypeOf(manifest.presets)).@"struct".fields) |field| {
+            if (std.mem.eql(u8, selected, field.name)) return selected;
+        }
+
+        self.logInvalidPresetName(selected, manifest);
+        return null;
+    }
+
+    fn logInvalidPresetName(self: *BuildRunner, actual: []const u8, comptime manifest: anytype) void {
+        var expected: std.ArrayList(u8) = .empty;
+        defer expected.deinit(self.b.allocator);
+
+        inline for (@typeInfo(@TypeOf(manifest.presets)).@"struct".fields, 0..) |field, i| {
+            if (i > 0) expected.appendSlice(self.b.allocator, ", ") catch @panic("OOM");
+            expected.appendSlice(self.b.allocator, field.name) catch @panic("OOM");
+        }
+
+        std.log.err("invalid value for -Dpreset: '{s}' (expected one of: {s})", .{
+            actual,
+            expected.items,
+        });
+        self.b.invalid_user_input = true;
+    }
+
+    fn validateResolvedManifest(self: *BuildRunner, comptime manifest: anytype) bool {
+        var failed = false;
+
+        if (@hasField(@TypeOf(manifest), "modules")) {
+            inline for (@typeInfo(@TypeOf(manifest.modules)).@"struct".fields) |field| {
+                failed = self.validateResolvedModuleDefinition(manifest, "modules", field.name, @field(manifest.modules, field.name)) or failed;
+            }
+        }
+
+        inline for (.{ "executables", "libraries", "objects", "tests" }) |section| {
+            if (@hasField(@TypeOf(manifest), section)) {
+                inline for (@typeInfo(@TypeOf(@field(manifest, section))).@"struct".fields) |field| {
+                    const item = @field(@field(manifest, section), field.name);
+                    failed = self.validateResolvedArtifactFields(section, field.name, item) or failed;
+                    if (comptime isInlineRootModuleType(@TypeOf(item.root_module))) {
+                        failed = self.validateResolvedModuleDefinition(manifest, section, field.name, item.root_module) or failed;
+                    }
+                }
+            }
+        }
+
+        if (@hasField(@TypeOf(manifest), "runs")) {
+            inline for (@typeInfo(@TypeOf(manifest.runs)).@"struct".fields) |field| {
+                const run = @field(manifest.runs, field.name);
+                if (@hasField(@TypeOf(run), "cmd")) {
+                    if (@hasField(@TypeOf(run), "cwd"))
+                        failed = self.validateResolvedLazyPath(run.cwd, "runs", field.name, "cwd") or failed;
+                    if (@hasField(@TypeOf(run), "stdin_file"))
+                        failed = self.validateResolvedLazyPath(run.stdin_file, "runs", field.name, "stdin_file") or failed;
+                }
+            }
+        }
+
+        return failed;
+    }
+
+    fn validateNamespaceReservations(self: *BuildRunner, comptime manifest: anytype, comptime opts: Options) !bool {
+        var failed = false;
+        var reserved_imports = std.StringHashMap([]const u8).init(self.b.allocator);
+        defer reserved_imports.deinit();
+        var reserved_steps = std.StringHashMap([]const u8).init(self.b.allocator);
+        defer reserved_steps.deinit();
+
+        if (@hasField(@TypeOf(manifest), "modules")) {
+            inline for (@typeInfo(@TypeOf(manifest.modules)).@"struct".fields) |field| {
+                const mod = @field(manifest.modules, field.name);
+                const is_private = @hasField(@TypeOf(mod), "private") and mod.private;
+                failed = try self.reserveOwnedImportName(
+                    &reserved_imports,
+                    field.name,
+                    if (is_private) "private named module" else "named module",
+                ) or failed;
+                if (!is_private) {
+                    failed = try self.ensurePublicModuleNameAvailable(field.name, "named module") or failed;
+                }
+            }
+        }
+
+        if (@hasField(@TypeOf(manifest), "options_modules")) {
+            inline for (@typeInfo(@TypeOf(manifest.options_modules)).@"struct".fields) |field| {
+                failed = try self.reserveOwnedImportName(&reserved_imports, field.name, "options module") or failed;
+            }
+        }
+
+        if (@hasField(@TypeOf(manifest), "dependencies")) {
+            inline for (@typeInfo(@TypeOf(manifest.dependencies)).@"struct".fields) |field| {
+                if (self.result.dependencies.get(field.name)) |dep| {
+                    if (dep.builder.modules.get(field.name) != null) {
+                        failed = try self.reserveOwnedImportName(&reserved_imports, field.name, "dependency default module") or failed;
+                    }
+                }
+            }
+        }
+
+        inline for (.{ "executables", "libraries", "objects" }) |section| {
+            if (!@hasField(@TypeOf(manifest), section)) continue;
+            inline for (@typeInfo(@TypeOf(@field(manifest, section))).@"struct".fields) |field| {
+                const prefix = switch (section[0]) {
+                    'e' => "build-exe:",
+                    'l' => "build-lib:",
+                    'o' => "build-obj:",
+                    else => unreachable,
+                };
+                failed = try self.reserveTopLevelStepName(
+                    &reserved_steps,
+                    self.b.fmt(prefix ++ "{s}", .{field.name}),
+                    section ++ " install step",
+                ) or failed;
+                if (comptime std.mem.eql(u8, section, "executables")) {
+                    failed = try self.reserveTopLevelStepName(
+                        &reserved_steps,
+                        self.b.fmt("run:{s}", .{field.name}),
+                        "executable run step",
+                    ) or failed;
+                }
+            }
+        }
+
+        if (@hasField(@TypeOf(manifest), "tests")) {
+            failed = try self.reserveTopLevelStepName(&reserved_steps, "test", "test aggregate step") or failed;
+            inline for (@typeInfo(@TypeOf(manifest.tests)).@"struct".fields) |field| {
+                failed = try self.reserveTopLevelStepName(
+                    &reserved_steps,
+                    self.b.fmt("build-test:{s}", .{field.name}),
+                    "test install step",
+                ) or failed;
+                failed = try self.reserveTopLevelStepName(
+                    &reserved_steps,
+                    self.b.fmt("test:{s}", .{field.name}),
+                    "test run step",
+                ) or failed;
+            }
+        }
+
+        if (@hasField(@TypeOf(manifest), "fmts")) {
+            failed = try self.reserveTopLevelStepName(&reserved_steps, "fmt", "fmt aggregate step") or failed;
+            inline for (@typeInfo(@TypeOf(manifest.fmts)).@"struct".fields) |field| {
+                failed = try self.reserveTopLevelStepName(
+                    &reserved_steps,
+                    self.b.fmt("fmt:{s}", .{field.name}),
+                    "fmt step",
+                ) or failed;
+            }
+        }
+
+        if (@hasField(@TypeOf(manifest), "runs")) {
+            inline for (@typeInfo(@TypeOf(manifest.runs)).@"struct".fields) |field| {
+                failed = try self.reserveTopLevelStepName(
+                    &reserved_steps,
+                    self.b.fmt("cmd:{s}", .{field.name}),
+                    "run command step",
+                ) or failed;
+            }
+        }
+
+        if (@hasField(@TypeOf(manifest), "aliases")) {
+            inline for (@typeInfo(@TypeOf(manifest.aliases)).@"struct".fields) |field| {
+                failed = try self.reserveTopLevelStepName(
+                    &reserved_steps,
+                    field.name,
+                    "alias step",
+                ) or failed;
+            }
+        }
+
+        if (opts.help_step) |step_name| {
+            failed = try self.reserveTopLevelStepName(&reserved_steps, step_name, "help step") or failed;
+        }
+
+        return failed;
+    }
+
+    fn reserveOwnedImportName(
+        self: *BuildRunner,
+        reserved: *std.StringHashMap([]const u8),
+        name: []const u8,
+        origin: []const u8,
+    ) !bool {
+        const gop = try reserved.getOrPut(name);
+        if (gop.found_existing) {
+            self.invalidateManifest("{s} '{s}' collides with another zbuild-owned import name ({s})", .{
+                origin,
+                name,
+                gop.value_ptr.*,
+            });
+            return true;
+        }
+        gop.value_ptr.* = origin;
+
+        return false;
+    }
+
+    fn ensurePublicModuleNameAvailable(self: *BuildRunner, name: []const u8, origin: []const u8) !bool {
+        if (self.b.modules.get(name) != null) {
+            self.invalidateManifest("{s} '{s}' collides with an existing module registered before configureBuild", .{
+                origin,
+                name,
+            });
+            return true;
+        }
+
+        return false;
+    }
+
+    fn reserveTopLevelStepName(
+        self: *BuildRunner,
+        reserved: *std.StringHashMap([]const u8),
+        name: []const u8,
+        origin: []const u8,
+    ) !bool {
+        const gop = try reserved.getOrPut(name);
+        if (gop.found_existing) {
+            self.invalidateManifest("{s} '{s}' collides with another zbuild-generated step ({s})", .{
+                origin,
+                name,
+                gop.value_ptr.*,
+            });
+            return true;
+        }
+        gop.value_ptr.* = origin;
+
+        if (self.b.top_level_steps.get(name) != null) {
+            self.invalidateManifest("{s} '{s}' collides with an existing top-level step registered before configureBuild", .{
+                origin,
+                name,
+            });
+            return true;
+        }
+
+        return false;
+    }
+
+    fn registerPublicModule(self: *BuildRunner, name: []const u8, module: *std.Build.Module) Error!void {
+        if (self.b.modules.get(name) != null) {
+            self.invalidateManifest("named module '{s}' collides with an existing module registered before configureBuild", .{name});
+            return error.NameCollision;
+        }
+        try self.b.modules.put(self.b.graph.arena, self.b.dupe(name), module);
+    }
+
+    fn createTopLevelStep(self: *BuildRunner, name: []const u8, description: []const u8) Error!*std.Build.Step {
+        if (self.b.top_level_steps.get(name) != null) {
+            self.invalidateManifest("top-level step '{s}' collides with an existing step named '{s}'", .{ name, name });
+            return error.NameCollision;
+        }
+        return self.b.step(name, description);
+    }
+
+    fn validateResolvedModuleDefinition(self: *BuildRunner, comptime manifest: anytype, comptime section: []const u8, comptime name: []const u8, comptime mod: anytype) bool {
+        var failed = false;
+        const Mod = @TypeOf(mod);
+
+        if (@hasField(Mod, "imports"))
+            failed = self.validateResolvedImports(manifest, mod.imports, section, name) or failed;
+        if (@hasField(Mod, "link_libraries"))
+            failed = self.validateResolvedLinkLibraries(mod.link_libraries, section, name) or failed;
+        if (@hasField(Mod, "root_source_file"))
+            failed = self.validateResolvedLazyPath(mod.root_source_file, section, name, "root_source_file") or failed;
+        if (@hasField(Mod, "include_paths")) {
+            inline for (@typeInfo(@TypeOf(mod.include_paths)).@"struct".fields) |field| {
+                failed = self.validateResolvedLazyPath(@field(mod.include_paths, field.name), section, name, "include_paths") or failed;
+            }
+        }
+
+        return failed;
+    }
+
+    fn validateResolvedArtifactFields(self: *BuildRunner, comptime section: []const u8, comptime name: []const u8, comptime item: anytype) bool {
+        var failed = false;
+        const Item = @TypeOf(item);
+
+        if (@hasField(Item, "zig_lib_dir"))
+            failed = self.validateResolvedLazyPath(item.zig_lib_dir, section, name, "zig_lib_dir") or failed;
+        if (@hasField(Item, "win32_manifest"))
+            failed = self.validateResolvedLazyPath(item.win32_manifest, section, name, "win32_manifest") or failed;
+
+        return failed;
+    }
+
+    fn validateResolvedImports(self: *BuildRunner, comptime manifest: anytype, comptime imports: anytype, comptime section: []const u8, comptime name: []const u8) bool {
+        var failed = false;
+
+        inline for (@typeInfo(@TypeOf(imports)).@"struct".fields) |field| {
+            const raw = @field(imports, field.name);
+            const import_name = comptime toComptimeString(raw);
+            switch (@typeInfo(@TypeOf(raw))) {
+                .enum_literal => {
+                    if (comptime hasModule(manifest, import_name) or hasOptionsModule(manifest, import_name)) continue;
+                    if (self.result.dependencies.get(import_name)) |dep| {
+                        if (dep.builder.modules.get(import_name) == null) {
+                            self.invalidateManifest("dependency import '{s}' in {s} '{s}' could not resolve default module '{s}' from dependency '{s}'", .{
+                                import_name,
+                                section,
+                                name,
+                                import_name,
+                                import_name,
+                            });
+                            failed = true;
+                        }
+                    }
+                },
+                .pointer => {
+                    if (countSeparators(import_name, ':') == 0) {
+                        if (!self.manual_modules.contains(import_name) or self.b.modules.get(import_name) == null) {
+                            self.invalidateManifest("manual import '{s}' in {s} '{s}' could not resolve a module registered before configureBuild", .{
+                                import_name,
+                                section,
+                                name,
+                            });
+                            failed = true;
+                        }
+                    } else {
+                        const dep_name = comptimeBaseName(import_name);
+                        const module_name = comptimeAfterSep(import_name);
+                        if (self.result.dependencies.get(dep_name)) |dep| {
+                            if (dep.builder.modules.get(module_name) == null) {
+                                self.invalidateManifest("dependency import '{s}' in {s} '{s}' could not resolve module '{s}' from dependency '{s}'", .{
+                                    import_name,
+                                    section,
+                                    name,
+                                    module_name,
+                                    dep_name,
+                                });
+                                failed = true;
+                            }
+                        } else {
+                            self.invalidateManifest("dependency import '{s}' in {s} '{s}' references missing dependency '{s}'", .{
+                                import_name,
+                                section,
+                                name,
+                                dep_name,
+                            });
+                            failed = true;
+                        }
+                    }
+                },
+                else => unreachable,
+            }
+        }
+
+        return failed;
+    }
+
+    fn validateResolvedLinkLibraries(self: *BuildRunner, comptime links: anytype, comptime section: []const u8, comptime name: []const u8) bool {
+        var failed = false;
+
+        inline for (@typeInfo(@TypeOf(links)).@"struct".fields) |field| {
+            const spec = comptime toComptimeString(@field(links, field.name));
+            const dep_name = comptime comptimeBaseName(spec);
+            const artifact_name = comptime comptimeAfterSep(spec);
+            if (self.result.dependencies.get(dep_name)) |dep| {
+                switch (lookupDependencyArtifact(dep, artifact_name)) {
+                    .found => {},
+                    .missing => {
+                        self.invalidateManifest("{s} '{s}': link_libraries entry '{s}' could not resolve artifact '{s}' from dependency '{s}'", .{
+                            section,
+                            name,
+                            spec,
+                            artifact_name,
+                            dep_name,
+                        });
+                        failed = true;
+                    },
+                    .ambiguous => {
+                        self.invalidateManifest("{s} '{s}': link_libraries entry '{s}' resolves ambiguous artifact '{s}' from dependency '{s}'", .{
+                            section,
+                            name,
+                            spec,
+                            artifact_name,
+                            dep_name,
+                        });
+                        failed = true;
+                    },
+                }
+            } else {
+                self.invalidateManifest("{s} '{s}': link_libraries references missing dependency '{s}'", .{ section, name, dep_name });
+                failed = true;
+            }
+        }
+
+        return failed;
+    }
+
+    fn validateResolvedLazyPath(self: *BuildRunner, path: []const u8, comptime section: []const u8, comptime name: []const u8, comptime field_name: []const u8) bool {
+        const separator_count = countSeparators(path, ':');
+        if (separator_count == 0) return false;
+
+        var parts = std.mem.splitScalar(u8, path, ':');
+        const dep_name = parts.first();
+        const dep = self.result.dependencies.get(dep_name) orelse return false;
+        const export_name = parts.next() orelse return false;
+
+        if (separator_count == 1) {
+            if (dep.builder.named_lazy_paths.get(export_name) == null) {
+                self.invalidateManifest("{s} '{s}': {s} path '{s}' could not resolve named lazy path '{s}' from dependency '{s}'", .{
+                    section,
+                    name,
+                    field_name,
+                    path,
+                    export_name,
+                    dep_name,
+                });
+                return true;
+            }
+            return false;
+        }
+
+        if (dep.builder.named_writefiles.get(export_name) == null) {
+            self.invalidateManifest("{s} '{s}': {s} path '{s}' could not resolve WriteFiles step '{s}' from dependency '{s}'", .{
+                section,
+                name,
+                field_name,
+                path,
+                export_name,
+                dep_name,
+            });
+            return true;
+        }
+
+        return false;
+    }
+
+    fn invalidateManifest(self: *BuildRunner, comptime fmt: []const u8, args: anytype) void {
+        std.log.err("zbuild: " ++ fmt, args);
+        self.b.invalid_user_input = true;
+    }
+
+    fn lookupDependencyArtifact(dep: *std.Build.Dependency, name: []const u8) DependencyArtifactLookup {
+        var found: ?*std.Build.Step.Compile = null;
+        for (dep.builder.install_tls.step.dependencies.items) |dep_step| {
+            const inst = dep_step.cast(std.Build.Step.InstallArtifact) orelse continue;
+            if (!std.mem.eql(u8, inst.artifact.name, name)) continue;
+            if (found != null) return .ambiguous;
+            found = inst.artifact;
+        }
+        return if (found) |artifact| .{ .found = artifact } else .missing;
+    }
+
+    // --- Module creation ---
+
+    fn createModule(
+        self: *BuildRunner,
+        comptime mod: anytype,
+        name: []const u8,
+        registry: *std.StringHashMap(*std.Build.Module),
+    ) Error!*std.Build.Module {
+        const Mod = @TypeOf(mod);
+        var opts: std.Build.Module.CreateOptions = .{
+            .root_source_file = if (@hasField(Mod, "root_source_file")) self.resolveLazyPath(mod.root_source_file) else null,
+            .target = if (@hasField(Mod, "target")) self.resolveTarget(mod.target) else self.target,
+            .optimize = if (@hasField(Mod, "optimize")) mod.optimize else self.optimize,
+        };
+        copyModulePassthroughFields(Mod, mod, &opts);
+        const m = self.b.createModule(opts);
+
+        if (@hasField(Mod, "include_paths")) {
+            inline for (@typeInfo(@TypeOf(mod.include_paths)).@"struct".fields) |field| {
+                m.addIncludePath(self.resolveLazyPath(@field(mod.include_paths, field.name)));
+            }
+        }
+
+        if (@hasField(Mod, "link_libraries")) {
+            inline for (@typeInfo(@TypeOf(mod.link_libraries)).@"struct".fields) |field| {
+                const lib_spec = comptime toComptimeString(@field(mod.link_libraries, field.name));
+                const dep_name = comptime comptimeBaseName(lib_spec);
+                const artifact_name = comptime comptimeAfterSep(lib_spec);
+                if (self.result.dependencies.get(dep_name)) |dep| {
+                    switch (lookupDependencyArtifact(dep, artifact_name)) {
+                        .found => |artifact| m.linkLibrary(artifact),
+                        .missing => {
+                            self.invalidateManifest("modules '{s}': link_libraries entry '{s}' could not resolve artifact '{s}' from dependency '{s}'", .{
+                                name,
+                                lib_spec,
+                                artifact_name,
+                                dep_name,
+                            });
+                            return error.ModuleNotFound;
+                        },
+                        .ambiguous => {
+                            self.invalidateManifest("modules '{s}': link_libraries entry '{s}' resolves ambiguous artifact '{s}' from dependency '{s}'", .{
+                                name,
+                                lib_spec,
+                                artifact_name,
+                                dep_name,
+                            });
+                            return error.ModuleNotFound;
+                        },
+                    }
+                }
+            }
+        }
+
+        if (registry != &self.result.modules and self.result.modules.get(name) != null) {
+            self.invalidateManifest("inline root_module name '{s}' collides with named module '{s}'", .{ name, name });
+            return error.NameCollision;
+        }
+        if (registry.get(name) != null) {
+            self.invalidateManifest("duplicate module registration for '{s}'", .{name});
+            return error.NameCollision;
+        }
+
+        try registry.put(name, m);
+        return m;
+    }
+
+    fn resolveModuleLink(self: *BuildRunner, comptime link: anytype, comptime name: []const u8) Error!*std.Build.Module {
+        const ti = @typeInfo(@TypeOf(link));
+        if (ti == .enum_literal) {
+            const mod_name = @tagName(link);
+            return self.result.modules.get(mod_name) orelse {
+                std.log.err("zbuild: module '{s}' not found", .{mod_name});
+                return error.ModuleNotFound;
+            };
+        } else if (ti == .pointer) {
+            const str: []const u8 = link;
+            if (countSeparators(str, ':') == 0 and self.manual_modules.contains(str)) {
+                if (self.b.modules.get(str)) |module| return module;
+            }
+            self.invalidateManifest("root_module '{s}' could not resolve a manual module registered before configureBuild", .{str});
+            return error.ModuleNotFound;
+        } else if (ti == .@"struct") {
+            const mod_name = inlineRootModuleName(name, link);
+            return try self.createModule(link, mod_name, &self.inline_modules);
+        } else {
+            @compileError("root_module must be a string, enum literal, or struct");
+        }
+    }
+
+    // --- Artifact creation ---
+
+    fn createExecutable(self: *BuildRunner, comptime name: []const u8, comptime exe: anytype) Error!void {
+        const Exe = @TypeOf(exe);
+        const root_module = try self.resolveModuleLink(exe.root_module, name);
+
+        var add_opts: std.Build.ExecutableOptions = .{
+            .name = name,
+            .root_module = root_module,
+            .version = if (@hasField(Exe, "version")) std.SemanticVersion.parse(exe.version) catch unreachable else null,
+        };
+        copyArtifactPassthroughFields("executables", Exe, exe, &add_opts);
+        if (@hasField(Exe, "zig_lib_dir")) add_opts.zig_lib_dir = self.resolveLazyPath(exe.zig_lib_dir);
+        if (@hasField(Exe, "win32_manifest")) add_opts.win32_manifest = self.resolveLazyPath(exe.win32_manifest);
+
+        const artifact = self.b.addExecutable(add_opts);
+        try self.result.executables.put(name, artifact);
+
+        try self.installAndRegister("build-exe", "executable", name, artifact, .{
+            .dest_sub_path = if (@hasField(Exe, "dest_sub_path")) exe.dest_sub_path else null,
+        });
+
+        const run = self.b.addRunArtifact(artifact);
+        if (self.b.args) |args| run.addArgs(args);
+        const tls_run = try self.createTopLevelStep(
+            self.b.fmt("run:{s}", .{name}),
+            self.b.fmt("Run the {s} executable", .{name}),
+        );
+        tls_run.dependOn(&run.step);
+    }
+
+    fn createLibrary(self: *BuildRunner, comptime name: []const u8, comptime lib: anytype) Error!void {
+        const Lib = @TypeOf(lib);
+        const root_module = try self.resolveModuleLink(lib.root_module, name);
+
+        var add_opts: std.Build.LibraryOptions = .{
+            .name = name,
+            .root_module = root_module,
+            .version = if (@hasField(Lib, "version")) std.SemanticVersion.parse(lib.version) catch unreachable else null,
+        };
+        copyArtifactPassthroughFields("libraries", Lib, lib, &add_opts);
+        if (@hasField(Lib, "zig_lib_dir")) add_opts.zig_lib_dir = self.resolveLazyPath(lib.zig_lib_dir);
+        if (@hasField(Lib, "win32_manifest")) add_opts.win32_manifest = self.resolveLazyPath(lib.win32_manifest);
+        if (@hasField(Lib, "win32_module_definition")) add_opts.win32_module_definition = self.resolveLazyPath(lib.win32_module_definition);
+
+        const artifact = self.b.addLibrary(add_opts);
+        try self.result.libraries.put(name, artifact);
+
+        if (@hasField(Lib, "linker_allow_shlib_undefined")) {
+            artifact.linker_allow_shlib_undefined = lib.linker_allow_shlib_undefined;
+        }
+
+        try self.installAndRegister("build-lib", "library", name, artifact, .{
+            .dest_sub_path = if (@hasField(Lib, "dest_sub_path")) lib.dest_sub_path else null,
+        });
+    }
+
+    fn createObject(self: *BuildRunner, comptime name: []const u8, comptime obj: anytype) Error!void {
+        const Obj = @TypeOf(obj);
+        const root_module = try self.resolveModuleLink(obj.root_module, name);
+
+        var add_opts: std.Build.ObjectOptions = .{
+            .name = name,
+            .root_module = root_module,
+        };
+        copyArtifactPassthroughFields("objects", Obj, obj, &add_opts);
+        if (@hasField(Obj, "zig_lib_dir")) add_opts.zig_lib_dir = self.resolveLazyPath(obj.zig_lib_dir);
+
+        const artifact = self.b.addObject(add_opts);
+        try self.result.objects.put(name, artifact);
+
+        try self.installAndRegister("build-obj", "object", name, artifact, .{});
+    }
+
+    fn createTest(self: *BuildRunner, comptime name: []const u8, comptime t: anytype, tls_run_test: *std.Build.Step) Error!void {
+        const T = @TypeOf(t);
+        const root_module = try self.resolveModuleLink(t.root_module, name);
+
+        const filters_option = self.b.option(
+            []const []const u8,
+            self.b.fmt("{s}.filters", .{name}),
+            self.b.fmt("{s} test filters", .{name}),
+        );
+
+        var add_opts: std.Build.TestOptions = .{
+            .name = name,
+            .root_module = root_module,
+            .filters = filters_option orelse if (@hasField(T, "filters")) comptime toStringSlice(t.filters) else &.{},
+        };
+        copyArtifactPassthroughFields("tests", T, t, &add_opts);
+        if (@hasField(T, "zig_lib_dir")) add_opts.zig_lib_dir = self.resolveLazyPath(t.zig_lib_dir);
+        if (@hasField(T, "test_runner")) {
+            add_opts.test_runner = .{
+                .path = self.resolveLazyPath(t.test_runner.path),
+                .mode = t.test_runner.mode,
+            };
+        }
+
+        const artifact = self.b.addTest(add_opts);
+        try self.result.tests.put(name, artifact);
+
+        if (@hasField(T, "linker_allow_shlib_undefined")) {
+            artifact.linker_allow_shlib_undefined = t.linker_allow_shlib_undefined;
+        }
+
+        const install = self.b.addInstallArtifact(artifact, .{});
+        const tls_install = try self.createTopLevelStep(
+            self.b.fmt("build-test:{s}", .{name}),
+            self.b.fmt("Install the {s} test", .{name}),
+        );
+        tls_install.dependOn(&install.step);
+
+        const run = self.b.addRunArtifact(artifact);
+        const tls_run = try self.createTopLevelStep(
+            self.b.fmt("test:{s}", .{name}),
+            self.b.fmt("Run the {s} test", .{name}),
+        );
+        tls_run.dependOn(&run.step);
+        tls_run_test.dependOn(&run.step);
+    }
+
+    fn createFmt(self: *BuildRunner, comptime name: []const u8, comptime fmt: anytype, tls_run_fmt: *std.Build.Step) Error!void {
+        const Fmt = @TypeOf(fmt);
+        const step = self.b.addFmt(.{
+            .paths = if (@hasField(Fmt, "paths")) comptime toStringSlice(fmt.paths) else &.{},
+            .exclude_paths = if (@hasField(Fmt, "exclude_paths")) comptime toStringSlice(fmt.exclude_paths) else &.{},
+            .check = if (@hasField(Fmt, "check")) fmt.check else false,
+        });
+        try self.result.fmts.put(name, step);
+
+        const tls = try self.createTopLevelStep(
+            self.b.fmt("fmt:{s}", .{name}),
+            self.b.fmt("Run the {s} fmt", .{name}),
+        );
+        tls.dependOn(&step.step);
+        tls_run_fmt.dependOn(&step.step);
+    }
+
+    fn createRun(self: *BuildRunner, comptime name: []const u8, comptime cmd: anytype) Error!void {
+        const is_long_form = @hasField(@TypeOf(cmd), "cmd");
+        const args_tuple = if (is_long_form) cmd.cmd else cmd;
+        const run = self.b.addSystemCommand(comptime toStringSlice(args_tuple));
+        try self.result.runs.put(name, run);
+
+        // Long form options
+        if (is_long_form) {
+            if (@hasField(@TypeOf(cmd), "cwd"))
+                run.setCwd(self.resolveLazyPath(cmd.cwd));
+
+            if (@hasField(@TypeOf(cmd), "env")) {
+                inline for (@typeInfo(@TypeOf(cmd.env)).@"struct".fields) |field| {
+                    run.setEnvironmentVariable(field.name, @field(cmd.env, field.name));
+                }
+            }
+
+            if (@hasField(@TypeOf(cmd), "inherit_stdio")) {
+                if (cmd.inherit_stdio) run.stdio = .inherit;
+            }
+
+            if (@hasField(@TypeOf(cmd), "stdin"))
+                run.setStdIn(.{ .bytes = cmd.stdin });
+
+            if (@hasField(@TypeOf(cmd), "stdin_file"))
+                run.setStdIn(.{ .lazy_path = self.resolveLazyPath(cmd.stdin_file) });
+        }
+
+        const tls = try self.createTopLevelStep(
+            self.b.fmt("cmd:{s}", .{name}),
+            self.b.fmt("Run the {s} command", .{name}),
+        );
+        tls.dependOn(&run.step);
+    }
+
+    fn createAlias(self: *BuildRunner, comptime name: []const u8, comptime alias: anytype) Error!void {
+        const description = if (@hasField(@TypeOf(alias), "description"))
+            alias.description
+        else
+            self.b.fmt("Run the {s} alias", .{name});
+
+        _ = try self.createTopLevelStep(name, description);
+    }
+
+    fn installAndRegister(
+        self: *BuildRunner,
+        comptime prefix: []const u8,
+        comptime label: []const u8,
+        comptime name: []const u8,
+        artifact: *std.Build.Step.Compile,
+        install_opts: std.Build.Step.InstallArtifact.Options,
+    ) Error!void {
+        const install = self.b.addInstallArtifact(artifact, install_opts);
+        const tls = try self.createTopLevelStep(
+            self.b.fmt(prefix ++ ":{s}", .{name}),
+            self.b.fmt("Install the {s} " ++ label, .{name}),
+        );
+        tls.dependOn(&install.step);
+        self.b.getInstallStep().dependOn(&install.step);
+        try self.install_steps.put(name, &install.step);
+    }
+
+    // --- Options modules ---
+
+    fn createOptionsModule(self: *BuildRunner, comptime manifest: anytype, comptime name: []const u8, comptime options: anytype) !void {
+        var source: std.ArrayList(u8) = .empty;
+        defer source.deinit(self.b.allocator);
+
+        try source.appendSlice(self.b.allocator, "//! Generated by zbuild.\n\n");
+
+        var emitted_type_names: std.ArrayList([]const u8) = .empty;
+        defer {
+            for (emitted_type_names.items) |type_name| self.b.allocator.free(type_name);
+            emitted_type_names.deinit(self.b.allocator);
+        }
+
+        const fields = @typeInfo(@TypeOf(options)).@"struct".fields;
+        inline for (fields) |field| {
+            const opt = @field(options, field.name);
+            if (!comptime isEnumOptionType(optionTypeString(opt))) continue;
+
+            const type_name = try self.optionTypeNameAlloc(field.name, opt);
+            if (stringSliceContains(emitted_type_names.items, type_name)) {
+                self.b.allocator.free(type_name);
+            } else {
+                try emitted_type_names.append(self.b.allocator, type_name);
+                try emitEnumType(&source, self.b.allocator, type_name, enumOptionValues(opt));
+                try source.appendSlice(self.b.allocator, "\n");
+            }
+        }
+
+        inline for (fields) |field| {
+            try self.emitOptionField(&source, manifest, name, field.name, @field(options, field.name));
+        }
+
+        const write_file = self.b.addWriteFiles();
+        const generated = write_file.add(self.b.fmt("zbuild-options-{s}.zig", .{name}), source.items);
+        const m = self.b.createModule(.{
+            .root_source_file = generated,
+        });
+        try self.result.options_modules.put(name, m);
+    }
+
+    fn optionTypeNameAlloc(self: *BuildRunner, comptime option_name: []const u8, comptime opt: anytype) ![]const u8 {
+        if (@hasField(@TypeOf(opt), "type_name")) {
+            return self.b.allocator.dupe(u8, opt.type_name);
+        }
+        return pascalCaseAlloc(self.b.allocator, option_name);
+    }
+
+    fn emitOptionField(
+        self: *BuildRunner,
+        out: *std.ArrayList(u8),
+        comptime manifest: anytype,
+        comptime module_name: []const u8,
+        comptime option_name: []const u8,
+        comptime opt: anytype,
+    ) !void {
+        const gpa = self.b.allocator;
+        const Opt = @TypeOf(opt);
+        const type_str = comptime optionTypeString(opt);
+        const desc: []const u8 = if (@hasField(Opt, "description")) opt.description else "";
+        const cli_name = comptime module_name ++ "." ++ option_name;
+
+        if (comptime std.mem.eql(u8, type_str, "bool")) {
+            const value = self.b.option(bool, cli_name, desc);
+            const preset_value = self.resolvePresetOptionOverride(manifest, module_name, option_name, opt);
+            if (@hasField(Opt, "default")) {
+                try out.print(gpa, "pub const {f}: bool = {any};\n", .{
+                    std.zig.fmtId(option_name),
+                    value orelse preset_value orelse opt.default,
+                });
+            } else if (value orelse preset_value) |resolved| {
+                try out.print(gpa, "pub const {f}: ?bool = {any};\n", .{
+                    std.zig.fmtId(option_name),
+                    resolved,
+                });
+            } else {
+                try out.print(gpa, "pub const {f}: ?bool = null;\n", .{std.zig.fmtId(option_name)});
+            }
+            return;
+        }
+
+        if (comptime std.mem.eql(u8, type_str, "string")) {
+            const value = self.b.option([]const u8, cli_name, desc);
+            const preset_value = self.resolvePresetOptionOverride(manifest, module_name, option_name, opt);
+            if (value orelse preset_value) |resolved| {
+                if (@hasField(Opt, "default")) {
+                    try out.print(gpa, "pub const {f}: []const u8 = \"{f}\";\n", .{
+                        std.zig.fmtId(option_name),
+                        std.zig.fmtString(resolved),
+                    });
+                } else {
+                    try out.print(gpa, "pub const {f}: ?[]const u8 = \"{f}\";\n", .{
+                        std.zig.fmtId(option_name),
+                        std.zig.fmtString(resolved),
+                    });
+                }
+            } else if (@hasField(Opt, "default")) {
+                try out.print(gpa, "pub const {f}: []const u8 = \"{f}\";\n", .{
+                    std.zig.fmtId(option_name),
+                    std.zig.fmtString(opt.default),
+                });
+            } else {
+                try out.print(gpa, "pub const {f}: ?[]const u8 = null;\n", .{std.zig.fmtId(option_name)});
+            }
+            return;
+        }
+
+        if (comptime std.mem.eql(u8, type_str, "list")) {
+            const value = self.b.option([]const []const u8, cli_name, desc);
+            const preset_value = self.resolvePresetOptionOverride(manifest, module_name, option_name, opt);
+            if (value orelse preset_value) |resolved| {
+                if (@hasField(Opt, "default")) {
+                    try out.print(gpa, "pub const {f}: []const []const u8 = ", .{std.zig.fmtId(option_name)});
+                } else {
+                    try out.print(gpa, "pub const {f}: ?[]const []const u8 = ", .{std.zig.fmtId(option_name)});
+                }
+                try emitStringListLiteral(out, gpa, resolved);
+                try out.appendSlice(gpa, ";\n");
+            } else if (@hasField(Opt, "default")) {
+                try out.print(gpa, "pub const {f}: []const []const u8 = ", .{std.zig.fmtId(option_name)});
+                try emitStringListLiteral(out, gpa, comptime toStringSlice(opt.default));
+                try out.appendSlice(gpa, ";\n");
+            } else {
+                try out.print(gpa, "pub const {f}: ?[]const []const u8 = null;\n", .{std.zig.fmtId(option_name)});
+            }
+            return;
+        }
+
+        if (comptime std.mem.eql(u8, type_str, "enum")) {
+            const allowed = comptime enumOptionValues(opt);
+            const type_name = try self.optionTypeNameAlloc(option_name, opt);
+            defer gpa.free(type_name);
+            const value = self.b.option([]const u8, cli_name, desc);
+            const preset_value = self.resolvePresetOptionOverride(manifest, module_name, option_name, opt);
+            const resolved = if (value) |candidate|
+                if (self.validateEnumOptionValue(cli_name, candidate, allowed))
+                    @as(?[]const u8, candidate)
+                else if (preset_value) |preset|
+                    @as(?[]const u8, preset)
+                else if (@hasField(Opt, "default"))
+                    @as(?[]const u8, toComptimeString(opt.default))
+                else
+                    null
+            else if (preset_value) |preset|
+                @as(?[]const u8, preset)
+            else if (@hasField(Opt, "default"))
+                @as(?[]const u8, toComptimeString(opt.default))
+            else
+                null;
+
+            if (@hasField(Opt, "default")) {
+                try out.print(gpa, "pub const {f}: {f} = .{f};\n", .{
+                    std.zig.fmtId(option_name),
+                    std.zig.fmtId(type_name),
+                    std.zig.fmtIdFlags(resolved.?, .{ .allow_primitive = true, .allow_underscore = true }),
+                });
+            } else if (resolved) |tag| {
+                try out.print(gpa, "pub const {f}: ?{f} = .{f};\n", .{
+                    std.zig.fmtId(option_name),
+                    std.zig.fmtId(type_name),
+                    std.zig.fmtIdFlags(tag, .{ .allow_primitive = true, .allow_underscore = true }),
+                });
+            } else {
+                try out.print(gpa, "pub const {f}: ?{f} = null;\n", .{
+                    std.zig.fmtId(option_name),
+                    std.zig.fmtId(type_name),
+                });
+            }
+            return;
+        }
+
+        if (comptime std.mem.eql(u8, type_str, "enum_list")) {
+            const allowed = comptime enumOptionValues(opt);
+            const type_name = try self.optionTypeNameAlloc(option_name, opt);
+            defer gpa.free(type_name);
+            const value = self.b.option([]const []const u8, cli_name, desc);
+            const preset_value = self.resolvePresetOptionOverride(manifest, module_name, option_name, opt);
+            const resolved = if (value) |candidates|
+                if (self.validateEnumOptionValues(cli_name, candidates, allowed))
+                    @as(?[]const []const u8, candidates)
+                else if (preset_value) |preset|
+                    @as(?[]const []const u8, preset)
+                else if (@hasField(Opt, "default"))
+                    @as(?[]const []const u8, comptime toComptimeStringSlice(opt.default))
+                else
+                    null
+            else if (preset_value) |preset|
+                @as(?[]const []const u8, preset)
+            else if (@hasField(Opt, "default"))
+                @as(?[]const []const u8, comptime toComptimeStringSlice(opt.default))
+            else
+                null;
+
+            if (@hasField(Opt, "default")) {
+                try out.print(gpa, "pub const {f}: []const {f} = ", .{
+                    std.zig.fmtId(option_name),
+                    std.zig.fmtId(type_name),
+                });
+                try emitEnumListLiteral(out, gpa, resolved.?);
+                try out.appendSlice(gpa, ";\n");
+            } else if (resolved) |tags| {
+                try out.print(gpa, "pub const {f}: ?[]const {f} = ", .{
+                    std.zig.fmtId(option_name),
+                    std.zig.fmtId(type_name),
+                });
+                try emitEnumListLiteral(out, gpa, tags);
+                try out.appendSlice(gpa, ";\n");
+            } else {
+                try out.print(gpa, "pub const {f}: ?[]const {f} = null;\n", .{
+                    std.zig.fmtId(option_name),
+                    std.zig.fmtId(type_name),
+                });
+            }
+            return;
+        }
+
+        if (comptime isIntType(type_str) or isFloatType(type_str)) {
+            const T = comptime optionValueType(type_str);
+            const value = self.b.option(T, cli_name, desc);
+            const preset_value = self.resolvePresetOptionOverride(manifest, module_name, option_name, opt);
+            if (@hasField(Opt, "default")) {
+                try out.print(gpa, "pub const {f}: {s} = {any};\n", .{
+                    std.zig.fmtId(option_name),
+                    type_str,
+                    value orelse preset_value orelse opt.default,
+                });
+            } else if (value orelse preset_value) |resolved| {
+                try out.print(gpa, "pub const {f}: ?{s} = {any};\n", .{
+                    std.zig.fmtId(option_name),
+                    type_str,
+                    resolved,
+                });
+            } else {
+                try out.print(gpa, "pub const {f}: ?{s} = null;\n", .{
+                    std.zig.fmtId(option_name),
+                    type_str,
+                });
+            }
+            return;
+        }
+
+        @compileError("unknown option type '" ++ type_str ++ "'");
+    }
+
+    fn resolvePresetOptionOverride(
+        self: *BuildRunner,
+        comptime manifest: anytype,
+        comptime module_name: []const u8,
+        comptime option_name: []const u8,
+        comptime opt: anytype,
+    ) ?optionOverrideValueType(opt) {
+        const preset_name = self.active_preset orelse return null;
+        if (!@hasField(@TypeOf(manifest), "presets")) return null;
+
+        inline for (@typeInfo(@TypeOf(manifest.presets)).@"struct".fields) |preset_field| {
+            if (std.mem.eql(u8, preset_name, preset_field.name)) {
+                const preset = @field(manifest.presets, preset_field.name);
+                if (!@hasField(@TypeOf(preset), module_name)) return null;
+
+                const module_overrides = @field(preset, module_name);
+                if (!@hasField(@TypeOf(module_overrides), option_name)) return null;
+
+                return coercePresetOptionOverride(opt, @field(module_overrides, option_name));
+            }
+        }
+
+        return null;
+    }
+
+    fn validateEnumOptionValue(self: *BuildRunner, name: []const u8, actual: []const u8, allowed: []const []const u8) bool {
+        if (stringSliceContains(allowed, actual)) return true;
+        self.logInvalidEnumOptionValue(name, actual, allowed);
+        return false;
+    }
+
+    fn validateEnumOptionValues(self: *BuildRunner, name: []const u8, actual: []const []const u8, allowed: []const []const u8) bool {
+        var ok = true;
+        for (actual) |value| {
+            ok = self.validateEnumOptionValue(name, value, allowed) and ok;
+        }
+        return ok;
+    }
+
+    fn logInvalidEnumOptionValue(self: *BuildRunner, name: []const u8, actual: []const u8, allowed: []const []const u8) void {
+        var expected: std.ArrayList(u8) = .empty;
+        defer expected.deinit(self.b.allocator);
+
+        for (allowed, 0..) |value, i| {
+            if (i > 0) expected.appendSlice(self.b.allocator, ", ") catch @panic("OOM");
+            expected.appendSlice(self.b.allocator, value) catch @panic("OOM");
+        }
+
+        std.log.err("invalid value for -D{s}: '{s}' (expected one of: {s})", .{
+            name,
+            actual,
+            expected.items,
+        });
+        self.b.invalid_user_input = true;
+    }
+
+    // --- Import wiring ---
+
+    fn wireAllImports(self: *BuildRunner, comptime manifest: anytype) Error!void {
+        if (@hasField(@TypeOf(manifest), "modules")) {
+            inline for (@typeInfo(@TypeOf(manifest.modules)).@"struct".fields) |field| {
+                const mod = @field(manifest.modules, field.name);
+                if (@hasField(@TypeOf(mod), "imports")) {
+                    if (self.result.modules.get(field.name)) |m| {
+                        try self.wireModuleImports(m, mod.imports);
+                    }
+                }
+            }
+        }
+
+        // Wire imports for inline modules in executables, libraries, objects, tests
+        inline for (.{ "executables", "libraries", "objects", "tests" }) |section| {
+            if (@hasField(@TypeOf(manifest), section)) {
+                inline for (@typeInfo(@TypeOf(@field(manifest, section))).@"struct".fields) |field| {
+                    const item = @field(@field(manifest, section), field.name);
+                    if (comptime isInlineRootModuleType(@TypeOf(item.root_module))) {
+                        if (comptime @hasField(@TypeOf(item.root_module), "imports")) {
+                            const mod_name = inlineRootModuleName(field.name, item.root_module);
+                            if (self.inline_modules.get(mod_name)) |m| {
+                                try self.wireModuleImports(m, item.root_module.imports);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn wireModuleImports(self: *BuildRunner, module: *std.Build.Module, comptime imports: anytype) Error!void {
+        inline for (@typeInfo(@TypeOf(imports)).@"struct".fields) |field| {
+            const raw = @field(imports, field.name);
+            const import_name = comptime toComptimeString(raw);
+            const resolved = switch (@typeInfo(@TypeOf(raw))) {
+                .enum_literal => try self.resolveOwnedImport(import_name),
+                .pointer => if (countSeparators(import_name, ':') == 0)
+                    try self.resolveManualImport(import_name)
+                else
+                    try self.resolveDependencyImport(import_name),
+                else => unreachable,
+            };
+            module.addImport(import_name, resolved);
+        }
+    }
+
+    // --- depends_on wiring ---
+
+    fn wireDependsOn(self: *BuildRunner, comptime manifest: anytype, comptime opts: Options) Error!void {
+        // Artifacts: wire install step
+        inline for (.{ "executables", "libraries", "objects" }) |section| {
+            if (@hasField(@TypeOf(manifest), section)) {
+                inline for (@typeInfo(@TypeOf(@field(manifest, section))).@"struct".fields) |field| {
+                    const item = @field(@field(manifest, section), field.name);
+                    if (@hasField(@TypeOf(item), "depends_on")) {
+                        if (self.install_steps.get(field.name)) |this_step| {
+                            try self.wireDependsOnList(manifest, opts, this_step, item.depends_on);
+                        }
+                    }
+                }
+            }
+        }
+        // Tests: wire via test run step
+        if (@hasField(@TypeOf(manifest), "tests")) {
+            inline for (@typeInfo(@TypeOf(manifest.tests)).@"struct".fields) |field| {
+                const item = @field(manifest.tests, field.name);
+                if (@hasField(@TypeOf(item), "depends_on")) {
+                    if (self.b.top_level_steps.get(self.b.fmt("test:{s}", .{field.name}))) |tls| {
+                        try self.wireDependsOnList(manifest, opts, &tls.step, item.depends_on);
+                    }
+                }
+            }
+        }
+        // Runs: wire via cmd step
+        if (@hasField(@TypeOf(manifest), "runs")) {
+            inline for (@typeInfo(@TypeOf(manifest.runs)).@"struct".fields) |field| {
+                const run = @field(manifest.runs, field.name);
+                if (@hasField(@TypeOf(run), "cmd") and @hasField(@TypeOf(run), "depends_on")) {
+                    if (self.b.top_level_steps.get(self.b.fmt("cmd:{s}", .{field.name}))) |tls| {
+                        try self.wireDependsOnList(manifest, opts, &tls.step, run.depends_on);
+                    }
+                }
+            }
+        }
+        // Aliases: wire via exact top-level alias step
+        if (@hasField(@TypeOf(manifest), "aliases")) {
+            inline for (@typeInfo(@TypeOf(manifest.aliases)).@"struct".fields) |field| {
+                const alias = @field(manifest.aliases, field.name);
+                if (self.b.top_level_steps.get(field.name)) |tls| {
+                    try self.wireDependsOnList(manifest, opts, &tls.step, alias.depends_on);
+                }
+            }
+        }
+    }
+
+    fn wireDependsOnList(self: *BuildRunner, comptime manifest: anytype, comptime opts: Options, step: *std.Build.Step, comptime deps: anytype) Error!void {
+        inline for (@typeInfo(@TypeOf(deps)).@"struct".fields) |field| {
+            const raw = @field(deps, field.name);
+            const dep_name = comptime toComptimeString(raw);
+            const dep_step = switch (@typeInfo(@TypeOf(raw))) {
+                .enum_literal => self.install_steps.get(dep_name),
+                .pointer => blk: {
+                    if (isManifestStepRef(manifest, opts, dep_name)) {
+                        if (self.b.top_level_steps.get(dep_name)) |tls| break :blk &tls.step;
+                        break :blk null;
+                    }
+                    if (!self.manual_steps.contains(dep_name)) break :blk null;
+                    if (self.b.top_level_steps.get(dep_name)) |tls| break :blk &tls.step;
+                    break :blk null;
+                },
+                else => @compileError("depends_on entries must be strings or enum literals"),
+            };
+            if (dep_step) |s| {
+                step.dependOn(s);
+            } else {
+                self.invalidateManifest("depends_on reference '{s}' could not resolve an artifact install step or top-level step registered before configureBuild", .{dep_name});
+                return error.ModuleNotFound;
+            }
+        }
+    }
+
+    // --- Resolution helpers (runtime) ---
+
+    fn resolveOwnedImport(self: *BuildRunner, import_name: []const u8) Error!*std.Build.Module {
+        if (self.result.modules.get(import_name)) |m| return m;
+        if (self.result.options_modules.get(import_name)) |m| return m;
+        if (self.result.dependencies.get(import_name)) |dep| {
+            if (dep.builder.modules.get(import_name)) |module| return module;
+            self.invalidateManifest("dependency import '{s}' could not resolve default module '{s}' from dependency '{s}'", .{
+                import_name,
+                import_name,
+                import_name,
+            });
+            return error.ModuleNotFound;
+        }
+        self.invalidateManifest("unresolved import '{s}' (expected a zbuild module, options module, or dependency default module)", .{import_name});
+        return error.ModuleNotFound;
+    }
+
+    fn resolveDependencyImport(self: *BuildRunner, import_name: []const u8) Error!*std.Build.Module {
+        var parts = std.mem.splitScalar(u8, import_name, ':');
+        const first = parts.first();
+        if (self.result.dependencies.get(first)) |dep| {
+            const module_name = parts.next() orelse unreachable;
+            if (dep.builder.modules.get(module_name)) |module| return module;
+            self.invalidateManifest("dependency import '{s}' could not resolve module '{s}' from dependency '{s}'", .{
+                import_name,
+                module_name,
+                first,
+            });
+            return error.ModuleNotFound;
+        }
+        self.invalidateManifest("dependency import '{s}' references missing dependency '{s}'", .{ import_name, first });
+        return error.ModuleNotFound;
+    }
+
+    fn resolveManualImport(self: *BuildRunner, import_name: []const u8) Error!*std.Build.Module {
+        if (self.manual_modules.contains(import_name)) {
+            if (self.b.modules.get(import_name)) |module| return module;
+        }
+        self.invalidateManifest("manual import '{s}' could not resolve a module registered before configureBuild", .{import_name});
+        return error.ModuleNotFound;
+    }
+
+    fn resolveLazyPath(self: *BuildRunner, path: []const u8) std.Build.LazyPath {
+        if (countSeparators(path, ':') == 0) return self.b.path(path);
+
+        var parts = std.mem.splitScalar(u8, path, ':');
+        const first = parts.first();
+        if (self.result.dependencies.get(first)) |dep| {
+            const next = parts.next() orelse return self.b.path(path);
+            if (parts.next()) |last| {
+                if (dep.builder.named_writefiles.get(next)) |write_files| {
+                    return write_files.getDirectory().path(self.b, last);
+                }
+                self.invalidateManifest("lazy path '{s}' could not resolve WriteFiles step '{s}' from dependency '{s}'", .{
+                    path,
+                    next,
+                    first,
+                });
+                return self.b.path(path);
+            }
+            if (dep.builder.named_lazy_paths.get(next)) |lazy_path| {
+                return lazy_path;
+            }
+            self.invalidateManifest("lazy path '{s}' could not resolve named lazy path '{s}' from dependency '{s}'", .{
+                path,
+                next,
+                first,
+            });
+            return self.b.path(path);
+        }
+        return self.b.path(path);
+    }
+
+    fn resolveTarget(self: *BuildRunner, target_str: []const u8) std.Build.ResolvedTarget {
+        if (std.mem.eql(u8, target_str, "native")) return self.target;
+        return self.b.resolveTargetQuery(
+            std.Target.Query.parse(.{ .arch_os_abi = target_str }) catch @panic("invalid target"),
+        );
+    }
+};
+
+// --- Comptime helpers ---
+
+fn toStringSlice(comptime tuple: anytype) []const []const u8 {
+    const fields = @typeInfo(@TypeOf(tuple)).@"struct".fields;
+    var result: [fields.len][]const u8 = undefined;
+    inline for (fields, 0..) |field, i| {
+        result[i] = @field(tuple, field.name);
+    }
+    const final = result;
+    return &final;
+}
+
+fn toComptimeStringSlice(comptime tuple: anytype) []const []const u8 {
+    const fields = @typeInfo(@TypeOf(tuple)).@"struct".fields;
+    var result: [fields.len][]const u8 = undefined;
+    inline for (fields, 0..) |field, i| {
+        result[i] = toComptimeString(@field(tuple, field.name));
+    }
+    const final = result;
+    return &final;
+}
+
+fn optionTypeString(comptime opt: anytype) []const u8 {
+    return toComptimeString(opt.type);
+}
+
+fn isSupportedOptionType(comptime t: []const u8) bool {
+    return std.mem.eql(u8, t, "bool") or
+        std.mem.eql(u8, t, "string") or
+        std.mem.eql(u8, t, "list") or
+        std.mem.eql(u8, t, "enum") or
+        std.mem.eql(u8, t, "enum_list") or
+        isIntType(t) or
+        isFloatType(t);
+}
+
+fn isEnumOptionType(comptime t: []const u8) bool {
+    return std.mem.eql(u8, t, "enum") or std.mem.eql(u8, t, "enum_list");
+}
+
+fn optionValueType(comptime t: []const u8) type {
+    if (comptime std.mem.eql(u8, t, "bool")) return bool;
+    if (comptime std.mem.eql(u8, t, "string")) return []const u8;
+    if (comptime std.mem.eql(u8, t, "list")) return []const []const u8;
+
+    inline for (.{
+        .{ "i8", i8 },           .{ "u8", u8 },                     .{ "i16", i16 },               .{ "u16", u16 },
+        .{ "i32", i32 },         .{ "u32", u32 },                   .{ "i64", i64 },               .{ "u64", u64 },
+        .{ "i128", i128 },       .{ "u128", u128 },                 .{ "isize", isize },           .{ "usize", usize },
+        .{ "c_short", c_short }, .{ "c_ushort", c_ushort },         .{ "c_int", c_int },           .{ "c_uint", c_uint },
+        .{ "c_long", c_long },   .{ "c_ulong", c_ulong },           .{ "c_longlong", c_longlong }, .{ "c_ulonglong", c_ulonglong },
+        .{ "f16", f16 },         .{ "f32", f32 },                   .{ "f64", f64 },               .{ "f80", f80 },
+        .{ "f128", f128 },       .{ "c_longdouble", c_longdouble },
+    }) |entry| {
+        if (comptime std.mem.eql(u8, t, entry[0])) return entry[1];
+    }
+
+    @compileError("unsupported option type '" ++ t ++ "'");
+}
+
+fn optionOverrideValueType(comptime opt: anytype) type {
+    const type_str = comptime optionTypeString(opt);
+    if (comptime std.mem.eql(u8, type_str, "enum")) return []const u8;
+    if (comptime std.mem.eql(u8, type_str, "enum_list")) return []const []const u8;
+    return optionValueType(type_str);
+}
+
+fn coercePresetOptionOverride(comptime opt: anytype, comptime value: anytype) optionOverrideValueType(opt) {
+    const type_str = comptime optionTypeString(opt);
+    if (comptime std.mem.eql(u8, type_str, "bool")) {
+        const value_check: bool = value;
+        return value_check;
+    }
+    if (comptime std.mem.eql(u8, type_str, "string")) {
+        const value_check: []const u8 = value;
+        return value_check;
+    }
+    if (comptime std.mem.eql(u8, type_str, "list")) {
+        return comptime toStringSlice(value);
+    }
+    if (comptime std.mem.eql(u8, type_str, "enum")) {
+        return toComptimeString(value);
+    }
+    if (comptime std.mem.eql(u8, type_str, "enum_list")) {
+        return comptime toComptimeStringSlice(value);
+    }
+
+    const T = comptime optionValueType(type_str);
+    const value_check: T = value;
+    return value_check;
+}
+
+fn enumOptionValues(comptime opt: anytype) []const []const u8 {
+    const values = comptime toComptimeStringSlice(opt.values);
+    if (values.len == 0) {
+        @compileError("enum options require a non-empty 'values' field");
+    }
+
+    inline for (values, 0..) |value, i| {
+        if (!comptime isValidEnumTagName(value)) {
+            @compileError("invalid enum value '" ++ value ++ "': values must be non-empty Zig-style identifiers");
+        }
+        inline for (values[i + 1 ..]) |other| {
+            if (comptime std.mem.eql(u8, value, other)) {
+                @compileError("duplicate enum value '" ++ value ++ "'");
+            }
+        }
+    }
+    return values;
+}
+
+fn resolvedOptionTypeName(comptime option_name: []const u8, comptime opt: anytype) []const u8 {
+    return if (@hasField(@TypeOf(opt), "type_name"))
+        opt.type_name
+    else
+        comptimePascalCase(option_name);
+}
+
+fn comptimePascalCase(comptime name: []const u8) []const u8 {
+    comptime var result: [name.len]u8 = undefined;
+    comptime var len: usize = 0;
+    comptime var upper = true;
+
+    inline for (name) |c| {
+        if (c == '_') {
+            upper = true;
+            continue;
+        }
+        result[len] = if (upper) std.ascii.toUpper(c) else c;
+        len += 1;
+        upper = false;
+    }
+
+    const final = result[0..len].*;
+    return &final;
+}
+
+fn pascalCaseAlloc(allocator: std.mem.Allocator, name: []const u8) ![]const u8 {
+    var result: std.ArrayList(u8) = .empty;
+    defer result.deinit(allocator);
+
+    var upper = true;
+    for (name) |c| {
+        if (c == '_') {
+            upper = true;
+            continue;
+        }
+        try result.append(allocator, if (upper) std.ascii.toUpper(c) else c);
+        upper = false;
+    }
+
+    return result.toOwnedSlice(allocator);
+}
+
+fn isValidEnumTagName(name: []const u8) bool {
+    if (name.len == 0) return false;
+    if (std.zig.isUnderscore(name)) return false;
+
+    for (name, 0..) |c, i| {
+        switch (c) {
+            '_', 'a'...'z', 'A'...'Z' => {},
+            '0'...'9' => if (i == 0) return false,
+            else => return false,
+        }
+    }
+
+    return true;
+}
+
+fn stringSliceContains(haystack: []const []const u8, needle: []const u8) bool {
+    for (haystack) |value| {
+        if (std.mem.eql(u8, value, needle)) return true;
+    }
+    return false;
+}
+
+fn stringSlicesEql(a: []const []const u8, b: []const []const u8) bool {
+    if (a.len != b.len) return false;
+    for (a, b) |lhs, rhs| {
+        if (!std.mem.eql(u8, lhs, rhs)) return false;
+    }
+    return true;
+}
+
+fn emitEnumType(out: *std.ArrayList(u8), gpa: std.mem.Allocator, type_name: []const u8, values: []const []const u8) !void {
+    try out.print(gpa, "pub const {f} = enum {{\n", .{std.zig.fmtId(type_name)});
+    for (values) |value| {
+        try out.print(gpa, "    {f},\n", .{std.zig.fmtIdFlags(value, .{ .allow_primitive = true, .allow_underscore = true })});
+    }
+    try out.appendSlice(gpa, "};\n");
+}
+
+fn emitStringListLiteral(out: *std.ArrayList(u8), gpa: std.mem.Allocator, values: []const []const u8) !void {
+    try out.appendSlice(gpa, "&.{\n");
+    for (values) |value| {
+        try out.print(gpa, "    \"{f}\",\n", .{std.zig.fmtString(value)});
+    }
+    try out.appendSlice(gpa, "}");
+}
+
+fn emitEnumListLiteral(out: *std.ArrayList(u8), gpa: std.mem.Allocator, values: []const []const u8) !void {
+    try out.appendSlice(gpa, "&.{\n");
+    for (values) |value| {
+        try out.print(gpa, "    .{f},\n", .{std.zig.fmtIdFlags(value, .{ .allow_primitive = true, .allow_underscore = true })});
+    }
+    try out.appendSlice(gpa, "}");
+}
+
+fn isIntType(comptime t: []const u8) bool {
+    return for ([_][]const u8{
+        "i8",     "u8",      "i16",        "u16",         "i32",     "u32",      "i64",   "u64",
+        "i128",   "u128",    "isize",      "usize",       "c_short", "c_ushort", "c_int", "c_uint",
+        "c_long", "c_ulong", "c_longlong", "c_ulonglong",
+    }) |valid| {
+        if (std.mem.eql(u8, t, valid)) break true;
+    } else false;
+}
+
+fn isFloatType(comptime t: []const u8) bool {
+    return for ([_][]const u8{
+        "f16", "f32", "f64", "f80", "f128", "c_longdouble",
+    }) |valid| {
+        if (std.mem.eql(u8, t, valid)) break true;
+    } else false;
+}
+
+// --- Tests ---
+
+test "toStringSlice" {
+    const result = comptime toStringSlice(.{ "hello", "world" });
+    try std.testing.expectEqual(2, result.len);
+    try std.testing.expectEqualStrings("hello", result[0]);
+    try std.testing.expectEqualStrings("world", result[1]);
+}
+
+test "toStringSlice empty" {
+    const result = comptime toStringSlice(.{});
+    try std.testing.expectEqual(0, result.len);
+}
+
+test "toComptimeStringSlice" {
+    const result = comptime toComptimeStringSlice(.{ .debug, "info", .warn });
+    try std.testing.expectEqual(3, result.len);
+    try std.testing.expectEqualStrings("debug", result[0]);
+    try std.testing.expectEqualStrings("info", result[1]);
+    try std.testing.expectEqualStrings("warn", result[2]);
+}
+
+test "isIntType" {
+    try std.testing.expect(comptime isIntType("i32"));
+    try std.testing.expect(comptime isIntType("u64"));
+    try std.testing.expect(comptime isIntType("usize"));
+    try std.testing.expect(comptime isIntType("c_int"));
+    try std.testing.expect(!comptime isIntType("f32"));
+    try std.testing.expect(!comptime isIntType("bool"));
+    try std.testing.expect(!comptime isIntType("string"));
+}
+
+test "isFloatType" {
+    try std.testing.expect(comptime isFloatType("f32"));
+    try std.testing.expect(comptime isFloatType("f64"));
+    try std.testing.expect(comptime isFloatType("c_longdouble"));
+    try std.testing.expect(!comptime isFloatType("i32"));
+    try std.testing.expect(!comptime isFloatType("bool"));
+}
+
+test "hasModule" {
+    const manifest = .{
+        .modules = .{
+            .core = .{ .root_source_file = "src/core.zig" },
+            .utils = .{ .root_source_file = "src/utils.zig" },
+        },
+    };
+    try std.testing.expect(comptime hasModule(manifest, "core"));
+    try std.testing.expect(comptime hasModule(manifest, "utils"));
+    try std.testing.expect(!comptime hasModule(manifest, "missing"));
+    // No modules section at all
+    try std.testing.expect(!comptime hasModule(.{}, "anything"));
+}
+
+test "hasArtifact" {
+    const manifest = .{
+        .executables = .{ .myapp = .{ .root_module = .{ .root_source_file = "src/main.zig" } } },
+        .libraries = .{ .mylib = .{ .root_module = .{ .root_source_file = "src/lib.zig" } } },
+    };
+    try std.testing.expect(comptime hasArtifact(manifest, "myapp"));
+    try std.testing.expect(comptime hasArtifact(manifest, "mylib"));
+    try std.testing.expect(!comptime hasArtifact(manifest, "missing"));
+}
+
+test "hasDependency" {
+    const manifest = .{
+        .dependencies = .{
+            .zlib = .{},
+        },
+    };
+    try std.testing.expect(comptime hasDependency(manifest, "zlib"));
+    try std.testing.expect(!comptime hasDependency(manifest, "missing"));
+}
+
+test "hasStepTarget" {
+    const manifest = .{
+        .executables = .{ .myapp = .{ .root_module = .{ .root_source_file = "src/main.zig" } } },
+        .tests = .{ .unit = .{ .root_module = .{ .root_source_file = "src/test.zig" } } },
+        .runs = .{ .deploy = .{ "echo", "deploy" } },
+        .fmts = .{ .src = .{ .paths = .{"src"} } },
+    };
+    // Executable steps
+    try std.testing.expect(comptime hasStepTarget(manifest, "build-exe:myapp"));
+    try std.testing.expect(comptime hasStepTarget(manifest, "run:myapp"));
+    try std.testing.expect(!comptime hasStepTarget(manifest, "run:missing"));
+    // Test steps
+    try std.testing.expect(comptime hasStepTarget(manifest, "test:unit"));
+    try std.testing.expect(comptime hasStepTarget(manifest, "build-test:unit"));
+    // Run steps
+    try std.testing.expect(comptime hasStepTarget(manifest, "cmd:deploy"));
+    try std.testing.expect(!comptime hasStepTarget(manifest, "cmd:missing"));
+    // Fmt steps
+    try std.testing.expect(comptime hasStepTarget(manifest, "fmt:src"));
+    // Unknown prefix
+    try std.testing.expect(!comptime hasStepTarget(manifest, "bogus:myapp"));
+}
+
+test "validateManifest accepts step references in depends_on" {
+    comptime validateManifest(.{
+        .name = .myproject,
+        .version = "0.1.0",
+        .fingerprint = 0x1234,
+        .minimum_zig_version = "0.16.0",
+        .paths = .{"."},
+        .executables = .{
+            .myapp = .{ .root_module = .{ .root_source_file = "src/main.zig" } },
+        },
+        .tests = .{
+            .unit = .{ .root_module = .{ .root_source_file = "src/test.zig" } },
+        },
+        .runs = .{
+            .deploy = .{
+                .cmd = .{"./deploy.sh"},
+                .depends_on = .{ .myapp, "test:unit" },
+            },
+        },
+    }, .{});
+}
+
+test "validateManifest accepts manual build.zig string refs" {
+    comptime validateManifest(.{
+        .name = .myproject,
+        .version = "0.1.0",
+        .fingerprint = 0x1234,
+        .minimum_zig_version = "0.16.0",
+        .paths = .{"."},
+        .modules = .{
+            .core = .{
+                .root_source_file = "src/core.zig",
+                .imports = .{"shared"},
+            },
+        },
+        .executables = .{
+            .myapp = .{
+                .root_module = "shared",
+                .depends_on = .{"gen:prep"},
+            },
+        },
+        .runs = .{
+            .deploy = .{
+                .cmd = .{"./deploy.sh"},
+                .depends_on = .{"gen:prep"},
+            },
+        },
+    }, .{});
+}
+
+test "isImportable" {
+    const manifest = .{
+        .modules = .{
+            .core = .{ .root_source_file = "src/core.zig" },
+        },
+        .options_modules = .{
+            .config = .{ .some_flag = .{ .type = .bool } },
+        },
+        .dependencies = .{
+            .zlib = .{},
+        },
+    };
+    // Module is importable
+    try std.testing.expect(comptime isImportable(manifest, "core"));
+    // Options module is importable
+    try std.testing.expect(comptime isImportable(manifest, "config"));
+    // Dependency is importable (plain name)
+    try std.testing.expect(comptime isImportable(manifest, "zlib"));
+    // Dependency sub-module is importable (colon-separated)
+    try std.testing.expect(comptime isImportable(manifest, "zlib:zlib"));
+    // Invalid dependency import syntax is rejected
+    try std.testing.expect(!comptime isImportable(manifest, "zlib:"));
+    try std.testing.expect(!comptime isImportable(manifest, "zlib:zlib:extra"));
+    // Unknown is not importable
+    try std.testing.expect(!comptime isImportable(manifest, "missing"));
+}
+
+test "comptimeBaseName" {
+    try std.testing.expectEqualStrings("zlib", comptime comptimeBaseName("zlib"));
+    try std.testing.expectEqualStrings("zlib", comptime comptimeBaseName("zlib:zlib"));
+    try std.testing.expectEqualStrings("foo", comptime comptimeBaseName("foo:bar:baz"));
+    try std.testing.expectEqualStrings("", comptime comptimeBaseName(""));
+}
+
+test "comptimeAfterSep" {
+    try std.testing.expectEqualStrings("zlib", comptime comptimeAfterSep("zlib"));
+    try std.testing.expectEqualStrings("zlib", comptime comptimeAfterSep("dep:zlib"));
+    try std.testing.expectEqualStrings("bar:baz", comptime comptimeAfterSep("foo:bar:baz"));
+    try std.testing.expectEqualStrings("", comptime comptimeAfterSep(""));
+}
+
+test "toComptimeString" {
+    try std.testing.expectEqualStrings("hello", comptime toComptimeString("hello"));
+    try std.testing.expectEqualStrings("world", comptime toComptimeString(.world));
+}
+
+test "inlineRootModuleName" {
+    try std.testing.expectEqualStrings("demo", comptime inlineRootModuleName("demo", .{
+        .root_source_file = "src/main.zig",
+    }));
+    try std.testing.expectEqualStrings("custom_name", comptime inlineRootModuleName("demo", .{
+        .root_source_file = "src/main.zig",
+        .name = "custom_name",
+    }));
+}
+
+test "countSeparators" {
+    try std.testing.expectEqual(@as(usize, 0), countSeparators("plain", ':'));
+    try std.testing.expectEqual(@as(usize, 1), countSeparators("dep:module", ':'));
+    try std.testing.expectEqual(@as(usize, 2), countSeparators("dep:wf:path", ':'));
+}
+
+test "comptimePascalCase" {
+    try std.testing.expectEqualStrings("LogLevel", comptime comptimePascalCase("log_level"));
+    try std.testing.expectEqualStrings("EnabledLevels", comptime comptimePascalCase("enabled_levels"));
+    try std.testing.expectEqualStrings("Http2", comptime comptimePascalCase("http2"));
+}
+
+test "resolvedOptionTypeName" {
+    try std.testing.expectEqualStrings("LogLevel", comptime resolvedOptionTypeName("log_level", .{
+        .type = .@"enum",
+        .values = .{ .debug, .info, .warn },
+    }));
+    try std.testing.expectEqualStrings("Verbosity", comptime resolvedOptionTypeName("log_level", .{
+        .type = .@"enum",
+        .type_name = "Verbosity",
+        .values = .{ .debug, .info, .warn },
+    }));
+}
+
+test "validateManifest accepts typed options modules" {
+    comptime validateManifest(.{
+        .name = .myproject,
+        .version = "0.1.0",
+        .fingerprint = 0x1234,
+        .minimum_zig_version = "0.16.0",
+        .paths = .{"."},
+        .options_modules = .{
+            .config = .{
+                .verbose = .{
+                    .type = .bool,
+                    .default = false,
+                },
+                .log_level = .{
+                    .type = .@"enum",
+                    .values = .{ .debug, .info, .warn },
+                    .default = .info,
+                },
+                .enabled_levels = .{
+                    .type = .enum_list,
+                    .values = .{ .debug, .info, .warn },
+                    .default = .{ .info, .warn },
+                },
+                .output_dir = .{
+                    .type = .string,
+                },
+            },
+        },
+    }, .{});
+}
+
+test "validateManifest accepts presets for options modules" {
+    comptime validateManifest(.{
+        .name = .myproject,
+        .version = "0.1.0",
+        .fingerprint = 0x1234,
+        .minimum_zig_version = "0.16.0",
+        .paths = .{"."},
+        .options_modules = .{
+            .config = .{
+                .verbose = .{
+                    .type = .bool,
+                    .default = false,
+                },
+                .log_level = .{
+                    .type = .@"enum",
+                    .values = .{ .debug, .info, .warn },
+                    .default = .info,
+                },
+                .output_dir = .{
+                    .type = .string,
+                },
+            },
+        },
+        .presets = .{
+            .dev = .{
+                .config = .{
+                    .verbose = true,
+                    .log_level = .debug,
+                },
+            },
+            .release = .{
+                .config = .{
+                    .log_level = .warn,
+                    .output_dir = "dist",
+                },
+            },
+        },
+    }, .{});
+}
+
+test "validateManifest accepts minimal manifest" {
+    comptime validateManifest(.{
+        .name = .myproject,
+        .version = "0.1.0",
+        .fingerprint = 0x1234,
+        .minimum_zig_version = "0.16.0",
+        .paths = .{"."},
+    }, .{});
+}
+
+test "validateManifest accepts valid cross-references" {
+    comptime validateManifest(.{
+        .name = .myproject,
+        .version = "0.1.0",
+        .fingerprint = 0x1234,
+        .minimum_zig_version = "0.16.0",
+        .paths = .{"."},
+        .modules = .{
+            .core = .{ .root_source_file = "src/core.zig" },
+        },
+        .executables = .{
+            .myapp = .{
+                .root_module = .core,
+            },
+        },
+        .libraries = .{
+            .mylib = .{
+                .root_module = .{
+                    .root_source_file = "src/lib.zig",
+                    .imports = .{.core},
+                },
+            },
+        },
+    }, .{});
+}
+
+test "validateManifest accepts unknown top-level fields" {
+    // Top-level unknown fields may belong to Zig itself, so zbuild leaves them alone.
+    comptime validateManifest(.{
+        .name = .myproject,
+        .version = "0.1.0",
+        .fingerprint = 0x1234,
+        .minimum_zig_version = "0.16.0",
+        .paths = .{"."},
+        .some_future_zig_field = "should be ignored",
+    }, .{});
+}
+
+test "validateManifest accepts short-form runs" {
+    comptime validateManifest(.{
+        .name = .myproject,
+        .version = "0.1.0",
+        .fingerprint = 0x1234,
+        .minimum_zig_version = "0.16.0",
+        .paths = .{"."},
+        .runs = .{
+            .fmt = .{ "zig", "fmt", "src" },
+        },
+    }, .{});
+}
+
+test "validateManifest accepts long-form runs" {
+    comptime validateManifest(.{
+        .name = .myproject,
+        .version = "0.1.0",
+        .fingerprint = 0x1234,
+        .minimum_zig_version = "0.16.0",
+        .paths = .{"."},
+        .executables = .{
+            .myapp = .{ .root_module = .{ .root_source_file = "src/main.zig" } },
+        },
+        .runs = .{
+            .deploy = .{
+                .cmd = .{"./deploy.sh"},
+                .cwd = "scripts",
+                .env = .{ .NODE_ENV = "production" },
+                .depends_on = .{.myapp},
+            },
+        },
+    }, .{});
+}
+
+test "validateManifest accepts run and executable with same name" {
+    comptime validateManifest(.{
+        .name = .myproject,
+        .version = "0.1.0",
+        .fingerprint = 0x1234,
+        .minimum_zig_version = "0.16.0",
+        .paths = .{"."},
+        .executables = .{
+            .deploy = .{ .root_module = .{ .root_source_file = "src/main.zig" } },
+        },
+        .runs = .{
+            .deploy = .{ "echo", "deploying" },
+        },
+    }, .{});
+}
diff --git a/src/cmd_build.zig b/src/cmd_build.zig
deleted file mode 100644
index d8b82f9..0000000
--- a/src/cmd_build.zig
+++ /dev/null
@@ -1,105 +0,0 @@
-const std = @import("std");
-const mem = std.mem;
-const Allocator = mem.Allocator;
-const fatal = std.process.fatal;
-
-const Config = @import("Config.zig");
-const Args = @import("Args.zig");
-const GlobalOptions = @import("GlobalOptions.zig");
-const sync = @import("cmd_sync.zig");
-const runZigBuild = @import("run_zig.zig").runZigBuild;
-
-/// Different kinds of zig build commands
-pub const BuildKind = enum {
-    build,
-    install,
-    uninstall,
-
-    build_exe,
-    build_lib,
-    build_obj,
-    build_test,
-    run,
-
-    @"test",
-    fmt,
-};
-
-pub const BuildOpts = struct {
-    kind: BuildKind,
-    cmd: ?[]const u8 = null,
-    args: []const []const u8,
-    stderr_behavior: ?std.process.Child.StdIo = .Inherit,
-    stdout_behavior: ?std.process.Child.StdIo = .Inherit,
-};
-
-fn usage(kind: BuildKind) void {
-    _ = kind;
-}
-
-fn list(kind: BuildKind, config: Config) void {
-    _ = kind;
-    _ = config;
-}
-
-pub fn parseArgs(args: *Args, kind: BuildKind, config: Config) BuildOpts {
-    switch (kind) {
-        .build, .install, .uninstall => return .{ .kind = kind, .args = args.rest() },
-        else => {},
-    }
-    const arg = args.peek() orelse return .{ .kind = kind, .args = args.rest() };
-    if (mem.eql(u8, arg, "--help") or mem.eql(u8, arg, "-h")) {
-        usage(kind);
-        return std.process.exit(0);
-    } else if (mem.eql(u8, arg, "--list") or mem.eql(u8, arg, "-l")) {
-        list(kind, config);
-        return std.process.exit(0);
-    } else if (mem.startsWith(u8, arg, "-")) {
-        if (kind == .build_exe or kind == .build_lib or kind == .build_obj or kind == .build_test) {
-            fatal("expected additional argument", .{});
-        }
-        return .{ .kind = kind, .args = args.rest() };
-    } else {
-        return .{ .kind = kind, .cmd = args.next() orelse fatal("expected command argument", .{}), .args = args.rest() };
-    }
-}
-
-pub fn exec(gpa: Allocator, arena: Allocator, global_opts: GlobalOptions, config: Config, opts: BuildOpts) !void {
-    if (!global_opts.no_sync) {
-        try sync.exec(gpa, arena, global_opts, config);
-    }
-    var step_name: [512]u8 = undefined;
-    const step = switch (opts.kind) {
-        .build => null,
-        .install => "install",
-        .uninstall => "uninstall",
-
-        .build_exe => try std.fmt.bufPrint(&step_name, "build-exe:{s}", .{opts.cmd orelse unreachable}),
-        .build_lib => try std.fmt.bufPrint(&step_name, "build-lib:{s}", .{opts.cmd orelse unreachable}),
-        .build_obj => try std.fmt.bufPrint(&step_name, "build-obj:{s}", .{opts.cmd orelse unreachable}),
-        .build_test => try std.fmt.bufPrint(&step_name, "build-test:{s}", .{opts.cmd orelse unreachable}),
-        .run => try std.fmt.bufPrint(&step_name, "run:{s}", .{opts.cmd orelse unreachable}),
-
-        .@"test" => if (opts.cmd) |c|
-            try std.fmt.bufPrint(&step_name, "test:{s}", .{c})
-        else
-            "test",
-        .fmt => if (opts.cmd) |c|
-            try std.fmt.bufPrint(&step_name, "fmt:{s}", .{c})
-        else
-            "fmt",
-    };
-
-    try runZigBuild(
-        gpa,
-        arena,
-        .{
-            .cwd = global_opts.project_dir,
-            .stderr_behavior = opts.stderr_behavior orelse .Inherit,
-            .stdout_behavior = opts.stdout_behavior orelse .Inherit,
-        },
-        global_opts.getZigEnv(),
-        step,
-        opts.args,
-    );
-}
diff --git a/src/cmd_fetch.zig b/src/cmd_fetch.zig
deleted file mode 100644
index 0c21796..0000000
--- a/src/cmd_fetch.zig
+++ /dev/null
@@ -1,245 +0,0 @@
-const std = @import("std");
-const GlobalOptions = @import("GlobalOptions.zig");
-const Args = @import("Args.zig");
-const Config = @import("Config.zig");
-const Manifest = @import("Manifest.zig");
-const runZigFetch = @import("run_zig.zig").runZigFetch;
-const Save = @import("run_zig.zig").ZigCmd.Fetch.Save;
-const mem = std.mem;
-const Allocator = mem.Allocator;
-const cleanExit = std.process.cleanExit;
-const fatal = std.process.fatal;
-
-const usage_fetch =
-    \\Usage: zbuild fetch [options] <url>
-    \\Usage: zbuild fetch [options] <path>
-    \\
-    \\    Copy a package into the global cache and print its hash.
-    \\    <url> must point to one of the following:
-    \\      - A git+http / git+https server for the package
-    \\      - A tarball file (with or without compression) containing
-    \\        package source
-    \\      - A git bundle file containing package source
-    \\
-    \\Examples:
-    \\
-    \\  zbuild fetch --save git+https://example.com/andrewrk/fun-example-tool.git
-    \\  zbuild fetch --save https://example.com/andrewrk/fun-example-tool/archive/refs/heads/master.tar.gz
-    \\
-    \\Options:
-    \\  -h, --help                    Print this help and exit
-    \\  --global-cache-dir [path]     Override path to global Zig cache directory
-    \\  --debug-hash                  Print verbose hash information to stdout
-    \\  --save                        Add the fetched package to build.zig.zon
-    \\  --save=[name]                 Add the fetched package to build.zig.zon as name
-    \\  --save-exact                  Add the fetched package to build.zig.zon, storing the URL verbatim
-    \\  --save-exact=[name]           Add the fetched package to build.zig.zon as name, storing the URL verbatim
-    \\
-;
-
-pub const Opts = struct {
-    save: Save = .no,
-    debug_hash: bool = false,
-    global_cache_dir: ?[]const u8 = null,
-    path_or_url: []const u8,
-};
-
-pub fn parseArgs(args: *Args) !Opts {
-    var opts: Opts = .{ .path_or_url = undefined };
-    var opt_path_or_url: ?[]const u8 = null;
-    while (args.next()) |arg| {
-        if (mem.startsWith(u8, arg, "-")) {
-            if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
-                const stdout = std.io.getStdOut().writer();
-                try stdout.writeAll(usage_fetch);
-                return std.process.exit(0);
-            } else if (mem.eql(u8, arg, "--global-cache-dir")) {
-                const value = args.next() orelse fatal("expected argument after '{s}'", .{arg});
-                opts.global_cache_dir = value;
-            } else if (mem.eql(u8, arg, "--debug-hash")) {
-                opts.debug_hash = true;
-            } else if (mem.eql(u8, arg, "--save")) {
-                opts.save = .{ .yes = null };
-            } else if (mem.startsWith(u8, arg, "--save=")) {
-                opts.save = .{ .yes = arg["--save=".len..] };
-            } else if (mem.eql(u8, arg, "--save-exact")) {
-                opts.save = .{ .exact = null };
-            } else if (mem.startsWith(u8, arg, "--save-exact=")) {
-                opts.save = .{ .exact = arg["--save-exact=".len..] };
-            } else {
-                fatal("unrecognized parameter: '{s}'", .{arg});
-            }
-        } else if (opt_path_or_url != null) {
-            fatal("unexpected extra parameter: '{s}'", .{arg});
-        } else {
-            opt_path_or_url = arg;
-        }
-    }
-    opts.path_or_url = opt_path_or_url orelse fatal("missing url or path parameter", .{});
-    return opts;
-}
-
-pub fn exec(
-    gpa: Allocator,
-    arena: Allocator,
-    global_opts: GlobalOptions,
-    opts: Opts,
-) !void {
-    switch (opts.save) {
-        .no => {
-            // just run zig fetch, no need to update the config
-            try runZigFetch(
-                gpa,
-                arena,
-                .{ .cwd = global_opts.project_dir },
-                global_opts.getZigEnv(),
-                opts.path_or_url,
-                opts.save,
-            );
-            return cleanExit();
-        },
-        else => {},
-    }
-
-    const zbuild_filename = try std.fs.path.join(gpa, &[_][]const u8{ global_opts.project_dir, global_opts.zbuild_file });
-    defer gpa.free(zbuild_filename);
-    const manifest_dir = try std.fs.cwd().openDir(global_opts.project_dir, .{});
-    // if the name is known, we can update the config without loading the manifest
-    // we first parse the manifest, run zig fetch, and then compare which dependency updated
-    // then we update the config with the new dependency
-    var old_manifest = try Manifest.load(gpa, arena, .{ .color = .auto, .dir = manifest_dir, .basename = "build.zig.zon" }) orelse fatal("failed to load manifest", .{});
-    defer old_manifest.deinit(gpa);
-
-    try runZigFetch(
-        gpa,
-        arena,
-        .{ .cwd = global_opts.project_dir },
-        global_opts.getZigEnv(),
-        opts.path_or_url,
-        opts.save,
-    );
-
-    var new_manifest = try Manifest.load(gpa, arena, .{ .color = .auto, .dir = manifest_dir, .basename = "build.zig.zon" }) orelse fatal("failed to load manifest", .{});
-    defer new_manifest.deinit(gpa);
-
-    for (new_manifest.dependencies.keys(), new_manifest.dependencies.values()) |n, new_dep| {
-        switch (new_dep.location) {
-            .url => |new_url| {
-                if (old_manifest.dependencies.get(n)) |old_dep| {
-                    if (old_dep.location == .url) {
-                        if (mem.eql(u8, new_url, old_dep.location.url)) {
-                            continue;
-                        }
-                    }
-                }
-            },
-            .path => |new_path| {
-                if (old_manifest.dependencies.get(n)) |old_dep| {
-                    if (old_dep.location == .path) {
-                        if (mem.eql(u8, new_path, old_dep.location.path)) {
-                            continue;
-                        }
-                    }
-                }
-            },
-        }
-        try updateConfigDependency(
-            gpa,
-            arena,
-            manifest_dir,
-            global_opts.zbuild_file,
-            n,
-            new_dep.location.url,
-            new_dep.hash,
-        );
-        break;
-    }
-    return cleanExit();
-}
-
-// Mostly copied from zig/src/main.zig
-// Allows us to update the config file with the new dependency without affecting comments and existing user formatting
-fn updateConfigDependency(
-    gpa: Allocator,
-    arena: Allocator,
-    dir: std.fs.Dir,
-    zbuild_file: []const u8,
-    dep_name: []const u8,
-    saved_path_or_url: []const u8,
-    package_hash_slice: ?[]const u8,
-) !void {
-    var manifest = Manifest.load(
-        gpa,
-        arena,
-        .{
-            .color = .auto,
-            .dir = dir,
-            .basename = zbuild_file,
-        },
-    ) catch |err| {
-        fatal("unable to open {s} file: {s}", .{ zbuild_file, @errorName(err) });
-    } orelse fatal("{s} file not found", .{zbuild_file});
-    defer manifest.deinit(gpa);
-
-    var fixups: std.zig.Ast.Fixups = .{};
-    defer fixups.deinit(gpa);
-
-    const new_node_init =
-        try std.fmt.allocPrint(arena,
-            \\.{{
-            \\            .url = "{}",
-            \\        }}
-        , .{
-            std.zig.fmtEscapes(saved_path_or_url),
-        });
-
-    const new_node_text = try std.fmt.allocPrint(arena, ".{p_} = {s},\n", .{
-        std.zig.fmtId(dep_name), new_node_init,
-    });
-
-    const dependencies_init = try std.fmt.allocPrint(arena, ".{{\n        {s}    }}", .{
-        new_node_text,
-    });
-
-    const dependencies_text = try std.fmt.allocPrint(arena, ".dependencies = {s},\n", .{
-        dependencies_init,
-    });
-
-    if (manifest.dependencies.get(dep_name)) |dep| {
-        const location_replace = try std.fmt.allocPrint(
-            arena,
-            "\"{}\"",
-            .{std.zig.fmtEscapes(saved_path_or_url)},
-        );
-        try fixups.replace_nodes_with_string.put(gpa, dep.location_node, location_replace);
-
-        if (package_hash_slice) |hash| {
-            const hash_replace = try std.fmt.allocPrint(
-                arena,
-                "\"{}\"",
-                .{std.zig.fmtEscapes(hash)},
-            );
-
-            try fixups.replace_nodes_with_string.put(gpa, dep.hash_node, hash_replace);
-        }
-    } else if (manifest.dependencies.count() > 0) {
-        // Add fixup for adding another dependency.
-        const deps = manifest.dependencies.values();
-        const last_dep_node = deps[deps.len - 1].node;
-        try fixups.append_string_after_node.put(gpa, last_dep_node, new_node_text);
-    } else if (manifest.dependencies_node != 0) {
-        // Add fixup for replacing the entire dependencies struct.
-        try fixups.replace_nodes_with_string.put(gpa, manifest.dependencies_node, dependencies_init);
-    } else {
-        // Add fixup for adding dependencies struct.
-        try fixups.append_string_after_node.put(gpa, manifest.version_node, dependencies_text);
-    }
-
-    var rendered = std.ArrayList(u8).init(gpa);
-    defer rendered.deinit();
-    try manifest.ast.renderToArrayList(&rendered, fixups);
-
-    dir.writeFile(.{ .sub_path = zbuild_file, .data = rendered.items }) catch |err| {
-        fatal("unable to write {s} file: {s}", .{ zbuild_file, @errorName(err) });
-    };
-}
diff --git a/src/cmd_init.zig b/src/cmd_init.zig
deleted file mode 100644
index 1406086..0000000
--- a/src/cmd_init.zig
+++ /dev/null
@@ -1,98 +0,0 @@
-const std = @import("std");
-const mem = std.mem;
-const Allocator = std.mem.Allocator;
-const GlobalOptions = @import("GlobalOptions.zig");
-const Config = @import("Config.zig");
-const sync = @import("cmd_sync.zig");
-const Package = @import("Package.zig");
-const Manifest = @import("Manifest.zig");
-
-pub fn exec(gpa: Allocator, arena: Allocator, global_opts: GlobalOptions) !void {
-    const cwd = try std.fs.cwd().realpathAlloc(gpa, global_opts.project_dir);
-    defer gpa.free(cwd);
-    const name = try sanitizeExampleName(arena, std.fs.path.basename(cwd));
-    const fingerprint = try std.fmt.allocPrint(
-        gpa,
-        "0x{x}",
-        .{Package.Fingerprint.generate(name).int()},
-    );
-    defer gpa.free(fingerprint);
-
-    var paths = [_][]const u8{ "build.zig", "build.zig.zon", "src" };
-
-    var config = Config{
-        .name = name,
-        .version = "0.1.0",
-        .minimum_zig_version = global_opts.version,
-        .fingerprint = fingerprint,
-        .paths = &paths,
-    };
-
-    try config.addExecutable(gpa, name, Config.Executable{ .root_module = .{ .module = .{
-        .root_source_file = "src/main.zig",
-    } } });
-
-    const zbuild_filename = try std.fs.path.join(gpa, &[_][]const u8{ cwd, global_opts.zbuild_file });
-    defer gpa.free(zbuild_filename);
-    try config.serializeToFile(zbuild_filename);
-
-    const src_dirname = try std.fs.path.join(gpa, &[_][]const u8{ cwd, "src" });
-    defer gpa.free(src_dirname);
-    std.fs.cwd().makeDir(src_dirname) catch |err| {
-        switch (err) {
-            error.PathAlreadyExists => {},
-            else => return err,
-        }
-    };
-    const main_filename = try std.fs.path.join(gpa, &[_][]const u8{ src_dirname, "main.zig" });
-    const main_file = try std.fs.cwd().createFile(main_filename, .{});
-    defer main_file.close();
-
-    try main_file.writeAll(main_bytes);
-
-    if (!global_opts.no_sync) {
-        try sync.exec(gpa, arena, global_opts, config);
-    }
-}
-
-const main_bytes =
-    \\//! By convention, main.zig is where your main function lives in the case that
-    \\//! you are building an executable. If you are making a library, the convention
-    \\//! is to delete this file and start with root.zig instead.
-    \\const std = @import("std");
-    \\
-    \\pub fn main() !void {
-    \\    // Prints to stderr (it's a shortcut based on `std.io.getStdErr()`)
-    \\    std.debug.print("All your {s} are belong to us.\n", .{"codebase"});
-    \\
-    \\    // stdout is for the actual output of your application, for example if you
-    \\    // are implementing gzip, then only the compressed bytes should be sent to
-    \\    // stdout, not any debugging messages.
-    \\    const stdout_file = std.io.getStdOut().writer();
-    \\    var bw = std.io.bufferedWriter(stdout_file);
-    \\    const stdout = bw.writer();
-    \\
-    \\    try stdout.print("Run `zbuild test` to run the tests.\n", .{});
-    \\
-    \\    try bw.flush(); // Don't forget to flush!
-    \\}
-    \\
-;
-
-fn sanitizeExampleName(arena: Allocator, bytes: []const u8) error{OutOfMemory}![]const u8 {
-    var result: std.ArrayListUnmanaged(u8) = .empty;
-    for (bytes, 0..) |byte, i| switch (byte) {
-        '0'...'9' => {
-            if (i == 0) try result.append(arena, '_');
-            try result.append(arena, byte);
-        },
-        '_', 'a'...'z', 'A'...'Z' => try result.append(arena, byte),
-        '-', '.', ' ' => try result.append(arena, '_'),
-        else => continue,
-    };
-    if (!std.zig.isValidId(result.items)) return "foo";
-    if (result.items.len > Manifest.max_name_len)
-        result.shrinkRetainingCapacity(Manifest.max_name_len);
-
-    return result.toOwnedSlice(arena);
-}
diff --git a/src/cmd_sync.zig b/src/cmd_sync.zig
deleted file mode 100644
index a8d1c5e..0000000
--- a/src/cmd_sync.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const std = @import("std");
-const mem = std.mem;
-const Allocator = std.mem.Allocator;
-const fatal = std.process.fatal;
-const GlobalOptions = @import("GlobalOptions.zig");
-const Config = @import("Config.zig");
-const syncBuildFile = @import("sync_build_file.zig").syncBuildFile;
-const syncManifest = @import("sync_manifest.zig").syncManifest;
-
-pub fn exec(gpa: Allocator, arena: Allocator, global_opts: GlobalOptions, config: Config) !void {
-    if (global_opts.no_sync) {
-        fatal("--no-sync is incompatible with the sync command", .{});
-    }
-    try syncBuildFile(gpa, arena, config, global_opts, .{ .out_dir = global_opts.project_dir });
-    try syncManifest(gpa, arena, global_opts, config, .{ .out_dir = global_opts.project_dir });
-}
diff --git a/src/help.zig b/src/help.zig
new file mode 100644
index 0000000..a4cb0b7
--- /dev/null
+++ b/src/help.zig
@@ -0,0 +1,270 @@
+const std = @import("std");
+const build_runner = @import("build_runner.zig");
+const toComptimeString = build_runner.toComptimeString;
+
+pub fn buildHelpText(comptime manifest: anytype) []const u8 {
+    var text: []const u8 = "";
+
+    // Header
+    if (@hasField(@TypeOf(manifest), "name"))
+        text = text ++ @tagName(manifest.name);
+    if (@hasField(@TypeOf(manifest), "version"))
+        text = text ++ " v" ++ manifest.version;
+    if (@hasField(@TypeOf(manifest), "description"))
+        text = text ++ " — " ++ manifest.description;
+    text = text ++ "\n";
+
+    // Modules
+    if (@hasField(@TypeOf(manifest), "modules")) {
+        const fields = @typeInfo(@TypeOf(manifest.modules)).@"struct".fields;
+        if (fields.len > 0) {
+            text = text ++ "\nModules:\n";
+            inline for (fields) |field| {
+                const mod = @field(manifest.modules, field.name);
+                text = text ++ "  " ++ comptimePad(field.name, 22);
+                if (@hasField(@TypeOf(mod), "root_source_file"))
+                    text = text ++ mod.root_source_file;
+                text = text ++ "\n";
+            }
+        }
+    }
+
+    // Executables
+    if (@hasField(@TypeOf(manifest), "executables")) {
+        const fields = @typeInfo(@TypeOf(manifest.executables)).@"struct".fields;
+        if (fields.len > 0) {
+            text = text ++ "\nExecutables:" ++ comptimePad("", 10) ++ "zig build run:<name>\n";
+            inline for (fields) |field| {
+                const exe = @field(manifest.executables, field.name);
+                text = text ++ "  " ++ comptimePad(field.name, 22) ++ describeRootModule(exe.root_module) ++ "\n";
+            }
+        }
+    }
+
+    // Libraries
+    if (@hasField(@TypeOf(manifest), "libraries")) {
+        const fields = @typeInfo(@TypeOf(manifest.libraries)).@"struct".fields;
+        if (fields.len > 0) {
+            text = text ++ "\nLibraries:" ++ comptimePad("", 12) ++ "zig build build-lib:<name>\n";
+            inline for (fields) |field| {
+                const lib = @field(manifest.libraries, field.name);
+                text = text ++ "  " ++ comptimePad(field.name, 22) ++ describeRootModule(lib.root_module) ++ "\n";
+            }
+        }
+    }
+
+    // Objects
+    if (@hasField(@TypeOf(manifest), "objects")) {
+        const fields = @typeInfo(@TypeOf(manifest.objects)).@"struct".fields;
+        if (fields.len > 0) {
+            text = text ++ "\nObjects:" ++ comptimePad("", 14) ++ "zig build build-obj:<name>\n";
+            inline for (fields) |field| {
+                const obj = @field(manifest.objects, field.name);
+                text = text ++ "  " ++ comptimePad(field.name, 22) ++ describeRootModule(obj.root_module) ++ "\n";
+            }
+        }
+    }
+
+    // Tests
+    if (@hasField(@TypeOf(manifest), "tests")) {
+        const fields = @typeInfo(@TypeOf(manifest.tests)).@"struct".fields;
+        if (fields.len > 0) {
+            text = text ++ "\nTests:" ++ comptimePad("", 16) ++ "zig build test:<name> | zig build test\n";
+            inline for (fields) |field| {
+                const t = @field(manifest.tests, field.name);
+                text = text ++ "  " ++ comptimePad(field.name, 22) ++ describeRootModule(t.root_module) ++ "\n";
+            }
+        }
+    }
+
+    // Fmts
+    if (@hasField(@TypeOf(manifest), "fmts")) {
+        const fields = @typeInfo(@TypeOf(manifest.fmts)).@"struct".fields;
+        if (fields.len > 0) {
+            text = text ++ "\nFmts:" ++ comptimePad("", 17) ++ "zig build fmt:<name> | zig build fmt\n";
+            inline for (fields) |field| {
+                const fmt = @field(manifest.fmts, field.name);
+                text = text ++ "  " ++ comptimePad(field.name, 22);
+                if (@hasField(@TypeOf(fmt), "paths"))
+                    text = text ++ "paths: " ++ comptimeJoinTuple(fmt.paths);
+                text = text ++ "\n";
+            }
+        }
+    }
+
+    // Runs
+    if (@hasField(@TypeOf(manifest), "runs")) {
+        const fields = @typeInfo(@TypeOf(manifest.runs)).@"struct".fields;
+        if (fields.len > 0) {
+            text = text ++ "\nRuns:" ++ comptimePad("", 17) ++ "zig build cmd:<name>\n";
+            inline for (fields) |field| {
+                const run = @field(manifest.runs, field.name);
+                text = text ++ "  " ++ comptimePad(field.name, 22) ++ describeRunCmd(run) ++ "\n";
+            }
+        }
+    }
+
+    // Options modules
+    if (@hasField(@TypeOf(manifest), "options_modules")) {
+        const mod_fields = @typeInfo(@TypeOf(manifest.options_modules)).@"struct".fields;
+        if (mod_fields.len > 0) {
+            text = text ++ "\nOptions:" ++ comptimePad("", 14) ++ "-D<module>.<option>=<value>\n";
+            inline for (mod_fields) |mod_field| {
+                const options = @field(manifest.options_modules, mod_field.name);
+                inline for (@typeInfo(@TypeOf(options)).@"struct".fields) |opt_field| {
+                    const opt = @field(options, opt_field.name);
+                    text = text ++ "  " ++ comptimePad(mod_field.name ++ "." ++ opt_field.name, 22);
+                    text = text ++ toComptimeString(opt.type);
+                    if (@hasField(@TypeOf(opt), "default"))
+                        text = text ++ " (default: " ++ describeValue(opt.default) ++ ")";
+                    if ((std.mem.eql(u8, toComptimeString(opt.type), "enum") or std.mem.eql(u8, toComptimeString(opt.type), "enum_list")) and @hasField(@TypeOf(opt), "values"))
+                        text = text ++ " values: " ++ comptimeJoinValues(opt.values);
+                    if (@hasField(@TypeOf(opt), "description"))
+                        text = text ++ " — " ++ opt.description;
+                    text = text ++ "\n";
+                }
+            }
+        }
+    }
+
+    // Dependencies
+    if (@hasField(@TypeOf(manifest), "dependencies")) {
+        const fields = @typeInfo(@TypeOf(manifest.dependencies)).@"struct".fields;
+        if (fields.len > 0) {
+            text = text ++ "\nDependencies:\n";
+            inline for (fields) |field| {
+                text = text ++ "  " ++ field.name ++ "\n";
+            }
+        }
+    }
+
+    return text;
+}
+
+pub fn comptimePad(comptime s: []const u8, comptime width: usize) []const u8 {
+    if (s.len >= width) return s ++ " ";
+    const padding = [1]u8{' '} ** (width - s.len);
+    return s ++ &padding;
+}
+
+fn describeRootModule(comptime root_module: anytype) []const u8 {
+    const ti = @typeInfo(@TypeOf(root_module));
+    if (ti == .enum_literal) return "module: " ++ @tagName(root_module);
+    if (ti == .pointer) return "module: " ++ @as([]const u8, root_module);
+    if (@hasField(@TypeOf(root_module), "root_source_file"))
+        return root_module.root_source_file;
+    return "(inline module)";
+}
+
+fn describeRunCmd(comptime cmd: anytype) []const u8 {
+    if (@hasField(@TypeOf(cmd), "cmd")) return comptimeJoinTuple(cmd.cmd);
+    return comptimeJoinTuple(cmd);
+}
+
+fn comptimeJoinTuple(comptime tuple: anytype) []const u8 {
+    const fields = @typeInfo(@TypeOf(tuple)).@"struct".fields;
+    var result: []const u8 = "";
+    inline for (fields, 0..) |field, i| {
+        if (i > 0) result = result ++ " ";
+        result = result ++ @field(tuple, field.name);
+    }
+    return result;
+}
+
+fn comptimeJoinValues(comptime tuple: anytype) []const u8 {
+    const fields = @typeInfo(@TypeOf(tuple)).@"struct".fields;
+    var result: []const u8 = "";
+    inline for (fields, 0..) |field, i| {
+        if (i > 0) result = result ++ ", ";
+        result = result ++ describeValue(@field(tuple, field.name));
+    }
+    return result;
+}
+
+pub fn describeValue(comptime val: anytype) []const u8 {
+    const ti = @typeInfo(@TypeOf(val));
+    if (ti == .enum_literal) return @tagName(val);
+    if (ti == .pointer) return val;
+    if (ti == .bool) return if (val) "true" else "false";
+    if (ti == .comptime_int or ti == .int) return std.fmt.comptimePrint("{d}", .{val});
+    if (ti == .comptime_float or ti == .float) return std.fmt.comptimePrint("{d}", .{val});
+    return "...";
+}
+
+// --- Tests ---
+
+test "buildHelpText minimal" {
+    const text = comptime buildHelpText(.{
+        .name = .myproject,
+        .version = "0.1.0",
+    });
+    try std.testing.expect(std.mem.indexOf(u8, text, "myproject v0.1.0") != null);
+}
+
+test "buildHelpText full manifest" {
+    const text = comptime buildHelpText(.{
+        .name = .myproject,
+        .version = "1.0.0",
+        .description = "A test project",
+        .modules = .{
+            .core = .{ .root_source_file = "src/core.zig" },
+        },
+        .executables = .{
+            .myapp = .{ .root_module = .core },
+        },
+        .tests = .{
+            .unit = .{ .root_module = .core },
+        },
+        .runs = .{
+            .fmt = .{ "zig", "fmt", "src" },
+            .deploy = .{ .cmd = .{ "./deploy.sh", "--prod" } },
+        },
+        .options_modules = .{
+            .config = .{
+                .verbose = .{ .type = .bool, .default = false, .description = "Verbose output" },
+                .log_level = .{
+                    .type = .@"enum",
+                    .values = .{ .debug, .info, .warn },
+                    .default = .info,
+                    .description = "Log level",
+                },
+            },
+        },
+        .dependencies = .{
+            .zlib = .{},
+        },
+    });
+    try std.testing.expect(std.mem.indexOf(u8, text, "myproject v1.0.0 — A test project") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "Modules:") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "core") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "src/core.zig") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "Executables:") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "module: core") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "Tests:") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "Runs:") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "zig fmt src") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "./deploy.sh --prod") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "Options:") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "-D<module>.<option>=<value>") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "config.verbose") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "config.log_level") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "bool") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "values: debug, info, warn") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "default: false") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "Verbose output") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "Dependencies:") != null);
+    try std.testing.expect(std.mem.indexOf(u8, text, "zlib") != null);
+}
+
+test "comptimePad" {
+    try std.testing.expectEqualStrings("hi    ", comptime comptimePad("hi", 6));
+    try std.testing.expectEqualStrings("toolong ", comptime comptimePad("toolong", 4));
+}
+
+test "describeValue" {
+    try std.testing.expectEqualStrings("true", comptime describeValue(true));
+    try std.testing.expectEqualStrings("false", comptime describeValue(false));
+    try std.testing.expectEqualStrings("hello", comptime describeValue("hello"));
+    try std.testing.expectEqualStrings("info", comptime describeValue(.info));
+    try std.testing.expectEqualStrings("42", comptime describeValue(42));
+}
diff --git a/src/main.zig b/src/main.zig
deleted file mode 100644
index 39226e3..0000000
--- a/src/main.zig
+++ /dev/null
@@ -1,163 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const process = std.process;
-const Allocator = std.mem.Allocator;
-const mem = std.mem;
-
-pub const Config = @import("Config.zig");
-pub const ConfigBuildgen = @import("ConfigBuildgen.zig");
-pub const Args = @import("Args.zig");
-pub const GlobalOptions = @import("GlobalOptions.zig");
-
-pub const init = @import("cmd_init.zig");
-pub const fetch = @import("cmd_fetch.zig");
-pub const build = @import("cmd_build.zig");
-pub const sync = @import("cmd_sync.zig");
-const fatal = std.process.fatal;
-
-pub const std_options: std.Options = .{
-    .log_level = .info,
-};
-
-const usage =
-    \\Usage: zbuild [global_options] [command] [options]
-    \\
-    \\Commands:
-    \\
-    \\  init             Initialize a Zig package in the current directory
-    \\  fetch            Copy a package into global cache
-    \\
-    \\  install          Install all artifacts
-    \\  uninstall        Uninstall all artifacts
-    \\  build            Run `zig build`
-    \\  sync             Sync build.zig and build.zig.zon
-    \\  build-exe        Build an executable
-    \\  build-lib        Build a library
-    \\  build-obj        Build an object file
-    \\  build-test       Build a test into an executable
-    \\  run              Run an executable or run script
-    \\  test             Perform unit testing
-    \\  fmt              Format source code
-    \\
-    \\  help             Print this help and exit
-    \\  version          Print version number and exit
-    \\
-    \\Global Options:
-    \\
-    \\  --zig-exe [path]              Override path to Zig executable
-    \\  --global-cache-dir [path]     Override path to global Zig cache directory
-    \\  --zig-lib-dir [path]          Override path to Zig library directory
-    \\  --zig-std-dir [path]          Override path to Zig standard library directory
-    \\  --project-dir [path]          Override path to project directory
-    \\  --zbuild-file [path]          Override path to zbuild file
-    \\  --no-sync                     Skip automatic synchronization of build.zig and build.zig.zon
-    \\
-    \\General Options:
-    \\
-    \\  -h, --help       Print command-specific usage
-    \\
-;
-
-pub fn main() anyerror!void {
-    // Here we use an ArenaAllocator because a build is a short-lived,
-    // one shot program. We don't need to waste time freeing memory and finding places to squish
-    // bytes into. So we free everything all at once at the very end.
-    var gpa = std.heap.DebugAllocator(.{}){};
-    const gpa_allocator = gpa.allocator();
-    var arena_instance = std.heap.ArenaAllocator.init(gpa_allocator);
-    defer arena_instance.deinit();
-    const arena = arena_instance.allocator();
-
-    var args = try Args.initFromProcessArgs(arena);
-    _ = args.next();
-
-    return mainArgs(gpa_allocator, arena, &args);
-}
-
-fn mainArgs(gpa: Allocator, arena: Allocator, args: *Args) !void {
-    const first_arg = args.peek() orelse {
-        cmdUsage();
-        fatal("expected command argument", .{});
-    };
-
-    // commands that shouldn't ever have any side effects
-    if (mem.eql(u8, first_arg, "help") or mem.eql(u8, first_arg, "--help") or mem.eql(u8, first_arg, "-h")) {
-        cmdUsage();
-        return;
-    } else if (mem.eql(u8, first_arg, "version")) {
-        std.log.info("zig version: {s}", .{builtin.zig_version_string});
-        return;
-    }
-
-    const global_opts = try GlobalOptions.parseArgs(gpa, args);
-    defer global_opts.deinit(gpa);
-
-    const cmd = args.next() orelse {
-        cmdUsage();
-        fatal("expected command argument", .{});
-    };
-
-    if (mem.eql(u8, cmd, "init")) {
-        try init.exec(gpa, arena, global_opts);
-        return;
-    }
-
-    var wip_bundle: std.zig.ErrorBundle.Wip = undefined;
-    try wip_bundle.init(gpa);
-    const config = Config.parseFromFile(arena, global_opts.zbuild_file, &wip_bundle) catch |err| switch (err) {
-        error.FileNotFound => {
-            fatal("no zbuild file found", .{});
-        },
-        error.OutOfMemory => {
-            fatal("out of memory", .{});
-        },
-        else => {
-            var error_bundle = try wip_bundle.toOwnedBundle("");
-            error_bundle.renderToStdErr(.{ .ttyconf = .escape_codes });
-            std.process.exit(1);
-        },
-    };
-
-    if (mem.eql(u8, cmd, "sync")) {
-        try sync.exec(gpa, arena, global_opts, config);
-    } else if (mem.eql(u8, cmd, "fetch")) {
-        try fetch.exec(
-            gpa,
-            arena,
-            global_opts,
-            try fetch.parseArgs(args),
-        );
-    } else {
-        var kind: build.BuildKind = undefined;
-        if (mem.eql(u8, cmd, "build")) {
-            kind = .build;
-        } else if (mem.eql(u8, cmd, "install")) {
-            kind = .install;
-        } else if (mem.eql(u8, cmd, "uninstall")) {
-            kind = .uninstall;
-        } else if (mem.eql(u8, cmd, "build-exe")) {
-            kind = .build_exe;
-        } else if (mem.eql(u8, cmd, "build-lib")) {
-            kind = .build_lib;
-        } else if (mem.eql(u8, cmd, "build-obj")) {
-            kind = .build_obj;
-        } else if (mem.eql(u8, cmd, "build-test")) {
-            kind = .build_test;
-        } else if (mem.eql(u8, cmd, "run")) {
-            kind = .run;
-        } else if (mem.eql(u8, cmd, "test")) {
-            kind = .@"test";
-        } else if (mem.eql(u8, cmd, "fmt")) {
-            kind = .fmt;
-        } else {
-            cmdUsage();
-            fatal("unknown command: {s}", .{cmd});
-        }
-        const opts = build.parseArgs(args, kind, config);
-        try build.exec(gpa, arena, global_opts, config, opts);
-    }
-}
-
-fn cmdUsage() void {
-    std.log.info("{s}", .{usage});
-}
diff --git a/src/run_zig.zig b/src/run_zig.zig
deleted file mode 100644
index 6fe5286..0000000
--- a/src/run_zig.zig
+++ /dev/null
@@ -1,128 +0,0 @@
-//! Simple wrapper around the `zig` executable.
-
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const ZigEnv = @import("ZigEnv.zig");
-
-pub fn runZigBuild(gpa: Allocator, arena: Allocator, child_opts: ChildOpts, env: ZigEnv, step: ?[]const u8, args: []const []const u8) !void {
-    try runZig(gpa, arena, child_opts, env, .{
-        .build = .{
-            .step = step,
-            .args = args,
-        },
-    });
-}
-
-pub fn runZigFetch(gpa: Allocator, arena: Allocator, child_opts: ChildOpts, env: ZigEnv, path_or_url: []const u8, save: ZigCmd.Fetch.Save) !void {
-    try runZig(gpa, arena, child_opts, env, .{
-        .fetch = .{
-            .path_or_url = path_or_url,
-            .save = save,
-        },
-    });
-}
-
-pub fn runZigFmt(gpa: Allocator, arena: Allocator, child_opts: ChildOpts, env: ZigEnv, args: []const []const u8) !void {
-    try runZig(gpa, arena, child_opts, env, .{
-        .fmt = .{
-            .args = args,
-        },
-    });
-}
-
-pub const ZigCmd = union(enum) {
-    build: Build,
-    fetch: Fetch,
-    fmt: Fmt,
-
-    pub const Build = struct {
-        step: ?[]const u8,
-        args: []const []const u8,
-    };
-
-    pub const Fetch = struct {
-        path_or_url: []const u8,
-        save: Save = .no,
-
-        pub const Save = union(enum) {
-            no,
-            yes: ?[]const u8,
-            exact: ?[]const u8,
-        };
-    };
-
-    pub const Fmt = struct {
-        args: []const []const u8,
-    };
-};
-
-pub const ChildOpts = struct {
-    cwd: ?[]const u8 = null,
-    stdout_behavior: std.process.Child.StdIo = .Inherit,
-    stderr_behavior: std.process.Child.StdIo = .Inherit,
-};
-
-pub fn runZig(gpa: Allocator, arena: Allocator, child_opts: ChildOpts, env: ZigEnv, cmd: ZigCmd) !void {
-    var argv = std.ArrayList([]const u8).init(gpa);
-    defer argv.deinit();
-
-    try argv.append(env.zig_exe);
-
-    switch (cmd) {
-        .build => |build| {
-            try argv.append("build");
-            if (build.step) |s| {
-                try argv.append(s);
-            }
-            try argv.appendSlice(build.args);
-        },
-        .fetch => |fetch| {
-            try argv.append("fetch");
-            try argv.append(fetch.path_or_url);
-            switch (fetch.save) {
-                .no => {},
-                .yes => |name| {
-                    if (name) |n| {
-                        const arg = try std.fmt.allocPrint(arena, "--save={s}", .{n});
-                        try argv.append(arg);
-                    } else {
-                        try argv.append("--save");
-                    }
-                },
-                .exact => |name| {
-                    if (name) |n| {
-                        const arg = try std.fmt.allocPrint(arena, "--save={s}", .{n});
-                        try argv.append(arg);
-                    } else {
-                        try argv.append("--save-exact");
-                    }
-                },
-            }
-        },
-        .fmt => |fmt| {
-            try argv.append("fmt");
-            try argv.appendSlice(fmt.args);
-        },
-    }
-
-    var child = std.process.Child.init(argv.items, gpa);
-    child.cwd = child_opts.cwd;
-    child.stdout_behavior = child_opts.stdout_behavior;
-    child.stderr_behavior = child_opts.stderr_behavior;
-
-    const term = try child.spawnAndWait();
-
-    switch (term) {
-        .Exited => |code| {
-            if (code == 0) {
-                return;
-            } else {
-                std.process.exit(code);
-            }
-        },
-        else => {},
-    }
-
-    std.process.exit(1);
-}
diff --git a/src/sync_build_file.zig b/src/sync_build_file.zig
deleted file mode 100644
index 6435de0..0000000
--- a/src/sync_build_file.zig
+++ /dev/null
@@ -1,38 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const Config = @import("Config.zig");
-const ConfigBuildgen = @import("ConfigBuildgen.zig");
-const GlobalOptions = @import("GlobalOptions.zig");
-const runZigFmt = @import("run_zig.zig").runZigFmt;
-
-pub const SyncBuildFileOpts = struct {
-    out_dir: ?[]const u8 = null,
-    build_file: ?[]const u8 = null,
-};
-
-const max_bytes_zbuild_file = 16_000;
-
-pub fn syncBuildFile(gpa: Allocator, arena: Allocator, config: Config, global_opts: GlobalOptions, opts: SyncBuildFileOpts) !void {
-    const build_root_directory = std.fs.cwd();
-
-    const out_dir = if (opts.out_dir) |o| try build_root_directory.openDir(o, .{}) else build_root_directory;
-    const out_file = try out_dir.createFile(opts.build_file orelse "build.zig", .{ .truncate = true });
-    errdefer out_file.close();
-    const writer = out_file.writer().any();
-
-    var buildgen = ConfigBuildgen.init(arena, config, writer);
-    defer buildgen.deinit();
-
-    try buildgen.write();
-
-    // after writing, close the file and format it with `zig fmt`, which modifies files in-place
-    out_file.close();
-    try runZigFmt(
-        gpa,
-        arena,
-        .{ .cwd = global_opts.project_dir, .stderr_behavior = .Ignore, .stdout_behavior = .Ignore },
-        global_opts.getZigEnv(),
-        &[_][]const u8{opts.build_file orelse "build.zig"},
-    );
-}
diff --git a/src/sync_manifest.zig b/src/sync_manifest.zig
deleted file mode 100644
index e9f64fc..0000000
--- a/src/sync_manifest.zig
+++ /dev/null
@@ -1,132 +0,0 @@
-const std = @import("std");
-const fatal = std.process.fatal;
-const builtin = @import("builtin");
-const Manifest = @import("Manifest.zig");
-const GlobalOptions = @import("GlobalOptions.zig");
-const strTupleLiteral = @import("ConfigBuildgen.zig").strTupleLiteral;
-const runZigFetch = @import("run_zig.zig").runZigFetch;
-
-const mem = std.mem;
-const Allocator = mem.Allocator;
-const Ast = std.zig.Ast;
-const Color = std.zig.Color;
-
-pub const SyncManifestOpts = struct {
-    out_dir: ?[]const u8 = null,
-};
-
-pub fn syncManifest(gpa: Allocator, arena: Allocator, global_opts: GlobalOptions, config: Config, opts: SyncManifestOpts) !void {
-    // naive strategy for now
-    // fetch existing manifest (if any)
-    // write new manifest based on config (except for dependencies, which get copied over from existing manifest)
-    // if any dependencies are different or added, call zig fetch on them
-
-    const build_root_directory = if (opts.out_dir) |manifest_dir|
-        try std.fs.cwd().openDir(manifest_dir, .{})
-    else
-        std.fs.cwd();
-    var manifest = try Manifest.load(gpa, arena, .{
-        .dir = build_root_directory,
-        .basename = "build.zig.zon",
-        .color = .auto,
-    });
-    defer {
-        if (manifest) |*m| {
-            m.ast.deinit(gpa);
-            m.deinit(gpa);
-        }
-    }
-
-    const new_manifest_bytes = try allocPrintManifest(gpa, config, manifest);
-    defer gpa.free(new_manifest_bytes);
-    try build_root_directory.writeFile(.{
-        .sub_path = "build.zig.zon",
-        .data = new_manifest_bytes,
-    });
-    if (config.dependencies) |dependencies| {
-        for (dependencies.keys(), dependencies.values()) |name, config_dep| {
-            if (manifest) |m| {
-                if (m.dependencies.get(name)) |manifest_dep| {
-                    if (depEql(manifest_dep, config_dep)) {
-                        continue;
-                    }
-                }
-            }
-            try runZigFetch(
-                gpa,
-                arena,
-                .{ .cwd = global_opts.project_dir },
-                global_opts.getZigEnv(),
-                config_dep.value,
-                .{ .exact = name },
-            );
-        }
-    }
-}
-
-pub const LoadManifestOptions = struct {
-    dir: std.fs.Dir,
-    basename: []const u8,
-    color: Color,
-};
-
-const Config = @import("Config.zig");
-
-const manifest_template =
-    \\// This file is generated by zbuild. Do not edit manually.
-    \\
-    \\.{{
-    \\    .name = .{s},
-    \\    .version = "{s}",
-    \\    .fingerprint = {s},
-    \\    .minimum_zig_version = "{s}",
-    \\    .dependencies = {s},
-    \\    .paths = {s},
-    \\}}
-    \\
-;
-
-fn allocPrintManifest(allocator: Allocator, config: Config, manifest: ?Manifest) ![]const u8 {
-    // TODO fix this
-    const paths: ?[][]const u8 = config.paths;
-    return try std.fmt.allocPrint(allocator, manifest_template, .{
-        config.name,
-        config.version,
-        config.fingerprint,
-        config.minimum_zig_version,
-        if (manifest) |m|
-            m.ast.getNodeSource(m.dependencies_node)
-        else
-            ".{}",
-        try strTupleLiteral(paths) orelse
-            \\.{ "build.zig", "build.zig.zon", "src" }
-        ,
-    });
-}
-
-fn depEql(manifest_dep: Manifest.Dependency, config_dep: Config.Dependency) bool {
-    if (config_dep.typ == .path and manifest_dep.location != .path) {
-        return false;
-    }
-    if (config_dep.typ == .url and manifest_dep.location != .url) {
-        return false;
-    }
-    const manifest_path_or_url = switch (manifest_dep.location) {
-        .path => |path| path,
-        .url => |url| url,
-    };
-    const config_path_or_url = config_dep.value;
-    const manifest_hash = manifest_dep.hash;
-    const config_hash = config_dep.hash;
-
-    if (!std.mem.eql(u8, manifest_path_or_url, config_path_or_url)) {
-        return false;
-    }
-    if (config_hash == null) {
-        return true;
-    }
-    if (manifest_hash == null) {
-        return false;
-    }
-    return std.mem.eql(u8, manifest_hash.?, config_hash.?);
-}
diff --git a/test/fixtures/alias_empty_depends_on/build.zig b/test/fixtures/alias_empty_depends_on/build.zig
new file mode 100644
index 0000000..1af7267
--- /dev/null
+++ b/test/fixtures/alias_empty_depends_on/build.zig
@@ -0,0 +1,6 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) !void {
+    _ = try zbuild.configureBuild(b, @import("build.zig.zon"), .{});
+}
diff --git a/test/fixtures/alias_empty_depends_on/build.zig.zon b/test/fixtures/alias_empty_depends_on/build.zig.zon
new file mode 100644
index 0000000..634698b
--- /dev/null
+++ b/test/fixtures/alias_empty_depends_on/build.zig.zon
@@ -0,0 +1,16 @@
+.{
+    .name = .alias_empty_depends_on,
+    .version = "0.1.0",
+    .fingerprint = 0xe19fa0c952d85520,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon" },
+    .description = "Alias empty depends_on fixture",
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .aliases = .{
+        .check = .{
+            .depends_on = .{},
+        },
+    },
+}
diff --git a/test/fixtures/aliases_nested/build.zig b/test/fixtures/aliases_nested/build.zig
new file mode 100644
index 0000000..1af7267
--- /dev/null
+++ b/test/fixtures/aliases_nested/build.zig
@@ -0,0 +1,6 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) !void {
+    _ = try zbuild.configureBuild(b, @import("build.zig.zon"), .{});
+}
diff --git a/test/fixtures/aliases_nested/build.zig.zon b/test/fixtures/aliases_nested/build.zig.zon
new file mode 100644
index 0000000..9f7a4eb
--- /dev/null
+++ b/test/fixtures/aliases_nested/build.zig.zon
@@ -0,0 +1,31 @@
+.{
+    .name = .aliases_nested,
+    .version = "0.1.0",
+    .fingerprint = 0x9742fd4b3beb0b7f,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+    .description = "Nested alias fixture",
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .executables = .{
+        .hello = .{
+            .root_module = .{
+                .root_source_file = "src/main.zig",
+            },
+        },
+    },
+    .aliases = .{
+        .smoke = .{
+            .depends_on = .{
+                "run:hello",
+            },
+        },
+        .check = .{
+            .description = "Run nested alias checks",
+            .depends_on = .{
+                "smoke",
+            },
+        },
+    },
+}
diff --git a/test/fixtures/aliases_nested/src/main.zig b/test/fixtures/aliases_nested/src/main.zig
new file mode 100644
index 0000000..ec5d80f
--- /dev/null
+++ b/test/fixtures/aliases_nested/src/main.zig
@@ -0,0 +1,5 @@
+const std = @import("std");
+
+pub fn main() void {
+    std.debug.print("alias fixture ok\n", .{});
+}
diff --git a/test/fixtures/basic1.zbuild.zon b/test/fixtures/basic1.zbuild.zon
deleted file mode 100644
index cb303a4..0000000
--- a/test/fixtures/basic1.zbuild.zon
+++ /dev/null
@@ -1,12 +0,0 @@
-.{
-    .name = .basic,
-    .version = "0.1.0",
-    .fingerprint = 0x90797553773ca567,
-    .minimum_zig_version = "0.14.0",
-    .paths = .{"src"},
-    .modules = .{
-        .module_0 = .{
-            .root_source_file = "src/module_0/main.zig",
-        },
-    },
-}
diff --git a/test/fixtures/basic2.zbuild.zon b/test/fixtures/basic2.zbuild.zon
deleted file mode 100644
index 520c66c..0000000
--- a/test/fixtures/basic2.zbuild.zon
+++ /dev/null
@@ -1,35 +0,0 @@
-.{
-    .name = .basic,
-    .version = "0.1.0",
-    .fingerprint = 0x90797553773ca567,
-    .minimum_zig_version = "0.14.0",
-    .paths = .{"src"},
-    .modules = .{
-        .module_0 = .{
-            .root_source_file = "src/module_0/main.zig",
-        },
-        .module_1 = .{
-            .root_source_file = "src/module_1/main.zig",
-            .imports = .{.module_0},
-            .target = "native",
-            .optimize = .ReleaseFast,
-            .link_libc = true,
-            .link_libcpp = true,
-            .single_threaded = true,
-            .strip = true,
-            .unwind_tables = .none,
-            .dwarf_format = .@"32",
-            .code_model = .default,
-            .stack_protector = true,
-            .stack_check = true,
-            .sanitize_c = true,
-            .sanitize_thread = true,
-            .fuzz = false,
-            .valgrind = true,
-            .pic = true,
-            .red_zone = true,
-            .omit_frame_pointer = true,
-            .error_tracing = true,
-        },
-    },
-}
diff --git a/test/fixtures/basic3.zbuild.zon b/test/fixtures/basic3.zbuild.zon
deleted file mode 100644
index 4181508..0000000
--- a/test/fixtures/basic3.zbuild.zon
+++ /dev/null
@@ -1,19 +0,0 @@
-.{
-    .name = .basic,
-    .version = "0.1.0",
-    .fingerprint = 0x90797553773ca567,
-    .minimum_zig_version = "0.14.0",
-    .paths = .{"src"},
-    .modules = .{
-        .module_0 = .{
-            .root_source_file = "src/module_0/main.zig",
-            .target = "native",
-            .optimize = .ReleaseFast,
-        },
-        .module_1 = .{
-            .root_source_file = "src/module_1/main.zig",
-            .target = "native",
-            .optimize = .ReleaseFast,
-        },
-    },
-}
diff --git a/test/fixtures/basic4.zbuild.zon b/test/fixtures/basic4.zbuild.zon
deleted file mode 100644
index 60c06e6..0000000
--- a/test/fixtures/basic4.zbuild.zon
+++ /dev/null
@@ -1,23 +0,0 @@
-.{
-    .name = .basic,
-    .version = "0.1.0",
-    .fingerprint = 0x90797553773ca567,
-    .minimum_zig_version = "0.14.0",
-    .paths = .{"src"},
-    .executables = .{
-        .module_0 = .{
-            .root_module = .{
-                .name = "module_0_exe",
-                .root_source_file = "src/module_0/main.zig",
-            },
-        },
-    },
-    .libraries = .{
-        .module_0 = .{
-            .root_module = .{
-                .name = "module_0_lib",
-                .root_source_file = "src/module_0/main.zig",
-            },
-        },
-    },
-}
diff --git a/test/fixtures/basic5.zbuild.zon b/test/fixtures/basic5.zbuild.zon
deleted file mode 100644
index bd9cf78..0000000
--- a/test/fixtures/basic5.zbuild.zon
+++ /dev/null
@@ -1,33 +0,0 @@
-.{
-    .name = .basic,
-    .version = "0.1.0",
-    .fingerprint = 0x90797553773ca567,
-    .minimum_zig_version = "0.14.0",
-    .paths = .{"src"},
-    .modules = .{
-        .module_0 = .{
-            .root_source_file = "src/module_0/main.zig",
-            .imports = .{.build_options},
-        },
-    },
-    .executables = .{
-        .exe_0 = .{
-            .root_module = .{
-                .root_source_file = "src/module_0/main.zig",
-                .imports = .{.build_options},
-            },
-        },
-    },
-    .options_modules = .{
-        .build_options = .{
-            .min_depth = .{
-                .type = "usize",
-                .default = 0,
-            },
-            .max_depth = .{
-                .type = "usize",
-                .default = 100,
-            },
-        },
-    },
-}
diff --git a/test/fixtures/basic6.zbuild.zon b/test/fixtures/basic6.zbuild.zon
deleted file mode 100644
index b327568..0000000
--- a/test/fixtures/basic6.zbuild.zon
+++ /dev/null
@@ -1,17 +0,0 @@
-.{
-    .name = .basic,
-    .version = "0.1.0",
-    .fingerprint = 0x90797553773ca567,
-    .minimum_zig_version = "0.14.0",
-    .paths = .{"src"},
-    .executables = .{
-        .exe_0 = .{
-            .root_module = .{
-                .root_source_file = "src/module_0/main.zig",
-            },
-        },
-    },
-    .runs = .{
-        .docs = "echo 'Generating documentation...'",
-    },
-}
diff --git a/test/fixtures/dependency_bad_import/build.zig b/test/fixtures/dependency_bad_import/build.zig
new file mode 100644
index 0000000..4259c57
--- /dev/null
+++ b/test/fixtures/dependency_bad_import/build.zig
@@ -0,0 +1,9 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/dependency_bad_import/build.zig.zon b/test/fixtures/dependency_bad_import/build.zig.zon
new file mode 100644
index 0000000..0340271
--- /dev/null
+++ b/test/fixtures/dependency_bad_import/build.zig.zon
@@ -0,0 +1,22 @@
+.{
+    .name = .dependency_bad_import,
+    .version = "0.1.0",
+    .fingerprint = 0x74cdf3df0f50705d,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src", "dep" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+        .dep_pkg = .{ .path = "dep" },
+    },
+    .modules = .{
+        .core = .{
+            .root_source_file = "src/core.zig",
+            .imports = .{ "dep_pkg:missing" },
+        },
+    },
+    .executables = .{
+        .demo = .{
+            .root_module = .core,
+        },
+    },
+}
diff --git a/test/fixtures/dependency_bad_import/dep/build.zig b/test/fixtures/dependency_bad_import/dep/build.zig
new file mode 100644
index 0000000..d45eb35
--- /dev/null
+++ b/test/fixtures/dependency_bad_import/dep/build.zig
@@ -0,0 +1,9 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    _ = b.addModule("dep_pkg", .{
+        .root_source_file = b.path("src/lib.zig"),
+        .target = b.resolveTargetQuery(.{}),
+        .optimize = .Debug,
+    });
+}
diff --git a/test/fixtures/dependency_bad_import/dep/build.zig.zon b/test/fixtures/dependency_bad_import/dep/build.zig.zon
new file mode 100644
index 0000000..cf33a3e
--- /dev/null
+++ b/test/fixtures/dependency_bad_import/dep/build.zig.zon
@@ -0,0 +1,7 @@
+.{
+    .name = .dep_pkg,
+    .version = "0.1.0",
+    .fingerprint = 0xd13ef89dae14394c,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+}
diff --git a/test/fixtures/dependency_bad_import/dep/src/lib.zig b/test/fixtures/dependency_bad_import/dep/src/lib.zig
new file mode 100644
index 0000000..70e1f9d
--- /dev/null
+++ b/test/fixtures/dependency_bad_import/dep/src/lib.zig
@@ -0,0 +1 @@
+pub const value = 1;
diff --git a/test/fixtures/dependency_bad_import/src/core.zig b/test/fixtures/dependency_bad_import/src/core.zig
new file mode 100644
index 0000000..902b554
--- /dev/null
+++ b/test/fixtures/dependency_bad_import/src/core.zig
@@ -0,0 +1 @@
+pub fn main() void {}
diff --git a/test/fixtures/dependency_bad_lazy_path/build.zig b/test/fixtures/dependency_bad_lazy_path/build.zig
new file mode 100644
index 0000000..4259c57
--- /dev/null
+++ b/test/fixtures/dependency_bad_lazy_path/build.zig
@@ -0,0 +1,9 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/dependency_bad_lazy_path/build.zig.zon b/test/fixtures/dependency_bad_lazy_path/build.zig.zon
new file mode 100644
index 0000000..99f0ae1
--- /dev/null
+++ b/test/fixtures/dependency_bad_lazy_path/build.zig.zon
@@ -0,0 +1,18 @@
+.{
+    .name = .dependency_bad_lazy_path,
+    .version = "0.1.0",
+    .fingerprint = 0x380bc1bd4047ea09,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "dep" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+        .dep_pkg = .{ .path = "dep" },
+    },
+    .executables = .{
+        .demo = .{
+            .root_module = .{
+                .root_source_file = "dep_pkg:missing",
+            },
+        },
+    },
+}
diff --git a/test/fixtures/dependency_bad_lazy_path/dep/build.zig b/test/fixtures/dependency_bad_lazy_path/dep/build.zig
new file mode 100644
index 0000000..d45eb35
--- /dev/null
+++ b/test/fixtures/dependency_bad_lazy_path/dep/build.zig
@@ -0,0 +1,9 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    _ = b.addModule("dep_pkg", .{
+        .root_source_file = b.path("src/lib.zig"),
+        .target = b.resolveTargetQuery(.{}),
+        .optimize = .Debug,
+    });
+}
diff --git a/test/fixtures/dependency_bad_lazy_path/dep/build.zig.zon b/test/fixtures/dependency_bad_lazy_path/dep/build.zig.zon
new file mode 100644
index 0000000..e7c55e9
--- /dev/null
+++ b/test/fixtures/dependency_bad_lazy_path/dep/build.zig.zon
@@ -0,0 +1,7 @@
+.{
+    .name = .dep_pkg,
+    .version = "0.1.0",
+    .fingerprint = 0xd13ef89db73c4e7f,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+}
diff --git a/test/fixtures/dependency_bad_lazy_path/dep/src/lib.zig b/test/fixtures/dependency_bad_lazy_path/dep/src/lib.zig
new file mode 100644
index 0000000..70e1f9d
--- /dev/null
+++ b/test/fixtures/dependency_bad_lazy_path/dep/src/lib.zig
@@ -0,0 +1 @@
+pub const value = 1;
diff --git a/test/fixtures/duplicate_installable_artifact_name/build.zig b/test/fixtures/duplicate_installable_artifact_name/build.zig
new file mode 100644
index 0000000..4259c57
--- /dev/null
+++ b/test/fixtures/duplicate_installable_artifact_name/build.zig
@@ -0,0 +1,9 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/duplicate_installable_artifact_name/build.zig.zon b/test/fixtures/duplicate_installable_artifact_name/build.zig.zon
new file mode 100644
index 0000000..886a7fd
--- /dev/null
+++ b/test/fixtures/duplicate_installable_artifact_name/build.zig.zon
@@ -0,0 +1,32 @@
+.{
+    .name = .duplicate_installable_name,
+    .version = "0.1.0",
+    .fingerprint = 0x4e19ae3976924b8c,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .executables = .{
+        .shared = .{
+            .root_module = .{
+                .name = "shared_exe_root",
+                .root_source_file = "src/main.zig",
+            },
+        },
+    },
+    .libraries = .{
+        .shared = .{
+            .root_module = .{
+                .name = "shared_lib_root",
+                .root_source_file = "src/lib.zig",
+            },
+        },
+    },
+    .runs = .{
+        .demo = .{
+            .cmd = .{ "echo", "ok" },
+            .depends_on = .{.shared},
+        },
+    },
+}
diff --git a/test/fixtures/duplicate_installable_artifact_name/src/lib.zig b/test/fixtures/duplicate_installable_artifact_name/src/lib.zig
new file mode 100644
index 0000000..1f49ca1
--- /dev/null
+++ b/test/fixtures/duplicate_installable_artifact_name/src/lib.zig
@@ -0,0 +1,3 @@
+pub export fn add(a: i32, b: i32) i32 {
+    return a + b;
+}
diff --git a/test/fixtures/duplicate_installable_artifact_name/src/main.zig b/test/fixtures/duplicate_installable_artifact_name/src/main.zig
new file mode 100644
index 0000000..902b554
--- /dev/null
+++ b/test/fixtures/duplicate_installable_artifact_name/src/main.zig
@@ -0,0 +1 @@
+pub fn main() void {}
diff --git a/test/fixtures/import_namespace_dependency_default_collision/build.zig b/test/fixtures/import_namespace_dependency_default_collision/build.zig
new file mode 100644
index 0000000..4259c57
--- /dev/null
+++ b/test/fixtures/import_namespace_dependency_default_collision/build.zig
@@ -0,0 +1,9 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/import_namespace_dependency_default_collision/build.zig.zon b/test/fixtures/import_namespace_dependency_default_collision/build.zig.zon
new file mode 100644
index 0000000..1ecd2bc
--- /dev/null
+++ b/test/fixtures/import_namespace_dependency_default_collision/build.zig.zon
@@ -0,0 +1,18 @@
+.{
+    .name = .import_ns_dep_default,
+    .version = "0.1.0",
+    .fingerprint = 0xd227427fc131983d,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "dep" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+        .dep_pkg = .{ .path = "dep" },
+    },
+    .options_modules = .{
+        .dep_pkg = .{
+            .verbose = .{
+                .type = .bool,
+            },
+        },
+    },
+}
diff --git a/test/fixtures/import_namespace_dependency_default_collision/dep/build.zig b/test/fixtures/import_namespace_dependency_default_collision/dep/build.zig
new file mode 100644
index 0000000..d45eb35
--- /dev/null
+++ b/test/fixtures/import_namespace_dependency_default_collision/dep/build.zig
@@ -0,0 +1,9 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    _ = b.addModule("dep_pkg", .{
+        .root_source_file = b.path("src/lib.zig"),
+        .target = b.resolveTargetQuery(.{}),
+        .optimize = .Debug,
+    });
+}
diff --git a/test/fixtures/import_namespace_dependency_default_collision/dep/build.zig.zon b/test/fixtures/import_namespace_dependency_default_collision/dep/build.zig.zon
new file mode 100644
index 0000000..ed30b85
--- /dev/null
+++ b/test/fixtures/import_namespace_dependency_default_collision/dep/build.zig.zon
@@ -0,0 +1,7 @@
+.{
+    .name = .dep_pkg,
+    .version = "0.1.0",
+    .fingerprint = 0xd13ef89d878d4378,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+}
diff --git a/test/fixtures/import_namespace_dependency_default_collision/dep/src/lib.zig b/test/fixtures/import_namespace_dependency_default_collision/dep/src/lib.zig
new file mode 100644
index 0000000..70e1f9d
--- /dev/null
+++ b/test/fixtures/import_namespace_dependency_default_collision/dep/src/lib.zig
@@ -0,0 +1 @@
+pub const value = 1;
diff --git a/test/fixtures/import_namespace_named_options_collision/build.zig b/test/fixtures/import_namespace_named_options_collision/build.zig
new file mode 100644
index 0000000..4259c57
--- /dev/null
+++ b/test/fixtures/import_namespace_named_options_collision/build.zig
@@ -0,0 +1,9 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/import_namespace_named_options_collision/build.zig.zon b/test/fixtures/import_namespace_named_options_collision/build.zig.zon
new file mode 100644
index 0000000..d7a6ae2
--- /dev/null
+++ b/test/fixtures/import_namespace_named_options_collision/build.zig.zon
@@ -0,0 +1,22 @@
+.{
+    .name = .import_ns_named_opts,
+    .version = "0.1.0",
+    .fingerprint = 0x9ba0f709896de986,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .modules = .{
+        .config = .{
+            .root_source_file = "src/config.zig",
+        },
+    },
+    .options_modules = .{
+        .config = .{
+            .verbose = .{
+                .type = .bool,
+            },
+        },
+    },
+}
diff --git a/test/fixtures/import_namespace_named_options_collision/src/config.zig b/test/fixtures/import_namespace_named_options_collision/src/config.zig
new file mode 100644
index 0000000..70e1f9d
--- /dev/null
+++ b/test/fixtures/import_namespace_named_options_collision/src/config.zig
@@ -0,0 +1 @@
+pub const value = 1;
diff --git a/test/fixtures/inline_name_collision/build.zig b/test/fixtures/inline_name_collision/build.zig
new file mode 100644
index 0000000..4259c57
--- /dev/null
+++ b/test/fixtures/inline_name_collision/build.zig
@@ -0,0 +1,9 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/inline_name_collision/build.zig.zon b/test/fixtures/inline_name_collision/build.zig.zon
new file mode 100644
index 0000000..94cbe5e
--- /dev/null
+++ b/test/fixtures/inline_name_collision/build.zig.zon
@@ -0,0 +1,22 @@
+.{
+    .name = .inline_name_collision,
+    .version = "0.1.0",
+    .fingerprint = 0x673a7a4b3b8a3ff0,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .modules = .{
+        .core = .{
+            .root_source_file = "src/core.zig",
+        },
+    },
+    .executables = .{
+        .core = .{
+            .root_module = .{
+                .root_source_file = "src/main.zig",
+            },
+        },
+    },
+}
diff --git a/test/fixtures/inline_name_collision/src/core.zig b/test/fixtures/inline_name_collision/src/core.zig
new file mode 100644
index 0000000..e469a4c
--- /dev/null
+++ b/test/fixtures/inline_name_collision/src/core.zig
@@ -0,0 +1 @@
+pub const message = "core";
diff --git a/test/fixtures/inline_name_collision/src/main.zig b/test/fixtures/inline_name_collision/src/main.zig
new file mode 100644
index 0000000..902b554
--- /dev/null
+++ b/test/fixtures/inline_name_collision/src/main.zig
@@ -0,0 +1 @@
+pub fn main() void {}
diff --git a/test/fixtures/manual_interop/build.zig b/test/fixtures/manual_interop/build.zig
new file mode 100644
index 0000000..4bf6063
--- /dev/null
+++ b/test/fixtures/manual_interop/build.zig
@@ -0,0 +1,16 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = b.step("gen:prep", "manual prep step");
+    _ = b.addModule("shared", .{
+        .root_source_file = b.path("src/shared.zig"),
+        .target = b.resolveTargetQuery(.{}),
+        .optimize = .Debug,
+    });
+
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/manual_interop/build.zig.zon b/test/fixtures/manual_interop/build.zig.zon
new file mode 100644
index 0000000..27df57e
--- /dev/null
+++ b/test/fixtures/manual_interop/build.zig.zon
@@ -0,0 +1,34 @@
+.{
+    .name = .manual_interop,
+    .version = "0.1.0",
+    .fingerprint = 0xb6f4a41579e23c4e,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .modules = .{
+        .core = .{
+            .root_source_file = "src/core.zig",
+            .imports = .{"shared"},
+        },
+    },
+    .executables = .{
+        .myapp = .{
+            .root_module = .{
+                .root_source_file = "src/main.zig",
+                .imports = .{ .core, "shared" },
+            },
+            .depends_on = .{"gen:prep"},
+        },
+        .shared_exe = .{
+            .root_module = "shared",
+        },
+    },
+    .runs = .{
+        .demo = .{
+            .cmd = .{ "echo", "manual interop ok" },
+            .depends_on = .{"gen:prep"},
+        },
+    },
+}
diff --git a/test/fixtures/manual_interop/src/core.zig b/test/fixtures/manual_interop/src/core.zig
new file mode 100644
index 0000000..7fcc9c7
--- /dev/null
+++ b/test/fixtures/manual_interop/src/core.zig
@@ -0,0 +1,5 @@
+const shared = @import("shared");
+
+pub fn get() []const u8 {
+    return shared.message;
+}
diff --git a/test/fixtures/manual_interop/src/main.zig b/test/fixtures/manual_interop/src/main.zig
new file mode 100644
index 0000000..1ca247e
--- /dev/null
+++ b/test/fixtures/manual_interop/src/main.zig
@@ -0,0 +1,7 @@
+const std = @import("std");
+const core = @import("core");
+const shared = @import("shared");
+
+pub fn main() void {
+    std.debug.print("{s} {s}\n", .{ core.get(), shared.message });
+}
diff --git a/test/fixtures/manual_interop/src/shared.zig b/test/fixtures/manual_interop/src/shared.zig
new file mode 100644
index 0000000..7548d71
--- /dev/null
+++ b/test/fixtures/manual_interop/src/shared.zig
@@ -0,0 +1,3 @@
+pub const message = "manual";
+
+pub fn main() void {}
diff --git a/test/fixtures/manual_module_collision/build.zig b/test/fixtures/manual_module_collision/build.zig
new file mode 100644
index 0000000..d40f0ab
--- /dev/null
+++ b/test/fixtures/manual_module_collision/build.zig
@@ -0,0 +1,15 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = b.addModule("core", .{
+        .root_source_file = b.path("src/manual_core.zig"),
+        .target = b.resolveTargetQuery(.{}),
+        .optimize = .Debug,
+    });
+
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/manual_module_collision/build.zig.zon b/test/fixtures/manual_module_collision/build.zig.zon
new file mode 100644
index 0000000..a0f2182
--- /dev/null
+++ b/test/fixtures/manual_module_collision/build.zig.zon
@@ -0,0 +1,15 @@
+.{
+    .name = .manual_module_collision,
+    .version = "0.1.0",
+    .fingerprint = 0xc99010b68cc87c5b,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .modules = .{
+        .core = .{
+            .root_source_file = "src/core.zig",
+        },
+    },
+}
diff --git a/test/fixtures/manual_module_collision/src/core.zig b/test/fixtures/manual_module_collision/src/core.zig
new file mode 100644
index 0000000..70e1f9d
--- /dev/null
+++ b/test/fixtures/manual_module_collision/src/core.zig
@@ -0,0 +1 @@
+pub const value = 1;
diff --git a/test/fixtures/manual_module_collision/src/manual_core.zig b/test/fixtures/manual_module_collision/src/manual_core.zig
new file mode 100644
index 0000000..12e5fc9
--- /dev/null
+++ b/test/fixtures/manual_module_collision/src/manual_core.zig
@@ -0,0 +1 @@
+pub const value = 2;
diff --git a/test/fixtures/manual_step_collision/build.zig b/test/fixtures/manual_step_collision/build.zig
new file mode 100644
index 0000000..73e58ba
--- /dev/null
+++ b/test/fixtures/manual_step_collision/build.zig
@@ -0,0 +1,11 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = b.step("cmd:demo", "manual demo step");
+
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/manual_step_collision/build.zig.zon b/test/fixtures/manual_step_collision/build.zig.zon
new file mode 100644
index 0000000..d67b5d5
--- /dev/null
+++ b/test/fixtures/manual_step_collision/build.zig.zon
@@ -0,0 +1,15 @@
+.{
+    .name = .manual_step_collision,
+    .version = "0.1.0",
+    .fingerprint = 0xf58657b0ec763366,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .runs = .{
+        .demo = .{
+            .cmd = .{ "echo", "collision" },
+        },
+    },
+}
diff --git a/test/fixtures/manual_step_named_test/build.zig b/test/fixtures/manual_step_named_test/build.zig
new file mode 100644
index 0000000..8ab0eae
--- /dev/null
+++ b/test/fixtures/manual_step_named_test/build.zig
@@ -0,0 +1,11 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = b.step("test", "manual test step");
+
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/manual_step_named_test/build.zig.zon b/test/fixtures/manual_step_named_test/build.zig.zon
new file mode 100644
index 0000000..386cedb
--- /dev/null
+++ b/test/fixtures/manual_step_named_test/build.zig.zon
@@ -0,0 +1,23 @@
+.{
+    .name = .manual_step_named_test,
+    .version = "0.1.0",
+    .fingerprint = 0xc2d7cd4f593eb900,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .executables = .{
+        .app = .{
+            .root_module = .{
+                .root_source_file = "src/main.zig",
+            },
+        },
+    },
+    .runs = .{
+        .demo = .{
+            .cmd = .{ "echo", "manual test step ok" },
+            .depends_on = .{"test"},
+        },
+    },
+}
diff --git a/test/fixtures/manual_step_named_test/src/main.zig b/test/fixtures/manual_step_named_test/src/main.zig
new file mode 100644
index 0000000..902b554
--- /dev/null
+++ b/test/fixtures/manual_step_named_test/src/main.zig
@@ -0,0 +1 @@
+pub fn main() void {}
diff --git a/test/fixtures/preset_unknown_option/build.zig b/test/fixtures/preset_unknown_option/build.zig
new file mode 100644
index 0000000..1af7267
--- /dev/null
+++ b/test/fixtures/preset_unknown_option/build.zig
@@ -0,0 +1,6 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) !void {
+    _ = try zbuild.configureBuild(b, @import("build.zig.zon"), .{});
+}
diff --git a/test/fixtures/preset_unknown_option/build.zig.zon b/test/fixtures/preset_unknown_option/build.zig.zon
new file mode 100644
index 0000000..c390bf2
--- /dev/null
+++ b/test/fixtures/preset_unknown_option/build.zig.zon
@@ -0,0 +1,25 @@
+.{
+    .name = .preset_unknown_option,
+    .version = "0.1.0",
+    .fingerprint = 0xc20daa3edff0612c,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .options_modules = .{
+        .config = .{
+            .verbose = .{
+                .type = .bool,
+                .default = false,
+            },
+        },
+    },
+    .presets = .{
+        .dev = .{
+            .config = .{
+                .missing = true,
+            },
+        },
+    },
+}
diff --git a/test/fixtures/presets/build.zig b/test/fixtures/presets/build.zig
new file mode 100644
index 0000000..1af7267
--- /dev/null
+++ b/test/fixtures/presets/build.zig
@@ -0,0 +1,6 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) !void {
+    _ = try zbuild.configureBuild(b, @import("build.zig.zon"), .{});
+}
diff --git a/test/fixtures/presets/build.zig.zon b/test/fixtures/presets/build.zig.zon
new file mode 100644
index 0000000..0f57b9d
--- /dev/null
+++ b/test/fixtures/presets/build.zig.zon
@@ -0,0 +1,48 @@
+.{
+    .name = .presets_fixture,
+    .version = "0.1.0",
+    .fingerprint = 0x99060a9877fe71c6,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .options_modules = .{
+        .config = .{
+            .log_level = .{
+                .type = .@"enum",
+                .values = .{ .debug, .info, .warn },
+                .default = .info,
+            },
+            .enable_tracing = .{
+                .type = .bool,
+                .default = false,
+            },
+            .asset_dir = .{
+                .type = .string,
+            },
+        },
+    },
+    .presets = .{
+        .dev = .{
+            .config = .{
+                .log_level = .debug,
+                .enable_tracing = true,
+            },
+        },
+        .prod = .{
+            .config = .{
+                .log_level = .warn,
+                .asset_dir = "dist/prod",
+            },
+        },
+    },
+    .executables = .{
+        .demo = .{
+            .root_module = .{
+                .root_source_file = "src/main.zig",
+                .imports = .{.config},
+            },
+        },
+    },
+}
diff --git a/test/fixtures/presets/src/main.zig b/test/fixtures/presets/src/main.zig
new file mode 100644
index 0000000..3332af3
--- /dev/null
+++ b/test/fixtures/presets/src/main.zig
@@ -0,0 +1,18 @@
+const std = @import("std");
+const config = @import("config");
+
+fn logLevelString(level: @TypeOf(config.log_level)) []const u8 {
+    return switch (level) {
+        .debug => "debug",
+        .info => "info",
+        .warn => "warn",
+    };
+}
+
+pub fn main() !void {
+    std.debug.print("level={s} tracing={} asset={s}\n", .{
+        logLevelString(config.log_level),
+        config.enable_tracing,
+        config.asset_dir orelse "none",
+    });
+}
diff --git a/test/fixtures/root_module_string_options_module/build.zig b/test/fixtures/root_module_string_options_module/build.zig
new file mode 100644
index 0000000..4259c57
--- /dev/null
+++ b/test/fixtures/root_module_string_options_module/build.zig
@@ -0,0 +1,9 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/root_module_string_options_module/build.zig.zon b/test/fixtures/root_module_string_options_module/build.zig.zon
new file mode 100644
index 0000000..e401fe6
--- /dev/null
+++ b/test/fixtures/root_module_string_options_module/build.zig.zon
@@ -0,0 +1,23 @@
+.{
+    .name = .root_mod_string_opt,
+    .version = "0.1.0",
+    .fingerprint = 0x80659922f8f360cd,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .options_modules = .{
+        .config = .{
+            .verbose = .{
+                .type = .bool,
+                .default = false,
+            },
+        },
+    },
+    .executables = .{
+        .app = .{
+            .root_module = "config",
+        },
+    },
+}
diff --git a/test/fixtures/root_module_string_options_module/src/main.zig b/test/fixtures/root_module_string_options_module/src/main.zig
new file mode 100644
index 0000000..902b554
--- /dev/null
+++ b/test/fixtures/root_module_string_options_module/src/main.zig
@@ -0,0 +1 @@
+pub fn main() void {}
diff --git a/test/fixtures/stdlib_passthrough/bin/test_runner.zig b/test/fixtures/stdlib_passthrough/bin/test_runner.zig
new file mode 100644
index 0000000..959b5f3
--- /dev/null
+++ b/test/fixtures/stdlib_passthrough/bin/test_runner.zig
@@ -0,0 +1,20 @@
+const builtin = @import("builtin");
+const std = @import("std");
+const testing = std.testing;
+
+pub fn main() !void {
+    testing.io_instance = .init(testing.allocator, .{});
+
+    var failed: usize = 0;
+    for (builtin.test_functions) |test_fn| {
+        test_fn.func() catch |err| switch (err) {
+            error.SkipZigTest => continue,
+            else => {
+                std.debug.print("{s}: {t}\n", .{ test_fn.name, err });
+                failed += 1;
+            },
+        };
+    }
+
+    if (failed != 0) std.process.exit(1);
+}
diff --git a/test/fixtures/stdlib_passthrough/build.zig b/test/fixtures/stdlib_passthrough/build.zig
new file mode 100644
index 0000000..4259c57
--- /dev/null
+++ b/test/fixtures/stdlib_passthrough/build.zig
@@ -0,0 +1,9 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/stdlib_passthrough/build.zig.zon b/test/fixtures/stdlib_passthrough/build.zig.zon
new file mode 100644
index 0000000..c6925c2
--- /dev/null
+++ b/test/fixtures/stdlib_passthrough/build.zig.zon
@@ -0,0 +1,37 @@
+.{
+    .name = .stdlib_passthrough,
+    .version = "0.1.0",
+    .fingerprint = 0xb7f75f47342d3f61,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src", "bin" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .modules = .{
+        .core = .{
+            .root_source_file = "src/core.zig",
+            .no_builtin = false,
+        },
+    },
+    .libraries = .{
+        .mylib = .{
+            .root_module = .core,
+            .win32_module_definition = "src/mylib.def",
+            .linker_allow_shlib_undefined = true,
+        },
+    },
+    .tests = .{
+        .unit = .{
+            .root_module = .{
+                .root_source_file = "src/test.zig",
+                .imports = .{.core},
+            },
+            .test_runner = .{
+                .path = "bin/test_runner.zig",
+                .mode = .simple,
+            },
+            .emit_object = false,
+            .linker_allow_shlib_undefined = true,
+        },
+    },
+}
diff --git a/test/fixtures/stdlib_passthrough/src/core.zig b/test/fixtures/stdlib_passthrough/src/core.zig
new file mode 100644
index 0000000..19ab525
--- /dev/null
+++ b/test/fixtures/stdlib_passthrough/src/core.zig
@@ -0,0 +1,3 @@
+pub fn add(a: i32, b: i32) i32 {
+    return a + b;
+}
diff --git a/test/fixtures/stdlib_passthrough/src/mylib.def b/test/fixtures/stdlib_passthrough/src/mylib.def
new file mode 100644
index 0000000..0e0f59b
--- /dev/null
+++ b/test/fixtures/stdlib_passthrough/src/mylib.def
@@ -0,0 +1,2 @@
+LIBRARY mylib
+EXPORTS
diff --git a/test/fixtures/stdlib_passthrough/src/test.zig b/test/fixtures/stdlib_passthrough/src/test.zig
new file mode 100644
index 0000000..933bbda
--- /dev/null
+++ b/test/fixtures/stdlib_passthrough/src/test.zig
@@ -0,0 +1,6 @@
+const std = @import("std");
+const core = @import("core");
+
+test "add" {
+    try std.testing.expectEqual(@as(i32, 5), core.add(2, 3));
+}
diff --git a/test/fixtures/undeclared_external_module/build.zig b/test/fixtures/undeclared_external_module/build.zig
new file mode 100644
index 0000000..90bbb95
--- /dev/null
+++ b/test/fixtures/undeclared_external_module/build.zig
@@ -0,0 +1,15 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = b.addModule("shared", .{
+        .root_source_file = b.path("src/shared.zig"),
+        .target = b.resolveTargetQuery(.{}),
+        .optimize = .Debug,
+    });
+
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/undeclared_external_module/build.zig.zon b/test/fixtures/undeclared_external_module/build.zig.zon
new file mode 100644
index 0000000..54a0d21
--- /dev/null
+++ b/test/fixtures/undeclared_external_module/build.zig.zon
@@ -0,0 +1,16 @@
+.{
+    .name = .undeclared_external_module,
+    .version = "0.1.0",
+    .fingerprint = 0x616e35e85d43f0fa,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon", "src" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .modules = .{
+        .core = .{
+            .root_source_file = "src/core.zig",
+            .imports = .{"shared"},
+        },
+    },
+}
diff --git a/test/fixtures/undeclared_external_module/src/core.zig b/test/fixtures/undeclared_external_module/src/core.zig
new file mode 100644
index 0000000..7fcc9c7
--- /dev/null
+++ b/test/fixtures/undeclared_external_module/src/core.zig
@@ -0,0 +1,5 @@
+const shared = @import("shared");
+
+pub fn get() []const u8 {
+    return shared.message;
+}
diff --git a/test/fixtures/undeclared_external_module/src/shared.zig b/test/fixtures/undeclared_external_module/src/shared.zig
new file mode 100644
index 0000000..3a8a3e6
--- /dev/null
+++ b/test/fixtures/undeclared_external_module/src/shared.zig
@@ -0,0 +1 @@
+pub const message = "shared";
diff --git a/test/fixtures/undeclared_external_step/build.zig b/test/fixtures/undeclared_external_step/build.zig
new file mode 100644
index 0000000..ded0462
--- /dev/null
+++ b/test/fixtures/undeclared_external_step/build.zig
@@ -0,0 +1,11 @@
+const std = @import("std");
+const zbuild = @import("zbuild");
+
+pub fn build(b: *std.Build) void {
+    _ = b.step("gen:prep", "manual prep step");
+
+    _ = zbuild.configureBuild(b, @import("build.zig.zon"), .{}) catch |err| {
+        std.log.err("zbuild: {}", .{err});
+        return;
+    };
+}
diff --git a/test/fixtures/undeclared_external_step/build.zig.zon b/test/fixtures/undeclared_external_step/build.zig.zon
new file mode 100644
index 0000000..2d804e7
--- /dev/null
+++ b/test/fixtures/undeclared_external_step/build.zig.zon
@@ -0,0 +1,16 @@
+.{
+    .name = .undeclared_external_step,
+    .version = "0.1.0",
+    .fingerprint = 0x664b633717aa56eb,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{ "build.zig", "build.zig.zon" },
+    .dependencies = .{
+        .zbuild = .{ .path = "../../.." },
+    },
+    .runs = .{
+        .deploy = .{
+            .cmd = .{ "echo", "deploy" },
+            .depends_on = .{"gen:prep"},
+        },
+    },
+}
diff --git a/test/sync.zig b/test/sync.zig
deleted file mode 100644
index 0e7f276..0000000
--- a/test/sync.zig
+++ /dev/null
@@ -1,74 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const zbuild = @import("zbuild");
-
-/// set to false to help debug the generated build.zig file
-const remove_build_file = true;
-
-const cwd = "test";
-
-const test_cases = &[_][]const u8{
-    "fixtures/basic1.zbuild.zon",
-    "fixtures/basic2.zbuild.zon",
-    "fixtures/basic3.zbuild.zon",
-    "fixtures/basic4.zbuild.zon",
-    "fixtures/basic5.zbuild.zon",
-    "fixtures/basic6.zbuild.zon",
-};
-
-fn maybeCleanup(should_cleanup: bool) void {
-    if (should_cleanup) {
-        const dir = std.fs.cwd().openDir(cwd, .{}) catch return;
-        dir.deleteFile("build.zig") catch return;
-        dir.deleteFile("build.zig.zon") catch return;
-    }
-}
-
-/// - Load the zbuild file
-/// - Generate the build and manifest files
-/// - Run `zig build --help`
-fn testSync(gpa: Allocator, arena: Allocator, should_cleanup: bool, global_opts: zbuild.GlobalOptions) !void {
-    defer maybeCleanup(should_cleanup);
-
-    const config = try zbuild.Config.parseFromFile(arena, global_opts.zbuild_file, null);
-
-    try zbuild.build.exec(
-        gpa,
-        arena,
-        global_opts,
-        config,
-        .{
-            .kind = .build,
-            .args = &[1][]const u8{"--help"},
-            .stderr_behavior = .Ignore,
-            .stdout_behavior = .Ignore,
-        },
-    );
-}
-
-test "zbuild build --help" {
-    const allocator = std.testing.allocator;
-
-    for (test_cases) |test_case| {
-        var arena_alloc = std.heap.ArenaAllocator.init(allocator);
-        defer arena_alloc.deinit();
-        const arena = arena_alloc.allocator();
-
-        const zbuild_file = try std.fs.path.join(allocator, &[_][]const u8{ cwd, test_case });
-        defer allocator.free(zbuild_file);
-
-        var args = try zbuild.Args.initFromString(
-            arena,
-            try std.fmt.allocPrint(
-                arena,
-                "--project-dir {s} --zbuild-file {s}",
-                .{ cwd, zbuild_file },
-            ),
-        );
-        const global_opts = try zbuild.GlobalOptions.parseArgs(allocator, &args);
-        defer global_opts.deinit(allocator);
-
-        try testSync(allocator, arena, remove_build_file, global_opts);
-    }
-}
diff --git a/zbuild.zon b/zbuild.zon
deleted file mode 100644
index 251e989..0000000
--- a/zbuild.zon
+++ /dev/null
@@ -1,25 +0,0 @@
-.{
-    .name = .zbuild,
-    .version = "0.2.0",
-    .fingerprint = 0x60f98ac2bf5a915c,
-    .minimum_zig_version = "0.14.0",
-    .paths = .{ "build.zig", "build.zig.zon", "src" },
-    .description = "An opinionated zig build tool",
-    .dependencies = .{},
-    .executables = .{
-        .zbuild = .{
-            .root_module = .{
-                .root_source_file = "src/main.zig",
-            },
-        },
-    },
-    .tests = .{
-        .sync = .{
-            .root_module = .{
-                .private = true,
-                .root_source_file = "test/sync.zig",
-                .imports = .{.zbuild},
-            },
-        },
-    },
-}