@xnetjs/sqlite 0.0.2 → 0.1.0

package/dist/chunk-BBZDKLA3.js

@@ -0,0 +1,727 @@
+import {
+  detectOpfsCapability
+} from "./chunk-SV475UL5.js";
+import {
+  isSQLiteCorruptionError
+} from "./chunk-CBU263LI.js";
+import {
+  SCHEMA_DDL,
+  SCHEMA_VERSION
+} from "./chunk-W3L4FXU5.js";
+
+// src/adapters/opfs-retry.ts
+function isOpfsLockError(err) {
+  const e = err;
+  if (!e) return false;
+  if (e.name === "NoModificationAllowedError") return true;
+  return /Access Handles cannot be created|createSyncAccessHandle/i.test(e.message ?? "");
+}
+async function withOpfsLockRetry(fn, options = {}) {
+  const attempts = options.attempts ?? 5;
+  const baseDelayMs = options.baseDelayMs ?? 150;
+  const sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  let lastErr;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (!isOpfsLockError(err) || attempt === attempts) throw err;
+      options.onRetry?.(attempt, err);
+      await sleep(baseDelayMs * attempt);
+    }
+  }
+  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";
+var WEB_SQLITE_INITIAL_CAPACITY = 10;
+function isDebugEnabled() {
+  return typeof self !== "undefined" && typeof localStorage !== "undefined" && localStorage.getItem("xnet:sqlite:debug") === "true";
+}
+function log(...args) {
+  if (isDebugEnabled()) {
+    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}`;
+}
+async function removeOPFSDirectory(directory) {
+  const storage = globalThis.navigator?.storage;
+  if (typeof storage?.getDirectory !== "function") {
+    return;
+  }
+  try {
+    const root = await storage.getDirectory();
+    await root.removeEntry(directory.replace(/^\/+/, ""), { recursive: true });
+  } catch (err) {
+    if (err instanceof DOMException && err.name === "NotFoundError") {
+      return;
+    }
+    throw err;
+  }
+}
+async function resetWebSQLiteOpfsStorage(config) {
+  const sqlite3InitModule = (await import("@sqlite.org/sqlite-wasm")).default;
+  const sqlite3 = await sqlite3InitModule();
+  const dbPath = getDatabasePath(config);
+  try {
+    const poolUtil = await sqlite3.installOpfsSAHPoolVfs({
+      name: WEB_SQLITE_VFS_NAME,
+      directory: WEB_SQLITE_VFS_DIRECTORY,
+      initialCapacity: WEB_SQLITE_INITIAL_CAPACITY,
+      clearOnInit: false
+    });
+    try {
+      poolUtil.unlink(dbPath);
+    } catch {
+    }
+    await poolUtil.wipeFiles();
+    await poolUtil.removeVfs();
+  } catch (err) {
+    console.warn("[WebSQLiteAdapter] SAH-pool reset failed, removing OPFS directory:", err);
+    await removeOPFSDirectory(WEB_SQLITE_VFS_DIRECTORY);
+  }
+}
+var WebSQLiteAdapter = class {
+  sqlite3 = null;
+  db = null;
+  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 () => {
+          log("[WebSQLiteAdapter] Installing OPFS-SAHPool VFS...");
+          this.poolUtil = await this.sqlite3.installOpfsSAHPoolVfs({
+            name: WEB_SQLITE_VFS_NAME,
+            directory: WEB_SQLITE_VFS_DIRECTORY,
+            initialCapacity: WEB_SQLITE_INITIAL_CAPACITY,
+            // Support ~3-4 databases with journals
+            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
+            );
+          }
+        }
+      );
+    } catch (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") {
+        try {
+          this.db = new opfsDbCtor(dbPath, "c");
+          this.storageMode = "opfs";
+          log("[WebSQLiteAdapter] Database opened with OPFS direct mode");
+        } catch (opfsErr) {
+          log("[WebSQLiteAdapter] OPFS direct mode not available:", opfsErr);
+          this.db = new this.sqlite3.oo1.DB(":memory:", "c");
+          this.storageMode = "memory";
+        }
+      } else {
+        this.db = new this.sqlite3.oo1.DB(":memory:", "c");
+        this.storageMode = "memory";
+      }
+      if (this.storageMode === "memory") {
+        const cause = isOpfsLockError(err) ? "another xNet tab/worker is holding the local database" : "OPFS is unavailable in this browser context";
+        console.error(
+          `[WebSQLiteAdapter] Using an IN-MEMORY database (${cause}). Local data will NOT persist across reloads and the workspace will appear empty until it re-syncs from the hub. Close other xNet tabs and reload to restore persistent storage.`
+        );
+      }
+    }
+    this._config = config;
+    const beforePragmas = nowMs();
+    if (config.foreignKeys !== false) {
+      this.execSync("PRAGMA foreign_keys = ON");
+    }
+    if (config.busyTimeout) {
+      this.execSync(`PRAGMA busy_timeout = ${config.busyTimeout}`);
+    } else {
+      this.execSync("PRAGMA busy_timeout = 5000");
+    }
+    try {
+      this.execSync("PRAGMA page_size = 8192");
+    } 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");
+      } catch (err) {
+        log("[WebSQLiteAdapter] optimize on close skipped:", err);
+      }
+      this.db.close();
+      this.db = null;
+    }
+    this.sqlite3 = null;
+    this.poolUtil = null;
+    this._config = null;
+  }
+  isOpen() {
+    return this.db !== null;
+  }
+  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 = [];
+    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.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)
+    };
+  }
+  async exec(sql) {
+    this.ensureOpen();
+    this.stmts.clear();
+    this.execSync(sql);
+  }
+  execSync(sql) {
+    this.db.exec({ sql });
+  }
+  async transaction(fn) {
+    await this.beginTransaction();
+    try {
+      const result = await fn();
+      await this.commit();
+      return result;
+    } catch (err) {
+      if (this.inTransaction) {
+        try {
+          await this.rollback();
+        } catch (rollbackErr) {
+          if (isSQLiteCorruptionError(rollbackErr) && !isSQLiteCorruptionError(err)) {
+            throw rollbackErr;
+          }
+        }
+      }
+      throw err;
+    }
+  }
+  async applyNodeBatch(input) {
+    await this.transaction(async () => {
+      for (const node of input.nodes) {
+        await this.run(
+          `INSERT INTO nodes (id, schema_id, created_at, updated_at, created_by, deleted_at)
+           VALUES (?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             schema_id = excluded.schema_id,
+             updated_at = excluded.updated_at,
+             deleted_at = excluded.deleted_at`,
+          [node.id, node.schemaId, node.createdAt, node.updatedAt, node.createdBy, node.deletedAt]
+        );
+        if (node.propertyKeys.length === 0) {
+          await this.run("DELETE FROM node_properties WHERE node_id = ?", [node.id]);
+        } else {
+          await this.run(
+            `DELETE FROM node_properties
+             WHERE node_id = ? AND property_key NOT IN (${node.propertyKeys.map(() => "?").join(", ")})`,
+            [node.id, ...node.propertyKeys]
+          );
+        }
+      }
+      for (const property of input.properties) {
+        await this.run(
+          `INSERT INTO node_properties
+              (node_id, property_key, value, lamport_time, updated_by, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+            ON CONFLICT(node_id, property_key) DO UPDATE SET
+              value = excluded.value,
+              lamport_time = excluded.lamport_time,
+              updated_by = excluded.updated_by,
+              updated_at = excluded.updated_at
+            WHERE excluded.lamport_time > node_properties.lamport_time`,
+          [
+            property.nodeId,
+            property.propertyKey,
+            property.value,
+            property.lamportTime,
+            property.updatedBy,
+            property.updatedAt
+          ]
+        );
+      }
+      if (input.indexMode !== "defer-schema") {
+        for (const node of input.nodes) {
+          await this.run("DELETE FROM node_property_scalars WHERE node_id = ?", [node.id]);
+        }
+        for (const row of input.scalarIndexRows) {
+          await this.run(
+            `INSERT INTO node_property_scalars
+                (
+                  node_id,
+                  schema_id,
+                  property_key,
+                  value_type,
+                  value_text,
+                  value_number,
+                  value_boolean,
+                  value_hash,
+                  updated_at,
+                  lamport_time
+                )
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            [
+              row.nodeId,
+              row.schemaId,
+              row.propertyKey,
+              row.valueType,
+              row.valueText,
+              row.valueNumber,
+              row.valueBoolean,
+              row.valueHash,
+              row.updatedAt,
+              row.lamportTime
+            ]
+          );
+        }
+        for (const nodeId of input.ftsNodeIds) {
+          await this.run("DELETE FROM nodes_fts WHERE node_id = ?", [nodeId]);
+        }
+        for (const row of input.ftsRows) {
+          await this.run("INSERT INTO nodes_fts (node_id, title, content) VALUES (?, ?, ?)", [
+            row.nodeId,
+            row.title,
+            row.content
+          ]);
+        }
+      }
+      for (const change of input.changes) {
+        await this.run(
+          `INSERT OR IGNORE INTO changes
+            (hash, node_id, payload, lamport_time, lamport_peer, wall_time, author, parent_hash, batch_id, signature)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            change.hash,
+            change.nodeId,
+            change.payload,
+            change.lamportTime,
+            change.lamportPeer,
+            change.wallTime,
+            change.author,
+            change.parentHash,
+            change.batchId,
+            change.signature
+          ]
+        );
+      }
+      await this.run(
+        `INSERT INTO sync_state (key, value) VALUES ('lastLamportTime', ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+        [String(input.lastLamportTime)]
+      );
+      if (input.indexMode !== "defer-schema") {
+        const invalidatedAt = Date.now();
+        for (const schemaId of input.affectedSchemaIds) {
+          await this.run(
+            `UPDATE node_query_materializations
+             SET invalidated_at = ?
+             WHERE schema_id = ? AND invalidated_at IS NULL`,
+            [invalidatedAt, schemaId]
+          );
+        }
+      }
+    });
+    return {
+      nodeRowsWritten: input.nodes.length,
+      propertyRowsWritten: input.properties.length,
+      changeRowsWritten: input.changes.length,
+      scalarRowsWritten: input.scalarIndexRows.length,
+      ftsRowsWritten: input.ftsRows.length
+    };
+  }
+  async beginTransaction() {
+    if (this.inTransaction) {
+      throw new Error("Transaction already in progress");
+    }
+    this.execSync("BEGIN IMMEDIATE");
+    this.inTransaction = true;
+    this.lastTransactionActivityAt = nowMs();
+  }
+  async commit() {
+    if (!this.inTransaction) {
+      throw new Error("No transaction in progress");
+    }
+    try {
+      this.execSync("COMMIT");
+      this.inTransaction = false;
+    } catch (err) {
+      if (isSQLiteCorruptionError(err)) {
+        this.inTransaction = false;
+      }
+      throw err;
+    }
+  }
+  async rollback() {
+    if (!this.inTransaction) {
+      return;
+    }
+    try {
+      this.execSync("ROLLBACK");
+    } finally {
+      this.inTransaction = false;
+    }
+  }
+  async prepare(sql) {
+    return {
+      query: async (params) => {
+        return this.query(sql, params);
+      },
+      queryOne: async (params) => {
+        return this.queryOne(sql, params);
+      },
+      run: async (params) => {
+        return this.run(sql, params);
+      },
+      finalize: async () => {
+      }
+    };
+  }
+  async getSchemaVersion() {
+    try {
+      const row = await this.queryOne(
+        "SELECT version FROM _schema_version ORDER BY version DESC LIMIT 1"
+      );
+      return row?.version ?? 0;
+    } catch {
+      return 0;
+    }
+  }
+  async setSchemaVersion(version) {
+    await this.run("INSERT INTO _schema_version (version, applied_at) VALUES (?, ?)", [
+      version,
+      Date.now()
+    ]);
+  }
+  async applySchema(version, sql) {
+    const currentVersion = await this.getSchemaVersion();
+    if (currentVersion >= version) {
+      return false;
+    }
+    await this.transaction(async () => {
+      await this.exec(sql);
+      await this.setSchemaVersion(version);
+    });
+    return true;
+  }
+  async getDatabaseSize() {
+    try {
+      const row = await this.queryOne(
+        "SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size()"
+      );
+      return row?.size ?? 0;
+    } catch {
+      return 0;
+    }
+  }
+  async vacuum() {
+    await this.exec("VACUUM");
+  }
+  async incrementalVacuum(maxPages) {
+    this.ensureOpen();
+    return stepIncrementalVacuumToCompletion(this.db, maxPages);
+  }
+  async checkpoint() {
+    return 0;
+  }
+  ensureOpen() {
+    if (!this.db || !this.sqlite3) {
+      throw new Error("Database not open. Call open() first.");
+    }
+  }
+};
+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
+};