@starlove/orbit 1.4.1 → 2.0.0

package/lib/adapters/indexeddb/store.js

@@ -0,0 +1,424 @@
+/// <reference lib="dom" />
+/**
+ * The IndexedDB adapter: Orbit's storage port in a browser, shared by every
+ * tab of the origin. `openIndexedDbStore()` gives the store and, as its
+ * `blobs`, the blob store of the same database.
+ *
+ * - **Writes.** An IndexedDB transaction commits by itself once its code
+ *   waits for anything else, so a write can't be one. A write takes the
+ *   board's exclusive lock (a Web Lock, held across tabs), runs its body
+ *   against a copy of the board in memory (the memory adapter's writer, so
+ *   its reads see its own changes and the port's checks are the same), then
+ *   commits what changed in one readwrite transaction. A body that throws
+ *   commits nothing. Card numbers are given under the lock.
+ * - **Reads.** A read loads the board in one readonly transaction, which is
+ *   one committed state, and runs its body against it. It takes no lock, so
+ *   a read never waits for a write. A tab keeps the board it last loaded and
+ *   reuses it while the board's revision is unchanged.
+ * - **watch().** This tab's commits reach its watchers at once; other tabs'
+ *   through a BroadcastChannel, after which the board is read again and the
+ *   events past the last one heard are delivered, in order, once.
+ * - **Search** filters a board's documents in memory, as the memory adapter
+ *   does: a board's documents are few.
+ * - **Backups:** none (`backups` is null); people export a board instead.
+ */
+import { OrbitError } from "../../core/errors.js";
+import { changeOf } from "../../core/model.js";
+import { byCodePoint, emptyTables, reader, writer } from "../memory/board.js";
+import { createIndexedDbBlobStore } from "./blobs.js";
+import { BOARDS, HEADS, ROWS, SETTINGS, openDatabase, rowRange, transact } from "./database.js";
+import { createLocalLocks, webLocks } from "./locks.js";
+import { changesOf, cloneTables, eventSeqs, snapshotOf } from "./tables.js";
+const yieldTurn = () => Promise.resolve();
+/** Listings in the order boards were made. */
+const made = (listed) => [...listed].sort((a, b) => a.n - b.n).map((entry) => entry.board);
+/** The directory's order: by name, then by when each was made. */
+const directoryOrder = (listed) => made(listed).sort((a, b) => byCodePoint(a.name, b.name));
+export async function openIndexedDbStore(options = {}) {
+    const name = options.name ?? "orbit";
+    const factory = options.indexedDB ?? globalThis.indexedDB;
+    const locks = options.locks ?? webLocks() ?? createLocalLocks();
+    const db = await openDatabase(factory, name);
+    const makeChannel = options.channel === undefined ? (typeof BroadcastChannel === "undefined" ? null : (channelName) => new BroadcastChannel(channelName)) : options.channel;
+    const channel = makeChannel ? makeChannel(`orbit-indexeddb:${name}`) : null;
+    const lockName = (boardId) => `orbit-indexeddb:${name}:board:${boardId}`;
+    /** The board as this tab last saw it. */
+    const cache = new Map();
+    const feeds = new Map();
+    const remember = (boardId, snapshot) => {
+        const known = cache.get(boardId);
+        if (!known || known.revision < snapshot.revision)
+            cache.set(boardId, snapshot);
+    };
+    /**
+     * The board's committed state, in one transaction: this tab's copy when
+     * the revision matches, else its rows. With `directory`, every listing too.
+     */
+    function load(boardId, withDirectory = false) {
+        return transact(db, [BOARDS, HEADS, ROWS], "readonly", (tx, refuse) => {
+            let snapshot = null;
+            let directory = [];
+            tx.objectStore(BOARDS).get(boardId).onsuccess = (event) => {
+                if (!event.target.result)
+                    refuse(new OrbitError("board_not_found"));
+            };
+            if (withDirectory) {
+                tx.objectStore(BOARDS).getAll().onsuccess = (event) => {
+                    directory = made(event.target.result);
+                };
+            }
+            tx.objectStore(HEADS).get(boardId).onsuccess = (event) => {
+                const head = event.target.result;
+                if (!head) {
+                    refuse(new OrbitError("board_not_found"));
+                    return;
+                }
+                const known = cache.get(boardId);
+                if (known && known.revision === head.revision) {
+                    snapshot = known;
+                    return;
+                }
+                tx.objectStore(ROWS).getAll(rowRange(boardId)).onsuccess = (rowsEvent) => {
+                    snapshot = snapshotOf(head.revision, head.seq, rowsEvent.target.result);
+                };
+            };
+            return () => {
+                if (!snapshot)
+                    throw new OrbitError("board_not_found");
+                remember(boardId, snapshot);
+                return { snapshot, directory };
+            };
+        });
+    }
+    /** Writes a write's changes in one transaction, if the board is still where the write found it. */
+    function commit(boardId, before, changes, board) {
+        return transact(db, [BOARDS, HEADS, ROWS], "readwrite", (tx, refuse) => {
+            const boards = tx.objectStore(BOARDS);
+            const rows = tx.objectStore(ROWS);
+            tx.objectStore(HEADS).get(boardId).onsuccess = (event) => {
+                const head = event.target.result;
+                if (!head) {
+                    refuse(new OrbitError("board_not_found"));
+                    return;
+                }
+                // The lock makes this impossible; a page without shared locks would otherwise lose a write.
+                if (head.revision !== before.revision) {
+                    refuse(new OrbitError("storage_busy", { message: "Another tab changed the board during this write." }));
+                    return;
+                }
+                const next = { board_id: boardId, revision: changes.after.revision, seq: changes.after.seq };
+                tx.objectStore(HEADS).put(next);
+                for (const key of changes.deletes)
+                    rows.delete(key);
+                for (const { key, row } of changes.puts)
+                    rows.put(row, key);
+            };
+            boards.getAll().onsuccess = (event) => {
+                const entries = event.target.result;
+                const listed = entries.find((candidate) => candidate.board.id === boardId);
+                if (!listed) {
+                    refuse(new OrbitError("board_not_found"));
+                    return;
+                }
+                if (!changes.boardChanged || !board)
+                    return;
+                if (entries.some((other) => other.board.id !== boardId && other.board.slug === board.slug)) {
+                    refuse(new OrbitError("board_slug_taken"));
+                    return;
+                }
+                const entry = listed.board;
+                boards.put({ n: listed.n, board: { ...entry, slug: board.slug, name: board.name, repo_url: board.repo_url, default_branch: board.default_branch, updated_at: board.updated_at } }, boardId);
+            };
+            return () => undefined;
+        });
+    }
+    /** Runs `body` on a copy of `base`, with the writer closed once it settles, as the memory adapter does. */
+    async function runWrite(boardId, base, slugTaken, body) {
+        const draft = cloneTables(base);
+        const log = { events: [] };
+        let open = true;
+        const guard = async () => {
+            await yieldTurn();
+            if (!open)
+                throw new OrbitError("write_closed");
+        };
+        try {
+            const result = await body(writer(boardId, draft, log, { slugTaken }, guard));
+            return { result, draft, log };
+        }
+        finally {
+            open = false;
+        }
+    }
+    /** Hands every event past the feed's cursor to its listeners, once and in order. */
+    function deliver(boardId, feed, snapshot) {
+        if (feed.cursor === null)
+            return;
+        for (const { s, event } of eventSeqs(snapshot)) {
+            if (s <= feed.cursor)
+                continue;
+            feed.cursor = s;
+            for (const listener of [...feed.listeners]) {
+                const change = changeOf(boardId, event);
+                queueMicrotask(() => {
+                    listener(change);
+                });
+            }
+        }
+    }
+    function enqueue(boardId, feed, step) {
+        feed.chain = feed.chain
+            .then(step)
+            .then((snapshot) => {
+            if (snapshot && feeds.get(boardId) === feed)
+                deliver(boardId, feed, snapshot);
+        })
+            .catch(() => undefined);
+    }
+    const onNotice = (event) => {
+        const { board } = event.data;
+        const feed = feeds.get(board);
+        if (!feed)
+            return;
+        enqueue(board, feed, async () => (await load(board)).snapshot);
+    };
+    if (channel)
+        channel.onmessage = onNotice;
+    function startFeed(boardId) {
+        const feed = { listeners: new Set(), cursor: null, chain: Promise.resolve() };
+        // Made now, so it reads the board as it is when watch() is called; later commits are heard.
+        const start = transact(db, [HEADS], "readonly", (tx) => {
+            let seq = 0;
+            tx.objectStore(HEADS).get(boardId).onsuccess = (event) => {
+                seq = event.target.result?.seq ?? 0;
+            };
+            return () => seq;
+        });
+        feed.chain = start.then((seq) => {
+            feed.cursor = seq;
+        }, () => {
+            feed.cursor = 0;
+        });
+        feeds.set(boardId, feed);
+        return feed;
+    }
+    function boardStore(id) {
+        return {
+            id,
+            async read(body) {
+                const { snapshot } = await load(id);
+                return body(reader(() => snapshot.tables));
+            },
+            write(body) {
+                return locks.request(lockName(id), async () => {
+                    const { snapshot, directory } = await load(id, true);
+                    const slugTaken = (slug) => directory.some((entry) => entry.slug === slug && entry.id !== id);
+                    const { result, draft } = await runWrite(id, snapshot.tables, slugTaken, body);
+                    const changes = changesOf(id, snapshot, draft);
+                    await commit(id, snapshot, changes, draft.board);
+                    remember(id, changes.after);
+                    const feed = feeds.get(id);
+                    if (feed)
+                        enqueue(id, feed, () => changes.after);
+                    channel?.postMessage({ board: id, revision: changes.after.revision });
+                    return result;
+                });
+            },
+            watch(listener) {
+                const feed = feeds.get(id) ?? startFeed(id);
+                feed.listeners.add(listener);
+                return () => {
+                    feed.listeners.delete(listener);
+                    if (feed.listeners.size === 0 && feeds.get(id) === feed)
+                        feeds.delete(id);
+                };
+            }
+        };
+    }
+    const allListed = () => transact(db, [BOARDS], "readonly", (tx) => {
+        let entries = [];
+        tx.objectStore(BOARDS).getAll().onsuccess = (event) => {
+            entries = event.target.result;
+        };
+        return () => entries;
+    });
+    const allBoards = async () => made(await allListed());
+    const boards = {
+        async list() {
+            return directoryOrder(await allListed());
+        },
+        async get(id) {
+            return (await allBoards()).find((entry) => entry.id === id) ?? null;
+        },
+        async bySlug(slug) {
+            return (await allBoards()).find((entry) => entry.slug === slug) ?? null;
+        },
+        async latest() {
+            let best = null;
+            for (const entry of await allBoards()) {
+                if (best === null || (entry.last_active_at ?? "") >= (best.last_active_at ?? ""))
+                    best = entry;
+            }
+            return best;
+        },
+        async create(board, seed) {
+            const existing = await allBoards();
+            const slugTaken = (slug) => existing.some((entry) => entry.slug === slug && entry.id !== board.id);
+            if (existing.some((entry) => entry.id === board.id))
+                throw new OrbitError("duplicate_id");
+            if (slugTaken(board.slug))
+                throw new OrbitError("board_slug_taken");
+            const base = emptyTables();
+            base.board = { ...board };
+            const empty = { revision: 0, seq: 0, tables: emptyTables(), seqs: new Map() };
+            const { draft } = await runWrite(board.id, base, slugTaken, seed);
+            const changes = changesOf(board.id, empty, draft);
+            const entry = {
+                id: board.id,
+                slug: draft.board?.slug ?? board.slug,
+                name: draft.board?.name ?? board.name,
+                db_path: "",
+                repo_url: draft.board?.repo_url ?? board.repo_url,
+                default_branch: draft.board?.default_branch ?? board.default_branch,
+                last_active_at: board.created_at,
+                created_at: board.created_at,
+                updated_at: draft.board?.updated_at ?? board.updated_at
+            };
+            await transact(db, [BOARDS, HEADS, ROWS], "readwrite", (tx, refuse) => {
+                const boardsStore = tx.objectStore(BOARDS);
+                boardsStore.getAll().onsuccess = (event) => {
+                    const entries = event.target.result;
+                    if (entries.some((other) => other.board.id === board.id)) {
+                        refuse(new OrbitError("duplicate_id"));
+                        return;
+                    }
+                    if (entries.some((other) => other.board.slug === entry.slug)) {
+                        refuse(new OrbitError("board_slug_taken"));
+                        return;
+                    }
+                    const n = entries.reduce((top, other) => Math.max(top, other.n), 0) + 1;
+                    boardsStore.add({ n, board: entry }, board.id);
+                };
+                tx.objectStore(HEADS).get(board.id).onsuccess = (event) => {
+                    // Rows left by a board removed with its data kept: the id is taken.
+                    if (event.target.result) {
+                        refuse(new OrbitError("duplicate_id"));
+                        return;
+                    }
+                    tx.objectStore(HEADS).put({ board_id: board.id, revision: changes.after.revision, seq: changes.after.seq });
+                    const rows = tx.objectStore(ROWS);
+                    for (const { key, row } of changes.puts)
+                        rows.put(row, key);
+                };
+                return () => undefined;
+            });
+            remember(board.id, changes.after);
+            return { ...entry };
+        },
+        touch(id, at) {
+            return transact(db, [BOARDS], "readwrite", (tx, refuse) => {
+                const store = tx.objectStore(BOARDS);
+                store.get(id).onsuccess = (event) => {
+                    const listed = event.target.result;
+                    if (!listed) {
+                        refuse(new OrbitError("board_not_found"));
+                        return;
+                    }
+                    store.put({ n: listed.n, board: { ...listed.board, last_active_at: at, updated_at: at } }, id);
+                };
+                return () => undefined;
+            });
+        },
+        remove(id, options = {}) {
+            return locks.request(lockName(id), async () => {
+                await transact(db, [BOARDS, HEADS, ROWS], "readwrite", (tx, refuse) => {
+                    const store = tx.objectStore(BOARDS);
+                    store.get(id).onsuccess = (event) => {
+                        if (!event.target.result) {
+                            refuse(new OrbitError("board_not_found"));
+                            return;
+                        }
+                        store.delete(id);
+                        if (options.keepData)
+                            return;
+                        tx.objectStore(HEADS).delete(id);
+                        tx.objectStore(ROWS).delete(rowRange(id));
+                    };
+                    return () => undefined;
+                });
+                cache.delete(id);
+                return { removed: options.keepData ? [] : [`IndexedDB ${name}: board ${id}`] };
+            });
+        }
+    };
+    const TABLE_OF = { state: "states", ticket: "tickets", entry: "entries", relation: "relations" };
+    const store = {
+        boards,
+        blobs: createIndexedDbBlobStore(db),
+        async board(id) {
+            if (!(await boards.get(id)))
+                throw new OrbitError("board_not_found");
+            return boardStore(id);
+        },
+        locate(kind, id, hint) {
+            return transact(db, [BOARDS, ROWS], "readonly", (tx) => {
+                let order = [];
+                const holds = new Set();
+                tx.objectStore(BOARDS).getAll().onsuccess = (event) => {
+                    order = directoryOrder(event.target.result).sort((a, b) => Number(b.id === hint) - Number(a.id === hint));
+                    for (const entry of order) {
+                        tx.objectStore(ROWS).count([entry.id, TABLE_OF[kind], id]).onsuccess = (countEvent) => {
+                            if (countEvent.target.result > 0)
+                                holds.add(entry.id);
+                        };
+                    }
+                };
+                return () => order.find((entry) => holds.has(entry.id)) ?? null;
+            });
+        },
+        relationsInto(boardId) {
+            return transact(db, [BOARDS, ROWS], "readonly", (tx) => {
+                const found = new Map();
+                let order = [];
+                tx.objectStore(BOARDS).getAll().onsuccess = (event) => {
+                    order = directoryOrder(event.target.result);
+                    for (const entry of order) {
+                        tx.objectStore(ROWS).getAll(rowRange(entry.id, "crossBoardRelations")).onsuccess = (rowsEvent) => {
+                            found.set(entry.id, rowsEvent.target.result);
+                        };
+                    }
+                };
+                return () => order.flatMap((entry) => (found.get(entry.id) ?? [])
+                    .map((row) => ({ s: row.s, relation: row.v }))
+                    .sort((a, b) => (a.relation.created_at < b.relation.created_at ? -1 : a.relation.created_at > b.relation.created_at ? 1 : a.s - b.s))
+                    .filter(({ relation }) => relation.target_board_id === boardId)
+                    .map(({ relation }) => ({ board_id: entry.id, relation })));
+            });
+        },
+        settings: {
+            get(key) {
+                return transact(db, [SETTINGS], "readonly", (tx) => {
+                    let value = null;
+                    tx.objectStore(SETTINGS).get(key).onsuccess = (event) => {
+                        value = (event.target.result ?? null);
+                    };
+                    return () => value;
+                });
+            },
+            set(key, value) {
+                return transact(db, [SETTINGS], "readwrite", (tx) => {
+                    tx.objectStore(SETTINGS).put(value, key);
+                    return () => undefined;
+                });
+            }
+        },
+        backups: null,
+        async close() {
+            await yieldTurn();
+            feeds.clear();
+            channel?.close();
+            db.close();
+        }
+    };
+    return store;
+}

