@lix-js/sdk 0.9.0 → 0.11.0

package/dist/remote/client.js

@@ -1,8 +1,9 @@
-import { decodeExecuteResult, decodeHandshake, decodeObserveEvent, encodeWireValue, errorFromResponseBody, protocolError, record, REMOTE_PROTOCOL_PATH, remoteError, } from "./protocol.js";
+import { decodeExecuteBatchResult, decodeExecuteResult, decodeHandshake, decodeObserveEvent, encodeWireValue, errorFromResponseBody, protocolError, record, REMOTE_PROTOCOL_PATH, remoteError, } from "./protocol.js";
 import { readSseEvents } from "./sse.js";
 const OBSERVE_RETRY_BASE_MS = 100;
 const OBSERVE_RETRY_MAX_MS = 5_000;
 const REMOTE_SESSION_HEADER = "Lix-Session-Id";
+const REMOTE_TRANSACTION_HEADER = "Lix-Transaction-Id";
 const IDEMPOTENCY_KEY_HEADER = "Idempotency-Key";
 const REQUEST_BLOB_DELTA_MIN_BYTES = 32 * 1024;
 const REQUEST_BLOB_DELTA_MIN_WIRE_RATIO = 0.9;
@@ -31,10 +32,12 @@ class RemoteLixBinding {
     #fetch;
     #headers;
     #initialActiveBranchId;
+    #initialActiveAccountId;
     #observationHub;
     #requestBlobBases = new Map();
     #sessionId;
     #activeBranchId;
+    #activeAccountId;
     #requestBlobBaseBytes = 0;
     #acceptingOperations = true;
     #operationQueue = Promise.resolve();
@@ -63,17 +66,29 @@ class RemoteLixBinding {
             throw new TypeError("initialActiveBranchId must be a non-empty string");
         }
         this.#initialActiveBranchId = clientOptions.initialActiveBranchId;
+        if (clientOptions.initialActiveAccountId !== undefined &&
+            clientOptions.initialActiveAccountId.length === 0) {
+            throw new TypeError("initialActiveAccountId must be a non-empty string");
+        }
+        this.#initialActiveAccountId = clientOptions.initialActiveAccountId;
         this.#observationHub = new RemoteObservationHub({
             openStream: (subscriptions, signal) => this.#requestObserveStream(subscriptions, signal),
+            refreshObservation: (subscription) => this.#refreshObservation(subscription),
         });
     }
     async open() {
-        const path = this.#initialActiveBranchId === undefined
-            ? ""
-            : `?activeBranchId=${encodeURIComponent(this.#initialActiveBranchId)}`;
+        const query = new URLSearchParams();
+        if (this.#initialActiveBranchId !== undefined) {
+            query.set("activeBranchId", this.#initialActiveBranchId);
+        }
+        if (this.#initialActiveAccountId !== undefined) {
+            query.set("activeAccountId", this.#initialActiveAccountId);
+        }
+        const path = query.size === 0 ? "" : `?${query}`;
         const handshake = decodeHandshake(await this.#requestJson(path, { method: "GET" }));
         this.#sessionId = handshake.sessionId;
         this.#activeBranchId = handshake.activeBranchId;
+        this.#activeAccountId = handshake.activeAccountId;
     }
     async execute(sql, params, options) {
         this.#assertOpen();
@@ -105,10 +120,12 @@ class RemoteLixBinding {
         const snapshot = statements.map((statement) => ({
             sql: statement.sql,
             params: snapshotParams(statement.params),
+            ...(statement.label === undefined ? {} : { label: statement.label }),
         }));
         return this.#enqueue(async () => {
             const preparedStatements = await Promise.all(snapshot.map(async (statement, statementIndex) => ({
                 sql: statement.sql,
+                label: statement.label,
                 prepared: await this.#prepareParams(statement.params, (paramIndex) => requestBlobSlot("batch", statement.sql, paramIndex, statementIndex)),
             })));
             const cacheBlobs = preparedStatements.some((statement) => statement.prepared.cacheBlobs);
@@ -119,6 +136,9 @@ class RemoteLixBinding {
                 body: JSON.stringify({
                     statements: preparedStatements.map((statement) => ({
                         sql: statement.sql,
+                        ...(statement.label === undefined
+                            ? {}
+                            : { label: statement.label }),
                         params: full
                             ? statement.prepared.fullParams()
                             : statement.prepared.params,
@@ -131,7 +151,7 @@ class RemoteLixBinding {
             if (!Array.isArray(value)) {
                 throw protocolError("execute batch response must be an array");
             }
-            const results = value.map(decodeExecuteResult);
+            const results = value.map(decodeExecuteBatchResult);
             this.#commitRequestBlobBases(preparedStatements.flatMap((statement) => statement.prepared.cacheUpdates));
             return results;
         });
@@ -142,7 +162,62 @@ class RemoteLixBinding {
     }
     async beginTransaction() {
         this.#assertOpen();
-        throw unsupportedRemoteOperation("beginTransaction");
+        return this.#enqueue(async () => {
+            const begun = record(await this.#requestJson("transaction/begin", { method: "POST" }), "begin transaction response");
+            if (typeof begun.transactionId !== "string") {
+                throw protocolError("begin transaction response.transactionId must be a string");
+            }
+            const transactionId = begun.transactionId;
+            let active = true;
+            const assertActive = () => {
+                if (!active) {
+                    throw remoteError("LIX_INVALID_TRANSACTION_STATE", "Lix transaction is closed");
+                }
+            };
+            return {
+                execute: async (sql, params, options) => {
+                    assertActive();
+                    const snapshot = snapshotParams(params);
+                    const requestOptions = remoteExecuteOptions(options);
+                    return this.#enqueue(async () => {
+                        const value = await this.#requestJson("transaction/execute", {
+                            method: "POST",
+                            headers: { [REMOTE_TRANSACTION_HEADER]: transactionId },
+                            body: JSON.stringify({
+                                sql,
+                                params: snapshot.map(encodeWireValue),
+                                ...(requestOptions === undefined
+                                    ? {}
+                                    : { options: requestOptions }),
+                            }),
+                        });
+                        return decodeExecuteResult(value);
+                    });
+                },
+                commit: async () => {
+                    assertActive();
+                    return this.#enqueue(async () => {
+                        assertActive();
+                        await this.#requestJson("transaction/commit", {
+                            method: "POST",
+                            headers: { [REMOTE_TRANSACTION_HEADER]: transactionId },
+                        }, "empty");
+                        active = false;
+                    });
+                },
+                rollback: async () => {
+                    assertActive();
+                    return this.#enqueue(async () => {
+                        assertActive();
+                        await this.#requestJson("transaction/rollback", {
+                            method: "POST",
+                            headers: { [REMOTE_TRANSACTION_HEADER]: transactionId },
+                        }, "empty");
+                        active = false;
+                    });
+                },
+            };
+        });
     }
     async activeBranchId() {
         this.#assertOpen();
@@ -157,6 +232,19 @@ class RemoteLixBinding {
             return this.#activeBranchId;
         });
     }
