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

package/dist/chunk-RJIEKEN4.js

@@ -1,751 +0,0 @@
-import {
-  Mutex
-} from "./chunk-TVJEC5S2.js";
-import {
-  AdapterError,
-  NoLeaderError,
-  StoreNotOpenError,
-  WorkerTimeoutError
-} from "./chunk-TUR7RGEP.js";
-
-// src/adapters/sqlite-wasm-adapter.ts
-import { generateFullDDL } from "@korajs/core";
-
-// src/multi-tab/tab-storage.ts
-var RPC_REQUEST = "kora-worker-request";
-var RPC_RESPONSE = "kora-worker-response";
-var CLIENT_LEAVE = "kora-client-leave";
-var LEADER_PING = "kora-leader-ping";
-var LEADER_PONG = "kora-leader-pong";
-var DEFAULT_LIVENESS_PROBE_MS = 2e3;
-var DEFAULT_TRANSACTION_IDLE_TIMEOUT_MS = 1e4;
-function isMultiTabStorageSupported() {
-  return typeof globalThis !== "undefined" && typeof BroadcastChannel !== "undefined" && typeof navigator !== "undefined" && typeof navigator.locks?.request === "function";
-}
-async function acquireTabStorageSession(dbName, options) {
-  const channelName = `kora-storage-${dbName}`;
-  const lockName = `kora-leader-${dbName}`;
-  if (!isMultiTabStorageSupported()) {
-    return { role: "leader", channelName };
-  }
-  return new Promise((resolve) => {
-    let releaseHeld;
-    void navigator.locks.request(lockName, { mode: "exclusive", ifAvailable: true }, (lock) => {
-      if (lock === null) {
-        resolve(startFollowerSession(channelName, lockName, options));
-        return;
-      }
-      resolve({
-        role: "leader",
-        channelName,
-        releaseLock: async () => {
-          releaseHeld?.();
-        }
-      });
-      return new Promise((release) => {
-        releaseHeld = release;
-      });
-    });
-  });
-}
-function startFollowerSession(channelName, lockName, options) {
-  let promoted = false;
-  let releasePromotedLock;
-  const abort = new AbortController();
-  void navigator.locks.request(lockName, { mode: "exclusive", signal: abort.signal }, () => {
-    promoted = true;
-    options?.onPromote?.();
-    return new Promise((release) => {
-      releasePromotedLock = release;
-    });
-  }).catch(() => {
-  });
-  return {
-    role: "follower",
-    channelName,
-    cancelPromotionWatch: () => {
-      if (promoted) {
-        releasePromotedLock?.();
-      } else {
-        abort.abort();
-      }
-    }
-  };
-}
-function startLeaderRpcRelay(channelName, bridge) {
-  const channel = new BroadcastChannel(channelName);
-  const onMessage = (event) => {
-    const data = event.data;
-    if (data?.type === LEADER_PING) {
-      channel.postMessage({ type: LEADER_PONG });
-      return;
-    }
-    if (data?.type === CLIENT_LEAVE) {
-      if (hasReclaimClient(bridge)) {
-        bridge.reclaimClient(data.clientId, "client-left");
-      }
-      return;
-    }
-    if (data?.type !== RPC_REQUEST) {
-      return;
-    }
-    void bridge.send(data.request, data.clientId).then((response) => {
-      const msg = {
-        type: RPC_RESPONSE,
-        requestId: data.requestId,
-        response
-      };
-      channel.postMessage(msg);
-    }).catch((error) => {
-      const message = error instanceof Error ? error.message : "Worker RPC failed";
-      const msg = {
-        type: RPC_RESPONSE,
-        requestId: data.requestId,
-        response: {
-          id: data.request.id,
-          type: "error",
-          message,
-          code: "LEADER_RPC_ERROR"
-        }
-      };
-      channel.postMessage(msg);
-    });
-  };
-  channel.addEventListener("message", onMessage);
-  return () => {
-    channel.removeEventListener("message", onMessage);
-    channel.close();
-  };
-}
-var FollowerBroadcastBridge = class {
-  channel;
-  clientId = createClientId();
-  onPageHide = () => {
-    this.leaveLeader();
-  };
-  pending = /* @__PURE__ */ new Map();
-  timeoutMs;
-  livenessProbeMs;
-  terminated = false;
-  constructor(channelName, timeoutMs = 3e4, livenessProbeMs = DEFAULT_LIVENESS_PROBE_MS) {
-    this.timeoutMs = timeoutMs;
-    this.livenessProbeMs = Math.min(livenessProbeMs, timeoutMs);
-    this.channel = new BroadcastChannel(channelName);
-    if (typeof addEventListener === "function") {
-      addEventListener("pagehide", this.onPageHide);
-    }
-    this.channel.addEventListener("message", (event) => {
-      const data = event.data;
-      if (data?.type !== RPC_RESPONSE) {
-        return;
-      }
-      const entry = this.pending.get(data.requestId);
-      if (entry) {
-        this.pending.delete(data.requestId);
-        entry.resolve(data.response);
-      }
-    });
-  }
-  /**
-   * Readiness handshake: resolves `true` as soon as a live leader answers a ping,
-   * or `false` if none answers within the budget. The adapter calls this before
-   * its first RPC so a follower created before a leader relay is live retries the
-   * handshake instead of firing into the void and waiting out the full timeout.
-   */
-  async waitForLeader(timeoutMs = 3e3, attempts = 3) {
-    const perAttempt = Math.max(50, Math.floor(timeoutMs / Math.max(1, attempts)));
-    for (let attempt = 0; attempt < attempts; attempt += 1) {
-      if (this.terminated) {
-        return false;
-      }
-      if (await this.pingLeader(perAttempt)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /** Sends one liveness ping and resolves whether a leader answered in time. */
-  pingLeader(timeoutMs) {
-    if (this.terminated) {
-      return Promise.resolve(false);
-    }
-    return new Promise((resolve) => {
-      const onPong = (event) => {
-        if (event.data?.type === LEADER_PONG) {
-          cleanup();
-          resolve(true);
-        }
-      };
-      const cleanup = () => {
-        clearTimeout(timer);
-        this.channel.removeEventListener("message", onPong);
-      };
-      const timer = setTimeout(() => {
-        cleanup();
-        resolve(false);
-      }, timeoutMs);
-      this.channel.addEventListener("message", onPong);
-      this.channel.postMessage({ type: LEADER_PING });
-    });
-  }
-  async send(request) {
-    if (this.terminated) {
-      return {
-        id: request.id,
-        type: "error",
-        message: "Follower bridge terminated",
-        code: "BRIDGE_TERMINATED"
-      };
-    }
-    const requestId = createClientId();
-    const msg = {
-      type: RPC_REQUEST,
-      requestId,
-      clientId: this.clientId,
-      request
-    };
-    return new Promise((resolve, reject) => {
-      const settle = (fn) => {
-        clearTimeout(timer);
-        clearTimeout(probe);
-        this.pending.delete(requestId);
-        fn();
-      };
-      const timer = setTimeout(() => {
-        settle(() => reject(new WorkerTimeoutError(`follower-rpc:${request.type}`, this.timeoutMs)));
-      }, this.timeoutMs);
-      const probe = setTimeout(() => {
-        void this.pingLeader(this.livenessProbeMs).then((alive) => {
-          if (!alive && this.pending.has(requestId)) {
-            settle(() => reject(new NoLeaderError(`follower-rpc:${request.type}`)));
-          }
-        });
-      }, this.livenessProbeMs);
-      this.pending.set(requestId, {
-        resolve: (response) => settle(() => resolve(response)),
-        reject: (error) => settle(() => reject(error))
-      });
-      this.channel.postMessage(msg);
-    });
-  }
-  terminate() {
-    if (this.terminated) {
-      return;
-    }
-    this.terminated = true;
-    this.leaveLeader();
-    if (typeof removeEventListener === "function") {
-      removeEventListener("pagehide", this.onPageHide);
-    }
-    this.channel.close();
-    for (const [, entry] of this.pending) {
-      entry.reject(new Error("Follower bridge terminated"));
-    }
-    this.pending.clear();
-  }
-  leaveLeader() {
-    try {
-      const message = {
-        type: CLIENT_LEAVE,
-        clientId: this.clientId
-      };
-      this.channel.postMessage(message);
-    } catch {
-    }
-  }
-};
-var TransactionSerializingWorkerBridge = class {
-  inner;
-  leaderClientId = createClientId();
-  transactionIdleTimeoutMs;
-  queue = [];
-  activeTransactionClient = null;
-  abortedClients = /* @__PURE__ */ new Set();
-  transactionIdleTimer = null;
-  reclaiming = false;
-  processing = false;
-  terminated = false;
-  constructor(inner, transactionIdleTimeoutMs = DEFAULT_TRANSACTION_IDLE_TIMEOUT_MS) {
-    this.inner = inner;
-    this.transactionIdleTimeoutMs = transactionIdleTimeoutMs;
-  }
-  send(request, clientId = this.leaderClientId) {
-    if (this.terminated) {
-      return Promise.resolve({
-        id: request.id,
-        type: "error",
-        message: "Worker has been terminated",
-        code: "WORKER_TERMINATED"
-      });
-    }
-    if (this.abortedClients.has(clientId)) {
-      if (request.type === "begin") {
-        this.abortedClients.delete(clientId);
-      } else {
-        return Promise.resolve({
-          id: request.id,
-          type: "error",
-          message: "Previous transaction was aborted because the client stopped sending requests.",
-          code: "TRANSACTION_ABORTED"
-        });
-      }
-    }
-    return new Promise((resolve, reject) => {
-      this.queue.push({ clientId, request, resolve, reject });
-      void this.processQueue();
-    });
-  }
-  terminate() {
-    if (this.terminated) {
-      return;
-    }
-    this.terminated = true;
-    this.clearTransactionIdleTimer();
-    this.inner.terminate();
-    const pending = this.queue.splice(0);
-    for (const entry of pending) {
-      entry.reject(new Error("Worker terminated"));
-    }
-  }
-  reclaimClient(clientId, reason) {
-    if (this.terminated) {
-      return;
-    }
-    void this.reclaimClientNow(clientId, reason);
-  }
-  async processQueue() {
-    if (this.processing || this.reclaiming) {
-      return;
-    }
-    this.processing = true;
-    try {
-      while (!this.terminated) {
-        const index = this.nextRunnableIndex();
-        if (index === -1) {
-          return;
-        }
-        const [entry] = this.queue.splice(index, 1);
-        if (!entry) {
-          return;
-        }
-        try {
-          const response = await this.inner.send(entry.request);
-          this.recordTransactionState(entry, response);
-          entry.resolve(response);
-        } catch (error) {
-          this.resetFailedTransaction(entry);
-          entry.reject(error instanceof Error ? error : new Error(String(error)));
-        }
-      }
-    } finally {
-      this.processing = false;
-      if (!this.terminated && !this.reclaiming && this.nextRunnableIndex() !== -1) {
-        void this.processQueue();
-      }
-    }
-  }
-  nextRunnableIndex() {
-    if (this.queue.length === 0) {
-      return -1;
-    }
-    if (this.activeTransactionClient === null) {
-      return 0;
-    }
-    return this.queue.findIndex((entry) => entry.clientId === this.activeTransactionClient);
-  }
-  recordTransactionState(entry, response) {
-    if (response.type === "error") {
-      this.resetFailedTransaction(entry);
-      return;
-    }
-    if (entry.request.type === "begin") {
-      this.activeTransactionClient = entry.clientId;
-      this.armTransactionIdleTimer(entry.clientId);
-      return;
-    }
-    if (this.activeTransactionClient === entry.clientId) {
-      this.armTransactionIdleTimer(entry.clientId);
-    }
-    if (this.activeTransactionClient === entry.clientId && (entry.request.type === "commit" || entry.request.type === "rollback")) {
-      this.activeTransactionClient = null;
-      this.clearTransactionIdleTimer();
-    }
-  }
-  resetFailedTransaction(entry) {
-    if (this.activeTransactionClient === entry.clientId) {
-      this.activeTransactionClient = null;
-      this.clearTransactionIdleTimer();
-    }
-  }
-  armTransactionIdleTimer(clientId) {
-    this.clearTransactionIdleTimer();
-    this.transactionIdleTimer = setTimeout(() => {
-      void this.reclaimClientNow(clientId, "transaction-idle-timeout");
-    }, this.transactionIdleTimeoutMs);
-  }
-  clearTransactionIdleTimer() {
-    if (this.transactionIdleTimer) {
-      clearTimeout(this.transactionIdleTimer);
-      this.transactionIdleTimer = null;
-    }
-  }
-  async reclaimClientNow(clientId, reason) {
-    if (this.reclaiming || this.activeTransactionClient !== clientId) {
-      return;
-    }
-    this.reclaiming = true;
-    this.clearTransactionIdleTimer();
-    this.activeTransactionClient = null;
-    this.abortedClients.add(clientId);
-    this.rejectQueuedClientRequests(clientId, reason);
-    try {
-      const response = await this.inner.send({ id: 0, type: "rollback" });
-      if (response.type === "error") {
-      }
-    } catch {
-    } finally {
-      this.reclaiming = false;
-      if (!this.terminated && this.nextRunnableIndex() !== -1) {
-        void this.processQueue();
-      }
-    }
-  }
-  rejectQueuedClientRequests(clientId, reason) {
-    const keep = [];
-    for (const entry of this.queue) {
-      if (entry.clientId === clientId) {
-        entry.resolve({
-          id: entry.request.id,
-          type: "error",
-          message: `Transaction client was reclaimed: ${reason}`,
-          code: "TRANSACTION_ABORTED"
-        });
-      } else {
-        keep.push(entry);
-      }
-    }
-    this.queue = keep;
-  }
-};
-function hasReclaimClient(bridge) {
-  return typeof bridge.reclaimClient === "function";
-}
-function createClientId() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-}
-
-// src/adapters/sqlite-wasm-adapter.ts
-var warnedSharedWorkerDeprecated = false;
-var SqliteWasmAdapter = class {
-  bridge = 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;
-  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;
-  }
-  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.opened = true;
-      return;
-    }
-    if (this.workerUrl) {
-      this.warnSharedWorkerDeprecated();
-      await this.openDurableWorkerBridge(schema);
-      const response = await this.openCurrentBridge(ddlStatements);
-      this.reportStorageMode(response.data);
-      this.opened = true;
-      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.'
-    );
-  }
-  async openDurableWorkerBridge(schema) {
-    if (!this.workerUrl) {
-      throw new AdapterError("Durable SQLite WASM storage requires workerUrl.");
-    }
-    this.schema = schema;
-    this.tabSession = await acquireTabStorageSession(this.dbName, {
-      onPromote: () => {
-        void this.promoteToLeader();
-      }
-    });
-    const { WebWorkerBridge } = await import("./sqlite-wasm-channel-GGHA2BXU.js");
-    if (this.tabSession.role === "leader") {
-      const workerBridge = new TransactionSerializingWorkerBridge(
-        new WebWorkerBridge(this.workerUrl, this.workerResponseTimeoutMs)
-      );
-      this.tabSession.stopRelay = startLeaderRpcRelay(this.tabSession.channelName, workerBridge);
-      this.bridge = workerBridge;
-      return;
-    }
-    const followerBridge = new FollowerBroadcastBridge(
-      this.tabSession.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();
-  }
-  async openCurrentBridge(ddlStatements) {
-    const response = await this.sendRequest({
-      id: 0,
-      type: "open",
-      ddlStatements,
-      dbName: this.dbName
-    });
-    if (response.type === "error") {
-      throw new AdapterError(`Failed to open database: ${response.message}`, {
-        code: response.code,
-        dbName: this.dbName
-      });
-    }
-    return response;
-  }
-  /**
-   * 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) {
-      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;
-  }
-  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."
-    );
-  }
-  async close() {
-    if (!this.bridge) return;
-    try {
-      await this.sendRequest({ id: 0, type: "close" });
-    } finally {
-      this.tabSession?.stopRelay?.();
-      this.tabSession?.cancelPromotionWatch?.();
-      if (this.tabSession?.releaseLock) {
-        await this.tabSession.releaseLock();
-      }
-      this.tabSession = null;
-      this.bridge.terminate();
-      this.bridge = null;
-      this.opened = false;
-    }
-  }
-  /**
-   * Promotes a follower to leader after the previous leader released the storage
-   * lock (its tab closed or crashed). The lock is only granted once the old leader
-   * is gone, so opening our own worker here is safe from the OPFS single-writer
-   * rule. In-flight follower RPCs are rejected and left to the caller / reactive
-   * layer to retry against the new leader.
-   */
-  async promoteToLeader() {
-    if (this.promoting || !this.opened || this.workerUrl === void 0 || this.schema === null) {
-      return;
-    }
-    this.promoting = true;
-    const { WebWorkerBridge } = await import("./sqlite-wasm-channel-GGHA2BXU.js");
-    const workerBridge = new TransactionSerializingWorkerBridge(
-      new WebWorkerBridge(this.workerUrl, this.workerResponseTimeoutMs)
-    );
-    const previousBridge = this.bridge;
-    this.bridge = workerBridge;
-    if (this.tabSession) {
-      this.tabSession.role = "leader";
-      this.tabSession.stopRelay = startLeaderRpcRelay(this.tabSession.channelName, workerBridge);
-    }
-    previousBridge?.terminate();
-    const ddlStatements = generateFullDDL(this.schema);
-    await this.sendRequest({ id: 0, type: "open", ddlStatements, dbName: this.dbName });
-  }
-  async execute(sql, params) {
-    this.guardOpen();
-    const response = await this.sendRequest({ id: 0, type: "execute", sql, params });
-    if (response.type === "error") {
-      throw new AdapterError(`Execute failed: ${response.message}`, { sql, params });
-    }
-  }
-  async query(sql, params) {
-    this.guardOpen();
-    const response = await this.sendRequest({ id: 0, type: "query", sql, params });
-    if (response.type === "error") {
-      throw new AdapterError(`Query failed: ${response.message}`, { sql, params });
-    }
-    return response.data ?? [];
-  }
-  async transaction(fn) {
-    this.guardOpen();
-    const release = await this.mutex.acquire();
-    try {
-      await this.sendChecked({ id: 0, type: "begin" }, "BEGIN transaction");
-      const tx = {
-        execute: async (sql, params) => {
-          const response = await this.sendRequest({ 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 this.sendRequest({ 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);
-      await this.sendChecked({ id: 0, type: "commit" }, "COMMIT transaction");
-    } catch (error) {
-      try {
-        await this.sendRequest({ id: 0, type: "rollback" });
-      } catch {
-      }
-      throw error;
-    } finally {
-      release();
-    }
-  }
-  async migrate(from, to, migration) {
-    this.guardOpen();
-    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 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;
-  }
-  /**
-   * Import a serialized database snapshot.
-   */
-  async importDatabase(data) {
-    this.guardOpen();
-    const response = await this.sendRequest({ id: 0, type: "import", data });
-    if (response.type === "error") {
-      throw new AdapterError(`Import failed: ${response.message}`);
-    }
-  }
-  guardOpen() {
-    if (!this.opened || !this.bridge) {
-      throw new StoreNotOpenError();
-    }
-  }
-  async sendRequest(request) {
-    const bridge = this.bridge;
-    if (!bridge) {
-      throw new StoreNotOpenError();
-    }
-    return bridge.send(request);
-  }
-  async sendChecked(request, description) {
-    const response = await this.sendRequest(request);
-    if (response.type === "error") {
-      throw new AdapterError(`${description} failed: ${response.message}`);
-    }
-  }
-};
-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 } : {}
-  };
-}
-
-export {
-  SqliteWasmAdapter
-};
-//# sourceMappingURL=chunk-RJIEKEN4.js.map