Skip to content
zit Artifact [36136eedc6]
Login

Artifact [36136eedc6]

Artifact 36136eedc6a840d69abc206f628a9b320d93c4c90b569418694673c4e52d0cfd:


const std = @import("std");
const repeat = @import("zit").repeat;
const container = @import("zit").container;
const sync = @import("zit").sync;
const zit = @import("zit");
const net = std.Io.net;
const support = @import("support.zig");
const XferHead = support.XferHead;
const addManaged = support.addManaged;
const artifactNameByContent = support.artifactNameByContent;
const checkinHash = support.checkinHash;
const collectArtifactDigests = support.collectArtifactDigests;
const commitHashDup = support.commitHashDup;
const dialServe = support.dialServe;
const doomed_body = support.doomed_body;
const erasureOk = support.erasureOk;
const erasureOrigin = support.erasureOrigin;
const erasure_seed_hex = support.erasure_seed_hex;
const expectContains = support.expectContains;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const expectNonzeroExit = support.expectNonzeroExit;
const expectSameDigestSet = support.expectSameDigestSet;
const fileExists = support.fileExists;
const freeDigests = support.freeDigests;
const freeResult = support.freeResult;
const freshLoopbackPort = support.freshLoopbackPort;
const initRepo = support.initRepo;
const kept_body = support.kept_body;
const postXferCards = support.postXferCards;
const postXferCardsHead = support.postXferCardsHead;
const postXferCardsHeaders = support.postXferCardsHeaders;
const readAutoRetune = support.readAutoRetune;
const readProjectCode = support.readProjectCode;
const readSubmanifestSettings = support.readSubmanifestSettings;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const shunFixture = support.shunFixture;
const spawnServe = support.spawnServe;
const spawnServeFlag = support.spawnServeFlag;
const spawnServeFlags = support.spawnServeFlags;
const spawnServeFronted = support.spawnServeFronted;
const storeHoldsArtifact = support.storeHoldsArtifact;
const tipHashOf = support.tipHashOf;
const waitForListen = support.waitForListen;
const writeFile = support.writeFile;

test "cli serve §9.3 r31: an unauthorized pushed config card is refused and changes nothing" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    // Repo A: enabled at k=3, auto-retune off — a settled configuration a
    // stranger is about to try to rewrite.
    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try writeFile(io, tmp_a.dir, "hello.txt", "served repository\n");
    try addManaged(gpa, io, tmp_a.dir, &.{"hello.txt"});
    var commit = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "seed" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    {
        var en = try runZit(gpa, io, tmp_a.dir, &.{ "submanifest", "enable", "--k", "3" });
        defer freeResult(gpa, &en);
        try expectExitDiag(en.term, 0, en);
    }

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);

    // §9.3 r30 — a well-formed scalar config push, from nobody: `zit serve`
    // holds no credential, so no requester can ever reach Admin.
    var cards_buf: [sync.submanifest_config_cards_max]u8 = undefined;
    const cards = try sync.writeSubmanifestConfigCards(false, 11, true, "", &cards_buf);
    const request = try std.fmt.allocPrint(gpa, "pragma client-version 20000\n{s}", .{cards});
    defer gpa.free(request);
    const reply = try postXferCards(gpa, io, port, request);
    defer gpa.free(reply);

    // §9.3 r31 L2023-2026 — the exact required text (§11.1 r2 fossilizes its
    // spaces on the wire), and nothing else in the reply: the rejection resets
    // the partial output.
    try std.testing.expectEqualStrings("error not\\sauthorized\\sto\\spush\\sconfiguration\n", reply);

    // THE PROOF: A's stored configuration is byte-for-byte what it was. A
    // server that applied the push would show k=11 and auto-retune on here.
    const a = try readSubmanifestSettings(gpa, io, tmp_a.dir);
    try std.testing.expect(a.enabled);
    try std.testing.expectEqual(@as(u8, 3), a.k);
    try std.testing.expect(!try readAutoRetune(gpa, io, tmp_a.dir));
}

test "cli serve §9.3: a peer that never asks for configuration still clones unchanged" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    // The interop case for a peer predating this feature: a request that
    // carries NO reqconfig must draw no config card and no error — the "group
    // mask zero" no-op extended to a peer that simply does not ask. Simulated
    // at the wire, because every zit clone now does ask.
    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try writeFile(io, tmp_a.dir, "hello.txt", "served repository\n");
    try addManaged(gpa, io, tmp_a.dir, &.{"hello.txt"});
    var commit = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "seed" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    {
        var en = try runZit(gpa, io, tmp_a.dir, &.{ "submanifest", "enable", "--k", "3" });
        defer freeResult(gpa, &en);
        try expectExitDiag(en.term, 0, en);
    }
    const a_digests = try collectArtifactDigests(gpa, io, tmp_a.dir);
    defer freeDigests(gpa, a_digests);

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);

    // §8.5 — the pull names the served project, as any peer of it would.
    const pcode = try readProjectCode(gpa, io, tmp_a.dir);
    defer gpa.free(pcode);
    const pull = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npull s {s}\n", .{pcode});
    defer gpa.free(pull);
    const silent = try postXferCards(gpa, io, port, pull);
    defer gpa.free(silent);
    try std.testing.expect(std.mem.indexOf(u8, silent, "config") == null);
    try std.testing.expect(std.mem.indexOf(u8, silent, "error") == null);

    // §9.3 r28 — `/shun` IS modelled now, but this repository shuns nothing, so
    // an empty table answers with no cards and no error. Same silent shape a
    // group with no rows always had; the populated case is its own test below.
    const table = try postXferCards(gpa, io, port, "pragma client-version 20000\nreqconfig /shun\n");
    defer gpa.free(table);
    try std.testing.expect(std.mem.indexOf(u8, table, "config /") == null);
    try std.testing.expect(std.mem.indexOf(u8, table, "error") == null);

    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);
    try expectCloneConverges(gpa, io, &tmp_a, url, a_digests);
}

