alinea 2.0.0-preview.11 → 2.0.0-preview.13

package/dist/dashboard/boot/DashboardWorker.js

@@ -9,13 +9,16 @@ import { getScope } from "alinea/core/Scope";
 import { trigger } from "alinea/core/Trigger";
 import { IndexEvent } from "alinea/core/db/IndexEvent";
 import { EntryUrlConflictError } from "alinea/core/db/EntryUrlConflictError";
-import { EntryValidationError } from "alinea/core/db/EntryValidationError";
-import { BrowserEntryStore } from "alinea/database/BrowserEntryStore";
+import {
+  BrowserEntryStore,
+  isCorruptDatabaseError
+} from "alinea/database/BrowserEntryStore";
 import { EntryStore } from "alinea/database/EntryStore";
 import {
   ActivityEvent
 } from "./ActivityEvent.js";
 var remote = pLimit(1);
+var cacheName = "alinea-entry-database";
 var syncInterval = 12e4;
 var activityHistoryLimit = 100;
 var DashboardWorker = class extends EventTarget {
@@ -24,14 +27,13 @@ var DashboardWorker = class extends EventTarget {
   #localClient;
   #nextLoad = trigger();
   #defer;
-  /** The store kept in IndexedDB, which a replacement takes over from. */
-  #stored;
   #currentRevision;
   #mutations = [];
   #activities = [];
   #local = pLimit(1);
   #blocked = false;
   #syncInterval;
+  /** Keep the content in memory with `source`, instead of in the browser. */
   constructor(source) {
     super();
     this.#source = source;
@@ -114,7 +116,7 @@ Remote updates: ${remote2}`
         void this.#flush(item);
         return item.sha;
       } catch (error) {
-        if (error instanceof EntryUrlConflictError || error instanceof EntryValidationError) {
+        if (error instanceof EntryUrlConflictError) {
           this.#cancelMutation(item, error);
           throw error;
         }
@@ -278,17 +280,17 @@ Remote updates: ${remote2}`
     this.#localDB = void 0;
     this.#localClient = void 0;
     try {
-      const db = globalThis.indexedDB ? await BrowserEntryStore.open(config, {
-        name: "alinea-entry-database",
-        revision,
-        replaces: this.#stored
-      }) : await EntryStore.memory(config, this.#fallbackSource());
-      if (db instanceof BrowserEntryStore) this.#stored = db;
+      let db = await this.#open(config, revision, false);
       if (this.#defer)
         void this.#defer().catch(() => {
         });
       this.#defer = void 0;
-      const cacheFailure = await this.#syncLocalIndex(db);
+      let cacheFailure = await this.#syncLocalIndex(db);
+      if (cacheFailure && isCorruptDatabaseError(cacheFailure.error)) {
+        await db.close();
+        db = await this.#open(config, revision, true);
+        cacheFailure = await this.#syncLocalIndex(db);
+      }
       if (hadPrevious && (await db.source.getTree()).isEmpty)
         await this.#syncWithClient(db, client).catch(() => {
         });
@@ -306,8 +308,7 @@ Remote updates: ${remote2}`
       });
       this.#defer = async () => {
         unsubscribe();
-        if (db instanceof BrowserEntryStore) await db.abandon();
-        else await db.close();
+        await db.close();
       };
     } catch (cause) {
       this.#currentRevision = void 0;
@@ -316,10 +317,9 @@ Remote updates: ${remote2}`
       throw cause;
     }
   }
