@korajs/store 1.0.0-beta.12 → 1.0.0-beta.14

package/dist/adapters/indexeddb.d.cts

@@ -1,6 +1,6 @@
 import { KoraEventEmitter, SchemaDefinition } from '@korajs/core';
-import { S as StorageAdapter, T as Transaction, M as MigrationPlan, a as StorageOpenState } from '../types-BslDOTk0.cjs';
-import { W as WorkerBridge } from '../sqlite-wasm-channel-L6o3bWQK.cjs';
+import { S as StorageAdapter, T as Transaction, M as MigrationPlan, a as StorageOpenState } from '../types-Dh-xyUjP.cjs';
+import { W as WorkerBridge } from '../sqlite-wasm-channel-DVX93Uiq.cjs';
 
 /**
  * Options for creating an IndexedDbAdapter.
@@ -50,8 +50,18 @@ declare class IndexedDbAdapter implements StorageAdapter {
     private readonly emitter;
     private readonly scheduler;
     private storageOpenState;
+    private readonly options;
+    /** True in browsers (a real worker), where the backend choice is recorded. */
+    private readonly usesRealWorker;
     constructor(options?: IndexedDbAdapterOptions);
     open(schema: SchemaDefinition): Promise<void>;
+    /**
+     * Read the OPFS copy of this database through a short-lived SQLite WASM
+     * adapter (as leader, or as a follower of a tab that has it open). Refuses
+     * loudly when OPFS cannot be read, instead of starting an empty copy.
+     */
+    private readOpfsCopy;
+    private applyDump;
     close(): Promise<void>;
     execute(sql: string, params?: unknown[]): Promise<void>;
     query<T>(sql: string, params?: unknown[]): Promise<T[]>;
@@ -63,9 +73,25 @@ declare class IndexedDbAdapter implements StorageAdapter {
      * Useful before tab unload or in tests.
      */
     flushPersistence(): Promise<void>;
+    /**
+     * Durability barrier (RT-35): resolves once every write committed before the call is
+     * in a snapshot persisted to IndexedDB, and rejects when the snapshot cannot be
+     * written. Sync calls it before an operation leaves the device, so the server never
+     * holds an operation this device could lose on reload.
+     */
+    ensureDurable(): Promise<void>;
     private writeSnapshot;
     private handlePersistenceError;
-    private restoreFromDumpFallback;
+    /**
+     * Restore the persisted snapshot into the worker database unless one was restored
+     * into it already (this adapter or another one sharing the worker). The binary
+     * snapshot (Node / test workers that support export) is imported whole; the JSON dump
+     * (browsers) is restored in one transaction.
+     */
+    private restoreIfFresh;
+    /** In `tx`: restore the JSON dump when no snapshot was restored into this database. */
+    private restoreDumpIfFresh;
+    /** A consistent snapshot: every table is read inside one transaction (STORE-7). */
     private exportDump;
 }
 

package/dist/adapters/indexeddb.d.ts

@@ -1,6 +1,6 @@
 import { KoraEventEmitter, SchemaDefinition } from '@korajs/core';
-import { S as StorageAdapter, T as Transaction, M as MigrationPlan, a as StorageOpenState } from '../types-BslDOTk0.js';
-import { W as WorkerBridge } from '../sqlite-wasm-channel-L6o3bWQK.js';
+import { S as StorageAdapter, T as Transaction, M as MigrationPlan, a as StorageOpenState } from '../types-Dh-xyUjP.js';
+import { W as WorkerBridge } from '../sqlite-wasm-channel-DVX93Uiq.js';
 
 /**
  * Options for creating an IndexedDbAdapter.
@@ -50,8 +50,18 @@ declare class IndexedDbAdapter implements StorageAdapter {
     private readonly emitter;
     private readonly scheduler;
     private storageOpenState;
+    private readonly options;
+    /** True in browsers (a real worker), where the backend choice is recorded. */
+    private readonly usesRealWorker;
     constructor(options?: IndexedDbAdapterOptions);
     open(schema: SchemaDefinition): Promise<void>;
+    /**
+     * Read the OPFS copy of this database through a short-lived SQLite WASM
+     * adapter (as leader, or as a follower of a tab that has it open). Refuses
+     * loudly when OPFS cannot be read, instead of starting an empty copy.
+     */
+    private readOpfsCopy;
+    private applyDump;
     close(): Promise<void>;
     execute(sql: string, params?: unknown[]): Promise<void>;
     query<T>(sql: string, params?: unknown[]): Promise<T[]>;
