@xnetjs/sqlite 0.0.3 → 0.1.1

package/dist/adapters/web.js

@@ -1,12 +1,15 @@
 import {
   WebSQLiteAdapter,
   createWebSQLiteAdapter,
-  resetWebSQLiteOpfsStorage
-} from "../chunk-DCY4LAUD.js";
+  resetWebSQLiteOpfsStorage,
+  stepIncrementalVacuumToCompletion
+} from "../chunk-BBZDKLA3.js";
+import "../chunk-SV475UL5.js";
 import "../chunk-CBU263LI.js";
-import "../chunk-NVD7G7DZ.js";
+import "../chunk-W3L4FXU5.js";
 export {
   WebSQLiteAdapter,
   createWebSQLiteAdapter,
-  resetWebSQLiteOpfsStorage
+  resetWebSQLiteOpfsStorage,
+  stepIncrementalVacuumToCompletion
 };

package/dist/browser-support.d.ts

@@ -118,5 +118,14 @@ declare function requestPersistentStorage(options?: PersistentStorageRequestOpti
  * ```
  */
 declare function showUnsupportedBrowserMessage(reason: string): void;
+/**
+ * Record that this session opened on the non-durable `:memory:` fallback
+ * (another tab/worker held the OPFS handles, or OPFS is unavailable).
+ * Multi-tab leadership routing (0263) should drive this count to ~zero —
+ * the counter is how we verify that in the field. Returns the new total.
+ */
+declare function recordMemoryFallbackSession(): number;
+/** Total sessions on this device that fell back to `:memory:` storage. */
+declare function getMemoryFallbackSessionCount(): number;
 
-export { type BrowserSupport, type PersistentStorageRequestOptions, type PersistentStorageStatus, checkBrowserSupport, checkPersistentStorage, isSilentPersistRequestSafe, requestPersistentStorage, showUnsupportedBrowserMessage, watchPersistentStoragePermission };
+export { type BrowserSupport, type PersistentStorageRequestOptions, type PersistentStorageStatus, checkBrowserSupport, checkPersistentStorage, getMemoryFallbackSessionCount, isSilentPersistRequestSafe, recordMemoryFallbackSession, requestPersistentStorage, showUnsupportedBrowserMessage, watchPersistentStoragePermission };

package/dist/browser-support.js

@@ -1,15 +1,19 @@
 import {
   checkBrowserSupport,
   checkPersistentStorage,
+  getMemoryFallbackSessionCount,
   isSilentPersistRequestSafe,
+  recordMemoryFallbackSession,
   requestPersistentStorage,
   showUnsupportedBrowserMessage,
   watchPersistentStoragePermission
-} from "./chunk-2OK46ZBU.js";
+} from "./chunk-S6MT6KCI.js";
 export {
   checkBrowserSupport,
   checkPersistentStorage,
+  getMemoryFallbackSessionCount,
   isSilentPersistRequestSafe,
+  recordMemoryFallbackSession,
   requestPersistentStorage,
   showUnsupportedBrowserMessage,
   watchPersistentStoragePermission

package/dist/chunk-5HC5V73T.js

@@ -0,0 +1,191 @@
+// src/adapters/worker-scheduler.ts
+var LANE_ORDER = ["interactive", "bulk", "write"];
+function nowMs() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function firstOpGapFields(report, openedAtMs) {
+  return {
+    firstOpAfterOpen: true,
+    idleBeforeFirstOpMs: Math.round(report.enqueuedAt - openedAtMs),
+    sinceOpenMs: Math.round(report.startedAt - openedAtMs)
+  };
+}
+function percentileMs(samples, p) {
+  if (samples.length === 0) return 0;
+  const sorted = [...samples].sort((a, b) => a - b);
+  const rank = Math.min(sorted.length - 1, Math.max(0, Math.ceil(p / 100 * sorted.length) - 1));
+  return Math.round(sorted[rank]);
+}
+var SCHEDULER_STATS_SAMPLE_CAP = 512;
+var LaneStatsAccumulator = class {
+  ops = 0;
+  maxExecMs = 0;
+  queueSamples = [];
+  execSamples = [];
+  cursor = 0;
+  record(queueMs, execMs) {
+    this.ops += 1;
+    if (execMs > this.maxExecMs) this.maxExecMs = execMs;
+    if (this.queueSamples.length < SCHEDULER_STATS_SAMPLE_CAP) {
+      this.queueSamples.push(queueMs);
+      this.execSamples.push(execMs);
+    } else {
+      this.queueSamples[this.cursor] = queueMs;
+      this.execSamples[this.cursor] = execMs;
+      this.cursor = (this.cursor + 1) % SCHEDULER_STATS_SAMPLE_CAP;
+    }
+  }
+  stats() {
+    return {
+      ops: this.ops,
+      queueP50Ms: percentileMs(this.queueSamples, 50),
+      queueP95Ms: percentileMs(this.queueSamples, 95),
+      execP50Ms: percentileMs(this.execSamples, 50),
+      execP95Ms: percentileMs(this.execSamples, 95),
+      maxExecMs: Math.round(this.maxExecMs)
+    };
+  }
+  reset() {
+    this.ops = 0;
+    this.maxExecMs = 0;
+    this.queueSamples.length = 0;
+    this.execSamples.length = 0;
+    this.cursor = 0;
+  }
+};
+var WorkerScheduler = class {
+  /**
+   * @param onOp optional per-operation timing reporter (boot diagnostics, 0229).
+   */
+  constructor(onOp) {
+    this.onOp = onOp;
+  }
+  queues = {
+    interactive: [],
+    bulk: [],
+    write: []
+  };
+  /** In-flight + queued reads keyed by `coalesceKey`, to collapse duplicates. */
+  coalesced = /* @__PURE__ */ new Map();
+  running = false;
+  /** Aggregated op timing per lane (exploration 0263). */
+  laneStats = {
+    interactive: new LaneStatsAccumulator(),
+    bulk: new LaneStatsAccumulator(),
+    write: new LaneStatsAccumulator()
+  };
+  coalescedHits = 0;
+  /**
+   * Enqueue `fn` on `lane`. Returns a promise that settles with `fn`'s result.
+   *
+   * When `coalesceKey` is provided (reads only — they're idempotent), an
+   * identical key that is already queued or in flight returns the SAME promise
+   * instead of enqueuing a second execution. The key is dropped once that
+   * execution settles, so a later identical read re-runs against fresh data.
+   */
+  schedule(lane, fn, coalesceKey, label, detail) {
+    if (coalesceKey !== void 0) {
+      const inflight = this.coalesced.get(coalesceKey);
+      if (inflight) {
+        this.coalescedHits += 1;
+        return inflight;
+      }
+    }
+    const promise = new Promise((resolve, reject) => {
+      this.queues[lane].push({
+        run: fn,
+        resolve,
+        reject,
+        lane,
+        label,
+        detail,
+        enqueuedAt: nowMs()
+      });
+    });
+    if (coalesceKey !== void 0) {
+      this.coalesced.set(coalesceKey, promise);
+      const clear = () => {
+        if (this.coalesced.get(coalesceKey) === promise) this.coalesced.delete(coalesceKey);
+      };
+      promise.then(clear, clear);
+    }
+    void this.pump();
+    return promise;
+  }
+  /** Current queue depths and in-flight flag. */
+  snapshot() {
+    return {
+      interactive: this.queues.interactive.length,
+      bulk: this.queues.bulk.length,
+      write: this.queues.write.length,
+      inFlight: this.running
+    };
+  }
+  /** Cumulative op counts, coalesce hits, and per-lane latency percentiles. */
+  opStats() {
+    const lanes = {
+      interactive: this.laneStats.interactive.stats(),
+      bulk: this.laneStats.bulk.stats(),
+      write: this.laneStats.write.stats()
+    };
+    return {
+      ops: lanes.interactive.ops + lanes.bulk.ops + lanes.write.ops,
+      coalescedHits: this.coalescedHits,
+      lanes
+    };
+  }
+  /** Zero the op-stats counters for a focused before/after measurement. */
+  resetOpStats() {
+    this.coalescedHits = 0;
+    for (const lane of LANE_ORDER) {
+      this.laneStats[lane].reset();
+    }
+  }
+  /** Pull the next job, highest-priority non-empty lane first (FIFO within a lane). */
+  next() {
+    for (const lane of LANE_ORDER) {
+      const job = this.queues[lane].shift();
+      if (job) return job;
+    }
+    return void 0;
+  }
+  /** Drain the queues one job at a time. Re-entrant-safe via the `running` latch. */
+  async pump() {
+    if (this.running) return;
+    this.running = true;
+    try {
+      let job;
+      while (job = this.next()) {
+        const startedAt = nowMs();
+        try {
+          job.resolve(await job.run());
+        } catch (err) {
+          job.reject(err);
+        } finally {
+          const endedAt = nowMs();
+          const queueMs = startedAt - job.enqueuedAt;
+          const execMs = endedAt - startedAt;
+          this.laneStats[job.lane].record(queueMs, execMs);
+          if (this.onOp) {
+            this.onOp({
+              lane: job.lane,
+              label: job.label,
+              detail: job.detail,
+              queueMs,
+              execMs,
+              enqueuedAt: job.enqueuedAt,
+              startedAt
+            });
+          }
+        }
+      }
+    } finally {
+      this.running = false;
+    }
+  }
+};
+
+export {
+  firstOpGapFields,
+  WorkerScheduler
+};

package/dist/{chunk-DCY4LAUD.js → chunk-BBZDKLA3.js}

@@ -1,10 +1,13 @@
+import {
+  detectOpfsCapability
+} from "./chunk-SV475UL5.js";
 import {
   isSQLiteCorruptionError
 } from "./chunk-CBU263LI.js";
 import {
   SCHEMA_DDL,
   SCHEMA_VERSION
-} from "./chunk-NVD7G7DZ.js";
+} from "./chunk-W3L4FXU5.js";
 
 // src/adapters/opfs-retry.ts
 function isOpfsLockError(err) {
@@ -31,6 +34,68 @@ async function withOpfsLockRetry(fn, options = {}) {
   throw lastErr;
 }
 
+// src/adapters/stmt-cache.ts
+var DEFAULT_STMT_CACHE_CAPACITY = 64;
+function hasInteriorSemicolon(sql) {
+  const trimmed = sql.replace(/[\s;]+$/, "");
+  return trimmed.includes(";");
+}
+var StmtCache = class {
+  constructor(capacity = DEFAULT_STMT_CACHE_CAPACITY) {
+    this.capacity = capacity;
+    if (capacity < 1) {
+      throw new Error("StmtCache capacity must be >= 1");
+    }
+  }
+  entries = /* @__PURE__ */ new Map();
+  get size() {
+    return this.entries.size;
+  }
+  /** Look up a cached statement, refreshing its recency. */
+  get(sql) {
+    const stmt = this.entries.get(sql);
+    if (stmt !== void 0) {
+      this.entries.delete(sql);
+      this.entries.set(sql, stmt);
+    }
+    return stmt;
+  }
+  /** Insert a statement, finalizing the least-recently-used one if over capacity. */
+  set(sql, stmt) {
+    const existing = this.entries.get(sql);
+    if (existing !== void 0 && existing !== stmt) {
+      this.safeFinalize(existing);
+    }
+    this.entries.delete(sql);
+    this.entries.set(sql, stmt);
+    while (this.entries.size > this.capacity) {
+      const oldest = this.entries.keys().next().value;
+      const evicted = this.entries.get(oldest);
+      this.entries.delete(oldest);
+      if (evicted !== void 0) {
+        this.safeFinalize(evicted);
+      }
+    }
+  }
+  /**
+   * Finalize and drop every cached statement. Called on DDL (`exec`) — where a
+   * dropped table would otherwise leave poisoned handles — and on `close()`.
+   */
+  clear() {
+    for (const stmt of this.entries.values()) {
+      this.safeFinalize(stmt);
+    }
+    this.entries.clear();
+  }
+  /** finalize() must never throw into a caller that is already unwinding. */
+  safeFinalize(stmt) {
+    try {
+      stmt.finalize();
+    } catch {
+    }
+  }
+};
+
 // src/adapters/web.ts
 var WEB_SQLITE_VFS_NAME = "opfs-sahpool";
 var WEB_SQLITE_VFS_DIRECTORY = ".xnet-sqlite";
@@ -43,6 +108,9 @@ function log(...args) {
     console.log(...args);
   }
 }
+function nowMs() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
 function getDatabasePath(config) {
   return config.path.startsWith("/") ? config.path : `/${config.path}`;
 }
@@ -89,18 +157,54 @@ var WebSQLiteAdapter = class {
   poolUtil = null;
   _config = null;
   inTransaction = false;
+  /**
+   * Monotonic time of the open transaction's last operation. Lets the worker
+   * host distinguish a LIVE manual transaction from one abandoned by a client
+   * that died between BEGIN and COMMIT (PowerSync-style lease recovery, 0263).
+   */
+  lastTransactionActivityAt = 0;
   storageMode = "memory";
+  /**
+   * Per-phase timing of the last {@link open} call, or null until it runs.
+   * Read by the worker host to emit `[xNet] sqlite open phases` (exploration
+   * 0253). Diagnostic only — never affects behaviour.
+   */
+  openPhaseTimings = null;
+  /** ms spent in `applySchema()` during {@link createWebSQLiteAdapter}, for the open-phases line. */
+  schemaApplyMs = 0;
+  /** How many times the OPFS lock-retry backoff fired during the last {@link open} (0 = first try). */
+  openRetryAttempts = 0;
+  /**
+   * Prepared-statement LRU for the hot query/run path (exploration 0263).
+   * `db.exec()` re-parses the SQL on every call; the hot path repeats a small
+   * statement set, so cached `oo1.Stmt` handles skip the parse+prepare cost.
+   * Cleared (finalizing all handles) on {@link exec} — the DDL/script path —
+   * and on {@link close}.
+   */
+  stmts = new StmtCache();
+  /** Per-phase timing of the last {@link open}, or null if it hasn't run. */
+  getOpenPhaseTimings() {
+    return this.openPhaseTimings ? { ...this.openPhaseTimings } : null;
+  }
   async open(config) {
     if (this.db !== null) {
       throw new Error("Database already open. Call close() first.");
     }
     log("[WebSQLiteAdapter] Starting open()...");
+    const openStartedAt = nowMs();
+    let afterImport = openStartedAt;
+    let afterInit = openStartedAt;
+    let afterVfsInstall = openStartedAt;
+    let afterReserveCapacity = openStartedAt;
+    let afterDbOpen = openStartedAt;
     log("[WebSQLiteAdapter] Importing sqlite-wasm...");
     const sqlite3InitModule = (await import("@sqlite.org/sqlite-wasm")).default;
     log("[WebSQLiteAdapter] sqlite-wasm imported");
+    afterImport = nowMs();
     log("[WebSQLiteAdapter] Initializing sqlite3 module...");
     this.sqlite3 = await sqlite3InitModule();
     log("[WebSQLiteAdapter] sqlite3 module initialized");
+    afterInit = nowMs();
     try {
       await withOpfsLockRetry(
         async () => {
@@ -113,17 +217,21 @@ var WebSQLiteAdapter = class {
             clearOnInit: false
           });
           log("[WebSQLiteAdapter] OPFS-SAHPool VFS installed");
+          afterVfsInstall = nowMs();
           log("[WebSQLiteAdapter] Reserving capacity...");
           await this.poolUtil.reserveMinimumCapacity(10);
           log("[WebSQLiteAdapter] Capacity reserved");
+          afterReserveCapacity = nowMs();
           const dbPath = getDatabasePath(config);
           log("[WebSQLiteAdapter] Opening database at", dbPath);
           this.db = new this.poolUtil.OpfsSAHPoolDb(dbPath, "c");
           this.storageMode = "opfs";
           log("[WebSQLiteAdapter] Database opened with OPFS-SAHPool");
+          afterDbOpen = nowMs();
         },
         {
           onRetry: (attempt, retryErr) => {
+            this.openRetryAttempts = attempt;
             console.warn(
               `[WebSQLiteAdapter] OPFS access handles are busy (attempt ${attempt}) \u2014 a previous tab/worker is likely still releasing them; retrying before any in-memory fallback.`,
               retryErr
@@ -132,7 +240,12 @@ var WebSQLiteAdapter = class {
         }
       );
     } catch (err) {
-      console.warn("[WebSQLiteAdapter] OPFS-SAHPool not available, trying OPFS direct mode:", err);
+      const capability = detectOpfsCapability();
+      if (capability.mode === "async-opfs") {
+        console.info("[WebSQLiteAdapter] Sync access handles unavailable \u2014 " + capability.reason);
+      } else {
+        console.warn("[WebSQLiteAdapter] OPFS-SAHPool not available, trying OPFS direct mode:", err);
+      }
       const dbPath = getDatabasePath(config);
       const opfsDbCtor = this.sqlite3?.oo1?.OpfsDb;
       if (typeof opfsDbCtor === "function") {
@@ -157,6 +270,7 @@ var WebSQLiteAdapter = class {
       }
     }
     this._config = config;
+    const beforePragmas = nowMs();
     if (config.foreignKeys !== false) {
       this.execSync("PRAGMA foreign_keys = ON");
     }
@@ -170,16 +284,44 @@ var WebSQLiteAdapter = class {
     } catch (err) {
       log("[WebSQLiteAdapter] page_size pragma not applied:", err);
     }
+    try {
+      this.execSync("PRAGMA auto_vacuum = INCREMENTAL");
+    } catch (err) {
+      log("[WebSQLiteAdapter] auto_vacuum pragma not applied:", err);
+    }
     this.execSync("PRAGMA synchronous = NORMAL");
     this.execSync("PRAGMA cache_size = -262144");
+    try {
+      this.execSync("PRAGMA mmap_size = 268435456");
+    } catch (err) {
+      log("[WebSQLiteAdapter] mmap_size pragma not applied:", err);
+    }
     this.execSync("PRAGMA temp_store = MEMORY");
     try {
       this.execSync("PRAGMA journal_mode = TRUNCATE");
     } catch (err) {
       log("[WebSQLiteAdapter] journal_mode pragma not applied:", err);
     }
+    try {
+      this.execSync("PRAGMA analysis_limit = 400");
+      this.execSync("PRAGMA optimize = 0x10002");
+    } catch (err) {
+      log("[WebSQLiteAdapter] open-time optimize not applied:", err);
+    }
+    const afterPragmas = nowMs();
+    const round = (a, b) => Math.round(b - a);
+    this.openPhaseTimings = {
+      wasmImportMs: round(openStartedAt, afterImport),
+      wasmInitMs: round(afterImport, afterInit),
+      vfsInstallMs: round(afterInit, afterVfsInstall),
+      reserveCapacityMs: round(afterVfsInstall, afterReserveCapacity),
+      dbOpenMs: round(afterReserveCapacity, afterDbOpen),
+      pragmasMs: round(beforePragmas, afterPragmas),
+      totalOpenMs: round(openStartedAt, afterPragmas)
+    };
   }
   async close() {
+    this.stmts.clear();
     if (this.db) {
       try {
         this.execSync("PRAGMA optimize");
@@ -199,29 +341,98 @@ var WebSQLiteAdapter = class {
   getStorageMode() {
     return this.storageMode;
   }
+  /** True while a manual BEGIN…COMMIT/ROLLBACK transaction is open. */
+  isInTransaction() {
+    return this.inTransaction;
+  }
+  /** ms since the open transaction last executed an operation (0 when none). */
+  transactionIdleMs() {
+    return this.inTransaction ? nowMs() - this.lastTransactionActivityAt : 0;
+  }
+  /** Stamp transaction liveness — called by ops that run inside one. */
+  touchTransaction() {
+    if (this.inTransaction) {
+      this.lastTransactionActivityAt = nowMs();
+    }
+  }
+  /**
+   * Fetch (or prepare and cache) the statement for `sql`, or null when the SQL
+   * must bypass the cache: `db.prepare()` compiles only the FIRST statement of
+   * a multi-statement string, whereas `db.exec()` runs them all — serving such
+   * SQL from the cache would silently drop statements.
+   */
+  getCachedStmt(sql) {
+    if (hasInteriorSemicolon(sql)) {
+      return null;
+    }
+    let stmt = this.stmts.get(sql);
+    if (stmt === void 0) {
+      stmt = this.db.prepare(sql);
+      this.stmts.set(sql, stmt);
+    }
+    return stmt;
+  }
   async query(sql, params) {
     this.ensureOpen();
+    this.touchTransaction();
     const rows = [];
-    this.db.exec({
-      sql,
-      bind: params,
-      rowMode: "object",
-      callback: (row) => {
-        rows.push(row);
+    const stmt = this.getCachedStmt(sql);
+    if (stmt === null) {
+      this.db.exec({
+        sql,
+        bind: params,
+        rowMode: "object",
+        callback: (row) => {
+          rows.push(row);
+        }
+      });
+      return rows;
+    }
+    try {
+      if (params && params.length > 0) {
+        stmt.bind(params);
       }
-    });
+      while (stmt.step()) {
+        rows.push(stmt.get({}));
+      }
+    } finally {
+      stmt.reset();
+      stmt.clearBindings();
+    }
     return rows;
   }
   async queryOne(sql, params) {
     const rows = await this.query(sql, params);
     return rows[0] ?? null;
   }
+  async queryBatch(reads) {
+    const results = [];
+    for (const read of reads) {
+      results.push(await this.query(read.sql, read.params));
+    }
+    return results;
+  }
   async run(sql, params) {
     this.ensureOpen();
-    this.db.exec({
-      sql,
-      bind: params
-    });
+    this.touchTransaction();
+    const stmt = this.getCachedStmt(sql);
+    if (stmt === null) {
+      this.db.exec({
+        sql,
+        bind: params
+      });
+    } else {
+      try {
+        if (params && params.length > 0) {
+          stmt.bind(params);
+        }
+        while (stmt.step()) {
+        }
+      } finally {
+        stmt.reset();
+        stmt.clearBindings();
+      }
+    }
     return {
       changes: this.sqlite3.capi.sqlite3_changes(this.db.pointer),
       lastInsertRowid: this.sqlite3.capi.sqlite3_last_insert_rowid(this.db.pointer)
@@ -229,6 +440,7 @@ var WebSQLiteAdapter = class {
   }
   async exec(sql) {
     this.ensureOpen();
+    this.stmts.clear();
     this.execSync(sql);
   }
   execSync(sql) {
@@ -391,6 +603,7 @@ var WebSQLiteAdapter = class {
     }
     this.execSync("BEGIN IMMEDIATE");
     this.inTransaction = true;
+    this.lastTransactionActivityAt = nowMs();
   }
   async commit() {
     if (!this.inTransaction) {
@@ -471,6 +684,10 @@ var WebSQLiteAdapter = class {
   async vacuum() {
     await this.exec("VACUUM");
   }
+  async incrementalVacuum(maxPages) {
+    this.ensureOpen();
+    return stepIncrementalVacuumToCompletion(this.db, maxPages);
+  }
   async checkpoint() {
     return 0;
   }
@@ -480,15 +697,31 @@ var WebSQLiteAdapter = class {
     }
   }
 };
+function stepIncrementalVacuumToCompletion(db, maxPages) {
+  const limit = maxPages !== void 0 && maxPages > 0 ? Math.floor(maxPages) : Infinity;
+  const stmt = db.prepare("PRAGMA incremental_vacuum");
+  let freed = 0;
+  try {
+    while (freed < limit && stmt.step()) {
+      freed++;
+    }
+  } finally {
+    stmt.finalize();
+  }
+  return freed;
+}
 async function createWebSQLiteAdapter(config) {
   const adapter = new WebSQLiteAdapter();
   await adapter.open(config);
+  const schemaStartedAt = nowMs();
   await adapter.applySchema(SCHEMA_VERSION, SCHEMA_DDL);
+  adapter.schemaApplyMs = Math.round(nowMs() - schemaStartedAt);
   return adapter;
 }
 
 export {
   resetWebSQLiteOpfsStorage,
   WebSQLiteAdapter,
+  stepIncrementalVacuumToCompletion,
   createWebSQLiteAdapter
 };

package/dist/chunk-CGI2YBZY.js

@@ -0,0 +1,16 @@
+// src/adapters/boot-log-bridge.ts
+var BOOT_LOG_KEY = "__xnetSqliteBootLog";
+function bootLogMessage(args) {
+  return { [BOOT_LOG_KEY]: args };
+}
+function readBootLogArgs(data) {
+  if (typeof data === "object" && data !== null && Array.isArray(data[BOOT_LOG_KEY])) {
+    return data[BOOT_LOG_KEY];
+  }
+  return null;
+}
+
+export {
+  bootLogMessage,
+  readBootLogArgs
+};

package/dist/{chunk-2OK46ZBU.js → chunk-S6MT6KCI.js}

@@ -247,6 +247,25 @@ function escapeHtml(text) {
   div.textContent = text;
   return div.innerHTML;
 }
+var MEMORY_FALLBACK_COUNT_KEY = "xnet:sqlite:memory-fallback-count";
+function recordMemoryFallbackSession() {
+  try {
+    const count = getMemoryFallbackSessionCount() + 1;
+    localStorage.setItem(MEMORY_FALLBACK_COUNT_KEY, String(count));
+    return count;
+  } catch {
+    return 0;
+  }
+}
+function getMemoryFallbackSessionCount() {
+  try {
+    const raw = localStorage.getItem(MEMORY_FALLBACK_COUNT_KEY);
+    const parsed = raw === null ? 0 : Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+  } catch {
+    return 0;
+  }
+}
 
 export {
   checkBrowserSupport,
@@ -254,5 +273,7 @@ export {
   isSilentPersistRequestSafe,
   watchPersistentStoragePermission,
   requestPersistentStorage,
-  showUnsupportedBrowserMessage
+  showUnsupportedBrowserMessage,
+  recordMemoryFallbackSession,
+  getMemoryFallbackSessionCount
 };