@lix-js/sdk 0.10.0 → 0.11.0

package/README.md

@@ -88,7 +88,7 @@ server switch into a rejected operation. Explicit `lix.clientState.set()` and
 Rust transaction has already committed, `get()` continues to expose that live
 session value; a later successful snapshot save can make it durable.
 
-Filesystem sync and SQLite persistence use native Node.js dependencies:
+Filesystem sync uses native Node.js dependencies:
 
 ```ts
 import { LocalFilesystem, openLix } from "@lix-js/sdk";
@@ -175,11 +175,10 @@ try {
 - `openLix()` opens a fresh in-memory Lix. Pass `new LocalFilesystem({ path, syncAllFiles: true })` for a filesystem workspace directory backed by `<path>/.lix/.internal/rocksdb`.
 - Pass `new LocalFilesystem({ path, lixDir, syncAllFiles: true })` for filesystem sync with repository metadata in an external `.lix` directory and no workspace `.lix` directory.
 - Pass `syncAllFiles: false` to start filesystem sync with no regular workspace files, then call `storage.importPaths(["notes/today.md"])` on the `LocalFilesystem` instance to sync selected files. Imported paths are exact workspace-relative file paths, not directories or globs.
-- Use `new SQLite({ path })` when a single SQLite-backed `.lix` file is the application document itself, for example when defining a new file format and using Lix as the application's file format.
 - In browsers, local mode and remote mode with client storage load the Rust
   engine as WebAssembly. Supplying a snapshot storage adapter persists that
   local Lix; in remote mode, the local engine contains only client state.
-- `LocalFilesystem` and `SQLite` are Node.js-only. Constructing them is safe in
+- `LocalFilesystem` is Node.js-only. Constructing it is safe in
   shared code, but passing one to `openLix()` in a browser throws an error.
 - The package is ESM-only.
 - The package uses conditional ESM imports internally: Node.js resolves the

package/dist/binding-types.d.ts

@@ -1,6 +1,8 @@
 import type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, UndoReceipt, RedoReceipt, ExecuteOptions, LixBatchOptions, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, SwitchBranchOptions, SwitchBranchReceipt, LixTelemetrySpan, JsonValue } from "./types.js";
 import type { NativeLixValue } from "./value.js";
 export type BindingExecuteResult = {
+    statementIndex?: number;
+    label?: string;
     columns: string[];
     rows: NativeLixValue[][];
     rowsAffected: number;
@@ -19,6 +21,7 @@ export type BindingParam = NativeLixValue;
 export type BindingBatchStatement = {
     sql: string;
     params: BindingParam[];
+    label?: string;
 };
 export type LixBinding = {
     execute(sql: string, params: BindingParam[], options?: ExecuteOptions): Promise<BindingExecuteResult>;
@@ -60,9 +63,6 @@ export type TelemetryDispatch = (span: LixTelemetrySpan) => void;
 export type LixStorageConfig = {
     kind: "memory";
     snapshot?: Uint8Array;
-} | {
-    kind: "sqlite";
-    path: string;
 } | {
     kind: "localFilesystem";
     path: string;

package/dist/binding.browser.js

@@ -7,7 +7,7 @@ function initializeWasm() {
 }
 export async function openLixBinding(storage, telemetry) {
     if (storage.kind !== "memory") {
-        throw new Error(`${storage.kind === "localFilesystem" ? "LocalFilesystem" : "SQLite"} is only available in Node.js`);
+        throw new Error("LocalFilesystem is only available in Node.js");
     }
     await initializeWasm();
     return openMemoryFromSnapshot(telemetry, storage.snapshot);

package/dist/binding.node.js

@@ -51,11 +51,6 @@ export function openLixBinding(storage, telemetry) {
             if (nativeTelemetry)
                 return addon.Lix.openMemory(nativeTelemetry);
             return addon.Lix.openMemory();
-        case "sqlite":
-            if (nativeTelemetry) {
-                return addon.Lix.openSQLite(storage.path, nativeTelemetry);
-            }
-            return addon.Lix.openSQLite(storage.path);
         case "localFilesystem":
             if (nativeTelemetry) {
                 return addon.Lix.openLocalFilesystem(storage.path, storage.lixDir, storage.syncAllFiles, nativeTelemetry);

package/dist/client-state.js

@@ -271,14 +271,11 @@ function decodeStoredClientState(snapshot) {
     const header = new TextEncoder().encode(STORED_CLIENT_STATE_HEADER);
     if (snapshot.length < header.length ||
         header.some((byte, index) => snapshot[index] !== byte)) {
-        // Remote storage previously contained a full Lix snapshot. Backward
-        // compatibility is intentionally not provided: start with empty state and
-        // replace it on the next write.
-        return new Map();
+        throw new Error("Stored Lix client state header is invalid");
     }
     let parsed;
     try {
-        parsed = JSON.parse(new TextDecoder().decode(snapshot.subarray(header.length)));
+        parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(snapshot.subarray(header.length)));
     }
     catch (error) {
         throw new Error("Stored Lix client state is invalid", { cause: error });

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { LocalFilesystem, Lix, LixTransaction, ObserveEvents, openLix, SQLite, } from "./open-lix.js";
+export { LocalFilesystem, Lix, LixTransaction, ObserveEvents, openLix, } from "./open-lix.js";
 export { bundledPluginArchives, type BundledPluginArchive, } from "./bundled-plugins.js";
 export { Row } from "./result.js";
 export { Value } from "./value.js";
 export type { LixClientState } from "./client-state.js";
-export type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, LixBatchOptions, LixBatchStatement, LocalFilesystemOptions, JsonValue, LixValue, MergeBranchOptions, MergeBranchOutcome, MergeBranchPreview, MergeBranchReceipt, MergeChangeStats, MergeConflict, MergeConflictSide, ObserveEvent, OpenLixOptions, LixTelemetryOptions, LixTelemetrySpan, LixSnapshotStorage, RemoteLixFetch, RemoteLixServerOptions, UndoReceipt, SqlParam, SQLiteOptions, SwitchBranchOptions, SwitchBranchReceipt, } from "./types.js";
+export type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, LixBatchOptions, LixBatchStatement, LocalFilesystemOptions, JsonValue, LixValue, MergeBranchOptions, MergeBranchOutcome, MergeBranchPreview, MergeBranchReceipt, MergeChangeStats, MergeConflict, MergeConflictSide, ObserveEvent, OpenLixOptions, LixTelemetryOptions, LixTelemetrySpan, LixSnapshotStorage, RemoteLixFetch, RemoteLixServerOptions, UndoReceipt, SqlParam, SwitchBranchOptions, SwitchBranchReceipt, } from "./types.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { LocalFilesystem, Lix, LixTransaction, ObserveEvents, openLix, SQLite, } from "./open-lix.js";
+export { LocalFilesystem, Lix, LixTransaction, ObserveEvents, openLix, } from "./open-lix.js";
 export { bundledPluginArchives, } from "./bundled-plugins.js";
 export { Row } from "./result.js";
 export { Value } from "./value.js";

package/dist/lix.d.ts

@@ -1,6 +1,6 @@
 import { type LixClientState, type ManagedClientState } from "./client-state.js";
 import type { LixBinding, LixTransactionBinding, ObserveEventsBinding } from "./binding-types.js";
-import type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, LixBatchOptions, LixBatchStatement, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, ObserveEvent, SqlParam, SwitchBranchOptions, SwitchBranchReceipt, UndoReceipt } from "./types.js";
+import type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, ExecuteBatchResult, LixBatchOptions, LixBatchStatement, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, ObserveEvent, SqlParam, SwitchBranchOptions, SwitchBranchReceipt, UndoReceipt } from "./types.js";
 export declare class Lix {
     #private;
     private readonly binding;
@@ -9,7 +9,7 @@ export declare class Lix {
     readonly clientState: LixClientState;
     constructor(binding: LixBinding, managedClientState?: ManagedClientState | undefined);
     execute(sql: string, params?: SqlParam[], options?: ExecuteOptions): Promise<ExecuteResult>;
-    executeBatch(statements: readonly LixBatchStatement[], options?: LixBatchOptions): Promise<readonly ExecuteResult[]>;
+    executeBatch(statements: readonly LixBatchStatement[], options?: LixBatchOptions): Promise<readonly ExecuteBatchResult[]>;
     observe(sql: string, params?: SqlParam[]): ObserveEvents;
     beginTransaction(): Promise<LixTransaction>;
     activeBranchId(): Promise<string>;

package/dist/lix.js

@@ -1,6 +1,6 @@
 import { invalidArgument } from "./errors.js";
 import { ACTIVE_BRANCH_CLIENT_STATE_KEY, unavailableClientState, } from "./client-state.js";
-import { normalizeOptionals, wrapExecuteResult } from "./result.js";
+import { normalizeOptionals, wrapExecuteBatchResult, wrapExecuteResult, } from "./result.js";
 import { isSnapshotPersistenceAfterCommitError } from "./snapshot-persistence.js";
 import { normalizeParam, toNativeValue } from "./value.js";
 const transactionFinalizer = new FinalizationRegistry(({ transaction, onFinish }) => {
@@ -50,7 +50,7 @@ export class Lix {
         const normalizedStatements = normalizeBatchStatements(statements, options);
         return this.#runOperation(async () => {
             const results = await this.binding.executeBatch(normalizedStatements, options);
-            return results.map(wrapExecuteResult);
+            return results.map(wrapExecuteBatchResult);
         });
     }
     observe(sql, params = []) {
@@ -336,9 +336,14 @@ function normalizeBatchStatements(statements, options) {
             if (!Array.isArray(params)) {
                 throw invalidArgument("executeBatch", `statements[${statementIndex}].params`, "array", typeof params);
             }
+            if (statement.label !== undefined &&
+                typeof statement.label !== "string") {
+                throw invalidArgument("executeBatch", `statements[${statementIndex}].label`, "string", typeof statement.label);
+            }
             return {
                 sql: statement.sql,
                 params: params.map((param, parameterIndex) => toNativeValue(normalizeParam(param, parameterIndex))),
+                ...(statement.label === undefined ? {} : { label: statement.label }),
             };
         }
         catch (error) {

package/dist/open-lix.d.ts

@@ -1,10 +1,6 @@
 import { Lix } from "./lix.js";
-import type { LocalFilesystemOptions, OpenLixOptions, SQLiteOptions } from "./types.js";
+import type { LocalFilesystemOptions, OpenLixOptions } from "./types.js";
 export { Lix, LixTransaction, ObserveEvents } from "./lix.js";
-export declare class SQLite {
-    readonly path: string;
-    constructor(options: SQLiteOptions);
-}
 export declare class LocalFilesystem {
     readonly path: string;
     readonly lixDir: string | undefined;

package/dist/open-lix.js

@@ -2,17 +2,6 @@ import { localFilesystemAlreadyOpen, localFilesystemNotOpen, } from "./errors.js
 import { ACTIVE_ACCOUNT_CLIENT_STATE_KEY, ACTIVE_BRANCH_CLIENT_STATE_KEY, openClientState, openStoredClientState, } from "./client-state.js";
 import { Lix } from "./lix.js";
 export { Lix, LixTransaction, ObserveEvents } from "./lix.js";
-export class SQLite {
-    path;
-    constructor(options) {
-        if (!options ||
-            typeof options.path !== "string" ||
-            options.path.length === 0) {
-            throw new TypeError("SQLite requires a non-empty path");
-        }
-        this.path = options.path;
-    }
-}
 const openLocalFilesystems = new WeakMap();
 export class LocalFilesystem {
     path;
@@ -119,12 +108,6 @@ export async function openLix(options = {}) {
     if (options.storage === undefined) {
         return new Lix(await openLixWorkerBinding({ kind: "memory" }, undefined, options.telemetry));
     }
-    if (options.storage instanceof SQLite) {
-        return new Lix(await openLixWorkerBinding({
-            kind: "sqlite",
-            path: options.storage.path,
-        }, undefined, options.telemetry));
-    }
     if (options.storage instanceof LocalFilesystem) {
         const storage = options.storage;
         if (openLocalFilesystems.has(storage)) {
@@ -162,7 +145,7 @@ export async function openLix(options = {}) {
             throw error;
         }
     }
-    throw new TypeError("openLix() requires storage to be SQLite, LocalFilesystem, or a Lix snapshot storage adapter");
+    throw new TypeError("openLix() requires storage to be LocalFilesystem or a Lix snapshot storage adapter");
 }
 function isSnapshotStorage(value) {
     return (typeof value === "object" &&

package/dist/remote/client.js

@@ -1,4 +1,4 @@
-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;
@@ -73,6 +73,7 @@ class RemoteLixBinding {
         this.#initialActiveAccountId = clientOptions.initialActiveAccountId;
         this.#observationHub = new RemoteObservationHub({
             openStream: (subscriptions, signal) => this.#requestObserveStream(subscriptions, signal),
+            refreshObservation: (subscription) => this.#refreshObservation(subscription),
         });
     }
     async open() {
@@ -119,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);
@@ -133,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,
@@ -145,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;
         });
@@ -442,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" ||
@@ -661,6 +679,7 @@ function copyArrayBuffer(bytes) {
 }
 class RemoteObservationHub {
     #openStream;
+    #refreshObservation;
     #observations = new Map();
     #nextObservationId = 0;
     #controller;
@@ -672,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}`;
@@ -743,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();
@@ -781,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

