alinea 2.0.0-preview.12 → 2.0.0-preview.13

package/dist/dashboard/boot/DashboardWorker.js

@@ -9,10 +9,8 @@ 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,
-  holdCache,
   isCorruptDatabaseError
 } from "alinea/database/BrowserEntryStore";
 import { EntryStore } from "alinea/database/EntryStore";
@@ -21,7 +19,6 @@ import {
 } from "./ActivityEvent.js";
 var remote = pLimit(1);
 var cacheName = "alinea-entry-database";
-var cacheWait = 1e3;
 var syncInterval = 12e4;
 var activityHistoryLimit = 100;
 var DashboardWorker = class extends EventTarget {
@@ -30,14 +27,13 @@ var DashboardWorker = class extends EventTarget {
   #localClient;
   #nextLoad = trigger();
   #defer;
-  /** Whether this worker holds the cache, see #holdsCache. */
-  #cacheHeld;
   #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;
@@ -120,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;
         }
@@ -284,9 +280,11 @@ Remote updates: ${remote2}`
     this.#localDB = void 0;
     this.#localClient = void 0;
     try {
-      await this.#defer?.();
-      this.#defer = void 0;
       let db = await this.#open(config, revision, false);
+      if (this.#defer)
+        void this.#defer().catch(() => {
+        });
+      this.#defer = void 0;
       let cacheFailure = await this.#syncLocalIndex(db);
       if (cacheFailure && isCorruptDatabaseError(cacheFailure.error)) {
         await db.close();
@@ -310,9 +308,7 @@ Remote updates: ${remote2}`
       });
       this.#defer = async () => {
         unsubscribe();
