@massalabs/gossip-sdk 0.0.2-dev.20260223124034 → 0.0.2-dev.20260223131319

package/dist/db/sqlite-worker.d.ts

@@ -1,8 +1,9 @@
 /**
  * SQLite Web Worker — owns all WASM/SQLite state.
  *
- * Runs wa-sqlite (sync build) with AccessHandlePoolVFS for OPFS persistence.
- * The main thread communicates via postMessage with { id, type, ... } messages.
+ * Two VFS modes:
+ *   - OPFS (mobile): AccessHandlePoolVFS + sync WASM — fast, single-tab.
+ *   - IDB (web): IDBBatchAtomicVFS + async WASM — multi-tab safe.
  *
  * Messages:
  *   init  → load WASM + VFS, open DB, run init SQL (PRAGMAs + DDL)

package/dist/db/sqlite-worker.js

@@ -1,17 +1,16 @@
 /**
  * SQLite Web Worker — owns all WASM/SQLite state.
  *
- * Runs wa-sqlite (sync build) with AccessHandlePoolVFS for OPFS persistence.
- * The main thread communicates via postMessage with { id, type, ... } messages.
+ * Two VFS modes:
+ *   - OPFS (mobile): AccessHandlePoolVFS + sync WASM — fast, single-tab.
+ *   - IDB (web): IDBBatchAtomicVFS + async WASM — multi-tab safe.
  *
  * Messages:
  *   init  → load WASM + VFS, open DB, run init SQL (PRAGMAs + DDL)
  *   exec  → prepare/bind/step/finalize, return { rows, lastInsertRowId }
  *   close → close DB
  */
-import SQLiteESMFactory from 'wa-sqlite/dist/wa-sqlite.mjs';
 import * as SQLite from 'wa-sqlite';
-import { AccessHandlePoolVFS } from 'wa-sqlite/src/examples/AccessHandlePoolVFS.js';
 import { execStatements } from './exec-utils.js';
 let sqlite3 = null;
 let dbHandle = null;