+    async activeAccountId() {
+        this.#assertOpen();
+        return this.#enqueue(async () => {
+            if (this.#activeAccountId === undefined) {
+                const handshake = decodeHandshake(await this.#requestJson("", { method: "GET" }));
+                if (handshake.sessionId !== this.#sessionId) {
+                    throw protocolError("remote handshake changed sessionId");
+                }
+                this.#activeAccountId = handshake.activeAccountId;
+            }
+            return this.#activeAccountId;
+        });
+    }
     async createBranch(options) {
         this.#assertOpen();
         return this.#enqueue(async () => {
@@ -189,6 +277,38 @@ class RemoteLixBinding {
             return { commitId: value.commitId };
         });
     }
+    async undo() {
+        this.#assertOpen();
+        return this.#enqueue(async () => {
+            const value = record(await this.#requestJson("undo", { method: "POST" }), "undo response");
+            if (typeof value.branchId !== "string" ||
+                typeof value.targetCommitId !== "string" ||
+                typeof value.inverseCommitId !== "string") {
+                throw protocolError("undo response is invalid");
+            }
+            return {
+                branchId: value.branchId,
+                targetCommitId: value.targetCommitId,
+                inverseCommitId: value.inverseCommitId,
+            };
+        });
+    }
+    async redo() {
+        this.#assertOpen();
+        return this.#enqueue(async () => {
+            const value = record(await this.#requestJson("redo", { method: "POST" }), "redo response");
+            if (typeof value.branchId !== "string" ||
+                typeof value.targetCommitId !== "string" ||
+                typeof value.replayCommitId !== "string") {
+                throw protocolError("redo response is invalid");
+            }
+            return {
+                branchId: value.branchId,
+                targetCommitId: value.targetCommitId,
+                replayCommitId: value.replayCommitId,
+            };
+        });
+    }
     async switchBranch(options) {
         this.#assertOpen();
         return this.#enqueue(async () => {
@@ -328,6 +448,18 @@ class RemoteLixBinding {
             throw remoteError("LIX_REMOTE_UNAVAILABLE", "The remote Lix observation stream is unavailable", { details: { cause: errorMessage(cause) } });
         }
     }
