build.w

use std.build
use build.runtime
use build.selfhost
use build.pcre2
use build.zlib
use build.seed
use build.emit_c
use build.compiler
use build.clang_resource
use build.retention
use build.release_uat
use build.package
use build.sdk
use std.sysinfo

fn build_project_dirname(path: str) -> str:
    var last_slash = -1
    for i in 0..path.len() as i32:
        if path.byte_at(i as i64) == 47:
            last_slash = i
    if last_slash < 0:
        return "."
    if last_slash == 0:
        return "/"
    path.slice(0, last_slash as i64)

fn with_object_target(name: str, compiler: str, source: str, output: str, opt: str, dep: str) -> Target:
    var target = target_new(.Action, name, "").output(output)
    target.action = run_with_compiler_build_action
    target = target.compiler(compiler)
    target = target.input(source)
    target = target.arg("--emit-obj")
    target = target.arg("--no-prelude")
    target = target.arg(opt)
    target = target.write_scope("out/command/" ++ name)
    target = target.write_scope(build_project_dirname(output))
    if dep.len() > 0:
        target = target.dep(dep)
    target

fn with_ir_target(name: str, compiler: str, source: str, output: str, dep: str) -> Target:
    var target = target_new(.Action, name, "").output(output)
    target.action = run_with_compiler_ir_action
    target = target.compiler(compiler)
    target = target.input(source)
    target = target.arg("--no-prelude")
    target = target.write_scope(build_project_dirname(output))
    target = target.write_scope("out/command/" ++ name)
    if dep.len() > 0:
        target = target.dep(dep)
    target

fn with_ir_target_overflow(name: str, compiler: str, source: str, output: str, dep: str, overflow: str) -> Target:
    var target = with_ir_target(name, compiler, source, output, dep)
    target = target.arg("overflow=" ++ overflow)
    target

fn run_write_empty_file_action(ctx: ActionCtx) -> i32:
    let output = ctx.output()
    if output.len() == 0:
        ctx.diagnostics().error(ctx.target_name() ++ ": missing output")
        return 1
    let dir = build_project_dirname(output)
    let fs = ctx.fs()
    if fs.mkdir_all(dir) != 0:
        ctx.diagnostics().error(ctx.target_name() ++ ": could not create output directory: " ++ dir)
        return 1
    if fs.write_text(output, "") != 0:
        ctx.diagnostics().error(ctx.target_name() ++ ": could not write: " ++ output)
        return 1
    0

fn run_cross_unsupported_action(ctx: ActionCtx) -> i32:
    let args = ctx.args()
    let target = if args.len() > 0: args.get(0) else: ""
    if target.len() == 0:
        ctx.diagnostics().error("cross: cross-target compilation is not implemented yet; set CROSS_TARGET=<triple> or use `with build --target <triple>` for the compiler diagnostic")
    else:
        ctx.diagnostics().error("cross: cross-target compilation for '" ++ target ++ "' is not implemented yet")
    1

fn empty_file_target(name: str, output: str) -> Target:
    var target = target_new(.Action, name, "").output(output)
    target.action = run_write_empty_file_action
    target = target.write_scope(build_project_dirname(output))
    target

fn run_prepare_bootstrap_link_root_action(ctx: ActionCtx) -> i32:
    // Old seed compilers may prefer out/lib before out/bootstrap-lib. Remove
    // stale unversioned runtime probes so stage1 selects the freshly generated
    // bootstrap runtime instead of yesterday's out/lib objects.
    let fs = ctx.fs()
    let stale_runtime_objects: Vec[str] = Vec.new()
    stale_runtime_objects.push("out/lib/cimport_stubs.o")
    stale_runtime_objects.push("out/lib/rt_core.o")
    stale_runtime_objects.push("out/lib/rt_darwin_aarch64.o")
    stale_runtime_objects.push("out/lib/rt_linux_x86_64.o")
    stale_runtime_objects.push("out/lib/rt_windows_x86_64.o")
    stale_runtime_objects.push("out/lib/compat_runtime.o")
    stale_runtime_objects.push("out/lib/panic_runtime.o")
    stale_runtime_objects.push("out/lib/regex_runtime.o")
    stale_runtime_objects.push("out/lib/channel_runtime.o")
    stale_runtime_objects.push("out/lib/fiber_runtime.o")
    stale_runtime_objects.push("out/lib/fiber.o")
    stale_runtime_objects.push("out/lib/fiber_asm.o")
    stale_runtime_objects.push("out/lib/fiber_stubs.o")
    for i in 0..stale_runtime_objects.len() as i32:
        let _remove_stale = fs.remove_file(stale_runtime_objects.get(i as i64))
    let output = ctx.output()
    if fs.mkdir_all(build_project_dirname(output)) != 0:
        ctx.diagnostics().error(ctx.target_name() ++ ": could not create output directory: " ++ build_project_dirname(output))
        return 1
    if fs.write_text(output, "ok\n") != 0:
        ctx.diagnostics().error(ctx.target_name() ++ ": could not write: " ++ output)
        return 1
    0

fn target_with_embedded_stdlib_inputs(target: Target, ctx: &BuildCtx) -> Target:
    var out = target
    let files = ctx.fs().list_files("lib/std")
    for i in 0..files.len() as i32:
        let path = files.get(i as i64)
        if path.ends_with(".w") and not path.starts_with("lib/std/re/"):
            out = out.input(path)
    out

fn target_with_compiler_c_export_audit_inputs(target: Target, ctx: &BuildCtx) -> Target:
    var out = target
    let roots: Vec[str] = Vec.new()
    roots.push("src")
    roots.push("rt")
    roots.push("lib/std")
    for ri in 0..roots.len() as i32:
        let files = ctx.fs().list_files(roots.get(ri as i64))
        for fi in 0..files.len() as i32:
            let path = files.get(fi as i64)
            if path.ends_with(".w"):
                out = out.input(path)
    out

fn target_with_compiler_source_inputs(target: Target, ctx: &BuildCtx) -> Target:
    var out = target
    let roots: Vec[str] = Vec.new()
    roots.push("src")
    roots.push("rt")
    roots.push("build")
    roots.push("lib/std")
    for ri in 0..roots.len() as i32:
        let files = ctx.fs().list_files(roots.get(ri as i64))
        for fi in 0..files.len() as i32:
            let path = files.get(fi as i64)
            if path.ends_with(".w"):
                out = out.input(path)
    out.input("build.w")

fn build_project_trim_line(text: str) -> str:
    var end = 0
    while end < text.len() as i32:
        let ch = text.byte_at(end as i64)
        if ch == 10 or ch == 13:
            break
        end = end + 1
    var start = 0
    while start < end:
        let ch = text.byte_at(start as i64)
        if ch != 9 and ch != 32:
            break
        start = start + 1
    while end > start:
        let ch = text.byte_at((end - 1) as i64)
        if ch != 9 and ch != 32:
            break
        end = end - 1
    text.slice(start as i64, end as i64)

fn target_with_version_inputs(target: Target, ctx: &BuildCtx) -> Target:
    var out = target
    out = out.arg("version-env=" ++ env("WITH_VERSION"))
    let fs = ctx.fs()
    if not fs.exists(".git/HEAD"):
        return out
    out = out.input(".git/HEAD")
    let head = build_project_trim_line(fs.read_text(".git/HEAD"))
    if head.starts_with("ref: "):
        let ref_path = ".git/" ++ head.slice(5, head.len())
        if fs.exists(ref_path):
            out = out.input(ref_path)
        else if fs.exists(".git/packed-refs"):
            out = out.input(".git/packed-refs")
    out

fn target_with_live_targets(target: Target, graph: &Build) -> Target:
    var out = target
    for i in 0..graph.targets.len() as i32:
        out = out.arg("live-target=" ++ graph.targets.get(i as i64).name)
    out

type HostRuntimeSpec:
    platform_source: str
    compat_source: str
    bootstrap_platform_object: str
    platform_object: str
    platform_install_object: str
    platform_symbol: str
    opposite_bootstrap_platform_blob: str
    opposite_platform_blob: str
    opposite_platform_symbol: str
    second_opposite_bootstrap_platform_blob: str
    second_opposite_platform_blob: str
    second_opposite_platform_symbol: str
    fiber_core_source: str
    fiber_asm_source: str

fn host_exe_suffix() -> str:
    if os() == "Windows":
        return ".exe"
    ""

fn host_bin(path: str) -> str:
    path ++ host_exe_suffix()

fn bootstrap_compiler_bin(name: str) -> str:
    host_bin("out/bootstrap/bin/" ++ name)

fn stage_compiler_bin(name: str) -> str:
    host_bin("out/stage/bin/" ++ name)

fn stage_compiler_obj(name: str) -> str:
    "out/stage/bin/" ++ name

fn release_compiler_bin(name: str) -> str:
    host_bin("out/release/bin/" ++ name)

fn release_platform_asset_bin() -> str:
    let host_os = os()
    let host_arch = arch()
    if host_os == "Macos" and (host_arch == "armv8" or host_arch == "aarch64"):
        return "out/release/with-darwin-aarch64"
    if host_os == "Linux" and host_arch == "x86_64":
        return "out/release/with-linux-x86_64"
    if host_os == "Windows" and host_arch == "x86_64":
        return "out/release/with-windows-x86_64.exe"
    release_compiler_bin("with")

// The platform asset target only exists when the asset is a distinct copy of
// the release compiler; on unknown hosts release_platform_asset_bin() falls
// back to the compiler path itself and there is nothing separate to produce.
fn release_platform_asset_is_distinct() -> bool:
    release_platform_asset_bin() != release_compiler_bin("with")

fn release_uat_platform_asset_dep(t: Target) -> Target:
    if release_platform_asset_is_distinct():
        return t.dep("release-platform-asset")
    t

fn host_runtime_spec() -> HostRuntimeSpec:
    if os() == "Linux" and arch() == "x86_64":
        return HostRuntimeSpec {
            platform_source: "rt/linux_x86_64.w",
            compat_source: "rt/compat_runtime.w",
            bootstrap_platform_object: "out/bootstrap-lib/rt_linux_x86_64.o",
            platform_object: "out/lib/rt_linux_x86_64.o",
            platform_install_object: "rt_linux_x86_64.o",
            platform_symbol: "rt_linux_x86_64_o",
            opposite_bootstrap_platform_blob: "out/bootstrap-lib/empty_rt_darwin_aarch64.bin",
            opposite_platform_blob: "out/lib/empty_rt_darwin_aarch64.bin",
            opposite_platform_symbol: "rt_darwin_aarch64_o",
            second_opposite_bootstrap_platform_blob: "out/bootstrap-lib/empty_rt_windows_x86_64.bin",
            second_opposite_platform_blob: "out/lib/empty_rt_windows_x86_64.bin",
            second_opposite_platform_symbol: "rt_windows_x86_64_o",
            fiber_core_source: "rt/fiber_core_darwin.w",
            fiber_asm_source: "runtime/fiber_asm_linux_x86_64.s",
        }
    if os() == "Windows" and arch() == "x86_64":
        return HostRuntimeSpec {
            platform_source: "rt/windows_x86_64.w",
            compat_source: "rt/compat_runtime.w",
            bootstrap_platform_object: "out/bootstrap-lib/rt_windows_x86_64.o",
            platform_object: "out/lib/rt_windows_x86_64.o",
            platform_install_object: "rt_windows_x86_64.o",
            platform_symbol: "rt_windows_x86_64_o",
            opposite_bootstrap_platform_blob: "out/bootstrap-lib/empty_rt_darwin_aarch64.bin",
            opposite_platform_blob: "out/lib/empty_rt_darwin_aarch64.bin",
            opposite_platform_symbol: "rt_darwin_aarch64_o",
            second_opposite_bootstrap_platform_blob: "out/bootstrap-lib/empty_rt_linux_x86_64.bin",
            second_opposite_platform_blob: "out/lib/empty_rt_linux_x86_64.bin",
            second_opposite_platform_symbol: "rt_linux_x86_64_o",
            fiber_core_source: "rt/fiber_core_windows.w",
            fiber_asm_source: "runtime/fiber_asm_windows_x86_64.s",
        }
    HostRuntimeSpec {
        platform_source: "rt/darwin_aarch64.w",
        compat_source: "rt/compat_runtime.w",
        bootstrap_platform_object: "out/bootstrap-lib/rt_darwin_aarch64.o",
        platform_object: "out/lib/rt_darwin_aarch64.o",
        platform_install_object: "rt_darwin_aarch64.o",
        platform_symbol: "rt_darwin_aarch64_o",
        opposite_bootstrap_platform_blob: "out/bootstrap-lib/empty_rt_linux_x86_64.bin",
        opposite_platform_blob: "out/lib/empty_rt_linux_x86_64.bin",
        opposite_platform_symbol: "rt_linux_x86_64_o",
        second_opposite_bootstrap_platform_blob: "out/bootstrap-lib/empty_rt_windows_x86_64.bin",
        second_opposite_platform_blob: "out/lib/empty_rt_windows_x86_64.bin",
        second_opposite_platform_symbol: "rt_windows_x86_64_o",
        fiber_core_source: "rt/fiber_core_darwin.w",
        fiber_asm_source: "runtime/fiber_asm_aarch64.s",
    }

fn release_asset_for_host() -> str:
    if os() == "Linux" and arch() == "x86_64":
        return "with-linux-x86_64"
    if os() == "Macos" and (arch() == "armv8" or arch() == "aarch64"):
        return "with-darwin-aarch64"
    if os() == "Windows" and arch() == "x86_64":
        return "with-windows-x86_64.exe"
    "with-darwin-aarch64"

// "with-darwin-aarch64" -> "darwin-aarch64"
fn release_platform_tag() -> str:
    let asset = release_asset_for_host()
    if asset.starts_with("with-"):
        var tag = asset.slice(5, asset.len())
        if tag.ends_with(".exe"):
            tag = tag.slice(0, tag.len() - 4)
        return tag
    asset

fn supported_release_platform_tag() -> str:
    if os() == "Linux" and arch() == "x86_64":
        return "linux-x86_64"
    if os() == "Macos" and (arch() == "armv8" or arch() == "aarch64"):
        return "darwin-aarch64"
    if os() == "Windows" and arch() == "x86_64":
        return "windows-x86_64"
    ""

// ".deps/llvm-<ver>-<host>" -> "llvm-<ver>-<host>"
fn llvm_sdk_dir_basename() -> str:
    let prefix = compiler_default_llvm_prefix()
    if prefix.starts_with(".deps/"):
        return prefix.slice(6, prefix.len())
    prefix

fn llvm_sdk_asset_for_host() -> str:
    "with-llvm-sdk-" ++ compiler_llvm_version() ++ "-" ++ release_platform_tag() ++ ".tar.gz"

fn release_package_asset_for_platform(platform: str) -> str:
    if platform == "darwin-aarch64":
        return "with-darwin-aarch64"
    if platform == "linux_x86_64" or platform == "linux-x86_64":
        return "with-linux-x86_64"
    if platform == "windows_x86_64" or platform == "windows-x86_64":
        return "with-windows-x86_64.exe"
    "with-unsupported"

fn package_platform_target(name: str, platform: str, ctx: &BuildCtx) -> Target:
    let asset = release_package_asset_for_platform(platform)
    var target = target_new(.Action, name, "").output("out/release/" ++ name ++ ".passed")
    target.action = run_package_platform_release_action
    target = target.arg(asset)
    target = target.arg(platform)
    target = target.arg(release_compiler_bin("with"))
    target = target.arg(compiler_default_llvm_prefix())
    target = target.input("src/version")
    target = target.input(release_compiler_bin("with"))
    target = target.input("build/package.w")
    target = target.extra_output("out/release/" ++ asset)
    target = target.extra_output("out/release/" ++ asset ++ ".sha256")
    target = target.write_scope("out/release")
    target = target.write_scope("out/command/" ++ name)
    target = target.timeout(600000)
    target = target_with_version_inputs(move target, ctx)
    if supported_release_platform_tag() == platform:
        target = target.dep("build")
        target = target.dep("fixpoint")
        target = target.dep("release-uat")
    target