test "cli serve --adopt-project: an empty fronted store takes the first push's project (sync §8.5)" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    // A, an existing project with a check-in.
    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try writeFile(io, tmp_a.dir, "a.txt", "the project being moved\n");
    try addManaged(gpa, io, tmp_a.dir, &.{"a.txt"});
    var commit_a = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "a" });
    defer freeResult(gpa, &commit_a);
    try expectExit(commit_a.term, 0);
    const a_code = try readProjectCode(gpa, io, tmp_a.dir);
    defer gpa.free(a_code);
    const a_digests = try collectArtifactDigests(gpa, io, tmp_a.dir);
    defer freeDigests(gpa, a_digests);

    // B, the empty store a forge makes; C, an unrelated project.
    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    try initRepo(gpa, io, tmp_b.dir);
    const b_init_code = try readProjectCode(gpa, io, tmp_b.dir);
    defer gpa.free(b_init_code);
    var tmp_c = std.testing.tmpDir(.{});
    defer tmp_c.cleanup();
    try initRepo(gpa, io, tmp_c.dir);
    try writeFile(io, tmp_c.dir, "c.txt", "another project\n");
    try addManaged(gpa, io, tmp_c.dir, &.{"c.txt"});
    var commit_c = try runCommitEnv(gpa, io, tmp_c.dir, .{ .user = "u" }, &.{ "commit", "-m", "c" });
    defer freeResult(gpa, &commit_c);
    try expectExit(commit_c.term, 0);

    const refused_push = "zit push: the peer refused: wrong project (this repository and the peer's are different projects; clone the peer to work on it)\n";

    // Without the flag the same first push is refused and B is unchanged.
    {
        const port = try freshLoopbackPort(io);
        var server = try spawnServeFlags(gpa, io, tmp_b.dir, port, &.{"--fronted"});
        defer server.kill(io);
        try waitForListen(io, port);
        const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/xfer", .{port});
        defer gpa.free(url);
        var push = try runZit(gpa, io, tmp_a.dir, &.{ "push", url });
        defer freeResult(gpa, &push);
        try expectExitDiag(push.term, 1, push);
        try std.testing.expectEqualStrings(refused_push, push.stderr);
        server.kill(io);
        const b_code = try readProjectCode(gpa, io, tmp_b.dir);
        defer gpa.free(b_code);
        try std.testing.expectEqualStrings(b_init_code, b_code);
    }

    const port = try freshLoopbackPort(io);
    var server = try spawnServeFlags(gpa, io, tmp_b.dir, port, &.{ "--fronted", "--adopt-project" });
    defer server.kill(io);
    try waitForListen(io, port);
    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/xfer", .{port});
    defer gpa.free(url);

    // The forge flow: name the remote, then push.
    {
        var remote = try runZit(gpa, io, tmp_a.dir, &.{ "remote", url });
        defer freeResult(gpa, &remote);
        try expectExitDiag(remote.term, 0, remote);
        var push = try runZit(gpa, io, tmp_a.dir, &.{"push"});
        defer freeResult(gpa, &push);
        try expectExitDiag(push.term, 0, push);
    }

    // An unrelated project is now refused, and B keeps A's code.
    {
        var push = try runZit(gpa, io, tmp_c.dir, &.{ "push", url });
        defer freeResult(gpa, &push);
        try expectExitDiag(push.term, 1, push);
        try std.testing.expectEqualStrings(refused_push, push.stderr);
    }

    // A fresh clone of B carries A's project code and A's content.
    var tmp_d = std.testing.tmpDir(.{});
    defer tmp_d.cleanup();
    {
        var clone = try runZit(gpa, io, tmp_d.dir, &.{ "clone", "--no-open", url, "repo" });
        defer freeResult(gpa, &clone);
        try expectExitDiag(clone.term, 0, clone);
    }
    server.kill(io);

    const b_code = try readProjectCode(gpa, io, tmp_b.dir);
    defer gpa.free(b_code);
    try std.testing.expectEqualStrings(a_code, b_code);
    const b_digests = try collectArtifactDigests(gpa, io, tmp_b.dir);
    defer freeDigests(gpa, b_digests);
    try expectSameDigestSet(a_digests, b_digests);

    var d_dir = try tmp_d.dir.openDir(io, "repo", .{});
    defer d_dir.close(io);
    const d_code = try readProjectCode(gpa, io, d_dir);
    defer gpa.free(d_code);
    try std.testing.expectEqualStrings(a_code, d_code);
    const d_digests = try collectArtifactDigests(gpa, io, d_dir);
    defer freeDigests(gpa, d_digests);
    try expectSameDigestSet(a_digests, d_digests);
}

/// Read the first bytes of the server's HTTP reply on `stream`, returning true
/// iff they are a status line (`HTTP/…`). Run as a `Select` task so a wedged
/// server (no reply ever comes) is a cancellation point the deadline interrupts.
fn probeReadOk(io: std.Io, stream: net.Stream) bool {
    var buf: [64]u8 = undefined;
    var r = stream.reader(io, &buf);
    const head = r.interface.take(5) catch return false;
    return std.mem.eql(u8, head, "HTTP/");
}

fn probeDeadline(io: std.Io, ns: u64) void {
    io.sleep(.{ .nanoseconds = @intCast(ns) }, .awake) catch {};
}

/// Bounded liveness proof: open a FRESH connection, send a well-formed HTTP
/// request head, and require a status-line reply within `window_ns`. On a
/// single-threaded server this reply cannot arrive until any prior stalled
/// connection is abandoned by the serve deadline, so `window_ns` must exceed it;
/// the race converts a persistent wedge into `error.ServerWedged` rather than an
/// unbounded hang (the bounded-waits rule: interval AND deadline). A clean
/// reply proves the accept loop was freed and the server still serves.
fn expectServesFreshRequest(io: std.Io, port: u16, window_ns: u64) !void {
    const stream = dialServe(io, port) catch return error.ProbeConnectFailed;
    defer stream.close(io);
    {
        var wbuf: [128]u8 = undefined;
        var w = stream.writer(io, &wbuf);
        // A GET is a well-formed request the server routes and answers (with a
        // §4 classification status); the point is that a fresh connection is
        // accepted and answered at all — proof the loop is not pinned.
        try w.interface.writeAll("GET /xfer HTTP/1.1\r\nHost: z\r\nConnection: close\r\n\r\n");
        try w.interface.flush();
    }
    const Outcome = union(enum) { replied: bool, expired: void };
    var slots: [2]Outcome = undefined;
    var race = std.Io.Select(Outcome).init(io, &slots);
    try race.concurrent(.replied, probeReadOk, .{ io, stream });
    race.concurrent(.expired, probeDeadline, .{ io, window_ns }) catch {
        // No concurrency for the deadline task: fall back to an unbounded read
        // (the server is expected to reply; this only loses the wedge ceiling).
        const got = race.await() catch {
            race.cancelDiscard();
            return error.ProbeCanceled;
        };
        race.cancelDiscard();
        if (got == .replied and got.replied) return;
        return error.ServerWedged;
    };
    const outcome = race.await() catch {
        race.cancelDiscard();
        return error.ProbeCanceled;
    };
    race.cancelDiscard();
    switch (outcome) {
        .replied => |ok| if (!ok) return error.ServerBadReply,
        .expired => return error.ServerWedged,
    }
}

/// Prove a full sync round still converges after the abuse: clone the served
/// repo into a fresh tree and require its on-disk artifact set to equal the
/// server's (`expectSameDigestSet`) — the interop oracle, unweakened.
fn expectCloneConverges(gpa: std.mem.Allocator, io: std.Io, tmp_parent: *std.testing.TmpDir, url: []const u8, want: []const []const u8) !void {
    var clone = try runZit(gpa, io, tmp_parent.dir, &.{ "clone", url, "recover" });
    defer freeResult(gpa, &clone);
    try expectExitDiag(clone.term, 0, clone);
    var b_dir = try tmp_parent.dir.openDir(io, "recover", .{});
    defer b_dir.close(io);
    const got = try collectArtifactDigests(gpa, io, b_dir);
    defer freeDigests(gpa, got);
    try expectSameDigestSet(want, got);
}

/// The bounded ceiling for `expectServesFreshRequest`: a stalled connection is
/// abandoned by the serve deadline (`serve.default_conn_read_timeout_ns`, 5 s),
/// after which a fresh loopback request is answered in milliseconds. 15 s is 3×
/// that deadline — ample slack for a loaded runner while still bounding a true
/// wedge into a clean failure well inside the e2e step timeout.
const serve_probe_window_ns: u64 = 15_000_000_000;

/// Seed a one-commit repo in `dir` and return its artifact-digest set (the
/// convergence oracle). Caller frees via `freeDigests`.
fn seedServedRepo(gpa: std.mem.Allocator, io: std.Io, dir: std.Io.Dir) ![][]u8 {
    try initRepo(gpa, io, dir);
    try writeFile(io, dir, "seed.txt", "served content for robustness\n");
    try addManaged(gpa, io, dir, &.{"seed.txt"});
    var commit = try runCommitEnv(gpa, io, dir, .{ .user = "u" }, &.{ "commit", "-m", "seed" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    return collectArtifactDigests(gpa, io, dir);
}

test "serve robustness: a byte-dribbled slow-loris head does not wedge the server" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    const a_digests = try seedServedRepo(gpa, io, tmp_a.dir);
    defer freeDigests(gpa, a_digests);

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);

    // Slow-loris: dribble a partial request head one byte per 50 ms and NEVER
    // complete it, holding the connection open. Bounded: 8 bytes × 50 ms = 400 ms
    // of dribble, then hold — the head terminator (\r\n\r\n) never arrives, so
    // `receiveHead` on the server blocks until its deadline abandons it.
    const loris = try dialServe(io, port);
    defer loris.close(io);
    {
        var wbuf: [8]u8 = undefined;
        var w = loris.writer(io, &wbuf);
        const dribble = "POST /xf"; // a partial, never-terminated request head
        for (dribble) |c| {
            w.interface.writeByte(c) catch break;
            w.interface.flush() catch break;
            io.sleep(.{ .nanoseconds = 50_000_000 }, .awake) catch {};
        }
    }

    // The server survives: a fresh request is answered within the bounded window
    // (served only once the loris connection is abandoned by the deadline).
    try expectServesFreshRequest(io, port, serve_probe_window_ns);

    // And a full sync round still converges against the same live server.
    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);
    try expectCloneConverges(gpa, io, &tmp_a, url, a_digests);
}