package/lib/adapters/indexeddb/tables.d.ts

@@ -0,0 +1,43 @@
+/**
+ * A board in memory and in rows: the memory adapter's tables (whose reader
+ * and writer the IndexedDB adapter reuses, so both keep the port's rules
+ * the same way), loaded from a board's rows, and the rows a write changed.
+ */
+import type { Tables } from "../memory/board.ts";
+import type { Row, RowKey } from "./database.ts";
+/** One board as a tab holds it: its tables, the commit they are from, and each record's sequence number. */
+export interface Snapshot {
+    revision: number;
+    /** The last sequence number given out on the board. */
+    seq: number;
+    tables: Tables;
+    /** `${table}\u0000${key}` to the record's sequence number. */
+    seqs: Map<string, number>;
+}
+/** A snapshot from a board's rows, as one getAll() returns them. */
+export declare function snapshotOf(revision: number, seq: number, rows: readonly Row[]): Snapshot;
+/** A copy a write can change freely: records are flat, so copying each record copies the board. */
+export declare function cloneTables(tables: Tables): Tables;
+/** What a write changed: rows to put and to delete, and the snapshot it leaves. */
+export interface Changes {
+    puts: {
+        key: RowKey;
+        row: Row;
+    }[];
+    deletes: RowKey[];
+    after: Snapshot;
+    /** The board's own record changed (the directory follows it). */
+    boardChanged: boolean;
+}
+/**
+ * Compares a write's tables with the snapshot it started from. A record
+ * keeps its sequence number while it stays in place; one that is new, or
+ * that moved behind a record written after it, gets the next number, so
+ * the rows read back in the order the tables have them.
+ */
+export declare function changesOf(boardId: string, before: Snapshot, draft: Tables): Changes;
+/** The sequence number of each of the snapshot's events, in order. */
+export declare function eventSeqs(snapshot: Snapshot): {
+    s: number;
+    event: Tables["events"][number];
+}[];