fn package_current_host_target() -> Target:
    var target = target_new(.Group, "package-current-host", "")
    let platform = supported_release_platform_tag()
    if platform == "darwin-aarch64":
        return target.dep("package-darwin-aarch64")
    if platform == "linux-x86_64":
        return target.dep("package-linux-x86_64")
    if platform == "windows-x86_64":
        return target.dep("package-windows-x86_64")
    target.dep("package-darwin-aarch64")

fn package_llvm_sdk_platform_target(name: str, platform: str, prefix: str, build_cache: str) -> Target:
    let asset = sdk_asset_for_platform(platform)
    let sdk_base = "llvm-" ++ compiler_llvm_version() ++ "-" ++ sdk_host_tag_for_platform(platform)
    var target = target_new(.Action, name, "").output("out/release/" ++ name ++ ".passed")
    target.action = run_package_llvm_sdk_action
    target = target.arg(platform)
    target = target.arg(prefix)
    target = target.arg(build_cache)
    target = target.arg(asset)
    target = target.arg(sdk_base)
    target = target.input(prefix)
    target = target.input(build_cache)
    target = target.input("build/sdk.w")
    target = target.extra_output("out/release/" ++ asset)
    target = target.extra_output("out/release/" ++ asset ++ ".sha256")
    target = target.extra_output("out/release/" ++ asset ++ ".manifest")
    target = target.write_scope("out/release")
    target = target.write_scope("out/command/" ++ name)
    target.timeout(1800000)

fn package_llvm_sdk_current_host_target() -> Target:
    var target = target_new(.Group, "package-llvm-sdk", "")
    let platform = sdk_current_platform()
    if platform == "darwin-aarch64":
        return target.dep("package-llvm-sdk-darwin-aarch64")
    if platform == "linux-x86_64":
        return target.dep("package-llvm-sdk-linux-x86_64")
    if platform == "windows-x86_64":
        return target.dep("package-llvm-sdk-windows-x86_64")
    target.dep("package-llvm-sdk-darwin-aarch64")

fn sdk_source_target(name: str, url: str, sha256: str, archive: str, source_root: str, source_dir: str, marker: str) -> Target:
    var target = target_new(.Action, name, "").output(marker)
    target.action = run_sdk_source_tar_gz_action
    target = target.arg(url)
    target = target.arg(sha256)
    target = target.arg(archive)
    target = target.arg(source_root)
    target = target.arg(source_dir)
    target = target.input("build/https_fetch.w")
    target = target.input("build/zlib_gunzip.w")
    target = target.write_scope(source_root)
    target = target.write_scope("out/command/" ++ name)
    target = target.allow_network()
    target.timeout(1800000)

fn sdk_bootstrap_prefix_arg(ctx: &BuildCtx, platform: str) -> str:
    let explicit = ctx.env_input("SDK_BOOTSTRAP_PREFIX")
    if explicit.len() > 0:
        return explicit
    let llvm_prefix = ctx.env_input("LLVM_PREFIX")
    if llvm_prefix.len() > 0:
        return llvm_prefix
    sdk_default_prefix_for_platform(platform)

fn sdk_output_prefix_arg(ctx: &BuildCtx, platform: str) -> str:
    let explicit = ctx.env_input("SDK_OUTPUT_PREFIX")
    if explicit.len() > 0:
        return explicit
    sdk_output_prefix_for_platform(platform)

fn sdk_build_root_arg(ctx: &BuildCtx, platform: str) -> str:
    let explicit = ctx.env_input("SDK_BUILD_ROOT")
    if explicit.len() > 0:
        return explicit
    sdk_output_build_root_for_platform(platform)

fn sdk_jobs_arg(ctx: &BuildCtx) -> str:
    ctx.env_input("PARALLEL_JOBS")

fn sdk_ninja_target(ctx: &BuildCtx) -> Target:
    let platform = sdk_current_platform()
    let bootstrap_prefix = sdk_bootstrap_prefix_arg(ctx, platform)
    let output_prefix = sdk_output_prefix_arg(ctx, platform)
    let build_root = sdk_build_root_arg(ctx, platform)
    var target = target_new(.Action, "sdk-ninja", "").output(output_prefix ++ "/bin/ninja" ++ host_exe_suffix())
    target.action = run_sdk_ninja_action
    target = target.arg(bootstrap_prefix)
    target = target.arg(output_prefix)
    target = target.arg(sdk_ninja_source_dir())
    target = target.arg(build_root ++ "/ninja-" ++ sdk_host_tag_for_platform(platform))
    target = target.arg(sdk_jobs_arg(ctx))
    target = target.input(sdk_ninja_source_marker())
    target = target.input(bootstrap_prefix)
    target = target.input("build/sdk.w")
    target = target.write_scope(output_prefix)
    target = target.write_scope(build_root)
    target = target.write_scope("out/command/sdk-ninja")
    target = target.dep("sdk-ninja-source")
    target.timeout(1800000)

fn sdk_cmake_target(ctx: &BuildCtx) -> Target:
    let platform = sdk_current_platform()
    let bootstrap_prefix = sdk_bootstrap_prefix_arg(ctx, platform)
    let output_prefix = sdk_output_prefix_arg(ctx, platform)
    let build_root = sdk_build_root_arg(ctx, platform)
    var target = target_new(.Action, "sdk-cmake", "").output(output_prefix ++ "/bin/cmake" ++ host_exe_suffix())
    target.action = run_sdk_cmake_action
    target = target.arg(bootstrap_prefix)
    target = target.arg(output_prefix)
    target = target.arg(sdk_cmake_source_dir())
    target = target.arg(build_root ++ "/cmake-" ++ sdk_host_tag_for_platform(platform))
    target = target.arg(sdk_jobs_arg(ctx))
    target = target.input(sdk_cmake_source_marker())
    target = target.input(output_prefix ++ "/bin/ninja" ++ host_exe_suffix())
    target = target.input(bootstrap_prefix)
    target = target.input("build/sdk.w")
    target = target.write_scope(output_prefix)
    target = target.write_scope(build_root)
    target = target.write_scope("out/command/sdk-cmake")
    target = target.dep("sdk-ninja")
    target = target.dep("sdk-cmake-source")
    target.timeout(3600000)

fn sdk_llvm_target(ctx: &BuildCtx) -> Target:
    let platform = sdk_current_platform()
    let bootstrap_prefix = sdk_bootstrap_prefix_arg(ctx, platform)
    let output_prefix = sdk_output_prefix_arg(ctx, platform)
    let build_root = sdk_build_root_arg(ctx, platform)
    var target = target_new(.Action, "sdk-llvm", "").output(if platform == "windows-x86_64": output_prefix ++ "/lib/libclang.lib" else: output_prefix ++ "/lib/libclang.a")
    target.action = run_sdk_llvm_action
    target = target.arg(bootstrap_prefix)
    target = target.arg(output_prefix)
    target = target.arg(sdk_llvm_source_dir())
    target = target.arg(build_root ++ "/llvm-" ++ compiler_llvm_version() ++ "-" ++ sdk_host_tag_for_platform(platform))
    target = target.arg(sdk_jobs_arg(ctx))
    target = target.arg(ctx.env_input("LLVM_TARGETS_TO_BUILD"))
    target = target.arg(ctx.env_input("SDKROOT"))
    target = target.arg(ctx.env_input("MACOSX_DEPLOYMENT_TARGET"))
    target = target.arg(ctx.env_input("SDK_WINDOWS_MT"))
    target = target.input(sdk_llvm_source_marker())
    target = target.input(output_prefix ++ "/bin/cmake" ++ host_exe_suffix())
    target = target.input(output_prefix ++ "/bin/ninja" ++ host_exe_suffix())
    target = target.input(bootstrap_prefix)
    target = target.input("build/sdk.w")
    target = target.write_scope(output_prefix)
    target = target.write_scope(build_root)
    target = target.write_scope("out/command/sdk-llvm")
    target = target.dep("sdk-cmake")
    target = target.dep("sdk-llvm-source")
    target.timeout(21600000)

fn sdk_group_target() -> Target:
    var target = target_new(.Group, "sdk", "")
    target = target.dep("sdk-ninja")
    target = target.dep("sdk-cmake")
    target.dep("sdk-llvm")

fn sdk_package_target(ctx: &BuildCtx) -> Target:
    let platform = sdk_current_platform()
    var target = package_llvm_sdk_platform_target("sdk-package", platform, sdk_output_prefix_arg(ctx, platform), sdk_output_llvm_cache_for_platform(platform))
    target.dep("sdk")

fn install_file_target(name: str, source: str, dest: str, mode: str, dep: str) -> Target:
    var target = target_new(.Install, name, source).output(dest)
    target = target.input(source)
    target = target.arg(mode)
    if dep.len() > 0:
        target = target.dep(dep)
    target

fn build_project_join(left: str, right: str) -> str:
    if left.len() == 0:
        return right
    if right.len() == 0:
        return left
    if left.ends_with("/"):
        return left ++ right
    left ++ "/" ++ right

fn build_project_abs(root: str, path: str) -> str:
    if path.len() > 0 and path.byte_at(0) == 47:
        return path
    build_project_join(root, path)

fn build_trim_trailing_line_endings(text: str) -> str:
    var end = text.len()
    while end > 0:
        let ch = text.byte_at(end - 1)
        if ch != 10 and ch != 13:
            break
        end = end - 1
    text.slice(0, end)

fn build_replace_once(text: str, needle: str, replacement: str) -> str:
    let idx = text.find(needle)
    if idx < 0:
        return ""
    text.slice(0, idx) ++ replacement ++ text.slice(idx + needle.len(), text.len())

fn issue61_fail(ctx: &ActionCtx, message: str) -> i32:
    ctx.diagnostics().error("issue61-regression: " ++ message)
    1

fn issue61_regression_action(ctx: ActionCtx) -> i32:
    let inputs = ctx.inputs()
    if inputs.len() == 0:
        return issue61_fail(ctx, "missing compiler input")
    let fs = ctx.fs()
    let output_dir = ctx.output()
    if fs.mkdir_all(output_dir) != 0:
        return issue61_fail(ctx, "could not create output directory: " ++ output_dir)

    let root = ctx.project_info().project_root()
    let compiler_path = build_project_abs(root, inputs.get(0))
    if not fs.exists(inputs.get(0)):
        return issue61_fail(ctx, "missing compiler: " ++ inputs.get(0))

    let repo_copy = build_project_join(output_dir, "repo")
    if fs.exists(repo_copy) and fs.remove_tree(repo_copy) != 0:
        return issue61_fail(ctx, "could not remove existing repo copy: " ++ repo_copy)
    if fs.mkdir_all(repo_copy) != 0:
        return issue61_fail(ctx, "could not create repo copy directory: " ++ repo_copy)

    if fs.copy_tree("src", build_project_join(repo_copy, "src")) != 0:
        return issue61_fail(ctx, "could not copy src into repo fixture")
    let copied_seed = build_project_join(repo_copy, "src/main")
    if fs.exists(copied_seed) and fs.remove_file(copied_seed) != 0:
        return issue61_fail(ctx, "could not remove copied seed from repo fixture")
    if fs.symlink("lib", build_project_join(repo_copy, "lib")) != 0:
        return issue61_fail(ctx, "could not link lib into repo fixture")

    let embedded_src = "out/gen/compiler/EmbeddedStdlibData.w"
    let embedded_dst = build_project_join(repo_copy, "out/gen/compiler/EmbeddedStdlibData.w")
    if fs.mkdir_all(build_project_join(repo_copy, "out/gen/compiler")) != 0:
        return issue61_fail(ctx, "could not create embedded stdlib data directory")
    if fs.write_text(embedded_dst, fs.read_text(embedded_src)) != 0:
        return issue61_fail(ctx, "could not copy embedded stdlib data module")

    let clang_res_src = "out/gen/compiler/EmbeddedClangResourceData.w"
    let clang_res_dst = build_project_join(repo_copy, "out/gen/compiler/EmbeddedClangResourceData.w")
    if fs.write_text(clang_res_dst, fs.read_text(clang_res_src)) != 0:
        return issue61_fail(ctx, "could not copy embedded clang resource data module")

    let sema_path = build_project_join(repo_copy, "src/SemaCheck.w")
    let sema_text = fs.read_text(sema_path)
    // Find the marker line and copy ITS leading whitespace for the injected
    // local: a fixed-indent splice rots when the surrounding code nests
    // deeper (the 4-space injection dedented out of the enclosing block and
    // the canary spent months red on a parse error instead of its real job).
    let marker_comment = "// Check all arguments (with expected-type propagation for Atomic ordering params)"
    let marker_at = sema_text.find(marker_comment)
    if marker_at < 0:
        return issue61_fail(ctx, "missing insertion point in " ++ sema_path)
    var indent_start = marker_at
    while indent_start > 0 and sema_text.byte_at((indent_start - 1) as i64) != 10:
        indent_start = indent_start - 1
    let indent = sema_text.slice(indent_start as i64, marker_at as i64)
    let marker = indent ++ marker_comment
    let replacement = marker ++ "\n" ++ indent ++ "var mc_issue61_padding_local: i32 = 0"
    let patched = build_replace_once(sema_text, marker, replacement)
    if patched.len() == 0:
        return issue61_fail(ctx, "missing insertion point in " ++ sema_path)
    if fs.write_text(sema_path, patched) != 0:
        return issue61_fail(ctx, "could not patch " ++ sema_path)
    if not fs.read_text(sema_path).contains("mc_issue61_padding_local"):
        return issue61_fail(ctx, "failed to inject noop local")

    let stdout_path = build_project_abs(root, build_project_join(output_dir, "check.stdout"))
    let stderr_path = build_project_abs(root, build_project_join(output_dir, "check.stderr"))
    var check_args: Vec[str] = Vec.new()
    check_args |> push(compiler_path)
    check_args |> push("check")
    check_args |> push("src/main.w")
    let check = ctx.process_runner().run_capture_cwd(check_args, stdout_path, stderr_path, 180000, build_project_abs(root, repo_copy))
    if check.rc == 124:
        return issue61_fail(ctx, "check timed out; stdout=" ++ stdout_path ++ " stderr=" ++ stderr_path)
    if check.rc != 0:
        return issue61_fail(ctx, f"check failed with exit code {check.rc}; stdout=" ++ stdout_path ++ " stderr=" ++ stderr_path)
    let output = build_trim_trailing_line_endings(check.stdout)
    if output != "ok":
        return issue61_fail(ctx, "check produced unexpected output: " ++ output)
    0

// Benign-edit invariance: the compiler's verdict on its own tree must be
// invariant under meaning-preserving perturbations (a comment, a fresh
// local, a fresh top-level let, at any position). Every #660-class defect
// — untagged unions probed by content, silent id-alignment sensitivity —
// breaks exactly this property, so this harness catches the CLASS without
// knowing the instance. Variants are a fixed deterministic list; each is
// applied to a pristine repo copy and `check src/main.w` must still say ok.
fn invariance_fail(ctx: &ActionCtx, message: str) -> i32:
    ctx.diagnostics().error("invariance-check: " ++ message)
    1

fn invariance_run_check(ctx: &ActionCtx, compiler_path: str, repo_copy: str, label: str) -> i32:
    let root = ctx.project_info().project_root()
    let stdout_path = build_project_abs(root, build_project_join(ctx.output(), label ++ ".stdout"))
    let stderr_path = build_project_abs(root, build_project_join(ctx.output(), label ++ ".stderr"))
    var check_args: Vec[str] = Vec.new()
    check_args |> push(compiler_path)
    check_args |> push("check")
    check_args |> push("src/main.w")
    let check = ctx.process_runner().run_capture_cwd(check_args, stdout_path, stderr_path, 240000, build_project_abs(root, repo_copy))
    if check.rc != 0:
        return invariance_fail(ctx, f"variant '{label}' changed the verdict (exit {check.rc}); the perturbed tree is left at " ++ repo_copy ++ " — stderr=" ++ stderr_path)
    if build_trim_trailing_line_endings(check.stdout) != "ok":
        return invariance_fail(ctx, "variant '" ++ label ++ "' produced unexpected output; stdout=" ++ stdout_path)
    0

