@starlove/orbit 1.4.0 → 2.0.0

package/lib/adapters/sqlite/records.js

@@ -0,0 +1,546 @@
+/**
+ * One board's records in SQL: the port's BoardReader and BoardWriter over a
+ * connection. Each method is one statement, prepared once per connection, and
+ * reads that serve a whole board return every row at once. Records come back
+ * built field for field in the order src/core/model.ts lists them, with the
+ * board's id added where a record names its board (board.db holds one board,
+ * so its rows don't repeat it).
+ */
+import { OrbitError } from "../../core/errors.js";
+import { literalQuery, queryWords } from "../../store/search-words.js";
+function kind(table, fields) {
+    const columns = fields.filter((field) => field !== "board_id");
+    return {
+        table,
+        fields,
+        columns,
+        select: `SELECT ${columns.join(", ")} FROM ${table}`,
+        insert: `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`
+    };
+}
+export const BOARD = kind("board", ["id", "slug", "name", "repo_url", "default_branch", "project_notes", "agent_instructions", "ai_enabled", "created_at", "updated_at"]);
+const STATE = kind("states", ["id", "board_id", "name", "position", "is_default", "role", "created_at"]);
+const LABEL = kind("labels", ["id", "board_id", "name", "color", "created_at"]);
+const TICKET = kind("tickets", [
+    "id", "board_id", "number", "title", "description", "type", "parent_ticket_id", "ai_plan", "plan_artifact_path", "implementation_summary",
+    "implementation_artifact_path", "implementation_updates", "nebula_url", "state_id", "priority", "created_by", "created_at", "updated_at", "archived_at"
+]);
+const TICKET_LABEL = kind("ticket_labels", ["ticket_id", "label_id"]);
+const COMMENT = kind("comments", ["id", "ticket_id", "author", "kind", "body", "omitted_for_ai", "created_at"]);
+const RELATION = kind("relations", ["id", "source_ticket_id", "target_ticket_id", "type", "created_at"]);
+export const CROSS = kind("cross_board_relations", ["id", "source_ticket_id", "target_board_id", "target_ticket_id", "type", "created_at"]);
+const ENTRY = kind("board_entries", ["id", "board_id", "type", "title", "body", "ticket_id", "created_by", "created_at", "updated_at", "struck_at"]);
+const VERDICT = kind("review_verdicts", [
+    "id", "ticket_id", "verdict", "blocking_findings_json", "optional_findings_json", "evidence_commands_json", "reviewer_profile",
+    "reviewer_session_id", "reviewed_commit_sha", "dispatch_run_id", "supersedes_prior_review_id", "created_by", "created_at"
+]);
+const ATTACHMENT = kind("attachments", ["id", "ticket_id", "board_id", "original_name", "stored_path", "mime_type", "size_bytes", "sha256", "created_by", "created_at"]);
+export const EVENT = kind("events", ["id", "ticket_id", "actor", "type", "body_json", "created_at"]);
+/** The record a row holds, built in the model's field order. */
+export function toRecord(of, row, boardId) {
+    const record = {};
+    for (const field of of.fields)
+        record[field] = field === "board_id" ? boardId : row[field];
+    return record;
+}
+/** A copy of a record handed in, built the same way, so the caller's object is never kept. */
+function copyOf(of, record, boardId) {
+    return toRecord(of, record, boardId);
+}
+/** The values of `columns` in `record`, in order, for a statement's parameters. */
+function valuesOf(columns, record) {
+    return columns.map((column) => record[column]);
+}
+/** The fields of `patch` that are set and may change, in the order given. */
+function patched(patch, allowed) {
+    return Object.entries(patch).filter(([key, value]) => value !== undefined && allowed.has(key));
+}
+const updatable = (of, fixed) => new Set(of.columns.filter((column) => !fixed.includes(column)));
+const TICKET_PATCH = updatable(TICKET, ["id", "number", "created_by", "created_at"]);
+const STATE_PATCH = new Set(["name", "position", "is_default", "role"]);
+const ENTRY_PATCH = new Set(["struck_at", "updated_at"]);
+const BOARD_PATCH = updatable(BOARD, ["id", "created_at"]);
+/** A new card's columns: all but its number, which the insert computes. */
+const NEW_TICKET = TICKET.columns.filter((column) => column !== "number");
+const json = (ids) => JSON.stringify(ids);
+const IN_IDS = "(SELECT value FROM json_each(?))";
+const BY_TIME = "ORDER BY created_at, seq";
+// Statements whose text never changes. Each binds plain `?` in order, a
+// value repeated where it is used twice: Node 22.16 binds an array of values to
+// `?1`-style parameters by occurrence, and refuses one named twice.
+const SQL = {
+    board: `${BOARD.select} LIMIT 1`,
+    setBoard: BOARD.insert.replace("INSERT INTO", "INSERT OR REPLACE INTO"),
+    states: `${STATE.select} ORDER BY position, seq`,
+    state: `${STATE.select} WHERE id = ?`,
+    labels: `${LABEL.select} ORDER BY name`,
+    ticket: `${TICKET.select} WHERE id = ?`,
+    ticketByNumber: `${TICKET.select} WHERE number = ?`,
+    ticketByTitle: `${TICKET.select} WHERE lower(title) = lower(?) ORDER BY archived_at IS NOT NULL, number DESC LIMIT 1`,
+    lastNumber: "SELECT coalesce(max(number), 0) AS number FROM tickets",
+    createTicket: `INSERT INTO tickets (number, ${NEW_TICKET.join(", ")}) ` +
+        `VALUES ((SELECT coalesce(max(number), 0) + 1 FROM tickets), ${NEW_TICKET.map(() => "?").join(", ")}) RETURNING number`,
+    ticketExists: "SELECT 1 AS here FROM tickets WHERE id = ?",
+    removeTicket: "DELETE FROM tickets WHERE id = ?",
+    ticketLabels: `${TICKET_LABEL.select} ORDER BY seq`,
+    ticketLabelsOf: `${TICKET_LABEL.select} WHERE ticket_id IN ${IN_IDS} ORDER BY seq`,
+    unlinkLabels: "DELETE FROM ticket_labels WHERE ticket_id = ?",
+    linkLabel: "INSERT INTO ticket_labels (ticket_id, label_id) VALUES (?, ?) ON CONFLICT (ticket_id, label_id) DO NOTHING",
+    comment: `${COMMENT.select} WHERE id = ?`,
+    comments: `${COMMENT.select} ${BY_TIME}`,
+    commentsOf: `${COMMENT.select} WHERE ticket_id = ? ${BY_TIME}`,
+    commentCounts: "SELECT ticket_id, count(*) AS count FROM comments WHERE (? = 0 OR omitted_for_ai = 0) AND (? IS NULL OR body <> ?) GROUP BY ticket_id ORDER BY min(seq)",
+    hideComment: `UPDATE comments SET omitted_for_ai = ? WHERE id = ? RETURNING ${COMMENT.columns.join(", ")}`,
+    relation: `${RELATION.select} WHERE id = ?`,
+    relations: `${RELATION.select} ${BY_TIME}`,
+    relationsOf: `${RELATION.select} WHERE source_ticket_id = ? OR target_ticket_id = ? ${BY_TIME}`,
+    removeRelation: "DELETE FROM relations WHERE id = ?",
+    crossRelations: `${CROSS.select} ${BY_TIME}`,
+    crossRelationsOf: `${CROSS.select} WHERE source_ticket_id = ? ${BY_TIME}`,
+    removeCrossRelation: "DELETE FROM cross_board_relations WHERE id = ?",
+    entry: `${ENTRY.select} WHERE id = ?`,
+    entries: `${ENTRY.select} ${BY_TIME}`,
+    removeEntry: "DELETE FROM board_entries WHERE id = ?",
+    verdict: `${VERDICT.select} WHERE id = ?`,
+    verdicts: `${VERDICT.select} ${BY_TIME}`,
+    verdictsOf: `${VERDICT.select} WHERE ticket_id = ? ${BY_TIME}`,
+    attachment: `${ATTACHMENT.select} WHERE id = ?`,
+    attachments: `${ATTACHMENT.select} ${BY_TIME}`,
+    attachmentsOf: `${ATTACHMENT.select} WHERE ticket_id = ? ${BY_TIME}`,
+    removeAttachment: "DELETE FROM attachments WHERE id = ?",
+    latestEvents: `SELECT ${EVENT.columns.join(", ")} FROM (SELECT *, row_number() OVER (PARTITION BY ticket_id ORDER BY created_at DESC, seq DESC) AS newest ` +
+        `FROM events WHERE ticket_id IN ${IN_IDS} AND type IN ${IN_IDS}) WHERE newest = 1 ${BY_TIME}`,
+    eventsAfter: `${EVENT.select} WHERE seq > (SELECT seq FROM events WHERE id = ?) ORDER BY seq LIMIT ?`,
+    lastEvent: `${EVENT.select} ORDER BY seq DESC LIMIT 1`,
+    searchWords: "SELECT tickets.id AS ticket_id, bm25(search) AS rank FROM search JOIN tickets ON tickets.number = search.rowid " +
+        "WHERE search MATCH ? AND tickets.archived_at IS NULL ORDER BY rank, tickets.number LIMIT ?",
+    searchText: "SELECT tickets.id AS ticket_id, 0 AS rank FROM search JOIN tickets ON tickets.number = search.rowid WHERE tickets.archived_at IS NULL " +
+        "AND (search.title LIKE ? ESCAPE '\\' OR search.description LIKE ? ESCAPE '\\' OR search.details LIKE ? ESCAPE '\\' OR search.comments LIKE ? ESCAPE '\\') " +
+        "ORDER BY tickets.number LIMIT ?",
+    index: "INSERT OR REPLACE INTO search (rowid, title, description, type, details, comments) SELECT number, ?, ?, ?, ?, ? FROM tickets WHERE id = ?",
+    unindex: "DELETE FROM search WHERE rowid = (SELECT number FROM tickets WHERE id = ?)",
+    clear: [
+        "search", "ticket_labels", "relations", "cross_board_relations", "comments", "review_verdicts", "attachments", "board_entries", "events", "tickets", "labels", "states", "board"
+    ].map((table) => `DELETE FROM ${table};`).join(" ")
+};
+/** For readers, which have nothing to check before a call. */
+export const noWait = () => Promise.resolve();
+/** The port's BoardReader over a connection. */
+export function reader({ c, boardId, before }) {
+    const one = (of, sql, params) => {
+        const row = c.get(sql, params);
+        return row ? toRecord(of, row, boardId) : null;
+    };
+    const many = (of, sql, params = []) => c.all(sql, params).map((row) => toRecord(of, row, boardId));
+    return {
+        board: {
+            async get() {
+                await before();
+                const board = one(BOARD, SQL.board, []);
+                if (!board)
+                    throw new OrbitError("board_not_found");
+                return board;
+            }
+        },
+        states: {
+            async list() {
+                await before();
+                return many(STATE, SQL.states);
+            },
+            async get(id) {
+                await before();
+                return one(STATE, SQL.state, [id]);
+            }
+        },
+        labels: {
+            async list() {
+                await before();
+                return many(LABEL, SQL.labels);
+            }
+        },
+        tickets: {
+            async get(id) {
+                await before();
+                return one(TICKET, SQL.ticket, [id]);
+            },
+            async byNumber(number) {
+                await before();
+                return one(TICKET, SQL.ticketByNumber, [number]);
+            },
+            async byTitle(title) {
+                await before();
+                return one(TICKET, SQL.ticketByTitle, [title]);
+            },
+            async list(filter = {}) {
+                await before();
+                if (filter.ids?.length === 0)
+                    return [];
+                const [sql, params] = ticketQuery(filter);
+                return many(TICKET, sql, params);
+            },
+            async lastNumber() {
+                await before();
+                return Number(c.get(SQL.lastNumber)?.number ?? 0);
+            }
+        },
+        ticketLabels: {
+            async list(ticketIds) {
+                await before();
+                if (ticketIds === undefined)
+                    return many(TICKET_LABEL, SQL.ticketLabels);
+                return ticketIds.length === 0 ? [] : many(TICKET_LABEL, SQL.ticketLabelsOf, [json(ticketIds)]);
+            }
+        },
+        comments: {
+            async get(id) {
+                await before();
+                return one(COMMENT, SQL.comment, [id]);
+            },
+            async list(ticketId) {
+                await before();
+                return ticketId === undefined ? many(COMMENT, SQL.comments) : many(COMMENT, SQL.commentsOf, [ticketId]);
+            },
+            async countByTicket(options = {}) {
+                await before();
+                return c.all(SQL.commentCounts, [options.forAgents ? 1 : 0, options.exceptBody ?? null, options.exceptBody ?? null]).map((row) => ({ ticket_id: String(row.ticket_id), count: Number(row.count) }));
+            }
+        },
+        relations: {
+            async get(id) {
+                await before();
+                return one(RELATION, SQL.relation, [id]);
+            },
+            async list(ticketId) {
+                await before();
+                return ticketId === undefined ? many(RELATION, SQL.relations) : many(RELATION, SQL.relationsOf, [ticketId, ticketId]);
+            }
+        },
+        crossBoardRelations: {
+            async list(ticketId) {
+                await before();
+                return ticketId === undefined ? many(CROSS, SQL.crossRelations) : many(CROSS, SQL.crossRelationsOf, [ticketId]);
+            }
+        },
+        entries: {
+            async get(id) {
+                await before();
+                return one(ENTRY, SQL.entry, [id]);
+            },
+            async list() {
+                await before();
+                return many(ENTRY, SQL.entries);
+            }
+        },
+        verdicts: {
+            async get(id) {
+                await before();
+                return one(VERDICT, SQL.verdict, [id]);
+            },
+            async list(ticketId) {
+                await before();
+                return ticketId === undefined ? many(VERDICT, SQL.verdicts) : many(VERDICT, SQL.verdictsOf, [ticketId]);
+            }
+        },
+        attachments: {
+            async get(id) {
+                await before();
+                return one(ATTACHMENT, SQL.attachment, [id]);
+            },
+            async list(ticketId) {
+                await before();
+                return ticketId === undefined ? many(ATTACHMENT, SQL.attachments) : many(ATTACHMENT, SQL.attachmentsOf, [ticketId]);
+            }
+        },
+        events: {
+            async list(filter = {}) {
+                await before();
+                if (filter.types?.length === 0)
+                    return [];
+                const [sql, params] = eventQuery(filter);
+                return many(EVENT, sql, params);
+            },
+            async latest(ticketIds, types) {
+                await before();
+                if (ticketIds.length === 0 || types.length === 0)
+                    return [];
+                return many(EVENT, SQL.latestEvents, [json(ticketIds), json(types)]);
+            },
+            async after(id, limit) {
+                await before();
+                return many(EVENT, SQL.eventsAfter, [id, limit]);
+            },
+            async last() {
+                await before();
+                return one(EVENT, SQL.lastEvent, []);
+            }
+        },
+        search: {
+            async query(text, options) {
+                await before();
+                return search(c, text, options.limit);
+            }
+        }
+    };
+}
+function ticketQuery(filter) {
+    const where = [];
+    const params = [];
+    if (filter.archived !== undefined)
+        where.push(filter.archived ? "archived_at IS NOT NULL" : "archived_at IS NULL");
+    if (filter.parent !== undefined) {
+        where.push("parent_ticket_id = ?");
+        params.push(filter.parent);
+    }
+    if (filter.state !== undefined) {
+        where.push("state_id = ?");
+        params.push(filter.state);
+    }
+    if (filter.ids !== undefined) {
+        where.push(`id IN ${IN_IDS}`);
+        params.push(json(filter.ids));
+    }
+    return [`${TICKET.select}${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY number`, params];
+}
+function eventQuery(filter) {
+    const where = [];
+    const params = [];
+    if (filter.ticketId !== undefined) {
+        where.push("ticket_id = ?");
+        params.push(filter.ticketId);
+    }
+    if (filter.types !== undefined) {
+        where.push(`type IN ${IN_IDS}`);
+        params.push(json(filter.types));
+    }
+    if (filter.since !== undefined) {
+        where.push("created_at >= ?");
+        params.push(filter.since);
+    }
+    return [`${EVENT.select}${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ${BY_TIME}`, params];
+}
+/** The port's search rules over FTS5: every word a prefix, or the literal text with LIKE's wildcards escaped. */
+function search(c, text, limit) {
+    const words = queryWords(text);
+    let rows;
+    if (words.length > 0) {
+        rows = c.all(SQL.searchWords, [words.map((word) => `"${word}"*`).join(" "), limit]);
+    }
+    else {
+        const literal = literalQuery(text);
+        if (literal === null)
+            return [];
+        const pattern = `%${literal.replace(/[\\%_]/g, "\\$&")}%`;
+        rows = c.all(SQL.searchText, [pattern, pattern, pattern, pattern, limit]);
+    }
+    return rows.map((row) => ({ ticket_id: String(row.ticket_id), rank: Number(row.rank) }));
+}
+/** The port's BoardWriter over a connection in an open transaction. */
+export function writer(over, log, checks) {
+    const { c, boardId, before } = over;
+    const read = reader(over);
+    const onBoard = (id) => {
+        if (id !== boardId)
+            throw new OrbitError("invalid_reference");
+    };
+    const insert = (of, record) => {
+        c.run(of.insert, valuesOf(of.columns, record));
+    };
+    const removed = (sql, id, missing) => {
+        if (c.run(sql, [id]).changes === 0)
+            throw new OrbitError(missing);
+    };
+    const setBoard = (board) => {
+        onBoard(board.id);
+        if (checks.slugTaken(board.slug))
+            throw new OrbitError("board_slug_taken");
+        c.run(SQL.setBoard, valuesOf(BOARD.columns, board));
+        log.board = copyOf(BOARD, board, boardId);
+    };
+    const update = (of, id, patch, allowed, missing) => {
+        const changes = patched(patch, allowed);
+        const row = changes.length === 0
+            ? c.get(`${of.select} WHERE id = ?`, [id])
+            : c.get(`UPDATE ${of.table} SET ${changes.map(([key]) => `${key} = ?`).join(", ")} WHERE id = ? RETURNING ${of.columns.join(", ")}`, [...changes.map(([, value]) => value), id]);
+        if (!row)
+            throw new OrbitError(missing);
+        return toRecord(of, row, boardId);
+    };
+    return {
+        ...read,
+        async clear() {
+            await before();
+            c.exec(SQL.clear);
+        },
+        board: {
+            ...read.board,
+            async set(board) {
+                await before();
+                setBoard(board);
+            },
+            async update(patch) {
+                await before();
+                const current = c.get(SQL.board);
+                if (!current)
+                    throw new OrbitError("board_not_found");
+                const next = toRecord(BOARD, current, boardId);
+                Object.assign(next, Object.fromEntries(patched(patch, BOARD_PATCH)));
+                setBoard(next);
+                return copyOf(BOARD, next, boardId);
+            }
+        },
+        states: {
+            ...read.states,
+            async insert(state) {
+                await before();
+                onBoard(state.board_id);
+                insert(STATE, state);
+            },
+            async update(id, patch) {
+                await before();
+                return update(STATE, id, patch, STATE_PATCH, "state_not_found");
+            },
+            async remove(id) {
+                await before();
+                if (c.run("DELETE FROM states WHERE id = ?", [id], { foreignKey: "state_has_tickets" }).changes === 0)
+                    throw new OrbitError("state_not_found");
+            }
+        },
+        labels: {
+            ...read.labels,
+            async insert(label) {
+                await before();
+                onBoard(label.board_id);
+                insert(LABEL, label);
+            }
+        },
+        tickets: {
+            ...read.tickets,
+            async create(ticket) {
+                await before();
+                onBoard(ticket.board_id);
+                const row = c.get(SQL.createTicket, valuesOf(NEW_TICKET, ticket));
+                return copyOf(TICKET, { ...ticket, number: Number(row?.number) }, boardId);
+            },
+            async insert(ticket) {
+                await before();
+                onBoard(ticket.board_id);
+                insert(TICKET, ticket);
+            },
+            async update(id, patch) {
+                await before();
+                return update(TICKET, id, patch, TICKET_PATCH, "ticket_not_found");
+            },
+            async remove(id) {
+                await before();
+                removed(SQL.removeTicket, id, "ticket_not_found");
+            }
+        },
+        ticketLabels: {
+            ...read.ticketLabels,
+            async set(ticketId, labelIds) {
+                await before();
+                if (labelIds.length === 0 && !c.get(SQL.ticketExists, [ticketId]))
+                    throw new OrbitError("invalid_reference");
+                c.run(SQL.unlinkLabels, [ticketId]);
+                for (const labelId of new Set(labelIds))
+                    c.run(SQL.linkLabel, [ticketId, labelId]);
+            },
+            async add(ticketId, labelId) {
+                await before();
+                c.run(SQL.linkLabel, [ticketId, labelId]);
+            }
+        },
+        comments: {
+            ...read.comments,
+            async insert(comment) {
+                await before();
+                insert(COMMENT, comment);
+            },
+            async update(id, patch) {
+                await before();
+                const row = c.get(SQL.hideComment, [patch.omitted_for_ai, id]);
+                if (!row)
+                    throw new OrbitError("comment_not_found");
+                return toRecord(COMMENT, row, boardId);
+            }
+        },
+        relations: {
+            ...read.relations,
+            async insert(relation) {
+                await before();
+                insert(RELATION, relation);
+            },
+            async remove(id) {
+                await before();
+                removed(SQL.removeRelation, id, "relation_not_found");
+            }
+        },
+        crossBoardRelations: {
+            ...read.crossBoardRelations,
+            async insert(relation) {
+                await before();
+                insert(CROSS, relation);
+            },
+            async remove(id) {
+                await before();
+                removed(SQL.removeCrossRelation, id, "relation_not_found");
+            }
+        },
+        entries: {
+            ...read.entries,
+            async insert(entry) {
+                await before();
+                onBoard(entry.board_id);
+                insert(ENTRY, entry);
+            },
+            async update(id, patch) {
+                await before();
+                return update(ENTRY, id, patch, ENTRY_PATCH, "board_entry_not_found");
+            },
+            async remove(id) {
+                await before();
+                removed(SQL.removeEntry, id, "board_entry_not_found");
+            }
+        },
+        verdicts: {
+            ...read.verdicts,
+            async insert(verdict) {
+                await before();
+                insert(VERDICT, verdict);
+            }
+        },
+        attachments: {
+            ...read.attachments,
+            async insert(attachment) {
+                await before();
+                onBoard(attachment.board_id);
+                insert(ATTACHMENT, attachment);
+            },
+            async remove(id) {
+                await before();
+                removed(SQL.removeAttachment, id, "attachment_not_found");
+            }
+        },
+        events: {
+            ...read.events,
+            async append(event) {
+                await before();
+                const { lastInsertRowid } = c.run(EVENT.insert, valuesOf(EVENT.columns, event));
+                log.events.push({ seq: lastInsertRowid, event: copyOf(EVENT, event, boardId) });
+            }
+        },
+        search: {
+            ...read.search,
+            async index(ticketId, document) {
+                await before();
+                const { changes } = c.run(SQL.index, [document.title, document.description, document.type, document.details, document.comments, ticketId]);
+                if (changes === 0)
+                    throw new OrbitError("invalid_reference");
+            },
+            async remove(ticketId) {
+                await before();
+                c.run(SQL.unindex, [ticketId]);
+            }
+        }
+    };
+}

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