test "serve robustness: a valid head then a half-sent body does not wedge the server" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    const a_digests = try seedServedRepo(gpa, io, tmp_a.dir);
    defer freeDigests(gpa, a_digests);

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);

    // Send a COMPLETE, well-formed sync request head declaring a 100-byte body,
    // then send only 50 bytes and HOLD. The server accepts the head, then blocks
    // reading the remaining body bytes that never come, until the deadline.
    const partial = try dialServe(io, port);
    defer partial.close(io);
    {
        var wbuf: [256]u8 = undefined;
        var w = partial.writer(io, &wbuf);
        try w.interface.writeAll(
            "POST /xfer HTTP/1.1\r\nHost: z\r\n" ++
                "Content-Type: application/x-fossil\r\nContent-Length: 100\r\n" ++
                "Connection: close\r\n\r\n",
        );
        try w.interface.writeAll(repeat("x", 50)); // half of the declared 100-byte body
        try w.interface.flush();
    }

    try expectServesFreshRequest(io, port, serve_probe_window_ns);

    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);
    try expectCloneConverges(gpa, io, &tmp_a, url, a_digests);
}

test "serve robustness: a client that disconnects mid-response does not wedge the server" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    const a_digests = try seedServedRepo(gpa, io, tmp_a.dir);
    defer freeDigests(gpa, a_digests);

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);

    // Send a complete well-formed request, then close the connection WITHOUT
    // reading the reply — the peer vanishes while the server is answering. The
    // server's write to a gone peer fails per-connection and the loop moves on.
    {
        const abrupt = try dialServe(io, port);
        var wbuf: [128]u8 = undefined;
        var w = abrupt.writer(io, &wbuf);
        try w.interface.writeAll("GET /xfer HTTP/1.1\r\nHost: z\r\nConnection: close\r\n\r\n");
        try w.interface.flush();
        abrupt.close(io); // disconnect without draining the response
    }

    try expectServesFreshRequest(io, port, serve_probe_window_ns);

    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);
    try expectCloneConverges(gpa, io, &tmp_a, url, a_digests);
}

test "serve robustness: a burst of idle connections that never send a byte does not wedge the server" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    const a_digests = try seedServedRepo(gpa, io, tmp_a.dir);
    defer freeDigests(gpa, a_digests);

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);

    // A burst of connections that connect and immediately give up without ever
    // sending a byte. Each is a clean EOF the accept loop must drain and move
    // past — a connection-churn peer must not pin or leak the server. Bounded:
    // a fixed count, each opened and closed in turn (sequential, never held).
    const idle_connections: u32 = 5;
    var i: u32 = 0;
    while (i < idle_connections) : (i += 1) {
        const idle = try dialServe(io, port);
        idle.close(io); // zero bytes sent, then gone
    }

    try expectServesFreshRequest(io, port, serve_probe_window_ns);

    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);
    try expectCloneConverges(gpa, io, &tmp_a, url, a_digests);
}

/// POST `plain` to the served repository as an `application/x-fossil` sync
/// request and return the DECODED reply body (caller frees). Raw HTTP rather than
/// a `zit` subcommand because no verb emits a bare `gimme` for an arbitrary hash —
/// that card is what §3.3 L569-572's "If absent, silently skip" is about.
fn postXferPlain(gpa: std.mem.Allocator, io: std.Io, port: u16, plain: []const u8) ![]u8 {
    const body = try container.encode(gpa, plain, .default);
    defer gpa.free(body);

    const stream = try dialServe(io, port);
    defer stream.close(io);
    {
        var wbuf: [512]u8 = undefined;
        var w = stream.writer(io, &wbuf);
        const head = try std.fmt.allocPrint(
            gpa,
            "POST /xfer HTTP/1.1\r\nHost: z\r\nContent-Type: application/x-fossil\r\n" ++
                "Content-Length: {d}\r\nConnection: close\r\n\r\n",
            .{body.len},
        );
        defer gpa.free(head);
        try w.interface.writeAll(head);
        try w.interface.writeAll(body);
        try w.interface.flush();
    }

    // Read to EOF (the server closed the connection), then split off the head. A
    // READ FAULT is not end-of-stream: both callers assert on a name being ABSENT
    // from the reply, which a truncated body satisfies for free, so a socket error
    // must fail the test rather than shorten the body.
    var rbuf: [4096]u8 = undefined;
    var r = stream.reader(io, &rbuf);
    const raw = try r.interface.allocRemaining(gpa, .limited(1 << 20));
    defer gpa.free(raw);

    const sep = std.mem.indexOf(u8, raw, "\r\n\r\n") orelse return error.NoHttpHeadEnd;
    if (std.mem.indexOf(u8, raw[0..sep], " 200 ") == null) return error.NotOk;
    return container.decode(gpa, raw[sep + 4 ..], 1 << 20);
}

test "cli serve: a slow-but-draining peer receives a multi-megabyte clone reply intact — the write deadline scales with the reply (at the §8.2 byte budget)" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    // A repo whose one clone batch approaches the §8.2 byte budget:
    // deterministic incompressible blobs, so the reply body is multi-MiB and
    // the server's write genuinely blocks on the peer draining it (loopback
    // kernel buffering absorbs the first few hundred KiB for free).
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    var prng = std.Random.DefaultPrng.init(0x5eed_c0de);
    const blob = try gpa.alloc(u8, 512 * 1024);
    defer gpa.free(blob);
    var names_buf: [8][16]u8 = undefined;
    var i: usize = 0;
    while (i < 8) : (i += 1) {
        prng.random().bytes(blob);
        const name = std.fmt.bufPrint(&names_buf[i], "blob{d}.bin", .{i}) catch unreachable;
        try writeFile(io, tmp.dir, name, blob);
        try addManaged(gpa, io, tmp.dir, &.{name});
    }
    var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "wide" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);

    // The raw clone opener a transport would send.
    const req = try container.encode(gpa, "pragma client-version 1\nclone 3 1\n", .default);
    defer gpa.free(req);
    const stream = try dialServe(io, port);
    defer stream.close(io);
    {
        var wbuf: [512]u8 = undefined;
        var w = stream.writer(io, &wbuf);
        const head = try std.fmt.allocPrint(
            gpa,
            "POST /xfer HTTP/1.1\r\nHost: z\r\nContent-Type: application/x-fossil\r\n" ++
                "Content-Length: {d}\r\nConnection: close\r\n\r\n",
            .{req.len},
        );
        defer gpa.free(head);
        try w.interface.writeAll(head);
        try w.interface.writeAll(req);
        try w.interface.flush();
    }

    // Drain the reply THROTTLED to ~427 KiB/s — a healthy DSL-class peer.
    // Over a ~4 MiB reply that is ~10 s of draining: far past the flat 5 s
    // deadline (which used to cancel this healthy write mid-flight — the
    // regression shape), comfortably above the scaled deadline's minimum
    // drain rate. The whole body must arrive: a truncated reply is exactly
    // the regression this test exists to catch.
    var chunk: [64 * 1024]u8 = undefined;
    var raw: std.ArrayList(u8) = .empty;
    defer raw.deinit(gpa);
    var rbuf: [4096]u8 = undefined;
    var r = stream.reader(io, &rbuf);
    while (true) {
        const n = r.interface.readSliceShort(&chunk) catch break;
        if (n == 0) break;
        try raw.appendSlice(gpa, chunk[0..n]);
        io.sleep(.{ .nanoseconds = 150 * std.time.ns_per_ms }, .awake) catch {};
    }

    // The head parsed 200 with a Content-Length the body honors in full.
    const sep = std.mem.indexOf(u8, raw.items, "\r\n\r\n") orelse return error.NoHttpHeadEnd;
    try std.testing.expect(std.mem.indexOf(u8, raw.items[0..sep], " 200 ") != null);
    const cl_key = "content-length: ";
    const head_lower = try std.ascii.allocLowerString(gpa, raw.items[0..sep]);
    defer gpa.free(head_lower);
    const cl_at = std.mem.indexOf(u8, head_lower, cl_key) orelse return error.NoContentLength;
    const cl_end = std.mem.indexOfScalarPos(u8, head_lower, cl_at, '\r') orelse return error.NoContentLength;
    const content_length = try std.fmt.parseInt(usize, head_lower[cl_at + cl_key.len .. cl_end], 10);
    // The batch really was multi-MiB — the premise that makes the write block.
    try std.testing.expect(content_length >= 3 << 20);
    try std.testing.expectEqual(content_length, raw.items.len - (sep + 4));
}

