@starlove/orbit 1.4.0 → 2.0.0

package/lib/adapters/memory/store.js

@@ -0,0 +1,266 @@
+/**
+ * The memory adapter: Orbit's storage port over plain objects. It is the
+ * reference the conformance suite is written against, the fast store for the
+ * core's own tests, and the smallest example of an adapter.
+ *
+ * Several stores can share one MemoryData, as several processes share a data
+ * folder: each write is serialised across all of them, and each hears the
+ * others' changes. A write works on a copy of the board's tables and swaps it
+ * in when the body returns, so a read always holds one committed state.
+ */
+import { OrbitError } from "../../core/errors.js";
+import { changeOf } from "../../core/model.js";
+import { byCodePoint, emptyTables, reader, writer } from "./board.js";
+const yieldTurn = () => Promise.resolve();
+/** Everything one Orbit keeps, shared by every memory store opened over it. */
+export class MemoryData {
+    /** In the order boards were registered. */
+    directory = [];
+    settings = new Map();
+    /** Each board's committed tables. A write replaces them whole and never changes them in place. */
+    tables = new Map();
+    tails = new Map();
+    listeners = new Map();
+    /** Runs `body` once every earlier body with the same key has finished. */
+    async exclusive(key, body) {
+        const previous = this.tails.get(key) ?? Promise.resolve();
+        let release = () => undefined;
+        const done = new Promise((resolve) => {
+            release = resolve;
+        });
+        const tail = previous.then(() => done);
+        this.tails.set(key, tail);
+        await previous;
+        try {
+            return await body();
+        }
+        finally {
+            release();
+            if (this.tails.get(key) === tail)
+                this.tails.delete(key);
+        }
+    }
+    listen(boardId, listener) {
+        let set = this.listeners.get(boardId);
+        if (!set) {
+            set = new Set();
+            this.listeners.set(boardId, set);
+        }
+        set.add(listener);
+        return () => {
+            set.delete(listener);
+        };
+    }
+    /** Tells every listener on the board, after the write that made them has committed. */
+    announce(boardId, log) {
+        const listeners = [...(this.listeners.get(boardId) ?? [])];
+        for (const event of log.events) {
+            const change = changeOf(boardId, event);
+            for (const listener of listeners) {
+                queueMicrotask(() => {
+                    listener(structuredClone(change));
+                });
+            }
+        }
+    }
+    entry(id) {
+        return this.directory.find((entry) => entry.id === id);
+    }
+    slugTaken(slug, exceptId) {
+        return this.directory.some((entry) => entry.slug === slug && entry.id !== exceptId);
+    }
+    /** Swaps in a write's tables and, when the write changed the board's record, brings its listing in line (as SQLite does). */
+    commit(boardId, draft) {
+        const board = draft.board;
+        if (board && this.slugTaken(board.slug, boardId))
+            throw new OrbitError("board_slug_taken");
+        const before = this.tables.get(boardId)?.board;
+        this.tables.set(boardId, draft);
+        if (!board || JSON.stringify(before) === JSON.stringify(board))
+            return;
+        this.directory = this.directory.map((entry) => entry.id === boardId
+            ? { ...entry, slug: board.slug, name: board.name, repo_url: board.repo_url, default_branch: board.default_branch, updated_at: board.updated_at }
+            : entry);
+    }
+}
+/** One write on a board's draft, with the writer closed once it settles. */
+async function runWrite(data, boardId, base, body) {
+    const draft = structuredClone(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: (slug) => data.slugTaken(slug, boardId) }, guard));
+        return { result, draft, log };
+    }
+    finally {
+        open = false;
+    }
+}
+function boardStore(data, id) {
+    const committed = () => {
+        const tables = data.entry(id) ? data.tables.get(id) : undefined;
+        if (!tables)
+            throw new OrbitError("board_not_found");
+        return tables;
+    };
+    return {
+        id,
+        async read(body) {
+            await yieldTurn();
+            const snapshot = committed();
+            return body(reader(() => snapshot));
+        },
+        write(body) {
+            return data.exclusive(`board:${id}`, async () => {
+                const { result, draft, log } = await runWrite(data, id, committed(), body);
+                data.commit(id, draft);
+                data.announce(id, log);
+                return result;
+            });
+        },
+        watch(listener) {
+            return data.listen(id, listener);
+        }
+    };
+}
+function directory(data) {
+    const listed = (id) => {
+        const entry = data.entry(id);
+        if (!entry)
+            throw new OrbitError("board_not_found");
+        return entry;
+    };
+    return {
+        async list() {
+            await yieldTurn();
+            return [...data.directory].sort((a, b) => byCodePoint(a.name, b.name)).map((entry) => ({ ...entry }));
+        },
+        async get(id) {
+            await yieldTurn();
+            const entry = data.entry(id);
+            return entry ? { ...entry } : null;
+        },
+        async bySlug(slug) {
+            await yieldTurn();
+            const entry = data.directory.find((candidate) => candidate.slug === slug);
+            return entry ? { ...entry } : null;
+        },
+        async latest() {
+            await yieldTurn();
+            let best = null;
+            for (const entry of data.directory) {
+                if (best === null || (entry.last_active_at ?? "") >= (best.last_active_at ?? ""))
+                    best = entry;
+            }
+            return best ? { ...best } : null;
+        },
+        create(board, seed) {
+            return data.exclusive("directory", async () => {
+                if (data.entry(board.id) || data.tables.has(board.id))
+                    throw new OrbitError("duplicate_id");
+                if (data.slugTaken(board.slug, board.id))
+                    throw new OrbitError("board_slug_taken");
+                const base = emptyTables();
+                base.board = { ...board };
+                const { draft, log } = await runWrite(data, board.id, base, seed);
+                const entry = {
+                    id: board.id,
+                    slug: board.slug,
+                    name: board.name,
+                    db_path: "",
+                    repo_url: board.repo_url,
+                    default_branch: board.default_branch,
+                    last_active_at: board.created_at,
+                    created_at: board.created_at,
+                    updated_at: board.updated_at
+                };
+                data.directory = [...data.directory, entry];
+                try {
+                    data.commit(board.id, draft);
+                }
+                catch (error) {
+                    data.directory = data.directory.filter((other) => other.id !== board.id);
+                    throw error;
+                }
+                data.announce(board.id, log);
+                return { ...listed(board.id) };
+            });
+        },
+        async touch(id, at) {
+            await yieldTurn();
+            listed(id);
+            data.directory = data.directory.map((entry) => (entry.id === id ? { ...entry, last_active_at: at, updated_at: at } : entry));
+        },
+        remove(id, options = {}) {
+            return data.exclusive("directory", () => data.exclusive(`board:${id}`, async () => {
+                await yieldTurn();
+                listed(id);
+                data.directory = data.directory.filter((entry) => entry.id !== id);
+                if (options.keepData)
+                    return { removed: [] };
+                data.tables.delete(id);
+                return { removed: [`memory:${id}`] };
+            }));
+        }
+    };
+}
+/** A store over `data`; pass the same MemoryData to two stores to have two views of one Orbit. */
+export function createMemoryStore(data = new MemoryData()) {
+    const boards = directory(data);
+    return {
+        boards,
+        async board(id) {
+            await yieldTurn();
+            if (!data.entry(id))
+                throw new OrbitError("board_not_found");
+            return boardStore(data, id);
+        },
+        async locate(kind, id, hint) {
+            await yieldTurn();
+            const holds = (tables) => {
+                switch (kind) {
+                    case "state":
+                        return tables.states.some((state) => state.id === id);
+                    case "ticket":
+                        return tables.tickets.some((ticket) => ticket.id === id);
+                    case "entry":
+                        return tables.entries.some((entry) => entry.id === id);
+                    case "relation":
+                        return tables.relations.some((relation) => relation.id === id);
+                }
+            };
+            const order = [...data.directory].sort((a, b) => byCodePoint(a.name, b.name)).sort((a, b) => Number(b.id === hint) - Number(a.id === hint));
+            const found = order.find((entry) => {
+                const tables = data.tables.get(entry.id);
+                return tables !== undefined && holds(tables);
+            });
+            return found ? { ...found } : null;
+        },
+        async relationsInto(boardId) {
+            await yieldTurn();
+            return [...data.directory].sort((a, b) => byCodePoint(a.name, b.name)).flatMap((entry) => [...(data.tables.get(entry.id)?.crossBoardRelations ?? [])]
+                .sort((a, b) => (a.created_at < b.created_at ? -1 : a.created_at > b.created_at ? 1 : 0))
+                .filter((relation) => relation.target_board_id === boardId)
+                .map((relation) => ({ board_id: entry.id, relation: { ...relation } })));
+        },
+        settings: {
+            async get(key) {
+                await yieldTurn();
+                return data.settings.get(key) ?? null;
+            },
+            async set(key, value) {
+                await yieldTurn();
+                data.settings.set(key, value);
+            }
+        },
+        backups: null,
+        async close() {
+            await yieldTurn();
+        }
+    };
+}