@@ -55,6 +55,7 @@ export type RemoteExecuteBatchRequest = {
     statements: Array<{
         sql: string;
         params: WireRequestValue[];
+        label?: string;
     }>;
     options?: {
         originKey?: string;
@@ -71,6 +72,10 @@ export type RemoteExecuteResponse = {
         hint?: string;
     }>;
 };
+export type RemoteExecuteBatchResponse = RemoteExecuteResponse & {
+    statementIndex: number;
+    label?: string;
+};
 export type RemoteObserveRequest = {
     sql: string;
     params: WireValue[];
@@ -156,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

@@ -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) {

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 = {

package/dist/wasm/lix_js_sdk.d.ts

@@ -83,8 +83,8 @@ export interface InitOutput {
     readonly wasmlixtransaction_rollback: (a: number) => number;
     readonly wasmobserveevents_close: (a: number) => void;
     readonly wasmobserveevents_next: (a: number) => number;
-    readonly __wasm_bindgen_func_elem_120695: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_120697: (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

@@ -536,7 +536,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_120697(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_122231(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -646,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: 30501, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_120695);
+            // 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) {
@@ -696,10 +696,10 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_120695(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_120695(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) {
@@ -710,8 +710,8 @@ function __wasm_bindgen_func_elem_120695(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_120697(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_120697(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

@@ -31,8 +31,8 @@ export const wasmlixtransaction_execute: (a: number, b: number, c: number, d: nu
 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_120695: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_120697: (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;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@lix-js/sdk",
 	"type": "module",
-	"version": "0.10.0",
+	"version": "0.11.0",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -57,10 +57,10 @@
 		"typecheck": "tsc -p tsconfig.test.json --noEmit"
 	},
 	"optionalDependencies": {
-		"@lix-js/sdk-darwin-arm64": "0.10.0",
-		"@lix-js/sdk-linux-arm64": "0.10.0",
-		"@lix-js/sdk-linux-x64": "0.10.0",
-		"@lix-js/sdk-win32-x64": "0.10.0"
+		"@lix-js/sdk-darwin-arm64": "0.11.0",
+		"@lix-js/sdk-linux-arm64": "0.11.0",
+		"@lix-js/sdk-linux-x64": "0.11.0",
+		"@lix-js/sdk-win32-x64": "0.11.0"
 	},
 	"devDependencies": {
 		"@vitest/browser-playwright": "4.1.10",