package/lib/adapters/indexeddb/tables.js

@@ -0,0 +1,127 @@
+/**
+ * A board in memory and in rows: the memory adapter's tables (whose reader
+ * and writer the IndexedDB adapter reuses, so both keep the port's rules
+ * the same way), loaded from a board's rows, and the rows a write changed.
+ */
+import { emptyTables } from "../memory/board.js";
+/** The tables that are lists of records, each in the order its records were written. */
+const LISTS = ["states", "labels", "tickets", "ticketLabels", "comments", "relations", "crossBoardRelations", "entries", "verdicts", "attachments", "events"];
+/** The board's own record and the search index are tables too, with no order. */
+const BOARD = "board";
+const SEARCH = "search";
+/** A record's key within its table: its id, or for a label link its card and label. */
+function keyOf(table, record) {
+    if (table === "ticketLabels") {
+        const link = record;
+        return `${link.ticket_id}\u0000${link.label_id}`;
+    }
+    return record.id;
+}
+const seqKey = (table, key) => `${table}\u0000${key}`;
+/** A snapshot from a board's rows, as one getAll() returns them. */
+export function snapshotOf(revision, seq, rows) {
+    const tables = emptyTables();
+    const seqs = new Map();
+    const lists = new Map();
+    for (const row of rows) {
+        if (row.t === BOARD)
+            tables.board = row.v;
+        else if (row.t === SEARCH) {
+            const { ticket_id, document } = row.v;
+            tables.search.set(ticket_id, document);
+        }
+        else {
+            const table = row.t;
+            let list = lists.get(table);
+            if (!list) {
+                list = [];
+                lists.set(table, list);
+            }
+            list.push({ s: row.s, v: row.v });
+        }
+    }
+    for (const [table, list] of lists) {
+        list.sort((a, b) => a.s - b.s);
+        tables[table] = list.map((entry) => entry.v);
+        for (const entry of list)
+            seqs.set(seqKey(table, keyOf(table, entry.v)), entry.s);
+    }
+    return { revision, seq, tables, seqs };
+}
+/** A copy a write can change freely: records are flat, so copying each record copies the board. */
+export function cloneTables(tables) {
+    const copy = emptyTables();
+    copy.board = tables.board ? { ...tables.board } : null;
+    for (const table of LISTS)
+        copy[table] = tables[table].map((record) => ({ ...record }));
+    for (const [id, document] of tables.search)
+        copy.search.set(id, { ...document });
+    return copy;
+}
+function sameRecord(a, b) {
+    const keysA = Object.keys(a);
+    if (keysA.length !== Object.keys(b).length)
+        return false;
+    return keysA.every((key) => Object.hasOwn(b, key) && Object.is(a[key], b[key]));
+}
+/**
+ * Compares a write's tables with the snapshot it started from. A record
+ * keeps its sequence number while it stays in place; one that is new, or
+ * that moved behind a record written after it, gets the next number, so
+ * the rows read back in the order the tables have them.
+ */
+export function changesOf(boardId, before, draft) {
+    const puts = [];
+    const deletes = [];
+    const seqs = new Map();
+    let seq = before.seq;
+    for (const table of LISTS) {
+        const old = new Map();
+        for (const record of before.tables[table])
+            old.set(keyOf(table, record), record);
+        let last = 0;
+        for (const record of draft[table]) {
+            const key = keyOf(table, record);
+            const kept = before.seqs.get(seqKey(table, key));
+            const previous = old.get(key);
+            old.delete(key);
+            let s;
+            let changed;
+            if (kept !== undefined && kept > last && previous !== undefined) {
+                s = kept;
+                changed = !sameRecord(previous, record);
+            }
+            else {
+                s = ++seq;
+                changed = true;
+            }
+            last = s;
+            seqs.set(seqKey(table, key), s);
+            if (changed)
+                puts.push({ key: [boardId, table, key], row: { t: table, s, v: record } });
+        }
+        for (const key of old.keys())
+            deletes.push([boardId, table, key]);
+    }
+    const boardChanged = before.tables.board === null || draft.board === null ? before.tables.board !== draft.board : !sameRecord(before.tables.board, draft.board);
+    if (boardChanged) {
+        if (draft.board)
+            puts.push({ key: [boardId, BOARD, ""], row: { t: BOARD, s: 0, v: draft.board } });
+        else
+            deletes.push([boardId, BOARD, ""]);
+    }
+    const oldDocuments = new Map(before.tables.search);
+    for (const [ticketId, document] of draft.search) {
+        const previous = oldDocuments.get(ticketId);
+        oldDocuments.delete(ticketId);
+        if (!previous || !sameRecord(previous, document))
+            puts.push({ key: [boardId, SEARCH, ticketId], row: { t: SEARCH, s: 0, v: { ticket_id: ticketId, document } } });
+    }
+    for (const ticketId of oldDocuments.keys())
+        deletes.push([boardId, SEARCH, ticketId]);
+    return { puts, deletes, boardChanged, after: { revision: before.revision + 1, seq, tables: draft, seqs } };
+}
+/** The sequence number of each of the snapshot's events, in order. */
+export function eventSeqs(snapshot) {
+    return snapshot.tables.events.map((event) => ({ s: snapshot.seqs.get(seqKey("events", event.id)) ?? 0, event }));
+}