package/lib/adapters/sqlite/backups.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Point-in-time copies of the data folder, under `backups/`: SQLite's
+ * `VACUUM INTO` writes a whole, consistent copy of a database while it stays
+ * in use. Each copy is written under a temporary name and renamed when done,
+ * with a small manifest beside it, and only the newest copies are kept.
+ *
+ *   backups/boards/<board id>/<time>-<reason>-<slug>.board.db
+ *   backups/boards/<board id>/<time>-<reason>-<slug>.files/   attachments/ and artifacts/
+ *   backups/registry/<time>-<reason>.registry.db
+ *
+ * A board's files are hard-linked into the copy's folder (a copy of the bytes
+ * where a link is refused). Blob writes never change a file in place (each is
+ * a new file renamed over the old name, and a remove unlinks), so a link keeps
+ * the bytes it saw while the board moves on, and a file that never changes
+ * costs no more disk across all its copies.
+ *
+ * The core writes a file's bytes before the record that names them and
+ * removes them after the record is gone. A copy keeps that order by holding
+ * SQLite's write lock (taken here with BEGIN IMMEDIATE, so another process is
+ * held off too) while it copies the database and takes the last links:
+ * - a record in the copy was committed before the lock, so its bytes were
+ *   written before the lock and are linked inside it, unless they were
+ *   removed, which only happens after the record is gone from the copy;
+ * - a remove whose record is still there when the lock is taken can't commit
+ *   its record until the lock is let go, so its bytes are still there to link.
+ * The bulk of the linking (or copying) happens before the lock, and only what
+ * changed since is looked at inside it. An extra file in a copy, one whose
+ * record isn't there, is harmless.
+ */
+import type { Id } from "../../core/model.ts";
+import type { Backups } from "../../store/types.ts";
+export interface BackupOptions {
+    dataDir: string;
+    /** Copies kept per board, and for the registry. */
+    retention: number;
+    busyMs: number;
+    now: () => Date;
+    /** The board's database and slug, or null for a board this Orbit doesn't have. */
+    board: (id: Id) => {
+        dbPath: string;
+        slug: string;
+        name: string;
+    } | null;
+    /** Told when a copy's files couldn't be kept (its database copy stands); the console by default. */
+    warn?: (message: string) => void;
+}
+/** What a files folder holds, for the manifest. */
+export interface FilesTally {
+    count: number;
+    bytes: number;
+    how: "linked" | "copied" | "mixed" | "none";
+}
+export declare function createSqliteBackups(options: BackupOptions): Backups;

