@xnetjs/sqlite 0.0.2 → 0.0.3

package/dist/{adapter-I7yAV6iu.d.ts → adapter-t2aqQ__n.d.ts}

@@ -1,4 +1,4 @@
-import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from './types-C_aHfRDF.js';
+import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult, k as SQLiteNodeBatchApplyInput, l as SQLiteNodeBatchApplyResult, d as SQLiteOperationStats } from './types-DMrj3K4o.js';
 
 /**
  * @xnetjs/sqlite - SQLite adapter interface definitions
@@ -81,6 +81,24 @@ interface SQLiteAdapter {
      * })
      */
     transaction<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Execute a list of SQL statements inside one transaction.
+     *
+     * This is primarily for proxy/worker-backed adapters where a callback
+     * transaction would cross a serialization boundary. Implementations should
+     * execute all operations atomically and roll back on the first failure.
+     */
+    transactionBatch?(operations: Array<{
+        sql: string;
+        params?: SQLValue[];
+    }>): Promise<void>;
+    /**
+     * Execute a node-store batch using compact typed row payloads.
+     *
+     * Worker-backed adapters can use this to avoid transferring a very large
+     * array of repeated SQL strings over Comlink.
+     */
+    applyNodeBatch?(input: SQLiteNodeBatchApplyInput): Promise<SQLiteNodeBatchApplyResult>;
     /**
      * Begin a manual transaction.
      * Must be followed by commit() or rollback().
@@ -140,6 +158,14 @@ interface SQLiteAdapter {
      * or 'memory' if using in-memory fallback.
      */
     getStorageMode(): Promise<'opfs' | 'memory'> | 'opfs' | 'memory';
