@korajs/store 1.0.0-beta.11 → 1.0.0-beta.13

package/dist/chunk-QDUSJMFV.js

@@ -0,0 +1,1095 @@
+import {
+  Mutex
+} from "./chunk-TVJEC5S2.js";
+import {
+  FollowerBroadcastBridge,
+  acquireTabStorageSession
+} from "./chunk-W5F2LWG6.js";
+import {
+  AdapterError,
+  BridgeTerminatedError,
+  PersistenceError,
+  StorageDurabilityError,
+  StoreNotOpenError
+} from "./chunk-DUKTWVZW.js";
+
+// src/adapters/sqlite-wasm-adapter.ts
+import { generateFullDDL } from "@korajs/core";
+
+// src/adapters/database-dump.ts
+import { quoteIdent } from "@korajs/core";
+function ensureSafeIdentifier(identifier) {
+  if (!/^[a-zA-Z0-9_]+$/.test(identifier)) {
+    throw new PersistenceError(`Unsafe SQL identifier: ${identifier}`, {
+      code: "UNSAFE_IDENTIFIER",
+      identifier
+    });
+  }
+  return identifier;
+}
+async function exportDump(query) {
+  const tableRows = await query(
+    "SELECT name, sql 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 query(`PRAGMA table_info(${quoteIdent(tableName)})`);
+    const rows = await query(`SELECT * FROM ${quoteIdent(tableName)}`);
+    tables.push({
+      name: tableName,
+      ...typeof tableRow.sql === "string" ? { sql: tableRow.sql } : {},
+      columns: columns.map((column) => column.name),
+      rows
+    });
+  }
+  return { tables };
+}
+function restoreDumpStatements(dump, _createMissingTables = true) {
+  const statements = [];
+  for (const table of dump.tables) {
+    const name = quoteIdent(ensureSafeIdentifier(table.name));
+    const create = createTableIfNotExists(table.name, table.sql);
+    if (create) {
+      statements.push({ sql: create });
+    } else {
+      const columns = table.columns.map((column) => quoteIdent(ensureSafeIdentifier(column)));
+      if (columns.length === 0) continue;
+      statements.push({ sql: `CREATE TABLE IF NOT EXISTS ${name} (${columns.join(", ")})` });
+    }
+    statements.push({ sql: `DELETE FROM ${name}` });
+    for (const row of table.rows) {
+      const columns = table.columns.filter(
+        (column) => Object.prototype.hasOwnProperty.call(row, column)
+      );
+      if (columns.length === 0) continue;
+      const quotedColumns = columns.map((column) => quoteIdent(ensureSafeIdentifier(column))).join(", ");
+      statements.push({
+        sql: `INSERT INTO ${name} (${quotedColumns}) VALUES (${columns.map(() => "?").join(", ")})`,
+        params: columns.map((column) => row[column])
+      });
+    }
+  }
+  return statements;
+}
+function createTableIfNotExists(tableName, sql) {
+  if (typeof sql !== "string" || sql.includes(";")) return null;
+  const match = /^\s*CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?("?)([A-Za-z0-9_]+)\1\s*\(/i.exec(
+    sql
+  );
+  if (!match || match[2] !== tableName) return null;
+  return `CREATE TABLE IF NOT EXISTS ${quoteIdent(tableName)} ${sql.slice(match[0].length - 1)}`;
+}
+
+// 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();
+  }
+}
+async function deleteFromIndexedDB(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);
+      store.delete(`${dbName}${DUMP_SUFFIX}`);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(
+        new PersistenceError(`Failed to delete database "${dbName}" from IndexedDB`, { dbName })
+      );
+    });
+  } finally {
+    idb.close();
+  }
+}
+
+// src/adapters/storage-manifest.ts
+var MANIFEST_DB_NAME = "kora-manifest";
+var MANIFEST_STORE = "databases";
+var MANIFEST_VERSION = 1;
+function isManifestAvailable() {
+  return typeof indexedDB !== "undefined";
+}
+function openManifest() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(MANIFEST_DB_NAME, MANIFEST_VERSION);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(MANIFEST_STORE)) {
+        db.createObjectStore(MANIFEST_STORE, { keyPath: "dbName" });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("Failed to open the Kora storage manifest"));
+  });
+}
+async function withStore(mode, run) {
+  const db = await openManifest();
+  try {
+    return await new Promise((resolve, reject) => {
+      const tx = db.transaction(MANIFEST_STORE, mode);
+      const request = run(tx.objectStore(MANIFEST_STORE));
+      let result;
+      if (request) {
+        request.onsuccess = () => {
+          result = request.result;
+        };
+      }
+      tx.oncomplete = () => resolve(result);
+      tx.onerror = () => reject(tx.error ?? new Error("Kora storage manifest transaction failed"));
+      tx.onabort = () => reject(tx.error ?? new Error("Kora storage manifest transaction aborted"));
+    });
+  } finally {
+    db.close();
+  }
+}
+function isRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return typeof record.dbName === "string" && (record.backend === "opfs" || record.backend === "indexeddb");
+}
+async function readManifestRecord(dbName) {
+  if (!isManifestAvailable()) return null;
+  const value = await withStore("readonly", (store) => store.get(dbName));
+  return isRecord(value) ? value : null;
+}
+async function listManifestRecords() {
+  if (!isManifestAvailable()) return [];
+  const values = await withStore("readonly", (store) => store.getAll());
+  return (values ?? []).filter(isRecord).sort((a, b) => a.dbName < b.dbName ? -1 : 1);
+}
+async function recordDatabase(entry) {
+  if (!isManifestAvailable()) return;
+  const existing = await readManifestRecord(entry.dbName);
+  const now = Date.now();
+  const record = {
+    dbName: entry.dbName,
+    backend: entry.backend,
+    ...entry.poolName ? { poolName: entry.poolName } : {},
+    createdAt: existing?.createdAt ?? now,
+    lastOpenedAt: now
+  };
+  await withStore("readwrite", (store) => store.put(record));
+}
+async function deleteManifestRecord(dbName) {
+  if (!isManifestAvailable()) return;
+  await withStore("readwrite", (store) => store.delete(dbName));
+}
+
+// src/adapters/sqlite-wasm-adapter.ts
+var warnedSharedWorkerDeprecated = false;
+function createGate() {
+  let open = () => {
+  };
+  const promise = new Promise((resolve) => {
+    open = resolve;
+  });
+  return { promise, open };
+}
+var SqliteWasmAdapter = class {
+  bridge = null;
+  /** The dedicated worker this tab runs while it is the database's leader. */
+  ownWorker = null;
+  opened = false;
+  mutex = new Mutex();
+  injectedBridge;
+  workerUrl;
+  sharedWorkerUrl;
+  workerResponseTimeoutMs;
+  dbName;
+  emitter;
+  tabSession = null;
+  emitNonPersistentDiagnostic;
+  storageOpenState = null;
+  /** Retained so a follower promoted to leader can re-open its own worker. */
+  schema = null;
+  promoting = false;
+  closing = false;
+  suspended = false;
+  /** Requests wait here while leadership changes hands (promotion, resume). */
+  gate = null;
+  removeLifecycleListeners = null;
+  allowNonDurable;
+  deferOpenDurabilityCheck;
+  releaseOnFreeze;
+  storage;
+  skipBackendRecord;
+  /** Set when this adapter lost (or never had) durable storage; writes are refused. */
+  durabilityLoss = null;
+  onLeaderWorkerOpened;
+  constructor(options = {}) {
+    this.injectedBridge = options.bridge;
+    this.workerUrl = options.workerUrl;
+    this.sharedWorkerUrl = options.sharedWorkerUrl;
+    this.workerResponseTimeoutMs = options.workerResponseTimeoutMs ?? 3e4;
+    this.dbName = options.dbName ?? "kora-db";
+    this.emitter = options.emitter;
+    this.emitNonPersistentDiagnostic = options.emitNonPersistentDiagnostic ?? true;
+    this.allowNonDurable = options.allowNonDurable ?? false;
+    this.deferOpenDurabilityCheck = options.deferOpenDurabilityCheck ?? false;
+    this.releaseOnFreeze = options.releaseOnFreeze ?? true;
+    this.storage = options.storage ?? "opfs";
+    this.skipBackendRecord = options.skipBackendRecord ?? false;
+    this.onLeaderWorkerOpened = options.onLeaderWorkerOpened;
+  }
+  async open(schema) {
+    if (this.opened) return;
+    const ddlStatements = generateFullDDL(schema);
+    if (this.injectedBridge) {
+      this.bridge = this.injectedBridge;
+      const response = await this.openCurrentBridge(ddlStatements);
+      this.reportStorageMode(response.data);
+      this.enforceDurability("open");
+      this.opened = true;
+      return;
+    }
+    if (this.workerUrl) {
+      this.warnSharedWorkerDeprecated();
+      this.schema = schema;
+      try {
+        const response = await this.attachAndOpen(ddlStatements);
+        this.reportStorageMode(response.data);
+        this.enforceDurability("open");
+        await this.afterLeaderOpen(response.data);
+        this.opened = true;
+      } catch (error) {
+        await this.teardown();
+        throw error;
+      }
+      return;
+    }
+    throw new AdapterError(
+      'SqliteWasmAdapter requires either a bridge (for testing) or a workerUrl (for browsers). Pass { bridge: new MockWorkerBridge() } for tests, or { workerUrl: "/worker.js" } for browsers.'
+    );
+  }
+  /**
+   * Join the database as leader (own worker) or follower (RPC to the leader's
+   * worker), then open it. The open waits, without a timeout, while another
+   * holder still has the storage; the worker reports that as a blocking state.
+   */
+  async attachAndOpen(ddlStatements) {
+    const workerUrl = this.workerUrl;
+    if (!workerUrl) {
+      throw new AdapterError("Durable SQLite WASM storage requires workerUrl.");
+    }
+    const session = await acquireTabStorageSession(this.dbName, {
+      onPromote: () => {
+        void this.promoteToLeader();
+      }
+    });
+    this.tabSession = session;
+    if (session.role === "leader") {
+      const { WebWorkerBridge } = await import("./sqlite-wasm-channel-MLHLKEED.js");
+      const worker = new WebWorkerBridge(workerUrl, this.workerResponseTimeoutMs, {
+        onEvent: (event) => this.onWorkerEvent(event)
+      });
+      this.ownWorker = worker;
+      this.bridge = worker;
+      const response = await this.openLeaderWorker(worker, ddlStatements);
+      this.installLifecycleListeners();
+      return response;
+    }
+    const followerBridge = new FollowerBroadcastBridge(
+      session.channelName,
+      this.workerResponseTimeoutMs
+    );
+    this.bridge = followerBridge;
+    this.emitter?.emit({
+      type: "store:db-name-collision",
+      dbName: this.dbName,
+      message: `Another runtime on this origin is already using database "${this.dbName}"; this runtime is sharing it as a follower. If these are separate apps, give each a distinct store name.`
+    });
+    await followerBridge.waitForLeader();
+    this.installLifecycleListeners();
+    return this.checkedOpen(followerBridge, ddlStatements);
+  }
+  /** Open the database in this tab's own worker and start serving followers. */
+  async openLeaderWorker(worker, ddlStatements) {
+    const hook = this.onLeaderWorkerOpened;
+    if (!hook) {
+      const pending = this.checkedOpen(worker, ddlStatements);
+      worker.post({ id: 0, type: "serve", channelName: this.tabSession?.channelName ?? "" });
+      return pending;
+    }
+    const response = await this.checkedOpen(worker, ddlStatements);
+    await runWorkerTransaction(worker, hook);
+    worker.post({ id: 0, type: "serve", channelName: this.tabSession?.channelName ?? "" });
+    return response;
+  }
+  /**
+   * Whether this runtime owns the database's worker: the storage leader in a browser,
+   * or any adapter with an injected bridge (tests, Node). A follower tab relays every
+   * request to the leader's worker (STORE-6).
+   */
+  isLeader() {
+    if (this.injectedBridge) return true;
+    return this.tabSession?.role === "leader";
+  }
+  async checkedOpen(bridge, ddlStatements) {
+    const response = await bridge.send(
+      {
+        id: 0,
+        type: "open",
+        ddlStatements,
+        dbName: this.dbName,
+        ...this.storage === "memory" ? { storage: "memory" } : {}
+      },
+      void 0,
+      { timeoutMs: Number.POSITIVE_INFINITY }
+    );
+    if (response.type === "error") {
+      throw new AdapterError(`Failed to open database: ${response.message}`, {
+        code: response.code,
+        dbName: this.dbName,
+        ...response.context ?? {}
+      });
+    }
+    return response;
+  }
+  async openCurrentBridge(ddlStatements) {
+    const bridge = this.bridge;
+    if (!bridge) throw new StoreNotOpenError();
+    return this.checkedOpen(bridge, ddlStatements);
+  }
+  onWorkerEvent(event) {
+    if (!this.emitter) return;
+    const holder = event.resource === "legacy-pool" ? "the shared OPFS pool used by older Kora versions (a tab running an older version of this app may still be open)" : "another tab or worker that is still releasing it";
+    if (event.kind === "storage-blocked") {
+      this.emitter.emit({
+        type: "store:storage-blocked",
+        dbName: this.dbName,
+        resource: event.resource,
+        state: "waiting",
+        message: `Database "${this.dbName}" is waiting for ${holder}. Close other tabs of this app if this persists; Kora will not fall back to non-durable storage.`
+      });
+      return;
+    }
+    this.emitter.emit({
+      type: "store:storage-blocked",
+      dbName: this.dbName,
+      resource: event.resource,
+      state: "resolved",
+      waitedMs: event.waitedMs,
+      message: `Database "${this.dbName}" obtained its storage after waiting ${event.waitedMs}ms.`
+    });
+  }
+  /**
+   * Leader-only bookkeeping after a durable open: report a legacy-pool
+   * migration, move an IndexedDB-held copy into OPFS explicitly (never two
+   * disjoint copies), and record OPFS as this database's backend.
+   */
+  async afterLeaderOpen(data) {
+    if (!this.ownWorker || this.skipBackendRecord || this.storageOpenState?.persistent !== true) {
+      return;
+    }
+    const info = typeof data === "object" && data !== null ? data : {};
+    if (info.migratedFromLegacy === true) {
+      this.emitter?.emit({
+        type: "store:storage-migrated",
+        dbName: this.dbName,
+        from: "legacy-opfs-pool",
+        to: "opfs",
+        message: `Database "${this.dbName}" moved from the shared pre-1.0 OPFS pool into its own pool.`
+      });
+    }
+    if (!isManifestAvailable()) return;
+    let recordedBackend = null;
+    try {
+      recordedBackend = (await readManifestRecord(this.dbName))?.backend ?? null;
+    } catch (error) {
+      console.warn(`[kora] Could not read the storage manifest for "${this.dbName}":`, error);
+    }
+    if (recordedBackend === "indexeddb") {
+      const dump = await loadDumpFromIndexedDB(this.dbName);
+      if (dump) {
+        await this.applyDumpThroughWorker(this.ownWorker, dump);
+      }
+      this.emitter?.emit({
+        type: "store:storage-migrated",
+        dbName: this.dbName,
+        from: "indexeddb",
+        to: "opfs",
+        message: `Database "${this.dbName}" moved from IndexedDB into OPFS.`
+      });
+    }
+    try {
+      await recordDatabase({
+        dbName: this.dbName,
+        backend: "opfs",
+        ...this.storageOpenState.poolName ? { poolName: this.storageOpenState.poolName } : {}
+      });
+      if (recordedBackend === "indexeddb") {
+        await deleteFromIndexedDB(this.dbName);
+      }
+    } catch (error) {
+      console.warn(`[kora] Could not update the storage manifest for "${this.dbName}":`, error);
+    }
+  }
+  async applyDumpThroughWorker(worker, dump) {
+    const check = async (request, what) => {
+      const response = await worker.send(request);
+      if (response.type === "error") {
+        throw new AdapterError(`${what} failed: ${response.message}`, { dbName: this.dbName });
+      }
+    };
+    await check({ id: 0, type: "begin" }, "BEGIN IndexedDB import");
+    try {
+      for (const statement of restoreDumpStatements(dump)) {
+        await check(
+          { id: 0, type: "execute", sql: statement.sql, params: statement.params },
+          "IndexedDB import"
+        );
+      }
+      await check({ id: 0, type: "commit" }, "COMMIT IndexedDB import");
+    } catch (error) {
+      await worker.send({ id: 0, type: "rollback" }).catch(() => void 0);
+      throw error;
+    }
+  }
+  /**
+   * Surface a `store:opfs-unavailable` diagnostic when the worker reported that
+   * persistence silently degraded to an in-memory database, so a data-loss
+   * condition is observable instead of failing silently. A persistent open (or a
+   * bridge that does not report a mode, e.g. the Node mock) emits nothing.
+   */
+  reportStorageMode(data) {
+    this.storageOpenState = parseStorageOpenState(data);
+    if (!this.emitNonPersistentDiagnostic || !this.emitter || !this.storageOpenState) {
+      return;
+    }
+    if (this.storageOpenState.persistent === false && this.storage === "opfs") {
+      const reason = this.storageOpenState.fallbackReason ?? "unsupported";
+      this.emitter.emit({
+        type: "store:opfs-unavailable",
+        dbName: this.dbName,
+        reason,
+        message: `OPFS persistence is unavailable (${reason}) for database "${this.dbName}"; the store is running in memory and data will not survive a reload.`
+      });
+    }
+  }
+  getStorageOpenState() {
+    return this.storageOpenState;
+  }
+  /**
+   * Durable or loud, never silent (NEW-STORE-6). When the open or a promotion
+   * ended on non-persistent storage and the app did not opt into that, emit the
+   * blocking `store:durability-lost` event and refuse every later write. A
+   * bridge that reports no mode (the Node mock) is not judged.
+   */
+  enforceDurability(phase, failure) {
+    if (this.allowNonDurable) return;
+    if (phase === "open" && this.deferOpenDurabilityCheck && !failure) return;
+    let reason;
+    if (failure) {
+      reason = failure.reason;
+    } else if (this.storageOpenState?.persistent === false) {
+      reason = this.storageOpenState.fallbackReason ?? "unsupported";
+    } else {
+      this.durabilityLoss = null;
+      return;
+    }
+    this.durabilityLoss = { phase, reason };
+    this.emitter?.emit({
+      type: "store:durability-lost",
+      dbName: this.dbName,
+      phase,
+      reason,
+      message: `Database "${this.dbName}" has no durable storage (${reason} during ${phase}); writes are refused until the app reloads with durable storage.${failure ? ` ${failure.message}` : ""}`
+    });
+  }
+  guardDurableWrite() {
+    if (this.durabilityLoss) {
+      throw new StorageDurabilityError(
+        this.dbName,
+        this.durabilityLoss.phase,
+        this.durabilityLoss.reason
+      );
+    }
+  }
+  warnSharedWorkerDeprecated() {
+    if (!this.sharedWorkerUrl || warnedSharedWorkerDeprecated) {
+      return;
+    }
+    warnedSharedWorkerDeprecated = true;
+    console.warn(
+      "[kora] sharedWorkerUrl is deprecated and ignored: SharedWorker-hosted SQLite cannot use OPFS and is never durable. Kora uses the durable dedicated-worker leader/follower path for multi-tab storage."
+    );
+  }
+  /**
+   * Close the database. A leader closes the database file and releases the OPFS
+   * pool inside its worker, terminates the worker, and only then releases the
+   * tab leader lock, so the next leader never races a still-running worker for
+   * the file handles (NEW-STORE-10). A follower just leaves.
+   */
+  async close() {
+    if (!this.bridge && !this.tabSession) return;
+    this.closing = true;
+    try {
+      if (this.injectedBridge && this.bridge) {
+        await this.bridge.send({ id: 0, type: "close" });
+      } else if (this.ownWorker && !this.ownWorker.isTerminated()) {
+        const response = await this.ownWorker.send({ id: 0, type: "close" }, void 0, { timeoutMs: 5e3 }).catch((error) => ({
+          id: 0,
+          type: "error",
+          message: error instanceof Error ? error.message : String(error),
+          code: "CLOSE_FAILED"
+        }));
+        if (response.type === "error") {
+          console.warn(`[kora] Closing "${this.dbName}" in its worker failed:`, response.message);
+        }
+      }
+    } finally {
+      await this.teardown();
+      this.closing = false;
+    }
+  }
+  /**
+   * Release everything this adapter holds, in ownership order: lifecycle
+   * listeners, then the worker (which holds the OPFS pool and its Web Lock),
+   * then the tab leader lock or queued promotion request.
+   */
+  async teardown() {
+    this.removeLifecycleListeners?.();
+    this.removeLifecycleListeners = null;
+    const session = this.tabSession;
+    this.tabSession = null;
+    session?.stopRelay?.();
+    this.bridge?.terminate();
+    this.bridge = null;
+    this.ownWorker = null;
+    if (session) {
+      if (session.releaseLock) {
+        await session.releaseLock();
+      }
+      session.cancelPromotionWatch?.();
+    }
+    this.opened = false;
+    this.suspended = false;
+    const gate = this.gate;
+    this.gate = null;
+    gate?.open();
+  }
+  /**
+   * Promotes a follower to leader after the previous leader released the storage
+   * lock (its tab closed, crashed, or suspended on freeze). The new worker waits
+   * on the pool's Web Lock and handles, so it never races the previous worker.
+   * Requests issued during the hand-off wait for it; requests that were in
+   * flight to the old leader fail with a retriable `BridgeTerminatedError`.
+   */
+  async promoteToLeader() {
+    if (this.promoting || this.closing || !this.opened || this.workerUrl === void 0 || this.schema === null) {
+      return;
+    }
+    this.promoting = true;
+    const gate = createGate();
+    this.gate = gate;
+    try {
+      const { WebWorkerBridge } = await import("./sqlite-wasm-channel-MLHLKEED.js");
+      if (this.closing || !this.opened) return;
+      const worker = new WebWorkerBridge(this.workerUrl, this.workerResponseTimeoutMs, {
+        onEvent: (event) => this.onWorkerEvent(event)
+      });
+      const previousBridge = this.bridge;
+      this.bridge = worker;
+      this.ownWorker = worker;
+      if (this.tabSession) {
+        this.tabSession.role = "leader";
+      }
+      previousBridge?.terminate();
+      const ddlStatements = generateFullDDL(this.schema);
+      let response;
+      try {
+        response = await this.openLeaderWorker(worker, ddlStatements);
+      } catch (error) {
+        this.storageOpenState = { persistent: false, mode: "memory" };
+        this.enforceDurability("promotion", {
+          reason: "open-failed",
+          message: error instanceof Error ? error.message : String(error)
+        });
+        return;
+      }
+      this.storageOpenState = parseStorageOpenState(response.data) ?? this.storageOpenState;
+      this.enforceDurability("promotion");
+      try {
+        await this.afterLeaderOpen(response.data);
+      } catch (error) {
+        this.enforceDurability("promotion", {
+          reason: "open-failed",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    } finally {
+      this.promoting = false;
+      if (this.gate === gate) this.gate = null;
+      gate.open();
+    }
+  }
+  /**
+   * Page Lifecycle: a frozen or bfcached page cannot run, so it must not keep
+   * other tabs waiting on its storage. Leaders terminate their worker (freeing
+   * the OPFS pool) and then release the leader lock, so a visible tab is
+   * promoted; followers withdraw their queued lock request so a frozen tab is
+   * never granted leadership it cannot use. Never uses Web Locks `steal`.
+   */
+  installLifecycleListeners() {
+    if (!this.releaseOnFreeze || this.removeLifecycleListeners) return;
+    if (typeof addEventListener !== "function" || typeof document === "undefined") return;
+    const onFreeze = () => this.suspend();
+    const onPageHide = () => this.suspend();
+    const onResume = () => {
+      void this.resume();
+    };
+    const onPageShow = (event) => {
+      if (event.persisted) void this.resume();
+    };
+    document.addEventListener("freeze", onFreeze);
+    document.addEventListener("resume", onResume);
+    addEventListener("pagehide", onPageHide);
+    addEventListener("pageshow", onPageShow);
+    this.removeLifecycleListeners = () => {
+      document.removeEventListener("freeze", onFreeze);
+      document.removeEventListener("resume", onResume);
+      removeEventListener("pagehide", onPageHide);
+      removeEventListener("pageshow", onPageShow);
+    };
+  }
+  /** Synchronous by necessity: a `freeze` handler gets no further turns. */
+  suspend() {
+    if (!this.opened || this.suspended || this.closing || this.promoting) return;
+    this.suspended = true;
+    this.gate = createGate();
+    const session = this.tabSession;
+    this.tabSession = null;
+    this.bridge?.terminate();
+    this.bridge = null;
+    this.ownWorker = null;
+    if (session) {
+      void session.releaseLock?.();
+      session.cancelPromotionWatch?.();
+    }
+  }
+  async resume() {
+    if (!this.suspended || this.closing || this.schema === null) return;
+    const gate = this.gate;
+    try {
+      const response = await this.attachAndOpen(generateFullDDL(this.schema));
+      this.reportStorageMode(response.data);
+      this.enforceDurability("promotion");
+      await this.afterLeaderOpen(response.data);
+    } catch (error) {
+      this.enforceDurability("promotion", {
+        reason: "open-failed",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.suspended = false;
+      if (this.gate === gate) this.gate = null;
+      gate?.open();
+    }
+  }
+  /**
+   * Non-transactional write. Takes the same mutex as {@link transaction}, so it
+   * never lands inside this tab's open transaction and is never rolled back
+   * with it (STORE-8). Inside a transaction callback, use the `tx` handle.
+   */
+  async execute(sql, params, options) {
+    this.guardOpen();
+    this.guardDurableWrite();
+    const release = await this.mutex.acquire();
+    try {
+      const response = await this.sendRequest(
+        {
+          id: 0,
+          type: "execute",
+          sql,
+          params,
+          ...options?.requestId ? { requestId: options.requestId } : {}
+        },
+        options?.signal ? { signal: options.signal } : void 0
+      );
+      if (response.type === "error") {
+        throw new AdapterError(`Execute failed: ${response.message}`, { sql, params });
+      }
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Non-transactional read. Waits for this tab's open transaction to finish, so
+   * it never observes uncommitted (possibly rolled-back) rows (STORE-8).
+   */
+  async query(sql, params, options) {
+    this.guardOpen();
+    const release = await this.mutex.acquire();
+    try {
+      const response = await this.sendRequest(
+        {
+          id: 0,
+          type: "query",
+          sql,
+          params,
+          ...options?.requestId ? { requestId: options.requestId } : {}
+        },
+        options?.signal ? { signal: options.signal } : void 0
+      );
+      if (response.type === "error") {
+        throw new AdapterError(`Query failed: ${response.message}`, { sql, params });
+      }
+      return response.data ?? [];
+    } finally {
+      release();
+    }
+  }
+  async transaction(fn) {
+    this.guardOpen();
+    this.guardDurableWrite();
+    const release = await this.mutex.acquire();
+    let txBridge = null;
+    const sendInSpan = async (request) => {
+      if (txBridge === null || this.bridge !== txBridge) {
+        throw new BridgeTerminatedError(request.type, "storage leader changed during transaction");
+      }
+      return txBridge.send(request);
+    };
+    try {
+      while (this.gate) {
+        await this.gate.promise;
+      }
+      txBridge = this.bridge;
+      if (!txBridge) throw new StoreNotOpenError();
+      const begin = await sendInSpan({ id: 0, type: "begin" });
+      if (begin.type === "error") {
+        throw new AdapterError(`BEGIN transaction failed: ${begin.message}`);
+      }
+      const tx = {
+        execute: async (sql, params) => {
+          const response = await sendInSpan({ id: 0, type: "execute", sql, params });
+          if (response.type === "error") {
+            throw new AdapterError(`Transaction execute failed: ${response.message}`, {
+              sql,
+              params
+            });
+          }
+        },
+        query: async (sql, params) => {
+          const response = await sendInSpan({ id: 0, type: "query", sql, params });
+          if (response.type === "error") {
+            throw new AdapterError(`Transaction query failed: ${response.message}`, { sql, params });
+          }
+          return response.data ?? [];
+        }
+      };
+      await fn(tx);
+      const commit = await sendInSpan({ id: 0, type: "commit" });
+      if (commit.type === "error") {
+        throw new AdapterError(`COMMIT transaction failed: ${commit.message}`);
+      }
+    } catch (error) {
+      try {
+        if (txBridge && this.bridge === txBridge) {
+          await txBridge.send({ id: 0, type: "rollback" });
+        }
+      } catch {
+      }
+      throw error;
+    } finally {
+      release();
+    }
+  }
+  async migrate(from, to, migration) {
+    this.guardOpen();
+    this.guardDurableWrite();
+    const release = await this.mutex.acquire();
+    try {
+      await this.sendChecked({ id: 0, type: "begin" }, "BEGIN migration");
+      for (const sql of migration.statements) {
+        const response = await this.sendRequest({ id: 0, type: "execute", sql });
+        if (response.type === "error") {
+          throw new AdapterError(`Migration from v${from} to v${to} failed: ${response.message}`, {
+            from,
+            to
+          });
+        }
+      }
+      await this.sendChecked({ id: 0, type: "commit" }, "COMMIT migration");
+    } catch (error) {
+      try {
+        await this.sendRequest({ id: 0, type: "rollback" });
+      } catch {
+      }
+      if (error instanceof AdapterError) throw error;
+      throw new AdapterError(
+        `Migration from v${from} to v${to} failed: ${error.message}`,
+        { from, to }
+      );
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Export the database as a Uint8Array (for IndexedDB persistence).
+   * Only available when the database is open.
+   */
+  async exportDatabase() {
+    this.guardOpen();
+    const release = await this.mutex.acquire();
+    try {
+      const response = await this.sendRequest({ id: 0, type: "export" });
+      if (response.type === "error") {
+        throw new AdapterError(`Export failed: ${response.message}`, {
+          code: response.code,
+          context: response.context
+        });
+      }
+      return response.data;
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Import a serialized database snapshot.
+   */
+  async importDatabase(data) {
+    this.guardOpen();
+    this.guardDurableWrite();
+    const release = await this.mutex.acquire();
+    try {
+      const response = await this.sendRequest({ id: 0, type: "import", data });
+      if (response.type === "error") {
+        throw new AdapterError(`Import failed: ${response.message}`);
+      }
+    } finally {
+      release();
+    }
+  }
+  guardOpen() {
+    if (!this.opened || !this.bridge && !this.gate) {
+      throw new StoreNotOpenError();
+    }
+  }
+  async sendRequest(request, options) {
+    while (this.gate) {
+      await this.gate.promise;
+    }
+    const bridge = this.bridge;
+    if (!bridge) {
+      throw new StoreNotOpenError();
+    }
+    return bridge.send(request, void 0, options);
+  }
+  async sendChecked(request, description) {
+    const response = await this.sendRequest(request);
+    if (response.type === "error") {
+      throw new AdapterError(`${description} failed: ${response.message}`);
+    }
+  }
+};
+async function runWorkerTransaction(worker, fn) {
+  const send = async (request, what) => {
+    const response = await worker.send(request);
+    if (response.type === "error") {
+      throw new AdapterError(`${what} failed: ${response.message}`, {
+        code: response.code,
+        ...request.type === "execute" || request.type === "query" ? { sql: request.sql } : {}
+      });
+    }
+    return response;
+  };
+  await send({ id: 0, type: "begin" }, "BEGIN");
+  try {
+    await fn({
+      execute: async (sql, params) => {
+        await send({ id: 0, type: "execute", sql, params }, "Leader open execute");
+      },
+      query: async (sql, params) => {
+        const response = await send({ id: 0, type: "query", sql, params }, "Leader open query");
+        return response.data ?? [];
+      }
+    });
+    await send({ id: 0, type: "commit" }, "COMMIT");
+  } catch (error) {
+    await worker.send({ id: 0, type: "rollback" }).catch(() => void 0);
+    throw error;
+  }
+}
+function parseStorageOpenState(data) {
+  if (typeof data !== "object" || data === null) {
+    return null;
+  }
+  const mode = data;
+  if (typeof mode.persistent !== "boolean") {
+    return null;
+  }
+  return {
+    persistent: mode.persistent,
+    mode: mode.persistent ? "opfs" : "memory",
+    ...mode.fallbackReason ? { fallbackReason: mode.fallbackReason } : {},
+    ...typeof mode.poolName === "string" ? { poolName: mode.poolName } : {},
+    ...typeof mode.journalMode === "string" ? { journalMode: mode.journalMode } : {}
+  };
+}
+
+export {
+  exportDump,
+  restoreDumpStatements,
+  isIndexedDbQuotaError,
+  saveToIndexedDB,
+  saveDumpToIndexedDB,
+  loadFromIndexedDB,
+  loadDumpFromIndexedDB,
+  deleteSnapshotFromIndexedDB,
+  deleteFromIndexedDB,
+  isManifestAvailable,
+  readManifestRecord,
+  listManifestRecords,
+  recordDatabase,
+  deleteManifestRecord,
+  SqliteWasmAdapter
+};
+//# sourceMappingURL=chunk-QDUSJMFV.js.map