test "cli serve: a --force shun's generation swap is served on the next round — the live server reopens the renamed store, no restart" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    const root = try shunFixture(gpa, io, tmp_a.dir);
    defer gpa.free(root);
    const doomed = try artifactNameByContent(gpa, io, tmp_a.dir, doomed_body);
    defer gpa.free(doomed);
    const kept = try artifactNameByContent(gpa, io, tmp_a.dir, kept_body);
    defer gpa.free(kept);

    // ONE server for the whole test: the point is what happens without a restart.
    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);
    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);

    // Before the shun: a clone receives the doomed artifact — the premise.
    {
        var clone = try runZit(gpa, io, tmp_a.dir, &.{ "clone", url, "before" });
        defer freeResult(gpa, &clone);
        try expectExitDiag(clone.term, 0, clone);
        var b_dir = try tmp_a.dir.openDir(io, "before", .{});
        defer b_dir.close(io);
        try std.testing.expect(try storeHoldsArtifact(gpa, io, b_dir, doomed));
    }

    // The takedown: --force reclaims by RENAMING a new generation over `.zit`.
    // The running server still holds the old inode's handle.
    {
        var res = try runZit(gpa, io, tmp_a.dir, &.{ "shun", "--force", doomed });
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 0, res);
    }
    try std.testing.expect(!try storeHoldsArtifact(gpa, io, tmp_a.dir, doomed));

    // The very next round serves the rewritten generation: the doomed bytes are
    // gone from a fresh clone, the kept artifact still arrives — no restart.
    {
        var clone = try runZit(gpa, io, tmp_a.dir, &.{ "clone", "--no-open", url, "after" });
        defer freeResult(gpa, &clone);
        try expectExitDiag(clone.term, 0, clone);
        var b_dir = try tmp_a.dir.openDir(io, "after", .{});
        defer b_dir.close(io);
        try std.testing.expect(!try storeHoldsArtifact(gpa, io, b_dir, doomed));
        try std.testing.expect(try storeHoldsArtifact(gpa, io, b_dir, kept));
    }
}

test "cli serve §9.1: the clone reply's push card carries a real derived servercode, not the placeholder" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "a.txt", "one\n");
    try addManaged(gpa, io, tmp.dir, &.{"a.txt"});
    var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "seed" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);

    // A clone reply rides UNCOMPRESSED (§8.1), so read the raw body rather
    // than routing through the container-decoding helper.
    const req = try container.encode(gpa, "pragma client-version 1\nclone 3 1\n", .default);
    defer gpa.free(req);
    const stream = try dialServe(io, port);
    defer stream.close(io);
    {
        var wbuf: [512]u8 = undefined;
        var w = stream.writer(io, &wbuf);
        const head = try std.fmt.allocPrint(
            gpa,
            "POST /xfer HTTP/1.1\r\nHost: z\r\nContent-Type: application/x-fossil\r\n" ++
                "Content-Length: {d}\r\nConnection: close\r\n\r\n",
            .{req.len},
        );
        defer gpa.free(head);
        try w.interface.writeAll(head);
        try w.interface.writeAll(req);
        try w.interface.flush();
    }
    var rbuf: [4096]u8 = undefined;
    var r = stream.reader(io, &rbuf);
    const raw = try r.interface.allocRemaining(gpa, .limited(1 << 20));
    defer gpa.free(raw);
    const sep = std.mem.indexOf(u8, raw, "\r\n\r\n") orelse return error.NoHttpHeadEnd;
    try std.testing.expect(std.mem.indexOf(u8, raw[0..sep], " 200 ") != null);
    const reply = raw[sep + 4 ..];
    const at = std.mem.indexOf(u8, reply, "\npush ") orelse return error.NoPushCard;
    const line_end = std.mem.indexOfScalarPos(u8, reply, at + 1, '\n') orelse return error.NoPushCard;
    const line = reply[at + 1 .. line_end];
    var toks = std.mem.tokenizeScalar(u8, line, ' ');
    _ = toks.next(); // "push"
    const servercode = toks.next() orelse return error.NoPushCard;
    // Real identity: 40 lowercase hex, and not the informational placeholder.
    try std.testing.expectEqual(@as(usize, 40), servercode.len);
    for (servercode) |c| try std.testing.expect(std.ascii.isHex(c) and !std.ascii.isUpper(c));
    try std.testing.expect(!std.mem.eql(u8, servercode, "0000000000000000"));
    try std.testing.expect(std.mem.indexOf(u8, servercode, "00000000") == null or !std.mem.allEqual(u8, servercode, '0'));
}

test "cli serve: a shunned holding is never igot-announced, and an inbound gimme for it is silently skipped (sync §9.5 L2170-2174, §3.3 L569-572)" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    const root = try shunFixture(gpa, io, tmp_a.dir);
    defer gpa.free(root);
    const doomed = try artifactNameByContent(gpa, io, tmp_a.dir, doomed_body);
    defer gpa.free(doomed);
    const kept = try artifactNameByContent(gpa, io, tmp_a.dir, kept_body);
    defer gpa.free(kept);

    {
        var res = try runZit(gpa, io, tmp_a.dir, &.{ "shun", "--force", "--defer", doomed });
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 0, res);
    }
    // Premise again: the server still HOLDS the bytes it must refuse to send.
    try std.testing.expect(try storeHoldsArtifact(gpa, io, tmp_a.dir, doomed));
    // §8.5 — both rounds pull as a peer of the served project.
    const pcode = try readProjectCode(gpa, io, tmp_a.dir);
    defer gpa.free(pcode);

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);

    // ROUND 1 — the §3.2/§9.5 INVENTORY WALK. The client announces a hash this
    // repo does not hold, so the server answers with igot for "every eligible
    // holding after the Section 3.3 shun … filters" (§9.5 L2171-2173). The
    // unshunned neighbour proves the walk ran at all, so the shunned name's
    // absence is the filter and not an empty reply.
    {
        const absent = try gpa.alloc(u8, doomed.len);
        defer gpa.free(absent);
        @memset(absent, '0');
        const plain = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npull sc {s}\nigot {s}\n", .{ pcode, absent });
        defer gpa.free(plain);
        const reply = try postXferPlain(gpa, io, port, plain);
        defer gpa.free(reply);

        const kept_igot = try std.fmt.allocPrint(gpa, "igot {s}\n", .{kept});
        defer gpa.free(kept_igot);
        try std.testing.expect(std.mem.indexOf(u8, reply, kept_igot) != null);
        // The shunned name appears on NO card — not igot (it is not an eligible
        // holding), not gimme (§3.3 L553-556 excludes it from the phantom scan),
        // and above all not `error`.
        try std.testing.expect(std.mem.indexOf(u8, reply, doomed) == null);
        try std.testing.expect(std.mem.indexOf(u8, reply, "error") == null);
    }

    // ROUND 2 — an inbound `gimme` for the shunned hash. §3.3 L569-572: "If
    // absent, silently skip." The mask is what makes it absent to the
    // enumeration, so this needs no code of its own on the gimme path.
    {
        const plain = try std.fmt.allocPrint(
            gpa,
            "pragma client-version 20000\npull sc {s}\ngimme {s}\ngimme {s}\n",
            .{ pcode, doomed, kept },
        );
        defer gpa.free(plain);
        const reply = try postXferPlain(gpa, io, port, plain);
        defer gpa.free(reply);

        // The neighbour comes back as a `file` card…
        const kept_card = try std.fmt.allocPrint(gpa, "file {s} ", .{kept});
        defer gpa.free(kept_card);
        try std.testing.expect(std.mem.indexOf(u8, reply, kept_card) != null);
        // …and the shunned hash produces nothing at all, error card included.
        try std.testing.expect(std.mem.indexOf(u8, reply, doomed) == null);
        try std.testing.expect(std.mem.indexOf(u8, reply, "error") == null);
    }
}