-        if (db instanceof BrowserEntryStore) await db.release();
-        void db.close().catch(() => {
-        });
+        await db.close();
       };
     } catch (cause) {
       this.#currentRevision = void 0;
@@ -321,41 +317,9 @@ Remote updates: ${remote2}`
       throw cause;
     }
   }
-  /**
-   * Open a store with its content cached in IndexedDB. While another worker
-   * holds the cache, start from a copy of what it holds without storing,
-   * and else, or if the cache fails, keep the content in memory only.
-   */
-  async #open(config, revision, reset) {
-    if (globalThis.indexedDB) {
-      const options = { name: cacheName, revision };
-      if (await this.#holdsCache()) {
-        try {
-          return await BrowserEntryStore.open(config, { ...options, reset });
-        } catch (error) {
-          console.warn("Failed to open the content cache", error);
-        }
-      } else if (!reset) {
-        const snapshot = await BrowserEntryStore.snapshot(config, options);
-        if (snapshot) return snapshot;
-      }
-    }
-    return EntryStore.memory(config, this.#fallbackSource());
-  }
-  /**
-   * Whether this worker holds the cache, which it then keeps for as long as
-   * it runs: no other worker writes the cache meanwhile, such as one of
-   * another dashboard build. A worker that does not hold it stores nothing
-   * until the dashboard loads again.
-   */
-  #holdsCache() {
-    this.#cacheHeld ??= holdCache(cacheName, { wait: cacheWait });
-    return this.#cacheHeld;
-  }
-  #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,
@@ -65,9 +66,9 @@ import {
 var EntryTable_default = {
   "EntryTable-loading": "alinea-EntryTable-loading",
   "EntryTableLoading": "alinea-EntryTable-loading",
+  "EntryTable": "alinea-EntryTable",
   "EntryTable-table": "alinea-EntryTable-table",
-  "EntryTableTable": "alinea-EntryTable-table",
-  "EntryTable": "alinea-EntryTable"
+  "EntryTableTable": "alinea-EntryTable-table"
 };
 
 // src/dashboard/cms/EntryTable.tsx
@@ -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,84 +1,34 @@
 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;
     /**
-     * Start over from an empty database instead of the stored one, such as
+     * Start over from an empty database instead of a stored base, such as
      * when it turned out to be corrupt.
      */
     reset?: boolean;
-    /** The IndexedDB implementation, the global one by default. */
-    indexedDB?: IDBFactory;
-    IDBKeyRange?: typeof IDBKeyRange;
-    /** The Web Locks implementation, the global one by default. */
-    locks?: CacheLocks;
-}
-/** The part of the Web Locks API that keeps a cache to one worker. */
-export interface CacheLocks {
-    request(name: string, options: {
-        ifAvailable?: boolean;
-        signal?: AbortSignal;
-    }, callback: (lock: Lock | null) => Promise<void> | void): Promise<unknown>;
-}
-export interface HoldCacheOptions {
-    /**
-     * How long to wait, in milliseconds, for another worker that holds the
-     * cache to end: none by default, Infinity until it does.
-     */
-    wait?: number;
-    /** The Web Locks implementation, the global one by default. */
-    locks?: CacheLocks;
 }
 /**
- * Hold the cache called `name` for as long as this worker runs, and resolve
- * with whether it does. Nothing coordinates two stores writing the same
- * pages, which corrupts them, so only the worker that holds the cache opens
- * it; another one, such as one of another dashboard build, reads a
- * snapshot. Without Web Locks, or if they refuse, no worker holds it.
- */
-export declare function holdCache(name: string, options?: HoldCacheOptions): Promise<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;
-    /**
-     * Open the store kept in IndexedDB. Only the worker that holds the cache
-     * opens it (see `holdCache`), and deletes the caches of other versions.
-     */
     static open(config: Config, options: BrowserEntryStoreOptions): Promise<BrowserEntryStore>;
-    /**
-     * A copy in memory of the stored content, for a worker that cannot store
-     * it while another one does: it loads the last committed state and never
-     * writes. Resolves with undefined if that state cannot be read.
-     */
-    static snapshot(config: Config, options: BrowserEntryStoreOptions): Promise<EntryStore | undefined>;
     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;
-    }>;
-    /**
-     * Stop storing, and resolve once the commits so far are stored, for a
-     * replacement to open the cache. Work in flight then changes only this
-     * store's memory, so the replacement need not wait for it.
-     */
-    release(): Promise<void>;
+    /** Close once the last checkpoint is stored. */
     close(): Promise<void>;
 }
 /** Whether an error, or one it holds, reports a damaged SQLite database. */

package/dist/database/BrowserEntryStore.js

@@ -5,196 +5,105 @@ import "../chunks/chunk-CQ52GEHY.js";
 
 // src/database/BrowserEntryStore.ts
 import { ReadonlyTree } from "alinea/core/source/Tree";
-import { TaskQueue } from "alinea/core/util/Async";
 import { isRecord } from "alinea/core/util/Objects";
 import {
-  indexedDBStorage
-} from "@alinea/sqlite-wasm/indexeddb";
-import { versionedCacheName } from "./Version.js";
+  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");
-function holdCache(name, options = {}) {
-  const locks = options.locks ?? globalThis.navigator?.locks;
-  if (!locks) return Promise.resolve(false);
-  const { wait = 0 } = options;
-  const timeout = wait > 0 && wait < Infinity ? new AbortController() : void 0;
-  const timer = timeout && setTimeout(() => timeout.abort(), wait);
-  const request = wait === 0 ? { ifAvailable: true } : timeout ? { signal: timeout.signal } : {};
-  return new Promise((resolve) => {
-    try {
-      locks.request(storageNameOf(name), request, (lock) => {
-        clearTimeout(timer);
-        resolve(Boolean(lock));
-        if (lock) return new Promise(() => {
-        });
-      }).catch(() => resolve(false));
-    } catch {
-      resolve(false);
-    }
-  });
-}
+import { wasmHandle, wasmSqlite } from "./driver/WasmDatabase.js";
+var cacheSize = -65536;
+var keepBranches = 2;
 var BrowserEntryStore = class _BrowserEntryStore extends EntryStore {
-  #handle;
-  #persistQueue = new TaskQueue();
-  #closed = false;
-  #detached = false;
-  /**
-   * Open the store kept in IndexedDB. Only the worker that holds the cache
-   * opens it (see `holdCache`), and deletes the caches of other versions.
-   */
+  #session;
+  #storage;
+  #stored;
+  #written = Promise.resolve();
+  #cleanup = Promise.resolve();
   static async open(config, options) {
-    const storageName = storageNameOf(options.name);
-    const factory = options.indexedDB ?? indexedDB;
-    const storage = indexedDBStorage(storageName, {
-      indexedDB: factory,
-      IDBKeyRange: options.IDBKeyRange ?? IDBKeyRange
-    });
-    const openStorage = () => _BrowserEntryStore.#openStorage(config, options, storage);
-    if (options.reset) await storage.delete();
-    let store;
-    try {
-      store = await openStorage();
-    } catch {
-      await storage.delete();
-      store = await openStorage();
-    }
-    await cleanupOldCaches({
-      factory,
-      locks: options.locks ?? globalThis.navigator?.locks,
-      baseName: options.name,
-      currentName: storageName
+    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,
+        storage.session(new Database(), { branch: fingerprint }),
+        storage,
+        fingerprint
+      );
     });
+    store.#cleanup = cleanup;
     return store;
   }
-  /**
-   * A copy in memory of the stored content, for a worker that cannot store
-   * it while another one does: it loads the last committed state and never
-   * writes. Resolves with undefined if that state cannot be read.
-   */
-  static async snapshot(config, options) {
-    const storage = indexedDBStorage(storageNameOf(options.name), {
-      indexedDB: options.indexedDB ?? indexedDB,
-      IDBKeyRange: options.IDBKeyRange ?? IDBKeyRange
-    });
-    let handle;
-    try {
-      handle = await syncWasmDatabase(storage);
-      handle.detach();
-      const db = handle.database;
-      const stored = await storedBuild(db);
-      if (stored === void 0) {
-        await db.close();
-        return void 0;
-      }
-      await EntryDatabase.createSchema(db, config, ReadonlyTree.EMPTY.sha);
-      const database = new EntryDatabase(config, db, { fork: handle.fork });
-      if (stored !== options.revision) await database.reindex(config);
-      return new EntryStore(config, database, new DatabaseSource(database), {
-        ownsDatabase: true,
-        sourceFollowsDatabase: true
-      });
-    } catch (error) {
-      if (handle) await handle.database.close();
-      console.warn("Failed to read the content cache", error);
-      return void 0;
+  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;
     }
-  }
-  static async #openStorage(config, options, storage) {
-    const handle = await syncWasmDatabase(storage);
     try {
-      const db = handle.database;
-      await db.run(sql`pragma page_size = 65536`);
-      const stored = await storedBuild(db);
+      await db.run(sql`pragma page_size = 16384`);
       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(config, database, handle);
+      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 handle.database.close();
+      await db.close();
       throw error;
     }
   }
-  #detach() {
-    if (this.#detached) return;
-    this.#detached = true;
-    this.#handle.detach();
-  }
-  constructor(config, database, handle) {
+  constructor(config, database, session, storage) {
     super(config, database, new DatabaseSource(database), {
       ownsDatabase: true,
       sourceFollowsDatabase: true
     });
-    this.#handle = handle;
+    this.#session = session;
+    this.#storage = storage;
   }
-  /**
-   * 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());
+  async sync() {
+    return this.#checkpoint(await super.sync());
   }
-  syncWith(remote, options) {
-    return this.#run(() => super.syncWith(remote, options));
+  async syncWith(remote, options) {
+    return this.#checkpoint(await super.syncWith(remote, options));
   }
-  mutate(mutations) {
-    return this.#persistAfter(() => super.mutate(mutations));
-  }
-  write(request) {
-    return this.#persistAfter(() => super.write(request));
-  }
-  /** 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.#store();
-      return result;
-    });
-  }
-  /**
-   * Wait for the commits so far to be stored. The cache only saves loading
-   * time: if storing fails, such as over quota, it stops instead of failing
-   * the commit, and keeps the last committed state it stored.
-   */
-  async #store() {
-    if (this.#detached) return;
-    try {
-      await this.#handle.flush();
-    } catch (error) {
-      console.warn("Stopped caching content in IndexedDB", error);
-      this.#detach();
-    }
-  }
-  /**
-   * Stop storing, and resolve once the commits so far are stored, for a
-   * replacement to open the cache. Work in flight then changes only this
-   * store's memory, so the replacement need not wait for it.
-   */
-  async release() {
-    this.#detach();
-    await this.#handle.flush().catch(() => {
+  /** 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;
   }
-  #run(task) {
-    if (this.#closed)
-      return Promise.reject(new Error("BrowserEntryStore is closed"));
-    return this.#persistQueue.run(task);
-  }
-  close() {
-    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();
   }
 };
 var corruptCodes = /* @__PURE__ */ new Set(["SQLITE_CORRUPT", "SQLITE_NOTADB"]);
@@ -208,43 +117,36 @@ function isCorruptDatabaseError(error) {
   const errors = Array.isArray(error.errors) ? error.errors : [];
   return isCorruptDatabaseError(error.cause) || errors.some(isCorruptDatabaseError);
 }
-function storageNameOf(name) {
-  return `${versionedCacheName(name)}-pages`;
+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 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 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,
-  locks,
-  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) => deleteUnheldCache(factory, locks, name)));
+  await Promise.all(stale.map((cache) => deleteCache(factory, cache)));
 }
-async function deleteUnheldCache(factory, locks, name) {
-  if (!locks) return deleteCache(factory, name);
-  await locks.request(name, { ifAvailable: true }, (lock) => {
-    if (lock) return deleteCache(factory, name);
-  }).catch(() => {
-  });
+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) => {
@@ -256,6 +158,5 @@ function deleteCache(factory, name) {
 }
 export {
   BrowserEntryStore,
-  holdCache,
   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";