package/lib/adapters/memory/blobs.d.ts

@@ -0,0 +1,3 @@
+/** Bytes in memory, by board and path: the reference BlobStore. */
+import type { BlobStore } from "../../store/types.ts";
+export declare function createMemoryBlobStore(): BlobStore;

package/lib/adapters/memory/blobs.js

@@ -0,0 +1,44 @@
+/** Bytes in memory, by board and path: the reference BlobStore. */
+import { OrbitError } from "../../core/errors.js";
+import { checkBlobPath } from "../../store/blob-path.js";
+const yieldTurn = () => Promise.resolve();
+export function createMemoryBlobStore() {
+    const boards = new Map();
+    const of = (boardId) => {
+        let blobs = boards.get(boardId);
+        if (!blobs) {
+            blobs = new Map();
+            boards.set(boardId, blobs);
+        }
+        return blobs;
+    };
+    return {
+        async put(boardId, path, bytes, options = {}) {
+            await yieldTurn();
+            checkBlobPath(path);
+            const blobs = of(boardId);
+            if (options.exclusive && blobs.has(path))
+                throw new OrbitError("blob_exists");
+            blobs.set(path, bytes.slice());
+        },
+        async get(boardId, path) {
+            await yieldTurn();
+            checkBlobPath(path);
+            return boards.get(boardId)?.get(path)?.slice() ?? null;
+        },
+        async size(boardId, path) {
+            await yieldTurn();
+            checkBlobPath(path);
+            return boards.get(boardId)?.get(path)?.byteLength ?? null;
+        },
+        async remove(boardId, path) {
+            await yieldTurn();
+            checkBlobPath(path);
+            boards.get(boardId)?.delete(path);
+        },
+        async removeBoard(boardId) {
+            await yieldTurn();
+            boards.delete(boardId);
+        }
+    };
+}