+    async #refreshObservation(subscription) {
+        return this.#enqueue(async () => {
+            const value = await this.#requestJson("execute", {
+                method: "POST",
+                body: JSON.stringify({
+                    sql: subscription.sql,
+                    params: subscription.params,
+                }),
+            });
+            return decodeExecuteResult(value);
+        });
+    }
     async #prepareParams(params, slot) {
         const prepared = await Promise.all(params.map(async (param, index) => {
             if (param.kind !== "blob" ||
@@ -547,6 +679,7 @@ function copyArrayBuffer(bytes) {
 }
 class RemoteObservationHub {
     #openStream;
+    #refreshObservation;
     #observations = new Map();
     #nextObservationId = 0;
     #controller;
@@ -558,6 +691,7 @@ class RemoteObservationHub {
     #closed = false;
     constructor(options) {
         this.#openStream = options.openStream;
+        this.#refreshObservation = options.refreshObservation;
     }
     observe(sql, params) {
         const id = `observe-${++this.#nextObservationId}`;
@@ -629,6 +763,7 @@ class RemoteObservationHub {
             if (!this.#isCurrent(generation, controller))
                 return;
             streamOpened = true;
+            const initialSubscriptions = new Set(this.#observations.keys());
             if (!response.ok) {
                 if (isRetryableObserveStatus(response.status)) {
                     void response.body?.cancel();
@@ -667,7 +802,21 @@ class RemoteObservationHub {
                         const transportDelta = payload.delta !== undefined;
                         const event = decodeObserveEvent(payload, transportBases.get(subscriptionId));
                         transportBases.set(subscriptionId, event);
-                        observation.accept(event, transportDelta);
+                        if (initialSubscriptions.delete(subscriptionId)) {
+                            // The first frame after opening (including a reconnect) is a
+                            // synchronization point, not an authoritative snapshot. The
+                            // remote runtime may have observed the stream before its
+                            // external-storage watcher caught up. Reconcile through the
+                            // normal execute endpoint before publishing it to consumers.
+                            const rows = await this.#refreshObservation(observation.request());
+                            observation.accept({
+                                ...event,
+                                rows,
+                            }, false);
+                        }
+                        else {
+                            observation.accept(event, transportDelta);
+                        }
                         this.#retryAttempt = 0;
                     }
                     catch (error) {

package/dist/remote/protocol.d.ts

@@ -1,6 +1,6 @@
 import type { BindingExecuteResult, BindingObserveEvent } from "../binding-types.js";
 import type { NativeLixValue } from "../value.js";
-export declare const REMOTE_PROTOCOL_VERSION = 1;
+export declare const REMOTE_PROTOCOL_VERSION = 2;
 export declare const REMOTE_PROTOCOL_PATH = "/lix/v1/";
 export type WireValue = {
     kind: "null";
@@ -36,10 +36,12 @@ export type WireRequestValue = WireValue | WireRequestBlobSplice;
 export type RemoteHandshake = {
     protocolVersion: number;
     activeBranchId: string;
+    activeAccountId: string;
     sessionId: string;
 };
 export type RemoteHandshakeRequest = {
     activeBranchId?: string;
+    activeAccountId?: string;
 };
 export type RemoteExecuteRequest = {
     sql: string;
@@ -53,6 +55,7 @@ export type RemoteExecuteBatchRequest = {
     statements: Array<{
         sql: string;
         params: WireRequestValue[];
+        label?: string;
     }>;
     options?: {
         originKey?: string;
@@ -69,6 +72,10 @@ export type RemoteExecuteResponse = {
         hint?: string;
     }>;
 };
+export type RemoteExecuteBatchResponse = RemoteExecuteResponse & {
+    statementIndex: number;
+    label?: string;
+};
 export type RemoteObserveRequest = {
     sql: string;
     params: WireValue[];
@@ -122,6 +129,16 @@ export type RemoteCreateBranchResponse = {
 export type RemoteCreateCheckpointResponse = {
     commitId: string;
 };
+export type RemoteUndoResponse = {
+    branchId: string;
+    targetCommitId: string;
+    inverseCommitId: string;
+};
+export type RemoteRedoResponse = {
+    branchId: string;
+    targetCommitId: string;
+    replayCommitId: string;
+};
 export type RemoteSwitchBranchRequest = {
     branchId: string;
 };
@@ -144,6 +161,7 @@ export type RemoteMultiplexObserveErrorEvent = RemoteObserveErrorEvent & {
 };
 export declare function encodeWireValue(value: NativeLixValue): WireValue;
 export declare function decodeExecuteResult(value: unknown): BindingExecuteResult;
+export declare function decodeExecuteBatchResult(value: unknown): BindingExecuteResult;
 export declare function decodeHandshake(value: unknown): RemoteHandshake;
 export declare function decodeObserveEvent(value: unknown, base?: BindingObserveEvent): BindingObserveEvent;
 export declare function remoteError(code: string, message: string, options?: {

package/dist/remote/protocol.js

@@ -1,4 +1,4 @@
-export const REMOTE_PROTOCOL_VERSION = 1;
+export const REMOTE_PROTOCOL_VERSION = 2;
 export const REMOTE_PROTOCOL_PATH = "/lix/v1/";
 export function encodeWireValue(value) {
     switch (value.kind) {
@@ -57,6 +57,18 @@ export function decodeExecuteResult(value) {
     });
     return { columns, rows, rowsAffected: result.rowsAffected, notices };
 }
+export function decodeExecuteBatchResult(value) {
+    const result = record(value, "execute batch result");
+    const statementIndex = nonNegativeSafeInteger(result.statementIndex, "execute batch result statementIndex");
+    if (result.label !== undefined && typeof result.label !== "string") {
+        throw protocolError("execute batch result label must be a string when present");
+    }
+    return {
+        ...decodeExecuteResult(value),
+        statementIndex,
+        ...(result.label === undefined ? {} : { label: result.label }),
+    };
+}
 export function decodeHandshake(value) {
     const handshake = record(value, "remote handshake");
     if (handshake.protocolVersion !== REMOTE_PROTOCOL_VERSION) {
@@ -66,6 +78,10 @@ export function decodeHandshake(value) {
         handshake.activeBranchId.length === 0) {
         throw protocolError("remote handshake requires activeBranchId");
     }
+    if (typeof handshake.activeAccountId !== "string" ||
+        handshake.activeAccountId.length === 0) {
+        throw protocolError("remote handshake requires activeAccountId");
+    }
     if (typeof handshake.sessionId !== "string" ||
         !/^[\x21-\x7e]{1,256}$/.test(handshake.sessionId)) {
         throw protocolError("remote handshake requires a valid sessionId");
@@ -73,6 +89,7 @@ export function decodeHandshake(value) {
     return {
         protocolVersion: REMOTE_PROTOCOL_VERSION,
         activeBranchId: handshake.activeBranchId,
+        activeAccountId: handshake.activeAccountId,
         sessionId: handshake.sessionId,
     };
 }
@@ -127,7 +144,7 @@ function applyObserveBlobDelta(delta, sequence, base) {
     }
     const baseValue = base.rows.rows[0]?.[0];
     if (base.rows.columns.length !== 1 ||
-        base.rows.columns[0] !== "data" ||
+        base.rows.columns[0] !== "content" ||
         base.rows.rows.length !== 1 ||
         base.rows.rows[0]?.length !== 1 ||
         base.rows.rowsAffected !== 0 ||
@@ -154,7 +171,7 @@ function applyObserveBlobDelta(delta, sequence, base) {
     blob.set(insert, prefixBytes);
     blob.set(baseValue.blob.subarray(baseValue.blob.byteLength - suffixBytes), prefixBytes + insert.byteLength);
     return {
-        columns: ["data"],
+        columns: ["content"],
         rows: [[{ kind: "blob", value: null, blob }]],
         rowsAffected: 0,
         notices: [],

package/dist/result.d.ts

@@ -1,5 +1,5 @@
 import { type NativeLixValue, Value } from "./value.js";
-import type { ExecuteResult, LixValue } from "./types.js";
+import type { ExecuteBatchResult, ExecuteResult, LixValue } from "./types.js";
 export declare class Row {
     private readonly columns;
     private readonly values;
@@ -14,5 +14,6 @@ type NativeExecuteResult = Omit<ExecuteResult, "rows"> & {
     rows: NativeLixValue[][];
 };
 export declare function wrapExecuteResult(result: NativeExecuteResult): ExecuteResult;
+export declare function wrapExecuteBatchResult(result: NativeExecuteResult): ExecuteBatchResult;
 export declare function normalizeOptionals<T>(value: T): T;
 export {};

package/dist/result.js

@@ -36,6 +36,18 @@ export function wrapExecuteResult(result) {
         rows: result.rows.map((row) => Row.fromRaw(result.columns, row.map(fromNativeValue))),
     };
 }
+export function wrapExecuteBatchResult(result) {
+    const statementIndex = result.statementIndex;
+    if (typeof statementIndex !== "number" ||
+        !Number.isSafeInteger(statementIndex) ||
+        statementIndex < 0) {
+        throw new Error("executeBatch result is missing a valid statementIndex");
+    }
+    return {
+        ...wrapExecuteResult(result),
+        statementIndex,
+    };
+}
 export function normalizeOptionals(value) {
     if (Array.isArray(value))
         return value.map(normalizeOptionals);

package/dist/types.d.ts

@@ -1,6 +1,3 @@
-export type SQLiteOptions = {
-    path: string;
-};
 export type LocalFilesystemOptions = {
     path: string;
     lixDir?: string;
@@ -36,7 +33,7 @@ export interface LixSnapshotStorage {
     save(namespace: string, snapshot: Uint8Array): Promise<void>;
 }
 export type OpenLixOptions = {
-    storage?: import("./open-lix.js").SQLite | import("./open-lix.js").LocalFilesystem | LixSnapshotStorage;
+    storage?: import("./open-lix.js").LocalFilesystem | LixSnapshotStorage;
     server?: never;
     telemetry?: LixTelemetryOptions;
 } | {
@@ -86,6 +83,7 @@ export type ExecuteOptions = {
 export type LixBatchStatement = {
     sql: string;
     params?: readonly SqlParam[];
+    label?: string;
 };
 export type LixBatchOptions = {
     originKey?: string;
@@ -93,6 +91,8 @@ export type LixBatchOptions = {
     idempotencyKey?: string;
 };
 export type ExecuteResult = {
+    statementIndex?: number;
+    label?: string;
     columns: string[];
     rows: RowLike[];
     rowsAffected: number;
@@ -102,9 +102,17 @@ export type ExecuteResult = {
         hint?: string;
     }>;
 };
+export type ExecuteBatchResult = ExecuteResult & {
+    statementIndex: number;
+};
 export type ObserveEvent = {
     sequence: number;
     mutationSequence: number;
+    /**
+     * The current result of the observed query. Remote observations reconcile
+     * the first frame of every stream through execute before publishing it, so
+     * reconnects cannot expose a stale server snapshot to consumers.
+     */
     result: ExecuteResult;
 };
 export type RowLike = {
@@ -132,6 +140,16 @@ export type CreateBranchReceipt = {
 export type CreateCheckpointReceipt = {
     commitId: string;
 };
+export type UndoReceipt = {
+    branchId: string;
+    targetCommitId: string;
+    inverseCommitId: string;
+};
+export type RedoReceipt = {
+    branchId: string;
+    targetCommitId: string;
+    replayCommitId: string;
+};
 export type SwitchBranchOptions = {
     branchId: string;
 };

package/dist/wasm/lix_js_sdk.d.ts

@@ -5,6 +5,7 @@ export class WasmLix {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    activeAccountId(): Promise<string>;
     activeBranchId(): Promise<string>;
     beginTransaction(): Promise<WasmLixTransaction>;
     clientStateDelete(key: string): Promise<void>;
@@ -20,7 +21,9 @@ export class WasmLix {
     mergeBranch(options: any): Promise<any>;
     mergeBranchPreview(options: any): Promise<any>;
     observe(sql: string, params: any): Promise<WasmObserveEvents>;
+    redo(): Promise<any>;
     switchBranch(options: any): Promise<any>;
+    undo(): Promise<any>;
 }
 
 export class WasmLixTransaction {
@@ -56,6 +59,7 @@ export interface InitOutput {
     readonly openMemory: (a: number) => number;
     readonly openMemoryFromSnapshot: (a: number, b: number, c: number) => number;
     readonly parseSqlScript: (a: number, b: number, c: number, d: number) => void;
+    readonly wasmlix_activeAccountId: (a: number) => number;
     readonly wasmlix_activeBranchId: (a: number) => number;
     readonly wasmlix_beginTransaction: (a: number) => number;
     readonly wasmlix_clientStateDelete: (a: number, b: number, c: number) => number;
@@ -71,14 +75,16 @@ export interface InitOutput {
     readonly wasmlix_mergeBranch: (a: number, b: number) => number;
     readonly wasmlix_mergeBranchPreview: (a: number, b: number) => number;
     readonly wasmlix_observe: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmlix_redo: (a: number) => number;
     readonly wasmlix_switchBranch: (a: number, b: number) => number;
+    readonly wasmlix_undo: (a: number) => number;
     readonly wasmlixtransaction_commit: (a: number) => number;
     readonly wasmlixtransaction_execute: (a: number, b: number, c: number, d: number, e: number) => number;
     readonly wasmlixtransaction_rollback: (a: number) => number;
     readonly wasmobserveevents_close: (a: number) => void;
     readonly wasmobserveevents_next: (a: number) => number;
-    readonly __wasm_bindgen_func_elem_111270: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_111272: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_122229: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_122231: (a: number, b: number, c: number, d: 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

@@ -17,6 +17,13 @@ export class WasmLix {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmlix_free(ptr, 0);
     }
+    /**
+     * @returns {Promise<string>}
+     */
+    activeAccountId() {
+        const ret = wasm.wasmlix_activeAccountId(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * @returns {Promise<string>}
      */
@@ -146,6 +153,13 @@ export class WasmLix {
         const ret = wasm.wasmlix_observe(this.__wbg_ptr, ptr0, len0, addHeapObject(params));
         return takeObject(ret);
     }
+    /**
+     * @returns {Promise<any>}
+     */
+    redo() {
+        const ret = wasm.wasmlix_redo(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * @param {any} options
      * @returns {Promise<any>}
@@ -154,6 +168,13 @@ export class WasmLix {
         const ret = wasm.wasmlix_switchBranch(this.__wbg_ptr, addHeapObject(options));
         return takeObject(ret);
     }
+    /**
+     * @returns {Promise<any>}
+     */
+    undo() {
+        const ret = wasm.wasmlix_undo(this.__wbg_ptr);
+        return takeObject(ret);
+    }
 }
 if (Symbol.dispose) WasmLix.prototype[Symbol.dispose] = WasmLix.prototype.free;
 
@@ -515,7 +536,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_111272(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_122231(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -625,8 +646,8 @@ function __wbg_get_imports() {
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 29773, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_111270);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 30525, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_122229);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0) {
@@ -675,10 +696,10 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_111270(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_122229(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_111270(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_122229(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -689,8 +710,8 @@ function __wasm_bindgen_func_elem_111270(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_111272(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_111272(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_122231(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_122231(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const WasmLixFinalization = (typeof FinalizationRegistry === 'undefined')

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

@@ -7,6 +7,7 @@ export const __wbg_wasmobserveevents_free: (a: number, b: number) => void;
 export const openMemory: (a: number) => number;
 export const openMemoryFromSnapshot: (a: number, b: number, c: 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;
 export const wasmlix_clientStateDelete: (a: number, b: number, c: number) => number;
@@ -22,14 +23,16 @@ export const wasmlix_exportSnapshot: (a: 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_redo: (a: number) => number;
 export const wasmlix_switchBranch: (a: number, b: 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;
 export const wasmlixtransaction_rollback: (a: number) => number;
 export const wasmobserveevents_close: (a: number) => void;
 export const wasmobserveevents_next: (a: number) => number;
-export const __wasm_bindgen_func_elem_111270: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_111272: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_122229: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_122231: (a: number, b: number, c: number, d: 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;