@taladb/web 0.5.0 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taladb/web",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "TalaDB WASM bindings — document queries and vector search in the browser",
   "main": "pkg/taladb_web.js",
   "types": "pkg/taladb_web.d.ts",

package/pkg/package.json

@@ -5,7 +5,7 @@
     "thinkgrid-labs"
   ],
   "description": "TalaDB browser WASM bindings (wasm-bindgen + OPFS)",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "license": "MIT",
   "files": [
     "taladb_web_bg.wasm",

package/pkg/taladb_web.d.ts

@@ -119,6 +119,20 @@ export class WorkerDB {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Remove tombstones older than `before_ms` from the given collection.
+     *
+     * Call periodically (e.g. on app startup) after your sync retention window
+     * has elapsed so deleted document IDs no longer accumulate indefinitely.
+     * Returns the number of tombstones removed.
+     *
+     * ```js
+     * // Prune tombstones older than 30 days
+     * const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000;
+     * const pruned = db.compactTombstones('users', cutoff);
+     * ```
+     */
+    compactTombstones(collection: string, before_ms: number): number;
     /**
      * Count matching documents.
      */
@@ -148,6 +162,18 @@ export class WorkerDB {
      * Drop a vector index (and its HNSW graph if present).
      */
     dropVectorIndex(collection: string, field: string): void;
+    /**
+     * Export a changeset for the given collections since `since_ms`.
+     *
+     * Returns a JSON string representing `Vec<Change>` that can be sent
+     * to a remote peer via fetch, WebSocket, or SSE.
+     *
+     * ```js
+     * const json = db.exportChangeset(JSON.stringify(['users', 'posts']), 0);
+     * await fetch('/sync', { method: 'POST', body: json });
+     * ```
+     */
+    exportChangeset(collections_json: string, since_ms: number): string;
     /**
      * Serialize the entire in-memory database to bytes for persistence.
      *
@@ -167,6 +193,19 @@ export class WorkerDB {
      * Find one document. Returns a JSON object or `"null"`.
      */
     findOne(collection: string, filter_json: string): string;
+    /**
+     * Import a remote changeset and merge it into the local database using
+     * Last-Write-Wins conflict resolution.
+     *
+     * Returns the number of documents actually changed.
+     *
+     * ```js
+     * const resp = await fetch('/sync?since=' + lastSync);
+     * const applied = db.importChangeset(await resp.text());
+     * if (applied > 0) { /* refresh UI */ }
+     * ```
+     */
+    importChangeset(changeset_json: string): number;
     /**
      * Insert a document. Returns the new ULID as a string.
      */
@@ -175,6 +214,11 @@ export class WorkerDB {
      * Insert many documents. Returns a JSON array of ULID strings.
      */
     insertMany(collection: string, docs_json: string): string;
+    /**
+     * Returns a JSON array of all collection names in the database.
+     * Used by the Worker to build the collections list for exportChangeset.
+     */
+    listCollections(): string;
     /**
      * Returns a JSON string `{ btree: string[], fts: string[], vector: string[] }`
      * listing all indexes on the given collection.
@@ -184,6 +228,27 @@ export class WorkerDB {
      * Open an in-memory database (for tests and OPFS-unavailable fallback).
      */
     static openInMemory(): WorkerDB;
+    /**
+     * Open a database backed by OPFS with HTTP push sync config.
+     *
+     * `config_json` — JSON-serialised `TalaDbConfig`, or `null` to open without sync.
+     *
+     * ```js
+     * const handle = await file_handle.createSyncAccessHandle();
+     * const db = WorkerDB.openWithConfigAndOpfs(handle, JSON.stringify(config));
+     * ```
+     */
+    static openWithConfigAndOpfs(sync_handle: FileSystemSyncAccessHandle, config_json?: string | null): WorkerDB;
+    /**
+     * Open a database from an optional snapshot with HTTP push sync config.
+     *
+     * `config_json` — JSON-serialised `TalaDbConfig`, or `null` to open without sync.
+     *
+     * ```js
+     * const db = WorkerDB.openWithConfigAndSnapshot(snapshot, JSON.stringify(config));
+     * ```
+     */
+    static openWithConfigAndSnapshot(data?: Uint8Array | null, config_json?: string | null): WorkerDB;
     /**
      * Open a database backed by an OPFS `FileSystemSyncAccessHandle`.
      *
@@ -277,6 +342,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_workerdb_free: (a: number, b: number) => void;
+    readonly workerdb_compactTombstones: (a: number, b: number, c: number, d: number) => [number, number, number];
     readonly workerdb_count: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
     readonly workerdb_createFtsIndex: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly workerdb_createIndex: (a: number, b: number, c: number, d: number, e: number) => [number, number];
@@ -286,14 +352,19 @@ export interface InitOutput {
     readonly workerdb_dropFtsIndex: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly workerdb_dropIndex: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly workerdb_dropVectorIndex: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly workerdb_exportChangeset: (a: number, b: number, c: number, d: number) => [number, number, number, number];
     readonly workerdb_exportSnapshot: (a: number) => [number, number, number, number];
     readonly workerdb_find: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
     readonly workerdb_findNearest: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number, number, number];
     readonly workerdb_findOne: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+    readonly workerdb_importChangeset: (a: number, b: number, c: number) => [number, number, number];
     readonly workerdb_insert: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
     readonly workerdb_insertMany: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+    readonly workerdb_listCollections: (a: number) => [number, number, number, number];
     readonly workerdb_listIndexes: (a: number, b: number, c: number) => [number, number, number, number];
     readonly workerdb_openInMemory: () => [number, number, number];
+    readonly workerdb_openWithConfigAndOpfs: (a: any, b: number, c: number) => [number, number, number];
+    readonly workerdb_openWithConfigAndSnapshot: (a: number, b: number, c: number, d: number) => [number, number, number];
     readonly workerdb_openWithOpfs: (a: any) => [number, number, number];
     readonly workerdb_openWithSnapshot: (a: number, b: number) => [number, number, number];
     readonly workerdb_updateMany: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
@@ -321,18 +392,20 @@ export interface InitOutput {
     readonly taladbwasm_openInMemory: () => [number, number, number];
     readonly taladbwasm_openWithSnapshot: (a: number, b: number) => [number, number, number];
     readonly init: () => void;
+    readonly idb_load_snapshot: (a: number, b: number) => any;
+    readonly idb_save_snapshot: (a: number, b: number, c: number, d: number) => any;
     readonly is_opfs_available: () => any;
     readonly opfs_delete_snapshot: (a: number, b: number) => any;
     readonly opfs_flush_snapshot: (a: number, b: number, c: number, d: number) => any;
     readonly opfs_load_snapshot: (a: number, b: number) => any;
     readonly opfs_open_backend: (a: number, b: number) => any;
-    readonly idb_load_snapshot: (a: number, b: number) => any;
-    readonly idb_save_snapshot: (a: number, b: number, c: number, d: number) => any;
-    readonly wasm_bindgen__closure__destroy__h1411c0b1433bd547: (a: number, b: number) => void;
-    readonly wasm_bindgen__closure__destroy__hc294c7484c23aa40: (a: number, b: number) => void;
-    readonly wasm_bindgen__convert__closures_____invoke__h4bd31e7387ab665d: (a: number, b: number, c: any) => [number, number];
-    readonly wasm_bindgen__convert__closures_____invoke__h675f15260128efbc: (a: number, b: number, c: any, d: any) => void;
-    readonly wasm_bindgen__convert__closures_____invoke__h6096c0f3a625f394: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__closure__destroy__h72641f1e1c5255af: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__h478053cb26acc43f: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__h1febc128ce23ccd1: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h3022e61d849d0b12: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__h470c93d8a24e0015: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h296c8d2fd599fbcf: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h325a87e086f6f78c: (a: number, b: number) => void;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;

package/pkg/taladb_web.js

@@ -344,6 +344,31 @@ export class WorkerDB {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_workerdb_free(ptr, 0);
     }
+    /**
+     * Remove tombstones older than `before_ms` from the given collection.
+     *
+     * Call periodically (e.g. on app startup) after your sync retention window
+     * has elapsed so deleted document IDs no longer accumulate indefinitely.
+     * Returns the number of tombstones removed.
+     *
+     * ```js
+     * // Prune tombstones older than 30 days
+     * const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000;
+     * const pruned = db.compactTombstones('users', cutoff);
+     * ```
+     * @param {string} collection
+     * @param {number} before_ms
+     * @returns {number}
+     */
+    compactTombstones(collection, before_ms) {
+        const ptr0 = passStringToWasm0(collection, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.workerdb_compactTombstones(this.__wbg_ptr, ptr0, len0, before_ms);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Count matching documents.
      * @param {string} collection
@@ -495,6 +520,40 @@ export class WorkerDB {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Export a changeset for the given collections since `since_ms`.
+     *
+     * Returns a JSON string representing `Vec<Change>` that can be sent
+     * to a remote peer via fetch, WebSocket, or SSE.
+     *
+     * ```js
+     * const json = db.exportChangeset(JSON.stringify(['users', 'posts']), 0);
+     * await fetch('/sync', { method: 'POST', body: json });
+     * ```
+     * @param {string} collections_json
+     * @param {number} since_ms
+     * @returns {string}
+     */
+    exportChangeset(collections_json, since_ms) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(collections_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.workerdb_exportChangeset(this.__wbg_ptr, ptr0, len0, since_ms);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
     /**
      * Serialize the entire in-memory database to bytes for persistence.
      *
@@ -602,6 +661,29 @@ export class WorkerDB {
             wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
         }
     }
+    /**
+     * Import a remote changeset and merge it into the local database using
+     * Last-Write-Wins conflict resolution.
+     *
+     * Returns the number of documents actually changed.
+     *
+     * ```js
+     * const resp = await fetch('/sync?since=' + lastSync);
+     * const applied = db.importChangeset(await resp.text());
+     * if (applied > 0) { /* refresh UI */ }
+     * ```
+     * @param {string} changeset_json
+     * @returns {number}
+     */
+    importChangeset(changeset_json) {
+        const ptr0 = passStringToWasm0(changeset_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.workerdb_importChangeset(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Insert a document. Returns the new ULID as a string.
      * @param {string} collection
@@ -658,6 +740,29 @@ export class WorkerDB {
             wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
         }
     }
+    /**
+     * Returns a JSON array of all collection names in the database.
+     * Used by the Worker to build the collections list for exportChangeset.
+     * @returns {string}
+     */
+    listCollections() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.workerdb_listCollections(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Returns a JSON string `{ btree: string[], fts: string[], vector: string[] }`
      * listing all indexes on the given collection.
@@ -695,6 +800,51 @@ export class WorkerDB {
         }
         return WorkerDB.__wrap(ret[0]);
     }
+    /**
+     * Open a database backed by OPFS with HTTP push sync config.
+     *
+     * `config_json` — JSON-serialised `TalaDbConfig`, or `null` to open without sync.
+     *
+     * ```js
+     * const handle = await file_handle.createSyncAccessHandle();
+     * const db = WorkerDB.openWithConfigAndOpfs(handle, JSON.stringify(config));
+     * ```
+     * @param {FileSystemSyncAccessHandle} sync_handle
+     * @param {string | null} [config_json]
+     * @returns {WorkerDB}
+     */
+    static openWithConfigAndOpfs(sync_handle, config_json) {
+        var ptr0 = isLikeNone(config_json) ? 0 : passStringToWasm0(config_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.workerdb_openWithConfigAndOpfs(sync_handle, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WorkerDB.__wrap(ret[0]);
+    }
+    /**
+     * Open a database from an optional snapshot with HTTP push sync config.
+     *
+     * `config_json` — JSON-serialised `TalaDbConfig`, or `null` to open without sync.
+     *
+     * ```js
+     * const db = WorkerDB.openWithConfigAndSnapshot(snapshot, JSON.stringify(config));
+     * ```
+     * @param {Uint8Array | null} [data]
+     * @param {string | null} [config_json]
+     * @returns {WorkerDB}
+     */
+    static openWithConfigAndSnapshot(data, config_json) {
+        var ptr0 = isLikeNone(data) ? 0 : passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(config_json) ? 0 : passStringToWasm0(config_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.workerdb_openWithConfigAndSnapshot(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WorkerDB.__wrap(ret[0]);
+    }
     /**
      * Open a database backed by an OPFS `FileSystemSyncAccessHandle`.
      *
@@ -988,10 +1138,23 @@ function __wbg_get_imports() {
         __wbg__wbg_cb_unref_6b5b6b8576d35cb1: function(arg0) {
             arg0._wbg_cb_unref();
         },
+        __wbg_abort_5ef96933660780b7: function(arg0) {
+            arg0.abort();
+        },
+        __wbg_abort_6479c2d794ebf2ee: function(arg0, arg1) {
+            arg0.abort(arg1);
+        },
+        __wbg_append_608dfb635ee8998f: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
         __wbg_apply_ac9afb97ca32f169: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.apply(arg1, arg2);
             return ret;
         }, arguments); },
+        __wbg_apply_d7728efbea08f95e: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.apply(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
         __wbg_arrayBuffer_7ff5e58aa85a64f7: function(arg0) {
             const ret = arg0.arrayBuffer();
             return ret;
@@ -1008,6 +1171,10 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1);
             return ret;
         }, arguments); },
+        __wbg_clearTimeout_6b8d9a38b9263d65: function(arg0) {
+            const ret = clearTimeout(arg0);
+            return ret;
+        },
         __wbg_close_8b24f0978d9a4917: function(arg0) {
             const ret = arg0.close();
             return ret;
@@ -1035,6 +1202,14 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
+        __wbg_fetch_5550a88cf343aaa9: function(arg0, arg1) {
+            const ret = arg0.fetch(arg1);
+            return ret;
+        },
+        __wbg_fetch_9dad4fe911207b37: function(arg0) {
+            const ret = fetch(arg0);
+            return ret;
+        },
         __wbg_flush_1eca046e0ff7c399: function() { return handleError(function (arg0) {
             arg0.flush();
         }, arguments); },
@@ -1077,6 +1252,14 @@ function __wbg_get_imports() {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
+        __wbg_has_926ef2ff40b308cf: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.has(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_headers_eb2234545f9ff993: function(arg0) {
+            const ret = arg0.headers;
+            return ret;
+        },
         __wbg_instanceof_ArrayBuffer_101e2bf31071a9f6: function(arg0) {
             let result;
             try {
@@ -1157,6 +1340,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Response_9b4d9fd451e051b1: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Response;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Uint8Array_740438561a5b956d: function(arg0) {
             let result;
             try {
@@ -1201,6 +1394,10 @@ function __wbg_get_imports() {
             const ret = arg0.navigator;
             return ret;
         },
+        __wbg_new_0837727332ac86ba: function() { return handleError(function () {
+            const ret = new Headers();
+            return ret;
+        }, arguments); },
         __wbg_new_227d7c05414eb861: function() {
             const ret = new Error();
             return ret;
@@ -1221,6 +1418,10 @@ function __wbg_get_imports() {
             const ret = new Object();
             return ret;
         },
+        __wbg_new_c518c60af666645b: function() { return handleError(function () {
+            const ret = new AbortController();
+            return ret;
+        }, arguments); },
         __wbg_new_d098e265629cd10f: function(arg0, arg1) {
             try {
                 var state0 = {a: arg0, b: arg1};
@@ -1228,7 +1429,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h675f15260128efbc(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h470c93d8a24e0015(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1250,7 +1451,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h675f15260128efbc(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h470c93d8a24e0015(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1265,6 +1466,10 @@ function __wbg_get_imports() {
             const ret = new Uint8Array(arg0 >>> 0);
             return ret;
         },
+        __wbg_new_with_str_and_init_b4b54d1a819bc724: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
+            return ret;
+        }, arguments); },
         __wbg_next_11b99ee6237339e3: function() { return handleError(function (arg0) {
             const ret = arg0.next();
             return ret;
@@ -1277,6 +1482,10 @@ function __wbg_get_imports() {
             const ret = Date.now();
             return ret;
         },
+        __wbg_of_d6376e3774c51f89: function(arg0, arg1) {
+            const ret = Array.of(arg0, arg1);
+            return ret;
+        },
         __wbg_prototypesetcall_d62e5099504357e6: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
@@ -1299,6 +1508,10 @@ function __wbg_get_imports() {
             const ret = Promise.resolve(arg0);
             return ret;
         },
+        __wbg_setTimeout_f757f00851f76c42: function(arg0, arg1) {
+            const ret = setTimeout(arg0, arg1);
+            return ret;
+        },
         __wbg_set_282384002438957f: function(arg0, arg1, arg2) {
             arg0[arg1 >>> 0] = arg2;
         },
@@ -1313,9 +1526,34 @@ function __wbg_get_imports() {
             const ret = arg0.set(arg1, arg2);
             return ret;
         },
+        __wbg_set_body_a3d856b097dfda04: function(arg0, arg1) {
+            arg0.body = arg1;
+        },
+        __wbg_set_cache_ec7e430c6056ebda: function(arg0, arg1) {
+            arg0.cache = __wbindgen_enum_RequestCache[arg1];
+        },
         __wbg_set_create_ef897736206a6f05: function(arg0, arg1) {
             arg0.create = arg1 !== 0;
         },
+        __wbg_set_credentials_ed63183445882c65: function(arg0, arg1) {
+            arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
+        },
+        __wbg_set_headers_3c8fecc693b75327: function(arg0, arg1) {
+            arg0.headers = arg1;
+        },
+        __wbg_set_method_8c015e8bcafd7be1: function(arg0, arg1, arg2) {
+            arg0.method = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_mode_5a87f2c809cf37c2: function(arg0, arg1) {
+            arg0.mode = __wbindgen_enum_RequestMode[arg1];
+        },
+        __wbg_set_signal_0cebecb698f25d21: function(arg0, arg1) {
+            arg0.signal = arg1;
+        },
+        __wbg_signal_166e1da31adcac18: function(arg0) {
+            const ret = arg0.signal;
+            return ret;
+        },
         __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
             const ret = arg1.stack;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -1339,10 +1577,18 @@ function __wbg_get_imports() {
             const ret = typeof window === 'undefined' ? null : window;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_status_318629ab93a22955: function(arg0) {
+            const ret = arg0.status;
+            return ret;
+        },
         __wbg_storage_63fa6fa9455d2153: function(arg0) {
             const ret = arg0.storage;
             return ret;
         },
+        __wbg_stringify_5ae93966a84901ac: function() { return handleError(function (arg0) {
+            const ret = JSON.stringify(arg0);
+            return ret;
+        }, arguments); },
         __wbg_then_098abe61755d12f6: function(arg0, arg1) {
             const ret = arg0.then(arg1);
             return ret;
@@ -1354,41 +1600,53 @@ function __wbg_get_imports() {
         __wbg_truncate_af8ac1613ab66393: function() { return handleError(function (arg0, arg1) {
             arg0.truncate(arg1);
         }, arguments); },
+        __wbg_url_7fefc1820fba4e0c: function(arg0, arg1) {
+            const ret = arg1.url;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg_value_21fc78aab0322612: function(arg0) {
             const ret = arg0.value;
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 422, function: Function { arguments: [Externref], shim_idx: 423, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h1411c0b1433bd547, wasm_bindgen__convert__closures_____invoke__h4bd31e7387ab665d);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 102, function: Function { arguments: [Externref], shim_idx: 103, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h72641f1e1c5255af, wasm_bindgen__convert__closures_____invoke__h296c8d2fd599fbcf);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 63, function: Function { arguments: [Externref], shim_idx: 64, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hc294c7484c23aa40, wasm_bindgen__convert__closures_____invoke__h6096c0f3a625f394);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 181, function: Function { arguments: [], shim_idx: 182, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h478053cb26acc43f, wasm_bindgen__convert__closures_____invoke__h325a87e086f6f78c);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 589, function: Function { arguments: [Externref], shim_idx: 590, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h1febc128ce23ccd1, wasm_bindgen__convert__closures_____invoke__h3022e61d849d0b12);
             return ret;
         },
-        __wbindgen_cast_0000000000000003: function(arg0) {
+        __wbindgen_cast_0000000000000004: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000004: function(arg0) {
+        __wbindgen_cast_0000000000000005: function(arg0) {
             // Cast intrinsic for `I64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000006: function(arg0) {
+        __wbindgen_cast_0000000000000007: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return ret;
         },
-        __wbindgen_cast_0000000000000007: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
             var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 1, 1);
             // Cast intrinsic for `Vector(U8) -> Externref`.
@@ -1411,21 +1669,33 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h6096c0f3a625f394(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h6096c0f3a625f394(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h325a87e086f6f78c(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h325a87e086f6f78c(arg0, arg1);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h296c8d2fd599fbcf(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h296c8d2fd599fbcf(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h4bd31e7387ab665d(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h4bd31e7387ab665d(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h3022e61d849d0b12(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h3022e61d849d0b12(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h675f15260128efbc(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h675f15260128efbc(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h470c93d8a24e0015(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h470c93d8a24e0015(arg0, arg1, arg2, arg3);
 }
 
+
+const __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
+
+
+const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
+
+
+const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
 const CollectionWasmFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_collectionwasm_free(ptr >>> 0, 1));

package/pkg/taladb_web_bg.wasm.d.ts

@@ -2,6 +2,7 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_workerdb_free: (a: number, b: number) => void;
+export const workerdb_compactTombstones: (a: number, b: number, c: number, d: number) => [number, number, number];
 export const workerdb_count: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
 export const workerdb_createFtsIndex: (a: number, b: number, c: number, d: number, e: number) => [number, number];
 export const workerdb_createIndex: (a: number, b: number, c: number, d: number, e: number) => [number, number];
@@ -11,14 +12,19 @@ export const workerdb_deleteOne: (a: number, b: number, c: number, d: number, e:
 export const workerdb_dropFtsIndex: (a: number, b: number, c: number, d: number, e: number) => [number, number];
 export const workerdb_dropIndex: (a: number, b: number, c: number, d: number, e: number) => [number, number];
 export const workerdb_dropVectorIndex: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const workerdb_exportChangeset: (a: number, b: number, c: number, d: number) => [number, number, number, number];
 export const workerdb_exportSnapshot: (a: number) => [number, number, number, number];
 export const workerdb_find: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
 export const workerdb_findNearest: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number, number, number];
 export const workerdb_findOne: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+export const workerdb_importChangeset: (a: number, b: number, c: number) => [number, number, number];
 export const workerdb_insert: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
 export const workerdb_insertMany: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+export const workerdb_listCollections: (a: number) => [number, number, number, number];
 export const workerdb_listIndexes: (a: number, b: number, c: number) => [number, number, number, number];
 export const workerdb_openInMemory: () => [number, number, number];
+export const workerdb_openWithConfigAndOpfs: (a: any, b: number, c: number) => [number, number, number];
+export const workerdb_openWithConfigAndSnapshot: (a: number, b: number, c: number, d: number) => [number, number, number];
 export const workerdb_openWithOpfs: (a: any) => [number, number, number];
 export const workerdb_openWithSnapshot: (a: number, b: number) => [number, number, number];
 export const workerdb_updateMany: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
@@ -46,18 +52,20 @@ export const taladbwasm_exportSnapshot: (a: number) => [number, number, number,
 export const taladbwasm_openInMemory: () => [number, number, number];
 export const taladbwasm_openWithSnapshot: (a: number, b: number) => [number, number, number];
 export const init: () => void;
+export const idb_load_snapshot: (a: number, b: number) => any;
+export const idb_save_snapshot: (a: number, b: number, c: number, d: number) => any;
 export const is_opfs_available: () => any;
 export const opfs_delete_snapshot: (a: number, b: number) => any;
 export const opfs_flush_snapshot: (a: number, b: number, c: number, d: number) => any;
 export const opfs_load_snapshot: (a: number, b: number) => any;
 export const opfs_open_backend: (a: number, b: number) => any;
-export const idb_load_snapshot: (a: number, b: number) => any;
-export const idb_save_snapshot: (a: number, b: number, c: number, d: number) => any;
-export const wasm_bindgen__closure__destroy__h1411c0b1433bd547: (a: number, b: number) => void;
-export const wasm_bindgen__closure__destroy__hc294c7484c23aa40: (a: number, b: number) => void;
-export const wasm_bindgen__convert__closures_____invoke__h4bd31e7387ab665d: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h675f15260128efbc: (a: number, b: number, c: any, d: any) => void;
-export const wasm_bindgen__convert__closures_____invoke__h6096c0f3a625f394: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__closure__destroy__h72641f1e1c5255af: (a: number, b: number) => void;
+export const wasm_bindgen__closure__destroy__h478053cb26acc43f: (a: number, b: number) => void;
+export const wasm_bindgen__closure__destroy__h1febc128ce23ccd1: (a: number, b: number) => void;
+export const wasm_bindgen__convert__closures_____invoke__h3022e61d849d0b12: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h470c93d8a24e0015: (a: number, b: number, c: any, d: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h296c8d2fd599fbcf: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h325a87e086f6f78c: (a: number, b: number) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;

package/worker/taladb.worker.js

@@ -48,6 +48,10 @@
  * dropVectorIndex   { collection, field }
  * upgradeVectorIndex { collection, field }
  * findNearest       { collection, field, queryJson, topK, filterJson? }
+ * listCollections   {}                             → JSON string[]
+ * compactTombstones { collection, beforeMs }       → number pruned
+ * exportChangeset   { collectionsJson, sinceMs? }  → JSON changeset string
+ * importChangeset   { changesetJson }              → number of applied changes
  * close             {}
  *
  * Multi-tab live queries (BroadcastChannel)
@@ -57,6 +61,16 @@
  * `"taladb:<dbName>"`.  Other tabs listening on the same channel re-trigger
  * their active `subscribe()` pollers immediately, bypassing the 300 ms tick.
  *
+ * Secondary-tab write propagation
+ * --------------------------------
+ * Fallback (non-OPFS) tabs can also make writes that need to reach the primary
+ * tab's OPFS-backed database.  After every mutating op a fallback tab exports a
+ * mini-changeset (all collections, since the previous sync point) and posts it
+ * as `{ type: 'taladb:secondary-write', changeset }` on the BroadcastChannel.
+ * The primary (OPFS) tab receives it, calls importChangeset(), and runs the
+ * normal onWriteCommitted() path — so all other tabs are notified and the OPFS
+ * file stays authoritative.  LWW merge handles any concurrent edits.
+ *
  * IndexedDB fallback (no OPFS)
  * ----------------------------
  * When OPFS is unavailable (cross-origin iframes, Firefox without storage
@@ -102,6 +116,9 @@ const initPromises = new Map();
 /** The dbName that was successfully initialised (or is being initialised). */
 let activeDbName = null;
 
+/** The configJson passed during init (stored so snapshot reloads can use it). */
+let activeConfigJson = null;
+
 const isDev = typeof location !== 'undefined' && (location.hostname === 'localhost' || location.hostname === '127.0.0.1');
 const log = isDev ? console.log.bind(console, '[TalaDB Worker]') : () => {};
 const warn = isDev ? console.warn.bind(console, '[TalaDB Worker]') : () => {};
@@ -127,6 +144,14 @@ let broadcastChannel = null;
  */
 let idbFallback = false;
 
+/**
+ * Timestamp (ms) of the last changeset we exported and broadcast to the
+ * primary tab.  Used as `sinceMs` for the next export so we only send the
+ * delta, not the entire database on every write.
+ * @type {number}
+ */
+let lastSecondaryPushMs = 0;
+
 // ---------------------------------------------------------------------------
 // IndexedDB helpers (used only when OPFS is unavailable)
 // ---------------------------------------------------------------------------
@@ -190,22 +215,99 @@ async function idbSaveSnapshot(dbName, bytes) {
   } catch { /* best-effort persistence — ignore failures */ }
 }
 
+// ---------------------------------------------------------------------------
+// Debounced IDB snapshot
+// ---------------------------------------------------------------------------
+
 /**
- * Notify sibling tabs of a write and, when in IDB-fallback mode, flush the
- * updated snapshot to IndexedDB.  Must be called after every mutating op.
+ * Debounce + max-interval parameters for IDB snapshot persistence.
+ *
+ * On every write we notify sibling tabs immediately via BroadcastChannel,
+ * but we defer the actual IDB persistence so that bulk inserts (insertMany,
+ * rapid sequential inserts) only produce a single IDB write rather than one
+ * per document.  A max-interval cap ensures data is never more than 5 s stale
+ * in IDB even under continuous write load.
  */
-function onWriteCommitted() {
-  broadcastChannel?.postMessage('taladb:changed');
-  // Always flush a snapshot to IDB after every write — this keeps other tabs'
-  // IDB-fallback instances in sync via BroadcastChannel + snapshotDirty reload.
+const SNAPSHOT_DEBOUNCE_MS = 500;
+const SNAPSHOT_MAX_INTERVAL_MS = 5000;
+
+/** setTimeout handle for the pending debounced flush. */
+let snapshotTimer = null;
+
+/** Timestamp of the last completed IDB flush (ms since epoch). */
+let lastSnapshotMs = 0;
+
+/** Perform the IDB snapshot write and reset state. */
+async function flushSnapshot() {
+  clearTimeout(snapshotTimer);
+  snapshotTimer = null;
+  lastSnapshotMs = Date.now();
   if (db && activeDbName) {
     try {
       const bytes = db.exportSnapshot();
-      idbSaveSnapshot(activeDbName, bytes).catch(() => {});
-    } catch { /* ignore snapshot export errors */ }
+      await idbSaveSnapshot(activeDbName, bytes);
+    } catch { /* best-effort — ignore failures */ }
   }
 }
 
+/**
+ * Schedule (or immediately trigger) an IDB snapshot write.
+ *
+ * - If the last flush was more than SNAPSHOT_MAX_INTERVAL_MS ago, flush now.
+ * - Otherwise debounce: reset the timer to fire SNAPSHOT_DEBOUNCE_MS from now.
+ */
+function scheduleSnapshot() {
+  const now = Date.now();
+  if (now - lastSnapshotMs > SNAPSHOT_MAX_INTERVAL_MS) {
+    // Overdue — flush synchronously in the microtask queue.
+    flushSnapshot().catch(() => {});
+    return;
+  }
+  clearTimeout(snapshotTimer);
+  snapshotTimer = setTimeout(() => { flushSnapshot().catch(() => {}); }, SNAPSHOT_DEBOUNCE_MS);
+}
+
+/**
+ * When running as a fallback (non-OPFS) tab, export the changes made since
+ * the last push and broadcast them to the primary tab for merging into OPFS.
+ *
+ * Uses exportChangeset with all known collections to keep the delta small.
+ * The primary tab's BroadcastChannel handler calls importChangeset() and runs
+ * its own onWriteCommitted(), which notifies all tabs (including this one) via
+ * taladb:changed so reads stay consistent.
+ */
+function pushChangesetToPrimary() {
+  if (!idbFallback || !db || !broadcastChannel || !activeDbName) return;
+  try {
+    // Collect all collection names from the current in-memory state.
+    // exportChangeset accepts a JSON array of collection names.
+    const collections = db.listCollections();
+    const changeset = db.exportChangeset(collections, lastSecondaryPushMs);
+    // Only broadcast if there is actually something to send.
+    const parsed = JSON.parse(changeset);
+    if (parsed.length === 0) return;
+    lastSecondaryPushMs = Date.now();
+    broadcastChannel.postMessage({ type: 'taladb:secondary-write', changeset });
+    log(`Broadcast ${parsed.length} change(s) to primary tab`);
+  } catch (err) {
+    warn('Failed to export changeset for primary tab:', err);
+  }
+}
+
+/**
+ * Notify sibling tabs of a write and schedule IDB persistence.
+ * Must be called after every mutating op.
+ */
+function onWriteCommitted() {
+  broadcastChannel?.postMessage('taladb:changed');
+  // Fallback tab: push local changes to the primary (OPFS) tab so they are
+  // merged into the authoritative database file.
+  pushChangesetToPrimary();
+  // Debounced IDB flush — keeps other tabs' fallback instances in sync via
+  // BroadcastChannel + snapshotDirty reload without writing to IDB on every op.
+  scheduleSnapshot();
+}
+
 // ---------------------------------------------------------------------------
 // Dedicated Worker message handler
 // ---------------------------------------------------------------------------
@@ -231,12 +333,16 @@ async function dispatch(op, args) {
     snapshotDirty = false;
     try {
       const fresh = await idbLoadSnapshot(activeDbName);
-      if (fresh) db = WorkerDB.openWithSnapshot(fresh);
+      if (fresh) {
+        db = activeConfigJson
+          ? WorkerDB.openWithConfigAndSnapshot(fresh, activeConfigJson)
+          : WorkerDB.openWithSnapshot(fresh);
+      }
     } catch { /* ignore reload errors — stale read is acceptable */ }
   }
 
   if (op === 'init') {
-    const { dbName } = args;
+    const { dbName, configJson } = args;
 
     if (activeDbName !== null && activeDbName !== dbName) {
       throw new Error(
@@ -247,7 +353,8 @@ async function dispatch(op, args) {
 
     if (!initPromises.has(dbName)) {
       activeDbName = dbName;
-      initPromises.set(dbName, doInit(dbName));
+      activeConfigJson = configJson ?? null;
+      initPromises.set(dbName, doInit(dbName, configJson ?? null));
     }
     await initPromises.get(dbName);
     return null;
@@ -349,7 +456,31 @@ async function dispatch(op, args) {
         args.filterJson ?? 'null',
       );
 
+    case 'listCollections':
+      return db.listCollections();
+
+    case 'compactTombstones':
+      // Prune tombstones older than beforeMs from a collection.
+      // Returns the count of tombstones removed.
+      return db.compactTombstones(args.collection, args.beforeMs ?? 0);
+
+    case 'exportChangeset':
+      // Export a LWW changeset for the given collections since sinceMs.
+      // Returns a JSON string the caller can POST to a sync server.
+      return db.exportChangeset(args.collectionsJson, args.sinceMs ?? 0);
+
+    case 'importChangeset': {
+      // Apply a remote changeset (JSON string from sync server) using LWW.
+      // Triggers onWriteCommitted so multi-tab peers get notified.
+      const applied = db.importChangeset(args.changesetJson);
+      if (applied > 0) onWriteCommitted();
+      return applied;
+    }
+
     case 'close':
+      // Flush any pending debounced snapshot before releasing the lock so
+      // no writes are lost when the tab closes or navigates away.
+      await flushSnapshot();
       // Release the Web Lock and close the sync handle gracefully.
       if (releaseLock) { releaseLock(); releaseLock = null; }
       broadcastChannel?.close();
@@ -367,7 +498,7 @@ async function dispatch(op, args) {
 // Initialisation — load WASM, acquire lock, open OPFS file
 // ---------------------------------------------------------------------------
 
-async function doInit(dbName) {
+async function doInit(dbName, configJson) {
   const wasm = await import('../pkg/taladb_web.js');
   await wasm.default();
 
@@ -394,16 +525,39 @@ async function doInit(dbName) {
         const resolve = pendingSnapshotResolve;
         pendingSnapshotResolve = null;
         resolve();
+      } else if (e.data?.type === 'taladb:secondary-write' && !idbFallback && db) {
+        // Primary (OPFS) tab: a secondary tab made a write — merge it in via LWW.
+        try {
+          const applied = db.importChangeset(e.data.changeset);
+          if (applied > 0) {
+            log(`Merged ${applied} change(s) from secondary tab`);
+            onWriteCommitted();
+          }
+        } catch (err) {
+          warn('Failed to import secondary-tab changeset:', err);
+        }
       }
     };
     log('BroadcastChannel opened:', `taladb:${dbName}`);
   }
 
+  // Helpers to open DB with or without sync config.
+  // Uses the config-aware constructors when configJson is provided so that
+  // HTTP push sync is wired up from the first write.
+  function openWithSnapshot(snapshot) {
+    if (configJson) return WorkerDB.openWithConfigAndSnapshot(snapshot, configJson);
+    return WorkerDB.openWithSnapshot(snapshot);
+  }
+  function openWithOpfs(syncHandle) {
+    if (configJson) return WorkerDB.openWithConfigAndOpfs(syncHandle, configJson);
+    return WorkerDB.openWithOpfs(syncHandle);
+  }
+
   const opfsAvailable = await checkOpfs();
   if (!opfsAvailable) {
     warn('OPFS unavailable — falling back to IndexedDB-backed in-memory');
     const snapshot = await idbLoadSnapshot(dbName);
-    db = WorkerDB.openWithSnapshot(snapshot);
+    db = openWithSnapshot(snapshot);
     idbFallback = true;
     if (snapshot) {
       log(`Restored from IndexedDB snapshot (${snapshot.byteLength} bytes)`);
@@ -421,7 +575,7 @@ async function doInit(dbName) {
     // Web Locks not available — open directly (single-tab safe only).
     warn('Web Locks unavailable — multi-tab write safety disabled');
     const syncHandle = await fileHandle.createSyncAccessHandle();
-    db = WorkerDB.openWithOpfs(syncHandle);
+    db = openWithOpfs(syncHandle);
     log(`Opened "${fileName}" via OPFS`);
     return;
   }
@@ -451,7 +605,7 @@ async function doInit(dbName) {
           if (gotIt !== false) snapshot = await idbLoadSnapshot(dbName);
         }
 
-        db = WorkerDB.openWithSnapshot(snapshot ?? null);
+        db = openWithSnapshot(snapshot ?? null);
         idbFallback = true;
         if (snapshot) {
           log(`Restored from IDB snapshot (${snapshot.byteLength} bytes)`);
@@ -465,7 +619,7 @@ async function doInit(dbName) {
       // Acquired the lock — use OPFS.
       try {
         const syncHandle = await fileHandle.createSyncAccessHandle();
-        db = WorkerDB.openWithOpfs(syncHandle);
+        db = openWithOpfs(syncHandle);
         log(`Opened "${fileName}" via OPFS (Web Locks)`);
         resolve(); // signal doInit complete — caller can proceed