fn invariance_check_action(ctx: ActionCtx) -> i32:
    let inputs = ctx.inputs()
    if inputs.len() == 0:
        return invariance_fail(ctx, "missing compiler input")
    let fs = ctx.fs()
    let output_dir = ctx.output()
    if fs.mkdir_all(output_dir) != 0:
        return invariance_fail(ctx, "could not create output directory: " ++ output_dir)
    let root = ctx.project_info().project_root()
    let compiler_path = build_project_abs(root, inputs.get(0))
    if not fs.exists(inputs.get(0)):
        return invariance_fail(ctx, "missing compiler: " ++ inputs.get(0))

    let repo_copy = build_project_join(output_dir, "repo")
    if fs.exists(repo_copy) and fs.remove_tree(repo_copy) != 0:
        return invariance_fail(ctx, "could not remove existing repo copy: " ++ repo_copy)
    if fs.mkdir_all(repo_copy) != 0:
        return invariance_fail(ctx, "could not create repo copy directory: " ++ repo_copy)
    if fs.copy_tree("src", build_project_join(repo_copy, "src")) != 0:
        return invariance_fail(ctx, "could not copy src into repo fixture")
    let copied_seed = build_project_join(repo_copy, "src/main")
    if fs.exists(copied_seed) and fs.remove_file(copied_seed) != 0:
        return invariance_fail(ctx, "could not remove copied seed from repo fixture")
    if fs.symlink("lib", build_project_join(repo_copy, "lib")) != 0:
        return invariance_fail(ctx, "could not link lib into repo fixture")
    if fs.mkdir_all(build_project_join(repo_copy, "out/gen/compiler")) != 0:
        return invariance_fail(ctx, "could not create embedded gen directory")
    if fs.write_text(build_project_join(repo_copy, "out/gen/compiler/EmbeddedStdlibData.w"), fs.read_text("out/gen/compiler/EmbeddedStdlibData.w")) != 0:
        return invariance_fail(ctx, "could not copy embedded stdlib data module")
    if fs.write_text(build_project_join(repo_copy, "out/gen/compiler/EmbeddedClangResourceData.w"), fs.read_text("out/gen/compiler/EmbeddedClangResourceData.w")) != 0:
        return invariance_fail(ctx, "could not copy embedded clang resource data module")

    // Pristine copies of the files the variants touch.
    let sema_copy = build_project_join(repo_copy, "src/Sema.w")
    let parser_copy = build_project_join(repo_copy, "src/Parser.w")
    let main_copy = build_project_join(repo_copy, "src/main.w")
    let sema_pristine = fs.read_text(sema_copy)
    let parser_pristine = fs.read_text(parser_copy)
    let main_pristine = fs.read_text(main_copy)
    if sema_pristine.len() == 0 or parser_pristine.len() == 0 or main_pristine.len() == 0:
        return invariance_fail(ctx, "could not read pristine sources from the repo copy")

    // Variant 1: comment appended mid-merge (byte shift, no tokens).
    if fs.write_text(sema_copy, sema_pristine ++ "\n// invariance probe comment\n") != 0:
        return invariance_fail(ctx, "could not write variant comment-sema")
    var rc = invariance_run_check(ctx, compiler_path, repo_copy, "comment-sema")
    if rc != 0: return rc

    // Variant 2: fresh top-level let mid-merge (the #660 killer shape:
    // one new interned symbol shifts every later-first-seen symbol id).
    if fs.write_text(sema_copy, sema_pristine ++ "\nlet __INVARIANCE_PAD_A: i32 = 0\n") != 0:
        return invariance_fail(ctx, "could not write variant let-sema")
    rc = invariance_run_check(ctx, compiler_path, repo_copy, "let-sema")
    if rc != 0: return rc

    // Variant 3: two fresh lets (larger id shift).
    if fs.write_text(sema_copy, sema_pristine ++ "\nlet __INVARIANCE_PAD_B: i32 = 0\nlet __INVARIANCE_PAD_C: i32 = 0\n") != 0:
        return invariance_fail(ctx, "could not write variant two-lets-sema")
    rc = invariance_run_check(ctx, compiler_path, repo_copy, "two-lets-sema")
    if rc != 0: return rc
    if fs.write_text(sema_copy, sema_pristine) != 0:
        return invariance_fail(ctx, "could not restore Sema.w")

    // Variant 4: fresh let in a different merge position (Parser.w).
    if fs.write_text(parser_copy, parser_pristine ++ "\nlet __INVARIANCE_PAD_D: i32 = 0\n") != 0:
        return invariance_fail(ctx, "could not write variant let-parser")
    rc = invariance_run_check(ctx, compiler_path, repo_copy, "let-parser")
    if rc != 0: return rc
    if fs.write_text(parser_copy, parser_pristine) != 0:
        return invariance_fail(ctx, "could not restore Parser.w")

    // Variant 5: fresh let in the root module (parsed first, ids lowest).
    if fs.write_text(main_copy, main_pristine ++ "\nlet __INVARIANCE_PAD_E: i32 = 0\n") != 0:
        return invariance_fail(ctx, "could not write variant let-main")
    rc = invariance_run_check(ctx, compiler_path, repo_copy, "let-main")
    if rc != 0: return rc
    if fs.write_text(main_copy, main_pristine) != 0:
        return invariance_fail(ctx, "could not restore main.w")
    0

// Debug-allocator fixture lane: build tools/debug_drop.w, then run it in `check`
// mode over test/debug_alloc/*.w. Gives the floor eyes for the over/under-drop
// blind spot it is structurally unable to see. See docs/debug-allocator.md.
fn run_debug_alloc_tests_action(ctx: ActionCtx) -> i32:
    let inputs = ctx.inputs()
    if inputs.len() == 0:
        ctx.diagnostics().error("debug-alloc-tests: missing compiler input")
        return 1
    let fs = ctx.fs()
    let out_dir = ctx.output()
    if fs.mkdir_all(out_dir) != 0:
        ctx.diagnostics().error("debug-alloc-tests: could not create output dir: " ++ out_dir)
        return 1
    let root = ctx.project_info().project_root()
    let compiler = build_project_abs(root, inputs.get(0))
    let driver_bin = build_project_abs(root, build_project_join(out_dir, "debug_drop"))

    var build_args: Vec[str] = Vec.new()
    build_args.push(compiler)
    build_args.push("build")
    build_args.push("tools/debug_drop.w")
    build_args.push("-o")
    build_args.push(driver_bin)
    let bout = build_project_abs(root, build_project_join(out_dir, "build.stdout"))
    let berr = build_project_abs(root, build_project_join(out_dir, "build.stderr"))
    let br = ctx.process_runner().run_capture_cwd(build_args, bout, berr, 180000, root)
    if br.rc != 0:
        ctx.diagnostics().error(f"debug-alloc-tests: driver build failed rc={br.rc}; stderr={berr}")
        return 1

    let fixtures = fs.list_files("test/debug_alloc")
    var check_args: Vec[str] = Vec.new()
    check_args.push(driver_bin)
    check_args.push("check")
    check_args.push(compiler)
    for i in 0..fixtures.len() as i32:
        let p = fixtures.get(i as i64)
        if p.ends_with(".w"):
            check_args.push(build_project_abs(root, p))
    let cout = build_project_abs(root, build_project_join(out_dir, "check.stdout"))
    let cerr = build_project_abs(root, build_project_join(out_dir, "check.stderr"))
    let cr = ctx.process_runner().run_capture_cwd(check_args, cout, cerr, 240000, root)
    if cr.rc != 0:
        ctx.diagnostics().error(f"debug-alloc-tests: lane failed rc={cr.rc}\n" ++ cr.stdout)
        return 1
    let _ = fs.write_text(build_project_join(out_dir, ".stamp"), "ok")
    0

fn run_fixpoint_diff_action(ctx: ActionCtx) -> i32:
    let fs = ctx.fs()
    let output = ctx.output()
    let out_dir = build_project_dirname(output)
    if fs.mkdir_all(out_dir) != 0:
        ctx.diagnostics().error("fixpoint-diff: could not create output dir: " ++ out_dir)
        return 1
    let root = ctx.project_info().project_root()
    let compiler = build_project_abs(root, stage_compiler_bin("with-stage2"))
    let left = build_project_abs(root, stage_compiler_obj("with-stage2-fixpoint.o"))
    let right = build_project_abs(root, stage_compiler_obj("with-stage3-fixpoint.o"))
    let err_path = build_project_abs(root, build_project_join(out_dir, "stderr.txt"))
    var args: Vec[str] = Vec.new()
    args.push(compiler)
    args.push("fixpoint-diff")
    args.push(left)
    args.push(right)
    let result = ctx.process_runner().run_capture_cwd(args, build_project_abs(root, output), err_path, 120000, root)
    if result.rc != 0:
        ctx.diagnostics().error("fixpoint-diff: report command failed; stderr=" ++ err_path)
        return result.rc
    0

fn deep_debug_tool_expect(ctx: &ActionCtx, root: str, compiler: str, source_path: str, out_dir: str, name: str, opt_a: str, opt_b: str, needle: str) -> i32:
    var args: Vec[str] = Vec.new()
    args.push(compiler)
    args.push("check")
    if opt_a.len() > 0:
        args.push(opt_a)
    if opt_b.len() > 0:
        args.push(opt_b)
    args.push(source_path)

    let stdout_rel = build_project_join(out_dir, name ++ ".stdout")
    let stderr_rel = build_project_join(out_dir, name ++ ".stderr")
    let stdout_path = build_project_abs(root, stdout_rel)
    let stderr_path = build_project_abs(root, stderr_rel)
    let result = ctx.process_runner().run_capture_cwd(args, stdout_path, stderr_path, 120000, root)
    if result.rc != 0:
        ctx.diagnostics().error(f"deep-debug-tool-tests: {name} failed rc={result.rc}; stdout={stdout_path} stderr={stderr_path}")
        return result.rc
    if not ctx.fs().read_text(stdout_rel).contains(needle):
        ctx.diagnostics().error("deep-debug-tool-tests: " ++ name ++ " report missing '" ++ needle ++ "'; stdout=" ++ stdout_path)
        return 1
    0

fn deep_debug_analyze_expect(ctx: &ActionCtx, root: str, compiler: str, source_path: str, out_dir: str, name: str, request: str, needle: str) -> i32:
    let args: Vec[str] = Vec.new()
    args.push(compiler)
    args.push("analyze")
    args.push(source_path)
    args.push(request)
    let stdout_rel = build_project_join(out_dir, name ++ ".stdout")
    let stderr_rel = build_project_join(out_dir, name ++ ".stderr")
    let stdout_path = build_project_abs(root, stdout_rel)
    let stderr_path = build_project_abs(root, stderr_rel)
    let result = ctx.process_runner().run_capture_cwd(args, stdout_path, stderr_path, 120000, root)
    if result.rc != 0:
        ctx.diagnostics().error(f"deep-debug-tool-tests: {name} failed rc={result.rc}; stdout={stdout_path} stderr={stderr_path}")
        return result.rc
    if not ctx.fs().read_text(stdout_rel).contains(needle):
        ctx.diagnostics().error("deep-debug-tool-tests: " ++ name ++ " report missing '" ++ needle ++ "'; stdout=" ++ stdout_path)
        return 1
    0

fn run_deep_debug_tool_tests_action(ctx: ActionCtx) -> i32:
    let inputs = ctx.inputs()
    if inputs.len() == 0:
        ctx.diagnostics().error("deep-debug-tool-tests: missing compiler input")
        return 1
    let fs = ctx.fs()
    let out_dir = ctx.output()
    if fs.mkdir_all(out_dir) != 0:
        ctx.diagnostics().error("deep-debug-tool-tests: could not create output dir: " ++ out_dir)
        return 1
    let root = ctx.project_info().project_root()
    let compiler = build_project_abs(root, inputs.get(0))
    let reduce_input = build_project_join(out_dir, "reduce-input.w")
    let reduce_output = build_project_join(out_dir, "reduce-output.w")
    let reduce_source =
        "fn unused:\n" ++
        "    let ok = 1\n" ++
        "    let _ = ok\n\n" ++
        "fn main:\n" ++
        "    missing_symbol\n"
    if fs.write_text(reduce_input, reduce_source) != 0:
        ctx.diagnostics().error("deep-debug-tool-tests: could not write reducer fixture")
        return 1
    var reduce_args: Vec[str] = Vec.new()
    reduce_args.push(compiler)
    reduce_args.push("reduce")
    reduce_args.push(build_project_abs(root, reduce_input))
    reduce_args.push("--out")
    reduce_args.push(build_project_abs(root, reduce_output))
    reduce_args.push("--contains")
    reduce_args.push("undefined variable")
    reduce_args.push("--")
    reduce_args.push(compiler)
    reduce_args.push("check")
    reduce_args.push("{file}")
    let reduce_stdout = build_project_abs(root, build_project_join(out_dir, "reduce.stdout"))
    let reduce_stderr = build_project_abs(root, build_project_join(out_dir, "reduce.stderr"))
    let reduce_result = ctx.process_runner().run_capture_cwd(reduce_args, reduce_stdout, reduce_stderr, 120000, root)
    if reduce_result.rc != 0:
        ctx.diagnostics().error("deep-debug-tool-tests: reduce failed; stderr=" ++ reduce_stderr)
        return reduce_result.rc
    let reduced_text = fs.read_text(reduce_output)
    if not reduced_text.contains("missing_symbol"):
        ctx.diagnostics().error("deep-debug-tool-tests: reducer output lost predicate line")
        return 1

    let left = build_project_join(out_dir, "left.bin")
    let right = build_project_join(out_dir, "right.bin")
    let report = build_project_join(out_dir, "fixpoint-diff.txt")
    if fs.write_text(left, "abc") != 0 or fs.write_text(right, "abd") != 0:
        ctx.diagnostics().error("deep-debug-tool-tests: could not write diff fixtures")
        return 1
    var diff_args: Vec[str] = Vec.new()
    diff_args.push(compiler)
    diff_args.push("fixpoint-diff")
    diff_args.push(build_project_abs(root, left))
    diff_args.push(build_project_abs(root, right))
    let diff_stderr = build_project_abs(root, build_project_join(out_dir, "fixpoint-diff.stderr"))
    let diff_result = ctx.process_runner().run_capture_cwd(diff_args, build_project_abs(root, report), diff_stderr, 120000, root)
    if diff_result.rc != 0:
        ctx.diagnostics().error("deep-debug-tool-tests: fixpoint-diff failed; stderr=" ++ diff_stderr)
        return diff_result.rc
    if not fs.read_text(report).contains("first-different-offset"):
        ctx.diagnostics().error("deep-debug-tool-tests: fixpoint-diff report missing offset")
        return 1

    let ownership_input = build_project_join(out_dir, "ownership-input.w")
    let ownership_source =
        "type Resource { id: i32 }\n\n" ++
        "type Plain { id: i32 }\n\n" ++
        "type Matrix { n: i32 }\n\n" ++
        "impl Matrix:\n" ++
        "    mut fn write(): self.n = self.n + 1\n" ++
        "    mut fn transitive_write(): self.write()\n" ++
        "    move fn take() -> Matrix: self\n\n" ++
        "impl Drop for Resource:\n" ++
        "    fn drop(move self: Self):\n" ++
        "        let _ = self.id\n\n" ++
        "fn consume(r: Resource):\n" ++
        "    let _ = r.id\n\n" ++
        "fn choose(flag: bool):\n" ++
        "    if flag:\n" ++
        "        let x = 1\n" ++
        "        let _ = x\n" ++
        "    else:\n" ++
        "        let y = 2\n" ++
        "        let _ = y\n\n" ++
        "fn main:\n" ++
        "    let p = Plain { id: 3 }\n" ++
        "    let value = p.id\n" ++
        "    let _ = value\n" ++
        "    let r = Resource { id: 7 }\n" ++
        "    consume(r)\n" ++
        "    choose(true)\n"
    if fs.write_text(ownership_input, ownership_source) != 0:
        ctx.diagnostics().error("deep-debug-tool-tests: could not write ownership fixture")
        return 1
    let ownership_abs = build_project_abs(root, ownership_input)
    if deep_debug_tool_expect(ctx, root, compiler, ownership_abs, out_dir, "trace-ownership", "--trace-ownership", "main:", "event=") != 0:
        return 1
    if deep_debug_tool_expect(ctx, root, compiler, ownership_abs, out_dir, "dump-drop-plan", "--dump-drop-plan", "", "drop-plan module") != 0:
        return 1
    if deep_debug_tool_expect(ctx, root, compiler, ownership_abs, out_dir, "validate-ownership", "--validate-ownership", "", "validate-ownership: ok") != 0:
        return 1
    if deep_debug_tool_expect(ctx, root, compiler, ownership_abs, out_dir, "dump-place-map", "--dump-place-map", "", "projections=[Field") != 0:
        return 1
    if deep_debug_tool_expect(ctx, root, compiler, ownership_abs, out_dir, "trace-cleanup-edge", "--trace-cleanup-edge", "choose:bb0->bb1", "edge=bb0->bb1") != 0:
        return 1
    if deep_debug_analyze_expect(ctx, root, compiler, ownership_abs, out_dir, "analyze-audit", "audit:all", "compiler-analysis-audit") != 0:
        return 1
    if deep_debug_analyze_expect(ctx, root, compiler, ownership_abs, out_dir, "analyze-storage", "audit:storage", "storage-audit") != 0:
        return 1
    if deep_debug_analyze_expect(ctx, root, compiler, ownership_abs, out_dir, "analyze-matrix", "matrix:name~consume", "callee-place-alias") != 0:
        return 1
    if deep_debug_analyze_expect(ctx, root, compiler, ownership_abs, out_dir, "analyze-receiver-effects", "matrix:kind=receiver,name~Matrix.transitive_write", "declared=mut required=mut") != 0:
        return 1
    if deep_debug_analyze_expect(ctx, root, compiler, ownership_abs, out_dir, "analyze-path", "path:call:main:consume", "call-path: main -> consume") != 0:
        return 1
    let _ = fs.write_text(build_project_join(out_dir, ".stamp"), "ok")
    0

