build.zig

const std = @import("std");
const builtin = @import("builtin");

const required_zig_version = "0.16.0";

// Build script for the current Zig stable template.
// - Builds the current example executables.
// - Uses src/lib.zig as a shared module imported by both executables.
pub fn build(b: *std.Build) void {
    // Keep build semantics tied to the Zig version this repository is tested with.
    comptime {
        if (!std.mem.eql(u8, builtin.zig_version_string, required_zig_version)) {
            @compileError("quicz requires Zig " ++ required_zig_version ++ "; found " ++ builtin.zig_version_string);
        }
    }

    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    // Shared quicz module (library logic lives in src/lib.zig).
    // link_libc: the library uses std.c / std.heap.c_allocator (fuzz targets,
    // tests) and needs libc for clock/malloc on Linux; macOS links it by default.
    // This is a system library, not a C-code dependency.
    const quicz_mod = b.addModule("quicz", .{
        .root_source_file = b.path("src/lib.zig"),
        .target = target,
        .optimize = optimize,
        .link_libc = true,
    });

    // Shared loopback identity (DER cert + P-256 key) used by examples and
    // downstream tools such as the CLI package.
    const quicz_test_cert_mod = b.addModule("quicz-test-cert", .{
        .root_source_file = b.path("examples/test_certs.zig"),
        .target = target,
        .optimize = optimize,
    });

    // Disposable Mons runtime probe. The override preserves a pristine baseline.
    const mvp_source = b.option([]const u8, "mvp-quicz-source", "Local baseline source for the disposable Mons NAT probe");
    const mvp_quicz = b.createModule(.{
        .root_source_file = if (mvp_source) |root| .{ .cwd_relative = b.pathJoin(&.{ root, "src/lib.zig" }) } else b.path("src/lib.zig"),
        .target = target,
        .optimize = optimize,
        .link_libc = true,
    });
    const mons_nat_mvp = b.addExecutable(.{
        .name = "mons-nat-mvp",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/mons_nat_mvp.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{.{ .name = "quicz", .module = mvp_quicz }},
        }),
    });
    b.step("build-mons-nat-mvp", "Build the disposable Mons NAT rebinding probe")
        .dependOn(&b.addInstallArtifact(mons_nat_mvp, .{}).step);

    // Benchmark executables must measure production-like throughput, so force
    // ReleaseFast instead of inheriting the default (Debug) optimize. Without
    // this, `zig build bench-suite` reports misleadingly low numbers (~50 MB/s
    // Debug vs ~470 MB/s ReleaseFast).
    const quicz_bench_mod = b.addModule("quicz_bench", .{
        .root_source_file = b.path("src/lib.zig"),
        .target = target,
        .optimize = .ReleaseFast,
    });

    const lib = b.addLibrary(.{
        .name = "quicz",
        .root_module = quicz_mod,
    });
    b.installArtifact(lib);

    const mobile_abi_mod = b.createModule(.{
        .root_source_file = b.path("src/mobile_abi.zig"),
        .target = target,
        .optimize = optimize,
        .link_libc = true,
        .imports = &.{
            .{ .name = "quicz", .module = quicz_mod },
        },
    });
    const mobile_abi_lib = b.addLibrary(.{
        .name = "quicz_mobile",
        .root_module = mobile_abi_mod,
    });
    const install_mobile_abi = b.addInstallArtifact(mobile_abi_lib, .{});
    const install_mobile_header = b.addInstallFileWithDir(
        b.path("include/quicz_mobile.h"),
        .header,
        "quicz_mobile.h",
    );
    const mobile_abi_step = b.step("mobile-static", "Build the mobile C ABI static library and header");
    mobile_abi_step.dependOn(&install_mobile_abi.step);
    mobile_abi_step.dependOn(&install_mobile_header.step);

    const shared_socket_connectivity = b.addExecutable(.{
        .name = "quicz-shared-socket-connectivity-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/shared_socket_connectivity_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    const run_shared_socket_connectivity = b.step(
        "run-shared-socket-connectivity-loopback",
        "Run STUN discovery and QUIC on one client UDP socket",
    );
    run_shared_socket_connectivity.dependOn(&b.addRunArtifact(shared_socket_connectivity).step);

    const mobile_abi_loopback = b.addExecutable(.{
        .name = "quicz-mobile-abi-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/mobile_abi_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
                .{ .name = "quicz_mobile", .module = mobile_abi_mod },
            },
        }),
    });
    const run_mobile_abi_loopback = b.step(
        "run-mobile-abi-loopback",
        "Run the blocking mobile C ABI against the native QUIC server",
    );
    run_mobile_abi_loopback.dependOn(&b.addRunArtifact(mobile_abi_loopback).step);
    const mobile_ipv6_header = b.addTranslateC(.{
        .root_source_file = b.path("include/quicz_mobile.h"),
        .target = target,
        .optimize = optimize,
    });
    const mobile_ipv6_abi_loopback = b.addExecutable(.{
        .name = "quicz-mobile-ipv6-abi-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/mobile_ipv6_abi_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
                .{ .name = "quicz_mobile", .module = mobile_abi_mod },
                .{ .name = "quicz_mobile_c", .module = mobile_ipv6_header.createModule() },
            },
        }),
    });
    b.step("build-mobile-ipv6-abi-loopback", "Compile native IPv6 C ABI layout and loopback checks")
        .dependOn(&mobile_ipv6_abi_loopback.step);
    b.step("run-mobile-ipv6-abi-loopback", "Verify native IPv6 STUN, authenticated punch, TLS and stream through the C ABI")
        .dependOn(&b.addRunArtifact(mobile_ipv6_abi_loopback).step);

    const mobile_deadline_regression = b.addExecutable(.{
        .name = "quicz-mobile-deadline-regression",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/mobile_deadline_regression.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
                .{ .name = "quicz_mobile", .module = mobile_abi_mod },
            },
        }),
    });
    b.step("run-mobile-deadline-regression", "Check hosted C ABI deadline and cleanup latency")
        .dependOn(&b.addRunArtifact(mobile_deadline_regression).step);

    const p2p_quic_loopback = b.addExecutable(.{
        .name = "quicz-p2p-quic-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/p2p_quic_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    const run_p2p_quic_loopback = b.step(
        "run-p2p-quic-loopback",
        "Run authenticated UDP probing and verified QUIC on the same sockets",
    );
    run_p2p_quic_loopback.dependOn(&b.addRunArtifact(p2p_quic_loopback).step);

    const mobile_latency_server = b.addExecutable(.{
        .name = "quicz-mobile-latency-server",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/mobile_latency_server.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    const run_mobile_latency_server = b.step(
        "run-mobile-latency-server",
        "Run the QUIC echo server for iOS latency measurements",
    );
    const run_mobile_latency_server_command = b.addRunArtifact(mobile_latency_server);
    if (b.args) |args| run_mobile_latency_server_command.addArgs(args);
    run_mobile_latency_server.dependOn(&run_mobile_latency_server_command.step);

    // Echo server executable
    const exe_server = b.addExecutable(.{
        .name = "quicz-echo-server",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/echo_server.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_server);

    // Echo client executable
    const exe_client = b.addExecutable(.{
        .name = "quicz-echo-client",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/echo_client.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_client);

    const exe_tls13_process_echo_server = b.addExecutable(.{
        .name = "quicz-tls13-process-echo-server",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/tls13_process_echo_server.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_tls13_process_echo_server);

    const exe_tls13_process_echo_client = b.addExecutable(.{
        .name = "quicz-tls13-process-echo-client",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/tls13_process_echo_client.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_tls13_process_echo_client);

    // QUIC echo server/client (practical examples)
    const exe_quic_echo_server = b.addExecutable(.{
        .name = "quicz-quic-echo-server",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/quic_echo_server.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_quic_echo_server);
    const run_quic_echo_server = b.step("run-quic-echo-server", "Run QUIC echo server on 127.0.0.1:4433");
    const run_quic_echo_server_cmd = b.addRunArtifact(exe_quic_echo_server);
    run_quic_echo_server.dependOn(&run_quic_echo_server_cmd.step);

    const exe_quic_echo_client = b.addExecutable(.{
        .name = "quicz-quic-echo-client",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/quic_echo_client.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_quic_echo_client);
    const run_quic_echo_client = b.step("run-quic-echo-client", "Run QUIC echo client (connects to 127.0.0.1:4433)");
    const run_quic_echo_client_cmd = b.addRunArtifact(exe_quic_echo_client);
    run_quic_echo_client.dependOn(&run_quic_echo_client_cmd.step);

    // Connection migration demo
    const exe_connection_migration = b.addExecutable(.{
        .name = "quicz-connection-migration",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/connection_migration.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_connection_migration);
    const run_connection_migration = b.step("run-connection-migration", "Run QUIC connection migration demo (PATH_CHALLENGE/RESPONSE)");
    const run_connection_migration_cmd = b.addRunArtifact(exe_connection_migration);
    run_connection_migration.dependOn(&run_connection_migration_cmd.step);

    // H3 server on the production runtime (runtime.Server.serveH3)
    const exe_h3_server = b.addExecutable(.{
        .name = "quicz-h3-server",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/h3_server.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_h3_server);
    const run_h3_server = b.step("run-h3-server", "Run HTTP/3 static file server on 127.0.0.1:4433");
    const run_h3_server_cmd = b.addRunArtifact(exe_h3_server);
    run_h3_server.dependOn(&run_h3_server_cmd.step);

    // Cookie-jar demo HTTP/3 server (Set-Cookie + redirect + cookie echo)
    const exe_h3_cookie_server = b.addExecutable(.{
        .name = "quicz-h3-cookie-server",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/h3_cookie_server.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_h3_cookie_server);
    const run_h3_cookie_server = b.step("run-h3-cookie-server", "Run HTTP/3 cookie demo server on 127.0.0.1:4434");
    const run_h3_cookie_server_cmd = b.addRunArtifact(exe_h3_cookie_server);
    run_h3_cookie_server.dependOn(&run_h3_cookie_server_cmd.step);

    // DATAGRAM echo (RFC 9221)
    const exe_datagram_echo = b.addExecutable(.{
        .name = "quicz-datagram-echo",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/datagram_echo.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_datagram_echo);
    const run_datagram_echo = b.step("run-datagram-echo", "Run QUIC DATAGRAM echo (--server or --client)");
    const run_datagram_echo_cmd = b.addRunArtifact(exe_datagram_echo);
    run_datagram_echo.dependOn(&run_datagram_echo_cmd.step);

    // Post-quantum echo
    const exe_post_quantum_echo = b.addExecutable(.{
        .name = "quicz-post-quantum-echo",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/post_quantum_echo.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_post_quantum_echo);
    const run_post_quantum_echo = b.step("run-post-quantum-echo", "Run X25519Kyber768 post-quantum echo (--server or --client)");
    const run_post_quantum_echo_cmd = b.addRunArtifact(exe_post_quantum_echo);
    run_post_quantum_echo.dependOn(&run_post_quantum_echo_cmd.step);

    // 0-RTT echo
    const exe_zero_rtt_echo = b.addExecutable(.{
        .name = "quicz-zero-rtt-echo",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/zero_rtt_echo.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_zero_rtt_echo);
    const run_zero_rtt_echo = b.step("run-zero-rtt-echo", "Run 0-RTT session resumption echo demo");
    const run_zero_rtt_echo_cmd = b.addRunArtifact(exe_zero_rtt_echo);
    run_zero_rtt_echo.dependOn(&run_zero_rtt_echo_cmd.step);

    // Congestion control benchmark
    const exe_congestion_bench = b.addExecutable(.{
        .name = "quicz-congestion-bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/congestion_bench.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_bench_mod },
            },
        }),
    });
    b.installArtifact(exe_congestion_bench);
    const run_congestion_bench = b.step("run-congestion-bench", "Run congestion control comparison benchmark (NewReno/CUBIC)");
    const run_congestion_bench_cmd = b.addRunArtifact(exe_congestion_bench);
    run_congestion_bench.dependOn(&run_congestion_bench_cmd.step);

    const exe_quic_bench = b.addExecutable(.{
        .name = "quicz-quic-bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/quic_bench.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_bench_mod },
            },
        }),
    });
    b.installArtifact(exe_quic_bench);
    const run_quic_bench = b.step("run-quic-bench", "Run QUIC transport micro-benchmark (throughput + latency)");
    const run_quic_bench_cmd = b.addRunArtifact(exe_quic_bench);
    run_quic_bench.dependOn(&run_quic_bench_cmd.step);

    const exe_quic_bench_hs = b.addExecutable(.{
        .name = "quicz-quic-bench-hs",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/quic_bench_hs.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_bench_mod },
            },
        }),
    });
    b.installArtifact(exe_quic_bench_hs);
    const run_quic_bench_hs = b.step("run-quic-bench-hs", "Run QUIC benchmark with real TLS 1.3 handshakes (throughput + latency)");
    const run_quic_bench_hs_cmd = b.addRunArtifact(exe_quic_bench_hs);
    run_quic_bench_hs.dependOn(&run_quic_bench_hs_cmd.step);

    const exe_quic_bench_simple = b.addExecutable(.{
        .name = "quicz-quic-bench-simple",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/quic_bench_simple.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_bench_mod },
            },
        }),
    });
    b.installArtifact(exe_quic_bench_simple);
    const run_quic_bench_simple = b.step("run-quic-bench-simple", "Run single-threaded raw QUIC processing benchmark");
    const run_quic_bench_simple_cmd = b.addRunArtifact(exe_quic_bench_simple);
    run_quic_bench_simple.dependOn(&run_quic_bench_simple_cmd.step);

    const exe_quic_bench_datagram = b.addExecutable(.{
        .name = "quicz-quic-bench-datagram",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/quic_bench_datagram.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_bench_mod },
            },
        }),
    });
    b.installArtifact(exe_quic_bench_datagram);
    const run_quic_bench_datagram = b.step("run-quic-bench-datagram", "Run RFC 9221 DATAGRAM throughput benchmark");
    const run_quic_bench_datagram_cmd = b.addRunArtifact(exe_quic_bench_datagram);
    run_quic_bench_datagram.dependOn(&run_quic_bench_datagram_cmd.step);

    const exe_quic_bench_profile = b.addExecutable(.{
        .name = "quicz-quic-bench-profile",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/quic_bench_profile.zig"),
            .target = target,
            .optimize = .ReleaseFast,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_bench_mod },
            },
        }),
    });
    b.installArtifact(exe_quic_bench_profile);
    const run_quic_bench_profile = b.step("run-quic-bench-profile", "Run per-phase QUIC profiling benchmark");
    const run_quic_bench_profile_cmd = b.addRunArtifact(exe_quic_bench_profile);
    run_quic_bench_profile.dependOn(&run_quic_bench_profile_cmd.step);

    // Standardized benchmark suite: build + run every benchmark in fixed order.
    const bench_suite = b.step("bench-suite", "Run the full standardized benchmark suite");
    bench_suite.dependOn(&run_quic_bench_cmd.step);
    bench_suite.dependOn(&run_quic_bench_hs_cmd.step);
    bench_suite.dependOn(&run_quic_bench_simple_cmd.step);
    bench_suite.dependOn(&run_quic_bench_datagram_cmd.step);
    bench_suite.dependOn(&run_quic_bench_profile_cmd.step);
    bench_suite.dependOn(&run_congestion_bench_cmd.step);

    // I/O runtime - async streaming echo (std.Io)
    const exe_io_echo = b.addExecutable(.{
        .name = "quicz-io-echo",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/io_echo.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_io_echo);
    const run_io_echo = b.step("run-io-echo", "Run I/O runtime async streaming echo demo");
    const run_io_echo_cmd = b.addRunArtifact(exe_io_echo);
    run_io_echo.dependOn(&run_io_echo_cmd.step);

    // I/O runtime - multi-connection test (std.http model)
    const exe_multi_conn = b.addExecutable(.{
        .name = "quicz-multi-conn-test",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/multi_conn_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_multi_conn);
    const run_multi_conn = b.step("run-multi-conn-test", "Run I/O runtime multi-connection echo test");
    const run_multi_conn_cmd = b.addRunArtifact(exe_multi_conn);
    run_multi_conn.dependOn(&run_multi_conn_cmd.step);

    const exe_interop_external_client = b.addExecutable(.{
        .name = "quicz-interop-external-client",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/interop_external_client.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_interop_external_client);
    // Runtime-based interop client (validates production API path)
    const exe_interop_runtime_client = b.addExecutable(.{
        .name = "quicz-interop-runtime-client",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/interop_runtime_client.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_interop_runtime_client);
    const run_interop_runtime_client = b.step("run-interop-runtime-client", "Run runtime-based interop client");
    const run_interop_runtime_client_cmd = b.addRunArtifact(exe_interop_runtime_client);
    run_interop_runtime_client.dependOn(&run_interop_runtime_client_cmd.step);
    if (b.args) |args| {
        run_interop_runtime_client_cmd.addArgs(args);
    }

    // Runtime-based interop server (validates production API path)
    const exe_interop_runtime_server = b.addExecutable(.{
        .name = "quicz-interop-runtime-server",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/interop_runtime_server.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_interop_runtime_server);
    const run_interop_runtime_server = b.step("run-interop-runtime-server", "Run runtime-based interop server");
    const run_interop_runtime_server_cmd = b.addRunArtifact(exe_interop_runtime_server);
    run_interop_runtime_server.dependOn(&run_interop_runtime_server_cmd.step);
    if (b.args) |args| {
        run_interop_runtime_server_cmd.addArgs(args);
    }

    // zig build run-fuzz — run the fuzz harness
    const exe_fuzz = b.addExecutable(.{
        .name = "quicz-fuzz",
        .root_module = b.createModule(.{
            .root_source_file = b.path("fuzz.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_fuzz);
    const run_fuzz = b.step("run-fuzz", "Run QUIC fuzz harness");
    const run_fuzz_cmd = b.addRunArtifact(exe_fuzz);
    run_fuzz.dependOn(&run_fuzz_cmd.step);
    if (b.args) |args| {
        run_fuzz_cmd.addArgs(args);
    }

    // Codec roundtrip executable
    const exe_codec = b.addExecutable(.{
        .name = "quicz-codec-roundtrip",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/codec_roundtrip.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_codec);

    // Transport parameters executable
    const exe_transport_parameters = b.addExecutable(.{
        .name = "quicz-transport-parameters",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/transport_parameters.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_transport_parameters);

    // Flow-control executable
    const exe_flow_control = b.addExecutable(.{
        .name = "quicz-flow-control",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/flow_control.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_flow_control);

    // Unidirectional stream executable
    const exe_uni_stream = b.addExecutable(.{
        .name = "quicz-uni-stream",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/uni_stream.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_uni_stream);

    // Stream reset executable
    const exe_stream_reset = b.addExecutable(.{
        .name = "quicz-stream-reset",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/stream_reset.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_stream_reset);

    // STOP_SENDING executable
    const exe_stop_sending = b.addExecutable(.{
        .name = "quicz-stop-sending",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/stop_sending.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_stop_sending);

    // Crypto stream executable
    const exe_crypto_stream = b.addExecutable(.{
        .name = "quicz-crypto-stream",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/crypto_stream.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_crypto_stream);

    // TLS backend adapter executable
    const exe_tls_backend_adapter = b.addExecutable(.{
        .name = "quicz-tls-backend-adapter",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/tls_backend_adapter.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_tls_backend_adapter);

    // Pure-Zig TLS 1.3 backend loopback executable
    const exe_tls13_backend_loopback = b.addExecutable(.{
        .name = "quicz-tls13-backend-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/tls13_backend_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_tls13_backend_loopback);

    // Pure-Zig TLS 1.3 over UDP loopback executable
    const exe_tls13_udp_loopback = b.addExecutable(.{
        .name = "quicz-tls13-udp-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/tls13_udp_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_tls13_udp_loopback);

    const exe_h3_loopback = b.addExecutable(.{
        .name = "quicz-h3-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/h3_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_h3_loopback);

    const exe_h3_runtime_loopback = b.addExecutable(.{
        .name = "quicz-h3-runtime-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/h3_runtime_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_h3_runtime_loopback);

    const exe_h3_external_client = b.addExecutable(.{
        .name = "quicz-h3-external-client",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/h3_external_client.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_h3_external_client);

    const exe_multi_client_bench = b.addExecutable(.{
        .name = "quicz-multi-client-bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/multi_client_bench.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_multi_client_bench);
    const run_multi_client_bench = b.step("run-multi-client-bench", "Multi-client concurrent connection benchmark (handshake + aggregate throughput)");
    const run_multi_client_bench_cmd = b.addRunArtifact(exe_multi_client_bench);
    run_multi_client_bench.dependOn(&run_multi_client_bench_cmd.step);

    const exe_stability_bench = b.addExecutable(.{
        .name = "quicz-stability-bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/stability_bench.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_stability_bench);
    const run_stability_bench = b.step("run-stability-bench", "Long-run stability benchmark (multi-connection, multi-stream, leak-checked)");
    const run_stability_bench_cmd = b.addRunArtifact(exe_stability_bench);
    run_stability_bench.dependOn(&run_stability_bench_cmd.step);
    if (b.args) |args| {
        run_stability_bench_cmd.addArgs(args);
    }

    const exe_scale_bench = b.addExecutable(.{
        .name = "quicz-scale-bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/scale_bench.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_scale_bench);
    const run_scale_bench = b.step("run-scale-bench", "Connection-scale benchmark (N concurrent handshakes + echo, leak-checked)");
    const run_scale_bench_cmd = b.addRunArtifact(exe_scale_bench);
    run_scale_bench.dependOn(&run_scale_bench_cmd.step);

    // Pure-Zig TLS 1.3 with EndpointConnectionLifecycle ownership
    const exe_tls13_lifecycle_loopback = b.addExecutable(.{
        .name = "quicz-tls13-lifecycle-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/tls13_lifecycle_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_tls13_lifecycle_loopback);

    // Pure-Zig TLS 1.3 stateless reset over UDP loopback executable
    const exe_tls13_stateless_reset_loopback = b.addExecutable(.{
        .name = "quicz-tls13-stateless-reset-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/tls13_stateless_reset_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_tls13_stateless_reset_loopback);

    // Pure-Zig TLS 1.3 path validation over UDP loopback executable
    const exe_tls13_path_validation_loopback = b.addExecutable(.{
        .name = "quicz-tls13-path-validation-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/tls13_path_validation_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_tls13_path_validation_loopback);

    // Pure-Zig TLS 1.3 Retry over UDP loopback executable
    const exe_tls13_retry_loopback = b.addExecutable(.{
        .name = "quicz-tls13-retry-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/tls13_retry_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_tls13_retry_loopback);

    // QUIC-Interop-Runner 风格 interop client executable（M7 外部互通起步）
    const exe_interop_client = b.addExecutable(.{
        .name = "quicz-interop-client",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/interop_client.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_interop_client);

    // 事件驱动 interop loopback executable（deadline 驱动收发循环）
    const exe_interop_event_loopback = b.addExecutable(.{
        .name = "quicz-interop-event-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/interop_event_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_interop_event_loopback);

    // P5-C: QUIC-Interop-Runner server/client binaries
    const exe_interop_server = b.addExecutable(.{
        .name = "quicz-interop-server",
        .root_module = b.createModule(.{
            .root_source_file = b.path("interop/server.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_interop_server);

    const exe_interop_runner_client = b.addExecutable(.{
        .name = "quicz-interop-runner-client",
        .root_module = b.createModule(.{
            .root_source_file = b.path("interop/client.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_interop_runner_client);

    // TLS C ABI adapter executable
    const exe_tls_c_abi_adapter = b.addExecutable(.{
        .name = "quicz-tls-c-abi-adapter",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/tls_c_abi_adapter.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    const translate_tls_c_abi_adapter = b.addTranslateC(.{
        .root_source_file = b.path("examples/tls_c_abi_demo_backend.h"),
        .target = target,
        .optimize = optimize,
    });
    exe_tls_c_abi_adapter.root_module.addImport("c", translate_tls_c_abi_adapter.createModule());
    exe_tls_c_abi_adapter.root_module.addCSourceFile(.{
        .file = b.path("examples/tls_c_abi_demo_backend.c"),
        .flags = &.{},
    });
    exe_tls_c_abi_adapter.root_module.link_libc = true;
    b.installArtifact(exe_tls_c_abi_adapter);

    // OpenSSL QUIC TLS API probe executable
    const exe_tls_openssl_probe = b.addExecutable(.{
        .name = "quicz-tls-openssl-probe",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/tls_openssl_probe.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    const translate_tls_openssl_probe = b.addTranslateC(.{
        .root_source_file = b.path("examples/tls_openssl_probe.h"),
        .target = target,
        .optimize = optimize,
    });
    exe_tls_openssl_probe.root_module.addImport("c", translate_tls_openssl_probe.createModule());
    exe_tls_openssl_probe.root_module.addCSourceFile(.{
        .file = b.path("examples/tls_openssl_probe.c"),
        .flags = &.{},
    });
    exe_tls_openssl_probe.root_module.link_libc = true;
    exe_tls_openssl_probe.root_module.linkSystemLibrary("ssl", .{});
    exe_tls_openssl_probe.root_module.linkSystemLibrary("crypto", .{});
    // Not installed by default: requires OpenSSL 3.4+ QUIC API (probe tool).
    // b.installArtifact(exe_tls_openssl_probe);

    // OpenSSL-backed TLS backend adapter executable
    const exe_tls_openssl_backend_adapter = b.addExecutable(.{
        .name = "quicz-tls-openssl-backend-adapter",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/tls_openssl_backend_adapter.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    const translate_tls_openssl_backend_adapter = b.addTranslateC(.{
        .root_source_file = b.path("examples/tls_openssl_backend_adapter.h"),
        .target = target,
        .optimize = optimize,
    });
    exe_tls_openssl_backend_adapter.root_module.addImport("c", translate_tls_openssl_backend_adapter.createModule());
    exe_tls_openssl_backend_adapter.root_module.addCSourceFile(.{
        .file = b.path("examples/tls_openssl_backend_adapter.c"),
        .flags = &.{},
    });
    exe_tls_openssl_backend_adapter.root_module.addCSourceFile(.{
        .file = b.path("examples/tls_openssl_pair_transcript.c"),
        .flags = &.{},
    });
    exe_tls_openssl_backend_adapter.root_module.link_libc = true;
    exe_tls_openssl_backend_adapter.root_module.linkSystemLibrary("ssl", .{});
    exe_tls_openssl_backend_adapter.root_module.linkSystemLibrary("crypto", .{});
    // Not installed by default: requires OpenSSL 3.4+ QUIC API (probe tool).
    // b.installArtifact(exe_tls_openssl_backend_adapter);

    // OpenSSL client/server TLS transcript executable
    const exe_tls_openssl_pair_transcript = b.addExecutable(.{
        .name = "quicz-tls-openssl-pair-transcript",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/tls_openssl_pair_transcript.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    const translate_tls_openssl_pair_transcript = b.addTranslateC(.{
        .root_source_file = b.path("examples/tls_openssl_pair_transcript.h"),
        .target = target,
        .optimize = optimize,
    });
    exe_tls_openssl_pair_transcript.root_module.addImport("c", translate_tls_openssl_pair_transcript.createModule());
    exe_tls_openssl_pair_transcript.root_module.addCSourceFile(.{
        .file = b.path("examples/tls_openssl_pair_transcript.c"),
        .flags = &.{},
    });
    exe_tls_openssl_pair_transcript.root_module.link_libc = true;
    exe_tls_openssl_pair_transcript.root_module.linkSystemLibrary("ssl", .{});
    exe_tls_openssl_pair_transcript.root_module.linkSystemLibrary("crypto", .{});
    // Not installed by default: requires OpenSSL 3.4+ QUIC API (probe tool).
    // b.installArtifact(exe_tls_openssl_pair_transcript);

    // Graceful close executable
    const exe_graceful_close = b.addExecutable(.{
        .name = "quicz-graceful-close",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/graceful_close.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_graceful_close);

    // Idle timeout executable
    const exe_idle_timeout = b.addExecutable(.{
        .name = "quicz-idle-timeout",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/idle_timeout.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_idle_timeout);

    // Packet-number-space executable
    const exe_packet_spaces = b.addExecutable(.{
        .name = "quicz-packet-spaces",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/packet_spaces.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_packet_spaces);

    // ECN validation executable
    const exe_ecn_validation = b.addExecutable(.{
        .name = "quicz-ecn-validation",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/ecn_validation.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_ecn_validation);

    // Loss recovery executable
    const exe_loss_recovery = b.addExecutable(.{
        .name = "quicz-loss-recovery",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/loss_recovery.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_loss_recovery);

    // PTO recovery executable
    const exe_pto_recovery = b.addExecutable(.{
        .name = "quicz-pto-recovery",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/pto_recovery.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_pto_recovery);

    // Endpoint recovery timer executable
    const exe_endpoint_recovery_timers = b.addExecutable(.{
        .name = "quicz-endpoint-recovery-timers",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/endpoint_recovery_timers.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_endpoint_recovery_timers);

    // Path validation executable
    const exe_path_validation = b.addExecutable(.{
        .name = "quicz-path-validation",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/path_validation.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_path_validation);

    // Address validation executable
    const exe_address_validation = b.addExecutable(.{
        .name = "quicz-address-validation",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/address_validation.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_address_validation);

    // UDP address validation loopback executable
    const exe_udp_address_validation_loopback = b.addExecutable(.{
        .name = "quicz-udp-address-validation-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_address_validation_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_address_validation_loopback);

    // Retry token executable
    const exe_retry_token = b.addExecutable(.{
        .name = "quicz-retry-token",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/retry_token.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_retry_token);

    // Connection ID executable
    const exe_connection_ids = b.addExecutable(.{
        .name = "quicz-connection-ids",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/connection_ids.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_connection_ids);

    // Stateless reset executable
    const exe_stateless_reset = b.addExecutable(.{
        .name = "quicz-stateless-reset",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/stateless_reset.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_stateless_reset);

    // Initial keys executable
    const exe_initial_keys = b.addExecutable(.{
        .name = "quicz-initial-keys",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/initial_keys.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_initial_keys);

    // Endpoint routing executable
    const exe_endpoint_routing = b.addExecutable(.{
        .name = "quicz-endpoint-routing",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/endpoint_routing.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_endpoint_routing);

    // UDP endpoint loopback executable
    const exe_udp_endpoint_loopback = b.addExecutable(.{
        .name = "quicz-udp-endpoint-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_endpoint_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_endpoint_loopback);

    // UDP zero-length CID loopback executable
    const exe_udp_zero_cid_loopback = b.addExecutable(.{
        .name = "quicz-udp-zero-cid-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_zero_cid_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_zero_cid_loopback);

    // UDP preferred-address loopback executable
    const exe_udp_preferred_address_loopback = b.addExecutable(.{
        .name = "quicz-udp-preferred-address-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_preferred_address_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_preferred_address_loopback);

    // UDP replacement CID loopback executable
    const exe_udp_replacement_cid_loopback = b.addExecutable(.{
        .name = "quicz-udp-replacement-cid-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_replacement_cid_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_replacement_cid_loopback);

    // UDP connection ID loopback executable
    const exe_udp_connection_ids_loopback = b.addExecutable(.{
        .name = "quicz-udp-connection-ids-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_connection_ids_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_connection_ids_loopback);

    // UDP flow-control loopback executable
    const exe_udp_flow_control_loopback = b.addExecutable(.{
        .name = "quicz-udp-flow-control-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_flow_control_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_flow_control_loopback);

    // UDP spin-bit loopback executable
    const exe_udp_spin_bit_loopback = b.addExecutable(.{
        .name = "quicz-udp-spin-bit-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_spin_bit_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_spin_bit_loopback);

    // UDP ECN validation loopback executable
    const exe_udp_ecn_validation_loopback = b.addExecutable(.{
        .name = "quicz-udp-ecn-validation-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_ecn_validation_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_ecn_validation_loopback);

    // UDP PTO recovery loopback executable
    const exe_udp_pto_recovery_loopback = b.addExecutable(.{
        .name = "quicz-udp-pto-recovery-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_pto_recovery_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_pto_recovery_loopback);

    // UDP loss recovery loopback executable
    const exe_udp_loss_recovery_loopback = b.addExecutable(.{
        .name = "quicz-udp-loss-recovery-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_loss_recovery_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_loss_recovery_loopback);

    // UDP STREAM retransmission loopback executable
    const exe_udp_stream_retransmission_loopback = b.addExecutable(.{
        .name = "quicz-udp-stream-retransmission-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_stream_retransmission_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_stream_retransmission_loopback);

    // UDP congestion recovery loopback executable
    const exe_udp_congestion_recovery_loopback = b.addExecutable(.{
        .name = "quicz-udp-congestion-recovery-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_congestion_recovery_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_congestion_recovery_loopback);

    // UDP protected loopback executable
    const exe_udp_protected_loopback = b.addExecutable(.{
        .name = "quicz-udp-protected-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_protected_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_protected_loopback);

    // UDP Handshake keys loopback executable
    const exe_udp_handshake_keys_loopback = b.addExecutable(.{
        .name = "quicz-udp-handshake-keys-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_handshake_keys_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_handshake_keys_loopback);

    // UDP CryptoBackend CRYPTO stream loopback executable
    const exe_udp_crypto_stream_loopback = b.addExecutable(.{
        .name = "quicz-udp-crypto-stream-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_crypto_stream_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_crypto_stream_loopback);

    // UDP 0-RTT loopback executable
    const exe_udp_zero_rtt_loopback = b.addExecutable(.{
        .name = "quicz-udp-zero-rtt-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_zero_rtt_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_zero_rtt_loopback);

    // UDP 1-RTT loopback executable
    const exe_udp_one_rtt_loopback = b.addExecutable(.{
        .name = "quicz-udp-one-rtt-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_one_rtt_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_one_rtt_loopback);

    // UDP echo loopback executable
    const exe_udp_echo_loopback = b.addExecutable(.{
        .name = "quicz-udp-echo-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_echo_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_echo_loopback);

    // UDP CryptoBackend loopback executable
    const exe_udp_crypto_backend_loopback = b.addExecutable(.{
        .name = "quicz-udp-crypto-backend-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_crypto_backend_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_crypto_backend_loopback);

    // UDP HANDSHAKE_DONE loopback executable
    const exe_udp_handshake_done_loopback = b.addExecutable(.{
        .name = "quicz-udp-handshake-done-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_handshake_done_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_handshake_done_loopback);

    // UDP key update loopback executable
    const exe_udp_key_update_loopback = b.addExecutable(.{
        .name = "quicz-udp-key-update-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_key_update_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_key_update_loopback);

    // UDP path validation loopback executable
    const exe_udp_path_validation_loopback = b.addExecutable(.{
        .name = "quicz-udp-path-validation-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_path_validation_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_path_validation_loopback);

    // UDP Retry loopback executable
    const exe_udp_retry_loopback = b.addExecutable(.{
        .name = "quicz-udp-retry-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_retry_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_retry_loopback);

    // UDP close lifecycle loopback executable
    const exe_udp_close_lifecycle_loopback = b.addExecutable(.{
        .name = "quicz-udp-close-lifecycle-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_close_lifecycle_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_close_lifecycle_loopback);

    // UDP stateless reset loopback executable
    const exe_udp_stateless_reset_loopback = b.addExecutable(.{
        .name = "quicz-udp-stateless-reset-loopback",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/udp_stateless_reset_loopback.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
            },
        }),
    });
    b.installArtifact(exe_udp_stateless_reset_loopback);

    // zig build run-server
    const run_server = b.step("run-server", "Run quicz echo server");
    const run_server_cmd = b.addRunArtifact(exe_server);
    run_server.dependOn(&run_server_cmd.step);
    run_server_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_server_cmd.addArgs(args);
    }

    // zig build run-client
    const run_client = b.step("run-client", "Run quicz echo client");
    const run_client_cmd = b.addRunArtifact(exe_client);
    run_client.dependOn(&run_client_cmd.step);
    run_client_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_client_cmd.addArgs(args);
    }

    const run_tls13_process_interop = b.step(
        "run-tls13-process-interop",
        "Run separate pure-Zig QUIC client and server over local UDP",
    );
    const run_tls13_process_interop_cmd = b.addSystemCommand(&.{ "sh", "scripts/run_tls13_process_interop.sh" });
    run_tls13_process_interop.dependOn(&run_tls13_process_interop_cmd.step);
    run_tls13_process_interop_cmd.step.dependOn(b.getInstallStep());

    const run_interop_external_client = b.step(
        "run-interop-external-client",
        "Run certificate-verified QUIC echo against an external server",
    );
    const run_interop_external_client_cmd = b.addRunArtifact(exe_interop_external_client);
    run_interop_external_client.dependOn(&run_interop_external_client_cmd.step);
    run_interop_external_client_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_interop_external_client_cmd.addArgs(args);
    }

    // zig build run-interop-client-standalone (no OpenSSL dependency)
    const run_interop_client_standalone = b.step(
        "run-interop-client-standalone",
        "Run QUIC interop client self-test (standalone)",
    );
    const run_interop_client_standalone_cmd = b.addRunArtifact(exe_interop_client);
    run_interop_client_standalone.dependOn(&run_interop_client_standalone_cmd.step);
    if (b.args) |args| {
        run_interop_client_standalone_cmd.addArgs(args);
    }

    // zig build run-interop-external (standalone, no OpenSSL dependency)
    const run_interop_standalone = b.step(
        "run-interop-external",
        "Run certificate-verified QUIC echo against an external server (standalone)",
    );
    const run_interop_standalone_cmd = b.addRunArtifact(exe_interop_external_client);
    run_interop_standalone.dependOn(&run_interop_standalone_cmd.step);
    if (b.args) |args| {
        run_interop_standalone_cmd.addArgs(args);
    }

    // zig build run-codec
    const run_codec = b.step("run-codec", "Run quicz codec roundtrip example");
    const run_codec_cmd = b.addRunArtifact(exe_codec);
    run_codec.dependOn(&run_codec_cmd.step);
    run_codec_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_codec_cmd.addArgs(args);
    }

    // zig build run-transport-parameters
    const run_transport_parameters = b.step("run-transport-parameters", "Run quicz transport parameters example");
    const run_transport_parameters_cmd = b.addRunArtifact(exe_transport_parameters);
    run_transport_parameters.dependOn(&run_transport_parameters_cmd.step);
    run_transport_parameters_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_transport_parameters_cmd.addArgs(args);
    }

    // zig build run-flow-control
    const run_flow_control = b.step("run-flow-control", "Run quicz flow-control example");
    const run_flow_control_cmd = b.addRunArtifact(exe_flow_control);
    run_flow_control.dependOn(&run_flow_control_cmd.step);
    run_flow_control_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_flow_control_cmd.addArgs(args);
    }

    // zig build run-uni-stream
    const run_uni_stream = b.step("run-uni-stream", "Run quicz unidirectional stream example");
    const run_uni_stream_cmd = b.addRunArtifact(exe_uni_stream);
    run_uni_stream.dependOn(&run_uni_stream_cmd.step);
    run_uni_stream_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_uni_stream_cmd.addArgs(args);
    }

    // zig build run-stream-reset
    const run_stream_reset = b.step("run-stream-reset", "Run quicz stream reset example");
    const run_stream_reset_cmd = b.addRunArtifact(exe_stream_reset);
    run_stream_reset.dependOn(&run_stream_reset_cmd.step);
    run_stream_reset_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_stream_reset_cmd.addArgs(args);
    }

    // zig build run-stop-sending
    const run_stop_sending = b.step("run-stop-sending", "Run quicz STOP_SENDING example");
    const run_stop_sending_cmd = b.addRunArtifact(exe_stop_sending);
    run_stop_sending.dependOn(&run_stop_sending_cmd.step);
    run_stop_sending_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_stop_sending_cmd.addArgs(args);
    }

    // zig build run-crypto-stream
    const run_crypto_stream = b.step("run-crypto-stream", "Run quicz crypto stream example");
    const run_crypto_stream_cmd = b.addRunArtifact(exe_crypto_stream);
    run_crypto_stream.dependOn(&run_crypto_stream_cmd.step);
    run_crypto_stream_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_crypto_stream_cmd.addArgs(args);
    }

    // zig build run-tls-backend-adapter
    const run_tls_backend_adapter = b.step("run-tls-backend-adapter", "Run quicz TLS backend adapter example");
    const run_tls_backend_adapter_cmd = b.addRunArtifact(exe_tls_backend_adapter);
    run_tls_backend_adapter.dependOn(&run_tls_backend_adapter_cmd.step);
    run_tls_backend_adapter_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_tls_backend_adapter_cmd.addArgs(args);
    }

    // zig build run-tls-c-abi-adapter
    const run_tls_c_abi_adapter = b.step("run-tls-c-abi-adapter", "Run quicz TLS C ABI adapter example");
    const run_tls_c_abi_adapter_cmd = b.addRunArtifact(exe_tls_c_abi_adapter);
    run_tls_c_abi_adapter.dependOn(&run_tls_c_abi_adapter_cmd.step);
    run_tls_c_abi_adapter_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_tls_c_abi_adapter_cmd.addArgs(args);
    }

    // zig build run-tls-openssl-probe
    const run_tls_openssl_probe = b.step("run-tls-openssl-probe", "Run quicz OpenSSL QUIC TLS API probe");
    const run_tls_openssl_probe_cmd = b.addRunArtifact(exe_tls_openssl_probe);
    run_tls_openssl_probe.dependOn(&run_tls_openssl_probe_cmd.step);
    run_tls_openssl_probe_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_tls_openssl_probe_cmd.addArgs(args);
    }

    // zig build run-tls-openssl-backend-adapter
    const run_tls_openssl_backend_adapter = b.step("run-tls-openssl-backend-adapter", "Run quicz OpenSSL-backed TLS backend adapter example");
    const run_tls_openssl_backend_adapter_cmd = b.addRunArtifact(exe_tls_openssl_backend_adapter);
    run_tls_openssl_backend_adapter.dependOn(&run_tls_openssl_backend_adapter_cmd.step);
    run_tls_openssl_backend_adapter_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_tls_openssl_backend_adapter_cmd.addArgs(args);
    }

    // zig build run-tls-openssl-pair-transcript
    const run_tls_openssl_pair_transcript = b.step("run-tls-openssl-pair-transcript", "Run quicz OpenSSL client/server TLS transcript example");
    const run_tls_openssl_pair_transcript_cmd = b.addRunArtifact(exe_tls_openssl_pair_transcript);
    run_tls_openssl_pair_transcript.dependOn(&run_tls_openssl_pair_transcript_cmd.step);
    run_tls_openssl_pair_transcript_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_tls_openssl_pair_transcript_cmd.addArgs(args);
    }

    // zig build run-graceful-close
    const run_graceful_close = b.step("run-graceful-close", "Run quicz graceful close example");
    const run_graceful_close_cmd = b.addRunArtifact(exe_graceful_close);
    run_graceful_close.dependOn(&run_graceful_close_cmd.step);
    run_graceful_close_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_graceful_close_cmd.addArgs(args);
    }

    // zig build run-idle-timeout
    const run_idle_timeout = b.step("run-idle-timeout", "Run quicz idle timeout example");
    const run_idle_timeout_cmd = b.addRunArtifact(exe_idle_timeout);
    run_idle_timeout.dependOn(&run_idle_timeout_cmd.step);
    run_idle_timeout_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_idle_timeout_cmd.addArgs(args);
    }

    // zig build run-packet-spaces
    const run_packet_spaces = b.step("run-packet-spaces", "Run quicz packet-number-space example");
    const run_packet_spaces_cmd = b.addRunArtifact(exe_packet_spaces);
    run_packet_spaces.dependOn(&run_packet_spaces_cmd.step);
    run_packet_spaces_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_packet_spaces_cmd.addArgs(args);
    }

    // zig build run-ecn-validation
    const run_ecn_validation = b.step("run-ecn-validation", "Run quicz ECN validation example");
    const run_ecn_validation_cmd = b.addRunArtifact(exe_ecn_validation);
    run_ecn_validation.dependOn(&run_ecn_validation_cmd.step);
    run_ecn_validation_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_ecn_validation_cmd.addArgs(args);
    }

    // zig build run-loss-recovery
    const run_loss_recovery = b.step("run-loss-recovery", "Run quicz loss recovery example");
    const run_loss_recovery_cmd = b.addRunArtifact(exe_loss_recovery);
    run_loss_recovery.dependOn(&run_loss_recovery_cmd.step);
    run_loss_recovery_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_loss_recovery_cmd.addArgs(args);
    }

    // zig build run-pto-recovery
    const run_pto_recovery = b.step("run-pto-recovery", "Run quicz PTO recovery example");
    const run_pto_recovery_cmd = b.addRunArtifact(exe_pto_recovery);
    run_pto_recovery.dependOn(&run_pto_recovery_cmd.step);
    run_pto_recovery_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_pto_recovery_cmd.addArgs(args);
    }

    // zig build run-endpoint-recovery-timers
    const run_endpoint_recovery_timers = b.step("run-endpoint-recovery-timers", "Run quicz endpoint recovery timer example");
    const run_endpoint_recovery_timers_cmd = b.addRunArtifact(exe_endpoint_recovery_timers);
    run_endpoint_recovery_timers.dependOn(&run_endpoint_recovery_timers_cmd.step);
    run_endpoint_recovery_timers_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_endpoint_recovery_timers_cmd.addArgs(args);
    }

    // zig build run-path-validation
    const run_path_validation = b.step("run-path-validation", "Run quicz path validation example");
    const run_path_validation_cmd = b.addRunArtifact(exe_path_validation);
    run_path_validation.dependOn(&run_path_validation_cmd.step);
    run_path_validation_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_path_validation_cmd.addArgs(args);
    }

    // zig build run-address-validation
    const run_address_validation = b.step("run-address-validation", "Run quicz address validation example");
    const run_address_validation_cmd = b.addRunArtifact(exe_address_validation);
    run_address_validation.dependOn(&run_address_validation_cmd.step);
    run_address_validation_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_address_validation_cmd.addArgs(args);
    }

    // zig build run-udp-address-validation-loopback
    const run_udp_address_validation_loopback = b.step("run-udp-address-validation-loopback", "Run quicz UDP address validation loopback example");
    const run_udp_address_validation_loopback_cmd = b.addRunArtifact(exe_udp_address_validation_loopback);
    run_udp_address_validation_loopback.dependOn(&run_udp_address_validation_loopback_cmd.step);
    run_udp_address_validation_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_address_validation_loopback_cmd.addArgs(args);
    }

    // zig build run-retry-token
    const run_retry_token = b.step("run-retry-token", "Run quicz Retry token example");
    const run_retry_token_cmd = b.addRunArtifact(exe_retry_token);
    run_retry_token.dependOn(&run_retry_token_cmd.step);
    run_retry_token_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_retry_token_cmd.addArgs(args);
    }

    // zig build run-connection-ids
    const run_connection_ids = b.step("run-connection-ids", "Run quicz connection ID example");
    const run_connection_ids_cmd = b.addRunArtifact(exe_connection_ids);
    run_connection_ids.dependOn(&run_connection_ids_cmd.step);
    run_connection_ids_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_connection_ids_cmd.addArgs(args);
    }

    // zig build run-stateless-reset
    const run_stateless_reset = b.step("run-stateless-reset", "Run quicz stateless reset example");
    const run_stateless_reset_cmd = b.addRunArtifact(exe_stateless_reset);
    run_stateless_reset.dependOn(&run_stateless_reset_cmd.step);
    run_stateless_reset_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_stateless_reset_cmd.addArgs(args);
    }

    // zig build run-initial-keys
    const run_initial_keys = b.step("run-initial-keys", "Run quicz Initial key derivation example");
    const run_initial_keys_cmd = b.addRunArtifact(exe_initial_keys);
    run_initial_keys.dependOn(&run_initial_keys_cmd.step);
    run_initial_keys_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_initial_keys_cmd.addArgs(args);
    }

    // zig build run-endpoint-routing
    const run_endpoint_routing = b.step("run-endpoint-routing", "Run quicz endpoint routing example");
    const run_endpoint_routing_cmd = b.addRunArtifact(exe_endpoint_routing);
    run_endpoint_routing.dependOn(&run_endpoint_routing_cmd.step);
    run_endpoint_routing_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_endpoint_routing_cmd.addArgs(args);
    }

    // zig build run-udp-endpoint-loopback
    const run_udp_endpoint_loopback = b.step("run-udp-endpoint-loopback", "Run quicz UDP endpoint loopback example");
    const run_udp_endpoint_loopback_cmd = b.addRunArtifact(exe_udp_endpoint_loopback);
    run_udp_endpoint_loopback.dependOn(&run_udp_endpoint_loopback_cmd.step);
    run_udp_endpoint_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_endpoint_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-zero-cid-loopback
    const run_udp_zero_cid_loopback = b.step("run-udp-zero-cid-loopback", "Run quicz UDP zero-length CID loopback example");
    const run_udp_zero_cid_loopback_cmd = b.addRunArtifact(exe_udp_zero_cid_loopback);
    run_udp_zero_cid_loopback.dependOn(&run_udp_zero_cid_loopback_cmd.step);
    run_udp_zero_cid_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_zero_cid_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-preferred-address-loopback
    const run_udp_preferred_address_loopback = b.step("run-udp-preferred-address-loopback", "Run quicz UDP preferred-address loopback example");
    const run_udp_preferred_address_loopback_cmd = b.addRunArtifact(exe_udp_preferred_address_loopback);
    run_udp_preferred_address_loopback.dependOn(&run_udp_preferred_address_loopback_cmd.step);
    run_udp_preferred_address_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_preferred_address_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-replacement-cid-loopback
    const run_udp_replacement_cid_loopback = b.step("run-udp-replacement-cid-loopback", "Run quicz UDP replacement CID loopback example");
    const run_udp_replacement_cid_loopback_cmd = b.addRunArtifact(exe_udp_replacement_cid_loopback);
    run_udp_replacement_cid_loopback.dependOn(&run_udp_replacement_cid_loopback_cmd.step);
    run_udp_replacement_cid_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_replacement_cid_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-connection-ids-loopback
    const run_udp_connection_ids_loopback = b.step("run-udp-connection-ids-loopback", "Run quicz UDP connection ID loopback example");
    const run_udp_connection_ids_loopback_cmd = b.addRunArtifact(exe_udp_connection_ids_loopback);
    run_udp_connection_ids_loopback.dependOn(&run_udp_connection_ids_loopback_cmd.step);
    run_udp_connection_ids_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_connection_ids_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-flow-control-loopback
    const run_udp_flow_control_loopback = b.step("run-udp-flow-control-loopback", "Run quicz UDP flow-control loopback example");
    const run_udp_flow_control_loopback_cmd = b.addRunArtifact(exe_udp_flow_control_loopback);
    run_udp_flow_control_loopback.dependOn(&run_udp_flow_control_loopback_cmd.step);
    run_udp_flow_control_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_flow_control_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-spin-bit-loopback
    const run_udp_spin_bit_loopback = b.step("run-udp-spin-bit-loopback", "Run quicz UDP spin-bit loopback example");
    const run_udp_spin_bit_loopback_cmd = b.addRunArtifact(exe_udp_spin_bit_loopback);
    run_udp_spin_bit_loopback.dependOn(&run_udp_spin_bit_loopback_cmd.step);
    run_udp_spin_bit_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_spin_bit_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-ecn-validation-loopback
    const run_udp_ecn_validation_loopback = b.step("run-udp-ecn-validation-loopback", "Run quicz UDP ECN validation loopback example");
    const run_udp_ecn_validation_loopback_cmd = b.addRunArtifact(exe_udp_ecn_validation_loopback);
    run_udp_ecn_validation_loopback.dependOn(&run_udp_ecn_validation_loopback_cmd.step);
    run_udp_ecn_validation_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_ecn_validation_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-pto-recovery-loopback
    const run_udp_pto_recovery_loopback = b.step("run-udp-pto-recovery-loopback", "Run quicz UDP PTO recovery loopback example");
    const run_udp_pto_recovery_loopback_cmd = b.addRunArtifact(exe_udp_pto_recovery_loopback);
    run_udp_pto_recovery_loopback.dependOn(&run_udp_pto_recovery_loopback_cmd.step);
    run_udp_pto_recovery_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_pto_recovery_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-loss-recovery-loopback
    const run_udp_loss_recovery_loopback = b.step("run-udp-loss-recovery-loopback", "Run quicz UDP loss recovery loopback example");
    const run_udp_loss_recovery_loopback_cmd = b.addRunArtifact(exe_udp_loss_recovery_loopback);
    run_udp_loss_recovery_loopback.dependOn(&run_udp_loss_recovery_loopback_cmd.step);
    run_udp_loss_recovery_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_loss_recovery_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-stream-retransmission-loopback
    const run_udp_stream_retransmission_loopback = b.step("run-udp-stream-retransmission-loopback", "Run quicz UDP STREAM retransmission loopback example");
    const run_udp_stream_retransmission_loopback_cmd = b.addRunArtifact(exe_udp_stream_retransmission_loopback);
    run_udp_stream_retransmission_loopback.dependOn(&run_udp_stream_retransmission_loopback_cmd.step);
    run_udp_stream_retransmission_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_stream_retransmission_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-congestion-recovery-loopback
    const run_udp_congestion_recovery_loopback = b.step("run-udp-congestion-recovery-loopback", "Run quicz UDP congestion recovery loopback example");
    const run_udp_congestion_recovery_loopback_cmd = b.addRunArtifact(exe_udp_congestion_recovery_loopback);
    run_udp_congestion_recovery_loopback.dependOn(&run_udp_congestion_recovery_loopback_cmd.step);
    run_udp_congestion_recovery_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_congestion_recovery_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-protected-loopback
    const run_udp_protected_loopback = b.step("run-udp-protected-loopback", "Run quicz UDP protected-packet loopback example");
    const run_udp_protected_loopback_cmd = b.addRunArtifact(exe_udp_protected_loopback);
    run_udp_protected_loopback.dependOn(&run_udp_protected_loopback_cmd.step);
    run_udp_protected_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_protected_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-handshake-keys-loopback
    const run_udp_handshake_keys_loopback = b.step("run-udp-handshake-keys-loopback", "Run quicz UDP Handshake keys loopback example");
    const run_udp_handshake_keys_loopback_cmd = b.addRunArtifact(exe_udp_handshake_keys_loopback);
    run_udp_handshake_keys_loopback.dependOn(&run_udp_handshake_keys_loopback_cmd.step);
    run_udp_handshake_keys_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_handshake_keys_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-crypto-stream-loopback
    const run_udp_crypto_stream_loopback = b.step("run-udp-crypto-stream-loopback", "Run quicz UDP CryptoBackend CRYPTO stream loopback example");
    const run_udp_crypto_stream_loopback_cmd = b.addRunArtifact(exe_udp_crypto_stream_loopback);
    run_udp_crypto_stream_loopback.dependOn(&run_udp_crypto_stream_loopback_cmd.step);
    run_udp_crypto_stream_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_crypto_stream_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-zero-rtt-loopback
    const run_udp_zero_rtt_loopback = b.step("run-udp-zero-rtt-loopback", "Run quicz UDP 0-RTT loopback example");
    const run_udp_zero_rtt_loopback_cmd = b.addRunArtifact(exe_udp_zero_rtt_loopback);
    run_udp_zero_rtt_loopback.dependOn(&run_udp_zero_rtt_loopback_cmd.step);
    run_udp_zero_rtt_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_zero_rtt_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-one-rtt-loopback
    const run_udp_one_rtt_loopback = b.step("run-udp-one-rtt-loopback", "Run quicz UDP 1-RTT loopback example");
    const run_udp_one_rtt_loopback_cmd = b.addRunArtifact(exe_udp_one_rtt_loopback);
    run_udp_one_rtt_loopback.dependOn(&run_udp_one_rtt_loopback_cmd.step);
    run_udp_one_rtt_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_one_rtt_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-echo-loopback
    const run_udp_echo_loopback = b.step("run-udp-echo-loopback", "Run quicz UDP echo loopback example");
    const run_udp_echo_loopback_cmd = b.addRunArtifact(exe_udp_echo_loopback);
    run_udp_echo_loopback.dependOn(&run_udp_echo_loopback_cmd.step);
    run_udp_echo_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_echo_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-crypto-backend-loopback
    const run_udp_crypto_backend_loopback = b.step("run-udp-crypto-backend-loopback", "Run quicz UDP CryptoBackend loopback example");
    const run_udp_crypto_backend_loopback_cmd = b.addRunArtifact(exe_udp_crypto_backend_loopback);
    run_udp_crypto_backend_loopback.dependOn(&run_udp_crypto_backend_loopback_cmd.step);
    run_udp_crypto_backend_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_crypto_backend_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-handshake-done-loopback
    const run_udp_handshake_done_loopback = b.step("run-udp-handshake-done-loopback", "Run quicz UDP HANDSHAKE_DONE loopback example");
    const run_udp_handshake_done_loopback_cmd = b.addRunArtifact(exe_udp_handshake_done_loopback);
    run_udp_handshake_done_loopback.dependOn(&run_udp_handshake_done_loopback_cmd.step);
    run_udp_handshake_done_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_handshake_done_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-key-update-loopback
    const run_udp_key_update_loopback = b.step("run-udp-key-update-loopback", "Run quicz UDP key update loopback example");
    const run_udp_key_update_loopback_cmd = b.addRunArtifact(exe_udp_key_update_loopback);
    run_udp_key_update_loopback.dependOn(&run_udp_key_update_loopback_cmd.step);
    run_udp_key_update_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_key_update_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-path-validation-loopback
    const run_udp_path_validation_loopback = b.step("run-udp-path-validation-loopback", "Run quicz UDP path validation loopback example");
    const run_udp_path_validation_loopback_cmd = b.addRunArtifact(exe_udp_path_validation_loopback);
    run_udp_path_validation_loopback.dependOn(&run_udp_path_validation_loopback_cmd.step);
    run_udp_path_validation_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_path_validation_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-retry-loopback
    const run_udp_retry_loopback = b.step("run-udp-retry-loopback", "Run quicz UDP Retry loopback example");
    const run_udp_retry_loopback_cmd = b.addRunArtifact(exe_udp_retry_loopback);
    run_udp_retry_loopback.dependOn(&run_udp_retry_loopback_cmd.step);
    run_udp_retry_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_retry_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-close-lifecycle-loopback
    const run_udp_close_lifecycle_loopback = b.step("run-udp-close-lifecycle-loopback", "Run quicz UDP close lifecycle loopback example");
    const run_udp_close_lifecycle_loopback_cmd = b.addRunArtifact(exe_udp_close_lifecycle_loopback);
    run_udp_close_lifecycle_loopback.dependOn(&run_udp_close_lifecycle_loopback_cmd.step);
    run_udp_close_lifecycle_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_close_lifecycle_loopback_cmd.addArgs(args);
    }

    // zig build run-udp-stateless-reset-loopback
    const run_udp_stateless_reset_loopback = b.step("run-udp-stateless-reset-loopback", "Run quicz UDP stateless reset loopback example");
    const run_udp_stateless_reset_loopback_cmd = b.addRunArtifact(exe_udp_stateless_reset_loopback);
    run_udp_stateless_reset_loopback.dependOn(&run_udp_stateless_reset_loopback_cmd.step);
    run_udp_stateless_reset_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_udp_stateless_reset_loopback_cmd.addArgs(args);
    }

    const lib_tests = b.addTest(.{
        .name = "quicz-tests",
        .root_module = quicz_mod,
    });
    const run_lib_tests = b.addRunArtifact(lib_tests);
    const mobile_abi_tests = b.addTest(.{
        .name = "quicz-mobile-abi-tests",
        .root_module = mobile_abi_mod,
    });
    const run_mobile_abi_tests = b.addRunArtifact(mobile_abi_tests);
    b.step("test-mobile-abi", "Run the public mobile C ABI tests").dependOn(&run_mobile_abi_tests.step);
    const runtime_keepalive_tests = b.addTest(.{
        .name = "quicz-runtime-keepalive-tests",
        .root_module = b.createModule(.{
            .root_source_file = b.path("examples/runtime_keepalive_test.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "quicz", .module = quicz_mod },
                .{ .name = "quicz-test-cert", .module = quicz_test_cert_mod },
            },
        }),
    });
    const run_runtime_keepalive_tests = b.addRunArtifact(runtime_keepalive_tests);

    // zig build run-tls13-backend-loopback
    const run_tls13_backend_loopback = b.step("run-tls13-backend-loopback", "Run pure-Zig TLS 1.3 in-memory loopback");
    const run_tls13_backend_loopback_cmd = b.addRunArtifact(exe_tls13_backend_loopback);
    run_tls13_backend_loopback.dependOn(&run_tls13_backend_loopback_cmd.step);
    run_tls13_backend_loopback_cmd.step.dependOn(b.getInstallStep());

    // zig build run-tls13-udp-loopback
    const run_tls13_udp_loopback = b.step("run-tls13-udp-loopback", "Run pure-Zig TLS 1.3 UDP loopback");
    const run_tls13_udp_loopback_cmd = b.addRunArtifact(exe_tls13_udp_loopback);
    run_tls13_udp_loopback.dependOn(&run_tls13_udp_loopback_cmd.step);
    run_tls13_udp_loopback_cmd.step.dependOn(b.getInstallStep());

    // zig build run-h3-loopback
    const run_h3_loopback = b.step("run-h3-loopback", "Run HTTP/3 + QPACK dynamic table over UDP loopback");
    const run_h3_loopback_cmd = b.addRunArtifact(exe_h3_loopback);
    run_h3_loopback.dependOn(&run_h3_loopback_cmd.step);
    run_h3_loopback_cmd.step.dependOn(b.getInstallStep());

    // zig build run-h3-runtime-loopback
    const run_h3_runtime_loopback = b.step("run-h3-runtime-loopback", "Run HTTP/3 + QPACK on the production std.Io runtime");
    const run_h3_runtime_loopback_cmd = b.addRunArtifact(exe_h3_runtime_loopback);
    run_h3_runtime_loopback.dependOn(&run_h3_runtime_loopback_cmd.step);

    // zig build run-h3-external-client (needs a go quic-go http3.Server on
    // 127.0.0.1:4439, see examples/interop/http3_server/main.go)
    const run_h3_external_client = b.step("run-h3-external-client", "Run HTTP/3 client against an external go quic-go http3.Server");
    const run_h3_external_client_cmd = b.addRunArtifact(exe_h3_external_client);
    run_h3_external_client.dependOn(&run_h3_external_client_cmd.step);

    // zig build run-tls13-lifecycle-loopback
    const run_tls13_lifecycle_loopback = b.step("run-tls13-lifecycle-loopback", "Run pure-Zig TLS 1.3 lifecycle loopback");
    const run_tls13_lifecycle_loopback_cmd = b.addRunArtifact(exe_tls13_lifecycle_loopback);
    run_tls13_lifecycle_loopback.dependOn(&run_tls13_lifecycle_loopback_cmd.step);
    run_tls13_lifecycle_loopback_cmd.step.dependOn(b.getInstallStep());

    // zig build run-tls13-stateless-reset-loopback
    const run_tls13_stateless_reset_loopback = b.step("run-tls13-stateless-reset-loopback", "Run pure-Zig TLS 1.3 stateless reset UDP loopback");
    const run_tls13_stateless_reset_loopback_cmd = b.addRunArtifact(exe_tls13_stateless_reset_loopback);
    run_tls13_stateless_reset_loopback.dependOn(&run_tls13_stateless_reset_loopback_cmd.step);
    run_tls13_stateless_reset_loopback_cmd.step.dependOn(b.getInstallStep());

    // zig build run-tls13-path-validation-loopback
    const run_tls13_path_validation_loopback = b.step("run-tls13-path-validation-loopback", "Run pure-Zig TLS 1.3 path validation UDP loopback");
    const run_tls13_path_validation_loopback_cmd = b.addRunArtifact(exe_tls13_path_validation_loopback);
    run_tls13_path_validation_loopback.dependOn(&run_tls13_path_validation_loopback_cmd.step);
    run_tls13_path_validation_loopback_cmd.step.dependOn(b.getInstallStep());

    // zig build run-tls13-retry-loopback
    const run_tls13_retry_loopback = b.step("run-tls13-retry-loopback", "Run pure-Zig TLS 1.3 Retry UDP loopback");
    const run_tls13_retry_loopback_cmd = b.addRunArtifact(exe_tls13_retry_loopback);
    run_tls13_retry_loopback.dependOn(&run_tls13_retry_loopback_cmd.step);
    run_tls13_retry_loopback_cmd.step.dependOn(b.getInstallStep());

    // zig build run-interop-client -- <server_host> <server_port> [TESTCASE]
    const run_interop_client = b.step("run-interop-client", "Run QUIC interop client (TESTCASE/SSLKEYLOGFILE env, local loopback self-test)");
    const run_interop_client_cmd = b.addRunArtifact(exe_interop_client);
    run_interop_client.dependOn(&run_interop_client_cmd.step);
    run_interop_client_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_interop_client_cmd.addArgs(args);
    }

    // zig build run-interop-event-loopback -- [TESTCASE]
    const run_interop_event_loopback = b.step("run-interop-event-loopback", "Run event-driven interop loopback (TESTCASE: handshake/transfer/loss/congestion/persistent/key-update/path/stream-control/stream-limit)");
    const run_interop_event_loopback_cmd = b.addRunArtifact(exe_interop_event_loopback);
    run_interop_event_loopback.dependOn(&run_interop_event_loopback_cmd.step);
    run_interop_event_loopback_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_interop_event_loopback_cmd.addArgs(args);
    }

    const test_step = b.step("test", "Run quicz unit tests");
    const runtime_metrics_tests = b.addTest(.{ .root_module = quicz_mod, .filters = &.{
        "metrics snapshot",           "connection drain",                   "idle retirement",
        "runtime verifies localhost", "listeners share pending and active", "IPv6 reader cancellation",
        "legacy runtime fields",
    } });
    b.step("test-runtime-metrics", "Verify metrics across runtime connection retirement")
        .dependOn(&b.addRunArtifact(runtime_metrics_tests).step);
    const peer_punch_tests = b.addTest(.{ .root_module = quicz_mod, .filters = &.{"peer learning"} });
    b.step("test-peer-punch", "Verify authenticated IPv4 peer learning on loopback")
        .dependOn(&b.addRunArtifact(peer_punch_tests).step);
    test_step.dependOn(&run_lib_tests.step);
    test_step.dependOn(&run_mobile_abi_tests.step);
    test_step.dependOn(&run_runtime_keepalive_tests.step);
}