package/lib/adapters/memory/board.d.ts

@@ -0,0 +1,41 @@
+/**
+ * One board's records in memory, and the reader and writer over them. The
+ * tables are arrays in the order records were written, so "then by when it
+ * was written" is array order, and every sort here is stable.
+ */
+import type { Attachment, Board, BoardEntry, Comment, CrossBoardRelation, Id, Label, OrbitEvent, Relation, ReviewVerdict, State, Ticket, TicketLabel } from "../../core/model.ts";
+import type { BoardReader, BoardWriter, SearchDocument } from "../../store/types.ts";
+export interface Tables {
+    board: Board | null;
+    states: State[];
+    labels: Label[];
+    tickets: Ticket[];
+    ticketLabels: TicketLabel[];
+    comments: Comment[];
+    relations: Relation[];
+    crossBoardRelations: CrossBoardRelation[];
+    entries: BoardEntry[];
+    verdicts: ReviewVerdict[];
+    attachments: Attachment[];
+    events: OrbitEvent[];
+    search: Map<Id, SearchDocument>;
+}
+export declare function emptyTables(): Tables;
+/** What a writer reports to its store: the board's record changed, events appended. */
+export interface WriteLog {
+    events: OrbitEvent[];
+}
+/** Checks a writer makes against the rest of the data: another board's slug. */
+export interface WriteChecks {
+    slugTaken(slug: string): boolean;
+}
+/** Code-point order, as SQLite compares text. */
+export declare function byCodePoint(a: string, b: string): number;
+/** A reader over `tables()`: committed tables for a read, the draft for a write. */
+export declare function reader(tables: () => Tables, ready?: () => Promise<void>): BoardReader;
+/**
+ * A writer over a draft. Every check the port names is made here, in the
+ * order the port lists them, so a write that breaks one throws before it
+ * changes anything.
+ */
+export declare function writer(boardId: Id, draft: Tables, log: WriteLog, checks: WriteChecks, guard: () => Promise<void>): BoardWriter;