@@ -0,0 +1,54 @@
+/**
+ * The SQLite adapter's schema: every table Orbit 2.0 keeps on a computer or
+ * server, top to bottom. A data folder holds two kinds of database:
+ *
+ *   registry.db               the list of boards and this Orbit's settings
+ *   boards/<folder>/board.db  one board's records, one file per board
+ *
+ * with each board's images and markdown beside its board.db (the blob store,
+ * ./blobs.ts) and copies under backups/ (./backups.ts).
+ *
+ * Every file carries two numbers in its header: `application_id`, which says
+ * the file is Orbit's, and `user_version`, the version of the schema below.
+ * A file without them was written by Orbit 1.x or the first 2.0 (same tables,
+ * no version), and the adapter refuses to open it rather than change it: the
+ * migration brings such folders over.
+ *
+ * Conventions:
+ *
+ * - Field names are the records' own (src/core/model.ts), so a row and its
+ *   record read the same.
+ * - A board's database holds one board, so its rows carry no `board_id`: the
+ *   adapter adds the board's id when it hands a record out, and refuses a
+ *   record naming another board.
+ * - `seq INTEGER PRIMARY KEY` keeps the order records were written, which the
+ *   port's lists fall back on ("then by when it was written"). It is an
+ *   explicit column because VACUUM (and so every backup) may renumber an
+ *   implicit rowid. The record's own id is `UNIQUE` beside it.
+ * - Foreign keys hold the board together (`PRAGMA foreign_keys` is on for
+ *   every connection): a comment's card exists, deleting a card deletes what
+ *   belongs to it, a lane with cards can't be deleted. Two names are left
+ *   unchecked on purpose, as the port says: a card's epic and a cross-board
+ *   relation's target.
+ * - Flags are 0 or 1, times are ISO 8601 text in UTC, JSON stays text.
+ */
+/** Says "this file is Orbit's": 'ORBT' as a big-endian 32-bit integer. */
+export declare const APPLICATION_ID = 1330790996;
+/** The version of the schema below, in every file's `user_version`. */
+export declare const SCHEMA_VERSION = 1;
+/**
+ * The version of the search index's shape (its columns and tokenizer). When
+ * it changes, a board's index is rebuilt from the documents it holds, once,
+ * the first time the board is opened; never at every start.
+ */
+export declare const SEARCH_INDEX_VERSION = 1;
+/**
+ * The search index's table, apart from the rest so a change of its shape
+ * rebuilds it alone (./board.ts). Its columns are the core's document
+ * (SearchDocument in src/store/types.ts).
+ */
+export declare const SEARCH_TABLE = "CREATE VIRTUAL TABLE search USING fts5 (\n  title, description, type, details, comments,\n  tokenize = \"unicode61 remove_diacritics 2 tokenchars '_'\"\n);";
+/** registry.db */
+export declare const REGISTRY_SCHEMA = "\n-- The boards this Orbit has. A board's records live in its own board.db, in\n-- boards/<folder>/; the folder is named once, by the slug the board was made\n-- with, and stays put when the slug changes. The name, slug and the rest are\n-- copies of the board's own record, kept in step after each write, so the\n-- list of boards is one read.\nCREATE TABLE boards (\n  seq            INTEGER PRIMARY KEY,\n  id             TEXT NOT NULL UNIQUE,\n  slug           TEXT NOT NULL UNIQUE,\n  name           TEXT NOT NULL,\n  folder         TEXT NOT NULL UNIQUE,\n  repo_url       TEXT NOT NULL,\n  default_branch TEXT NOT NULL,\n  last_active_at TEXT,\n  created_at     TEXT NOT NULL,\n  updated_at     TEXT NOT NULL\n);\nCREATE INDEX boards_by_name ON boards (name, seq);\n\n-- Small values this Orbit keeps for itself (the computer's default board).\nCREATE TABLE settings (\n  key   TEXT PRIMARY KEY,\n  value TEXT NOT NULL\n);\n";
+/** board.db */
+export declare const BOARD_SCHEMA: string;