-  #fallbackSource() {
-    if (!this.#source)
-      throw new Error("A source is required when IndexedDB is unavailable");
-    return this.#source;
+  #open(config, fingerprint, reset) {
+    if (this.#source) return EntryStore.memory(config, this.#source);
+    return BrowserEntryStore.open(config, { name: cacheName, fingerprint, reset });
   }
   async #syncLocalIndex(db) {
     const sourceTree = await db.source.getTree();

package/dist/dashboard/boot/LoadWorker.js

@@ -5,19 +5,14 @@ import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/dashboard/boot/LoadWorker.ts
 import { IndexEvent } from "alinea/core/db/IndexEvent";
-import { MemorySource } from "alinea/core/source/MemorySource";
 import { ActivityEvent } from "./ActivityEvent.js";
 import { DashboardWorker } from "./DashboardWorker.js";
 async function loadWorker(gen) {
-  const worker = new DashboardWorker(new MemorySource());
-  addEventListener("connect", (event) => {
-    if (!(event instanceof MessageEvent)) return;
-    console.info("Worker connected");
-    const port = event.ports[0];
-    expose(worker, port);
-    const listen = (event2) => {
+  const worker = new DashboardWorker();
+  function forward(target) {
+    const listen = (event) => {
       try {
-        port.postMessage({ ...event2, type: event2.type });
+        target.postMessage({ ...event, type: event.type });
       } catch {
         worker.removeEventListener(IndexEvent.type, listen);
         worker.removeEventListener(ActivityEvent.type, listen);
@@ -25,7 +20,19 @@ async function loadWorker(gen) {
     };
     worker.addEventListener(IndexEvent.type, listen);
     worker.addEventListener(ActivityEvent.type, listen);
-  });
+  }
+  if ("onconnect" in globalThis) {
+    addEventListener("connect", (event) => {
+      if (!(event instanceof MessageEvent)) return;
+      console.info("Worker connected");
+      const port = event.ports[0];
+      expose(worker, port);
+      forward(port);
+    });
+  } else {
+    expose(worker, globalThis);
+    forward(globalThis);
+  }
   for await (const batch of gen) {
     await worker.load(batch.configFingerprint, batch.config, batch.client);
   }

package/dist/dashboard/cms/EntryTable.js

@@ -1,6 +1,6 @@
 import {
   unwrap
-} from "../../chunks/chunk-TIJTT5ZI.js";
+} from "../../chunks/chunk-G43W7AME.js";
 import {
   useAtomValueRaw,
   useAtomValueRawSync,
@@ -37,6 +37,7 @@ import {
 import { Schema } from "alinea/core/Schema";
 import { getScope } from "alinea/core/Scope";
 import { Type } from "alinea/core/Type";
+import { EntryStatusIcon, entryStatus } from "../app/EntryStatusIcon.js";
 import {
   OverviewCell,
   overviewCellText,
@@ -234,17 +235,19 @@ function EntryTableRow({ config, overview, row }) {
   const texts = overview.columns.map(
     (column) => overviewCellText(config, column, row, links)
   );
+  const status = entryStatus(row);
   return /* @__PURE__ */ jsxs(
     TableRow,
     {
       id: row.id,
-      textValue: [row.title, ...texts].filter(Boolean).join(" "),
+      textValue: [row.title, status?.label, ...texts].filter(Boolean).join(" "),
       children: [
         /* @__PURE__ */ jsx(
           TableTitle,
           {
             icon: type && getType(type).icon || LucideFile,
-            title: row.title
+            title: row.title,
+            suffix: status && /* @__PURE__ */ jsx(EntryStatusIcon, { status })
           }
         ),
         overview.columns.map((column, index) => /* @__PURE__ */ jsx(

package/dist/database/BrowserEntryStore.d.ts

@@ -1,47 +1,35 @@
 import type { Config } from 'alinea/core/Config';
-import type { Mutation } from 'alinea/core/db/Mutation';
-import type { CommitRequest } from 'alinea/core/db/CommitRequest';
 import type { SyncOptions } from 'alinea/core/db/LocalStore';
 import type { RemoteSource } from 'alinea/core/source/Source';
+import { type SnapshotStorage } from '@alinea/sqlite-wasm/snapshots';
 import { EntryStore } from './EntryStore.js';
 export interface BrowserEntryStoreOptions {
     name: string;
-    revision: string;
+    /** Stores of one config fingerprint open the bases it wrote. */
+    fingerprint: string;
+    /** Where bases are kept, Blobs in IndexedDB by default. */
+    storage?: SnapshotStorage;
     /**
-     * The store this one replaces, such as one of a previous dashboard build:
-     * its content carries over from memory instead of loading it again, and it
-     * stops storing without waiting for its work in flight.
+     * Start over from an empty database instead of a stored base, such as
+     * when it turned out to be corrupt.
      */
-    replaces?: BrowserEntryStore;
-    /** The IndexedDB implementation, the global one by default. */
-    indexedDB?: IDBFactory;
-    IDBKeyRange?: typeof IDBKeyRange;
+    reset?: boolean;
 }
 /**
- * WASM entry store kept in IndexedDB: every commit stores the pages it
- * changed.
+ * WASM entry store on a copy-on-write overlay over the newest stored base:
+ * it reads pages from the base as queries need them, and keeps its changes
+ * in memory. Every sync stores them as a new base in the background, which
+ * the next store opens; the stored bases never change, so stores of any
+ * number of workers and dashboard builds can use them at once.
  */
 export declare class BrowserEntryStore extends EntryStore {
     #private;
-    static open(config: Config, options: BrowserEntryStoreOptions, retried?: boolean): Promise<BrowserEntryStore>;
+    static open(config: Config, options: BrowserEntryStoreOptions): Promise<BrowserEntryStore>;
     private constructor();
-    /**
-     * Opening, and syncing, resolve once the content is in memory: storing it
-     * is a cache that finishes in the background, which takes seconds for a
-     * first sync or a rebuild of a large project.
-     */
     sync(): Promise<string>;
     syncWith(remote: RemoteSource, options?: SyncOptions): Promise<string>;
-    mutate(mutations: Array<Mutation>): Promise<{
-        sha: string;
-    }>;
-    write(request: CommitRequest): Promise<{
-        sha: string;
-    }>;
+    /** Close once the last checkpoint is stored. */
     close(): Promise<void>;
-    /**
-     * Close a store that a replacement took over from: its work in flight
-     * changes only its memory copy, which is not stored.
-     */
-    abandon(): Promise<void>;
 }
+/** Whether an error, or one it holds, reports a damaged SQLite database. */
+export declare function isCorruptDatabaseError(error: unknown): boolean;

package/dist/database/BrowserEntryStore.js

@@ -5,177 +5,148 @@ import "../chunks/chunk-CQ52GEHY.js";
 
 // src/database/BrowserEntryStore.ts
 import { ReadonlyTree } from "alinea/core/source/Tree";
-import { TaskQueue } from "alinea/core/util/Async";
-import { indexedDBStorage } from "@alinea/sqlite-wasm/indexeddb";
-import { versionedCacheName } from "./Version.js";
+import { isRecord } from "alinea/core/util/Objects";
+import {
+  indexedDBSnapshots
+} from "@alinea/sqlite-wasm/snapshots";
+import { databaseVersion, versionedCacheName } from "./Version.js";
 import { EntryDatabase } from "./EntryDatabase.js";
 import { EntryStore } from "./EntryStore.js";
 import { DatabaseSource } from "./DatabaseSource.js";
-import {
-  syncWasmDatabase
-} from "./driver/WasmDatabase.js";
-var buildTable = sql.identifier("alinea_dashboard_build");
+import { wasmHandle, wasmSqlite } from "./driver/WasmDatabase.js";
+var cacheSize = -65536;
+var keepBranches = 2;
 var BrowserEntryStore = class _BrowserEntryStore extends EntryStore {
-  #handle;
-  #indexedDB;
-  #baseName;
-  #storageName;
-  #persistQueue = new TaskQueue();
-  #closed = false;
-  #detached = false;
-  static async open(config, options, retried = false) {
-    const factory = options.indexedDB ?? indexedDB;
-    const storageName = storageNameOf(options.name);
-    const storage = indexedDBStorage(storageName, {
-      indexedDB: factory,
-      IDBKeyRange: options.IDBKeyRange ?? IDBKeyRange
-    });
-    let handle;
-    try {
-      handle = options.replaces ? await options.replaces.#handOver(storage) : await syncWasmDatabase(storage);
-      const db = handle.database;
-      await db.run(sql`pragma page_size = 65536`);
-      const stored = await storedBuild(db);
-      await EntryDatabase.createSchema(db, config, ReadonlyTree.EMPTY.sha);
-      const database = new EntryDatabase(config, db, { fork: handle.fork });
-      if (stored !== void 0 && stored !== options.revision)
-        await database.reindex(config);
-      if (stored !== options.revision)
-        await db.run(
-          sql`insert or replace into ${buildTable} (id, revision)
-            values (1, ${options.revision})`
-        );
-      return new _BrowserEntryStore(
+  #session;
+  #storage;
+  #stored;
+  #written = Promise.resolve();
+  #cleanup = Promise.resolve();
+  static async open(config, options) {
+    const { name, fingerprint } = options;
+    const storage = options.storage ?? indexedDBSnapshots(`${versionedCacheName(name)}-snapshots`);
+    const cleanup = !options.storage && globalThis.indexedDB ? cleanupOldCaches(indexedDB, name).catch(() => {
+    }) : Promise.resolve();
+    const Database = await wasmSqlite();
+    const session = options.reset ? storage.session(new Database(), { branch: fingerprint }) : await openBase(storage, Database, fingerprint);
+    const store = await _BrowserEntryStore.#on(
+      config,
+      session,
+      storage,
+      fingerprint
+    ).catch((error) => {
+      if (!session.snapshot) throw error;
+      return _BrowserEntryStore.#on(
         config,
-        database,
-        handle,
-        factory,
-        options.name,
-        storageName
+        storage.session(new Database(), { branch: fingerprint }),
+        storage,
+        fingerprint
       );
-    } catch (error) {
-      if (handle) await handle.database.close();
-      if (retried) throw error;
-      await storage.delete();
-      return _BrowserEntryStore.open(
-        config,
-        { ...options, replaces: void 0 },
-        true
-      );
-    }
+    });
+    store.#cleanup = cleanup;
+    return store;
   }
-  /**
-   * Copy this store's database for a replacement stored in `storage`, and
-   * stop storing this one. The replacement is stored once this store's
-   * commits so far are written.
-   */
-  async #handOver(storage) {
-    const copy = await this.database.whileIdle(() => this.#handle.fork());
-    this.#detach();
-    try {
-      await copy.attach(storage);
+  static async #on(config, session, storage, fingerprint) {
+    const sqlite = session.db;
+    const branch = session.snapshot?.branch;
+    sqlite.run(`pragma cache_size = ${cacheSize}`);
+    const { database: db, fork } = wasmHandle(sqlite);
+    async function preview() {
+      const copy = await fork();
+      await copy.database.run(sql`pragma cache_size = -8192`);
       return copy;
+    }
+    try {
+      await db.run(sql`pragma page_size = 16384`);
+      await EntryDatabase.createSchema(db, config, ReadonlyTree.EMPTY.sha);
+      const database = new EntryDatabase(config, db, { fork: preview });
+      if (branch !== void 0 && branch !== fingerprint)
+        await withoutJournal(sqlite, () => database.reindex(config));
+      return new _BrowserEntryStore(config, database, session, storage);
     } catch (error) {
-      await copy.database.close();
+      await db.close();
       throw error;
     }
   }
-  #detach() {
-    if (this.#detached) return;
-    this.#detached = true;
-    this.#handle.detach();
-  }
-  constructor(config, database, handle, factory, baseName, storageName) {
+  constructor(config, database, session, storage) {
     super(config, database, new DatabaseSource(database), {
       ownsDatabase: true,
       sourceFollowsDatabase: true
     });
-    this.#handle = handle;
-    this.#indexedDB = factory;
-    this.#baseName = baseName;
-    this.#storageName = storageName;
-  }
-  /**
-   * Opening, and syncing, resolve once the content is in memory: storing it
-   * is a cache that finishes in the background, which takes seconds for a
-   * first sync or a rebuild of a large project.
-   */
-  sync() {
-    return this.#run(() => super.sync());
-  }
-  syncWith(remote, options) {
-    return this.#run(() => super.syncWith(remote, options));
-  }
-  mutate(mutations) {
-    return this.#persistAfter(() => super.mutate(mutations));
-  }
-  write(request) {
-    return this.#persistAfter(() => super.write(request));
+    this.#session = session;
+    this.#storage = storage;
   }
-  /** Resolve once the commits of a task that changed this store are stored. */
-  #persistAfter(task) {
-    return this.#run(async () => {
-      const result = await task();
-      await this.#handle.flush();
-      return result;
-    });
+  async sync() {
+    return this.#checkpoint(await super.sync());
   }
-  #run(task) {
-    if (this.#closed)
-      return Promise.reject(new Error("BrowserEntryStore is closed"));
-    return this.#persistQueue.run(task);
+  async syncWith(remote, options) {
+    return this.#checkpoint(await super.syncWith(remote, options));
   }
-  close() {
-    if (this.#closed) return this.#persistQueue.drain();
-    this.#closed = true;
-    return this.#persistQueue.run(async () => {
-      try {
-        await super.close();
-      } finally {
-        await cleanupOldCaches(
-          this.#indexedDB,
-          this.#baseName,
-          this.#storageName
-        );
-      }
+  /** Store the content at `revision` as a base, in the background. */
+  #checkpoint(revision) {
+    if (!this.#storage.supported() || this.#stored === revision) return revision;
+    this.#stored = revision;
+    const session = this.#session;
+    const storage = this.#storage;
+    const key = `${revision}-${session.branch}`;
+    const save = (key2) => this.database.whileIdle(async () => ({
+      saved: session.held ? session.save({ key: key2, meta: { tree: revision } }) : void 0
+    })).then(({ saved }) => saved);
+    const written = save(key).then(
+      (result) => result?.status === "mismatch" ? save(`${key}-${crypto.randomUUID()}`) : result
+    ).then(() => storage.retain({ branches: keepBranches })).catch(() => {
+      if (this.#stored === revision) this.#stored = void 0;
     });
+    this.#written = Promise.all([this.#written, written]);
+    return revision;
   }
-  /**
-   * Close a store that a replacement took over from: its work in flight
-   * changes only its memory copy, which is not stored.
-   */
-  abandon() {
-    this.#detach();
-    if (this.#closed) return this.#persistQueue.drain();
-    this.#closed = true;
-    return this.#persistQueue.run(() => super.close());
+  /** Close once the last checkpoint is stored. */
+  async close() {
+    await Promise.all([this.#cleanup, this.#written]);
+    await super.close();
   }
 };
-function storageNameOf(name) {
-  return `${versionedCacheName(name)}-pages`;
+var corruptCodes = /* @__PURE__ */ new Set(["SQLITE_CORRUPT", "SQLITE_NOTADB"]);
+var corruptMessage = /database disk image is malformed|file is not a database/;
+function isCorruptDatabaseError(error) {
+  if (!isRecord(error)) return false;
+  if (typeof error.code === "string" && corruptCodes.has(error.code))
+    return true;
+  if (typeof error.message === "string" && corruptMessage.test(error.message))
+    return true;
+  const errors = Array.isArray(error.errors) ? error.errors : [];
+  return isCorruptDatabaseError(error.cause) || errors.some(isCorruptDatabaseError);
 }
-async function storedBuild(db) {
-  await db.run(sql`create table if not exists ${buildTable} (
-    id integer primary key,
-    revision text not null
-  )`);
-  const row = await db.get(
-    sql`select revision from ${buildTable} where id = 1`
-  );
-  if (row) return row.revision;
-  const entries = await db.get(
-    sql`select count(*) as count from sqlite_master
-      where type = 'table' and name = 'alinea_entry_index'`
-  );
-  return entries?.count ? "" : void 0;
+async function withoutJournal(sqlite, task) {
+  const [[mode]] = sqlite.exec("pragma journal_mode")[0].values;
+  sqlite.run("pragma journal_mode = off");
+  try {
+    return await task();
+  } finally {
+    sqlite.run(`pragma journal_mode = ${mode}`);
+  }
+}
+async function openBase(storage, Database, fingerprint) {
+  const empty = () => storage.session(new Database(), { branch: fingerprint });
+  if (!storage.supported()) return empty();
+  return storage.open(Database, {
+    branch: fingerprint,
+    choose: (bases) => bases.find((base) => base.branch === fingerprint) ?? bases[0]
+  }).catch(empty);
 }
-async function cleanupOldCaches(factory, baseName, currentName) {
+async function cleanupOldCaches(factory, name) {
   if (!factory.databases) return;
   const databases = await factory.databases().catch(() => []);
-  const names = databases.flatMap(
-    (database) => database.name && database.name !== currentName && (database.name === baseName || database.name.startsWith(`${baseName}-`)) ? [database.name] : []
+  const stale = databases.flatMap(
+    (database) => database.name && isStale(database.name, name) ? [database.name] : []
   );
-  await Promise.all(names.map((name) => deleteCache(factory, name)));
+  await Promise.all(stale.map((cache) => deleteCache(factory, cache)));
+}
+function isStale(cache, name) {
+  if (cache === name || cache === `${versionedCacheName(name)}-pages`)
+    return true;
+  if (!cache.startsWith(`${name}-v`)) return false;
+  return Number.parseInt(cache.slice(name.length + 2)) < databaseVersion;
 }
 function deleteCache(factory, name) {
   return new Promise((resolve) => {
@@ -186,5 +157,6 @@ function deleteCache(factory, name) {
   });
 }
 export {
-  BrowserEntryStore
+  BrowserEntryStore,
+  isCorruptDatabaseError
 };

package/dist/database/DatabaseTables.js

@@ -4,10 +4,10 @@ import {
   number,
   text,
   varchar
-} from "../chunks/chunk-ASYKC6IE.js";
+} from "../chunks/chunk-5H4D5JQL.js";
 import {
   table
-} from "../chunks/chunk-MOWR65LM.js";
+} from "../chunks/chunk-PYDOMKJZ.js";
 import "../chunks/chunk-76VMZTLN.js";
 import "../chunks/chunk-2PIFHEYR.js";
 import "../chunks/chunk-K62JP6HR.js";

package/dist/database/EntryDatabase.js

@@ -11,6 +11,7 @@ import "../chunks/chunk-2PIFHEYR.js";
 import "../chunks/chunk-K62JP6HR.js";
 import "../chunks/chunk-ATF42T2B.js";
 import {
+  getTable,
   sql
 } from "../chunks/chunk-ETBQTP2S.js";
 import "../chunks/chunk-CQ52GEHY.js";
@@ -171,6 +172,7 @@ var EntryDatabase = class _EntryDatabase extends Graph {
         tree: revision === ReadonlyTree.EMPTY.sha ? ReadonlyTree.EMPTY : null
       });
     await syncFieldIndexes(db, config);
+    await analyze(db);
   }
   /**
    * Synchronize a source through this database's single prepared syncer,
@@ -194,6 +196,7 @@ var EntryDatabase = class _EntryDatabase extends Graph {
           recordsTree: this.#recordsTree
         });
         this.#tree = tree;
+        if (changed.length > 0) await this.#optimize();
         return changed;
       });
       const change = { revision: tree.sha, changedEntryIds };
@@ -222,7 +225,7 @@ var EntryDatabase = class _EntryDatabase extends Graph {
         const { tree } = await this.#readTreeState();
         if (!tree)
           throw new Error("Cannot reindex a database without a source tree");
-        return this.#db.transaction(
+        const reindexed = await this.#db.transaction(
           async (tx) => {
             await tx.run(sql`drop table if exists temp.${blobs}`);
             await tx.run(sql`create temp table ${blobs} as
@@ -273,6 +276,8 @@ var EntryDatabase = class _EntryDatabase extends Graph {
           },
           { async: true }
         );
+        await this.#optimize();
+        return reindexed;
       });
       this.#tree = result.tree;
       this.#vocabulary = new SearchVocabulary();
@@ -386,6 +391,9 @@ var EntryDatabase = class _EntryDatabase extends Graph {
   [Symbol.asyncDispose]() {
     return this.close();
   }
+  async #optimize() {
+    if (!this.#transactional) await analyze(this.#db);
+  }
   getRevision() {
     return this.#queue.run(() => this.#getRevision(this.#db));
   }
@@ -527,6 +535,18 @@ var EntryDatabase = class _EntryDatabase extends Graph {
     });
   }
 };
+async function analyze(db) {
+  try {
+    await db.run(sql`pragma analysis_limit = 400`);
+    const entries = getTable(EntryIndexTable).name;
+    const stats = await db.get(
+      sql`select 1 from sqlite_master where name = 'sqlite_stat1'`
+    );
+    const analyzed = stats && await db.get(sql`select 1 from sqlite_stat1 where tbl = ${entries}`);
+    await db.run(analyzed ? sql`pragma optimize = 0x10002` : sql`analyze`);
+  } catch {
+  }
+}
 export {
   EntryDatabase
 };