@dev.fast/whiteboard 0.3.4 → 0.3.5-preview.20261021.131

package/src/review-api/scratchpad-plan-upgrade.ts

@@ -0,0 +1,250 @@
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+
+import type { JsonValue } from "@dev.fast/json";
+import { migrateStoredDocument } from "@review/stored-document-migration.js";
+
+import { type Block, sourceReferences } from "./document.js";
+import { snapshotForeignReferences } from "./foreign-references.js";
+import type { StoreUpgradeContext } from "./store-migrations.js";
+import { BOARD_REPOSITORY_ID_SQL, columnsOf } from "./store-schema.js";
+
+// The old global scratchpad becomes a plan titled "Scratchpad", history
+// kept, in the project of the repository its blocks quote most, else of the
+// repository opened last. A board quotes only its own repository, so its
+// quotes of others become snapshots.
+
+const OLD_SCRATCHPAD_ID = "scratchpad";
+
+const hasScratchpadVersions = ({ db }: StoreUpgradeContext) =>
+  Boolean(
+    db
+      .prepare("SELECT 1 FROM versions WHERE review_id=? LIMIT 1")
+      .get(OLD_SCRATCHPAD_ID),
+  );
+
+type PadSnapshot = { document: JsonValue[]; [key: string]: JsonValue };
+
+/** A pad version's snapshot with its document in today's form (old pads
+ * held anchors as objects); undefined for one that won't parse. */
+function parsePadVersion(text: string): PadSnapshot | undefined {
+  try {
+    // SAFETY: versions holds snapshots validated when they were saved.
+    const snapshot = JSON.parse(text) as PadSnapshot;
+    const document = migrateStoredDocument(snapshot.document);
+
+    snapshot.document = Array.isArray(document) ? document : [];
+
+    return snapshot;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Each pad version as parsed, by version, for one open. The run, inside
+ * the write lock, reads the rows again: it reuses a parse only of text that
+ * hasn't changed since. */
+const parsedPads = new WeakMap<
+  StoreUpgradeContext,
+  Map<number, { text: string; snapshot: PadSnapshot | undefined }>
+>();
+
+function padVersion(
+  context: StoreUpgradeContext,
+  version: number,
+  text: string,
+) {
+  let parsed = parsedPads.get(context);
+
+  if (!parsed) parsedPads.set(context, (parsed = new Map()));
+  const known = parsed.get(version);
+
+  if (known?.text === text) return known.snapshot;
+
+  const snapshot = parsePadVersion(text);
+
+  parsed.set(version, { text, snapshot });
+
+  return snapshot;
+}
+
+/** The pad's versions, oldest first, each parsed once per open. */
+const scratchpadVersions = (context: StoreUpgradeContext) =>
+  context.db
+    .prepare(
+      "SELECT version,snapshot FROM versions WHERE review_id=? ORDER BY version",
+    )
+    .all(OLD_SCRATCHPAD_ID)
+    .map((row) => ({
+      version: Number(row.version),
+      snapshot: padVersion(context, Number(row.version), String(row.snapshot)),
+    }));
+
+/** The pad's newest version that parses, reading no further back. */
+function latestScratchpadDocument(context: StoreUpgradeContext) {
+  for (const row of context.db
+    .prepare(
+      "SELECT version,snapshot FROM versions WHERE review_id=? ORDER BY version DESC",
+    )
+    .iterate(OLD_SCRATCHPAD_ID)) {
+    const snapshot = padVersion(
+      context,
+      Number(row.version),
+      String(row.snapshot),
+    );
+
+    if (snapshot) return snapshot.document;
+  }
+
+  return undefined;
+}
+
+/** The checkout the pad quotes most, else the one opened last. Only a
+ * checkout that still exists: a plan opens on it. */
+function scratchpadRepository(context: StoreUpgradeContext) {
+  const exists = (repositoryId: string) => {
+    try {
+      return existsSync(context.repositoryPath(repositoryId));
+    } catch {
+      return false;
+    }
+  };
+
+  const counts = new Map<string, number>();
+
+  // SAFETY: a stored pad's blocks, in today's form.
+  const latest = latestScratchpadDocument(context) as Block[] | undefined;
+
+  for (const { source } of sourceReferences(latest ?? [], {
+    tolerant: true,
+  })) {
+    const repositoryId = source.pins?.repositoryId;
+
+    if (repositoryId && exists(repositoryId))
+      counts.set(repositoryId, (counts.get(repositoryId) ?? 0) + 1);
+  }
+
+  const [quoted] = [...counts].sort((a, b) => b[1] - a[1])[0] ?? [];
+
+  if (quoted) return quoted;
+
+  const viewed = context.db
+    .prepare(
+      `SELECT ${BOARD_REPOSITORY_ID_SQL} AS repository
+      FROM review_attention
+      JOIN reviews ON reviews.id=review_attention.review_id
+      JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
+      WHERE review_attention.viewed_at IS NOT NULL AND repository IS NOT NULL
+      ORDER BY review_attention.viewed_at DESC`,
+    )
+    .all()
+    .map(({ repository }) => String(repository));
+
+  return [...viewed, ...context.repositories().map(({ id }) => id)].find(
+    exists,
+  );
+}
+
+const snapshots = (
+  context: StoreUpgradeContext,
+  own: string,
+  document: JsonValue[],
+  allocate: (prefix: string) => string,
+) =>
+  snapshotForeignReferences(
+    document,
+    own,
+    context.fileAtCommit,
+    context.repositoryName,
+    allocate,
+  );
+
+/** Reads the files the pad quotes, which the context keeps, before the
+ * write lock other hosts on this home wait on. */
+export function readScratchpadQuotes(context: StoreUpgradeContext) {
+  if (!hasScratchpadVersions(context)) return;
+
+  const quoting = scratchpadRepository(context);
+
+  if (quoting)
+    for (const { snapshot } of scratchpadVersions(context))
+      if (snapshot)
+        snapshots(context, quoting, snapshot.document, (prefix) => prefix);
+}
+
+export function planFromScratchpad(context: StoreUpgradeContext) {
+  const { db } = context;
+
+  // A pad row with no versions has nothing to keep; it stays as it is.
+  if (!hasScratchpadVersions(context)) return;
+
+  const own = scratchpadRepository(context);
+  const id = randomUUID();
+
+  db.prepare(
+    "INSERT INTO reviews(id,version,next_id,project_id) SELECT ?,version,next_id,? FROM reviews WHERE id=?",
+  ).run(
+    id,
+    own ? context.projectOfRepository(own) : context.fallbackProject(),
+    OLD_SCRATCHPAD_ID,
+  );
+
+  let nextId = Number(
+    db.prepare("SELECT next_id FROM reviews WHERE id=?").get(id)!.next_id,
+  );
+
+  const old = scratchpadVersions(context);
+
+  // The run changes the snapshots it took; nothing parses them again.
+  parsedPads.delete(context);
+
+  // Every version moves over; one that no longer parses, as it is.
+  db.prepare("UPDATE versions SET review_id=? WHERE review_id=?").run(
+    id,
+    OLD_SCRATCHPAD_ID,
+  );
+
+  for (const { version, snapshot } of old) {
+    if (!snapshot) continue;
+
+    delete snapshot.kind;
+
+    snapshot.reviewId = id;
+    snapshot.title = "Scratchpad";
+
+    if (own) {
+      snapshot.target = { kind: "project", repositoryId: own };
+      snapshot.document = snapshots(
+        context,
+        own,
+        snapshot.document,
+        (prefix) => `${prefix}-${++nextId}`,
+      );
+    }
+
+    context.rewriteVersion(id, version, snapshot);
+  }
+
+  db.prepare("UPDATE reviews SET next_id=? WHERE id=?").run(nextId, id);
+
+  // Tables a store makes after its upgrades may not exist yet. A thread's
+  // board is its review_id until ask-threads-by-project renames it, which
+  // a development build may have done already.
+  for (const [table, ...names] of [
+    ["ask_conversations", "review_id", "anchor_board"],
+    ["authoring_presences", "review_id"],
+    ["review_coverage", "review_id"],
+    ["review_attention", "review_id"],
+  ]) {
+    const columns = columnsOf(db, table!);
+    const column = names.find((name) => columns.has(name));
+
+    if (column)
+      db.prepare(`UPDATE ${table} SET ${column}=? WHERE ${column}=?`).run(
+        id,
+        OLD_SCRATCHPAD_ID,
+      );
+  }
+
+  db.prepare("DELETE FROM reviews WHERE id=?").run(OLD_SCRATCHPAD_ID);
+}

package/src/review-api/store-migrations.ts

@@ -0,0 +1,355 @@
+import { existsSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+
+import type { JsonValue } from "@dev.fast/json";
+
+import { CheckoutGroups } from "./checkout-groups.js";
+import type { ReadAtCommit } from "./foreign-references.js";
+import {
+  planFromScratchpad,
+  readScratchpadQuotes,
+} from "./scratchpad-plan-upgrade.js";
+import { columnsOf, hasTable } from "./store-schema.js";
+
+// A store's one-time upgrades, in order. PRAGMA user_version holds the last
+// one a store has run, so each runs once per store and a later launch runs
+// none; a new store runs them all on its first open.
+//
+// A shipped step never changes: a fix is a new step at the end. Each step
+// upgrades a store as a release before user_version left it, which may
+// already have some of it done, or lack the tables it touches; so each
+// checks what it needs before changing anything.
+
+/** What a step may use besides the database. */
+export interface StoreUpgradeContext {
+  db: DatabaseSync;
+  /** Groups the registered checkouts, reading their git metadata. */
+  prepareCheckouts(): void;
+  repositories(): { id: string }[];
+  repositoryPath(repositoryId: string): string;
+  /** A checkout's name as its project labels it, else its folder. */
+  repositoryName(repositoryId: string): string;
+  /** Undefined when the file can't be read; each file is read once. */
+  fileAtCommit: ReadAtCommit;
+  /** A checkout's project, made on first use. */
+  projectOfRepository(repositoryId: string): string;
+  fallbackProject(): string;
+  /** Saves a version over what it was; the current one re-indexes its
+   * board's links, as every written version does. */
+  rewriteVersion(reviewId: string, version: number, snapshot: JsonValue): void;
+  firstRepositoryProject(): string;
+}
+
+interface StoreUpgrade {
+  version: number;
+  name: string;
+  /** It groups the checkouts, which the store can work out before it
+   * opens (`groupCheckoutsAhead`), else does before the write lock. */
+  groupsCheckouts?: true;
+  /** Slow reads to do before taking the write lock other hosts wait on. */
+  beforeLock?(context: StoreUpgradeContext): void;
+  /** For a table rebuild: foreign keys can't be turned off in a
+   * transaction. */
+  foreignKeysOff?: true;
+  run(context: StoreUpgradeContext): void;
+}
+
+/** Keep versions.author_kind to its values, as a CHECK would. */
+const VERSION_AUTHOR_TRIGGERS = `
+  CREATE TRIGGER IF NOT EXISTS versions_author_kind_insert BEFORE INSERT ON versions
+    WHEN NEW.author_kind NOT IN ('person','agent','system')
+    BEGIN SELECT RAISE(ABORT, 'versions.author_kind must be person, agent or system'); END;
+  CREATE TRIGGER IF NOT EXISTS versions_author_kind_update BEFORE UPDATE OF author_kind ON versions
+    WHEN NEW.author_kind NOT IN ('person','agent','system')
+    BEGIN SELECT RAISE(ABORT, 'versions.author_kind must be person, agent or system'); END;`;
+
+export const STORE_UPGRADES: readonly StoreUpgrade[] = [
+  {
+    version: 1,
+    name: "retired-tables",
+    // Tables earlier releases kept and nothing reads any more. Presences
+    // replaced authoring_sessions; both last minutes, so it isn't moved.
+    run: ({ db }) =>
+      db.exec(`DROP TABLE IF EXISTS receipts;
+        DROP TABLE IF EXISTS review_viewed;
+        DROP TABLE IF EXISTS authoring_drafts;
+        DROP TABLE IF EXISTS authoring_sessions;`),
+  },
+  {
+    version: 2,
+    name: "archive-to-trash",
+    // Archive became Trash: archived boards get Trash's full recovery
+    // window from the upgrade, since Archive kept them forever.
+    run: ({ db }) => {
+      if (!columnsOf(db, "review_attention").has("dismissed_at")) return;
+
+      db.exec(
+        "ALTER TABLE review_attention RENAME COLUMN dismissed_at TO deleted_at",
+      );
+      db.prepare(
+        "UPDATE review_attention SET deleted_at=? WHERE deleted_at IS NOT NULL",
+      ).run(new Date().toISOString());
+    },
+  },
+  {
+    version: 3,
+    name: "board-projects",
+    // Every board belongs to a project: its repository's, else the one of
+    // the board opened last. With hundreds of checkouts, grouping them
+    // reads a good deal of git metadata.
+    groupsCheckouts: true,
+    foreignKeysOff: true,
+    run: ({
+      db,
+      repositories,
+      projectOfRepository,
+      firstRepositoryProject,
+    }) => {
+      // A child's parent is found by it.
+      const parents = () =>
+        db.exec(
+          "CREATE INDEX IF NOT EXISTS reviews_parent ON reviews(parent_id)",
+        );
+
+      // A new store has the columns from the start.
+      if (columnsOf(db, "reviews").has("project_id")) return parents();
+
+      // A checkout names its project; stores from before projects lack
+      // the column.
+      if (!columnsOf(db, "repositories").has("project_id"))
+        db.exec(
+          "ALTER TABLE repositories ADD COLUMN project_id TEXT REFERENCES projects(id)",
+        );
+
+      // In creation order, which the rebuild keeps. A board whose current
+      // version is missing is kept too, in the fallback project.
+      const boards = db
+        .prepare(
+          `SELECT reviews.id, CASE WHEN json_valid(versions.snapshot) THEN COALESCE(json_extract(versions.snapshot,'$.target.repositoryId'),json_extract(versions.snapshot,'$.pins.repositoryId')) END AS repository_id,
+            review_attention.viewed_at
+          FROM reviews LEFT JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
+          LEFT JOIN review_attention ON review_attention.review_id=reviews.id
+          ORDER BY reviews.rowid`,
+        )
+        .all();
+
+      const registered = new Set(repositories().map(({ id }) => id));
+      const projects = new Map<string, string>();
+
+      for (const { id, repository_id: repository } of boards)
+        if (repository && registered.has(String(repository)))
+          projects.set(String(id), projectOfRepository(String(repository)));
+
+      // The project of the board opened last.
+      const [opened] = boards
+        .filter(({ id, viewed_at }) => viewed_at && projects.has(String(id)))
+        .sort((a, b) => String(b.viewed_at).localeCompare(String(a.viewed_at)));
+
+      let fallback = opened && projects.get(String(opened.id));
+
+      const brokenReferences = () =>
+        db
+          .prepare("PRAGMA foreign_key_check")
+          .all()
+          .filter(({ parent }) => parent === "reviews").length;
+
+      // Only references this rebuild breaks; older dangling rows stay.
+      const broken = brokenReferences();
+
+      // A child names its parent; deleting the parent moves it to top
+      // level. No board had one before projects.
+      db.exec(`CREATE TABLE reviews_with_projects(id TEXT PRIMARY KEY, version INTEGER NOT NULL, next_id INTEGER NOT NULL,
+        project_id TEXT NOT NULL REFERENCES projects(id),
+        parent_id TEXT REFERENCES reviews(id) ON DELETE SET NULL)`);
+
+      const insert = db.prepare(
+        "INSERT INTO reviews_with_projects(id,version,next_id,project_id) SELECT id,version,next_id,? FROM reviews WHERE id=?",
+      );
+
+      for (const { id } of boards)
+        insert.run(
+          projects.get(String(id)) ?? (fallback ??= firstRepositoryProject()),
+          String(id),
+        );
+      db.exec(`DROP TABLE reviews;
+        ALTER TABLE reviews_with_projects RENAME TO reviews;`);
+      parents();
+
+      if (brokenReferences() > broken)
+        throw new Error("Giving boards projects broke a reference.");
+    },
+  },
+  {
+    version: 4,
+    name: "scratchpad-plan",
+    beforeLock: readScratchpadQuotes,
+    run: planFromScratchpad,
+  },
+  {
+    version: 5,
+    name: "ask-threads-by-project",
+    // Threads were kept per review. Each is now anchored on the board it
+    // started on, and is in that board's project.
+    run: ({ db }) => {
+      // The Threads tab's Project filter finds a project's boards by it.
+      db.exec(
+        "CREATE INDEX IF NOT EXISTS reviews_project ON reviews(project_id)",
+      );
+      const columns = columnsOf(db, "ask_conversations");
+
+      if (columns.size === 0) return;
+
+      if (columns.has("review_id"))
+        db.exec(
+          "ALTER TABLE ask_conversations RENAME COLUMN review_id TO anchor_board",
+        );
+
+      if (!columns.has("anchor_block"))
+        db.exec("ALTER TABLE ask_conversations ADD COLUMN anchor_block TEXT");
+    },
+  },
+  {
+    version: 6,
+    name: "version-threads",
+    // A version names the Ask thread that caused it in its own column.
+    // No release wrote one into a version, so earlier versions have none.
+    run: ({ db }) => {
+      if (!columnsOf(db, "versions").has("thread_id"))
+        db.exec("ALTER TABLE versions ADD COLUMN thread_id TEXT");
+
+      db.exec(
+        "CREATE INDEX IF NOT EXISTS versions_thread_id ON versions(thread_id)",
+      );
+    },
+  },
+  {
+    version: 7,
+    name: "viewed-on-upgrade",
+    // Every board counts as viewed at its latest version, so only later
+    // changes badge it.
+    run: ({ db }) =>
+      db.exec(`INSERT OR IGNORE INTO review_attention(review_id) SELECT id FROM reviews;
+        UPDATE review_attention SET viewed_at=COALESCE(NULLIF((
+          SELECT MAX(COALESCE(review_attention.viewed_at, ''), COALESCE(CASE WHEN json_valid(versions.snapshot) THEN json_extract(versions.snapshot,'$.createdAt') END, ''))
+          FROM reviews JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
+          WHERE reviews.id=review_attention.review_id), ''), review_attention.viewed_at)
+        WHERE review_id IN (SELECT id FROM reviews);`),
+  },
+  {
+    version: 8,
+    name: "ask-thread-viewed",
+    // A thread keeps when it was last seen; one saved before has none.
+    run: ({ db }) => {
+      const columns = columnsOf(db, "ask_conversations");
+
+      if (columns.size > 0 && !columns.has("viewed_at"))
+        db.exec("ALTER TABLE ask_conversations ADD COLUMN viewed_at TEXT");
+    },
+  },
+  {
+    version: 9,
+    name: "version-authors",
+    // Who wrote each version, a person or an agent, in its own column.
+    // Releases didn't record it: an agent's command and a person's edit on
+    // the canvas saved alike, so earlier versions have none. Triggers keep
+    // the column to its values; a CHECK added with it would have SQLite read
+    // every version, all of their JSON, to check the empty column.
+    run: ({ db }) => {
+      if (!columnsOf(db, "versions").has("author_kind"))
+        db.exec("ALTER TABLE versions ADD COLUMN author_kind TEXT");
+
+      db.exec(VERSION_AUTHOR_TRIGGERS);
+    },
+  },
+  {
+    version: 10,
+    name: "ask-permissions",
+    // Auto mode keeps what an Ask thread may do without asking; threads
+    // saved before it lack the column.
+    run: ({ db }) => {
+      const columns = columnsOf(db, "ask_conversations");
+
+      if (columns.size > 0 && !columns.has("permissions"))
+        db.exec("ALTER TABLE ask_conversations ADD COLUMN permissions TEXT");
+    },
+  },
+];
+
+export const STORE_VERSION = STORE_UPGRADES.at(-1)!.version;
+
+export const storeVersion = (db: DatabaseSync) =>
+  Number(db.prepare("PRAGMA user_version").get()!.user_version);
+
+/** Runs every step the store hasn't, each in its own transaction with the
+ * version it reaches, so a failed step rolls back alone and stops the store
+ * opening, naming the step; the ones before it stay done. A store at a
+ * later version than this build knows is left as it is. */
+export function upgradeStore(context: StoreUpgradeContext) {
+  const { db } = context;
+
+  for (const step of STORE_UPGRADES) {
+    if (storeVersion(db) >= step.version) continue;
+
+    if (step.groupsCheckouts) context.prepareCheckouts();
+    step.beforeLock?.(context);
+
+    if (step.foreignKeysOff) db.exec("PRAGMA foreign_keys=OFF");
+
+    db.exec("BEGIN IMMEDIATE");
+
+    try {
+      // Another host on this home may have run it while this one waited.
+      if (storeVersion(db) < step.version) {
+        step.run(context);
+        db.exec(`PRAGMA user_version=${step.version}`);
+      }
+
+      db.exec("COMMIT");
+    } catch (error) {
+      // SQLite may have rolled back already, on a full disk say; the error
+      // that made it is the one to report.
+      if (db.isTransaction) db.exec("ROLLBACK");
+      throw new Error(
+        `Could not upgrade the whiteboard store: step ${step.version} (${step.name}) failed and was rolled back. ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error },
+      );
+    } finally {
+      if (step.foreignKeysOff) db.exec("PRAGMA foreign_keys=ON");
+    }
+  }
+}
+
+/** How the store's checkouts group, worked out before it opens, asking
+ * several repositories at once, when an upgrade still to run needs it;
+ * undefined otherwise, or when the store can't be read so, and the step
+ * works it out itself. */
+export async function groupCheckoutsAhead(
+  databasePath: string,
+): Promise<ReadonlyMap<string, string> | undefined> {
+  if (!existsSync(databasePath)) return undefined;
+
+  let db: DatabaseSync | undefined;
+
+  try {
+    db = new DatabaseSync(databasePath, { timeout: 5000 });
+    const version = storeVersion(db);
+
+    if (
+      !STORE_UPGRADES.some(
+        (step) => step.groupsCheckouts && step.version > version,
+      ) ||
+      !columnsOf(db, "repositories").size
+    )
+      return undefined;
+
+    const groups = new CheckoutGroups(db);
+
+    await groups.prepareConcurrently();
+
+    return groups.prepared;
+  } catch {
+    return undefined;
+  } finally {
+    db?.close();
+  }
+}

package/src/review-api/store-schema.ts

@@ -1,46 +1,55 @@
 import type { DatabaseSync } from "node:sqlite";
 
+/** A board version's repository in SQL over `versions.snapshot`, as
+ * `boardRepositoryId` reads it: its target's, else its pins'. */
+export const BOARD_REPOSITORY_ID_SQL =
+  "CASE WHEN json_valid(versions.snapshot) THEN COALESCE(json_extract(versions.snapshot,'$.target.repositoryId'),json_extract(versions.snapshot,'$.pins.repositoryId')) END";
+
+export const columnsOf = (db: DatabaseSync, table: string) =>
+  new Set(
+    db
+      .prepare("SELECT name FROM pragma_table_info(?)")
+      .all(table)
+      .map(({ name }) => String(name)),
+  );
+
+export const hasTable = (db: DatabaseSync, table: string) =>
+  Boolean(
+    db
+      .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?")
+      .get(table),
+  );
+
 export function initializeReviewStoreSchema(db: DatabaseSync): void {
   db.exec(`
     PRAGMA journal_mode=WAL;
     PRAGMA foreign_keys=ON;
-    CREATE TABLE IF NOT EXISTS reviews(id TEXT PRIMARY KEY, version INTEGER NOT NULL, next_id INTEGER NOT NULL);
+    CREATE TABLE IF NOT EXISTS reviews(id TEXT PRIMARY KEY, version INTEGER NOT NULL, next_id INTEGER NOT NULL,
+      project_id TEXT NOT NULL REFERENCES projects(id), parent_id TEXT REFERENCES reviews(id) ON DELETE SET NULL);
     CREATE TABLE IF NOT EXISTS versions(review_id TEXT REFERENCES reviews(id), version INTEGER, snapshot TEXT NOT NULL,
+      thread_id TEXT, author_kind TEXT,
       PRIMARY KEY(review_id,version));
-    DROP TABLE IF EXISTS receipts;
     CREATE TABLE IF NOT EXISTS review_attention(review_id TEXT PRIMARY KEY REFERENCES reviews(id), viewed_at TEXT, deleted_at TEXT);
-    CREATE TABLE IF NOT EXISTS repositories(id TEXT PRIMARY KEY, path TEXT NOT NULL UNIQUE, name TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS projects(id TEXT PRIMARY KEY, name TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS repositories(id TEXT PRIMARY KEY, path TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
+      project_id TEXT REFERENCES projects(id));
     CREATE TABLE IF NOT EXISTS resources(id TEXT PRIMARY KEY, repository_id TEXT NOT NULL REFERENCES repositories(id),
       kind TEXT NOT NULL, mime_type TEXT NOT NULL, data BLOB NOT NULL);
     CREATE TABLE IF NOT EXISTS review_coverage(review_id TEXT REFERENCES reviews(id), file TEXT, fingerprint TEXT NOT NULL, coverage TEXT NOT NULL,
       PRIMARY KEY(review_id,file));
-    DROP TABLE IF EXISTS review_viewed;
     CREATE TABLE IF NOT EXISTS comparison_stats(identity TEXT PRIMARY KEY, stats TEXT NOT NULL);
     CREATE TABLE IF NOT EXISTS server_identity(one INTEGER PRIMARY KEY CHECK(one=1), id TEXT NOT NULL);
-    DROP TABLE IF EXISTS authoring_drafts;
+    CREATE TABLE IF NOT EXISTS board_dependencies(review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+      depends_on TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE, PRIMARY KEY(review_id,depends_on));
+    CREATE INDEX IF NOT EXISTS board_dependencies_depends_on ON board_dependencies(depends_on);
+    -- A link goes with the board it is on. Where it points stays plain
+    -- text, no foreign key: a link to a deleted board stays, and reads
+    -- "Board deleted" from the deleted_boards tombstone.
+    CREATE TABLE IF NOT EXISTS board_links(from_review TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE, from_block TEXT NOT NULL,
+      to_review TEXT NOT NULL, to_block TEXT);
+    CREATE INDEX IF NOT EXISTS board_links_from ON board_links(from_review);
+    CREATE INDEX IF NOT EXISTS board_links_to ON board_links(to_review);
+    CREATE TABLE IF NOT EXISTS deleted_boards(id TEXT PRIMARY KEY, title TEXT NOT NULL, deleted_at TEXT NOT NULL,
+      project_id TEXT);
   `);
-
-  db.exec("BEGIN IMMEDIATE");
-
-  try {
-    // Migrate the former Archive timestamp without losing recoverable boards.
-    const attentionColumns = db
-      .prepare("PRAGMA table_info(review_attention)")
-      .all();
-
-    if (attentionColumns.some((column) => column.name === "dismissed_at")) {
-      db.exec(
-        "ALTER TABLE review_attention RENAME COLUMN dismissed_at TO deleted_at",
-      );
-      // Archive had no retention limit. Give migrated boards the full recovery window.
-      db.prepare(
-        "UPDATE review_attention SET deleted_at=? WHERE deleted_at IS NOT NULL",
-      ).run(new Date().toISOString());
-    }
-
-    db.exec("COMMIT");
-  } catch (error) {
-    db.exec("ROLLBACK");
-    throw error;
-  }
 }