// --- RECEIVE-side admission through the real binary (sync §7.7 L1469-1490) --
//
// The send-side filter above keeps a shunned artifact off the wire when WE are
// the sender. This is the other direction, and the one a shun is worthless
// without: a PEER pushes the shunned artifact AT us. §7.7 L1472-1475 — "A
// non-clone file whose target is shunned is consumed and discarded after its
// payload and pending private marker; it emits no error, does not set
// content-received, and makes no repository mutation." A server under
// push-receive is always non-clone, so this is the discard arm, unconditionally.
//
// WHY A RAW POST AND NOT `zit push`. A zit-to-zit push cannot reach this code at
// all: the receiving server's §3.3 L553-556 phantom scan already declines to
// `gimme` a shunned name, and a zit push client only uploads what the peer asked
// for — so the send-side filter masks the receive-side gap end to end, and a
// `zit push` e2e passes with the whole admission check deleted (checked, not
// assumed). A real Fossil push is UNSOLICITED: it sends the content its own
// inventory says the peer lacks. `postXferPlain` is that shape, and it is the
// only shape that puts the receive path under test.
//
// The shun is `--force`, so A does not hold the bytes: the ONLY thing that can
// keep them out is admission at ingest.

test "cli serve: an unsolicited push of a shunned artifact is discarded — nothing lands and no error card comes back (sync §7.7 L1472-1475)" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    const root = try shunFixture(gpa, io, tmp_a.dir);
    defer gpa.free(root);
    const doomed = try artifactNameByContent(gpa, io, tmp_a.dir, doomed_body);
    defer gpa.free(doomed);

    {
        var res = try runZit(gpa, io, tmp_a.dir, &.{ "shun", "--force", doomed });
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 0, res);
    }
    // The premise: the operator's removal actually happened.
    try std.testing.expect(!try storeHoldsArtifact(gpa, io, tmp_a.dir, doomed));

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);

    // §9.1 — a `push SERVERCODE PROJECTCODE` card naming the served project
    // (§8.5), then the artifact itself, sent without ever having been asked for.
    const pcode = try readProjectCode(gpa, io, tmp_a.dir);
    defer gpa.free(pcode);
    const plain = try std.fmt.allocPrint(
        gpa,
        "pragma client-version 20000\npush {s} {s}\nfile {s} {d}\n{s}",
        .{ repeat("1", 40), pcode, doomed, doomed_body.len, doomed_body },
    );
    defer gpa.free(plain);
    const reply = try postXferPlain(gpa, io, port, plain);
    defer gpa.free(reply);

    // "it emits no error" — no error card of any kind, and the shunned name is
    // not echoed back on one either.
    try std.testing.expect(std.mem.indexOf(u8, reply, "error") == null);
    try std.testing.expect(std.mem.indexOf(u8, reply, doomed) == null);

    // The SAME card in DELTA form (§7.1 `file HASH DELTASRC SIZE`), against a
    // basis this repository does not hold. That is the COMMON shape for a
    // shunned target — its neighbours are unlikely to still be here — and it is
    // the one that reaches the server's delta reconstruction. L1437-1440 draws no
    // distinction between the two forms: still no error card, still nothing
    // lands. The delta payload is deliberately junk; the basis lookup fails
    // before it is parsed, so the path is deterministic either way.
    const delta_plain = try std.fmt.allocPrint(
        gpa,
        "pragma client-version 20000\npush {s} {s}\nfile {s} {s} 4\njunk",
        .{ repeat("1", 40), pcode, doomed, repeat("3", 64) },
    );
    defer gpa.free(delta_plain);
    const delta_reply = try postXferPlain(gpa, io, port, delta_plain);
    defer gpa.free(delta_reply);
    try std.testing.expect(std.mem.indexOf(u8, delta_reply, "error") == null);
    try std.testing.expect(std.mem.indexOf(u8, delta_reply, doomed) == null);
    // "makes no repository mutation" — not even the DELTASRC phantom, because
    // admission is decided before DELTASRC is looked at (L1434-1435).
    try std.testing.expect(std.mem.indexOf(u8, delta_reply, repeat("3", 64)) == null);

    // THE PROOF: release the server's handles, then read A back off disk. The
    // repository the operator emptied is still empty of it.
    server.kill(io);
    try std.testing.expect(!try storeHoldsArtifact(gpa, io, tmp_a.dir, doomed));
}

test "cli serve --read-only: a peer clones and pulls, its push is refused, and nothing it pushed is stored" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try writeFile(io, tmp_a.dir, "a.txt", "a\n");
    try addManaged(gpa, io, tmp_a.dir, &.{"a.txt"});
    var first = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "first" });
    defer freeResult(gpa, &first);
    try expectExitDiag(first.term, 0, first);

    const port = try freshLoopbackPort(io);
    var server = try spawnServeFlag(gpa, io, tmp_a.dir, port, "--read-only");
    defer server.kill(io);
    try waitForListen(io, port);
    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);

    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", url, "cl" });
    defer freeResult(gpa, &clone);
    try expectExitDiag(clone.term, 0, clone);
    var cl = try tmp_b.dir.openDir(io, "cl", .{});
    defer cl.close(io);

    try writeFile(io, cl, "b.txt", "b\n");
    try addManaged(gpa, io, cl, &.{"b.txt"});
    var stranger = try runCommitEnv(gpa, io, cl, .{ .user = "s" }, &.{ "commit", "-m", "stranger", "--no-sync" });
    defer freeResult(gpa, &stranger);
    try expectExitDiag(stranger.term, 0, stranger);
    var push = try runZit(gpa, io, cl, &.{ "push", url });
    defer freeResult(gpa, &push);
    try expectExit(push.term, 1);
    var tl = try runZit(gpa, io, tmp_a.dir, &.{ "timeline", "-n", "5" });
    defer freeResult(gpa, &tl);
    try std.testing.expect(std.mem.indexOf(u8, tl.stdout, "stranger") == null);

    // A pull still answers: a check-in made at the server reaches the clone.
    try writeFile(io, tmp_a.dir, "a.txt", "a2\n");
    var second = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "second" });
    defer freeResult(gpa, &second);
    try expectExitDiag(second.term, 0, second);
    var pull = try runZit(gpa, io, cl, &.{ "pull", url });
    defer freeResult(gpa, &pull);
    // "second" lands beside the clone's unpushed "stranger": a fork the pull
    // brought, so the pull succeeds with the fork status.
    try expectExitDiag(pull.term, 9, pull);
    try expectContains(pull.stderr, "fork on trunk: 2 leaves (");
    var cl_tl = try runZit(gpa, io, cl, &.{ "timeline", "-n", "5" });
    defer freeResult(gpa, &cl_tl);
    try std.testing.expect(std.mem.indexOf(u8, cl_tl.stdout, "second") != null);
}