@@ -34,15 +33,28 @@ addEventListener('message', async (e) => {
     try {
         switch (type) {
             case 'init': {
-                const { opfsPath, wasmUrl, initSql } = e.data;
+                const { dbPath, wasmUrl, initSql, useOPFS } = e.data;
                 const moduleArg = {};
                 if (wasmUrl)
                     moduleArg.locateFile = () => wasmUrl;
-                const module = await SQLiteESMFactory(moduleArg);
-                sqlite3 = SQLite.Factory(module);
-                const vfs = new AccessHandlePoolVFS(opfsPath);
-                await vfs.isReady;
-                sqlite3.vfs_register(vfs, true);
+                // Load the right WASM build + VFS.
+                // NOTE: import() paths must be string literals — Vite can't resolve variables.
+                if (useOPFS) {
+                    const { default: SQLiteESMFactory } = await import('wa-sqlite/dist/wa-sqlite.mjs');
+                    const { AccessHandlePoolVFS } = await import('wa-sqlite/src/examples/AccessHandlePoolVFS.js');
+                    const module = await SQLiteESMFactory(moduleArg);
+                    sqlite3 = SQLite.Factory(module);
+                    const vfs = new AccessHandlePoolVFS(dbPath);
+                    await vfs.isReady;
+                    sqlite3.vfs_register(vfs, true);
+                }
+                else {
+                    const { default: SQLiteESMFactory } = await import('wa-sqlite/dist/wa-sqlite-async.mjs');
+                    const { IDBBatchAtomicVFS } = await import('wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
+                    const module = await SQLiteESMFactory(moduleArg);
+                    sqlite3 = SQLite.Factory(module);
+                    sqlite3.vfs_register(new IDBBatchAtomicVFS(dbPath), true);
+                }
                 dbHandle = await sqlite3.open_v2('gossip.db');
                 if (initSql) {
                     await sqlite3.exec(dbHandle, initSql);

package/dist/db/sqlite.d.ts

@@ -3,7 +3,7 @@
  *
  * Uses wa-sqlite (WASM) with Drizzle ORM's sqlite-proxy driver.
  * Two execution paths:
- *   - Browser (opfsPath set): Web Worker + AccessHandlePoolVFS — OPFS persistence,
+ *   - Browser (opfsPath set): Web Worker + IDBBatchAtomicVFS — IndexedDB persistence,
  *     off the main thread. Uses the sync WASM build (wa-sqlite).
  *   - In-memory (tests): :memory: in-process — no persistence, fast, isolated.
  *     Uses the sync WASM build with wasmBinary passed directly.
@@ -15,11 +15,15 @@ import * as schema from './schema/index.js';
 export type GossipDatabase = SqliteRemoteDatabase<typeof schema>;
 export interface InitDbOptions {
     /**
-     * OPFS directory path for persistent storage.
-     * When set, spawns a Web Worker with AccessHandlePoolVFS for OPFS persistence.
-     * When omitted, uses an in-memory database (for tests).
+     * OPFS directory path. When set, uses AccessHandlePoolVFS (fast, single-tab).
+     * Use for mobile (Capacitor) where only one instance runs at a time.
      */
     opfsPath?: string;
+    /**
+     * IndexedDB database name. When set, uses IDBBatchAtomicVFS (multi-tab safe).
+     * Use for web where multiple tabs may be open.
+     */
+    idbName?: string;
     /**
      * Pre-loaded WASM binary for environments where fetch() is unavailable
      * (e.g. Node.js tests). When omitted, the factory uses fetch() to load
@@ -37,8 +41,9 @@ export interface InitDbOptions {
  * Initialize wa-sqlite and create the Drizzle ORM instance.
  * Idempotent — subsequent calls are no-ops.
  *
- * @param options.opfsPath - Set to persist via OPFS Worker (production).
- *                           Omit for in-memory database (tests).
+ * @param options.opfsPath - OPFS path for mobile (single-tab, fast).
+ * @param options.idbName  - IndexedDB name for web (multi-tab safe).
+ *                           Omit both for in-memory database (tests).
  */
 export declare function initDb(options?: InitDbOptions): Promise<void>;
 /**

package/dist/db/sqlite.js

@@ -3,7 +3,7 @@
  *
  * Uses wa-sqlite (WASM) with Drizzle ORM's sqlite-proxy driver.
  * Two execution paths:
- *   - Browser (opfsPath set): Web Worker + AccessHandlePoolVFS — OPFS persistence,
+ *   - Browser (opfsPath set): Web Worker + IDBBatchAtomicVFS — IndexedDB persistence,
  *     off the main thread. Uses the sync WASM build (wa-sqlite).
  *   - In-memory (tests): :memory: in-process — no persistence, fast, isolated.
  *     Uses the sync WASM build with wasmBinary passed directly.
@@ -114,15 +114,17 @@ const PRAGMAS = `
  * Initialize wa-sqlite and create the Drizzle ORM instance.
  * Idempotent — subsequent calls are no-ops.
  *
- * @param options.opfsPath - Set to persist via OPFS Worker (production).
- *                           Omit for in-memory database (tests).
+ * @param options.opfsPath - OPFS path for mobile (single-tab, fast).
+ * @param options.idbName  - IndexedDB name for web (multi-tab safe).
+ *                           Omit both for in-memory database (tests).
  */
 export async function initDb(options = {}) {
     if (db.drizzleDb)
         return;
-    if (options.opfsPath) {
-        // Browser path: spawn Worker with OPFS + AccessHandlePoolVFS.
-        // The sync WASM build runs in the Worker (no Asyncify needed).
+    const useOPFS = !!options.opfsPath;
+    const dbPath = options.opfsPath ?? options.idbName;
+    if (dbPath) {
+        // Spawn Worker with persistent VFS.
         db.worker = new Worker(new URL('./sqlite-worker.ts', import.meta.url), {
             type: 'module',
         });
@@ -131,16 +133,15 @@ export async function initDb(options = {}) {
         try {
             await postToWorker({
                 type: 'init',
-                opfsPath: options.opfsPath,
+                dbPath,
+                useOPFS,
                 wasmUrl: options.wasmUrl,
                 initSql: PRAGMAS,
             });
         }
         catch (err) {
-            // Prevent dangling worker and "another open Access Handle" on retry:
-            // only one SyncAccessHandle per file is allowed (e.g. another tab or
-            // a previous failed init may hold it). Terminate and reset so retry
-            // doesn't create a second worker.
+            // Prevent dangling worker on init failure.
+            // Terminate and reset so retry doesn't create a second worker.
             if (db.worker) {
                 db.worker.terminate();
                 db.worker = null;

package/dist/gossip.d.ts

@@ -23,14 +23,18 @@ export interface GossipSdkInitOptions {
     protocolBaseUrl?: string;
     /** SDK configuration (optional - uses defaults if not provided) */
     config?: DeepPartial<SdkConfig>;
-    /** URL to wa-sqlite.wasm (for bundlers that rewrite asset paths) */
+    /** URL to wa-sqlite WASM file (for bundlers that rewrite asset paths) */
     wasmUrl?: string;
     /**
-     * OPFS directory path for persistent SQLite storage.
-     * When set, data persists across page reloads via OPFS.
-     * When omitted, uses an in-memory database (data lost on reload).
+     * OPFS directory path for persistent SQLite storage (mobile/Capacitor).
+     * Fast but single-tab only. Mutually exclusive with `idbName`.
      */
     opfsPath?: string;
+    /**
+     * IndexedDB database name for persistent SQLite storage (web).
+     * Multi-tab safe. Mutually exclusive with `opfsPath`.
+     */
+    idbName?: string;
 }
 export interface OpenSessionOptions {
     /** BIP39 mnemonic phrase */

package/dist/gossip.js

@@ -177,7 +177,11 @@ class GossipSdk {
         startWasmInitialization();
         console.log('[GossipSdk] Initializing SQLite');
         // Initialize SQLite (idempotent — no-op if already initialized).
-        await initDb({ wasmUrl: options.wasmUrl, opfsPath: options.opfsPath });
+        await initDb({
+            wasmUrl: options.wasmUrl,
+            opfsPath: options.opfsPath,
+            idbName: options.idbName,
+        });
         console.log('[GossipSdk] SQLite initialized');
         // Create message protocol
         const messageProtocol = createMessageProtocol();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massalabs/gossip-sdk",
-  "version": "0.0.2-dev.20260223124034",
+  "version": "0.0.2-dev.20260223131319",
   "description": "Gossip SDK for automation, chatbot, and integration use cases",
   "type": "module",
   "main": "./dist/index.js",