pub fn build(ctx: BuildCtx) -> Build:
    var out = ctx.new_build()
    let host_runtime = host_runtime_spec()
    let release_version = build_project_trim_line(ctx.fs().read_text("src/version"))

    var compiler_sources = target_new(.Action, "compiler-sources", "").output("out/gen/.generated-stamp")
    compiler_sources.action = run_generate_compiler_entrypoints_action
    compiler_sources = compiler_sources.input("src/main.w")
    compiler_sources = compiler_sources.input("src/bootstrap_main.w")
    compiler_sources = compiler_sources.input("src/version")
    compiler_sources = compiler_sources.extra_output("out/gen/main.w")
    compiler_sources = compiler_sources.extra_output("out/gen/bootstrap_main.w")
    compiler_sources = compiler_sources.extra_output("out/gen/version.txt")
    compiler_sources = target_with_version_inputs(move compiler_sources, ctx)
    out = out.add_target(compiler_sources)

    var print_version = target_new(.Action, "print-version", "").output("out/.build-state/print-version.txt")
    print_version.action = run_print_version_action
    print_version = print_version.input("src/version")
    print_version = target_with_version_inputs(move print_version, ctx)
    out = out.add_target(print_version)

    var bootstrap_c_emit_sources = target_new(.Action, "bootstrap-c-emit-sources", "").output("out/bootstrap-c/src/with_compiler.c")
    bootstrap_c_emit_sources.action = run_bootstrap_c_emit_sources_action
    bootstrap_c_emit_sources = bootstrap_c_emit_sources.extra_output("out/gen/wl_decls.h")
    bootstrap_c_emit_sources = bootstrap_c_emit_sources.extra_output("out/gen/wl_stubs.c")
    bootstrap_c_emit_sources = bootstrap_c_emit_sources.write_scope("out/bootstrap-c/src")
    bootstrap_c_emit_sources = bootstrap_c_emit_sources.write_scope("out/gen")
    bootstrap_c_emit_sources = bootstrap_c_emit_sources.write_scope("out/command/bootstrap-c-emit-sources")
    bootstrap_c_emit_sources = bootstrap_c_emit_sources.dep("compiler-sources")
    out = out.add_target(bootstrap_c_emit_sources)

    var package_bootstrap_c = target_new(.Action, "package-bootstrap-c", "").output("out/release/with-bootstrap-c-" ++ release_version ++ ".tar.gz")
    package_bootstrap_c.action = run_package_bootstrap_c_action
    package_bootstrap_c = package_bootstrap_c.arg(release_compiler_bin("with"))
    package_bootstrap_c = target_with_version_inputs(move package_bootstrap_c, ctx)
    package_bootstrap_c = package_bootstrap_c.dep("build")
    package_bootstrap_c = package_bootstrap_c.dep("bootstrap-c-emit-sources")
    package_bootstrap_c = package_bootstrap_c.input("src/version")
    package_bootstrap_c = package_bootstrap_c.input("out/release/bin/with")
    package_bootstrap_c = package_bootstrap_c.input("out/bootstrap-c/src/with_compiler.c")
    package_bootstrap_c = package_bootstrap_c.input("out/gen/wl_decls.h")
    package_bootstrap_c = package_bootstrap_c.input("src/compiler/LlvmBridge.w")
    package_bootstrap_c = package_bootstrap_c.input("src/compiler/ClangBridge.w")
    package_bootstrap_c = package_bootstrap_c.input("rt/rt_core.w")
    package_bootstrap_c = package_bootstrap_c.input("rt/panic_runtime.w")
    package_bootstrap_c = package_bootstrap_c.input("rt/regex_runtime.w")
    package_bootstrap_c = package_bootstrap_c.input("rt/fiber_stubs.w")
    package_bootstrap_c = package_bootstrap_c.input("rt/compat_runtime.w")
    package_bootstrap_c = package_bootstrap_c.input("runtime/with_runtime.h")
    package_bootstrap_c = package_bootstrap_c.input("runtime/unistd.h")
    package_bootstrap_c = package_bootstrap_c.input("runtime/undef_stdio_macros.h")
    package_bootstrap_c = package_bootstrap_c.input("runtime/sys/resource.h")
    package_bootstrap_c = package_bootstrap_c.input("scripts/bootstrap/linux_platform.c")
    package_bootstrap_c = package_bootstrap_c.input("scripts/bootstrap/windows_platform.c")
    package_bootstrap_c = package_bootstrap_c.input("scripts/bootstrap/windows_compat_runtime.c")
    package_bootstrap_c = package_bootstrap_c.input("scripts/bootstrap/empty_embedded_windows.s")
    package_bootstrap_c = package_bootstrap_c.input("build/package.w")
    package_bootstrap_c = package_bootstrap_c.input("build/zlib_gzip.w")
    package_bootstrap_c = package_bootstrap_c.write_scope("out/bootstrap-c-package")
    package_bootstrap_c = package_bootstrap_c.write_scope("out/release")
    package_bootstrap_c = package_bootstrap_c.write_scope("out/command/package-bootstrap-c")
    package_bootstrap_c = package_bootstrap_c.timeout(900000)
    out = out.add_target(package_bootstrap_c)

    out = out.add_target(package_platform_target("package-darwin-aarch64", "darwin-aarch64", ctx))
    out = out.add_target(package_platform_target("package-linux-x86_64", "linux-x86_64", ctx))
    out = out.add_target(package_platform_target("package-windows-x86_64", "windows-x86_64", ctx))
    out = out.add_target(package_current_host_target())
    out = out.add_target(package_llvm_sdk_platform_target("package-llvm-sdk-darwin-aarch64", "darwin-aarch64", sdk_default_prefix_for_platform("darwin-aarch64"), sdk_default_build_cache_for_platform("darwin-aarch64")))
    out = out.add_target(package_llvm_sdk_platform_target("package-llvm-sdk-linux-x86_64", "linux-x86_64", sdk_default_prefix_for_platform("linux-x86_64"), sdk_default_build_cache_for_platform("linux-x86_64")))
    out = out.add_target(package_llvm_sdk_platform_target("package-llvm-sdk-windows-x86_64", "windows-x86_64", sdk_default_prefix_for_platform("windows-x86_64"), sdk_default_build_cache_for_platform("windows-x86_64")))
    out = out.add_target(package_llvm_sdk_current_host_target())

    out = out.add_target(sdk_source_target("sdk-ninja-source", sdk_ninja_source_url(), sdk_ninja_source_sha256(), sdk_ninja_archive(), sdk_source_root(), sdk_ninja_source_dir(), sdk_ninja_source_marker()))
    out = out.add_target(sdk_source_target("sdk-cmake-source", sdk_cmake_source_url(), sdk_cmake_source_sha256(), sdk_cmake_archive(), sdk_source_root(), sdk_cmake_source_dir(), sdk_cmake_source_marker()))
    out = out.add_target(sdk_source_target("sdk-llvm-source", sdk_llvm_source_url(), sdk_llvm_source_sha256(), sdk_llvm_archive(), sdk_source_root(), sdk_llvm_source_dir(), sdk_llvm_source_marker()))
    out = out.add_target(sdk_ninja_target(ctx))
    out = out.add_target(sdk_cmake_target(ctx))
    out = out.add_target(sdk_llvm_target(ctx))
    out = out.add_target(sdk_group_target())
    out = out.add_target(sdk_package_target(ctx))

    var compat_runtime = target_new(.Action, "compat-runtime-source", "").output("out/gen/compat_runtime.w")
    compat_runtime = compat_runtime.extra_output("out/gen/compiler/EmbeddedStdlibData.w")
    compat_runtime = compat_runtime.input(host_runtime.compat_source)
    compat_runtime = target_with_embedded_stdlib_inputs(move compat_runtime, ctx)
    compat_runtime.action = generate_compat_runtime_action
    out = out.add_target(compat_runtime)

    // Embed clang's builtin headers into the binary so c_import is self-contained
    // at runtime (#312). Generated from the static SDK fetched/built into .deps.
    var clang_resource = target_new(.Action, "embedded-clang-resource-source", "").output("out/gen/compiler/EmbeddedClangResourceData.w")
    clang_resource.action = generate_embedded_clang_resource_action
    out = out.add_target(clang_resource)

    var compiler_no_c_export = target_new(.Action, "compiler-no-c-export", "").output("out/.build-state/compiler-no-c-export.txt")
    compiler_no_c_export.action = run_check_compiler_no_new_c_export_action
    compiler_no_c_export = compiler_no_c_export.write_scope("out/.build-state")
    compiler_no_c_export = target_with_compiler_c_export_audit_inputs(move compiler_no_c_export, ctx)
    out = out.add_target(compiler_no_c_export)

    var requirements_informative = target_new(.Action, "requirements-informative-check", "").output("out/.build-state/requirements-informative-check.txt")
    requirements_informative.action = run_check_requirements_informative_action
    requirements_informative = requirements_informative.write_scope("out/.build-state")
    requirements_informative = requirements_informative.input("docs/requirements.md")
    out = out.add_target(requirements_informative)

    // docs/requirements.md is hand-maintained, NOT build-generated. The former
    // `requirements` (generate) and `requirements-check` targets — which rewrote
    // docs/requirements.md from the spec and failed the build if it differed —
    // have been removed (build/requirements.w deleted). The build must never
    // auto-generate or auto-modify docs/requirements.md.

    var spec_inventory = target_new(.Action, "spec-inventory-check", "").output("out/.build-state/spec-inventory-check.txt")
    spec_inventory.action = run_check_spec_inventory_action
    spec_inventory = spec_inventory.write_scope("out/.build-state")
    spec_inventory = spec_inventory.input("docs/with-specification.md")
    spec_inventory = spec_inventory.input("src/Token.w")
    spec_inventory = spec_inventory.input("src/Parser.w")
    spec_inventory = spec_inventory.input("src/main.w")
    spec_inventory = spec_inventory.input("src/compiler/DriverOptions.w")
    spec_inventory = spec_inventory.input("lib/std")
    out = out.add_target(spec_inventory)

    out = out.add_target(with_object_target("bootstrap-llvm-bridge-object", "seed", "src/compiler/LlvmBridge.w", "out/bootstrap-lib/llvm_bridge.o", "-O1", ""))
    out = out.add_target(with_object_target("bootstrap-clang-bridge-object", "seed", "src/compiler/ClangBridge.w", "out/bootstrap-lib/clang_bridge.o", "-O1", ""))

    var bootstrap_llvm_link_metadata = target_new(.Action, "bootstrap-llvm-link-metadata", "").output("out/bootstrap-lib/.llvm-link-ready")
    bootstrap_llvm_link_metadata.action = run_generate_llvm_link_metadata_action
    bootstrap_llvm_link_metadata = bootstrap_llvm_link_metadata.input("out/bootstrap-lib/llvm_bridge.o")
    bootstrap_llvm_link_metadata = bootstrap_llvm_link_metadata.input("out/bootstrap-lib/clang_bridge.o")
    bootstrap_llvm_link_metadata = bootstrap_llvm_link_metadata.extra_output("out/bootstrap-lib/llvm_link.rsp")
    bootstrap_llvm_link_metadata = bootstrap_llvm_link_metadata.extra_output("out/bootstrap-lib/llvm_cc")
    bootstrap_llvm_link_metadata = bootstrap_llvm_link_metadata.extra_output("out/bootstrap-lib/llvm_ld.rsp")
    bootstrap_llvm_link_metadata = bootstrap_llvm_link_metadata.extra_output("out/bootstrap-lib/llvm_ld")
    bootstrap_llvm_link_metadata = bootstrap_llvm_link_metadata.dep("bootstrap-llvm-bridge-object")
    bootstrap_llvm_link_metadata = bootstrap_llvm_link_metadata.dep("bootstrap-clang-bridge-object")
    out = out.add_target(bootstrap_llvm_link_metadata)

    out = out.add_target(with_object_target("bootstrap-rt-core-object", "seed", "rt/rt_core.w", "out/bootstrap-lib/rt_core.o", "-O2", ""))
    out = out.add_target(with_object_target("bootstrap-rt-platform-object", "seed", host_runtime.platform_source, host_runtime.bootstrap_platform_object, "-O2", ""))
    out = out.add_target(empty_file_target("bootstrap-empty-opposite-runtime-blob", host_runtime.opposite_bootstrap_platform_blob))
    out = out.add_target(empty_file_target("bootstrap-empty-second-opposite-runtime-blob", host_runtime.second_opposite_bootstrap_platform_blob))
    out = out.add_target(with_object_target("bootstrap-cimport-stubs-object", "seed", "rt/cimport_stubs.w", "out/bootstrap-lib/cimport_stubs.o", "-O1", ""))
    out = out.add_target(with_object_target("bootstrap-compat-runtime-object", "seed", "out/gen/compat_runtime.w", "out/bootstrap-lib/compat_runtime.o", "-O1", "compat-runtime-source"))
    out = out.add_target(with_object_target("bootstrap-panic-runtime-object", "seed", "rt/panic_runtime.w", "out/bootstrap-lib/panic_runtime.o", "-O1", ""))
    out = out.add_target(with_ir_target_overflow("bootstrap-regex-runtime-ir", "seed", "rt/regex_runtime.w", "out/bootstrap-tmp/regex_runtime.ll", "", "wrap"))
    var bootstrap_regex_runtime = target_new(.CompileLlvmIrObject, "bootstrap-regex-runtime-object", "out/bootstrap-tmp/regex_runtime.ll").output("out/bootstrap-lib/regex_runtime.o")
    bootstrap_regex_runtime = bootstrap_regex_runtime.dep("bootstrap-regex-runtime-ir")
    out = out.add_target(bootstrap_regex_runtime)
    out = out.add_target(with_object_target("bootstrap-fiber-stubs-object", "seed", "rt/fiber_stubs.w", "out/bootstrap-lib/fiber_stubs.o", "-O1", ""))
    out = out.add_target(with_object_target("bootstrap-channel-runtime-object", "seed", "rt/channel_runtime.w", "out/bootstrap-lib/channel_runtime.o", "-O1", ""))
    out = out.add_target(with_object_target("bootstrap-fiber-runtime-object", "seed", "rt/fiber_runtime.w", "out/bootstrap-lib/fiber_runtime.o", "-O1", ""))
    out = out.add_target(with_object_target("bootstrap-fiber-core-object", "seed", host_runtime.fiber_core_source, "out/bootstrap-lib/fiber.o", "-O1", ""))
    var bootstrap_fiber_asm = target_new(.CompileAsmObject, "bootstrap-fiber-asm-object", host_runtime.fiber_asm_source).output("out/bootstrap-lib/fiber_asm.o")
    out = out.add_target(bootstrap_fiber_asm)

    var bootstrap_embedded_objects = target_new(.EmbedObjectFiles, "bootstrap-embedded-objects-asm", "").output("out/bootstrap-lib/embedded_objects.s")
    bootstrap_embedded_objects = bootstrap_embedded_objects.input("out/bootstrap-lib/cimport_stubs.o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.arg("cimport_stubs_o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.input("out/bootstrap-lib/compat_runtime.o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.arg("compat_runtime_o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.input("out/bootstrap-lib/panic_runtime.o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.arg("panic_runtime_o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.input("out/bootstrap-lib/regex_runtime.o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.arg("regex_runtime_o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.input("out/bootstrap-lib/fiber_stubs.o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.arg("fiber_stubs_o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.input("out/bootstrap-lib/channel_runtime.o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.arg("channel_runtime_o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.input("out/bootstrap-lib/fiber_runtime.o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.arg("fiber_runtime_o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.input("out/bootstrap-lib/fiber.o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.arg("fiber_o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.input("out/bootstrap-lib/fiber_asm.o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.arg("fiber_asm_o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.input("out/bootstrap-lib/rt_core.o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.arg("rt_core_o")
    bootstrap_embedded_objects = bootstrap_embedded_objects.input(host_runtime.bootstrap_platform_object)
    bootstrap_embedded_objects = bootstrap_embedded_objects.arg(host_runtime.platform_symbol)
    bootstrap_embedded_objects = bootstrap_embedded_objects.input(host_runtime.opposite_bootstrap_platform_blob)
    bootstrap_embedded_objects = bootstrap_embedded_objects.arg(host_runtime.opposite_platform_symbol)
    bootstrap_embedded_objects = bootstrap_embedded_objects.input(host_runtime.second_opposite_bootstrap_platform_blob)
    bootstrap_embedded_objects = bootstrap_embedded_objects.arg(host_runtime.second_opposite_platform_symbol)
    out = out.add_target(bootstrap_embedded_objects)
    var bootstrap_embedded_objects_obj = target_new(.CompileAsmObject, "bootstrap-embedded-objects-object", "out/bootstrap-lib/embedded_objects.s").output("out/bootstrap-lib/embedded_objects.o")
    bootstrap_embedded_objects_obj = bootstrap_embedded_objects_obj.dep("bootstrap-embedded-objects-asm")
    out = out.add_target(bootstrap_embedded_objects_obj)

    var bootstrap_runtime = target_new(.Group, "bootstrap-runtime", "")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-llvm-link-metadata")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-rt-core-object")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-rt-platform-object")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-empty-opposite-runtime-blob")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-empty-second-opposite-runtime-blob")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-cimport-stubs-object")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-compat-runtime-object")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-panic-runtime-object")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-regex-runtime-object")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-fiber-stubs-object")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-channel-runtime-object")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-fiber-runtime-object")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-fiber-core-object")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-fiber-asm-object")
    bootstrap_runtime = bootstrap_runtime.dep("bootstrap-embedded-objects-object")
    out = out.add_target(bootstrap_runtime)

    var prepare_bootstrap_link_root = target_new(.Action, "prepare-bootstrap-link-root", "").output("out/bootstrap-lib/.prepared-link-root")
    prepare_bootstrap_link_root.action = run_prepare_bootstrap_link_root_action
    prepare_bootstrap_link_root = prepare_bootstrap_link_root.input("src/compiler/LlvmBridge.w")
    prepare_bootstrap_link_root = prepare_bootstrap_link_root.input("src/compiler/ClangBridge.w")
    prepare_bootstrap_link_root = prepare_bootstrap_link_root.input("rt/cimport_stubs.w")
    prepare_bootstrap_link_root = prepare_bootstrap_link_root.input("rt/rt_core.w")
    prepare_bootstrap_link_root = prepare_bootstrap_link_root.input(host_runtime.platform_source)
    prepare_bootstrap_link_root = prepare_bootstrap_link_root.input(host_runtime.compat_source)
    prepare_bootstrap_link_root = prepare_bootstrap_link_root.write_scope("out/lib")
    prepare_bootstrap_link_root = prepare_bootstrap_link_root.write_scope("out/bootstrap-lib")
    prepare_bootstrap_link_root = prepare_bootstrap_link_root.dep("bootstrap-runtime")
    out = out.add_target(prepare_bootstrap_link_root)

    var sha256_tool = target_new(.Executable, "with-sha256", "tools/with-sha256.w").output(host_bin("out/bin/with-sha256"))
    sha256_tool = sha256_tool.compiler("seed")
    sha256_tool = sha256_tool.dep("prepare-bootstrap-link-root")
    out = out.add_target(sha256_tool)

    out = out.add_target(with_object_target("llvm-bridge-object", stage_compiler_bin("with-stage2"), "src/compiler/LlvmBridge.w", "out/lib/llvm_bridge.o", "-O1", "stage2"))
    out = out.add_target(with_object_target("clang-bridge-object", stage_compiler_bin("with-stage2"), "src/compiler/ClangBridge.w", "out/lib/clang_bridge.o", "-O1", "stage2"))

    var llvm_link_metadata = target_new(.Action, "llvm-link-metadata", "").output("out/lib/.llvm-link-ready")
    llvm_link_metadata.action = run_generate_llvm_link_metadata_action
    llvm_link_metadata = llvm_link_metadata.input("out/lib/llvm_bridge.o")
    llvm_link_metadata = llvm_link_metadata.input("out/lib/clang_bridge.o")
    llvm_link_metadata = llvm_link_metadata.extra_output("out/lib/llvm_link.rsp")
    llvm_link_metadata = llvm_link_metadata.extra_output("out/lib/llvm_cc")
    llvm_link_metadata = llvm_link_metadata.extra_output("out/lib/llvm_ld.rsp")
    llvm_link_metadata = llvm_link_metadata.extra_output("out/lib/llvm_ld")
    llvm_link_metadata = llvm_link_metadata.dep("llvm-bridge-object")
    llvm_link_metadata = llvm_link_metadata.dep("clang-bridge-object")
    out = out.add_target(llvm_link_metadata)

    var stage1 = target_new(.Action, "stage1", "").output(bootstrap_compiler_bin("with-stage1"))
    stage1.action = run_with_compiler_build_action
    stage1 = stage1.compiler("seed")
    stage1 = stage1.input("out/gen/main.w")
    stage1 = target_with_compiler_source_inputs(move stage1, ctx)
    stage1 = stage1.arg("-O1")
    stage1 = stage1.extra_output("out/command/stage1")
    stage1 = stage1.extra_output("out/.build-state/seed-input.json")
    stage1 = stage1.input(host_bin("out/bin/with-sha256"))
    stage1 = stage1.write_scope("out/bootstrap/bin")
    stage1 = stage1.write_scope("out/.build-state")
    stage1 = stage1.dep("compiler-sources")
    stage1 = stage1.dep("compat-runtime-source")
    stage1 = stage1.dep("embedded-clang-resource-source")
    stage1 = stage1.dep("compiler-no-c-export")
    stage1 = stage1.dep("prepare-bootstrap-link-root")
    stage1 = stage1.dep("with-sha256")
    out = out.add_target(stage1)

    var stage2 = target_new(.Action, "stage2", "").output(stage_compiler_bin("with-stage2"))
    stage2.action = run_with_compiler_build_action
    stage2 = stage2.compiler(bootstrap_compiler_bin("with-stage1"))
    stage2 = stage2.input("out/gen/main.w")
    stage2 = target_with_compiler_source_inputs(move stage2, ctx)
    stage2 = stage2.arg("-O1")
    stage2 = stage2.extra_output("out/command/stage2")
    stage2 = stage2.write_scope("out/stage/bin")
    stage2 = stage2.dep("stage1")
    stage2 = stage2.dep("compat-runtime-source")
    stage2 = stage2.dep("embedded-clang-resource-source")
    out = out.add_target(stage2)

    var stage3 = target_new(.Action, "stage3", "").output(stage_compiler_bin("with-stage3"))
    stage3.action = run_with_compiler_build_action
    stage3 = stage3.compiler(stage_compiler_bin("with-stage2"))
    stage3 = stage3.input("out/gen/main.w")
    stage3 = target_with_compiler_source_inputs(move stage3, ctx)
    stage3 = stage3.arg("-O1")
    stage3 = stage3.extra_output("out/command/stage3")
    stage3 = stage3.write_scope("out/stage/bin")
    stage3 = stage3.dep("stage2")
    stage3 = stage3.dep("compat-runtime-source")
    stage3 = stage3.dep("embedded-clang-resource-source")
    out = out.add_target(stage3)

    var stage2_fixpoint = target_new(.Action, "stage2-fixpoint-object", "").output(stage_compiler_obj("with-stage2-fixpoint.o"))
    stage2_fixpoint.action = run_with_compiler_build_action
    stage2_fixpoint = stage2_fixpoint.compiler(bootstrap_compiler_bin("with-stage1"))
    stage2_fixpoint = stage2_fixpoint.input("out/gen/main.w")
    stage2_fixpoint = target_with_compiler_source_inputs(move stage2_fixpoint, ctx)
    stage2_fixpoint = stage2_fixpoint.arg("--emit-obj")
    stage2_fixpoint = stage2_fixpoint.arg("-O1")
    stage2_fixpoint = stage2_fixpoint.extra_output("out/command/stage2-fixpoint-object")
    stage2_fixpoint = stage2_fixpoint.write_scope("out/stage/bin")
    stage2_fixpoint = stage2_fixpoint.dep("stage1")
    stage2_fixpoint = stage2_fixpoint.dep("compat-runtime-source")
    stage2_fixpoint = stage2_fixpoint.dep("embedded-clang-resource-source")
    out = out.add_target(stage2_fixpoint)

    var stage3_fixpoint = target_new(.Action, "stage3-fixpoint-object", "").output(stage_compiler_obj("with-stage3-fixpoint.o"))
    stage3_fixpoint.action = run_with_compiler_build_action
    stage3_fixpoint = stage3_fixpoint.compiler(stage_compiler_bin("with-stage2"))
    stage3_fixpoint = stage3_fixpoint.input("out/gen/main.w")
    stage3_fixpoint = target_with_compiler_source_inputs(move stage3_fixpoint, ctx)
    stage3_fixpoint = stage3_fixpoint.arg("--emit-obj")
    stage3_fixpoint = stage3_fixpoint.arg("-O1")
    stage3_fixpoint = stage3_fixpoint.extra_output("out/command/stage3-fixpoint-object")
    stage3_fixpoint = stage3_fixpoint.write_scope("out/stage/bin")
    stage3_fixpoint = stage3_fixpoint.dep("stage2")
    stage3_fixpoint = stage3_fixpoint.dep("compat-runtime-source")
    stage3_fixpoint = stage3_fixpoint.dep("embedded-clang-resource-source")
    out = out.add_target(stage3_fixpoint)

    var selfcheck = target_new(.RunCorpusTest, "selfcheck", stage_compiler_bin("with-stage2"))
    selfcheck = selfcheck.output("out/corpus/selfcheck")
    selfcheck = selfcheck.arg("check")
    selfcheck = selfcheck.arg("src/main.w")
    selfcheck = selfcheck.dep("stage2")
    out = out.add_target(selfcheck)

    var fixpoint_compare = target_new(.FixpointCompare, "fixpoint-compare", stage_compiler_obj("with-stage2-fixpoint.o"))
    fixpoint_compare = fixpoint_compare.arg(stage_compiler_obj("with-stage3-fixpoint.o"))
    fixpoint_compare = fixpoint_compare.dep("stage2-fixpoint-object")
    fixpoint_compare = fixpoint_compare.dep("stage3-fixpoint-object")
    out = out.add_target(fixpoint_compare)

    var bless_manifest = target_new(.Action, "bless-manifest", "").output("out/.build-state/blessed-manifest")
    bless_manifest.action = run_bless_manifest_action
    bless_manifest = bless_manifest.write_scope("out/.build-state")
    bless_manifest = bless_manifest.dep("fixpoint-compare")
    out = out.add_target(bless_manifest)

    var fixpoint = target_new(.Group, "fixpoint", "")
    fixpoint = fixpoint.dep("fixpoint-compare")
    fixpoint = fixpoint.dep("bless-manifest")
    out = out.add_target(fixpoint)

    var fixpoint_diff = target_new(.Action, "fixpoint-diff", "").output("out/fixpoint-diff/report.txt")
    fixpoint_diff.action = run_fixpoint_diff_action
    fixpoint_diff = fixpoint_diff.dep("stage2")
    fixpoint_diff = fixpoint_diff.dep("stage2-fixpoint-object")
    fixpoint_diff = fixpoint_diff.dep("stage3-fixpoint-object")
    fixpoint_diff = fixpoint_diff.write_scope("out/fixpoint-diff")
    out = out.add_target(fixpoint_diff)

    var verified = target_new(.Group, "verified-existing-stage", "")
    verified = verified.dep("selfcheck")
    verified = verified.dep("fixpoint")
    out = out.add_target(verified)

    out = out.add_target(with_object_target("rt-core-object", stage_compiler_bin("with-stage2"), "rt/rt_core.w", "out/lib/rt_core.o", "-O2", "stage2"))
    out = out.add_target(with_object_target("rt-platform-object", stage_compiler_bin("with-stage2"), host_runtime.platform_source, host_runtime.platform_object, "-O2", "stage2"))
    out = out.add_target(empty_file_target("empty-opposite-runtime-blob", host_runtime.opposite_platform_blob))
    out = out.add_target(empty_file_target("empty-second-opposite-runtime-blob", host_runtime.second_opposite_platform_blob))
    out = out.add_target(with_object_target("cimport-stubs-object", stage_compiler_bin("with-stage2"), "rt/cimport_stubs.w", "out/lib/cimport_stubs.o", "-O1", "stage2"))
    var compat_runtime_obj = with_object_target("compat-runtime-object", stage_compiler_bin("with-stage2"), "out/gen/compat_runtime.w", "out/lib/compat_runtime.o", "-O1", "stage2")
    compat_runtime_obj = compat_runtime_obj.dep("compat-runtime-source")
    out = out.add_target(compat_runtime_obj)
    out = out.add_target(with_object_target("panic-runtime-object", stage_compiler_bin("with-stage2"), "rt/panic_runtime.w", "out/lib/panic_runtime.o", "-O1", "stage2"))
    out = out.add_target(with_ir_target_overflow("regex-runtime-ir", stage_compiler_bin("with-stage2"), "rt/regex_runtime.w", "out/tmp/regex_runtime.ll", "stage2", "wrap"))

    var regex_runtime = target_new(.CompileLlvmIrObject, "regex-runtime-object", "out/tmp/regex_runtime.ll").output("out/lib/regex_runtime.o")
    out = out.add_target(regex_runtime)

    out = out.add_target(with_object_target("fiber-stubs-object", stage_compiler_bin("with-stage2"), "rt/fiber_stubs.w", "out/lib/fiber_stubs.o", "-O1", "stage2"))
    out = out.add_target(with_object_target("channel-runtime-object", stage_compiler_bin("with-stage2"), "rt/channel_runtime.w", "out/lib/channel_runtime.o", "-O1", "stage2"))
    out = out.add_target(with_object_target("fiber-runtime-object", stage_compiler_bin("with-stage2"), "rt/fiber_runtime.w", "out/lib/fiber_runtime.o", "-O1", "stage2"))
    out = out.add_target(with_object_target("fiber-core-object", stage_compiler_bin("with-stage2"), host_runtime.fiber_core_source, "out/lib/fiber.o", "-O1", "stage2"))

    var fiber_asm = target_new(.CompileAsmObject, "fiber-asm-object", host_runtime.fiber_asm_source).output("out/lib/fiber_asm.o")
    out = out.add_target(fiber_asm)

    var embedded_objects = target_new(.EmbedObjectFiles, "embedded-objects-asm", "").output("out/lib/embedded_objects.s")
    embedded_objects = embedded_objects.input("out/lib/cimport_stubs.o")
    embedded_objects = embedded_objects.arg("cimport_stubs_o")
    embedded_objects = embedded_objects.input("out/lib/compat_runtime.o")
    embedded_objects = embedded_objects.arg("compat_runtime_o")
    embedded_objects = embedded_objects.input("out/lib/panic_runtime.o")
    embedded_objects = embedded_objects.arg("panic_runtime_o")
    embedded_objects = embedded_objects.input("out/lib/regex_runtime.o")
    embedded_objects = embedded_objects.arg("regex_runtime_o")
    embedded_objects = embedded_objects.input("out/lib/fiber_stubs.o")
    embedded_objects = embedded_objects.arg("fiber_stubs_o")
    embedded_objects = embedded_objects.input("out/lib/channel_runtime.o")
    embedded_objects = embedded_objects.arg("channel_runtime_o")
    embedded_objects = embedded_objects.input("out/lib/fiber_runtime.o")
    embedded_objects = embedded_objects.arg("fiber_runtime_o")
    embedded_objects = embedded_objects.input("out/lib/fiber.o")
    embedded_objects = embedded_objects.arg("fiber_o")
    embedded_objects = embedded_objects.input("out/lib/fiber_asm.o")
    embedded_objects = embedded_objects.arg("fiber_asm_o")
    embedded_objects = embedded_objects.input("out/lib/rt_core.o")
    embedded_objects = embedded_objects.arg("rt_core_o")
    embedded_objects = embedded_objects.input(host_runtime.platform_object)
    embedded_objects = embedded_objects.arg(host_runtime.platform_symbol)
    embedded_objects = embedded_objects.input(host_runtime.opposite_platform_blob)
    embedded_objects = embedded_objects.arg(host_runtime.opposite_platform_symbol)
    embedded_objects = embedded_objects.input(host_runtime.second_opposite_platform_blob)
    embedded_objects = embedded_objects.arg(host_runtime.second_opposite_platform_symbol)
    out = out.add_target(embedded_objects)

    var embedded_objects_obj = target_new(.CompileAsmObject, "embedded-objects-object", "out/lib/embedded_objects.s").output("out/lib/embedded_objects.o")
    embedded_objects_obj = embedded_objects_obj.dep("embedded-objects-asm")
    out = out.add_target(embedded_objects_obj)

    var runtime = target_new(.Group, "runtime", "")
    runtime = runtime.dep("embedded-objects-object")
    runtime = runtime.dep("empty-opposite-runtime-blob")
    runtime = runtime.dep("empty-second-opposite-runtime-blob")
    out = out.add_target(runtime)

    var compiler = target_new(.Action, "build", "").output(release_compiler_bin("with"))
    compiler.action = run_with_compiler_build_action
    compiler = compiler.compiler(stage_compiler_bin("with-stage2"))
    compiler = compiler.input("out/gen/main.w")
    compiler = target_with_compiler_source_inputs(move compiler, ctx)
    compiler = compiler.arg("-O1")
    compiler = compiler.extra_output("out/command/build")
    compiler = compiler.write_scope("out/release/bin")
    compiler = compiler.dep("llvm-link-metadata")
    compiler = compiler.dep("embedded-objects-object")
    out = out.add_target(compiler)

    var build_handoff = target_new(.CopyFile, "update-bin", release_compiler_bin("with")).output(host_bin("out/bin/with"))
    build_handoff = build_handoff.arg("0755")
    build_handoff = build_handoff.write_scope("out/bin")
    build_handoff = build_handoff.dep("build")
    out = out.add_target(build_handoff)

    var stack_budget_check = target_new(.Action, "stack-budget-check", "").output("out/test-graph/stack-budget-check")
    stack_budget_check.action = run_stack_budget_check_action
    stack_budget_check = stack_budget_check.input(release_compiler_bin("with"))
    stack_budget_check = stack_budget_check.dep("build")
    out = out.add_target(stack_budget_check)

    var emit_c_test = target_new(.Action, "emit-c-test", "").output("out/gen/.emit-c-test-stamp")
    emit_c_test.action = run_emit_c_test_action
    emit_c_test = emit_c_test.input(release_compiler_bin("with"))
    emit_c_test = emit_c_test.extra_output("out/emit-c-test")
    emit_c_test = emit_c_test.extra_output("out/gen/wl_decls.h")
    emit_c_test = emit_c_test.extra_output("out/gen/wl_stubs.c")
    emit_c_test = emit_c_test.extra_output("out/command/emit-c-test")
    emit_c_test = emit_c_test.dep("build")
    out = out.add_target(emit_c_test)

    var emit_c_fixpoint = target_new(.Action, "emit-c-fixpoint", "").output("out/gen/.emit-c-fixpoint-stamp")
    emit_c_fixpoint.action = run_emit_c_fixpoint_action
    emit_c_fixpoint = emit_c_fixpoint.input("out/emit-c-test/main.c")
    emit_c_fixpoint = emit_c_fixpoint.input(host_bin("out/emit-c-test/with-from-c"))
    emit_c_fixpoint = emit_c_fixpoint.extra_output("out/emit-c-test/main2.c")
    emit_c_fixpoint = emit_c_fixpoint.extra_output("out/command/emit-c-fixpoint")
    emit_c_fixpoint = emit_c_fixpoint.dep("emit-c-test")
    out = out.add_target(emit_c_fixpoint)

    var emit_c_roundtrip = target_new(.Action, "emit-c-roundtrip", "").output("out/gen/.emit-c-roundtrip-stamp")
    emit_c_roundtrip.action = run_emit_c_roundtrip_action
    emit_c_roundtrip = emit_c_roundtrip.input(release_compiler_bin("with"))
    emit_c_roundtrip = emit_c_roundtrip.extra_output("out/emit-c-roundtrip")
    emit_c_roundtrip = emit_c_roundtrip.extra_output("out/gen/wl_decls.h")
    emit_c_roundtrip = emit_c_roundtrip.extra_output("out/gen/wl_stubs.c")
    emit_c_roundtrip = emit_c_roundtrip.extra_output("out/command/emit-c-roundtrip")
    emit_c_roundtrip = emit_c_roundtrip.dep("build")
    out = out.add_target(emit_c_roundtrip)

    var behavior_tests = target_new(.Test, "behavior-tests", "test/behavior/*.w")
    behavior_tests = behavior_tests.arg("compiler=" ++ release_compiler_bin("with"))
    behavior_tests = behavior_tests.dep("build")
    out = out.add_target(behavior_tests)

    // Debug-allocator fixture lane (custom //! expect-debug-alloc directive; run
    // via tools/debug_drop.w, not the built-in test runner). See docs/debug-allocator.md.
    var debug_alloc_tests = target_new(.Action, "debug-alloc-tests", "").output("out/debug-alloc-tests")
    debug_alloc_tests.action = run_debug_alloc_tests_action
    debug_alloc_tests = debug_alloc_tests.input(release_compiler_bin("with"))
    debug_alloc_tests = debug_alloc_tests.input("tools/debug_drop.w")
    debug_alloc_tests = debug_alloc_tests.input("test/debug_alloc")
    debug_alloc_tests = debug_alloc_tests.dep("build")
    debug_alloc_tests = debug_alloc_tests.write_scope("out/debug-alloc-tests")
    out = out.add_target(debug_alloc_tests)

    var deep_debug_tool_tests = target_new(.Action, "deep-debug-tool-tests", "").output("out/deep-debug-tool-tests")
    deep_debug_tool_tests.action = run_deep_debug_tool_tests_action
    deep_debug_tool_tests = deep_debug_tool_tests.input(release_compiler_bin("with"))
    deep_debug_tool_tests = deep_debug_tool_tests.dep("build")
    deep_debug_tool_tests = deep_debug_tool_tests.write_scope("out/deep-debug-tool-tests")
    out = out.add_target(deep_debug_tool_tests)

    var native_compile_error_tests = target_new(.Test, "native-compile-error-tests", "test/compile_errors/*.w")
    native_compile_error_tests = native_compile_error_tests.arg("compiler=" ++ release_compiler_bin("with"))
    native_compile_error_tests = native_compile_error_tests.dep("build")
    native_compile_error_tests = native_compile_error_tests.dep("selfcheck")
    out = out.add_target(native_compile_error_tests)

    var native_codegen_tests = target_new(.Test, "native-codegen-tests", "test/codegen/*.w")
    native_codegen_tests = native_codegen_tests.arg("compiler=" ++ release_compiler_bin("with"))
    native_codegen_tests = native_codegen_tests.dep("build")
    native_codegen_tests = native_codegen_tests.dep("selfcheck")
    out = out.add_target(native_codegen_tests)

    var native_spec_tests = target_new(.Test, "native-spec-tests", "test/spec/*.w")
    native_spec_tests = native_spec_tests.arg("compiler=" ++ release_compiler_bin("with"))
    native_spec_tests = native_spec_tests.dep("build")
    native_spec_tests = native_spec_tests.dep("selfcheck")
    out = out.add_target(native_spec_tests)

    var comptime_diff_tests = target_new(.Test, "comptime-diff-tests", "test/comptime_diff/*.w")
    comptime_diff_tests = comptime_diff_tests.arg("compiler=" ++ release_compiler_bin("with"))
    comptime_diff_tests = comptime_diff_tests.dep("build")
    comptime_diff_tests = comptime_diff_tests.dep("selfcheck")
    out = out.add_target(comptime_diff_tests)

    var native_phase_tests = target_new(.Test, "native-phase-tests", "test/phase/*.w")
    native_phase_tests = native_phase_tests.arg("compiler=" ++ release_compiler_bin("with"))
    native_phase_tests = native_phase_tests.dep("build")
    native_phase_tests = native_phase_tests.dep("selfcheck")
    out = out.add_target(native_phase_tests)

    var internals_tests = target_new(.Test, "internals-tests", "test/internals/*.w")
    internals_tests = internals_tests.arg("compiler=" ++ release_compiler_bin("with"))
    internals_tests = internals_tests.dep("build")
    internals_tests = internals_tests.dep("selfcheck")
    out = out.add_target(internals_tests)

    var lexer_tests = target_new(.Test, "lexer-tests", "test/lexer/*.w")
    lexer_tests = lexer_tests.arg("compiler=" ++ release_compiler_bin("with"))
    lexer_tests = lexer_tests.dep("build")
    lexer_tests = lexer_tests.dep("selfcheck")
    out = out.add_target(lexer_tests)

    var parser_tests = target_new(.Test, "parser-tests", "test/parser/*.w")
    parser_tests = parser_tests.arg("compiler=" ++ release_compiler_bin("with"))
    parser_tests = parser_tests.dep("build")
    parser_tests = parser_tests.dep("selfcheck")
    out = out.add_target(parser_tests)

    var cli_selfhost_smoke_tests = target_new(.Action, "cli-selfhost-smoke-tests", "").output("out/test-graph/cli-selfhost-smoke-tests")
    cli_selfhost_smoke_tests.action = run_cli_selfhost_smoke_action
    cli_selfhost_smoke_tests = cli_selfhost_smoke_tests.input(release_compiler_bin("with"))
    cli_selfhost_smoke_tests = cli_selfhost_smoke_tests.dep("build")
    out = out.add_target(cli_selfhost_smoke_tests)

    var cli_selfhost_one_liner_tests = target_new(.Action, "cli-selfhost-one-liner-tests", "").output("out/test-graph/cli-selfhost-one-liner-tests")
    cli_selfhost_one_liner_tests.action = run_cli_selfhost_one_liner_action
    cli_selfhost_one_liner_tests = cli_selfhost_one_liner_tests.input(release_compiler_bin("with"))
    cli_selfhost_one_liner_tests = cli_selfhost_one_liner_tests.dep("build")
    out = out.add_target(cli_selfhost_one_liner_tests)

    var cli_selfhost_object_symbol_tests = target_new(.Action, "cli-selfhost-object-symbol-tests", "").output("out/test-graph/cli-selfhost-object-symbol-tests")
    cli_selfhost_object_symbol_tests.action = run_cli_selfhost_object_symbol_action
    cli_selfhost_object_symbol_tests = cli_selfhost_object_symbol_tests.arg("nm")
    cli_selfhost_object_symbol_tests = cli_selfhost_object_symbol_tests.input(release_compiler_bin("with"))
    cli_selfhost_object_symbol_tests = cli_selfhost_object_symbol_tests.dep("build")
    out = out.add_target(cli_selfhost_object_symbol_tests)

    var cli_selfhost_build_w_tests = target_new(.Action, "cli-selfhost-build-w-tests", "").output("out/test-graph/cli-selfhost-build-w-tests")
    cli_selfhost_build_w_tests.action = run_cli_selfhost_build_w_action
    cli_selfhost_build_w_tests = cli_selfhost_build_w_tests.input(release_compiler_bin("with"))
    cli_selfhost_build_w_tests = cli_selfhost_build_w_tests.dep("build")
    out = out.add_target(cli_selfhost_build_w_tests)

    var cli_selfhost_project_tests = target_new(.Action, "cli-selfhost-project-tests", "").output("out/test-graph/cli-selfhost-project-tests")
    cli_selfhost_project_tests.action = run_cli_selfhost_project_action
    cli_selfhost_project_tests = cli_selfhost_project_tests.input(release_compiler_bin("with"))
    cli_selfhost_project_tests = cli_selfhost_project_tests.allow_network()
    cli_selfhost_project_tests = cli_selfhost_project_tests.dep("build")
    out = out.add_target(cli_selfhost_project_tests)

    var cli_selfhost_lsp_tests = target_new(.Action, "cli-selfhost-lsp-tests", "").output("out/test-graph/cli-selfhost-lsp-tests")
    cli_selfhost_lsp_tests.action = run_cli_selfhost_lsp_action
    cli_selfhost_lsp_tests = cli_selfhost_lsp_tests.input(release_compiler_bin("with"))
    cli_selfhost_lsp_tests = cli_selfhost_lsp_tests.dep("build")
    out = out.add_target(cli_selfhost_lsp_tests)

    var cli_selfhost_edge_tests = target_new(.Action, "cli-selfhost-edge-tests", "").output("out/test-graph/cli-selfhost-edge-tests")
    cli_selfhost_edge_tests.action = run_cli_selfhost_edge_action
    cli_selfhost_edge_tests = cli_selfhost_edge_tests.input(release_compiler_bin("with"))
    cli_selfhost_edge_tests = cli_selfhost_edge_tests.dep("build")
    out = out.add_target(cli_selfhost_edge_tests)

    var cli_selfhost_parallel_tests = target_new(.Action, "cli-selfhost-parallel-tests", "").output("out/test-graph/cli-selfhost-parallel-tests")
    cli_selfhost_parallel_tests.action = run_cli_selfhost_parallel_action
    cli_selfhost_parallel_tests = cli_selfhost_parallel_tests.input(release_compiler_bin("with"))
    cli_selfhost_parallel_tests = cli_selfhost_parallel_tests.dep("build")
    out = out.add_target(cli_selfhost_parallel_tests)

    var c_migrator_pcre2_prep_tests = target_new(.Action, "c-migrator-pcre2-prep-tests", "").output("out/test-graph/c-migrator-pcre2-prep-tests")
    c_migrator_pcre2_prep_tests.action = run_cli_selfhost_pcre2_prep_action
    c_migrator_pcre2_prep_tests = c_migrator_pcre2_prep_tests.input(release_compiler_bin("with"))
    c_migrator_pcre2_prep_tests = c_migrator_pcre2_prep_tests.dep("build")
    out = out.add_target(c_migrator_pcre2_prep_tests)

    var c_migrator_basic_tests = target_new(.Action, "c-migrator-basic-tests", "").output("out/test-graph/c-migrator-basic-tests")
    c_migrator_basic_tests.action = run_cli_selfhost_migrate_basic_action
    c_migrator_basic_tests = c_migrator_basic_tests.input(release_compiler_bin("with"))
    c_migrator_basic_tests = c_migrator_basic_tests.dep("build")
    out = out.add_target(c_migrator_basic_tests)

    var c_migrator_core_tests = target_new(.Action, "c-migrator-core-tests", "").output("out/test-graph/c-migrator-core-tests")
    c_migrator_core_tests.action = run_cli_selfhost_migrate_core_action
    c_migrator_core_tests = c_migrator_core_tests.input(release_compiler_bin("with"))
    c_migrator_core_tests = c_migrator_core_tests.dep("build")
    out = out.add_target(c_migrator_core_tests)

    var c_migrator_tests = target_new(.Group, "c-migrator-tests", "")
    c_migrator_tests = c_migrator_tests.dep("c-migrator-basic-tests")
    c_migrator_tests = c_migrator_tests.dep("c-migrator-core-tests")
    out = out.add_target(c_migrator_tests)

    var issue61_regression = target_new(.Action, "issue61-regression", "").output("out/test-graph/issue61-regression")
    issue61_regression.action = issue61_regression_action
    issue61_regression = issue61_regression.input(release_compiler_bin("with"))
    issue61_regression = issue61_regression.dep("build")
    out = out.add_target(issue61_regression)

    var invariance_check = target_new(.Action, "invariance-check", "").output("out/test-graph/invariance-check")
    invariance_check.action = invariance_check_action
    invariance_check = invariance_check.input(release_compiler_bin("with"))
    invariance_check = invariance_check.dep("build")
    out = out.add_target(invariance_check)

    var embedded_runtime_regression = target_new(.Action, "embedded-runtime-regression", "").output("out/test-graph/embedded-runtime-regression")
    embedded_runtime_regression.action = run_embedded_runtime_regression_action
    embedded_runtime_regression = embedded_runtime_regression.input(release_compiler_bin("with"))
    embedded_runtime_regression = embedded_runtime_regression.dep("build")
    out = out.add_target(embedded_runtime_regression)

    var emit_c_smoke = target_new(.Action, "emit-c-smoke", "").output("out/test-graph/emit-c-smoke")
    emit_c_smoke.action = run_emit_c_smoke_action
    emit_c_smoke = emit_c_smoke.input(release_compiler_bin("with"))
    emit_c_smoke = emit_c_smoke.input("test/hello.w")
    emit_c_smoke = emit_c_smoke.dep("build")
    emit_c_smoke = emit_c_smoke.dep("runtime")
    out = out.add_target(emit_c_smoke)

    var test_green = target_new(.Action, "test-green", "").output("out/.build-state/test-green.json")
    test_green.action = run_test_green_action
    test_green = test_green.input(host_bin("out/bin/with-sha256"))
    test_green = test_green.write_scope("out/.build-state")
    test_green = test_green.write_scope("out/command/test-green")
    test_green = test_green.dep("with-sha256")
    out = out.add_target(test_green)

    var tests = target_new(.Group, "test", "")
    tests = tests.dep("behavior-tests")
    tests = tests.dep("native-compile-error-tests")
    tests = tests.dep("native-codegen-tests")
    tests = tests.dep("native-spec-tests")
    tests = tests.dep("native-phase-tests")
    tests = tests.dep("comptime-diff-tests")
    tests = tests.dep("internals-tests")
    tests = tests.dep("lexer-tests")
    tests = tests.dep("parser-tests")
    tests = tests.dep("deep-debug-tool-tests")
    tests = tests.dep("cli-selfhost-smoke-tests")
    tests = tests.dep("cli-selfhost-one-liner-tests")
    tests = tests.dep("cli-selfhost-object-symbol-tests")
    tests = tests.dep("cli-selfhost-build-w-tests")
    tests = tests.dep("cli-selfhost-project-tests")
    tests = tests.dep("cli-selfhost-lsp-tests")
    tests = tests.dep("cli-selfhost-edge-tests")
    tests = tests.dep("cli-selfhost-parallel-tests")
    tests = tests.dep("c-migrator-tests")
    tests = tests.dep("issue61-regression")
    tests = tests.dep("invariance-check")
    tests = tests.dep("embedded-runtime-regression")
    tests = tests.dep("emit-c-smoke")
    tests = tests.dep("requirements-informative-check")
    tests = tests.dep("spec-inventory-check")
    tests = tests.dep("test-green")
    out = out.add_target(tests)

    var last_green = target_new(.Action, "last-green", "").output("out/.build-state/last-green.json")
    last_green.action = run_last_green_action
    last_green = last_green.input(host_bin("out/bin/with-sha256"))
    last_green = last_green.input(release_compiler_bin("with"))
    last_green = last_green.input(stage_compiler_obj("with-stage2-fixpoint.o"))
    last_green = last_green.input(stage_compiler_obj("with-stage3-fixpoint.o"))
    last_green = last_green.input("out/.build-state/seed-input.json")
    last_green = last_green.input("src/version")
    last_green = last_green.extra_output("out/seed-archive")
    last_green = last_green.extra_output("out/command/last-green")
    last_green = last_green.write_scope("out/.build-state")
    last_green = last_green.write_scope("out/seed-archive")
    last_green = last_green.write_scope("out/command/last-green")
    last_green = last_green.dep("fixpoint")
    last_green = last_green.dep("with-sha256")
    out = out.add_target(last_green)

    var require_last_green = target_new(.Action, "require-last-green", "").output("out/command/require-last-green/ok")
    require_last_green.action = run_require_last_green_action
    require_last_green = require_last_green.input(host_bin("out/bin/with-sha256"))
    require_last_green = require_last_green.write_scope("out/command/require-last-green")
    require_last_green = require_last_green.dep("with-sha256")
    out = out.add_target(require_last_green)

    if release_platform_asset_is_distinct():
        var release_platform_asset = target_new(.Action, "release-platform-asset", "").output(release_platform_asset_bin())
        release_platform_asset.action = run_release_platform_asset_action
        release_platform_asset = release_platform_asset.input(release_compiler_bin("with"))
        release_platform_asset = release_platform_asset.write_scope("out/release")
        release_platform_asset = release_platform_asset.dep("build")
        out = out.add_target(release_platform_asset)

    var release_artifact_smoke_uat = target_new(.Action, "release-artifact-smoke-uat", "").output("out/release-uat/artifact-smoke.passed")
    release_artifact_smoke_uat.action = run_release_artifact_smoke_uat_action
    release_artifact_smoke_uat = release_artifact_smoke_uat.input(release_platform_asset_bin())
    release_artifact_smoke_uat = release_artifact_smoke_uat.write_scope("out/release-uat")
    release_artifact_smoke_uat = release_artifact_smoke_uat.dep("require-last-green")
    release_artifact_smoke_uat = release_uat_platform_asset_dep(move release_artifact_smoke_uat)
    out = out.add_target(release_artifact_smoke_uat)

    var release_fresh_project_uat = target_new(.Action, "release-fresh-project-uat", "").output("out/release-uat/fresh-project.passed")
    release_fresh_project_uat.action = run_release_fresh_project_uat_action
    release_fresh_project_uat = release_fresh_project_uat.input(release_platform_asset_bin())
    release_fresh_project_uat = release_fresh_project_uat.write_scope("out/release-uat")
    release_fresh_project_uat = release_fresh_project_uat.dep("require-last-green")
    release_fresh_project_uat = release_uat_platform_asset_dep(move release_fresh_project_uat)
    out = out.add_target(release_fresh_project_uat)

    var release_migrate_uat = target_new(.Action, "release-migrate-uat", "").output("out/release-uat/migrate.passed")
    release_migrate_uat.action = run_release_migrate_uat_action
    release_migrate_uat = release_migrate_uat.input(release_platform_asset_bin())
    release_migrate_uat = release_migrate_uat.write_scope("out/release-uat")
    release_migrate_uat = release_migrate_uat.dep("require-last-green")
    release_migrate_uat = release_uat_platform_asset_dep(move release_migrate_uat)
    out = out.add_target(release_migrate_uat)

    var release_zlib_uat = target_new(.Action, "release-zlib-uat", "").output("out/release-uat/zlib.passed")
    release_zlib_uat.action = run_release_zlib_uat_action
    release_zlib_uat = release_zlib_uat.input(release_platform_asset_bin())
    release_zlib_uat = release_zlib_uat.input("build/release_uat_fixtures/zlib_main.w")
    release_zlib_uat = release_zlib_uat.write_scope("out/release-uat")
    release_zlib_uat = release_zlib_uat.allow_network()
    release_zlib_uat = release_zlib_uat.dep("require-last-green")
    release_zlib_uat = release_uat_platform_asset_dep(move release_zlib_uat)
    out = out.add_target(release_zlib_uat)

    var release_bzip2_uat = target_new(.Action, "release-bzip2-uat", "").output("out/release-uat/bzip2.passed")
    release_bzip2_uat.action = run_release_bzip2_uat_action
    release_bzip2_uat = release_bzip2_uat.input(release_platform_asset_bin())
    release_bzip2_uat = release_bzip2_uat.input("build/release_uat_fixtures/bzip2_main.w")
    release_bzip2_uat = release_bzip2_uat.write_scope("out/release-uat")
    release_bzip2_uat = release_bzip2_uat.allow_network()
    release_bzip2_uat = release_bzip2_uat.dep("require-last-green")
    release_bzip2_uat = release_uat_platform_asset_dep(move release_bzip2_uat)
    out = out.add_target(release_bzip2_uat)

    var release_sqlite3_uat = target_new(.Action, "release-sqlite3-uat", "").output("out/release-uat/sqlite3.passed")
    release_sqlite3_uat.action = run_release_sqlite3_uat_action
    release_sqlite3_uat = release_sqlite3_uat.input(release_platform_asset_bin())
    release_sqlite3_uat = release_sqlite3_uat.input("build/release_uat_fixtures/sqlite3_main.w")
    release_sqlite3_uat = release_sqlite3_uat.write_scope("out/release-uat")
    release_sqlite3_uat = release_sqlite3_uat.allow_network()
    release_sqlite3_uat = release_sqlite3_uat.dep("require-last-green")
    release_sqlite3_uat = release_uat_platform_asset_dep(move release_sqlite3_uat)
    out = out.add_target(release_sqlite3_uat)

    var release_openssl_uat = target_new(.Action, "release-openssl-uat", "").output("out/release-uat/openssl.passed")
    release_openssl_uat.action = run_release_openssl_uat_action
    release_openssl_uat = release_openssl_uat.input(release_platform_asset_bin())
    release_openssl_uat = release_openssl_uat.input("build/release_uat_fixtures/openssl_main.w")
    release_openssl_uat = release_openssl_uat.write_scope("out/release-uat")
    release_openssl_uat = release_openssl_uat.allow_network()
    release_openssl_uat = release_openssl_uat.dep("require-last-green")
    release_openssl_uat = release_uat_platform_asset_dep(move release_openssl_uat)
    out = out.add_target(release_openssl_uat)

    var release_libcurl_uat = target_new(.Action, "release-libcurl-uat", "").output("out/release-uat/libcurl.passed")
    release_libcurl_uat.action = run_release_libcurl_uat_action
    release_libcurl_uat = release_libcurl_uat.input(release_platform_asset_bin())
    release_libcurl_uat = release_libcurl_uat.input("build/release_uat_fixtures/libcurl_main.w")
    release_libcurl_uat = release_libcurl_uat.write_scope("out/release-uat")
    release_libcurl_uat = release_libcurl_uat.allow_network()
    release_libcurl_uat = release_libcurl_uat.dep("require-last-green")
    release_libcurl_uat = release_uat_platform_asset_dep(move release_libcurl_uat)
    out = out.add_target(release_libcurl_uat)

    var release_install_layout_uat = target_new(.Action, "release-install-layout-uat", "").output("out/release-uat/install-layout.passed")
    release_install_layout_uat.action = run_release_install_layout_uat_action
    release_install_layout_uat = release_install_layout_uat.input(release_platform_asset_bin())
    release_install_layout_uat = release_install_layout_uat.write_scope("out/release-uat")
    release_install_layout_uat = release_install_layout_uat.dep("require-last-green")
    release_install_layout_uat = release_uat_platform_asset_dep(move release_install_layout_uat)
    out = out.add_target(release_install_layout_uat)

    var release_raylib_spiral_uat = target_new(.Action, "release-raylib-spiral-uat", "").output("out/release-uat/raylib-spiral.passed")
    release_raylib_spiral_uat.action = run_release_raylib_spiral_uat_action
    release_raylib_spiral_uat = release_raylib_spiral_uat.input(release_platform_asset_bin())
    release_raylib_spiral_uat = release_raylib_spiral_uat.input("build/release_uat_fixtures/raylib_spiral_main.w")
    release_raylib_spiral_uat = release_raylib_spiral_uat.write_scope("out/release-uat")
    release_raylib_spiral_uat = release_raylib_spiral_uat.allow_network()
    release_raylib_spiral_uat = release_raylib_spiral_uat.dep("require-last-green")
    release_raylib_spiral_uat = release_uat_platform_asset_dep(move release_raylib_spiral_uat)
    out = out.add_target(release_raylib_spiral_uat)

    var release_one_liner_uat = target_new(.Action, "release-one-liner-uat", "").output("out/release-uat/one-liners.passed")
    release_one_liner_uat.action = run_release_one_liner_uat_action
    release_one_liner_uat = release_one_liner_uat.input(release_platform_asset_bin())
    release_one_liner_uat = release_one_liner_uat.write_scope("out/release-uat")
    release_one_liner_uat = release_one_liner_uat.dep("require-last-green")
    release_one_liner_uat = release_uat_platform_asset_dep(move release_one_liner_uat)
    out = out.add_target(release_one_liner_uat)

    var release_uat = target_new(.Group, "release-uat", "")
    release_uat = release_uat.dep("release-artifact-smoke-uat")
    release_uat = release_uat.dep("release-fresh-project-uat")
    release_uat = release_uat.dep("release-migrate-uat")
    release_uat = release_uat.dep("release-zlib-uat")
    release_uat = release_uat.dep("release-bzip2-uat")
    release_uat = release_uat.dep("release-sqlite3-uat")
    release_uat = release_uat.dep("release-openssl-uat")
    release_uat = release_uat.dep("release-libcurl-uat")
    release_uat = release_uat.dep("release-install-layout-uat")
    release_uat = release_uat.dep("release-raylib-spiral-uat")
    release_uat = release_uat.dep("release-one-liner-uat")
    out = out.add_target(release_uat)

    var check_committed = target_new(.Action, "check-committed-state", "").output("out/command/check-committed-state/ok")
    check_committed.action = run_check_committed_state_action
    check_committed = check_committed.write_scope("out/command/check-committed-state")
    out = out.add_target(check_committed)

    out = out.add_target(install_file_target("install-user", release_compiler_bin("with"), "$HOME/.local/bin/with", "0755", "require-last-green"))

    out = out.add_target(install_file_target("install-compiler", release_compiler_bin("with"), "$INSTALL_BINDIR/with" ++ host_exe_suffix(), "0755", "build"))
    out = out.add_target(install_file_target("install-rt-core", "out/lib/rt_core.o", "$INSTALL_LIBDIR/rt_core.o", "0644", "runtime"))
    out = out.add_target(install_file_target("install-rt-platform", host_runtime.platform_object, "$INSTALL_LIBDIR/" ++ host_runtime.platform_install_object, "0644", "runtime"))
    out = out.add_target(install_file_target("install-cimport-stubs", "out/lib/cimport_stubs.o", "$INSTALL_LIBDIR/cimport_stubs.o", "0644", "runtime"))
    out = out.add_target(install_file_target("install-compat-runtime", "out/lib/compat_runtime.o", "$INSTALL_LIBDIR/compat_runtime.o", "0644", "runtime"))
    out = out.add_target(install_file_target("install-panic-runtime", "out/lib/panic_runtime.o", "$INSTALL_LIBDIR/panic_runtime.o", "0644", "runtime"))
    out = out.add_target(install_file_target("install-regex-runtime", "out/lib/regex_runtime.o", "$INSTALL_LIBDIR/regex_runtime.o", "0644", "runtime"))
    out = out.add_target(install_file_target("install-fiber-stubs", "out/lib/fiber_stubs.o", "$INSTALL_LIBDIR/fiber_stubs.o", "0644", "runtime"))
    out = out.add_target(install_file_target("install-channel-runtime", "out/lib/channel_runtime.o", "$INSTALL_LIBDIR/channel_runtime.o", "0644", "runtime"))
    out = out.add_target(install_file_target("install-fiber-runtime", "out/lib/fiber_runtime.o", "$INSTALL_LIBDIR/fiber_runtime.o", "0644", "runtime"))
    out = out.add_target(install_file_target("install-fiber-core", "out/lib/fiber.o", "$INSTALL_LIBDIR/fiber.o", "0644", "runtime"))
    out = out.add_target(install_file_target("install-fiber-asm", "out/lib/fiber_asm.o", "$INSTALL_LIBDIR/fiber_asm.o", "0644", "runtime"))
    out = out.add_target(install_file_target("install-embedded-objects", "out/lib/embedded_objects.o", "$INSTALL_LIBDIR/embedded_objects.o", "0644", "runtime"))
    out = out.add_target(install_file_target("install-embedded-objects-asm", "out/lib/embedded_objects.s", "$INSTALL_LIBDIR/embedded_objects.s", "0644", "runtime"))
    out = out.add_target(install_file_target("install-llvm-bridge", "out/lib/llvm_bridge.o", "$INSTALL_LIBDIR/llvm_bridge.o", "0644", "llvm-link-metadata"))
    out = out.add_target(install_file_target("install-clang-bridge", "out/lib/clang_bridge.o", "$INSTALL_LIBDIR/clang_bridge.o", "0644", "llvm-link-metadata"))
    out = out.add_target(install_file_target("install-llvm-link-rsp", "out/lib/llvm_link.rsp", "$INSTALL_LIBDIR/llvm_link.rsp", "0644", "llvm-link-metadata"))
    out = out.add_target(install_file_target("install-llvm-cc", "out/lib/llvm_cc", "$INSTALL_LIBDIR/llvm_cc", "0644", "llvm-link-metadata"))
    out = out.add_target(install_file_target("install-llvm-ld-rsp", "out/lib/llvm_ld.rsp", "$INSTALL_LIBDIR/llvm_ld.rsp", "0644", "llvm-link-metadata"))
    out = out.add_target(install_file_target("install-llvm-ld", "out/lib/llvm_ld", "$INSTALL_LIBDIR/llvm_ld", "0644", "llvm-link-metadata"))
    var install = target_new(.Group, "install", "")
    install = install.dep("install-compiler")
    install = install.dep("install-rt-core")
    install = install.dep("install-rt-platform")
    install = install.dep("install-cimport-stubs")
    install = install.dep("install-compat-runtime")
    install = install.dep("install-panic-runtime")
    install = install.dep("install-regex-runtime")
    install = install.dep("install-fiber-stubs")
    install = install.dep("install-channel-runtime")
    install = install.dep("install-fiber-runtime")
    install = install.dep("install-fiber-core")
    install = install.dep("install-fiber-asm")
    install = install.dep("install-embedded-objects")
    install = install.dep("install-embedded-objects-asm")
    install = install.dep("install-llvm-bridge")
    install = install.dep("install-clang-bridge")
    install = install.dep("install-llvm-link-rsp")
    install = install.dep("install-llvm-cc")
    install = install.dep("install-llvm-ld-rsp")
    install = install.dep("install-llvm-ld")
    out = out.add_target(install)

    var seed = target_new(.Action, "seed", "").output("src/main")
    seed.action = run_seed_download_action
    seed = seed.input("build/https_fetch.w")
    seed = seed.write_scope("out/tmp")
    seed = seed.allow_network()
    seed = seed.arg("withlang-dev/with")
    seed = seed.arg(release_asset_for_host())
    out = out.add_target(seed)

    // `with build :deps` — fetch the pinned, per-platform static LLVM SDK that
    // bootstrap built and a release published, into `.deps/llvm-<ver>-<host>`,
    // so a build never rebuilds LLVM from source or trusts a system LLVM.
    var deps = target_new(.Action, "deps", "").output(compiler_default_libclang_archive_path())
    deps.action = run_deps_download_action
    deps = deps.input("build/https_fetch.w")
    deps = deps.input("build/zlib_gunzip.w")
    deps = deps.write_scope("out/tmp")
    deps = deps.write_scope(".deps")
    deps = deps.allow_network()
    deps = deps.arg("withlang-dev/with")
    deps = deps.arg(llvm_sdk_asset_for_host())
    deps = deps.arg(llvm_sdk_dir_basename())
    out = out.add_target(deps)

    var cross = target_new(.Action, "cross", "").output("out/command/cross/unsupported")
    cross.action = run_cross_unsupported_action
    cross = cross.arg(env("CROSS_TARGET"))
    cross = cross.write_scope("out/command/cross")
    out = out.add_target(cross)

    out = out.add_target(install_file_target("update-seed", release_compiler_bin("with"), "src/main", "0755", "require-last-green"))

    var clean = target_new(.Clean, "clean", "")
    clean = clean.arg("out")
    clean = clean.arg(".with")
    clean = clean.arg("src/main.c")
    clean = clean.arg("src/main.o")
    clean = clean.arg("src/bootstrap_main.c")
    clean = clean.arg("src/bootstrap_main.o")
    clean = clean.arg("main.c")
    clean = clean.arg("main.o")
    clean = clean.arg("bootstrap_main.c")
    clean = clean.arg("bootstrap_main.o")
    out = out.add_target(clean)

    var pcre2_reference = target_new(.Action, "pcre2-reference", "").output("out/pcre2_reference/pcre2-10.47")
    pcre2_reference.action = run_pcre2_reference_action
    pcre2_reference = pcre2_reference.extra_output("out/pcre2_reference/pcre2-10.47/.with-reference-ready")
    pcre2_reference = pcre2_reference.input("build/https_fetch.w")
    pcre2_reference = pcre2_reference.input("build/zlib_gunzip.w")
    pcre2_reference = pcre2_reference.write_scope("out/tmp/action-scratch/pcre2-reference")
    pcre2_reference = pcre2_reference.allow_network()
    pcre2_reference = pcre2_reference.arg("pcre2-10.47")
    pcre2_reference = pcre2_reference.arg("https://github.com/PCRE2Project/pcre2/releases/download/pcre2-10.47/pcre2-10.47.tar.gz")
    out = out.add_target(pcre2_reference)

    var pcre2_migrate = target_new(.Action, "pcre2-migrate", "").output("out/gen/.regex-migrate-stamp")
    pcre2_migrate.action = run_pcre2_migrate_action
    pcre2_migrate = pcre2_migrate.extra_output("out/pcre2_migrated")
    pcre2_migrate = pcre2_migrate.write_scope("out/tmp/action-scratch/pcre2-migrate")
    pcre2_migrate = pcre2_migrate.write_scope("out/pcre2_migrate_raw")
    pcre2_migrate = pcre2_migrate.write_scope("out/pcre2_generated")
    pcre2_migrate = pcre2_migrate.write_scope("out/pcre2_build")
    pcre2_migrate = pcre2_migrate.write_scope("out/gen/.regex-build-stamp")
    pcre2_migrate = pcre2_migrate.input("out/pcre2_reference/pcre2-10.47/src")
    pcre2_migrate = pcre2_migrate.arg("out/pcre2_migrated")
    pcre2_migrate = pcre2_migrate.arg("pcre2demo.c")
    pcre2_migrate = pcre2_migrate.arg("pcre2grep.c")
    pcre2_migrate = pcre2_migrate.arg("pcre2posix_test.c")
    pcre2_migrate = pcre2_migrate.arg("pcre2_jit_test.c")
    pcre2_migrate = pcre2_migrate.arg("pcre2_dftables.c")
    pcre2_migrate = pcre2_migrate.arg("pcre2_fuzzsupport.c")
    pcre2_migrate = pcre2_migrate.dep("pcre2-reference")
    out = out.add_target(pcre2_migrate)

    var pcre2_migrate_smoke = target_new(.Action, "pcre2-migrate-smoke", "").output("out/test-graph/pcre2-migrate-smoke")
    pcre2_migrate_smoke.action = run_pcre2_migrate_smoke_action
    pcre2_migrate_smoke = pcre2_migrate_smoke.input("out/pcre2_reference/pcre2-10.47/src/pcre2_compile.c")
    pcre2_migrate_smoke = pcre2_migrate_smoke.input("out/pcre2_reference/pcre2-10.47/src")
    pcre2_migrate_smoke = pcre2_migrate_smoke.dep("pcre2-reference")
    out = out.add_target(pcre2_migrate_smoke)

    var pcre2_test_smoke = target_new(.Action, "pcre2-test-smoke", "").output("out/test-graph/pcre2-test-smoke")
    pcre2_test_smoke.action = run_pcre2_test_smoke_action
    pcre2_test_smoke = pcre2_test_smoke.input("lib/std/re/pcre2test.w")
    pcre2_test_smoke = pcre2_test_smoke.input("out/pcre2_reference/pcre2-10.47/RunTest")
    pcre2_test_smoke = pcre2_test_smoke.arg("out/pcre2_reference/pcre2-10.47")
    pcre2_test_smoke = pcre2_test_smoke.dep("pcre2-reference")
    pcre2_test_smoke = pcre2_test_smoke.dep("selfcheck")
    out = out.add_target(pcre2_test_smoke)

    var pcre2_build = target_new(.Action, "pcre2-build", "").output("out/pcre2_build")
    pcre2_build.action = run_pcre2_build_action
    pcre2_build = pcre2_build.write_scope("out/tmp/action-scratch/pcre2-build")
    pcre2_build = pcre2_build.input("out/pcre2_migrated")
    pcre2_build = pcre2_build.dep("build")
    out = out.add_target(pcre2_build)

    var pcre2_test = target_new(.Action, "pcre2-test", "").output("out/corpus/pcre2-test")
    pcre2_test.action = run_pcre2_test_action
    pcre2_test = pcre2_test.input("out/pcre2_migrated")
    pcre2_test = pcre2_test.input("out/pcre2_build/bin/pcre2test")
    pcre2_test = pcre2_test.input("out/pcre2_reference/pcre2-10.47/RunTest")
    pcre2_test = pcre2_test.arg("out/pcre2_reference/pcre2-10.47")
    pcre2_test = pcre2_test.dep("verified-existing-stage")
    out = out.add_target(pcre2_test)

    var pcre2_check_generated = target_new(.Action, "pcre2-check-generated", "").output("out/gen/.pcre2-check-generated-stamp")
    pcre2_check_generated.action = run_pcre2_check_generated_action
    pcre2_check_generated = pcre2_check_generated.write_scope("out/tmp/action-scratch/pcre2-check-generated")
    pcre2_check_generated = pcre2_check_generated.input("out/pcre2_build/lib/std/re")
    pcre2_check_generated = pcre2_check_generated.dep("build")
    out = out.add_target(pcre2_check_generated)

    var pcre2_promote = target_new(.Action, "pcre2-promote", "").output("lib/std/re")
    pcre2_promote.action = run_pcre2_promote_action
    pcre2_promote = pcre2_promote.write_scope("out/tmp/action-scratch/pcre2-promote")
    pcre2_promote = pcre2_promote.input("out/pcre2_build/lib/std/re")
    pcre2_promote = pcre2_promote.dep("pcre2-test")
    out = out.add_target(pcre2_promote)

    var zlib_reference = target_new(.Action, "zlib-reference", "").output("out/zlib_reference/zlib-1.3.2")
    zlib_reference.action = run_zlib_reference_action
    zlib_reference = zlib_reference.extra_output("out/zlib_reference/zlib-1.3.2/.with-reference-ready")
    zlib_reference = zlib_reference.write_scope("out/tmp/action-scratch/zlib-reference")
    zlib_reference = zlib_reference.input("build/zlib_http_fetch.w")
    zlib_reference = zlib_reference.input("build/zlib_gunzip.w")
    zlib_reference = zlib_reference.arg("zlib-1.3.2")
    zlib_reference = zlib_reference.arg("http://zlib.net/fossils/zlib-1.3.2.tar.gz")
    zlib_reference = zlib_reference.allow_network()
    zlib_reference = zlib_reference.dep("runtime")
    out = out.add_target(zlib_reference)

    var zlib_migrate = target_new(.Action, "zlib-migrate", "").output("out/gen/.zlib-migrate-stamp")
    zlib_migrate.action = run_zlib_migrate_action
    zlib_migrate = zlib_migrate.extra_output("out/zlib_migrated")
    zlib_migrate = zlib_migrate.write_scope("out/tmp/action-scratch/zlib-migrate")
    zlib_migrate = zlib_migrate.write_scope("out/zlib_migrated")
    zlib_migrate = zlib_migrate.write_scope("out/zlib_build")
    zlib_migrate = zlib_migrate.write_scope("out/corpus/zlib-test")
    zlib_migrate = zlib_migrate.input("out/zlib_reference/zlib-1.3.2")
    zlib_migrate = zlib_migrate.arg("out/zlib_migrated")
    zlib_migrate = zlib_migrate.dep("zlib-reference")
    out = out.add_target(zlib_migrate)

    var zlib_build = target_new(.Action, "zlib-build", "").output("out/zlib_build")
    zlib_build.action = run_zlib_build_action
    zlib_build = zlib_build.write_scope("out/tmp/action-scratch/zlib-build")
    zlib_build = zlib_build.input("out/zlib_migrated")
    zlib_build = zlib_build.dep("build")
    zlib_build = zlib_build.dep("zlib-migrate")
    out = out.add_target(zlib_build)

    var zlib_test = target_new(.Action, "zlib-test", "").output("out/corpus/zlib-test")
    zlib_test.action = run_zlib_test_action
    zlib_test = zlib_test.input("out/zlib_migrated")
    zlib_test = zlib_test.input("out/zlib_build/bin/zlib_example")
    zlib_test = zlib_test.input("out/zlib_build/bin/minigzip")
    zlib_test = zlib_test.dep("zlib-build")
    out = out.add_target(zlib_test)

    var zlib_check_generated = target_new(.Action, "zlib-check-generated", "").output("out/gen/.zlib-check-generated-stamp")
    zlib_check_generated.action = run_zlib_check_generated_action
    zlib_check_generated = zlib_check_generated.write_scope("out/tmp/action-scratch/zlib-check-generated")
    zlib_check_generated = zlib_check_generated.input("out/zlib_migrated")
    zlib_check_generated = zlib_check_generated.dep("zlib-migrate")
    out = out.add_target(zlib_check_generated)

    var zlib_promote = target_new(.Action, "zlib-promote", "").output("lib/std/zlib")
    zlib_promote.action = run_zlib_promote_action
    zlib_promote = zlib_promote.write_scope("out/tmp/action-scratch/zlib-promote")
    zlib_promote = zlib_promote.input("out/zlib_migrated")
    zlib_promote = zlib_promote.dep("zlib-test")
    out = out.add_target(zlib_promote)

    var prune = target_new(.Action, "prune", "").output("out/.build-state/prune.always")
    prune.action = run_prune_action
    prune = prune.arg("dry-run")
    prune = prune.arg("live-target=prune")
    prune = prune.arg("live-target=prune-apply")
    prune = target_with_live_targets(move prune, out)
    prune = prune.write_scope("out/bin")
    prune = prune.write_scope("out/bootstrap/bin")
    prune = prune.write_scope("out/stage/bin")
    prune = prune.write_scope("out/release/bin")
    prune = prune.write_scope("out/lib")
    prune = prune.write_scope("out/bootstrap-lib")
    prune = prune.write_scope("out/.build-state")
    prune = prune.write_scope("out/seed-archive")
    prune = prune.write_scope("out/release")
    prune = prune.write_scope("out/test-graph")
    prune = prune.write_scope("out/command/prune")
    out = out.add_target(prune)

    var prune_apply = target_new(.Action, "prune-apply", "").output("out/.build-state/prune-apply.always")
    prune_apply.action = run_prune_action
    prune_apply = prune_apply.arg("apply")
    prune_apply = prune_apply.arg("live-target=prune")
    prune_apply = prune_apply.arg("live-target=prune-apply")
    prune_apply = target_with_live_targets(move prune_apply, out)
    prune_apply = prune_apply.write_scope("out/bin")
    prune_apply = prune_apply.write_scope("out/bootstrap/bin")
    prune_apply = prune_apply.write_scope("out/stage/bin")
    prune_apply = prune_apply.write_scope("out/release/bin")
    prune_apply = prune_apply.write_scope("out/lib")
    prune_apply = prune_apply.write_scope("out/bootstrap-lib")
    prune_apply = prune_apply.write_scope("out/.build-state")
    prune_apply = prune_apply.write_scope("out/seed-archive")
    prune_apply = prune_apply.write_scope("out/release")
    prune_apply = prune_apply.write_scope("out/test-graph")
    prune_apply = prune_apply.write_scope("out/command/prune-apply")
    out = out.add_target(prune_apply)

    out.default("build")