test "cli serve on a sparse store: dense and uncovered clones refuse, a covered cone clone succeeds" {
    // Goal: section 5.3 -- a sparse origin refuses to serve clones it does
    // not cover (dense requests and cones outside its coverage) with one
    // error card and zero content bytes; a clone wholly inside its cone is
    // served. Method: build a dense repo, clone --cone=src into B, serve B,
    // then attempt the three clone shapes against it.
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try tmp_a.dir.createDir(io, "src", .default_dir);
    try tmp_a.dir.createDir(io, "tools", .default_dir);
    try writeFile(io, tmp_a.dir, "src/a.zig", "in\n");
    try writeFile(io, tmp_a.dir, "tools/t.bin", "out\n");
    try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.bin" });
    var c1 = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "seed" });
    defer freeResult(gpa, &c1);
    try expectExit(c1.term, 0);

    const port_a = try freshLoopbackPort(io);
    var server_a = try spawnServe(gpa, io, tmp_a.dir, port_a);
    defer server_a.kill(io);
    try waitForListen(io, port_a);
    const url_a = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port_a});
    defer gpa.free(url_a);

    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    var clone_b = try runZit(gpa, io, tmp_b.dir, &.{ "clone", "--cone=src", url_a, "repo" });
    defer freeResult(gpa, &clone_b);
    try expectExitDiag(clone_b.term, 0, clone_b);
    var b_dir = try tmp_b.dir.openDir(io, "repo", .{});
    defer b_dir.close(io);

    const port_b = try freshLoopbackPort(io);
    var server_b = try spawnServe(gpa, io, b_dir, port_b);
    defer server_b.kill(io);
    try waitForListen(io, port_b);
    const url_b = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port_b});
    defer gpa.free(url_b);

    var tmp_c = std.testing.tmpDir(.{});
    defer tmp_c.cleanup();
    // A dense clone from the sparse origin refuses.
    var dense = try runZit(gpa, io, tmp_c.dir, &.{ "clone", url_b, "dense" });
    defer freeResult(gpa, &dense);
    try expectNonzeroExit(dense.term);
    // An uncovered cone refuses the same way.
    var wide = try runZit(gpa, io, tmp_c.dir, &.{ "clone", "--cone=tools", url_b, "wide" });
    defer freeResult(gpa, &wide);
    try expectNonzeroExit(wide.term);
    // A cone inside the origin's coverage is served.
    var narrow = try runZit(gpa, io, tmp_c.dir, &.{ "clone", "--no-open", "--cone=src", url_b, "narrow" });
    defer freeResult(gpa, &narrow);
    try expectExitDiag(narrow.term, 0, narrow);
    var n_dir = try tmp_c.dir.openDir(io, "narrow", .{});
    defer n_dir.close(io);
    var op = try runZit(gpa, io, n_dir, &.{ "open", "--cone=src" });
    defer freeResult(gpa, &op);
    try expectExitDiag(op.term, 0, op);
    try std.testing.expect(fileExists(io, n_dir, "src/a.zig"));
}

/// Every artifact `dir` holds that `except` does not, as push
/// `file` cards, read through `zit frames` (whose framing is the push card's
/// own: a header line, then exactly SIZE raw bytes).
fn pushCardsFrom(gpa: std.mem.Allocator, io: std.Io, dir: std.Io.Dir, except: []const []const u8) ![]u8 {
    var frames = try runZit(gpa, io, dir, &.{"frames"});
    defer freeResult(gpa, &frames);
    try expectExitDiag(frames.term, 0, frames);
    const out = frames.stdout;

    var cards: std.ArrayListUnmanaged(u8) = .empty;
    errdefer cards.deinit(gpa);
    var pos: usize = 0;
    while (pos < out.len) {
        const nl = std.mem.indexOfScalarPos(u8, out, pos, '\n') orelse break;
        const line = out[pos..nl];
        pos = nl + 1;
        if (std.mem.startsWith(u8, line, "cursor ")) break;
        if (!std.mem.startsWith(u8, line, "artifact ")) continue;
        var it = std.mem.tokenizeScalar(u8, line["artifact ".len..], ' ');
        const hash = it.next() orelse return error.TestUnexpectedResult;
        const size = try std.fmt.parseInt(usize, it.next() orelse return error.TestUnexpectedResult, 10);
        if (pos + size > out.len) return error.TestUnexpectedResult;
        const bytes = out[pos .. pos + size];
        pos += size;
        if (pos < out.len and out[pos] == '\n') pos += 1;
        // `except` holds raw digests, the frames listing prints hex: compare
        // in one alphabet or nothing is ever excluded and every held artifact
        // rides the push again.
        var skip = false;
        for (except) |e| {
            if (e.len == 32 and std.mem.eql(u8, &std.fmt.bytesToHex(e[0..32].*, .lower), hash)) skip = true;
            if (std.mem.eql(u8, e, hash)) skip = true;
        }
        if (skip) continue;
        var header: [128]u8 = undefined;
        try cards.appendSlice(gpa, try std.fmt.bufPrint(&header, "file {s} {d}\n", .{ hash, size }));
        try cards.appendSlice(gpa, bytes);
    }
    return cards.toOwnedSlice(gpa);
}

fn projectCodeOf(gpa: std.mem.Allocator, io: std.Io, dir: std.Io.Dir) ![]u8 {
    var stat = try runZit(gpa, io, dir, &.{"stat"});
    defer freeResult(gpa, &stat);
    try expectExitDiag(stat.term, 0, stat);
    var lines = std.mem.tokenizeScalar(u8, stat.stdout, '\n');
    while (lines.next()) |l| {
        if (std.mem.startsWith(u8, l, "project-code ")) return gpa.dupe(u8, std.mem.trim(u8, l["project-code ".len..], " "));
    }
    return error.TestUnexpectedResult;
}

fn hasDigest(set: []const []const u8, want: []const u8) bool {
    for (set) |d| if (std.mem.eql(u8, d, want)) return true;
    return false;
}

test "cli serve: a fronted server refuses a push that would join a protected branch and stores nothing; without --fronted the header is ignored" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    // A: the served repository, one seed check-in on trunk.
    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try writeFile(io, tmp_a.dir, "one.txt", "seed\n");
    try addManaged(gpa, io, tmp_a.dir, &.{"one.txt"});
    var seed = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", "seed" });
    defer freeResult(gpa, &seed);
    try expectExit(seed.term, 0);

    // B: a clone that grows by one trunk check-in — the thing to be refused.
    const clone_port = try freshLoopbackPort(io);
    var clone_server = try spawnServe(gpa, io, tmp_a.dir, clone_port);
    try waitForListen(io, clone_port);
    const clone_url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/xfer", .{clone_port});
    defer gpa.free(clone_url);
    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", clone_url, "repo" });
    defer freeResult(gpa, &clone);
    try expectExitDiag(clone.term, 0, clone);
    clone_server.kill(io);
    var b_repo = try tmp_b.dir.openDir(io, "repo", .{});
    defer b_repo.close(io);
    try writeFile(io, b_repo, "two.txt", "grows trunk\n");
    try addManaged(gpa, io, b_repo, &.{"two.txt"});
    var grow = try runCommitEnv(gpa, io, b_repo, .{ .user = "u" }, &.{ "commit", "-m", "grow" });
    defer freeResult(gpa, &grow);
    try expectExit(grow.term, 0);

    const a_before = try collectArtifactDigests(gpa, io, tmp_a.dir);
    defer freeDigests(gpa, a_before);
    const b_all = try collectArtifactDigests(gpa, io, b_repo);
    defer freeDigests(gpa, b_all);
    try std.testing.expect(b_all.len > a_before.len);

    // The push B's client would send, as raw cards, so a header can ride it.
    const files = try pushCardsFrom(gpa, io, b_repo, a_before);
    defer gpa.free(files);
    const project = try projectCodeOf(gpa, io, b_repo);
    defer gpa.free(project);
    const request = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npush {s} {s}\n{s}", .{ repeat("c", 40), project, files });
    defer gpa.free(request);

    // Fronted, with the front's rule: refused, naming trunk, and A is byte-for-
    // byte what it was.
    {
        const port = try freshLoopbackPort(io);
        var server = try spawnServeFronted(gpa, io, tmp_a.dir, port, true);
        defer server.kill(io);
        try waitForListen(io, port);
        const reply = try postXferCardsHeaders(gpa, io, port, request, "X-Zit-Protect: trunk\r\n");
        defer gpa.free(reply);
        try std.testing.expect(std.mem.startsWith(u8, reply, "error "));
        try std.testing.expect(std.mem.indexOf(u8, reply, "'trunk'") != null);
        server.kill(io);
        const a_after = try collectArtifactDigests(gpa, io, tmp_a.dir);
        defer freeDigests(gpa, a_after);
        try std.testing.expectEqual(a_before.len, a_after.len);
    }
    // Not fronted, same header: ignored. The push lands and A holds B's set.
    {
        const port = try freshLoopbackPort(io);
        var server = try spawnServe(gpa, io, tmp_a.dir, port);
        defer server.kill(io);
        try waitForListen(io, port);
        const reply = try postXferCardsHeaders(gpa, io, port, request, "X-Zit-Protect: trunk\r\n");
        defer gpa.free(reply);
        try std.testing.expect(!std.mem.startsWith(u8, reply, "error "));
        server.kill(io);
        const a_after = try collectArtifactDigests(gpa, io, tmp_a.dir);
        defer freeDigests(gpa, a_after);
        for (b_all) |d| try std.testing.expect(hasDigest(a_after, d));
    }
}