package/lib/adapters/sqlite/backups.js

@@ -0,0 +1,232 @@
+/**
+ * Point-in-time copies of the data folder, under `backups/`: SQLite's
+ * `VACUUM INTO` writes a whole, consistent copy of a database while it stays
+ * in use. Each copy is written under a temporary name and renamed when done,
+ * with a small manifest beside it, and only the newest copies are kept.
+ *
+ *   backups/boards/<board id>/<time>-<reason>-<slug>.board.db
+ *   backups/boards/<board id>/<time>-<reason>-<slug>.files/   attachments/ and artifacts/
+ *   backups/registry/<time>-<reason>.registry.db
+ *
+ * A board's files are hard-linked into the copy's folder (a copy of the bytes
+ * where a link is refused). Blob writes never change a file in place (each is
+ * a new file renamed over the old name, and a remove unlinks), so a link keeps
+ * the bytes it saw while the board moves on, and a file that never changes
+ * costs no more disk across all its copies.
+ *
+ * The core writes a file's bytes before the record that names them and
+ * removes them after the record is gone. A copy keeps that order by holding
+ * SQLite's write lock (taken here with BEGIN IMMEDIATE, so another process is
+ * held off too) while it copies the database and takes the last links:
+ * - a record in the copy was committed before the lock, so its bytes were
+ *   written before the lock and are linked inside it, unless they were
+ *   removed, which only happens after the record is gone from the copy;
+ * - a remove whose record is still there when the lock is taken can't commit
+ *   its record until the lock is let go, so its bytes are still there to link.
+ * The bulk of the linking (or copying) happens before the lock, and only what
+ * changed since is looked at inside it. An extra file in a copy, one whose
+ * record isn't there, is harmless.
+ */
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { copyFile, link, lstat, mkdir, readdir, rm, utimes } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { Connection, untilFree } from "./database.js";
+/** A name part made of letters, digits, `.`, `_` and `-` only. */
+function segment(value) {
+    return value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "unknown";
+}
+/** The trees a board keeps beside its database. */
+const FILE_TREES = ["attachments", "artifacts"];
+const gone = (error) => {
+    const code = error.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+};
+/** A file written by a blob put that hasn't been renamed into place yet. */
+const inFlight = (name) => name.startsWith(".") && name.endsWith(".partial");
+async function walk(folder, visit, relative = "") {
+    let entries;
+    try {
+        entries = await readdir(folder, { withFileTypes: true });
+    }
+    catch (error) {
+        if (gone(error))
+            return;
+        throw error;
+    }
+    for (const entry of entries) {
+        const next = relative ? `${relative}/${entry.name}` : entry.name;
+        // A symlink is never followed: a board's folder is Orbit's, but a copy must not reach outside it.
+        if (entry.isDirectory())
+            await walk(join(folder, entry.name), visit, next);
+        else if (entry.isFile() && !inFlight(entry.name))
+            await visit(join(folder, entry.name), next);
+    }
+}
+/**
+ * Makes `target` hold every file of `source`'s trees: linked, else copied.
+ * Safe to run again: a file already there (the same inode, or a copy with the
+ * same size and time) is left alone, a changed one is put in again, one that
+ * has since left `source` stays (an extra file is harmless).
+ */
+async function syncFiles(source, target) {
+    await mkdir(target, { recursive: true });
+    for (const tree of FILE_TREES) {
+        await walk(join(source, tree), async (file, relative) => {
+            const destination = join(target, tree, ...relative.split("/"));
+            let from;
+            try {
+                from = await lstat(file);
+            }
+            catch (error) {
+                if (gone(error))
+                    return;
+                throw error;
+            }
+            const have = await lstat(destination).catch(() => null);
+            if (have && ((have.ino === from.ino && have.dev === from.dev) || (have.nlink === 1 && have.size === from.size && Math.floor(have.mtimeMs) === Math.floor(from.mtimeMs))))
+                return;
+            await mkdir(dirname(destination), { recursive: true });
+            await rm(destination, { force: true });
+            try {
+                await link(file, destination);
+            }
+            catch (error) {
+                if (gone(error))
+                    return;
+                // Another device, no permission, a file system without links: keep the bytes by copying.
+                try {
+                    await copyFile(file, destination);
+                    await utimes(destination, from.atime, from.mtime);
+                }
+                catch (copyError) {
+                    await rm(destination, { force: true });
+                    if (gone(copyError))
+                        return;
+                    throw copyError;
+                }
+            }
+        });
+    }
+}
+/** Counts a files folder: files, bytes, and whether they are links or copies. */
+async function tallyFiles(target) {
+    let count = 0;
+    let bytes = 0;
+    let linked = 0;
+    for (const tree of FILE_TREES) {
+        await walk(join(target, tree), async (file) => {
+            const found = await lstat(file);
+            count += 1;
+            bytes += found.size;
+            if (found.nlink > 1)
+                linked += 1;
+        });
+    }
+    return { count, bytes, how: count === 0 ? "none" : linked === count ? "linked" : linked === 0 ? "copied" : "mixed" };
+}
+export function createSqliteBackups(options) {
+    const root = join(options.dataDir, "backups");
+    const warn = options.warn ?? ((message) => { console.warn(message); });
+    /**
+     * Holds SQLite's write lock on `source` (every writer, in this process or
+     * another, waits for it) until the returned function lets go. Taking it
+     * changes nothing: it is rolled back.
+     */
+    async function holdWrites(source) {
+        const conn = new Connection(source);
+        try {
+            await untilFree(() => { conn.exec("BEGIN IMMEDIATE"); }, Date.now() + options.busyMs);
+        }
+        catch (error) {
+            conn.close();
+            throw error;
+        }
+        return () => {
+            conn.rollback();
+            conn.close();
+        };
+    }
+    /** `filesFrom`: a board's folder, whose attachments and artifacts go beside the database copy. */
+    async function copy(source, filesFrom, dir, name, suffix, manifest, oncePerDay) {
+        const when = options.now().toISOString();
+        if (oncePerDay && existsSync(dir) && readdirSync(dir).some((file) => file.startsWith(`${when.slice(0, 10)}T`) && file.endsWith(suffix)))
+            return null;
+        mkdirSync(dir, { recursive: true });
+        const base = `${when.replace(/[:.]/g, "-")}-${name}`;
+        const target = join(dir, `${base}${suffix}`);
+        const partial = `${target}.partial`;
+        const filesTarget = join(dir, `${base}.files`);
+        const filesPartial = `${filesTarget}.partial`;
+        rmSync(partial, { force: true });
+        rmSync(filesPartial, { recursive: true, force: true });
+        // Most of the linking (or copying) first, with the board still writing.
+        const problem = { error: null };
+        if (filesFrom !== null)
+            await syncFiles(filesFrom, filesPartial).catch((error) => { problem.error = error instanceof Error ? error : new Error(String(error)); });
+        // Then the database and what changed since, with writes held off.
+        try {
+            const release = filesFrom !== null && problem.error === null ? await holdWrites(source) : null;
+            try {
+                const conn = new Connection(source);
+                try {
+                    await untilFree(() => conn.run("VACUUM INTO ?", [partial]), Date.now() + options.busyMs);
+                }
+                finally {
+                    conn.close();
+                }
+                if (filesFrom !== null && problem.error === null)
+                    await syncFiles(filesFrom, filesPartial).catch((error) => { problem.error = error instanceof Error ? error : new Error(String(error)); });
+            }
+            finally {
+                release?.();
+            }
+        }
+        catch (error) {
+            rmSync(filesPartial, { recursive: true, force: true });
+            throw error;
+        }
+        renameSync(partial, target);
+        const record = { ...manifest, created_at: when };
+        if (filesFrom !== null) {
+            try {
+                if (problem.error !== null)
+                    throw problem.error;
+                const tally = await tallyFiles(filesPartial);
+                renameSync(filesPartial, filesTarget);
+                record.files = tally;
+            }
+            catch (error) {
+                problem.error = error instanceof Error ? error : new Error(String(error));
+            }
+            if (problem.error !== null) {
+                rmSync(filesPartial, { recursive: true, force: true });
+                const reason = problem.error.message;
+                warn(`[orbit] Backup ${base}${suffix} has its database but not the board's files: ${reason}`);
+                record.files = { error: "The board's files could not be kept in this copy; see Orbit's log." };
+            }
+        }
+        writeFileSync(`${target}.json`, `${JSON.stringify(record, null, 2)}\n`);
+        prune(dir, suffix);
+        return target;
+    }
+    function prune(dir, suffix) {
+        const copies = readdirSync(dir).filter((file) => file.endsWith(suffix)).sort().reverse();
+        for (const stale of copies.slice(options.retention)) {
+            rmSync(join(dir, stale), { force: true });
+            rmSync(join(dir, `${stale}.json`), { force: true });
+            rmSync(join(dir, `${stale.slice(0, -suffix.length)}.files`), { recursive: true, force: true });
+        }
+    }
+    return {
+        async board(id, reason, opts = {}) {
+            const board = options.board(id);
+            if (board === null)
+                return null;
+            const manifest = { kind: "board", reason, board_id: id, slug: board.slug, name: board.name };
+            return copy(board.dbPath, dirname(board.dbPath), join(root, "boards", segment(id)), `${segment(reason)}-${segment(board.slug)}`, ".board.db", manifest, opts.oncePerDay === true);
+        },
+        async directory(reason, opts = {}) {
+            return copy(join(options.dataDir, "registry.db"), null, join(root, "registry"), segment(reason), ".registry.db", { kind: "registry", reason }, opts.oncePerDay === true);
+        }
+    };
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Bytes beside each board's database: `boards/<folder>/attachments/...` and
+ * `boards/<folder>/artifacts/...`, the port's paths taken as they are. Each
+ * file is written under a temporary name and renamed into place, so a crash
+ * leaves the old bytes or the new ones, never half a file.
+ */
+import type { Id } from "../../core/model.ts";
+import type { BlobStore } from "../../store/types.ts";
+/**
+ * A blob store over board folders. `folderOf` gives a board's folder, or null
+ * for a board this Orbit doesn't have: nothing can be stored for it, and
+ * nothing is there to read or remove.
+ */
+export declare function createSqliteBlobStore(folderOf: (boardId: Id) => string | null): BlobStore;

package/lib/adapters/sqlite/blobs.js

@@ -0,0 +1,109 @@
+/**
+ * Bytes beside each board's database: `boards/<folder>/attachments/...` and
+ * `boards/<folder>/artifacts/...`, the port's paths taken as they are. Each
+ * file is written under a temporary name and renamed into place, so a crash
+ * leaves the old bytes or the new ones, never half a file.
+ */
+import { randomUUID } from "node:crypto";
+import { link, mkdir, open, readFile, rename, rm, rmdir, stat, unlink } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { OrbitError } from "../../core/errors.js";
+import { checkBlobPath } from "../../store/blob-path.js";
+const missing = (error) => {
+    const code = error.code;
+    return code === "ENOENT" || code === "EISDIR" || code === "ENOTDIR";
+};
+/**
+ * A blob store over board folders. `folderOf` gives a board's folder, or null
+ * for a board this Orbit doesn't have: nothing can be stored for it, and
+ * nothing is there to read or remove.
+ */
+export function createSqliteBlobStore(folderOf) {
+    const fileOf = (boardId, path) => {
+        checkBlobPath(path);
+        const folder = folderOf(boardId);
+        return folder === null ? null : join(folder, ...path.split("/"));
+    };
+    return {
+        async put(boardId, path, bytes, options = {}) {
+            const file = fileOf(boardId, path);
+            if (file === null)
+                throw new OrbitError("board_not_found");
+            await mkdir(dirname(file), { recursive: true });
+            const temporary = join(dirname(file), `.${basename(file)}.${randomUUID()}.partial`);
+            try {
+                const handle = await open(temporary, "wx");
+                try {
+                    await handle.writeFile(bytes);
+                    await handle.sync();
+                }
+                finally {
+                    await handle.close();
+                }
+                if (options.exclusive) {
+                    // A hard link fails when the name is taken, so two exclusive puts can't both win.
+                    await link(temporary, file).catch((error) => {
+                        throw error.code === "EEXIST" ? new OrbitError("blob_exists") : error;
+                    });
+                }
+                else {
+                    await rename(temporary, file);
+                }
+            }
+            catch (error) {
+                throw error instanceof OrbitError ? error : new OrbitError("storage_failed", { cause: error });
+            }
+            finally {
+                await rm(temporary, { force: true });
+            }
+        },
+        async get(boardId, path) {
+            const file = fileOf(boardId, path);
+            if (file === null)
+                return null;
+            try {
+                return new Uint8Array(await readFile(file));
+            }
+            catch (error) {
+                if (missing(error))
+                    return null;
+                throw new OrbitError("storage_failed", { cause: error });
+            }
+        },
+        async size(boardId, path) {
+            const file = fileOf(boardId, path);
+            if (file === null)
+                return null;
+            try {
+                const found = await stat(file);
+                return found.isFile() ? found.size : null;
+            }
+            catch (error) {
+                if (missing(error))
+                    return null;
+                throw new OrbitError("storage_failed", { cause: error });
+            }
+        },
+        async remove(boardId, path) {
+            const file = fileOf(boardId, path);
+            if (file === null)
+                return;
+            await unlink(file).catch((error) => {
+                if (!missing(error))
+                    throw new OrbitError("storage_failed", { cause: error });
+            });
+        },
+        async removeBoard(boardId) {
+            const folder = folderOf(boardId);
+            if (folder === null)
+                return;
+            for (const kind of ["attachments", "artifacts"])
+                await rm(join(folder, kind), { recursive: true, force: true });
+            // The folder goes too once nothing else is in it (its database is the store's to delete).
+            await rmdir(folder).catch(() => undefined);
+        },
+        location(boardId, path) {
+            return fileOf(boardId, path) ?? "";
+        }
+    };
+}