+    /**
+     * Optional cumulative operation counters for import diagnostics.
+     */
+    getOperationStats?(): Promise<SQLiteOperationStats> | SQLiteOperationStats;
+    /**
+     * Reset cumulative operation counters when starting a focused measurement.
+     */
+    resetOperationStats?(): Promise<void> | void;
 }
 /**
  * Prepared statement for repeated execution.

package/dist/adapters/electron.d.ts

@@ -1,7 +1,7 @@
-import { S as SQLiteAdapter, P as PreparedStatement } from '../adapter-I7yAV6iu.js';
-import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '../types-C_aHfRDF.js';
+import { S as SQLiteAdapter, P as PreparedStatement } from '../adapter-t2aqQ__n.js';
+import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '../types-DMrj3K4o.js';
 import Database from 'better-sqlite3';
-export { a as SCHEMA_DDL, S as SCHEMA_VERSION } from '../schema-CjkXTqxn.js';
+export { a as SCHEMA_DDL, S as SCHEMA_VERSION } from '../schema-BEgIA-rZ.js';
 
 /**
  * @xnetjs/sqlite - Electron SQLite adapter using better-sqlite3
@@ -37,6 +37,10 @@ declare class ElectronSQLiteAdapter implements SQLiteAdapter {
     run(sql: string, params?: SQLValue[]): Promise<RunResult>;
     exec(sql: string): Promise<void>;
     transaction<T>(fn: () => Promise<T>): Promise<T>;
+    transactionBatch(operations: Array<{
+        sql: string;
+        params?: SQLValue[];
+    }>): Promise<void>;
     /**
      * Synchronous transaction for performance-critical batch operations.
      * Prefer this over async transaction when the body is synchronous.

package/dist/adapters/electron.js

@@ -1,7 +1,10 @@
+import {
+  isSQLiteCorruptionError
+} from "../chunk-CBU263LI.js";
 import {
   SCHEMA_DDL,
   SCHEMA_VERSION
-} from "../chunk-HIREU5S5.js";
+} from "../chunk-NVD7G7DZ.js";
 
 // src/adapters/electron.ts
 var DatabaseConstructor = null;
@@ -104,10 +107,41 @@ var ElectronSQLiteAdapter = class {
       await this.commit();
       return result;
     } catch (err) {
-      await this.rollback();
+      if (this.inTransaction) {
+        try {
+          await this.rollback();
+        } catch (rollbackErr) {
+          if (isSQLiteCorruptionError(rollbackErr) && !isSQLiteCorruptionError(err)) {
+            throw rollbackErr;
+          }
+        }
+      }
       throw err;
     }
   }
+  async transactionBatch(operations) {
+    this.ensureOpen();
+    if (operations.length === 0) return;
+    if (this.inTransaction) {
+      throw new Error("Transaction already in progress");
+    }
+    let currentSql = operations[0].sql;
+    try {
+      this.transactionSync(() => {
+        for (const operation of operations) {
+          currentSql = operation.sql;
+          const stmt = this.getOrPrepare(operation.sql);
+          if (operation.params) {
+            stmt.run(...operation.params);
+          } else {
+            stmt.run();
+          }
+        }
+      });
+    } catch (err) {
+      throw this.wrapError(err, currentSql);
+    }
+  }
   /**
    * Synchronous transaction for performance-critical batch operations.
    * Prefer this over async transaction when the body is synchronous.
@@ -128,15 +162,25 @@ var ElectronSQLiteAdapter = class {
     if (!this.inTransaction) {
       throw new Error("No transaction in progress");
     }
-    this.db.exec("COMMIT");
-    this.inTransaction = false;
+    try {
+      this.db.exec("COMMIT");
+      this.inTransaction = false;
+    } catch (err) {
+      if (isSQLiteCorruptionError(err)) {
+        this.inTransaction = false;
+      }
+      throw err;
+    }
   }
   async rollback() {
     if (!this.inTransaction) {
       return;
     }
-    this.db.exec("ROLLBACK");
-    this.inTransaction = false;
+    try {
+      this.db.exec("ROLLBACK");
+    } finally {
+      this.inTransaction = false;
+    }
   }
   async prepare(sql) {
     this.ensureOpen();

package/dist/adapters/expo.d.ts

@@ -1,5 +1,5 @@
-import { S as SQLiteAdapter, P as PreparedStatement } from '../adapter-I7yAV6iu.js';
-import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '../types-C_aHfRDF.js';
+import { S as SQLiteAdapter, P as PreparedStatement } from '../adapter-t2aqQ__n.js';
+import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '../types-DMrj3K4o.js';
 
 /**
  * @xnetjs/sqlite - Expo SQLite adapter using expo-sqlite

package/dist/adapters/expo.js

@@ -1,7 +1,10 @@
+import {
+  isSQLiteCorruptionError
+} from "../chunk-CBU263LI.js";
 import {
   SCHEMA_DDL,
   SCHEMA_VERSION
-} from "../chunk-HIREU5S5.js";
+} from "../chunk-NVD7G7DZ.js";
 
 // src/adapters/expo.ts
 var ExpoSQLiteAdapter = class {
@@ -69,7 +72,15 @@ var ExpoSQLiteAdapter = class {
       await this.commit();
       return result;
     } catch (err) {
-      await this.rollback();
+      if (this.inTransaction) {
+        try {
+          await this.rollback();
+        } catch (rollbackErr) {
+          if (isSQLiteCorruptionError(rollbackErr) && !isSQLiteCorruptionError(err)) {
+            throw rollbackErr;
+          }
+        }
+      }
       throw err;
     }
   }
@@ -84,15 +95,25 @@ var ExpoSQLiteAdapter = class {
     if (!this.inTransaction) {
       throw new Error("No transaction in progress");
     }
-    await this.exec("COMMIT");
-    this.inTransaction = false;
+    try {
+      await this.exec("COMMIT");
+      this.inTransaction = false;
+    } catch (err) {
+      if (isSQLiteCorruptionError(err)) {
+        this.inTransaction = false;
+      }
+      throw err;
+    }
   }
   async rollback() {
     if (!this.inTransaction) {
       return;
     }
-    await this.exec("ROLLBACK");
-    this.inTransaction = false;
+    try {
+      await this.exec("ROLLBACK");
+    } finally {
+      this.inTransaction = false;
+    }
   }
   async prepare(sql) {
     this.ensureOpen();

package/dist/adapters/memory.d.ts

@@ -1,5 +1,5 @@
-import { S as SQLiteAdapter, P as PreparedStatement } from '../adapter-I7yAV6iu.js';
-import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '../types-C_aHfRDF.js';
+import { S as SQLiteAdapter, P as PreparedStatement } from '../adapter-t2aqQ__n.js';
+import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '../types-DMrj3K4o.js';
 
 /**
  * @xnetjs/sqlite - In-memory SQLite adapter for testing

package/dist/adapters/memory.js

@@ -1,7 +1,7 @@
 import {
   SCHEMA_DDL_CORE,
   SCHEMA_VERSION
-} from "../chunk-HIREU5S5.js";
+} from "../chunk-NVD7G7DZ.js";
 
 // src/adapters/memory.ts
 var MemorySQLiteAdapter = class {

package/dist/adapters/web-proxy.d.ts

@@ -1,5 +1,5 @@
-import { S as SQLiteAdapter, P as PreparedStatement } from '../adapter-I7yAV6iu.js';
-import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '../types-C_aHfRDF.js';
+import { S as SQLiteAdapter, P as PreparedStatement } from '../adapter-t2aqQ__n.js';
+import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult, k as SQLiteNodeBatchApplyInput, l as SQLiteNodeBatchApplyResult, d as SQLiteOperationStats } from '../types-DMrj3K4o.js';
 
 /**
  * @xnetjs/sqlite - Main thread proxy for SQLite Web Worker
@@ -24,7 +24,11 @@ declare class WebSQLiteProxy implements SQLiteAdapter {
     private worker;
     private proxy;
     private _config;
+    private inTransaction;
+    private operationStats;
+    private createWorkerProxy;
     open(config: SQLiteConfig): Promise<void>;
+    resetStorage(config: SQLiteConfig): Promise<void>;
     close(): Promise<void>;
     isOpen(): boolean;
     query<T extends SQLRow = SQLRow>(sql: string, params?: SQLValue[]): Promise<T[]>;
@@ -48,6 +52,7 @@ declare class WebSQLiteProxy implements SQLiteAdapter {
         sql: string;
         params?: SQLValue[];
     }>): Promise<void>;
+    applyNodeBatch(input: SQLiteNodeBatchApplyInput): Promise<SQLiteNodeBatchApplyResult>;
     beginTransaction(): Promise<void>;
     commit(): Promise<void>;
     rollback(): Promise<void>;
@@ -59,6 +64,16 @@ declare class WebSQLiteProxy implements SQLiteAdapter {
     vacuum(): Promise<void>;
     checkpoint(): Promise<number>;
     getStorageMode(): Promise<'opfs' | 'memory'>;
+    /**
+     * Create a MessagePort connected directly to the SQLite worker.
+     *
+     * The returned port speaks the same Comlink `SQLiteWorkerHandler`
+     * protocol as this proxy and can be transferred to another worker
+     * (e.g. the data worker) so its storage calls skip the main thread.
+     */
+    createMessagePort(): Promise<MessagePort>;
+    getOperationStats(): SQLiteOperationStats;
+    resetOperationStats(): void;
 }
 /**
  * Create a WebSQLiteProxy ready for use.
@@ -71,5 +86,6 @@ declare class WebSQLiteProxy implements SQLiteAdapter {
  * ```
  */
 declare function createWebSQLiteProxy(config: SQLiteConfig): Promise<WebSQLiteProxy>;