test "cli serve: a refused check-in amended onto another branch lands there, while a held trunk check-in still cannot be moved" {
    // After a refused push the obvious recovery is `zit amend X --branch other`,
    // which cancels `sym-trunk` on X from a control artifact. A cancel aimed at
    // a check-in the server does not hold removes it from nothing held, so it is
    // admitted and X is judged by where it joins — with the move applied, since
    // the two travel in one round. Before this, the cancel was refused by name
    // alone and every later push from that checkout carried the same refused
    // round: a dead end only a fresh clone escaped.
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try writeFile(io, tmp_a.dir, "one.txt", "seed\n");
    try addManaged(gpa, io, tmp_a.dir, &.{"one.txt"});
    const seed = try commitHashDup(gpa, io, tmp_a.dir, "seed");
    defer gpa.free(seed);

    const clone_port = try freshLoopbackPort(io);
    var clone_server = try spawnServe(gpa, io, tmp_a.dir, clone_port);
    try waitForListen(io, clone_port);
    const clone_url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/xfer", .{clone_port});
    defer gpa.free(clone_url);
    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", clone_url, "repo" });
    defer freeResult(gpa, &clone);
    try expectExitDiag(clone.term, 0, clone);
    clone_server.kill(io);
    var b_repo = try tmp_b.dir.openDir(io, "repo", .{});
    defer b_repo.close(io);
    try writeFile(io, b_repo, "two.txt", "grows trunk\n");
    try addManaged(gpa, io, b_repo, &.{"two.txt"});
    const grow = try commitHashDup(gpa, io, b_repo, "grow");
    defer gpa.free(grow);

    const a_before = try collectArtifactDigests(gpa, io, tmp_a.dir);
    defer freeDigests(gpa, a_before);
    const project = try projectCodeOf(gpa, io, b_repo);
    defer gpa.free(project);

    // The recovery: move the refused check-in, then push the same set again.
    // Strictly later than the pinned check-in time: a retag that ties its
    // target's timestamp does not win, in fossil or here.
    var am = try runCommitEnv(gpa, io, b_repo, .{ .user = "u", .epoch = "1234567891" }, &.{ "amend", grow, "--branch", "other" });
    defer freeResult(gpa, &am);
    try expectExitDiag(am.term, 0, am);
    {
        const files = try pushCardsFrom(gpa, io, b_repo, a_before);
        defer gpa.free(files);
        const request = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npush {s} {s}\n{s}", .{ repeat("c", 40), project, files });
        defer gpa.free(request);
        const port = try freshLoopbackPort(io);
        var server = try spawnServeFronted(gpa, io, tmp_a.dir, port, true);
        defer server.kill(io);
        try waitForListen(io, port);
        const reply = try postXferCardsHeaders(gpa, io, port, request, "X-Zit-Protect: trunk\r\n");
        defer gpa.free(reply);
        try std.testing.expect(!std.mem.startsWith(u8, reply, "error "));
        server.kill(io);
    }
    // A holds the check-in on `other`, and trunk's tip is still the seed.
    {
        var info = try runZit(gpa, io, tmp_a.dir, &.{ "info", grow });
        defer freeResult(gpa, &info);
        try expectExitDiag(info.term, 0, info);
        try std.testing.expect(std.mem.indexOf(u8, info.stdout, "branch:  other\n") != null);
        const trunk_tip = try tipHashOf(gpa, io, tmp_a.dir, "trunk");
        defer gpa.free(trunk_tip);
        try std.testing.expectEqualStrings(seed, trunk_tip);
    }

    // Not a loosening: the same move on a check-in A HOLDS on trunk is still
    // refused, because cancelling its sym is exactly how it would leave.
    const a_mid = try collectArtifactDigests(gpa, io, tmp_a.dir);
    defer freeDigests(gpa, a_mid);
    var am2 = try runCommitEnv(gpa, io, b_repo, .{ .user = "u", .epoch = "1234567892" }, &.{ "amend", seed, "--branch", "other" });
    defer freeResult(gpa, &am2);
    try expectExitDiag(am2.term, 0, am2);
    {
        const files = try pushCardsFrom(gpa, io, b_repo, a_mid);
        defer gpa.free(files);
        const request = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npush {s} {s}\n{s}", .{ repeat("c", 40), project, files });
        defer gpa.free(request);
        const port = try freshLoopbackPort(io);
        var server = try spawnServeFronted(gpa, io, tmp_a.dir, port, true);
        defer server.kill(io);
        try waitForListen(io, port);
        const reply = try postXferCardsHeaders(gpa, io, port, request, "X-Zit-Protect: trunk\r\n");
        defer gpa.free(reply);
        try std.testing.expect(std.mem.startsWith(u8, reply, "error "));
        try std.testing.expect(std.mem.indexOf(u8, reply, "'trunk'") != null);
        server.kill(io);
        const a_after = try collectArtifactDigests(gpa, io, tmp_a.dir);
        defer freeDigests(gpa, a_after);
        try std.testing.expectEqual(a_mid.len, a_after.len);
    }
}

test "cli serve: a branch check-in amended onto a protected branch is refused, and amended off it again lands" {
    // The pusher's own move onto trunk travels with every later push, so the
    // way out has to be judged by where the check-in ends up after all of its
    // moves, newest winning, the way the derive itself will place it. Judged
    // by the moves' names alone, the move onto trunk refused every push from
    // that checkout.
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try writeFile(io, tmp_a.dir, "one.txt", "seed\n");
    try addManaged(gpa, io, tmp_a.dir, &.{"one.txt"});
    const seed = try commitHashDup(gpa, io, tmp_a.dir, "seed");
    defer gpa.free(seed);

    const clone_port = try freshLoopbackPort(io);
    var clone_server = try spawnServe(gpa, io, tmp_a.dir, clone_port);
    try waitForListen(io, clone_port);
    const clone_url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/xfer", .{clone_port});
    defer gpa.free(clone_url);
    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", clone_url, "repo" });
    defer freeResult(gpa, &clone);
    try expectExitDiag(clone.term, 0, clone);
    clone_server.kill(io);
    var b_repo = try tmp_b.dir.openDir(io, "repo", .{});
    defer b_repo.close(io);
    try writeFile(io, b_repo, "two.txt", "on a branch\n");
    try addManaged(gpa, io, b_repo, &.{"two.txt"});
    var ci = try runCommitEnv(gpa, io, b_repo, .{ .user = "u", .epoch = "1234567891" }, &.{ "commit", "-m", "feature work", "--branch", "feat" });
    defer freeResult(gpa, &ci);
    try expectExitDiag(ci.term, 0, ci);
    const work = try gpa.dupe(u8, try checkinHash(ci.stdout));
    defer gpa.free(work);

    const a_before = try collectArtifactDigests(gpa, io, tmp_a.dir);
    defer freeDigests(gpa, a_before);
    const project = try projectCodeOf(gpa, io, b_repo);
    defer gpa.free(project);

    var onto = try runCommitEnv(gpa, io, b_repo, .{ .user = "u", .epoch = "1234567892" }, &.{ "amend", work, "--branch", "trunk" });
    defer freeResult(gpa, &onto);
    try expectExitDiag(onto.term, 0, onto);
    const refused = try pushProtected(gpa, io, tmp_a.dir, b_repo, a_before, project);
    defer gpa.free(refused);
    try std.testing.expect(std.mem.startsWith(u8, refused, "error "));
    try std.testing.expect(std.mem.indexOf(u8, refused, "'trunk'") != null);
    {
        const a_after = try collectArtifactDigests(gpa, io, tmp_a.dir);
        defer freeDigests(gpa, a_after);
        try std.testing.expectEqual(a_before.len, a_after.len);
    }

    var off = try runCommitEnv(gpa, io, b_repo, .{ .user = "u", .epoch = "1234567893" }, &.{ "amend", work, "--branch", "other" });
    defer freeResult(gpa, &off);
    try expectExitDiag(off.term, 0, off);
    const landed = try pushProtected(gpa, io, tmp_a.dir, b_repo, a_before, project);
    defer gpa.free(landed);
    try std.testing.expect(!std.mem.startsWith(u8, landed, "error "));
    {
        var info = try runZit(gpa, io, tmp_a.dir, &.{ "info", work });
        defer freeResult(gpa, &info);
        try expectExitDiag(info.term, 0, info);
        try std.testing.expect(std.mem.indexOf(u8, info.stdout, "branch:  other\n") != null);
        const trunk_tip = try tipHashOf(gpa, io, tmp_a.dir, "trunk");
        defer gpa.free(trunk_tip);
        try std.testing.expectEqualStrings(seed, trunk_tip);
    }
}