@@ -63,9 +73,25 @@ declare class IndexedDbAdapter implements StorageAdapter {
      * Useful before tab unload or in tests.
      */
     flushPersistence(): Promise<void>;
+    /**
+     * Durability barrier (RT-35): resolves once every write committed before the call is
+     * in a snapshot persisted to IndexedDB, and rejects when the snapshot cannot be
+     * written. Sync calls it before an operation leaves the device, so the server never
+     * holds an operation this device could lose on reload.
+     */
+    ensureDurable(): Promise<void>;
     private writeSnapshot;
     private handlePersistenceError;
-    private restoreFromDumpFallback;
+    /**
+     * Restore the persisted snapshot into the worker database unless one was restored
+     * into it already (this adapter or another one sharing the worker). The binary
+     * snapshot (Node / test workers that support export) is imported whole; the JSON dump
+     * (browsers) is restored in one transaction.
+     */
+    private restoreIfFresh;
+    /** In `tx`: restore the JSON dump when no snapshot was restored into this database. */
+    private restoreDumpIfFresh;
+    /** A consistent snapshot: every table is read inside one transaction (STORE-7). */
     private exportDump;
 }
 

package/dist/adapters/indexeddb.js

@@ -1,15 +1,30 @@
 import {
-  SqliteWasmAdapter
-} from "../chunk-RJIEKEN4.js";
-import "../chunk-VDBJQ75K.js";
+  STORED_SCHEMA_VERSION_SQL,
+  storedSchemaVersion
+} from "../chunk-A6GFH5IG.js";
+import {
+  SqliteWasmAdapter,
+  deleteSnapshotFromIndexedDB,
+  exportDump,
+  isIndexedDbQuotaError,
+  isManifestAvailable,
+  loadDumpFromIndexedDB,
+  loadFromIndexedDB,
+  readManifestRecord,
+  recordDatabase,
+  restoreDumpStatements,
+  saveDumpToIndexedDB,
+  saveToIndexedDB
+} from "../chunk-BQSIL6TT.js";
+import "../chunk-KK3GBONL.js";
 import "../chunk-TVJEC5S2.js";
+import "../chunk-5JMGMPUE.js";
 import {
   AdapterError,
-  PersistenceError
-} from "../chunk-TUR7RGEP.js";
-
-// src/adapters/indexeddb-adapter.ts
-import { quoteIdent } from "@korajs/core";
+  PersistenceError,
+  SchemaVersionAheadError,
+  StorageBackendMismatchError
+} from "../chunk-SRHDJF5B.js";
 
 // src/adapters/indexeddb-persistence-scheduler.ts
 var DEFAULT_DEBOUNCE_MS = 500;