+declare function resetWebSQLiteStorage(config: SQLiteConfig): Promise<void>;
 
-export { WebSQLiteProxy, createWebSQLiteProxy };
+export { WebSQLiteProxy, createWebSQLiteProxy, resetWebSQLiteStorage };

package/dist/adapters/web-proxy.js

@@ -8,14 +8,32 @@ function log(...args) {
     console.log(...args);
   }
 }
+function createEmptyOperationStats() {
+  return {
+    queryCount: 0,
+    queryOneCount: 0,
+    runCount: 0,
+    execCount: 0,
+    transactionCount: 0,
+    transactionBatchCount: 0,
+    transactionBatchOperationCount: 0,
+    workerRequestCount: 0
+  };
+}
+function cloneOperationStats(stats) {
+  return { ...stats };
+}
+function estimateNodeBatchSqlOperations(input) {
+  const indexOperations = input.indexMode === "defer-schema" ? 0 : input.nodes.length + input.scalarIndexRows.length + input.ftsNodeIds.length + input.ftsRows.length + input.affectedSchemaIds.length;
+  return input.nodes.length * 2 + input.properties.length + input.changes.length + indexOperations + 1;
+}
 var WebSQLiteProxy = class {
   worker = null;
   proxy = null;
   _config = null;
-  async open(config) {
-    if (this.worker) {
-      throw new Error("Already open. Call close() first.");
-    }
+  inTransaction = false;
+  operationStats = createEmptyOperationStats();
+  createWorkerProxy() {
     log("[WebSQLiteProxy] Creating worker...");
     this.worker = new Worker(new URL("./web-worker.js", import.meta.url), { type: "module" });
     this.worker.onerror = (event) => {
@@ -26,8 +44,16 @@ var WebSQLiteProxy = class {
     };
     log("[WebSQLiteProxy] Worker created, wrapping with Comlink...");
     this.proxy = Comlink.wrap(this.worker);
+    return this.proxy;
+  }
+  async open(config) {
+    if (this.worker) {
+      throw new Error("Already open. Call close() first.");
+    }
+    const proxy = this.createWorkerProxy();
     log("[WebSQLiteProxy] Calling proxy.open()...");
-    const openPromise = this.proxy.open(config);
+    const openPromise = proxy.open(config);
+    this.operationStats.workerRequestCount += 1;
     const timeoutPromise = new Promise(
       (_, reject) => setTimeout(() => reject(new Error("Worker initialization timeout after 15s")), 15e3)
     );
@@ -35,8 +61,25 @@ var WebSQLiteProxy = class {
     log("[WebSQLiteProxy] proxy.open() completed");
     this._config = config;
   }
+  async resetStorage(config) {
+    if (this.worker) {
+      throw new Error("Already open. Call close() first.");
+    }
+    const proxy = this.createWorkerProxy();
+    const resetPromise = proxy.resetStorage(config);
+    this.operationStats.workerRequestCount += 1;
+    const timeoutPromise = new Promise(
+      (_, reject) => setTimeout(() => reject(new Error("Worker storage reset timeout after 15s")), 15e3)
+    );
+    try {
+      await Promise.race([resetPromise, timeoutPromise]);
+    } finally {
+      await this.close();
+    }
+  }
   async close() {
     if (this.proxy) {
+      this.operationStats.workerRequestCount += 1;
       await this.proxy.close();
       this.proxy = null;
     }
@@ -45,26 +88,35 @@ var WebSQLiteProxy = class {
       this.worker = null;
     }
     this._config = null;
+    this.inTransaction = false;
   }
   isOpen() {
     return this.proxy !== null;
   }
   async query(sql, params) {
     if (!this.proxy) throw new Error("Database not open");
+    this.operationStats.queryCount += 1;
+    this.operationStats.workerRequestCount += 1;
     const result = await this.proxy.query(sql, params);
     return result;
   }
   async queryOne(sql, params) {
     if (!this.proxy) throw new Error("Database not open");
+    this.operationStats.queryOneCount += 1;
+    this.operationStats.workerRequestCount += 1;
     const result = await this.proxy.queryOne(sql, params);
     return result;
   }
   async run(sql, params) {
     if (!this.proxy) throw new Error("Database not open");
+    this.operationStats.runCount += 1;
+    this.operationStats.workerRequestCount += 1;
     return this.proxy.run(sql, params);
   }
   async exec(sql) {
     if (!this.proxy) throw new Error("Database not open");
+    this.operationStats.execCount += 1;
+    this.operationStats.workerRequestCount += 1;
     return this.proxy.exec(sql);
   }
   async transaction(_fn) {
@@ -84,29 +136,61 @@ var WebSQLiteProxy = class {
    */
   async transactionBatch(operations) {
     if (!this.proxy) throw new Error("Database not open");
+    this.operationStats.transactionBatchCount += 1;
+    this.operationStats.transactionBatchOperationCount += operations.length;
+    this.operationStats.workerRequestCount += 1;
     await this.proxy.transaction(operations);
   }
+  async applyNodeBatch(input) {
+    if (!this.proxy) throw new Error("Database not open");
+    this.operationStats.transactionBatchCount += 1;
+    this.operationStats.transactionBatchOperationCount += estimateNodeBatchSqlOperations(input);
+    this.operationStats.workerRequestCount += 1;
+    return this.proxy.applyNodeBatch(input);
+  }
   async beginTransaction() {
     if (!this.proxy) throw new Error("Database not open");
+    if (this.inTransaction) {
+      throw new Error("Transaction already in progress");
+    }
+    this.operationStats.execCount += 1;
+    this.operationStats.workerRequestCount += 1;
     await this.proxy.exec("BEGIN IMMEDIATE");
+    this.inTransaction = true;
   }
   async commit() {
     if (!this.proxy) throw new Error("Database not open");
+    if (!this.inTransaction) {
+      throw new Error("No transaction in progress");
+    }
+    this.operationStats.execCount += 1;
+    this.operationStats.workerRequestCount += 1;
     await this.proxy.exec("COMMIT");
+    this.inTransaction = false;
   }
   async rollback() {
     if (!this.proxy) throw new Error("Database not open");
+    if (!this.inTransaction) {
+      return;
+    }
+    this.operationStats.execCount += 1;
+    this.operationStats.workerRequestCount += 1;
     await this.proxy.exec("ROLLBACK");
+    this.inTransaction = false;
   }
   async prepare(_sql) {
     throw new Error("Prepared statements not supported in proxy. Use query() or run() directly.");
   }
   async getSchemaVersion() {
     if (!this.proxy) throw new Error("Database not open");
+    this.operationStats.queryOneCount += 1;
+    this.operationStats.workerRequestCount += 1;
     return this.proxy.getSchemaVersion();
   }
   async setSchemaVersion(version) {
     if (!this.proxy) throw new Error("Database not open");
+    this.operationStats.runCount += 1;
+    this.operationStats.workerRequestCount += 1;
     await this.proxy.run("INSERT INTO _schema_version (version, applied_at) VALUES (?, ?)", [
       version,
       Date.now()
@@ -121,10 +205,12 @@ var WebSQLiteProxy = class {
   }
   async getDatabaseSize() {
     if (!this.proxy) throw new Error("Database not open");
+    this.operationStats.workerRequestCount += 1;
     return this.proxy.getDatabaseSize();
   }
   async vacuum() {
     if (!this.proxy) throw new Error("Database not open");
+    this.operationStats.workerRequestCount += 1;
     return this.proxy.vacuum();
   }
   async checkpoint() {
@@ -134,6 +220,7 @@ var WebSQLiteProxy = class {
     if (!this.proxy) throw new Error("Database not open");
     try {
       log("[WebSQLiteProxy] Calling proxy.getStorageMode()...");
+      this.operationStats.workerRequestCount += 1;
       const mode = await this.proxy.getStorageMode();
       log("[WebSQLiteProxy] getStorageMode() returned:", mode);
       return mode;
@@ -142,13 +229,38 @@ var WebSQLiteProxy = class {
       throw err;
     }
   }
+  /**
+   * Create a MessagePort connected directly to the SQLite worker.
+   *
+   * The returned port speaks the same Comlink `SQLiteWorkerHandler`
+   * protocol as this proxy and can be transferred to another worker
+   * (e.g. the data worker) so its storage calls skip the main thread.
+   */
+  async createMessagePort() {
+    if (!this.proxy) throw new Error("Database not open");
+    const channel = new MessageChannel();
+    this.operationStats.workerRequestCount += 1;
+    await this.proxy.connectPort(Comlink.transfer(channel.port1, [channel.port1]));
+    return channel.port2;
+  }
+  getOperationStats() {
+    return cloneOperationStats(this.operationStats);
+  }
+  resetOperationStats() {
+    this.operationStats = createEmptyOperationStats();
+  }
 };
 async function createWebSQLiteProxy(config) {
   const proxy = new WebSQLiteProxy();
   await proxy.open(config);
   return proxy;
 }
+async function resetWebSQLiteStorage(config) {
+  const proxy = new WebSQLiteProxy();
+  await proxy.resetStorage(config);
+}
 export {
   WebSQLiteProxy,
-  createWebSQLiteProxy
+  createWebSQLiteProxy,
+  resetWebSQLiteStorage
 };

package/dist/adapters/web-worker.d.ts

@@ -1,4 +1,4 @@
-import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '../types-C_aHfRDF.js';
+import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult, k as SQLiteNodeBatchApplyInput, l as SQLiteNodeBatchApplyResult } from '../types-DMrj3K4o.js';
 
 /**
  * @xnetjs/sqlite - Web Worker entry point for SQLite WASM
@@ -13,6 +13,7 @@ import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '.
 declare class SQLiteWorkerHandler {
     private adapter;
     open(config: SQLiteConfig): Promise<void>;
+    resetStorage(config: SQLiteConfig): Promise<void>;
     close(): Promise<void>;
     isOpen(): boolean;
     query<T extends SQLRow = SQLRow>(sql: string, params?: SQLValue[]): Promise<T[]>;
@@ -23,10 +24,20 @@ declare class SQLiteWorkerHandler {
         sql: string;
         params?: SQLValue[];
     }>): Promise<void>;
+    applyNodeBatch(input: SQLiteNodeBatchApplyInput): Promise<SQLiteNodeBatchApplyResult>;
     getSchemaVersion(): Promise<number>;
     vacuum(): Promise<void>;
     getDatabaseSize(): Promise<number>;
     getStorageMode(): Promise<'opfs' | 'memory'>;
+    /**
+     * Expose this handler on an additional MessagePort.
+     *
+     * Lets another worker (e.g. the data worker from @xnetjs/data-bridge)
+     * talk to this SQLite worker directly without routing every storage call
+     * through the main thread. The port is created on the main thread with
+     * `WebSQLiteProxy.createMessagePort()` and transferred to the peer.
+     */
+    connectPort(port: MessagePort): void;
 }
 
 export { SQLiteWorkerHandler };

package/dist/adapters/web-worker.js

@@ -1,7 +1,9 @@
 import {
-  createWebSQLiteAdapter
-} from "../chunk-BXYZU3OL.js";
-import "../chunk-HIREU5S5.js";
+  createWebSQLiteAdapter,
+  resetWebSQLiteOpfsStorage
+} from "../chunk-DCY4LAUD.js";
+import "../chunk-CBU263LI.js";
+import "../chunk-NVD7G7DZ.js";
 
 // src/adapters/web-worker.ts
 import * as Comlink from "comlink";
@@ -24,6 +26,13 @@ var SQLiteWorkerHandler = class {
     this.adapter = await createWebSQLiteAdapter(config);
     log("[SQLiteWorkerHandler] open() completed");
   }
+  async resetStorage(config) {
+    if (this.adapter) {
+      await this.adapter.close();
+      this.adapter = null;
+    }
+    await resetWebSQLiteOpfsStorage(config);
+  }
   async close() {
     if (this.adapter) {
       await this.adapter.close();
@@ -57,6 +66,10 @@ var SQLiteWorkerHandler = class {
       }
     });
   }
+  async applyNodeBatch(input) {
+    if (!this.adapter) throw new Error("Database not open");
+    return this.adapter.applyNodeBatch(input);
+  }
   async getSchemaVersion() {
     if (!this.adapter) throw new Error("Database not open");
     return this.adapter.getSchemaVersion();
@@ -73,6 +86,17 @@ var SQLiteWorkerHandler = class {
     if (!this.adapter) throw new Error("Database not open");
     return this.adapter.getStorageMode();
   }
+  /**
+   * Expose this handler on an additional MessagePort.
+   *
+   * Lets another worker (e.g. the data worker from @xnetjs/data-bridge)
+   * talk to this SQLite worker directly without routing every storage call
+   * through the main thread. The port is created on the main thread with
+   * `WebSQLiteProxy.createMessagePort()` and transferred to the peer.
+   */
+  connectPort(port) {
+    Comlink.expose(this, port);
+  }
 };
 var handler = new SQLiteWorkerHandler();
 log("[SQLiteWorker] Handler instance created");

package/dist/adapters/web.d.ts

@@ -1,5 +1,5 @@
-import { S as SQLiteAdapter, P as PreparedStatement } from '../adapter-I7yAV6iu.js';
-import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '../types-C_aHfRDF.js';
+import { S as SQLiteAdapter, P as PreparedStatement } from '../adapter-t2aqQ__n.js';
+import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult, k as SQLiteNodeBatchApplyInput, l as SQLiteNodeBatchApplyResult } from '../types-DMrj3K4o.js';
 
 /**
  * @xnetjs/sqlite - Web SQLite adapter using @sqlite.org/sqlite-wasm
@@ -8,6 +8,13 @@ import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '.
  * Must run in a Web Worker for OPFS access.
  */
 
+/**
+ * Remove xNet's OPFS-backed SQLite storage for the supplied database path.
+ *
+ * This must run in a worker because the SAH-pool VFS uses synchronous OPFS
+ * handles. It is intentionally scoped to xNet's SQLite VFS directory.
+ */
+declare function resetWebSQLiteOpfsStorage(config: SQLiteConfig): Promise<void>;
 /**
  * SQLite adapter for web browsers using @sqlite.org/sqlite-wasm.
  *
@@ -44,6 +51,7 @@ declare class WebSQLiteAdapter implements SQLiteAdapter {
     exec(sql: string): Promise<void>;
     private execSync;
     transaction<T>(fn: () => Promise<T>): Promise<T>;
+    applyNodeBatch(input: SQLiteNodeBatchApplyInput): Promise<SQLiteNodeBatchApplyResult>;
     beginTransaction(): Promise<void>;
     commit(): Promise<void>;
     rollback(): Promise<void>;
@@ -61,4 +69,4 @@ declare class WebSQLiteAdapter implements SQLiteAdapter {
  */
 declare function createWebSQLiteAdapter(config: SQLiteConfig): Promise<WebSQLiteAdapter>;
 
-export { WebSQLiteAdapter, createWebSQLiteAdapter };
+export { WebSQLiteAdapter, createWebSQLiteAdapter, resetWebSQLiteOpfsStorage };

package/dist/adapters/web.js

@@ -1,9 +1,12 @@
 import {
   WebSQLiteAdapter,
-  createWebSQLiteAdapter
-} from "../chunk-BXYZU3OL.js";
-import "../chunk-HIREU5S5.js";
+  createWebSQLiteAdapter,
+  resetWebSQLiteOpfsStorage
+} from "../chunk-DCY4LAUD.js";
+import "../chunk-CBU263LI.js";
+import "../chunk-NVD7G7DZ.js";
 export {
   WebSQLiteAdapter,
-  createWebSQLiteAdapter
+  createWebSQLiteAdapter,
+  resetWebSQLiteOpfsStorage
 };