test "cli serve: a fronted divert refuses a push onto trunk once, then keeps it on an attempt branch and tells the front" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try writeFile(io, tmp_a.dir, "one.txt", "seed\n");
    try addManaged(gpa, io, tmp_a.dir, &.{"one.txt"});
    const seed = try commitHashDup(gpa, io, tmp_a.dir, "seed");
    defer gpa.free(seed);

    const clone_port = try freshLoopbackPort(io);
    var clone_server = try spawnServe(gpa, io, tmp_a.dir, clone_port);
    try waitForListen(io, clone_port);
    const clone_url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/xfer", .{clone_port});
    defer gpa.free(clone_url);
    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", clone_url, "repo" });
    defer freeResult(gpa, &clone);
    try expectExitDiag(clone.term, 0, clone);
    clone_server.kill(io);
    var b_repo = try tmp_b.dir.openDir(io, "repo", .{});
    defer b_repo.close(io);
    try writeFile(io, b_repo, "two.txt", "grows trunk\n");
    try addManaged(gpa, io, b_repo, &.{"two.txt"});
    const grow = try commitHashDup(gpa, io, b_repo, "grow");
    defer gpa.free(grow);
    const a_before = try collectArtifactDigests(gpa, io, tmp_a.dir);
    defer freeDigests(gpa, a_before);
    const project = try projectCodeOf(gpa, io, b_repo);
    defer gpa.free(project);
    const headers = "X-Zit-Protect: trunk\r\nX-Zit-Divert-Login: jan\r\n";

    {
        const got = try pushProtectedHead(gpa, io, tmp_a.dir, b_repo, a_before, project, headers);
        defer gpa.free(got.head);
        defer gpa.free(got.body);
        try std.testing.expect(std.mem.startsWith(u8, got.body, "error "));
        try std.testing.expect(std.mem.indexOf(u8, got.body, "attempt/jan/") != null);
        try std.testing.expect(std.ascii.findIgnoreCase(got.head, "x-zit-diverted") == null);
        const a_after = try collectArtifactDigests(gpa, io, tmp_a.dir);
        defer freeDigests(gpa, a_after);
        try std.testing.expectEqual(a_before.len, a_after.len);
    }
    {
        const got = try pushProtectedHead(gpa, io, tmp_a.dir, b_repo, a_before, project, headers);
        defer gpa.free(got.head);
        defer gpa.free(got.body);
        try std.testing.expect(!std.mem.startsWith(u8, got.body, "error "));
        try std.testing.expect(std.mem.indexOf(u8, got.body, "pragma zit-diverted ") != null);
        const want = try std.fmt.allocPrint(gpa, "x-zit-diverted: {s} attempt/jan/{s} trunk", .{ grow, grow[0..12] });
        defer gpa.free(want);
        try std.testing.expect(std.ascii.findIgnoreCase(got.head, want) != null);
    }
    {
        var info = try runZit(gpa, io, tmp_a.dir, &.{ "info", grow });
        defer freeResult(gpa, &info);
        try expectExitDiag(info.term, 0, info);
        const want = try std.fmt.allocPrint(gpa, "branch:  attempt/jan/{s}\n", .{grow[0..12]});
        defer gpa.free(want);
        try std.testing.expect(std.mem.indexOf(u8, info.stdout, want) != null);
        const trunk_tip = try tipHashOf(gpa, io, tmp_a.dir, "trunk");
        defer gpa.free(trunk_tip);
        try std.testing.expectEqualStrings(seed, trunk_tip);
    }
}

/// `pushProtected` with the front's headers spelled out, keeping the
/// response head.
fn pushProtectedHead(gpa: std.mem.Allocator, io: std.Io, served: std.Io.Dir, from: std.Io.Dir, except: []const []const u8, project: []const u8, headers: []const u8) !XferHead {
    const files = try pushCardsFrom(gpa, io, from, except);
    defer gpa.free(files);
    const request = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npush {s} {s}\n{s}", .{ repeat("c", 40), project, files });
    defer gpa.free(request);
    const port = try freshLoopbackPort(io);
    var server = try spawnServeFronted(gpa, io, served, port, true);
    defer server.kill(io);
    try waitForListen(io, port);
    return postXferCardsHead(gpa, io, port, request, headers);
}

/// Push everything `from` holds beyond `except` to a fronted server over
/// `served`, with trunk protected, and return the reply's cards.
fn pushProtected(gpa: std.mem.Allocator, io: std.Io, served: std.Io.Dir, from: std.Io.Dir, except: []const []const u8, project: []const u8) ![]u8 {
    const files = try pushCardsFrom(gpa, io, from, except);
    defer gpa.free(files);
    const request = try std.fmt.allocPrint(gpa, "pragma client-version 20000\npush {s} {s}\n{s}", .{ repeat("c", 40), project, files });
    defer gpa.free(request);
    const port = try freshLoopbackPort(io);
    var server = try spawnServeFronted(gpa, io, served, port, true);
    defer server.kill(io);
    try waitForListen(io, port);
    return postXferCardsHeaders(gpa, io, port, request, "X-Zit-Protect: trunk\r\n");
}

test "cli serve: a box whose own signed erasure passes its not-before reclaims between connections and stops serving the bytes" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    const names = try erasureOrigin(gpa, io, tmp.dir);
    defer gpa.free(names.secret);
    defer gpa.free(names.other);
    var a = try tmp.dir.openDir(io, "a", .{});
    defer a.close(io);
    // The box signs for itself, its 24 h delay ending a few seconds from now
    // on the server's own wall clock.
    const now = std.Io.Timestamp.now(io, .real).toSeconds();
    var at_buf: [24]u8 = undefined;
    const signed_at = try std.fmt.bufPrint(&at_buf, "{d}", .{now - zit.erasure.default_delay + 3});
    try erasureOk(gpa, io, a, .{ .epoch = signed_at, .key = erasure_seed_hex }, &.{ "shun", "--force", "--sign", names.secret });
    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, a, port);
    defer server.kill(io);
    try waitForListen(io, port);
    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);
    try erasureOk(gpa, io, tmp.dir, .{}, &.{ "clone", url, "early" });
    var early = try tmp.dir.openDir(io, "early", .{});
    defer early.close(io);
    try std.testing.expect(try storeHoldsArtifact(gpa, io, early, names.secret));

    // Each connection gives the server its between-connections turn.
    const start = std.Io.Clock.now(.awake, io).nanoseconds;
    while (try storeHoldsArtifact(gpa, io, a, names.secret)) {
        if (std.Io.Clock.now(.awake, io).nanoseconds - start > 20 * std.time.ns_per_s) return error.StillHeld;
        const reply = try postXferCards(gpa, io, port, "pragma client-version 20000\n");
        gpa.free(reply);
        io.sleep(.{ .nanoseconds = 200_000_000 }, .awake) catch {};
    }
    try erasureOk(gpa, io, tmp.dir, .{}, &.{ "clone", "--no-open", url, "late" });
    var late = try tmp.dir.openDir(io, "late", .{});
    defer late.close(io);
    try std.testing.expect(!try storeHoldsArtifact(gpa, io, late, names.secret));
}