@starlove/orbit 1.4.1 → 2.0.0

package/lib/store/conformance.js

@@ -0,0 +1,1449 @@
+/**
+ * The behaviour every OrbitStore and BlobStore must show, written once and
+ * run against each adapter: memory and SQLite in vitest, IndexedDB in real
+ * browsers too. It imports no test framework, so a stranger's adapter proves
+ * itself the same way:
+ *
+ *   registerStoreConformance({ describe, it }, "my adapter", () => ({ open: () => openMyStore(dir) }));
+ *
+ * Each case gets a fresh harness. `open()` gives a store over the harness's
+ * data; calling it again gives a second store over the same data, as a second
+ * process (or tab) would have, which is how the cases prove that writes are
+ * serialised and heard everywhere.
+ */
+import { isOrbitError } from "../core/errors.js";
+// Assertions
+class ConformanceFailure extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ConformanceFailure";
+    }
+}
+function show(value) {
+    try {
+        const text = JSON.stringify(value);
+        return text.length > 600 ? `${text.slice(0, 600)}…` : text;
+    }
+    catch {
+        return String(value);
+    }
+}
+function assert(condition, message) {
+    if (!condition)
+        throw new ConformanceFailure(message);
+}
+/** Equal values, and for objects exactly the same keys: an extra field fails too. */
+function same(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+        return false;
+    return keysA.every((key) => Object.hasOwn(b, key) && same(a[key], b[key]));
+}
+function assertEqual(actual, expected, message) {
+    if (!same(actual, expected)) {
+        throw new ConformanceFailure(`${message}\n  expected: ${show(expected)}\n  actual:   ${show(actual)}`);
+    }
+}
+async function assertRejects(action, code, message) {
+    let caught;
+    let rejected = false;
+    try {
+        await action();
+    }
+    catch (error) {
+        rejected = true;
+        caught = error;
+    }
+    assert(rejected, `${message}: expected OrbitError ${code}, but it resolved`);
+    const got = caught instanceof Error ? `${caught.name}: ${caught.message}` : String(caught);
+    assert(isOrbitError(caught) && caught.code === code, `${message}: expected OrbitError ${code}, got ${got}`);
+}
+/** Waits for `check` to hold: watchers hear other processes' writes a little later. */
+async function eventually(check, message, timeoutMs = 3000) {
+    const started = Date.now();
+    while (!check()) {
+        if (Date.now() - started > timeoutMs)
+            throw new ConformanceFailure(`${message} (waited ${timeoutMs} ms)`);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+}
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// Records
+const T0 = Date.UTC(2026, 0, 1);
+/** A time `n` seconds into the suite's day, so every case's times are fixed. */
+const at = (n) => new Date(T0 + n * 1000).toISOString();
+function boardRecord(id, slug, over = {}) {
+    return {
+        id,
+        slug,
+        name: `Board ${slug}`,
+        repo_url: "",
+        default_branch: "main",
+        project_notes: "",
+        agent_instructions: "",
+        ai_enabled: 1,
+        created_at: at(0),
+        updated_at: at(0),
+        ...over
+    };
+}
+function stateRecord(id, boardId, name, position, over = {}) {
+    return { id, board_id: boardId, name, position, is_default: 0, role: null, created_at: at(1), ...over };
+}
+function newTicket(id, boardId, stateId, over = {}) {
+    return {
+        id,
+        board_id: boardId,
+        title: `Card ${id}`,
+        description: "",
+        type: "task",
+        parent_ticket_id: null,
+        ai_plan: "",
+        plan_artifact_path: "",
+        implementation_summary: "",
+        implementation_artifact_path: "",
+        implementation_updates: "",
+        nebula_url: "",
+        state_id: stateId,
+        priority: 2,
+        created_by: "local",
+        created_at: at(10),
+        updated_at: at(10),
+        archived_at: null,
+        ...over
+    };
+}
+function ticketRecord(id, boardId, stateId, number, over = {}) {
+    return { ...newTicket(id, boardId, stateId, over), number };
+}
+function commentRecord(id, ticketId, over = {}) {
+    return { id, ticket_id: ticketId, author: "local", kind: "human_comment", body: `Comment ${id}`, omitted_for_ai: 0, created_at: at(20), ...over };
+}
+function eventRecord(id, ticketId, over = {}) {
+    return { id, ticket_id: ticketId, actor: "local", type: "ticket_updated", body_json: JSON.stringify({ n: id }), created_at: at(30), ...over };
+}
+function labelRecord(id, name, over = {}) {
+    return { id, board_id: "b1", name, color: "#000000", created_at: at(1), ...over };
+}
+function relationRecord(id, source, target, type = "relates_to", over = {}) {
+    return { id, source_ticket_id: source, target_ticket_id: target, type, created_at: at(2), ...over };
+}
+function crossRecord(id, source, board, target, over = {}) {
+    return { id, source_ticket_id: source, target_board_id: board, target_ticket_id: target, type: "blocked_by", created_at: at(2), ...over };
+}
+function entryRecord(id, over = {}) {
+    return {
+        id,
+        board_id: "b1",
+        type: "decision",
+        title: `Entry ${id}`,
+        body: "",
+        ticket_id: null,
+        created_by: "local",
+        created_at: at(40),
+        updated_at: at(40),
+        struck_at: null,
+        ...over
+    };
+}
+function verdictRecord(id, ticketId, over = {}) {
+    return {
+        id,
+        ticket_id: ticketId,
+        verdict: "PASS",
+        blocking_findings_json: "[]",
+        optional_findings_json: "[]",
+        evidence_commands_json: "[]",
+        reviewer_profile: "",
+        reviewer_session_id: "",
+        reviewed_commit_sha: "",
+        dispatch_run_id: "",
+        supersedes_prior_review_id: null,
+        created_by: "local",
+        created_at: at(3),
+        ...over
+    };
+}
+function attachmentRecord(id, ticketId, over = {}) {
+    return {
+        id,
+        ticket_id: ticketId,
+        board_id: "b1",
+        original_name: `${id}.png`,
+        stored_path: `tickets/${ticketId}/${id}.png`,
+        mime_type: "image/png",
+        size_bytes: 1,
+        sha256: "0",
+        created_by: "local",
+        created_at: at(3),
+        ...over
+    };
+}
+function documentFor(title, over = {}) {
+    return { title, description: "", type: "task", details: "", comments: "", ...over };
+}
+/**
+ * A board with three lanes (Todo, the default; Doing; Done, the done lane),
+ * made through the directory as Orbit makes boards.
+ */
+async function makeBoard(store, slug = "harbor", id = `board-${slug}`) {
+    const lanes = { todo: `${id}-todo`, doing: `${id}-doing`, done: `${id}-done` };
+    await store.boards.create(boardRecord(id, slug), async (w) => {
+        await w.states.insert(stateRecord(lanes.todo, id, "Todo", 0, { is_default: 1 }));
+        await w.states.insert(stateRecord(lanes.doing, id, "Doing", 1, { role: "in_progress" }));
+        await w.states.insert(stateRecord(lanes.done, id, "Done", 2, { role: "done" }));
+    });
+    return { board: await store.board(id), id, ...lanes };
+}
+/** Opens a store, runs `body`, and closes every store the case opened. */
+async function using(harness, body) {
+    const store = await harness.open();
+    try {
+        await body(store);
+    }
+    finally {
+        await store.close();
+    }
+}
+/** Two stores over the same data, as two processes would have. */
+async function usingTwo(harness, body) {
+    const here = await harness.open();
+    const there = await harness.open();
+    try {
+        await body(here, there);
+    }
+    finally {
+        await here.close();
+        await there.close();
+    }
+}
+function gate() {
+    let open = () => undefined;
+    const wait = new Promise((resolve) => {
+        open = resolve;
+    });
+    return { open, wait };
+}
+/** A first write that writes nothing but the board's own record. */
+const seedNothing = () => Promise.resolve();
+const numbersOf = (tickets) => tickets.map((ticket) => ticket.number);
+const idsOf = (records) => records.map((record) => record.id);
+// The cases
+export const storeConformanceCases = [
+    // The list of boards
+    {
+        name: "a new store lists no boards and answers null for any board it doesn't have",
+        async run(harness) {
+            await using(harness, async (store) => {
+                assertEqual(await store.boards.list(), [], "list() of a new store");
+                assertEqual(await store.boards.get("nope"), null, "get() of an unknown id");
+                assertEqual(await store.boards.bySlug("nope"), null, "bySlug() of an unknown slug");
+                assertEqual(await store.boards.latest(), null, "latest() with no boards");
+                await assertRejects(() => store.board("nope"), "board_not_found", "board() of an unknown id");
+            });
+        }
+    },
+    {
+        name: "makes a board with its first write and lists it",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const fields = { name: "Harbor Lights", repo_url: "https://example.com/h.git", default_branch: "trunk", created_at: at(5), updated_at: at(6) };
+                const record = boardRecord("b1", "harbor", fields);
+                const listed = await store.boards.create(record, async (w) => {
+                    await w.states.insert(stateRecord("s1", "b1", "Todo", 0));
+                });
+                const expected = { id: "b1", slug: "harbor", ...fields, last_active_at: at(5) };
+                assertEqual({ ...listed, db_path: undefined }, { ...expected, db_path: undefined }, "the listing create() returns");
+                assert(typeof listed.db_path === "string", "db_path is a string");
+                assertEqual(await store.boards.get("b1"), listed, "get()");
+                assertEqual(await store.boards.bySlug("harbor"), listed, "bySlug()");
+                assertEqual(await store.boards.list(), [listed], "list()");
+                const board = await store.board("b1");
+                assertEqual(await board.read((r) => r.board.get()), record, "the board's own record");
+                assertEqual(idsOf(await board.read((r) => r.states.list())), ["s1"], "what the first write made");
+            });
+        }
+    },
+    {
+        name: "refuses a slug or an id another board has, and leaves nothing of the attempt",
+        async run(harness) {
+            await using(harness, async (store) => {
+                await makeBoard(store, "harbor", "b1");
+                let seeded = false;
+                await assertRejects(() => store.boards.create(boardRecord("b2", "harbor"), () => { seeded = true; return Promise.resolve(); }), "board_slug_taken", "a second board named harbor");
+                await assertRejects(() => store.boards.create(boardRecord("b1", "other"), () => { seeded = true; return Promise.resolve(); }), "duplicate_id", "a second board with id b1");
+                assert(!seeded, "the refused boards' first writes never ran");
+                assertEqual(idsOf(await store.boards.list()), ["b1"], "only the first board is listed");
+                await assertRejects(() => store.board("b2"), "board_not_found", "the refused board");
+            });
+        }
+    },
+    {
+        name: "two boards made at once with one slug: exactly one is made",
+        async run(harness) {
+            await usingTwo(harness, async (here, there) => {
+                const results = await Promise.allSettled([
+                    here.boards.create(boardRecord("b1", "same"), async () => { await pause(5); }),
+                    there.boards.create(boardRecord("b2", "same"), async () => { await pause(5); })
+                ]);
+                const made = results.filter((result) => result.status === "fulfilled");
+                assertEqual(made.length, 1, "boards made");
+                const lost = results.find((result) => result.status === "rejected");
+                const refusal = lost?.reason;
+                assert(isOrbitError(refusal) && refusal.code === "board_slug_taken", `the other is refused with board_slug_taken, got ${String(refusal)}`);
+                assertEqual((await here.boards.list()).length, 1, "boards listed");
+            });
+        }
+    },
+    {
+        name: "a board whose first write throws is not made, and its slug stays free",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const failure = new Error("seed failed");
+                let caught;
+                try {
+                    await store.boards.create(boardRecord("b1", "harbor"), async (w) => {
+                        await w.states.insert(stateRecord("s1", "b1", "Todo", 0));
+                        throw failure;
+                    });
+                }
+                catch (error) {
+                    caught = error;
+                }
+                assert(caught === failure, "the seed's own error is rethrown");
+                assertEqual(await store.boards.list(), [], "nothing is listed");
+                await assertRejects(() => store.board("b1"), "board_not_found", "the board that wasn't made");
+                const { board } = await makeBoard(store, "harbor", "b1");
+                assertEqual(await board.read((r) => r.tickets.list()), [], "the same slug and id make a fresh board");
+            });
+        }
+    },
+    {
+        name: "lists boards by name in code-point order, then in the order they were made",
+        async run(harness) {
+            await using(harness, async (store) => {
+                for (const [id, name] of [["b1", "harbor"], ["b2", "Zebra"], ["b3", "Émile"], ["b4", "apple"], ["b5", "harbor"]]) {
+                    await store.boards.create(boardRecord(id, `slug-${id}`, { name }), seedNothing);
+                }
+                assertEqual(idsOf(await store.boards.list()), ["b2", "b4", "b1", "b5", "b3"], "list() order");
+            });
+        }
+    },
+    {
+        name: "latest() is the board used last, and among equals the one made last",
+        async run(harness) {
+            await using(harness, async (store) => {
+                await store.boards.create(boardRecord("b1", "one", { created_at: at(1) }), seedNothing);
+                await store.boards.create(boardRecord("b2", "two", { created_at: at(1) }), seedNothing);
+                assertEqual((await store.boards.latest())?.id, "b2", "two boards made at the same time");
+                await store.boards.touch("b1", at(50));
+                const one = await store.boards.get("b1");
+                assertEqual([one?.last_active_at, one?.updated_at], [at(50), at(50)], "touch() sets last_active_at and updated_at");
+                assertEqual((await store.boards.latest())?.id, "b1", "after b1 was used");
+                await assertRejects(() => store.boards.touch("nope", at(60)), "board_not_found", "touch() of an unknown board");
+            });
+        }
+    },
+    {
+        name: "the list follows the board's own record once its write commits",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board } = await makeBoard(store, "harbor", "b1");
+                await makeBoard(store, "side", "b2");
+                await board.write(async (w) => {
+                    await w.board.update({ slug: "lights", name: "Lights", repo_url: "https://example.com/l.git", default_branch: "dev", updated_at: at(70) });
+                });
+                const listed = await store.boards.get("b1");
+                assertEqual([listed?.slug, listed?.name, listed?.repo_url, listed?.default_branch, listed?.updated_at], ["lights", "Lights", "https://example.com/l.git", "dev", at(70)], "the listing after the write");
+                assertEqual((await store.boards.bySlug("lights"))?.id, "b1", "found by its new slug");
+                assertEqual(await store.boards.bySlug("harbor"), null, "not by its old one");
+                await assertRejects(() => board.write((w) => w.board.update({ slug: "side", name: "Taken" })), "board_slug_taken", "a slug another board has");
+                const after = [(await store.boards.get("b1"))?.slug, (await board.read((r) => r.board.get())).name];
+                assertEqual(after, ["lights", "Lights"], "the refused write changed nothing");
+            });
+        }
+    },
+    {
+        name: "a write that leaves the board's own record alone leaves its listing alone",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                await store.boards.touch("b1", at(50));
+                const before = await store.boards.get("b1");
+                await board.write(async (w) => {
+                    await w.tickets.create(newTicket("t1", "b1", todo));
+                    await w.events.append(eventRecord("e1", "t1", { created_at: at(60) }));
+                });
+                assertEqual(await store.boards.get("b1"), before, "the listing after a write to the board's cards");
+            });
+        }
+    },
+    {
+        name: "removes a board: off the list, its data gone, its slug free",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                await board.write((w) => w.tickets.create(newTicket("t1", "b1", todo)));
+                const { removed } = await store.boards.remove("b1");
+                assert(Array.isArray(removed) && removed.every((place) => typeof place === "string"), "remove() says what it deleted");
+                assertEqual(await store.boards.list(), [], "the list after remove()");
+                await assertRejects(() => store.board("b1"), "board_not_found", "board() of a removed board");
+                await assertRejects(() => board.read((r) => r.tickets.list()), "board_not_found", "a read through a store opened before the board was removed");
+                await assertRejects(() => store.boards.remove("b1"), "board_not_found", "removing it again");
+                const again = await makeBoard(store, "harbor", "b1");
+                assertEqual(await again.board.read((r) => r.tickets.list()), [], "a new board with its slug and id starts empty");
+            });
+        }
+    },
+    {
+        name: "keeps settings, shared by every store over the same data",
+        async run(harness) {
+            await usingTwo(harness, async (here, there) => {
+                assertEqual(await here.settings.get("default_board"), null, "an unset key");
+                await here.settings.set("default_board", "harbor");
+                assertEqual(await there.settings.get("default_board"), "harbor", "read through the other store");
+                await there.settings.set("default_board", "side");
+                assertEqual(await here.settings.get("default_board"), "side", "overwritten");
+            });
+        }
+    },
+    {
+        name: "locates the board holding a lane, card, journal entry or relation, looking at the hint first",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const a = await makeBoard(store, "alpha", "b1");
+                const b = await makeBoard(store, "beta", "b2");
+                await a.board.write(async (w) => {
+                    await w.tickets.create(newTicket("t1", "b1", a.todo));
+                    await w.tickets.create(newTicket("t2", "b1", a.todo));
+                    await w.relations.insert(relationRecord("r1", "t1", "t2"));
+                    await w.entries.insert(entryRecord("e1"));
+                });
+                // An import can bring a card id another board already has.
+                await b.board.write((w) => w.tickets.create(newTicket("t1", "b2", b.todo)));
+                assertEqual((await store.locate("state", b.doing))?.id, "b2", "a lane");
+                assertEqual((await store.locate("ticket", "t2"))?.id, "b1", "a card");
+                assertEqual((await store.locate("entry", "e1"))?.id, "b1", "a journal entry");
+                assertEqual((await store.locate("relation", "r1"))?.id, "b1", "a relation");
+                assertEqual((await store.locate("ticket", "t1"))?.id, "b1", "a card on two boards, without a hint: list() order");
+                assertEqual((await store.locate("ticket", "t1", "b2"))?.id, "b2", "with a hint");
+                assertEqual(await store.locate("ticket", "nope", "b1"), null, "an id nowhere");
+            });
+        }
+    },
+    // Records
+    {
+        name: "gives back every kind of record exactly as written, with no field added or lost",
+        async run(harness) {
+            await usingTwo(harness, async (store, other) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                await makeBoard(store, "side", "b2");
+                const text = "Ünïcödé 🌌 “quotes”, 'single', back\\slash,\nnew line\ttab and 漢字";
+                const ticket = ticketRecord("t1", "b1", todo, 7, {
+                    title: text,
+                    description: `${text}\n\n## Steps`,
+                    type: "epic",
+                    ai_plan: "1. plan",
+                    plan_artifact_path: "artifacts/plan.md",
+                    implementation_summary: "summary",
+                    implementation_artifact_path: "artifacts/summary.md",
+                    implementation_updates: "updates",
+                    nebula_url: "https://nebula.starscape.app/app/p/x/a.md",
+                    priority: 4,
+                    created_by: "crea",
+                    created_at: at(11),
+                    updated_at: at(12),
+                    archived_at: at(13)
+                });
+                const child = ticketRecord("t2", "b1", todo, 8, { type: "feature", parent_ticket_id: "t1", priority: 0 });
+                const label = labelRecord("l1", text, { color: "#123456", created_at: at(14) });
+                const comment = commentRecord("c1", "t2", { author: "crea", kind: "agent_note", body: text, omitted_for_ai: 1, created_at: at(15) });
+                const relation = relationRecord("r1", "t2", "t1", "loves", { created_at: at(16) });
+                const cross = crossRecord("x1", "t2", "b2", "elsewhere", { created_at: at(17) });
+                const entry = entryRecord("e1", {
+                    type: "lesson",
+                    title: text,
+                    body: text,
+                    ticket_id: "t2",
+                    created_at: at(18),
+                    updated_at: at(19),
+                    struck_at: at(20)
+                });
+                const first = {
+                    id: "v1",
+                    ticket_id: "t2",
+                    verdict: "BLOCK",
+                    blocking_findings_json: '["Plank 7"]',
+                    optional_findings_json: "[]",
+                    evidence_commands_json: '["pier --walk"]',
+                    reviewer_profile: "secu",
+                    reviewer_session_id: "s-1",
+                    reviewed_commit_sha: "abc123",
+                    dispatch_run_id: "run-1",
+                    supersedes_prior_review_id: null,
+                    created_by: "secu",
+                    created_at: at(21)
+                };
+                const second = { ...first, id: "v2", verdict: "PASS", supersedes_prior_review_id: "v1", created_at: at(22) };
+                const attachment = attachmentRecord("a1", "t2", { original_name: "roof.png", size_bytes: 1234, sha256: "f".repeat(64), created_at: at(23) });
+                const event = eventRecord("ev1", "t2", { actor: "crea", type: "agent_claimed", body_json: '{"agent_id":"crea","n":[1,2]}', created_at: at(24) });
+                const boardRow = boardRecord("b1", "harbor", { name: text, project_notes: text, agent_instructions: text, ai_enabled: 0, updated_at: at(25) });
+                await board.write(async (w) => {
+                    await w.tickets.insert(ticket);
+                    await w.tickets.insert(child);
+                    await w.labels.insert(label);
+                    await w.ticketLabels.add("t2", "l1");
+                    await w.comments.insert(comment);
+                    await w.relations.insert(relation);
+                    await w.crossBoardRelations.insert(cross);
+                    await w.entries.insert(entry);
+                    await w.verdicts.insert(first);
+                    await w.verdicts.insert(second);
+                    await w.attachments.insert(attachment);
+                    await w.events.append(event);
+                    await w.board.set(boardRow);
+                });
+                for (const [where, reading] of [["this store", board], ["another store", await other.board("b1")]]) {
+                    await reading.read(async (r) => {
+                        assertEqual(await r.board.get(), boardRow, `the board's record, through ${where}`);
+                        assertEqual(await r.tickets.get("t1"), ticket, `a card with every field set, through ${where}`);
+                        assertEqual(await r.tickets.get("t2"), child, `a sub-card, through ${where}`);
+                        assertEqual(await r.labels.list(), [label], `labels, through ${where}`);
+                        assertEqual(await r.ticketLabels.list(), [{ ticket_id: "t2", label_id: "l1" }], `label links, through ${where}`);
+                        assertEqual(await r.comments.get("c1"), comment, `a comment, through ${where}`);
+                        assertEqual(await r.relations.get("r1"), relation, `a relation of a type Orbit doesn't name, through ${where}`);
+                        assertEqual(await r.crossBoardRelations.list(), [cross], `a cross-board relation, through ${where}`);
+                        assertEqual(await r.entries.get("e1"), entry, `a journal entry, through ${where}`);
+                        assertEqual(await r.verdicts.list("t2"), [first, second], `review verdicts, through ${where}`);
+                        assertEqual(await r.attachments.get("a1"), attachment, `an image's record, through ${where}`);
+                        assertEqual(await r.events.list(), [event], `an event, through ${where}`);
+                    });
+                }
+            });
+        }
+    },
+    {
+        name: "hands out copies: changing a record after writing or reading it changes nothing stored",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                const written = ticketRecord("t1", "b1", todo, 1, { title: "Original" });
+                await board.write(async (w) => {
+                    await w.tickets.insert(written);
+                    written.title = "Changed after insert";
+                    const inside = await w.tickets.get("t1");
+                    if (inside)
+                        inside.title = "Changed inside the write";
+                });
+                const read = await board.read((r) => r.tickets.get("t1"));
+                assertEqual(read?.title, "Original", "the stored title");
+                if (read)
+                    read.title = "Changed after read";
+                const listed = await board.read((r) => r.tickets.list());
+                const first = listed[0];
+                if (first)
+                    first.priority = 4;
+                const again = await board.read((r) => r.tickets.get("t1"));
+                assertEqual([again?.title, again?.priority], ["Original", 2], "after changing what reads handed out");
+                const lanes = await board.read((r) => r.states.list());
+                lanes.reverse();
+                assertEqual(idsOf(await board.read((r) => r.states.list())), [todo, "b1-doing", "b1-done"], "a list handed out is the caller's");
+            });
+        }
+    },
+    {
+        name: "lists every kind of record in its stated order",
+        async run(harness) {
+            await usingTwo(harness, async (store, other) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                await board.write(async (w) => {
+                    await w.states.insert(stateRecord("s-mid", "b1", "Middle", 1));
+                    await w.states.update("b1-doing", { position: 5 });
+                    for (const [id, name] of [["l1", "tower"], ["l2", "Zebra"], ["l3", "électrique"], ["l4", "apple"]]) {
+                        await w.labels.insert(labelRecord(id, name));
+                    }
+                    for (const [id, number] of [["t3", 3], ["t1", 1], ["t2", 2]])
+                        await w.tickets.insert(ticketRecord(id, "b1", todo, number));
+                    await w.ticketLabels.set("t1", ["l1", "l4", "l3"]);
+                    // Times written out of order, and ties: by time, then the order written.
+                    await w.comments.insert(commentRecord("c-late", "t1", { created_at: at(30) }));
+                    await w.comments.insert(commentRecord("c-tie-1", "t1", { created_at: at(20) }));
+                    await w.comments.insert(commentRecord("c-early", "t1", { created_at: at(10) }));
+                    await w.comments.insert(commentRecord("c-tie-2", "t1", { created_at: at(20) }));
+                    await w.comments.insert(commentRecord("c-other", "t2", { created_at: at(15) }));
+                    await w.events.append(eventRecord("e-late", "t1", { created_at: at(30) }));
+                    await w.events.append(eventRecord("e-tie-1", "t1", { created_at: at(20) }));
+                    await w.events.append(eventRecord("e-early", null, { created_at: at(10) }));
+                    await w.events.append(eventRecord("e-tie-2", "t2", { created_at: at(20) }));
+                    for (const [id, time] of [["j-late", 30], ["j-tie-1", 20], ["j-tie-2", 20]]) {
+                        await w.entries.insert(entryRecord(id, { created_at: at(time), updated_at: at(time) }));
+                    }
+                    for (const [id, time] of [["r-late", 30], ["r-early", 10]]) {
+                        await w.relations.insert(relationRecord(id, "t1", id === "r-late" ? "t2" : "t3", "relates_to", { created_at: at(time) }));
+                    }
+                    for (const [id, time] of [["a-late", 30], ["a-early", 10]]) {
+                        await w.attachments.insert(attachmentRecord(id, "t2", { created_at: at(time) }));
+                    }
+                    for (const [id, time] of [["v-late", 30], ["v-tie-1", 20], ["v-tie-2", 20]]) {
+                        await w.verdicts.insert(verdictRecord(id, "t3", { created_at: at(time) }));
+                    }
+                });
+                // A later write links them again in another order: the order is the new one's.
+                await board.write((w) => w.ticketLabels.set("t2", ["l2", "l1"]));
+                await board.write((w) => w.ticketLabels.set("t2", ["l1", "l2"]));
+                for (const [where, reading] of [["this store", board], ["another store", await other.board("b1")]]) {
+                    await reading.read(async (r) => {
+                        assertEqual((await r.ticketLabels.list(["t2"])).map((link) => link.label_id), ["l1", "l2"], `links set again, in their new order, through ${where}`);
+                        assertEqual(idsOf(await r.states.list()), [todo, "s-mid", "b1-done", "b1-doing"], `lanes by position, then the order written, through ${where}`);
+                        assertEqual(idsOf(await r.labels.list()), ["l2", "l4", "l1", "l3"], `labels by name in code-point order, through ${where}`);
+                        assertEqual(numbersOf(await r.tickets.list()), [1, 2, 3], `cards by number, through ${where}`);
+                        assertEqual((await r.ticketLabels.list(["t1"])).map((link) => link.label_id), ["l1", "l4", "l3"], `a card's labels in the order they were linked, through ${where}`);
+                        assertEqual(idsOf(await r.comments.list("t1")), ["c-early", "c-tie-1", "c-tie-2", "c-late"], `a card's comments, through ${where}`);
+                        assertEqual(idsOf(await r.comments.list()), ["c-early", "c-other", "c-tie-1", "c-tie-2", "c-late"], `every comment on the board, through ${where}`);
+                        assertEqual(idsOf(await r.events.list()), ["e-early", "e-tie-1", "e-tie-2", "e-late"], `events, through ${where}`);
+                        assertEqual(idsOf(await r.entries.list()), ["j-tie-1", "j-tie-2", "j-late"], `journal entries, through ${where}`);
+                        assertEqual(idsOf(await r.relations.list()), ["r-early", "r-late"], `relations, through ${where}`);
+                        assertEqual(idsOf(await r.attachments.list()), ["a-early", "a-late"], `images, through ${where}`);
+                        assertEqual(idsOf(await r.verdicts.list("t3")), ["v-tie-1", "v-tie-2", "v-late"], `verdicts, through ${where}`);
+                    });
+                }
+            });
+        }
+    },
+    // Cards
+    {
+        name: "finds cards by id, number and title, ignoring the case of ASCII letters only",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                await board.write(async (w) => {
+                    await w.tickets.insert(ticketRecord("t1", "b1", todo, 1, { title: "Lamp Check" }));
+                    await w.tickets.insert(ticketRecord("t2", "b1", todo, 2, { title: "lamp check" }));
+                    await w.tickets.insert(ticketRecord("t3", "b1", todo, 3, { title: "LAMP CHECK", archived_at: at(5) }));
+                    await w.tickets.insert(ticketRecord("t4", "b1", todo, 4, { title: "Émile" }));
+                });
+                await board.read(async (r) => {
+                    assertEqual((await r.tickets.get("t4"))?.number, 4, "by id");
+                    assertEqual((await r.tickets.byNumber(2))?.id, "t2", "by number");
+                    assertEqual(await r.tickets.byNumber(9), null, "a number no card has");
+                    assertEqual((await r.tickets.byTitle("lAmP cHeCk"))?.id, "t2", "by title: open before archived, then the highest number");
+                    assertEqual((await r.tickets.byTitle("Émile"))?.id, "t4", "a title outside ASCII, exactly");
+                    assertEqual(await r.tickets.byTitle("émile"), null, "letters outside ASCII keep their case");
+                    assertEqual(await r.tickets.byTitle("Lamp"), null, "only the whole title matches");
+                });
+            });
+        }
+    },
+    {
+        name: "lists cards by every filter given",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo, doing } = await makeBoard(store, "harbor", "b1");
+                await board.write(async (w) => {
+                    await w.tickets.insert(ticketRecord("epic", "b1", todo, 1, { type: "epic" }));
+                    await w.tickets.insert(ticketRecord("t2", "b1", doing, 2, { parent_ticket_id: "epic" }));
+                    await w.tickets.insert(ticketRecord("t3", "b1", todo, 3, { parent_ticket_id: "epic", archived_at: at(9) }));
+                    await w.tickets.insert(ticketRecord("t4", "b1", doing, 4));
+                });
+                await board.read(async (r) => {
+                    assertEqual(numbersOf(await r.tickets.list()), [1, 2, 3, 4], "no filter: archived cards too");
+                    assertEqual(numbersOf(await r.tickets.list({ archived: false })), [1, 2, 4], "open cards");
+                    assertEqual(numbersOf(await r.tickets.list({ archived: true })), [3], "archived cards");
+                    assertEqual(numbersOf(await r.tickets.list({ parent: "epic" })), [2, 3], "an epic's sub-cards");
+                    assertEqual(numbersOf(await r.tickets.list({ parent: "epic", archived: false })), [2], "its open sub-cards");
+                    assertEqual(numbersOf(await r.tickets.list({ state: doing })), [2, 4], "a lane's cards");
+                    assertEqual(numbersOf(await r.tickets.list({ ids: ["t4", "nope", "epic"] })), [1, 4], "chosen cards, unknown ids skipped");
+                    assertEqual(numbersOf(await r.tickets.list({ ids: [] })), [], "no ids, no cards");
+                });
+            });
+        }
+    },
+    {
+        name: "numbers a new card one past the highest number on the board, archived cards included",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                assertEqual(await board.read((r) => r.tickets.lastNumber()), 0, "an empty board");
+                const first = await board.write((w) => w.tickets.create(newTicket("t1", "b1", todo)));
+                assertEqual(first, ticketRecord("t1", "b1", todo, 1), "the first card, as create() returns it");
+                await board.write((w) => w.tickets.insert(ticketRecord("t41", "b1", todo, 41, { archived_at: at(3) })));
+                assertEqual(await board.read((r) => r.tickets.lastNumber()), 41, "lastNumber() counts archived cards");
+                const next = await board.write((w) => w.tickets.create(newTicket("t2", "b1", todo)));
+                assertEqual(next.number, 42, "after an archived #41");
+                await board.write((w) => w.tickets.remove("t2"));
+                const reused = await board.write((w) => w.tickets.create(newTicket("t3", "b1", todo)));
+                assertEqual(reused.number, 42, "removing the highest card frees its number, as one past the highest says");
+                await assertRejects(() => board.write((w) => w.tickets.insert(ticketRecord("t9", "b1", todo, 42))), "ticket_number_taken", "inserting a number in use");
+            });
+        }
+    },
+    {
+        name: "twenty cards made at once, through two stores, get twenty different numbers",
+        async run(harness) {
+            await usingTwo(harness, async (here, there) => {
+                const { todo } = await makeBoard(here, "harbor", "b1");
+                const boards = [await here.board("b1"), await there.board("b1")];
+                const made = await Promise.all(Array.from({ length: 20 }, (_, i) => boards[i % 2].write(async (w) => {
+                    const top = await w.tickets.lastNumber();
+                    await pause(i % 3);
+                    const ticket = await w.tickets.create(newTicket(`t${i}`, "b1", todo));
+                    assert(ticket.number === top + 1, `a write's card follows what it read: ${top} then ${ticket.number}`);
+                    return ticket.number;
+                })));
+                assertEqual([...made].sort((a, b) => a - b), Array.from({ length: 20 }, (_, i) => i + 1), "the numbers given");
+                const stored = await (await here.board("b1")).read((r) => r.tickets.list());
+                assertEqual(numbersOf(stored), Array.from({ length: 20 }, (_, i) => i + 1), "the numbers stored");
+            });
+        }
+    },
+    {
+        name: "changes only the fields a patch names, and returns the record",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo, doing } = await makeBoard(store, "harbor", "b1");
+                await board.write((w) => w.tickets.insert(ticketRecord("t1", "b1", todo, 1, { title: "Keep", description: "Old", priority: 3 })));
+                const updated = await board.write((w) => w.tickets.update("t1", { description: "New", state_id: doing, title: undefined, updated_at: at(50) }));
+                const expected = ticketRecord("t1", "b1", doing, 1, { title: "Keep", description: "New", priority: 3, updated_at: at(50) });
+                assertEqual(updated, expected, "what update() returns");
+                assertEqual(await board.read((r) => r.tickets.get("t1")), expected, "what is stored");
+                const lane = await board.write((w) => w.states.update(todo, { name: "To do", role: "ai_ready" }));
+                assertEqual(lane, stateRecord(todo, "b1", "To do", 0, { is_default: 1, role: "ai_ready" }), "a lane's update");
+                const comment = await board.write(async (w) => {
+                    await w.comments.insert(commentRecord("c1", "t1"));
+                    return w.comments.update("c1", { omitted_for_ai: 1 });
+                });
+                assertEqual(comment, commentRecord("c1", "t1", { omitted_for_ai: 1 }), "a comment hidden from agents");
+                const board2 = await board.write((w) => w.board.update({ agent_instructions: "Be brief." }));
+                assertEqual(board2, boardRecord("b1", "harbor", { agent_instructions: "Be brief." }), "the board's update");
+                const entry = await board.write(async (w) => {
+                    await w.entries.insert(entryRecord("e1", { title: "LED", created_at: at(1), updated_at: at(1) }));
+                    return w.entries.update("e1", { struck_at: at(2), updated_at: at(2) });
+                });
+                assertEqual([entry.struck_at, entry.updated_at, entry.title], [at(2), at(2), "LED"], "a struck journal entry");
+            });
+        }
+    },
+    {
+        name: "removing a card removes what belongs to it and keeps its history",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                await makeBoard(store, "side", "b2");
+                await board.write(async (w) => {
+                    await w.tickets.insert(ticketRecord("epic", "b1", todo, 1, { type: "epic" }));
+                    await w.tickets.insert(ticketRecord("t2", "b1", todo, 2, { parent_ticket_id: "epic" }));
+                    await w.tickets.insert(ticketRecord("t3", "b1", todo, 3));
+                    await w.labels.insert(labelRecord("l1", "tower"));
+                    await w.ticketLabels.add("epic", "l1");
+                    await w.ticketLabels.add("t3", "l1");
+                    await w.comments.insert(commentRecord("c1", "epic"));
+                    await w.comments.insert(commentRecord("c3", "t3"));
+                    await w.relations.insert(relationRecord("r-out", "epic", "t3", "blocks"));
+                    await w.relations.insert(relationRecord("r-in", "t3", "epic"));
+                    await w.crossBoardRelations.insert(crossRecord("x1", "epic", "b2", "far"));
+                    await w.verdicts.insert(verdictRecord("v1", "epic"));
+                    await w.attachments.insert(attachmentRecord("a1", "epic"));
+                    await w.events.append(eventRecord("ev1", "epic"));
+                    await w.events.append(eventRecord("ev3", "t3"));
+                    await w.entries.insert(entryRecord("j1", { type: "lesson", ticket_id: "epic" }));
+                    await w.search.index("epic", documentFor("Relight the tower"));
+                    await w.search.index("t3", documentFor("Paint the tower"));
+                });
+                await board.write((w) => w.tickets.remove("epic"));
+                await board.read(async (r) => {
+                    assertEqual(await r.tickets.get("epic"), null, "the card");
+                    assertEqual((await r.tickets.get("t2"))?.parent_ticket_id, "epic", "its sub-card keeps its parent id");
+                    assertEqual(await r.ticketLabels.list(), [{ ticket_id: "t3", label_id: "l1" }], "label links");
+                    assertEqual(idsOf(await r.labels.list()), ["l1"], "the label itself stays");
+                    assertEqual(await r.comments.list("epic"), [], "its comments");
+                    assertEqual(idsOf(await r.comments.list("t3")), ["c3"], "another card's comments");
+                    assertEqual(await r.relations.list(), [], "relations either way");
+                    assertEqual(await r.crossBoardRelations.list(), [], "cross-board relations from it");
+                    assertEqual(await r.verdicts.list(), [], "its verdicts");
+                    assertEqual(await r.attachments.list(), [], "its images' records");
+                    assertEqual((await r.events.list()).map((event) => [event.id, event.ticket_id]), [["ev1", null], ["ev3", "t3"]], "events stay, unlinked");
+                    assertEqual((await r.entries.get("j1"))?.ticket_id, null, "journal entries stay, unlinked");
+                    assertEqual((await r.search.query("tower", { limit: 10 })).map((hit) => hit.ticket_id), ["t3"], "its index entry");
+                });
+                await assertRejects(() => board.write((w) => w.tickets.remove("epic")), "ticket_not_found", "removing it again");
+            });
+        }
+    },
+    {
+        name: "refuses duplicates with their codes",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo, doing } = await makeBoard(store, "harbor", "b1");
+                await board.write(async (w) => {
+                    await w.tickets.insert(ticketRecord("t1", "b1", todo, 1));
+                    await w.tickets.insert(ticketRecord("t2", "b1", todo, 2));
+                    await w.labels.insert(labelRecord("l1", "tower"));
+                    await w.comments.insert(commentRecord("c1", "t1"));
+                    await w.events.append(eventRecord("e1", "t1"));
+                    await w.relations.insert(relationRecord("r1", "t1", "t2", "blocks"));
+                    await w.crossBoardRelations.insert(crossRecord("x1", "t1", "b9", "far"));
+                });
+                const refused = async (code, what, body) => {
+                    await assertRejects(() => board.write(body), code, what);
+                };
+                await refused("duplicate_id", "a card id", (w) => w.tickets.create(newTicket("t1", "b1", todo)));
+                await refused("duplicate_id", "a lane id", (w) => w.states.insert(stateRecord(todo, "b1", "Other", 9)));
+                await refused("duplicate_id", "a comment id", (w) => w.comments.insert(commentRecord("c1", "t2")));
+                await refused("duplicate_id", "an event id", (w) => w.events.append(eventRecord("e1", null)));
+                await refused("duplicate_id", "a label id", (w) => w.labels.insert(labelRecord("l1", "other")));
+                await refused("state_name_taken", "a lane named as another", (w) => w.states.insert(stateRecord("s9", "b1", "Doing", 9)));
+                await refused("state_name_taken", "renaming a lane to another's name", (w) => w.states.update(todo, { name: "Doing" }));
+                await refused("label_name_taken", "a label named as another", (w) => w.labels.insert(labelRecord("l2", "tower")));
+                await refused("relation_exists", "the same relation again", (w) => w.relations.insert(relationRecord("r2", "t1", "t2", "blocks")));
+                await refused("relation_exists", "the same cross-board relation again", (w) => w.crossBoardRelations.insert(crossRecord("x2", "t1", "b9", "far")));
+                await refused("state_has_tickets", "removing a lane with cards", async (w) => {
+                    await w.tickets.update("t1", { archived_at: at(3) });
+                    await w.tickets.update("t2", { state_id: doing });
+                    await w.states.remove(todo);
+                });
+                await board.write(async (w) => {
+                    await w.relations.insert(relationRecord("r3", "t2", "t1", "blocks"));
+                    await w.relations.insert(relationRecord("r4", "t1", "t2"));
+                    await w.ticketLabels.add("t1", "l1");
+                    await w.ticketLabels.add("t1", "l1");
+                });
+                assertEqual((await board.read((r) => r.ticketLabels.list())).length, 1, "adding a label link twice keeps one");
+                assertEqual((await board.read((r) => r.relations.list())).length, 3, "the other direction and another type are other relations");
+            });
+        }
+    },
+    {
+        name: "refuses records naming what the board doesn't have, and takes what it doesn't check",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                await makeBoard(store, "side", "b2");
+                await board.write((w) => w.tickets.insert(ticketRecord("t1", "b1", todo, 1)));
+                const refused = (what, body) => assertRejects(() => board.write(body), "invalid_reference", what);
+                await refused("a card in a lane the board doesn't have", (w) => w.tickets.create(newTicket("t2", "b1", "b2-todo")));
+                await refused("a card moved to such a lane", (w) => w.tickets.update("t1", { state_id: "nope" }));
+                await refused("a card of another board", (w) => w.tickets.insert(ticketRecord("t3", "b2", todo, 3)));
+                await refused("a lane of another board", (w) => w.states.insert(stateRecord("s9", "b2", "Elsewhere", 9)));
+                await refused("a label of another board", (w) => w.labels.insert(labelRecord("l9", "x", { board_id: "b2" })));
+                await refused("a comment on a missing card", (w) => w.comments.insert(commentRecord("c1", "nope")));
+                await refused("a link to a missing label", (w) => w.ticketLabels.add("t1", "nope"));
+                await refused("a link from a missing card", async (w) => {
+                    await w.labels.insert(labelRecord("l1", "tower"));
+                    await w.ticketLabels.set("nope", ["l1"]);
+                });
+                await refused("a relation to a missing card", (w) => w.relations.insert(relationRecord("r1", "t1", "nope", "blocks")));
+                await refused("a cross-board relation from a missing card", (w) => w.crossBoardRelations.insert(crossRecord("x1", "nope", "b2", "t9")));
+                await refused("an event about a missing card", (w) => w.events.append(eventRecord("e1", "nope")));
+                await refused("a journal entry about a missing card", (w) => w.entries.insert(entryRecord("j1", { ticket_id: "nope" })));
+                await refused("an image of a missing card", (w) => w.attachments.insert(attachmentRecord("a1", "nope")));
+                await refused("a verdict superseding a missing verdict", (w) => w.verdicts.insert(verdictRecord("v1", "t1", { supersedes_prior_review_id: "nope" })));
+                await refused("the board's record with another board's id", async (w) => w.board.set(boardRecord("b2", "harbor")));
+                await board.write(async (w) => {
+                    await w.tickets.insert(ticketRecord("t5", "b1", todo, 5, { parent_ticket_id: "gone" }));
+                    await w.crossBoardRelations.insert(crossRecord("x5", "t5", "b2", "not-checked", { type: "relates_to" }));
+                });
+                assertEqual((await board.read((r) => r.tickets.get("t5")))?.parent_ticket_id, "gone", "a card's epic isn't checked");
+                assertEqual(numbersOf(await board.read((r) => r.tickets.list())), [1, 5], "nothing else was written");
+            });
+        }
+    },
+    {
+        name: "updating or removing what isn't there answers its kind's not-found code",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board } = await makeBoard(store, "harbor", "b1");
+                const missing = async (code, body) => {
+                    await assertRejects(() => board.write(body), code, code);
+                };
+                await missing("state_not_found", (w) => w.states.update("nope", { name: "x" }));
+                await missing("state_not_found", (w) => w.states.remove("nope"));
+                await missing("ticket_not_found", (w) => w.tickets.update("nope", { title: "x" }));
+                await missing("ticket_not_found", (w) => w.tickets.remove("nope"));
+                await missing("comment_not_found", (w) => w.comments.update("nope", { omitted_for_ai: 1 }));
+                await missing("relation_not_found", (w) => w.relations.remove("nope"));
+                await missing("relation_not_found", (w) => w.crossBoardRelations.remove("nope"));
+                await missing("board_entry_not_found", (w) => w.entries.update("nope", { struck_at: null }));
+                await missing("board_entry_not_found", (w) => w.entries.remove("nope"));
+                await missing("attachment_not_found", (w) => w.attachments.remove("nope"));
+            });
+        }
+    },
+    {
+        name: "removes a lane, an image and relations by id",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo, doing } = await makeBoard(store, "harbor", "b1");
+                await board.write(async (w) => {
+                    await w.tickets.insert(ticketRecord("t1", "b1", todo, 1));
+                    await w.tickets.insert(ticketRecord("t2", "b1", todo, 2));
+                    await w.relations.insert(relationRecord("r1", "t1", "t2", "blocks"));
+                    await w.crossBoardRelations.insert(crossRecord("x1", "t1", "b9", "far"));
+                    await w.attachments.insert(attachmentRecord("a1", "t1"));
+                });
+                await board.write(async (w) => {
+                    await w.states.remove(doing);
+                    await w.relations.remove("r1");
+                    await w.crossBoardRelations.remove("x1");
+                    await w.attachments.remove("a1");
+                });
+                await board.read(async (r) => {
+                    assertEqual(idsOf(await r.states.list()), [todo, "b1-done"], "lanes");
+                    assertEqual([await r.relations.list(), await r.crossBoardRelations.list(), await r.attachments.list()], [[], [], []], "relations and images");
+                    assertEqual(numbersOf(await r.tickets.list()), [1, 2], "the cards stay");
+                });
+            });
+        }
+    },
+    {
+        name: "removes a journal entry by id, and only that one",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board } = await makeBoard(store, "harbor", "b1");
+                await board.write(async (w) => {
+                    await w.entries.insert(entryRecord("e1", { title: "Keep", created_at: at(1), updated_at: at(1) }));
+                    await w.entries.insert(entryRecord("e2", { title: "Go", created_at: at(2), updated_at: at(2), struck_at: at(3) }));
+                });
+                await board.write((w) => w.entries.remove("e2"));
+                await board.read(async (r) => {
+                    assertEqual(idsOf(await r.entries.list()), ["e1"], "the journal after the removal");
+                    assertEqual(await r.entries.get("e2"), null, "the removed entry");
+                });
+            });
+        }
+    },
+    {
+        name: "counts each card's comments, leaving out hidden ones and one text when asked",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                const claim = "Agent claimed this ticket and is starting work.";
+                await board.write(async (w) => {
+                    for (const id of ["t1", "t2", "t3"])
+                        await w.tickets.create(newTicket(id, "b1", todo));
+                    await w.comments.insert(commentRecord("c1", "t1"));
+                    await w.comments.insert(commentRecord("c2", "t1", { omitted_for_ai: 1 }));
+                    await w.comments.insert(commentRecord("c3", "t1", { body: claim }));
+                    await w.comments.insert(commentRecord("c4", "t2", { omitted_for_ai: 1 }));
+                });
+                const counts = async (options) => Object.fromEntries((await board.read((r) => r.comments.countByTicket(options))).map((row) => [row.ticket_id, row.count]));
+                assertEqual(await counts(), { t1: 3, t2: 1 }, "every comment, cards with none left out");
+                assertEqual(await counts({ forAgents: true }), { t1: 2 }, "the ones agents may read");
+                assertEqual(await counts({ forAgents: true, exceptBody: claim }), { t1: 1 }, "without claim notes");
+            });
+        }
+    },
+    {
+        name: "reads events by card, type and time, the newest per card, and those after one",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                const work = ["agent_claimed", "state_changed"];
+                await board.write(async (w) => {
+                    for (const id of ["t1", "t2", "t3"])
+                        await w.tickets.create(newTicket(id, "b1", todo));
+                    await w.events.append(eventRecord("e1", "t1", { type: "agent_claimed", created_at: at(10) }));
+                    await w.events.append(eventRecord("e2", "t1", { type: "comment_created", created_at: at(20) }));
+                    await w.events.append(eventRecord("e3", "t2", { type: "state_changed", created_at: at(20) }));
+                    await w.events.append(eventRecord("e4", "t2", { type: "agent_claimed", created_at: at(20) }));
+                    await w.events.append(eventRecord("e5", null, { type: "board_updated", created_at: at(30) }));
+                    await w.events.append(eventRecord("e0", "t1", { type: "state_changed", created_at: at(5) }));
+                });
+                await board.read(async (r) => {
+                    assertEqual(idsOf(await r.events.list({ ticketId: "t1" })), ["e0", "e1", "e2"], "a card's");
+                    assertEqual(idsOf(await r.events.list({ types: work })), ["e0", "e1", "e3", "e4"], "of some types");
+                    assertEqual(idsOf(await r.events.list({ since: at(20) })), ["e2", "e3", "e4", "e5"], "since a time, that time included");
+                    assertEqual(idsOf(await r.events.list({ ticketId: "t1", types: work, since: at(6) })), ["e1"], "every filter at once");
+                    const newest = idsOf(await r.events.latest(["t1", "t2", "t3"], work));
+                    assertEqual(newest, ["e1", "e4"], "the newest work event per card, a tie going to the one appended last");
+                    assertEqual(idsOf(await r.events.after("e2", 2)), ["e3", "e4"], "after one, in the order appended, up to the limit");
+                    assertEqual(idsOf(await r.events.after("e5", 10)), ["e0"], "appended order, not time order");
+                    assertEqual(await r.events.after("nope", 10), [], "after an id the board doesn't have");
+                    assertEqual((await r.events.last())?.id, "e0", "the last appended");
+                });
+            });
+        }
+    },
+    {
+        name: "clear() empties the board, and a write can fill it again",
+        async run(harness) {
+            await usingTwo(harness, async (store, other) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                await board.write(async (w) => {
+                    await w.tickets.create(newTicket("t1", "b1", todo));
+                    await w.events.append(eventRecord("e1", "t1"));
+                    await w.search.index("t1", documentFor("Lamp"));
+                });
+                const replaced = boardRecord("b1", "harbor", { name: "Replaced", updated_at: at(90) });
+                await board.write(async (w) => {
+                    await w.clear();
+                    await assertRejects(() => w.board.get(), "board_not_found", "the board's record right after clear()");
+                    assertEqual([await w.states.list(), await w.tickets.list(), await w.events.list()], [[], [], []], "everything else");
+                    await w.board.set(replaced);
+                    await w.states.insert(stateRecord("s1", "b1", "Only", 0));
+                    await w.tickets.insert(ticketRecord("t9", "b1", "s1", 9));
+                });
+                for (const [where, reading] of [["this store", board], ["another store", await other.board("b1")]]) {
+                    await reading.read(async (r) => {
+                        assertEqual(await r.board.get(), replaced, `the board's new record, through ${where}`);
+                        assertEqual(idsOf(await r.tickets.list()), ["t9"], `its cards, through ${where}`);
+                        assertEqual(await r.events.list(), [], `the old events, through ${where}`);
+                        assertEqual(await r.search.query("lamp", { limit: 5 }), [], `the old index, through ${where}`);
+                    });
+                }
+                assertEqual((await store.boards.get("b1"))?.name, "Replaced", "the list follows");
+            });
+        }
+    },
+    // Cross-board relations
+    {
+        name: "keeps a cross-board relation on its source's board and finds it from the target's",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const a = await makeBoard(store, "alpha", "b1");
+                const b = await makeBoard(store, "beta", "b2");
+                const c = await makeBoard(store, "gamma", "b3");
+                await b.board.write((w) => w.tickets.create(newTicket("target", "b2", b.todo)));
+                await a.board.write(async (w) => {
+                    await w.tickets.create(newTicket("blocked", "b1", a.todo));
+                    await w.crossBoardRelations.insert(crossRecord("x1", "blocked", "b2", "target", { created_at: at(1) }));
+                });
+                await c.board.write(async (w) => {
+                    await w.tickets.create(newTicket("related", "b3", c.todo));
+                    await w.crossBoardRelations.insert(crossRecord("x2", "related", "b2", "target", { type: "relates_to", created_at: at(0) }));
+                });
+                const expected = [
+                    { board_id: "b1", relation: crossRecord("x1", "blocked", "b2", "target", { created_at: at(1) }) },
+                    { board_id: "b3", relation: crossRecord("x2", "related", "b2", "target", { type: "relates_to", created_at: at(0) }) }
+                ];
+                assertEqual(await store.relationsInto("b2"), expected, "the relations into beta, board by board");
+                assertEqual(await store.relationsInto("b1"), [], "none into alpha");
+                assertEqual(idsOf(await a.board.read((r) => r.crossBoardRelations.list("blocked"))), ["x1"], "on the source's board");
+                assertEqual(await b.board.read((r) => r.crossBoardRelations.list()), [], "nothing on the target's board");
+                await b.board.write((w) => w.tickets.remove("target"));
+                assertEqual(idsOf(await a.board.read((r) => r.crossBoardRelations.list())), ["x1"], "removing the target leaves it (it reads as resolved)");
+                await a.board.write((w) => w.tickets.remove("blocked"));
+                assertEqual(idsOf((await store.relationsInto("b2")).map((row) => row.relation)), ["x2"], "removing the source removes it");
+            });
+        }
+    },
+    // Search
+    {
+        name: "finds open cards by the start of every word, in any field and case",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                await board.write(async (w) => {
+                    for (const id of ["t1", "t2", "t3", "t4", "t5"])
+                        await w.tickets.create(newTicket(id, "b1", todo));
+                    await w.tickets.update("t5", { archived_at: at(5) });
+                    await w.search.index("t1", documentFor("Replace the lamp HOUSING", { description: "North tower" }));
+                    await w.search.index("t2", documentFor("Paint", { type: "bug", details: "Primer first" }));
+                    await w.search.index("t3", documentFor("Wiring", { comments: "Checked the torque table" }));
+                    await w.search.index("t4", documentFor("Café lights", { description: "lamp" }));
+                    await w.search.index("t5", documentFor("Old lamp housing"));
+                });
+                const found = async (query, limit = 10) => (await board.read((r) => r.search.query(query, { limit }))).map((hit) => hit.ticket_id).sort();
+                assertEqual(await found("lamp"), ["t1", "t4"], "a word in a title or description, archived cards left out");
+                assertEqual(await found("hous"), ["t1"], "the start of a word, in any case");
+                assertEqual(await found("LAMP tow"), ["t1"], "every word must match");
+                assertEqual(await found("prim"), ["t2"], "the details");
+                assertEqual(await found("bug"), ["t2"], "the type");
+                assertEqual(await found("torque"), ["t3"], "the comments given");
+                assertEqual(await found("cafe"), ["t4"], "a word with an accent, by its ASCII letters");
+                assertEqual(await found("amp"), [], "not the middle of a word");
+                assertEqual(await found("   "), [], "a blank query");
+                assertEqual((await found("lamp", 1)).length, 1, "at most the limit");
+                const hits = await board.read((r) => r.search.query("lamp", { limit: 10 }));
+                assert(hits.every((hit) => typeof hit.rank === "number" && Number.isFinite(hit.rank)), `ranks are numbers: ${show(hits)}`);
+            });
+        }
+    },
+    {
+        name: "matches a query with no words by its text alone, with % _ and \\ meaning only themselves",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                await board.write(async (w) => {
+                    for (const id of ["t1", "t2", "t3", "t4"])
+                        await w.tickets.create(newTicket(id, "b1", todo));
+                    await w.search.index("t1", documentFor("Discount", { comments: "40% off" }));
+                    await w.search.index("t2", documentFor("Paths", { description: "C:\\orbit" }));
+                    await w.search.index("t3", documentFor("Plain words"));
+                    await w.search.index("t4", documentFor("Snake", { details: "a__b" }));
+                });
+                const found = async (query) => (await board.read((r) => r.search.query(query, { limit: 10 }))).map((hit) => hit.ticket_id).sort();
+                assertEqual(await found("%"), ["t1"], "a percent sign");
+                assertEqual(await found("\\"), ["t2"], "a backslash");
+                assertEqual(await found("__"), ["t4"], "underscores");
+                assertEqual(await found("?"), [], "a sign no card has");
+            });
+        }
+    },
+    {
+        name: "words joined by _ are one word, found by their start and never by a later part",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                await board.write(async (w) => {
+                    for (const id of ["t1", "t2"])
+                        await w.tickets.create(newTicket(id, "b1", todo));
+                    await w.search.index("t1", documentFor("Rename snake_case keys"));
+                    await w.search.index("t2", documentFor("Upper case keys"));
+                });
+                const found = async (query) => (await board.read((r) => r.search.query(query, { limit: 10 }))).map((hit) => hit.ticket_id).sort();
+                assertEqual(await found("snake"), ["t1"], "the start of the joined word");
+                assertEqual(await found("snake_c"), ["t1"], "the start, the _ included");
+                assertEqual(await found("case"), ["t2"], "the part after the _ is no word of its own");
+                assertEqual(await found("keys"), ["t1", "t2"], "the words around it");
+            });
+        }
+    },
+    {
+        name: "a card's document is replaced when indexed again, and gone when removed",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                await board.write(async (w) => {
+                    await w.tickets.create(newTicket("t1", "b1", todo));
+                    await w.search.index("t1", documentFor("Lamp"));
+                    await w.search.index("t1", documentFor("Beacon"));
+                });
+                const found = async (query) => (await board.read((r) => r.search.query(query, { limit: 10 }))).map((hit) => hit.ticket_id);
+                assertEqual(await found("lamp"), [], "the old words");
+                assertEqual(await found("beacon"), ["t1"], "the new words");
+                await board.write((w) => w.search.remove("t1"));
+                assertEqual(await found("beacon"), [], "after remove()");
+            });
+        }
+    },
+    // Transactions: the contract owns the races
+    {
+        name: "a write that throws leaves nothing behind: no record, number, event or index entry",
+        async run(harness) {
+            await usingTwo(harness, async (here, there) => {
+                const { board, todo } = await makeBoard(here, "harbor", "b1");
+                const heard = [];
+                const stop = [board.watch((change) => heard.push(change.id)), (await there.board("b1")).watch((change) => heard.push(`there:${change.id}`))];
+                const failure = new Error("the body failed");
+                let caught;
+                try {
+                    await board.write(async (w) => {
+                        await w.tickets.create(newTicket("t1", "b1", todo));
+                        await w.comments.insert(commentRecord("c1", "t1"));
+                        await w.events.append(eventRecord("e-failed", "t1"));
+                        await w.search.index("t1", documentFor("Lamp"));
+                        await w.board.update({ name: "Renamed" });
+                        throw failure;
+                    });
+                }
+                catch (error) {
+                    caught = error;
+                }
+                assert(caught === failure, "write() rethrows the body's own error");
+                await board.read(async (r) => {
+                    assertEqual([await r.tickets.list(), await r.comments.list("t1"), await r.events.list()], [[], [], []], "records");
+                    assertEqual(await r.search.query("lamp", { limit: 5 }), [], "the index");
+                    assertEqual((await r.board.get()).name, "Board harbor", "the board's record");
+                });
+                assertEqual((await here.boards.get("b1"))?.name, "Board harbor", "the list");
+                const next = await board.write(async (w) => {
+                    const made = await w.tickets.create(newTicket("t2", "b1", todo));
+                    await w.events.append(eventRecord("e-ok", "t2"));
+                    return made;
+                });
+                assertEqual(next.number, 1, "the failed write used no number");
+                await eventually(() => heard.includes("e-ok") && heard.includes("there:e-ok"), "both stores hear the write that worked");
+                assertEqual(heard.filter((id) => id.endsWith("e-failed")), [], "no one heard the failed write's event");
+                for (const unsubscribe of stop)
+                    unsubscribe();
+            });
+        }
+    },
+    {
+        name: "a write's own reads see its changes before it commits",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                await board.write(async (w) => {
+                    const made = await w.tickets.create(newTicket("t1", "b1", todo));
+                    assertEqual(await w.tickets.get("t1"), made, "get() inside the write");
+                    assertEqual(numbersOf(await w.tickets.list({ archived: false })), [1], "list() inside the write");
+                    await w.tickets.update("t1", { title: "Renamed" });
+                    assertEqual((await w.tickets.byTitle("renamed"))?.id, "t1", "byTitle() after an update");
+                    await w.events.append(eventRecord("e1", "t1"));
+                    assertEqual(idsOf(await w.events.list()), ["e1"], "its events");
+                    await w.search.index("t1", documentFor("Lamp"));
+                    assertEqual((await w.search.query("lamp", { limit: 5 })).map((hit) => hit.ticket_id), ["t1"], "its index");
+                });
+            });
+        }
+    },
+    {
+        name: "writes to one board run one at a time, across stores",
+        async run(harness) {
+            await usingTwo(harness, async (here, there) => {
+                await makeBoard(here, "harbor", "b1");
+                const steps = [];
+                const body = (name) => async (w) => {
+                    steps.push(`${name} starts`);
+                    await w.tickets.lastNumber();
+                    await pause(5);
+                    await w.tickets.lastNumber();
+                    steps.push(`${name} ends`);
+                };
+                const boards = [await here.board("b1"), await there.board("b1"), await here.board("b1")];
+                await Promise.all(boards.map((board, i) => board.write(body(`w${i}`))));
+                for (let i = 0; i < steps.length; i += 2) {
+                    const start = steps[i] ?? "";
+                    assertEqual(steps[i + 1], start.replace("starts", "ends"), `a write ended before another started: ${steps.join(", ")}`);
+                }
+                assertEqual(steps.length, 6, "every write ran");
+            });
+        }
+    },
+    {
+        name: "a read while another caller's write is open never sees that write's changes",
+        async run(harness) {
+            await usingTwo(harness, async (here, there) => {
+                const { board, todo } = await makeBoard(here, "harbor", "b1");
+                const farBoard = await there.board("b1");
+                const hold = gate();
+                let opened = false;
+                const failing = board.write(async (w) => {
+                    await w.tickets.create(newTicket("t1", "b1", todo));
+                    await w.events.append(eventRecord("e1", "t1"));
+                    opened = true;
+                    await hold.wait;
+                    throw new Error("rolled back");
+                });
+                await eventually(() => opened, "the write is open");
+                const reads = [
+                    board.read(async (r) => [await r.tickets.get("t1"), await r.events.list()]),
+                    farBoard.read(async (r) => [await r.tickets.get("t1"), await r.events.list()])
+                ];
+                // A store may make a read wait for the write; let it, then end the write.
+                await pause(30);
+                hold.open();
+                await failing.then(() => undefined, () => undefined);
+                const [mine, theirs] = await Promise.all(reads);
+                assertEqual(mine, [null, []], "a read through the same store");
+                assertEqual(theirs, [null, []], "a read through another store");
+                const done = gate();
+                let made = false;
+                const working = board.write(async (w) => {
+                    await w.tickets.create(newTicket("t2", "b1", todo));
+                    made = true;
+                    await done.wait;
+                });
+                await eventually(() => made, "the second write is open");
+                const during = farBoard.read((r) => r.tickets.get("t2"));
+                await pause(30);
+                done.open();
+                await working;
+                const seen = await during;
+                assert(seen === null || seen.number === 1, "a read during a write sees the state before it or, if it waited, after it");
+                assertEqual((await farBoard.read((r) => r.tickets.get("t2")))?.number, 1, "after the commit, everyone sees it");
+            });
+        }
+    },
+    {
+        name: "everything one read sees is one committed state",
+        async run(harness) {
+            await usingTwo(harness, async (here, there) => {
+                const { board, todo } = await makeBoard(here, "harbor", "b1");
+                const farBoard = await there.board("b1");
+                let writing = Promise.resolve();
+                let finished = false;
+                const seen = await board.read(async (r) => {
+                    const tickets = await r.tickets.list();
+                    writing = farBoard.write(async (w) => {
+                        await w.tickets.create(newTicket("t1", "b1", todo));
+                        await w.events.append(eventRecord("e1", "t1"));
+                    }).then(() => {
+                        finished = true;
+                    });
+                    // A store may hold the write until this read ends; give it the chance to commit first.
+                    const started = Date.now();
+                    while (!finished && Date.now() - started < 200)
+                        await pause(10);
+                    const events = await r.events.list();
+                    const again = await r.tickets.list();
+                    return { tickets: idsOf(tickets), events: idsOf(events), again: idsOf(again) };
+                });
+                await writing;
+                assertEqual(seen, { tickets: [], events: [], again: [] }, "the read saw only the state it began with");
+                assertEqual(idsOf(await board.read((r) => r.events.list())), ["e1"], "a new read sees the write");
+            });
+        }
+    },
+    {
+        name: "a writer refuses every call once its write has settled",
+        async run(harness) {
+            await using(harness, async (store) => {
+                const { board, todo } = await makeBoard(store, "harbor", "b1");
+                let kept;
+                await board.write(async (w) => {
+                    kept = w;
+                    await w.tickets.create(newTicket("t1", "b1", todo));
+                });
+                const late = kept;
+                assert(late, "the writer was kept");
+                await assertRejects(() => late.tickets.create(newTicket("t2", "b1", todo)), "write_closed", "a create after the write");
+                await assertRejects(() => late.tickets.list(), "write_closed", "a read through the writer after the write");
+                let floating = Promise.resolve();
+                await board.write(async (w) => {
+                    floating = w.tickets.create(newTicket("t3", "b1", todo)).then(() => w.tickets.create(newTicket("t4", "b1", todo)));
+                    // Handled now: an adapter whose commit takes a while refuses it before the case looks.
+                    floating.catch(() => undefined);
+                    await Promise.resolve();
+                });
+                await floating.then(() => undefined, () => undefined);
+                const left = idsOf(await board.read((r) => r.tickets.list()));
+                assert(!left.includes("t4"), `a call the body never awaited can't land after the write: ${left.join(", ")}`);
+            });
+        }
+    },
+    // Watching
+    {
+        name: "watch() hears every committed event once, in order, from this store and others",
+        async run(harness) {
+            await usingTwo(harness, async (here, there) => {
+                const { board, todo } = await makeBoard(here, "harbor", "b1");
+                await makeBoard(here, "side", "b2");
+                const farBoard = await there.board("b1");
+                const otherBoard = await there.board("b2");
+                const mine = [];
+                const theirs = [];
+                const stopMine = board.watch((change) => mine.push(change));
+                const stopTheirs = farBoard.watch((change) => theirs.push(change.id));
+                await board.write(async (w) => {
+                    await w.tickets.create(newTicket("t1", "b1", todo));
+                    await w.events.append(eventRecord("e1", "t1", { type: "ticket_created", actor: "crea", body_json: '{"title":"One"}', created_at: at(1) }));
+                    await w.events.append(eventRecord("e2", null, { type: "board_updated", body_json: "not json", created_at: at(2) }));
+                });
+                await farBoard.write((w) => w.events.append(eventRecord("e3", "t1", { created_at: at(3) })));
+                await otherBoard.write((w) => w.events.append(eventRecord("elsewhere", null)));
+                await eventually(() => mine.length >= 3 && theirs.length >= 3, "both stores hear all three");
+                assertEqual(mine.slice(0, 2), [
+                    { id: "e1", type: "ticket_created", ticket_id: "t1", board_id: "b1", actor: "crea", data: { title: "One" }, timestamp: at(1) },
+                    { id: "e2", type: "board_updated", ticket_id: null, board_id: "b1", actor: "local", data: {}, timestamp: at(2) }
+                ], "the changes, data parsed (unreadable data as {})");
+                assertEqual(mine.map((change) => change.id), ["e1", "e2", "e3"], "this store hears its writes and the other store's, in order");
+                assertEqual(theirs, ["e1", "e2", "e3"], "the other store hears them too");
+                stopMine();
+                await board.write((w) => w.events.append(eventRecord("e4", null)));
+                await eventually(() => theirs.length >= 4, "the other store hears the next");
+                await pause(50);
+                assertEqual(mine.length, 3, "nothing after unsubscribing");
+                assertEqual(theirs, ["e1", "e2", "e3", "e4"], "never another board's events, never twice");
+                stopTheirs();
+            });
+        }
+    }
+];
+export const blobConformanceCases = [
+    {
+        name: "keeps bytes exactly, by board and path",
+        async run(blobs) {
+            const every = new Uint8Array(256).map((_, i) => i);
+            const big = new Uint8Array(300_000).map((_, i) => (i * 31) % 251);
+            await blobs.put("b1", "attachments/tickets/t1/a1.png", every);
+            await blobs.put("b1", "artifacts/tickets/t1/plan.md", big);
+            await blobs.put("b2", "attachments/tickets/t1/a1.png", new Uint8Array([7]));
+            assertEqual([...((await blobs.get("b1", "attachments/tickets/t1/a1.png")) ?? [])], [...every], "every byte value");
+            const back = await blobs.get("b1", "artifacts/tickets/t1/plan.md");
+            assert(back !== null && back.length === big.length && back.every((byte, i) => byte === big[i]), "300 KB, byte for byte");
+            assertEqual(await blobs.size("b1", "artifacts/tickets/t1/plan.md"), 300_000, "size()");
+            assertEqual([...((await blobs.get("b2", "attachments/tickets/t1/a1.png")) ?? [])], [7], "the same path on another board");
+            assertEqual(await blobs.get("b1", "attachments/none.png"), null, "nothing at a path");
+            assertEqual(await blobs.size("b1", "attachments/none.png"), null, "no size for nothing");
+            const kept = await blobs.get("b1", "attachments/tickets/t1/a1.png");
+            if (kept)
+                kept[0] = 99;
+            assertEqual((await blobs.get("b1", "attachments/tickets/t1/a1.png"))?.[0], 0, "bytes handed out are the caller's");
+        }
+    },
+    {
+        name: "replaces bytes, refuses an exclusive put over them, and removes them",
+        async run(blobs) {
+            await blobs.put("b1", "attachments/a.png", new Uint8Array([1, 2, 3]));
+            await blobs.put("b1", "attachments/a.png", new Uint8Array([4]));
+            assertEqual([...((await blobs.get("b1", "attachments/a.png")) ?? [])], [4], "a put replaces");
+            await assertRejects(() => blobs.put("b1", "attachments/a.png", new Uint8Array([5]), { exclusive: true }), "blob_exists", "an exclusive put over bytes");
+            assertEqual([...((await blobs.get("b1", "attachments/a.png")) ?? [])], [4], "the refused put changed nothing");
+            await blobs.put("b1", "attachments/b.png", new Uint8Array([6]), { exclusive: true });
+            await blobs.remove("b1", "attachments/a.png");
+            await blobs.remove("b1", "attachments/never.png");
+            assertEqual(await blobs.get("b1", "attachments/a.png"), null, "removed");
+            await blobs.put("b2", "attachments/c.png", new Uint8Array([8]));
+            await blobs.removeBoard("b1");
+            const left = [await blobs.get("b1", "attachments/b.png"), await blobs.size("b2", "attachments/c.png")];
+            assertEqual(left, [null, 1], "removeBoard() removes that board's only");
+        }
+    },
+    {
+        name: "refuses paths that leave the board",
+        async run(blobs) {
+            for (const path of ["", "/etc/passwd", "../other/board.db", "attachments/../../x", "attachments//x", "attachments/./x", "attachments\\x"]) {
+                await assertRejects(() => blobs.put("b1", path, new Uint8Array([1])), "invalid_blob_path", `put ${JSON.stringify(path)}`);
+                await assertRejects(() => blobs.get("b1", path), "invalid_blob_path", `get ${JSON.stringify(path)}`);
+            }
+        }
+    }
+];
+// Running the cases
+/** Registers every store case, under one describe block, with a test framework. */
+export function registerStoreConformance(api, label, factory, options = {}) {
+    api.describe(`${label} (OrbitStore conformance)`, () => {
+        for (const testCase of storeConformanceCases) {
+            if (options.skip?.includes(testCase.name))
+                continue;
+            api.it(testCase.name, async () => {
+                const harness = await factory();
+                try {
+                    await testCase.run(harness);
+                }
+                finally {
+                    await harness.dispose?.();
+                }
+            });
+        }
+    });
+}
+/** Registers every blob case, each on a fresh BlobStore. */
+export function registerBlobConformance(api, label, factory) {
+    api.describe(`${label} (BlobStore conformance)`, () => {
+        for (const testCase of blobConformanceCases) {
+            api.it(testCase.name, async () => testCase.run(await factory()));
+        }
+    });
+}
+/** Runs every store case in order, each on a fresh harness, and reports instead of throwing. */
+export async function runStoreConformance(factory, options = {}) {
+    const results = [];
+    for (const testCase of storeConformanceCases) {
+        if (options.skip?.includes(testCase.name))
+            continue;
+        if (options.only && !options.only.includes(testCase.name))
+            continue;
+        const harness = await factory();
+        try {
+            await testCase.run(harness);
+            results.push({ name: testCase.name, ok: true });
+        }
+        catch (error) {
+            results.push({ name: testCase.name, ok: false, error: error instanceof Error ? `${error.name}: ${error.message}` : String(error) });
+        }
+        finally {
+            await harness.dispose?.();
+        }
+    }
+    return results;
+}