@lix-js/sdk 0.15.1 → 0.16.1

package/dist/types.d.ts

@@ -1,24 +1,22 @@
 export type RemoteLixFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-export type RemoteLixServerOptions = {
-    mode: "remote";
-    /** Stable HTTPS locator whose path is exactly `/lix/{uuid}`. HTTP is loopback-only. */
+/** A Lix protocol endpoint. Host URL for creation; repository URL for opening/deletion. */
+export type LixServerOptions = {
     url: string | URL;
     headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
     fetch?: RemoteLixFetch;
 };
-/**
- * Opens a local native replica that synchronizes with the server in the
- * background. Sync mode keeps the normal local storage/read path and works
- * with browser storage such as OPFS as well as native storage.
- */
-export type SyncLixServerOptions = {
-    mode: "sync";
-    /** Stable HTTPS locator whose path is exactly `/lix/{uuid}`. HTTP is loopback-only. */
-    url: string | URL;
-    /** Resolved for every browser sync request, including reconnect handshakes. */
-    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
-    /** Browser fetch override. Functions cross the worker boundary through RPC. */
-    fetch?: RemoteLixFetch;
+export type HostedLix = {
+    id: string;
+    url: string;
+};
+export type CreateLixOptions = {
+    /** Reuse this key when retrying a creation whose outcome was uncertain. */
+    idempotencyKey?: string;
+    server: Pick<LixServerOptions, "url" | "headers">;
+    from?: import("./lix.js").Lix;
+};
+export type DeleteLixOptions = {
+    server: Pick<LixServerOptions, "url" | "headers">;
 };
 export type LixTelemetrySpanLink = {
     traceId: string;
@@ -77,24 +75,80 @@ export type LixOpenReport = {
     initialized: boolean;
     migration?: LixOpenMigrationReport;
 };
+/** A retained local generation. Presence does not mean recovery is complete. */
+export type ReplicaRecoverySource = {
+    id: string;
+    sourceFormat: number;
+    repositoryId: string;
+    accountId: string;
+    recoveryRequired: boolean;
+};
+export type ReplicaRecoveryRow = {
+    rowPk: JsonValue;
+    schemaKey: string;
+    fileId: string | null;
+    snapshot: JsonValue;
+    metadata: JsonValue;
+    deleted: boolean;
+    untracked: boolean;
+    global: boolean;
+    changeId: string | null;
+    commitId: string | null;
+};
+export type ReplicaRecoveryBranch = {
+    branchId: string;
+    headCommitId: string;
+    checkpointCommitId: string | null;
+    rows: ReplicaRecoveryRow[];
+};
+export type ReplicaRecoveryBlob = {
+    id: string;
+    contentBase64: string;
+};
+export type ReplicaRecoveryFile = {
+    branchId: string;
+    id: string;
+    path: string;
+    untracked: boolean;
+    blobId: string | null;
+};
+/** Portable recovery data; unresolved entries identify data not reconstructed. */
+export type ReplicaRecoveryExport = {
+    version: number;
+    source: ReplicaRecoverySource;
+    branches: ReplicaRecoveryBranch[];
+    commits: JsonValue[];
+    uploads: JsonValue[];
+    blobs: ReplicaRecoveryBlob[];
+    files: ReplicaRecoveryFile[];
+    unresolved: string[];
+};
+/** Local recovery result. This does not acknowledge durable server storage. */
+export type ReplicaRecoveryReceipt = {
+    branchIds: string[];
+    restoredFiles: number;
+    restoredRows: number;
+    unresolved: string[];
+};
 export type LixOpenProgressOptions = {
     /** Observes local inspection, automatic migration, and opening. */
     onProgress?(progress: LixOpenProgress): void;
 };
-export type OpenLixOptions = {
+/** No options: memory. Storage: local. Server: remote. Storage + server: sync. */
+export type OpenLixOptions = ({
     storage?: import("./storage-adapter.js").LixStorage;
     server?: never;
     telemetry?: LixTelemetryOptions;
-} & LixOpenProgressOptions | {
+} & LixOpenProgressOptions) | {
     storage?: never;
-    server: RemoteLixServerOptions;
+    server: LixServerOptions;
     telemetry?: never;
     onProgress?: never;
-} | {
+} | ({
     storage: import("./storage-adapter.js").LixStorage;
-    server: SyncLixServerOptions;
+    server: LixServerOptions;
     telemetry?: LixTelemetryOptions;
-} & LixOpenProgressOptions;
+} & LixOpenProgressOptions);
 /** Selects the initial context for an additional independent session. */
 export type OpenAnotherSessionOptions = {
     /** Defaults to the current branch of the session opening it. */
@@ -165,6 +219,18 @@ export type ResultColumn = {
 export type ResultObjectRow = Record<string, unknown>;
 export type ResultArrayRow = unknown[];
 export type ResultRow = ResultObjectRow | ResultArrayRow;
+/**
+ * The active-branch commits a write moved between.
+ *
+ * `before` is the active branch's head before the write and `after` the head
+ * it published, so `lix_diff('lix_file', before, after)` is exactly what the
+ * write changed. A write that published no commit on the active branch
+ * reports both ids equal; a restore reports the commit it moved the head to.
+ */
+export type CommitSpan = {
+    before: string;
+    after: string;
+};
 export type ExecuteResult<TRow extends object = ResultObjectRow> = {
     statementIndex?: number;
     label?: string;
@@ -176,6 +242,15 @@ export type ExecuteResult<TRow extends object = ResultObjectRow> = {
         message: string;
         hint?: string;
     }>;
+    /**
+     * Present on every auto-committed write statement, including `RETURNING`
+     * writes, and on every statement of a written batch (all carry the
+     * batch's one span, read statements included). Absent for read
+     * statements outside a written batch, read-only batches, statements
+     * inside an explicit transaction (whose commit is the write), and the
+     * first commit on a branch that had no head yet.
+     */
+    commit?: CommitSpan;
 };
 export type ExecuteBatchResult<TRow extends object = ResultObjectRow> = ExecuteResult<TRow> & {
     statementIndex: number;

package/dist/wasm/lix_js_sdk.d.ts

@@ -10,8 +10,10 @@ export class WasmLix {
     beginTransaction(): Promise<WasmLixTransaction>;
     close(): Promise<void>;
     createBranch(options: any): Promise<any>;
+    createHosted(server: any): Promise<any>;
     execute(sql: string, params: any, options?: any | null): Promise<any>;
     executeBatch(statements: any, options?: any | null): Promise<any>;
+    exportReplicaRecovery(id: string): Promise<any>;
     exportSnapshot(): WasmSnapshotExport;
     importFilesystemPaths(_paths: any): Promise<void>;
     mergeBranch(options: any): Promise<any>;
@@ -19,7 +21,9 @@ export class WasmLix {
     observe(sql: string, params: any): Promise<WasmObserveEvents>;
     openAnotherSession(options: any): Promise<WasmLix>;
     openReport(): any;
+    recoverReplica(id: string): Promise<any>;
     redo(): Promise<any>;
+    replicaRecoverySources(): Promise<any>;
     setTelemetryParent(parent?: any | null): void;
     switchBranch(options: any): Promise<any>;
     syncDiskToLix(): Promise<void>;
@@ -55,13 +59,16 @@ export class WasmRemoteLix {
     createBranch(options: any): Promise<any>;
     execute(sql: string, params: any, options?: any | null): Promise<any>;
     executeBatch(statements: any, options?: any | null): Promise<any>;
+    exportReplicaRecovery(_id: string): Promise<any>;
     exportSnapshot(): WasmSnapshotExport;
     importFilesystemPaths(_paths: any): Promise<void>;
     mergeBranch(options: any): Promise<any>;
     mergeBranchPreview(options: any): Promise<any>;
     observe(sql: string, params: any): Promise<WasmRemoteObserveEvents>;
     openAnotherSession(options: any): Promise<WasmRemoteLix>;
+    recoverReplica(_id: string): Promise<any>;
     redo(): Promise<any>;
+    replicaRecoverySources(): Promise<any>;
     setTelemetryParent(_parent?: any | null): void;
     switchBranch(options: any): Promise<any>;
     syncDiskToLix(): Promise<void>;
@@ -104,6 +111,10 @@ export class WasmSnapshotRestore {
     write(chunk: Uint8Array): Promise<void>;
 }
 
+export function createHosted(server: any): Promise<any>;
+
+export function deleteHosted(server: any): Promise<void>;
+
 export function openJsStorage(provider: any, telemetry_dispatch?: Function | null, telemetry_parent?: any | null, server?: any | null, open_progress_dispatch?: Function | null): Promise<WasmLix>;
 
 export function openJsStorageFromSnapshot(provider: any, telemetry_dispatch?: Function | null, telemetry_parent?: any | null, open_progress_dispatch?: Function | null): WasmSnapshotRestore;
@@ -126,6 +137,8 @@ export interface InitOutput {
     readonly __wbg_wasmremoteobserveevents_free: (a: number, b: number) => void;
     readonly __wbg_wasmsnapshotexport_free: (a: number, b: number) => void;
     readonly __wbg_wasmsnapshotrestore_free: (a: number, b: number) => void;
+    readonly createHosted: (a: number) => number;
+    readonly deleteHosted: (a: number) => number;
     readonly openJsStorage: (a: number, b: number, c: number, d: number, e: number) => number;
     readonly openJsStorageFromSnapshot: (a: number, b: number, c: number, d: number) => number;
     readonly openMemory: (a: number, b: number, c: number, d: number) => number;
@@ -136,8 +149,10 @@ export interface InitOutput {
     readonly wasmlix_beginTransaction: (a: number) => number;
     readonly wasmlix_close: (a: number) => number;
     readonly wasmlix_createBranch: (a: number, b: number) => number;
+    readonly wasmlix_createHosted: (a: number, b: number) => number;
     readonly wasmlix_execute: (a: number, b: number, c: number, d: number, e: number) => number;
     readonly wasmlix_executeBatch: (a: number, b: number, c: number) => number;
+    readonly wasmlix_exportReplicaRecovery: (a: number, b: number, c: number) => number;
     readonly wasmlix_exportSnapshot: (a: number) => number;
     readonly wasmlix_importFilesystemPaths: (a: number, b: number) => number;
     readonly wasmlix_mergeBranch: (a: number, b: number) => number;
@@ -145,7 +160,9 @@ export interface InitOutput {
     readonly wasmlix_observe: (a: number, b: number, c: number, d: number) => number;
     readonly wasmlix_openAnotherSession: (a: number, b: number) => number;
     readonly wasmlix_openReport: (a: number, b: number) => void;
+    readonly wasmlix_recoverReplica: (a: number, b: number, c: number) => number;
     readonly wasmlix_redo: (a: number) => number;
+    readonly wasmlix_replicaRecoverySources: (a: number) => number;
     readonly wasmlix_setTelemetryParent: (a: number, b: number, c: number) => void;
     readonly wasmlix_switchBranch: (a: number, b: number) => number;
     readonly wasmlix_syncDiskToLix: (a: number) => number;
@@ -163,13 +180,16 @@ export interface InitOutput {
     readonly wasmremotelix_createBranch: (a: number, b: number) => number;
     readonly wasmremotelix_execute: (a: number, b: number, c: number, d: number, e: number) => number;
     readonly wasmremotelix_executeBatch: (a: number, b: number, c: number) => number;
+    readonly wasmremotelix_exportReplicaRecovery: (a: number, b: number, c: number) => number;
     readonly wasmremotelix_exportSnapshot: (a: number) => number;
     readonly wasmremotelix_importFilesystemPaths: (a: number, b: number) => number;
     readonly wasmremotelix_mergeBranch: (a: number, b: number) => number;
     readonly wasmremotelix_mergeBranchPreview: (a: number, b: number) => number;
     readonly wasmremotelix_observe: (a: number, b: number, c: number, d: number) => number;
     readonly wasmremotelix_openAnotherSession: (a: number, b: number) => number;
+    readonly wasmremotelix_recoverReplica: (a: number, b: number, c: number) => number;
     readonly wasmremotelix_redo: (a: number) => number;
+    readonly wasmremotelix_replicaRecoverySources: (a: number) => number;
     readonly wasmremotelix_setTelemetryParent: (a: number, b: number) => void;
     readonly wasmremotelix_switchBranch: (a: number, b: number) => number;
     readonly wasmremotelix_syncDiskToLix: (a: number) => number;
@@ -186,9 +206,10 @@ export interface InitOutput {
     readonly wasmsnapshotrestore_finish: (a: number) => number;
     readonly wasmsnapshotrestore_isComplete: (a: number) => number;
     readonly wasmsnapshotrestore_write: (a: number, b: number, c: number) => number;
-    readonly __wasm_bindgen_func_elem_92636: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_92638: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_16813: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_95812: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_95814: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_17860: (a: number, b: number, c: number) => number;
+    readonly __wasm_bindgen_func_elem_17859: (a: number, b: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/dist/wasm/lix_js_sdk.js

@@ -53,6 +53,14 @@ export class WasmLix {
         const ret = wasm.wasmlix_createBranch(this.__wbg_ptr, addHeapObject(options));
         return takeObject(ret);
     }
+    /**
+     * @param {any} server
+     * @returns {Promise<any>}
+     */
+    createHosted(server) {
+        const ret = wasm.wasmlix_createHosted(this.__wbg_ptr, addHeapObject(server));
+        return takeObject(ret);
+    }
     /**
      * @param {string} sql
      * @param {any} params
@@ -74,6 +82,16 @@ export class WasmLix {
         const ret = wasm.wasmlix_executeBatch(this.__wbg_ptr, addHeapObject(statements), isLikeNone(options) ? 0 : addHeapObject(options));
         return takeObject(ret);
     }
+    /**
+     * @param {string} id
+     * @returns {Promise<any>}
+     */
+    exportReplicaRecovery(id) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmlix_exportReplicaRecovery(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
     /**
      * @returns {WasmSnapshotExport}
      */
@@ -142,6 +160,16 @@ export class WasmLix {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @param {string} id
+     * @returns {Promise<any>}
+     */
+    recoverReplica(id) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmlix_recoverReplica(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
     /**
      * @returns {Promise<any>}
      */
@@ -149,6 +177,13 @@ export class WasmLix {
         const ret = wasm.wasmlix_redo(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * @returns {Promise<any>}
+     */
+    replicaRecoverySources() {
+        const ret = wasm.wasmlix_replicaRecoverySources(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * @param {any | null} [parent]
      */
@@ -356,6 +391,16 @@ export class WasmRemoteLix {
         const ret = wasm.wasmremotelix_executeBatch(this.__wbg_ptr, addHeapObject(statements), isLikeNone(options) ? 0 : addHeapObject(options));
         return takeObject(ret);
     }
+    /**
+     * @param {string} _id
+     * @returns {Promise<any>}
+     */
+    exportReplicaRecovery(_id) {
+        const ptr0 = passStringToWasm0(_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmremotelix_exportReplicaRecovery(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
     /**
      * @returns {WasmSnapshotExport}
      */
@@ -406,6 +451,16 @@ export class WasmRemoteLix {
         const ret = wasm.wasmremotelix_openAnotherSession(this.__wbg_ptr, addHeapObject(options));
         return takeObject(ret);
     }
+    /**
+     * @param {string} _id
+     * @returns {Promise<any>}
+     */
+    recoverReplica(_id) {
+        const ptr0 = passStringToWasm0(_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmremotelix_recoverReplica(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
     /**
      * @returns {Promise<any>}
      */
@@ -413,6 +468,13 @@ export class WasmRemoteLix {
         const ret = wasm.wasmremotelix_redo(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * @returns {Promise<any>}
+     */
+    replicaRecoverySources() {
+        const ret = wasm.wasmremotelix_replicaRecoverySources(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * @param {any | null} [_parent]
      */
@@ -611,6 +673,24 @@ export class WasmSnapshotRestore {
 }
 if (Symbol.dispose) WasmSnapshotRestore.prototype[Symbol.dispose] = WasmSnapshotRestore.prototype.free;
 
+/**
+ * @param {any} server
+ * @returns {Promise<any>}
+ */
+export function createHosted(server) {
+    const ret = wasm.createHosted(addHeapObject(server));
+    return takeObject(ret);
+}
+
+/**
+ * @param {any} server
+ * @returns {Promise<void>}
+ */
+export function deleteHosted(server) {
+    const ret = wasm.deleteHosted(addHeapObject(server));
+    return takeObject(ret);
+}
+
 /**
  * @param {any} provider
  * @param {Function | null} [telemetry_dispatch]
@@ -767,19 +847,19 @@ function __wbg_get_imports() {
         __wbg__wbg_cb_unref_61db23ac97f16c31: function(arg0) {
             getObject(arg0)._wbg_cb_unref();
         },
-        __wbg_acquireSession_4217826058465f0a: function(arg0) {
+        __wbg_acquireSession_23e79c33392e697b: function(arg0) {
             const ret = getObject(arg0).acquireSession();
             return addHeapObject(ret);
         },
-        __wbg_beginRead_94ff94b93b664ae5: function(arg0, arg1) {
+        __wbg_beginRead_a07540d6b7276aa8: function(arg0, arg1) {
             const ret = getObject(arg0).beginRead(takeObject(arg1));
             return addHeapObject(ret);
         },
-        __wbg_beginScan_51d1ffb7b76bed05: function(arg0, arg1, arg2, arg3) {
+        __wbg_beginScan_fe1d6b306d24f1d8: function(arg0, arg1, arg2, arg3) {
             const ret = getObject(arg0).beginScan(takeObject(arg1), takeObject(arg2), takeObject(arg3));
             return addHeapObject(ret);
         },
-        __wbg_beginWrite_57e757a92c7a162f: function(arg0, arg1) {
+        __wbg_beginWrite_accabb884da53d0d: function(arg0, arg1) {
             const ret = getObject(arg0).beginWrite(takeObject(arg1));
             return addHeapObject(ret);
         },
@@ -795,18 +875,18 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
         }, arguments); },
-        __wbg_changed_58ce3f6384cfabf1: function(arg0) {
+        __wbg_changed_611eb1bd688d481b: function(arg0) {
             const ret = getObject(arg0).changed();
             return addHeapObject(ret);
         },
-        __wbg_close_48f18a70bd365447: function(arg0) {
+        __wbg_close_312ad1c70f8567ec: function(arg0) {
             getObject(arg0).close();
         },
-        __wbg_close_c5652a29ac52dc7a: function(arg0) {
+        __wbg_close_60c048095d05207d: function(arg0) {
             const ret = getObject(arg0).close();
             return addHeapObject(ret);
         },
-        __wbg_commit_abef9a20db94a24b: function(arg0) {
+        __wbg_commit_786079320b8e0b9b: function(arg0) {
             const ret = getObject(arg0).commit();
             return addHeapObject(ret);
         },
@@ -814,11 +894,11 @@ function __wbg_get_imports() {
             const ret = Reflect.construct(getObject(arg0), getObject(arg1));
             return addHeapObject(ret);
         }, arguments); },
-        __wbg_deleteMany_fba03247e38ecd66: function(arg0, arg1, arg2) {
+        __wbg_deleteMany_556f48be1c237ec7: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).deleteMany(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
-        __wbg_deleteRange_d3f785b237515ef2: function(arg0, arg1, arg2) {
+        __wbg_deleteRange_7fdc05ce4261d0da: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).deleteRange(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
@@ -845,7 +925,7 @@ function __wbg_get_imports() {
             const ret = Array.from(getObject(arg0));
             return addHeapObject(ret);
         },
-        __wbg_getMany_274d167fafd6553d: function(arg0, arg1) {
+        __wbg_getMany_235250e3424e09ca: function(arg0, arg1) {
             const ret = getObject(arg0).getMany(takeObject(arg1));
             return addHeapObject(ret);
         },
@@ -970,7 +1050,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_92638(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_95814(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1000,7 +1080,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_92638(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_95814(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1011,7 +1091,7 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
-        __wbg_nextPage_2c82fda0921c8144: function(arg0, arg1) {
+        __wbg_nextPage_13fba4fc5bb93a4e: function(arg0, arg1) {
             const ret = getObject(arg0).nextPage(arg1 >>> 0);
             return addHeapObject(ret);
         },
@@ -1050,7 +1130,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).push(getObject(arg1));
             return ret;
         },
-        __wbg_putMany_232f0878d2013b1a: function(arg0, arg1, arg2) {
+        __wbg_putMany_899cb0bea0c14903: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).putMany(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
@@ -1061,7 +1141,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).queueMicrotask;
             return addHeapObject(ret);
         },
-        __wbg_replaceMany_79fe2cff87eae447: function(arg0, arg1, arg2) {
+        __wbg_replaceMany_cc9b2f5513501e0c: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).replaceMany(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
@@ -1069,7 +1149,7 @@ function __wbg_get_imports() {
             const ret = Promise.resolve(getObject(arg0));
             return addHeapObject(ret);
         },
-        __wbg_rollback_ff9a2e1df7d86a27: function(arg0) {
+        __wbg_rollback_32c62a16e328ea97: function(arg0) {
             const ret = getObject(arg0).rollback();
             return addHeapObject(ret);
         },
@@ -1153,46 +1233,51 @@ function __wbg_get_imports() {
             const ret = WasmRemoteObserveEvents.__wrap(arg0);
             return addHeapObject(ret);
         },
-        __wbg_watchForChanges_6e168a3d435984ae: function(arg0) {
+        __wbg_watchForChanges_1a153bdf7830e63a: 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: 21338, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_92636);
+            // 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);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 1647, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_16813);
+            // 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);
+            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);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000003: function(arg0) {
+        __wbindgen_cast_0000000000000004: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000004: function(arg0) {
+        __wbindgen_cast_0000000000000005: function(arg0) {
             // Cast intrinsic for `I64 -> Externref`.
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
             const ret = getArrayU8FromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000007: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000007: function(arg0) {
+        __wbindgen_cast_0000000000000008: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000009: function(arg0, arg1) {
             var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_export4(arg0, arg1 * 1, 1);
             // Cast intrinsic for `Vector(U8) -> Externref`.
@@ -1213,14 +1298,19 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_16813(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_16813(arg0, arg1);
+function __wasm_bindgen_func_elem_17859(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_17859(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_17860(arg0, arg1, arg2) {
+    const ret = wasm.__wasm_bindgen_func_elem_17860(arg0, arg1, addHeapObject(arg2));
+    return takeObject(ret);
 }
 
-function __wasm_bindgen_func_elem_92636(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_95812(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_92636(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_95812(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -1231,8 +1321,8 @@ function __wasm_bindgen_func_elem_92636(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_92638(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_92638(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_95814(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_95814(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const WasmLixFinalization = (typeof FinalizationRegistry === 'undefined')