@@ -20,6 +35,15 @@ var IndexedDbPersistenceScheduler = class {
   timer = null;
   inFlight = null;
   disposed = false;
+  /**
+   * Mutation generations (RT-35): `scheduled` counts schedule() calls (one per committed
+   * write), `persisted` is the generation the last SUCCESSFUL snapshot covered. A
+   * snapshot covers every generation scheduled before it started.
+   */
+  scheduledGeneration = 0;
+  persistedGeneration = 0;
+  /** Error of the last snapshot attempt, cleared by the next success. */
+  lastFlushError = null;
   onVisibilityChange;
   constructor(options) {
     this.debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
@@ -37,6 +61,7 @@ var IndexedDbPersistenceScheduler = class {
   /** Schedule a debounced snapshot write. */
   schedule() {
     if (this.disposed) return;
+    this.scheduledGeneration++;
     if (this.debounceMs <= 0) {
       void this.flushNow();
       return;
@@ -49,22 +74,75 @@ var IndexedDbPersistenceScheduler = class {
       void this.flushNow();
     }, this.debounceMs);
   }
-  /** Cancel any pending debounce and persist immediately. */
+  /**
+   * Cancel any pending debounce and persist immediately. Resolves only when a snapshot
+   * taken after every write scheduled so far was written (STORE-7): a snapshot already in
+   * flight may predate the latest writes, so the call waits for it and then writes again
+   * while anything is still dirty. A failed snapshot ends the loop (the failure is
+   * reported through `onError`; {@link flushBarrier} is the variant that rejects).
+   */
   async flushNow() {
     if (this.disposed) return;
     if (this.timer !== null) {
       clearTimeout(this.timer);
       this.timer = null;
     }
-    if (this.inFlight) {
-      await this.inFlight;
-      return;
+    let mustRun = this.inFlight === null;
+    for (; ; ) {
+      if (this.inFlight) {
+        await this.inFlight;
+        continue;
+      }
+      if (!mustRun && this.persistedGeneration >= this.scheduledGeneration) return;
+      mustRun = false;
+      this.inFlight = this.runFlush();
+      try {
+        await this.inFlight;
+      } finally {
+        this.inFlight = null;
+      }
+      if (this.lastFlushError !== null) return;
     }
-    this.inFlight = this.runFlush();
-    try {
-      await this.inFlight;
-    } finally {
-      this.inFlight = null;
+  }
+  /** Whether a write was scheduled that no successful snapshot covers yet. */
+  isDirty() {
+    return this.persistedGeneration < this.scheduledGeneration;
+  }
+  /**
+   * Durability barrier (RT-35): resolve once every write scheduled before this call is
+   * in a snapshot persisted to IndexedDB. A snapshot already in flight may predate the
+   * latest write, so the barrier waits for it and then writes a fresh one when needed.
+   * Rejects when the snapshot cannot be written: the caller must treat the writes as
+   * not durable (for example, not upload them yet).
+   */
+  async flushBarrier() {
+    const target = this.scheduledGeneration;
+    if (this.persistedGeneration >= target) return;
+    if (this.disposed) {
+      throw new Error("IndexedDB persistence was disposed before the writes were persisted");
+    }
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    for (let round = 0; round < 3 && this.persistedGeneration < target; round++) {
+      if (this.inFlight) {
+        try {
+          await this.inFlight;
+        } catch {
+        }
+        continue;
+      }
+      this.inFlight = this.runFlush();
+      try {
+        await this.inFlight;
+      } finally {
+        this.inFlight = null;
+      }
+      if (this.persistedGeneration < target) break;
+    }
+    if (this.persistedGeneration < target) {
+      throw this.lastFlushError instanceof Error ? this.lastFlushError : new Error("IndexedDB snapshot was not persisted");
     }
   }
   dispose() {
@@ -78,165 +156,18 @@ var IndexedDbPersistenceScheduler = class {
     }
   }
   async runFlush() {
+    const generation = this.scheduledGeneration;
     try {
       await this.flush();
+      this.persistedGeneration = Math.max(this.persistedGeneration, generation);
+      this.lastFlushError = null;
     } catch (error) {
+      this.lastFlushError = error;
       this.onError?.(error);
     }
   }
 };
 
-// src/adapters/sqlite-wasm-persistence.ts
-var IDB_DATABASE_NAME = "kora-persistence";
-var IDB_STORE_NAME = "databases";
-var IDB_VERSION = 1;
-var DUMP_SUFFIX = "::dump";
-function isIndexedDbQuotaError(error) {
-  if (error instanceof DOMException && error.name === "QuotaExceededError") {
-    return true;
-  }
-  if (error instanceof PersistenceError && error.context?.quotaExceeded === true) {
-    return true;
-  }
-  if (error instanceof Error && /quota/i.test(error.message)) {
-    return true;
-  }
-  return false;
-}
-function rejectWithIdbError(reject, message, context, event) {
-  const domError = event.target?.error;
-  if (domError && isIndexedDbQuotaError(domError)) {
-    reject(
-      new PersistenceError(message, {
-        ...context,
-        quotaExceeded: true,
-        cause: domError.message
-      })
-    );
-    return;
-  }
-  reject(new PersistenceError(message, context));
-}
-function openIdb() {
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open(IDB_DATABASE_NAME, IDB_VERSION);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(IDB_STORE_NAME)) {
-        db.createObjectStore(IDB_STORE_NAME);
-      }
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(
-      new PersistenceError(
-        `Failed to open IndexedDB: ${request.error?.message ?? "unknown error"}`,
-        { database: IDB_DATABASE_NAME }
-      )
-    );
-  });
-}
-async function saveToIndexedDB(dbName, data) {
-  const idb = await openIdb();
-  try {
-    await new Promise((resolve, reject) => {
-      const tx = idb.transaction(IDB_STORE_NAME, "readwrite");
-      const store = tx.objectStore(IDB_STORE_NAME);
-      store.put(data, dbName);
-      tx.oncomplete = () => resolve();
-      tx.onerror = (event) => rejectWithIdbError(
-        reject,
-        `Failed to save database "${dbName}" to IndexedDB`,
-        { dbName },
-        event
-      );
-    });
-  } finally {
-    idb.close();
-  }
-}
-async function saveDumpToIndexedDB(dbName, dump) {
-  const idb = await openIdb();
-  try {
-    await new Promise((resolve, reject) => {
-      const tx = idb.transaction(IDB_STORE_NAME, "readwrite");
-      const store = tx.objectStore(IDB_STORE_NAME);
-      store.put(dump, `${dbName}${DUMP_SUFFIX}`);
-      tx.oncomplete = () => resolve();
-      tx.onerror = (event) => rejectWithIdbError(
-        reject,
-        `Failed to save dump for database "${dbName}"`,
-        { dbName },
-        event
-      );
-    });
-  } finally {
-    idb.close();
-  }
-}
-async function loadFromIndexedDB(dbName) {
-  const idb = await openIdb();
-  try {
-    return await new Promise((resolve, reject) => {
-      const tx = idb.transaction(IDB_STORE_NAME, "readonly");
-      const store = tx.objectStore(IDB_STORE_NAME);
-      const request = store.get(dbName);
-      request.onsuccess = () => {
-        const result = request.result;
-        if (result instanceof Uint8Array) {
-          resolve(result);
-        } else if (result) {
-          resolve(new Uint8Array(result));
-        } else {
-          resolve(null);
-        }
-      };
-      request.onerror = () => reject(
-        new PersistenceError(`Failed to load database "${dbName}" from IndexedDB`, { dbName })
-      );
-    });
-  } finally {
-    idb.close();
-  }
-}
-async function loadDumpFromIndexedDB(dbName) {
-  const idb = await openIdb();
-  try {
-    return await new Promise((resolve, reject) => {
-      const tx = idb.transaction(IDB_STORE_NAME, "readonly");
-      const store = tx.objectStore(IDB_STORE_NAME);
-      const request = store.get(`${dbName}${DUMP_SUFFIX}`);
-      request.onsuccess = () => {
-        resolve(request.result ?? null);
-      };
-      request.onerror = () => reject(
-        new PersistenceError(`Failed to load dump for database "${dbName}" from IndexedDB`, {
-          dbName
-        })
-      );
-    });
-  } finally {
-    idb.close();
-  }
-}
-async function deleteSnapshotFromIndexedDB(dbName) {
-  const idb = await openIdb();
-  try {
-    await new Promise((resolve, reject) => {
-      const tx = idb.transaction(IDB_STORE_NAME, "readwrite");
-      const store = tx.objectStore(IDB_STORE_NAME);
-      store.delete(dbName);
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(
-        new PersistenceError(`Failed to delete database snapshot "${dbName}" from IndexedDB`, {
-          dbName
-        })
-      );
-    });
-  } finally {
-    idb.close();
-  }
-}
-
 // src/adapters/indexeddb-adapter.ts
 var IndexedDbAdapter = class {
   inner;
@@ -244,14 +175,29 @@ var IndexedDbAdapter = class {
   emitter;
   scheduler;
   storageOpenState = null;
+  options;
+  /** True in browsers (a real worker), where the backend choice is recorded. */
+  usesRealWorker;
   constructor(options = {}) {
+    this.options = options;
     this.dbName = options.dbName ?? "kora-db";
     this.emitter = options.emitter;
+    this.usesRealWorker = !options.bridge && options.workerUrl !== void 0;
     this.inner = new SqliteWasmAdapter({
       bridge: options.bridge,
       workerUrl: options.workerUrl,
       dbName: this.dbName,
-      workerResponseTimeoutMs: options.workerResponseTimeoutMs
+      workerResponseTimeoutMs: options.workerResponseTimeoutMs,
+      // The inner SQLite database is in memory by design: this adapter makes it
+      // durable by persisting snapshots to IndexedDB, so the inner adapter must
+      // not refuse writes as non-durable, and must never touch OPFS (which would
+      // create a second, disjoint copy of the data).
+      allowNonDurable: true,
+      storage: "memory",
+      skipBackendRecord: true,
+      // A browser leader restores the snapshot into its own fresh worker database
+      // before serving other tabs (first open and promotion, STORE-6).
+      onLeaderWorkerOpened: (tx) => this.restoreDumpIfFresh(tx)
     });
     this.scheduler = new IndexedDbPersistenceScheduler({
       debounceMs: options.persistenceDebounceMs,
@@ -260,19 +206,91 @@ var IndexedDbAdapter = class {
     });
   }
   async open(schema) {
+    const tracksBackend = this.usesRealWorker && isManifestAvailable();
+    const recorded = tracksBackend ? await readManifestRecord(this.dbName).catch(() => null) : null;
+    const carried = recorded?.backend === "opfs" ? await this.readOpfsCopy(schema) : null;
     await this.inner.open(schema);
     this.storageOpenState = { persistent: true, mode: "indexeddb" };
-    const persisted = await loadFromIndexedDB(this.dbName);
-    if (!persisted) {
-      await this.restoreFromDumpFallback();
+    if (carried && this.inner.isLeader()) {
+      await this.inner.transaction(async (tx) => {
+        await markRestored(tx);
+      });
+      await this.applyDump(carried);
+      await this.scheduler.flushNow();
+      await recordDatabase({ dbName: this.dbName, backend: "indexeddb" });
+      this.emitter?.emit({
+        type: "store:storage-migrated",
+        dbName: this.dbName,
+        from: "opfs",
+        to: "indexeddb",
+        message: `Database "${this.dbName}" moved from OPFS into IndexedDB because OPFS is not usable in this session.`
+      });
       return;
     }
+    if (this.inner.isLeader()) {
+      await this.restoreIfFresh();
+    }
+    const stored = storedSchemaVersion(
+      await this.inner.query(STORED_SCHEMA_VERSION_SQL)
+    );
+    if (stored > schema.version) {
+      this.scheduler.dispose();
+      await this.inner.close().catch(() => void 0);
+      throw new SchemaVersionAheadError(this.dbName, stored, schema.version);
+    }
+    if (tracksBackend) {
+      await recordDatabase({ dbName: this.dbName, backend: "indexeddb" }).catch(
+        (error) => console.warn(`[kora] Could not record the storage backend of "${this.dbName}":`, error)
+      );
+    }
+  }
+  /**
+   * Read the OPFS copy of this database through a short-lived SQLite WASM
+   * adapter (as leader, or as a follower of a tab that has it open). Refuses
+   * loudly when OPFS cannot be read, instead of starting an empty copy.
+   */
+  async readOpfsCopy(schema) {
+    const reader = new SqliteWasmAdapter({
+      dbName: this.dbName,
+      workerUrl: this.options.workerUrl,
+      workerResponseTimeoutMs: this.options.workerResponseTimeoutMs,
+      skipBackendRecord: true,
+      releaseOnFreeze: false
+    });
     try {
-      await this.inner.importDatabase(persisted);
-    } catch {
-      await this.restoreFromDumpFallback();
+      await reader.open(schema);
+      if (reader.getStorageOpenState()?.persistent !== true) {
+        throw new StorageBackendMismatchError(
+          this.dbName,
+          "OPFS",
+          "IndexedDB",
+          `OPFS reported ${reader.getStorageOpenState()?.fallbackReason ?? "no durable storage"}`
+        );
+      }
+      let dump = { tables: [] };
+      await reader.transaction(async (tx) => {
+        dump = await exportDump((sql, params) => tx.query(sql, params));
+      });
+      return dump;
+    } catch (error) {
+      if (error instanceof StorageBackendMismatchError) throw error;
+      throw new StorageBackendMismatchError(
+        this.dbName,
+        "OPFS",
+        "IndexedDB",
+        error instanceof Error ? error.message : String(error)
+      );
+    } finally {
+      await reader.close().catch(() => void 0);
     }
   }
+  async applyDump(dump) {
+    await this.inner.transaction(async (tx) => {
+      for (const statement of restoreDumpStatements(dump)) {
+        await tx.execute(statement.sql, statement.params);
+      }
+    });
+  }
   async close() {
     await this.scheduler.flushNow();
     this.scheduler.dispose();
@@ -303,6 +321,15 @@ var IndexedDbAdapter = class {
   async flushPersistence() {
     await this.scheduler.flushNow();
   }
+  /**
+   * Durability barrier (RT-35): resolves once every write committed before the call is
+   * in a snapshot persisted to IndexedDB, and rejects when the snapshot cannot be
+   * written. Sync calls it before an operation leaves the device, so the server never
+   * holds an operation this device could lose on reload.
+   */
+  async ensureDurable() {
+    await this.scheduler.flushBarrier();
+  }
   async writeSnapshot() {
     const dump = await this.exportDump();
     await saveDumpToIndexedDB(this.dbName, dump);
@@ -334,59 +361,58 @@ var IndexedDbAdapter = class {
       code: quotaExceeded ? "QUOTA_EXCEEDED" : code
     });
   }
-  async restoreFromDumpFallback() {
-    const dump = await loadDumpFromIndexedDB(this.dbName);
-    if (!dump) return;
-    for (const table of dump.tables) {
-      const name = ensureSafeIdentifier(table.name);
-      await this.inner.execute(`DELETE FROM ${quoteIdent(name)}`);
-      if (table.rows.length === 0) continue;
-      for (const row of table.rows) {
-        const columns = table.columns.filter(
-          (column) => Object.prototype.hasOwnProperty.call(row, column)
-        );
-        if (columns.length === 0) continue;
-        const placeholders = columns.map(() => "?").join(", ");
-        const quotedColumns = columns.map((column) => quoteIdent(ensureSafeIdentifier(column))).join(", ");
-        const values = columns.map((column) => row[column]);
-        await this.inner.execute(
-          `INSERT INTO ${quoteIdent(name)} (${quotedColumns}) VALUES (${placeholders})`,
-          values
-        );
+  /**
+   * Restore the persisted snapshot into the worker database unless one was restored
+   * into it already (this adapter or another one sharing the worker). The binary
+   * snapshot (Node / test workers that support export) is imported whole; the JSON dump
+   * (browsers) is restored in one transaction.
+   */
+  async restoreIfFresh() {
+    const persisted = await loadFromIndexedDB(this.dbName);
+    if (persisted) {
+      const fresh = { value: false };
+      await this.inner.transaction(async (tx) => {
+        fresh.value = !await isRestored(tx);
+      });
+      if (!fresh.value) return;
+      try {
+        await this.inner.importDatabase(persisted);
+        await this.inner.transaction(markRestored);
+        return;
+      } catch {
       }
     }
+    await this.inner.transaction((tx) => this.restoreDumpIfFresh(tx));
   }
-  async exportDump() {
-    const tableRows = await this.inner.query(
-      "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
-    );
-    const tables = [];
-    for (const tableRow of tableRows) {
-      const tableName = ensureSafeIdentifier(tableRow.name);
-      const columns = await this.inner.query(
-        `PRAGMA table_info(${quoteIdent(tableName)})`
-      );
-      const columnNames = columns.map((column) => column.name);
-      const rows = await this.inner.query(
-        `SELECT * FROM ${quoteIdent(tableName)}`
-      );
-      tables.push({
-        name: tableName,
-        columns: columnNames,
-        rows
-      });
+  /** In `tx`: restore the JSON dump when no snapshot was restored into this database. */
+  async restoreDumpIfFresh(tx) {
+    if (await isRestored(tx)) return;
+    await markRestored(tx);
+    const dump = await loadDumpFromIndexedDB(this.dbName);
+    if (!dump) return;
+    for (const statement of restoreDumpStatements(dump)) {
+      await tx.execute(statement.sql, statement.params);
     }
-    return { tables };
   }
-};
-function ensureSafeIdentifier(identifier) {
-  if (!/^[a-zA-Z0-9_]+$/.test(identifier)) {
-    throw new PersistenceError(`Unsafe SQL identifier: ${identifier}`, {
-      code: "UNSAFE_IDENTIFIER",
-      identifier
+  /** A consistent snapshot: every table is read inside one transaction (STORE-7). */
+  async exportDump() {
+    let dump = { tables: [] };
+    await this.inner.transaction(async (tx) => {
+      dump = await exportDump((sql, params) => tx.query(sql, params));
     });
+    return dump;
   }
-  return identifier;
+};
+var RESTORED_MARKER = "_kora_idb_restored";
+async function isRestored(tx) {
+  const rows = await tx.query(
+    "SELECT name FROM sqlite_temp_master WHERE type = 'table' AND name = ?",
+    [RESTORED_MARKER]
+  );
+  return rows.length > 0;
+}
+async function markRestored(tx) {
+  await tx.execute(`CREATE TEMP TABLE IF NOT EXISTS ${RESTORED_MARKER} (restored INTEGER)`);
 }
 function isUnsupportedWorkerExport(error) {
   return error instanceof AdapterError && error.context?.code === "EXPORT_NOT_SUPPORTED";