@lix-js/sdk 0.16.1 → 0.17.0

package/dist/wasm/lix_js_sdk.js

@@ -1,5 +1,58 @@
 /* @ts-self-types="./lix_js_sdk.d.ts" */
 
+export class BrowserComponentHost {
+    static __wrap(ptr) {
+        const obj = Object.create(BrowserComponentHost.prototype);
+        obj.__wbg_ptr = ptr;
+        BrowserComponentHostFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BrowserComponentHostFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_browsercomponenthost_free(ptr, 0);
+    }
+    /**
+     * @param {string} method
+     * @param {string} _arguments
+     * @returns {string}
+     */
+    call(method, _arguments) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(method, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(_arguments, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.browsercomponenthost_call(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr3 = r0;
+            var len3 = r1;
+            if (r3) {
+                ptr3 = 0; len3 = 0;
+                throw takeObject(r2);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) BrowserComponentHost.prototype[Symbol.dispose] = BrowserComponentHost.prototype.free;
+
 export class WasmLix {
     static __wrap(ptr) {
         const obj = Object.create(WasmLix.prototype);
@@ -136,10 +189,11 @@ export class WasmLix {
     }
     /**
      * @param {any} options
+     * @param {Function | null} [telemetry_dispatch]
      * @returns {Promise<WasmLix>}
      */
-    openAnotherSession(options) {
-        const ret = wasm.wasmlix_openAnotherSession(this.__wbg_ptr, addHeapObject(options));
+    openAnotherSession(options, telemetry_dispatch) {
+        const ret = wasm.wasmlix_openAnotherSession(this.__wbg_ptr, addHeapObject(options), isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch));
         return takeObject(ret);
     }
     /**
@@ -170,6 +224,17 @@ export class WasmLix {
         const ret = wasm.wasmlix_recoverReplica(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
+    /**
+     * @param {string} id
+     * @param {any} server
+     * @returns {Promise<any>}
+     */
+    recoverReplicaWithServer(id, server) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmlix_recoverReplicaWithServer(this.__wbg_ptr, ptr0, len0, addHeapObject(server));
+        return takeObject(ret);
+    }
     /**
      * @returns {Promise<any>}
      */
@@ -215,6 +280,13 @@ export class WasmLix {
         const ret = wasm.wasmlix_syncDiskToLix(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * @returns {Promise<any>}
+     */
+    syncHealth() {
+        const ret = wasm.wasmlix_syncHealth(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * @returns {Promise<any>}
      */
@@ -243,7 +315,7 @@ export class WasmLixTransaction {
         wasm.__wbg_wasmlixtransaction_free(ptr, 0);
     }
     /**
-     * @returns {Promise<void>}
+     * @returns {Promise<any>}
      */
     commit() {
         const ret = wasm.wasmlixtransaction_commit(this.__wbg_ptr);
@@ -461,6 +533,17 @@ export class WasmRemoteLix {
         const ret = wasm.wasmremotelix_recoverReplica(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
+    /**
+     * @param {string} _id
+     * @param {any} _server
+     * @returns {Promise<any>}
+     */
+    recoverReplicaWithServer(_id, _server) {
+        const ptr0 = passStringToWasm0(_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmremotelix_recoverReplicaWithServer(this.__wbg_ptr, ptr0, len0, addHeapObject(_server));
+        return takeObject(ret);
+    }
     /**
      * @returns {Promise<any>}
      */
@@ -496,6 +579,13 @@ export class WasmRemoteLix {
         const ret = wasm.wasmremotelix_syncDiskToLix(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * @returns {Promise<any>}
+     */
+    syncHealth() {
+        const ret = wasm.wasmremotelix_syncHealth(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * @returns {Promise<any>}
      */
@@ -524,7 +614,7 @@ export class WasmRemoteLixTransaction {
         wasm.__wbg_wasmremotelixtransaction_free(ptr, 0);
     }
     /**
-     * @returns {Promise<void>}
+     * @returns {Promise<any>}
      */
     commit() {
         const ret = wasm.wasmremotelixtransaction_commit(this.__wbg_ptr);
@@ -692,50 +782,76 @@ export function deleteHosted(server) {
 }
 
 /**
+ * Read-only routing metadata; available in the current-format runtime.
  * @param {any} provider
- * @param {Function | null} [telemetry_dispatch]
- * @param {any | null} [telemetry_parent]
- * @param {any | null} [server]
- * @param {Function | null} [open_progress_dispatch]
+ * @returns {Promise<any>}
+ */
+export function inspectJsStorageRepository(provider) {
+    const ret = wasm.inspectJsStorageRepository(addHeapObject(provider));
+    return takeObject(ret);
+}
+
+/**
+ * @param {any} provider
+ * @param {Function | null | undefined} telemetry_dispatch
+ * @param {any | null | undefined} telemetry_parent
+ * @param {any | null | undefined} server
+ * @param {Function | null | undefined} open_progress_dispatch
+ * @param {Function} component_dispatch
+ * @param {string | null} [durability]
  * @returns {Promise<WasmLix>}
  */
-export function openJsStorage(provider, telemetry_dispatch, telemetry_parent, server, open_progress_dispatch) {
-    const ret = wasm.openJsStorage(addHeapObject(provider), isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch), isLikeNone(telemetry_parent) ? 0 : addHeapObject(telemetry_parent), isLikeNone(server) ? 0 : addHeapObject(server), isLikeNone(open_progress_dispatch) ? 0 : addHeapObject(open_progress_dispatch));
+export function openJsStorage(provider, telemetry_dispatch, telemetry_parent, server, open_progress_dispatch, component_dispatch, durability) {
+    var ptr0 = isLikeNone(durability) ? 0 : passStringToWasm0(durability, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.openJsStorage(addHeapObject(provider), isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch), isLikeNone(telemetry_parent) ? 0 : addHeapObject(telemetry_parent), isLikeNone(server) ? 0 : addHeapObject(server), isLikeNone(open_progress_dispatch) ? 0 : addHeapObject(open_progress_dispatch), addHeapObject(component_dispatch), ptr0, len0);
     return takeObject(ret);
 }
 
 /**
  * @param {any} provider
- * @param {Function | null} [telemetry_dispatch]
- * @param {any | null} [telemetry_parent]
- * @param {Function | null} [open_progress_dispatch]
+ * @param {Function | null | undefined} telemetry_dispatch
+ * @param {any | null | undefined} telemetry_parent
+ * @param {Function | null | undefined} open_progress_dispatch
+ * @param {Function} component_dispatch
+ * @param {string | null} [durability]
  * @returns {WasmSnapshotRestore}
  */
-export function openJsStorageFromSnapshot(provider, telemetry_dispatch, telemetry_parent, open_progress_dispatch) {
-    const ret = wasm.openJsStorageFromSnapshot(addHeapObject(provider), isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch), isLikeNone(telemetry_parent) ? 0 : addHeapObject(telemetry_parent), isLikeNone(open_progress_dispatch) ? 0 : addHeapObject(open_progress_dispatch));
+export function openJsStorageFromSnapshot(provider, telemetry_dispatch, telemetry_parent, open_progress_dispatch, component_dispatch, durability) {
+    var ptr0 = isLikeNone(durability) ? 0 : passStringToWasm0(durability, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.openJsStorageFromSnapshot(addHeapObject(provider), isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch), isLikeNone(telemetry_parent) ? 0 : addHeapObject(telemetry_parent), isLikeNone(open_progress_dispatch) ? 0 : addHeapObject(open_progress_dispatch), addHeapObject(component_dispatch), ptr0, len0);
     return WasmSnapshotRestore.__wrap(ret);
 }
 
 /**
- * @param {Function | null} [telemetry_dispatch]
- * @param {any | null} [telemetry_parent]
- * @param {any | null} [server]
- * @param {Function | null} [open_progress_dispatch]
+ * @param {Function | null | undefined} telemetry_dispatch
+ * @param {any | null | undefined} telemetry_parent
+ * @param {any | null | undefined} server
+ * @param {Function | null | undefined} open_progress_dispatch
+ * @param {Function} component_dispatch
+ * @param {string | null} [durability]
  * @returns {Promise<WasmLix>}
  */
-export function openMemory(telemetry_dispatch, telemetry_parent, server, open_progress_dispatch) {
-    const ret = wasm.openMemory(isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch), isLikeNone(telemetry_parent) ? 0 : addHeapObject(telemetry_parent), isLikeNone(server) ? 0 : addHeapObject(server), isLikeNone(open_progress_dispatch) ? 0 : addHeapObject(open_progress_dispatch));
+export function openMemory(telemetry_dispatch, telemetry_parent, server, open_progress_dispatch, component_dispatch, durability) {
+    var ptr0 = isLikeNone(durability) ? 0 : passStringToWasm0(durability, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.openMemory(isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch), isLikeNone(telemetry_parent) ? 0 : addHeapObject(telemetry_parent), isLikeNone(server) ? 0 : addHeapObject(server), isLikeNone(open_progress_dispatch) ? 0 : addHeapObject(open_progress_dispatch), addHeapObject(component_dispatch), ptr0, len0);
     return takeObject(ret);
 }
 
 /**
- * @param {Function | null} [telemetry_dispatch]
- * @param {any | null} [telemetry_parent]
- * @param {Function | null} [open_progress_dispatch]
+ * @param {Function | null | undefined} telemetry_dispatch
+ * @param {any | null | undefined} telemetry_parent
+ * @param {Function | null | undefined} open_progress_dispatch
+ * @param {Function} component_dispatch
+ * @param {string | null} [durability]
  * @returns {WasmSnapshotRestore}
  */
-export function openMemoryFromSnapshot(telemetry_dispatch, telemetry_parent, open_progress_dispatch) {
-    const ret = wasm.openMemoryFromSnapshot(isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch), isLikeNone(telemetry_parent) ? 0 : addHeapObject(telemetry_parent), isLikeNone(open_progress_dispatch) ? 0 : addHeapObject(open_progress_dispatch));
+export function openMemoryFromSnapshot(telemetry_dispatch, telemetry_parent, open_progress_dispatch, component_dispatch, durability) {
+    var ptr0 = isLikeNone(durability) ? 0 : passStringToWasm0(durability, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.openMemoryFromSnapshot(isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch), isLikeNone(telemetry_parent) ? 0 : addHeapObject(telemetry_parent), isLikeNone(open_progress_dispatch) ? 0 : addHeapObject(open_progress_dispatch), addHeapObject(component_dispatch), ptr0, len0);
     return WasmSnapshotRestore.__wrap(ret);
 }
 
@@ -754,6 +870,30 @@ export function openRemote(url, fetch, headers, initial_active_branch_id) {
     const ret = wasm.openRemote(ptr0, len0, addHeapObject(fetch), addHeapObject(headers), ptr1, len1);
     return takeObject(ret);
 }
+
+/**
+ * Parse the engine SQL dialect for hosts that authorize public SQL.
+ * @param {string} sql
+ * @param {number} provided_param_count
+ * @returns {any}
+ */
+export function parseSqlScript(sql, provided_param_count) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(sql, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.parseSqlScript(retptr, ptr0, len0, provided_param_count);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -847,22 +987,30 @@ function __wbg_get_imports() {
         __wbg__wbg_cb_unref_61db23ac97f16c31: function(arg0) {
             getObject(arg0)._wbg_cb_unref();
         },
-        __wbg_acquireSession_23e79c33392e697b: function(arg0) {
+        __wbg_acquirePartialReplicaOwner_eec421a6abd55550: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).acquirePartialReplicaOwner(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_acquireSession_efd474d194c89c7c: function(arg0) {
             const ret = getObject(arg0).acquireSession();
             return addHeapObject(ret);
         },
-        __wbg_beginRead_a07540d6b7276aa8: function(arg0, arg1) {
+        __wbg_beginRead_c29ba5aceee12f65: function(arg0, arg1) {
             const ret = getObject(arg0).beginRead(takeObject(arg1));
             return addHeapObject(ret);
         },
-        __wbg_beginScan_fe1d6b306d24f1d8: function(arg0, arg1, arg2, arg3) {
+        __wbg_beginScan_0a623d7363773a8c: function(arg0, arg1, arg2, arg3) {
             const ret = getObject(arg0).beginScan(takeObject(arg1), takeObject(arg2), takeObject(arg3));
             return addHeapObject(ret);
         },
-        __wbg_beginWrite_accabb884da53d0d: function(arg0, arg1) {
+        __wbg_beginWrite_243047d9cbfeca9e: function(arg0, arg1) {
             const ret = getObject(arg0).beginWrite(takeObject(arg1));
             return addHeapObject(ret);
         },
+        __wbg_browsercomponenthost_new: function(arg0) {
+            const ret = BrowserComponentHost.__wrap(arg0);
+            return addHeapObject(ret);
+        },
         __wbg_call_40e4174f169eaca7: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
             return addHeapObject(ret);
@@ -875,18 +1023,21 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
         }, arguments); },
-        __wbg_changed_611eb1bd688d481b: function(arg0) {
+        __wbg_changed_09a2471dfa033a65: function(arg0) {
             const ret = getObject(arg0).changed();
             return addHeapObject(ret);
         },
-        __wbg_close_312ad1c70f8567ec: function(arg0) {
+        __wbg_close_037c736acbd898fe: function(arg0) {
             getObject(arg0).close();
         },
-        __wbg_close_60c048095d05207d: function(arg0) {
+        __wbg_close_84f9cb63f6cabe57: function(arg0) {
+            getObject(arg0).close();
+        },
+        __wbg_close_9f2d9c9e61b826ae: function(arg0) {
             const ret = getObject(arg0).close();
             return addHeapObject(ret);
         },
-        __wbg_commit_786079320b8e0b9b: function(arg0) {
+        __wbg_commit_0426d36d5c3467bd: function(arg0) {
             const ret = getObject(arg0).commit();
             return addHeapObject(ret);
         },
@@ -894,11 +1045,11 @@ function __wbg_get_imports() {
             const ret = Reflect.construct(getObject(arg0), getObject(arg1));
             return addHeapObject(ret);
         }, arguments); },
-        __wbg_deleteMany_556f48be1c237ec7: function(arg0, arg1, arg2) {
+        __wbg_deleteMany_592dee42b3e47e6b: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).deleteMany(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
-        __wbg_deleteRange_7fdc05ce4261d0da: function(arg0, arg1, arg2) {
+        __wbg_deleteRange_e742782bb7dd946f: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).deleteRange(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
@@ -925,7 +1076,7 @@ function __wbg_get_imports() {
             const ret = Array.from(getObject(arg0));
             return addHeapObject(ret);
         },
-        __wbg_getMany_235250e3424e09ca: function(arg0, arg1) {
+        __wbg_getMany_954f9ded5c747f31: function(arg0, arg1) {
             const ret = getObject(arg0).getMany(takeObject(arg1));
             return addHeapObject(ret);
         },
@@ -1050,7 +1201,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_95814(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_99619(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1080,7 +1231,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_95814(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_99619(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1091,7 +1242,7 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
-        __wbg_nextPage_13fba4fc5bb93a4e: function(arg0, arg1) {
+        __wbg_nextPage_0f9d04d46afb4abb: function(arg0, arg1) {
             const ret = getObject(arg0).nextPage(arg1 >>> 0);
             return addHeapObject(ret);
         },
@@ -1130,7 +1281,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).push(getObject(arg1));
             return ret;
         },
-        __wbg_putMany_899cb0bea0c14903: function(arg0, arg1, arg2) {
+        __wbg_putMany_ee434f7186403754: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).putMany(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
@@ -1141,15 +1292,15 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).queueMicrotask;
             return addHeapObject(ret);
         },
-        __wbg_replaceMany_cc9b2f5513501e0c: function(arg0, arg1, arg2) {
-            const ret = getObject(arg0).replaceMany(takeObject(arg1), takeObject(arg2));
+        __wbg_ready_6d4eba7d7a164914: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).ready;
             return addHeapObject(ret);
-        },
+        }, arguments); },
         __wbg_resolve_25a7e548d5881dca: function(arg0) {
             const ret = Promise.resolve(getObject(arg0));
             return addHeapObject(ret);
         },
-        __wbg_rollback_32c62a16e328ea97: function(arg0) {
+        __wbg_rollback_4951ba72d8d65007: function(arg0) {
             const ret = getObject(arg0).rollback();
             return addHeapObject(ret);
         },
@@ -1233,23 +1384,23 @@ function __wbg_get_imports() {
             const ret = WasmRemoteObserveEvents.__wrap(arg0);
             return addHeapObject(ret);
         },
-        __wbg_watchForChanges_1a153bdf7830e63a: function(arg0) {
+        __wbg_watchForChanges_aadd2b8cd4d55844: function(arg0) {
             const ret = getObject(arg0).watchForChanges();
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1312, ret: NamedExternref("Promise<any>"), inner_ret: Some(NamedExternref("Promise<any>")) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_17860);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1996, ret: NamedExternref("Promise<any>"), inner_ret: Some(NamedExternref("Promise<any>")) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_20812);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 21212, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_95812);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 21938, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_99617);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 1311, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_17859);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 1995, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_20811);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000004: function(arg0) {
@@ -1298,19 +1449,19 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_17859(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_17859(arg0, arg1);
+function __wasm_bindgen_func_elem_20811(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_20811(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_17860(arg0, arg1, arg2) {
-    const ret = wasm.__wasm_bindgen_func_elem_17860(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_20812(arg0, arg1, arg2) {
+    const ret = wasm.__wasm_bindgen_func_elem_20812(arg0, arg1, addHeapObject(arg2));
     return takeObject(ret);
 }
 
-function __wasm_bindgen_func_elem_95812(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_99617(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_95812(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_99617(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -1321,10 +1472,13 @@ function __wasm_bindgen_func_elem_95812(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_95814(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_95814(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_99619(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_99619(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
+const BrowserComponentHostFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_browsercomponenthost_free(ptr, 1));
 const WasmLixFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmlix_free(ptr, 1));

package/dist/wasm/lix_js_sdk_bg.wasm

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/wasm/lix_js_sdk_bg.wasm
-size: 44138202 bytes
-sha256: 88485ec491a36d8722b343becd7a04d6e688fb919e37126174b16f0098f2b664
+size: 51272624 bytes
+sha256: 1b1a35b55d02451dc8ef2c418bf9b9a3e55733ad7e73cc39ecaf1bda88f11661

package/dist/wasm/lix_js_sdk_bg.wasm.d.ts

@@ -1,6 +1,7 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_browsercomponenthost_free: (a: number, b: number) => void;
 export const __wbg_wasmlix_free: (a: number, b: number) => void;
 export const __wbg_wasmlixtransaction_free: (a: number, b: number) => void;
 export const __wbg_wasmobserveevents_free: (a: number, b: number) => void;
@@ -9,13 +10,16 @@ export const __wbg_wasmremotelixtransaction_free: (a: number, b: number) => void
 export const __wbg_wasmremoteobserveevents_free: (a: number, b: number) => void;
 export const __wbg_wasmsnapshotexport_free: (a: number, b: number) => void;
 export const __wbg_wasmsnapshotrestore_free: (a: number, b: number) => void;
+export const browsercomponenthost_call: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const createHosted: (a: number) => number;
 export const deleteHosted: (a: number) => number;
-export const openJsStorage: (a: number, b: number, c: number, d: number, e: number) => number;
-export const openJsStorageFromSnapshot: (a: number, b: number, c: number, d: number) => number;
-export const openMemory: (a: number, b: number, c: number, d: number) => number;
-export const openMemoryFromSnapshot: (a: number, b: number, c: number) => number;
+export const inspectJsStorageRepository: (a: number) => number;
+export const openJsStorage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+export const openJsStorageFromSnapshot: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+export const openMemory: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+export const openMemoryFromSnapshot: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
 export const openRemote: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const parseSqlScript: (a: number, b: number, c: number, d: number) => void;
 export const wasmlix_activeAccountId: (a: number) => number;
 export const wasmlix_activeBranchId: (a: number) => number;
 export const wasmlix_beginTransaction: (a: number) => number;
@@ -30,14 +34,16 @@ export const wasmlix_importFilesystemPaths: (a: number, b: number) => number;
 export const wasmlix_mergeBranch: (a: number, b: number) => number;
 export const wasmlix_mergeBranchPreview: (a: number, b: number) => number;
 export const wasmlix_observe: (a: number, b: number, c: number, d: number) => number;
-export const wasmlix_openAnotherSession: (a: number, b: number) => number;
+export const wasmlix_openAnotherSession: (a: number, b: number, c: number) => number;
 export const wasmlix_openReport: (a: number, b: number) => void;
 export const wasmlix_recoverReplica: (a: number, b: number, c: number) => number;
+export const wasmlix_recoverReplicaWithServer: (a: number, b: number, c: number, d: number) => number;
 export const wasmlix_redo: (a: number) => number;
 export const wasmlix_replicaRecoverySources: (a: number) => number;
 export const wasmlix_setTelemetryParent: (a: number, b: number, c: number) => void;
 export const wasmlix_switchBranch: (a: number, b: number) => number;
 export const wasmlix_syncDiskToLix: (a: number) => number;
+export const wasmlix_syncHealth: (a: number) => number;
 export const wasmlix_undo: (a: number) => number;
 export const wasmlixtransaction_commit: (a: number) => number;
 export const wasmlixtransaction_execute: (a: number, b: number, c: number, d: number, e: number) => number;
@@ -60,11 +66,13 @@ export const wasmremotelix_mergeBranchPreview: (a: number, b: number) => number;
 export const wasmremotelix_observe: (a: number, b: number, c: number, d: number) => number;
 export const wasmremotelix_openAnotherSession: (a: number, b: number) => number;
 export const wasmremotelix_recoverReplica: (a: number, b: number, c: number) => number;
+export const wasmremotelix_recoverReplicaWithServer: (a: number, b: number, c: number, d: number) => number;
 export const wasmremotelix_redo: (a: number) => number;
 export const wasmremotelix_replicaRecoverySources: (a: number) => number;
 export const wasmremotelix_setTelemetryParent: (a: number, b: number) => void;
 export const wasmremotelix_switchBranch: (a: number, b: number) => number;
 export const wasmremotelix_syncDiskToLix: (a: number) => number;
+export const wasmremotelix_syncHealth: (a: number) => number;
 export const wasmremotelix_undo: (a: number) => number;
 export const wasmremotelixtransaction_commit: (a: number) => number;
 export const wasmremotelixtransaction_execute: (a: number, b: number, c: number, d: number, e: number) => number;
@@ -78,10 +86,10 @@ export const wasmsnapshotrestore_cancel: (a: number) => number;
 export const wasmsnapshotrestore_finish: (a: number) => number;
 export const wasmsnapshotrestore_isComplete: (a: number) => number;
 export const wasmsnapshotrestore_write: (a: number, b: number, c: number) => number;
-export const __wasm_bindgen_func_elem_95812: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_95814: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_17860: (a: number, b: number, c: number) => number;
-export const __wasm_bindgen_func_elem_17859: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_99617: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_99619: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_20812: (a: number, b: number, c: number) => number;
+export const __wasm_bindgen_func_elem_20811: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;

package/dist/worker/client.d.ts

@@ -1,7 +1,10 @@
+import { type HttpTransport } from "../http-transport.js";
 import type { LixBinding, LixStorageConfig } from "../binding-types.js";
 import type { LixTelemetryOptions, LixOpenProgress, LixOpenReport, LixServerOptions } from "../types.js";
-import { type WorkerConnection, type WorkerNotification, type WorkerOperation } from "./protocol.js";
-type SyncServerRuntimeOptions = LixServerOptions;
+import { type WorkerConnection, type WorkerNotification, type WorkerOperation, type WorkerSyncServerOptions } from "./protocol.js";
+type SyncServerRuntimeOptions = LixServerOptions & {
+    transport?: HttpTransport;
+};
 export declare function openLixWorker(storage: LixStorageConfig, onDisposed?: () => void, telemetry?: LixTelemetryOptions, server?: SyncServerRuntimeOptions, onProgress?: (progress: LixOpenProgress) => void, snapshot?: ReadableStream<Uint8Array>): Promise<LixWorkerClient>;
 export declare function pumpSnapshotToWorker(client: LixWorkerClient, reader: ReadableStreamDefaultReader<Uint8Array>, snapshotId: number, open: Promise<unknown>): Promise<void>;
 /** Opens the local worker transport behind the semantic Lix binding. */
@@ -18,6 +21,7 @@ export declare class BindingLease {
 export declare function workerBinding(client: LixWorkerClient, lease: BindingLease, sessionId: number): LixBinding;
 export declare class LixWorkerClient {
     private readonly connection;
+    readonly reusable: boolean;
     private nextRequestId;
     private nextSnapshotInputId;
     private readonly pending;
@@ -26,11 +30,14 @@ export declare class LixWorkerClient {
     private onDisposed?;
     private telemetry?;
     private syncServer?;
+    private scopedServers;
+    private nextTransportScope;
+    withRecoveryServer<T>(server: import("../binding-types.js").SyncServerBindingOptions, operation: (scope: number, server: WorkerSyncServerOptions) => Promise<T>): Promise<T>;
     private onProgress?;
     openReport: LixOpenReport | undefined;
     private readonly syncFetchControllers;
     private readonly syncFetchStreams;
-    constructor(connection?: WorkerConnection);
+    constructor(connection?: WorkerConnection, reusable?: boolean);
     get isDisposed(): boolean;
     allocateSnapshotInputId(): number;
     beginLease(onDisposed?: () => void, telemetry?: LixTelemetryOptions, syncServer?: SyncServerRuntimeOptions, onProgress?: (progress: LixOpenProgress) => void): void;
@@ -51,4 +58,6 @@ export declare class LixWorkerClient {
 export declare function hostedLixWorkerOperation<T>(operation: Extract<WorkerOperation, {
     kind: "hosted.create" | "hosted.delete";
 }>): Promise<T>;
+export declare function convertReplicaWorkerOperation(storage: LixStorageConfig, server: SyncServerRuntimeOptions, branchId?: string): Promise<void>;
+export declare function retryReplicaMigrationCleanupWorkerOperation(storage: LixStorageConfig, server: SyncServerRuntimeOptions): Promise<number>;
 export {};