@lix-js/sdk 0.9.0 → 0.10.0

package/README.md

@@ -41,7 +41,7 @@ const files = lix.observe("SELECT path FROM lix_file ORDER BY path");
 const initial = await files.next();
 
 await lix.execute(
-	"INSERT INTO lix_file (path, data) VALUES ($1, $2)",
+	"INSERT INTO lix_file (path, content) VALUES ($1, $2)",
 	["/hello.txt", new TextEncoder().encode("hello")],
 );
 const update = await files.next();
@@ -101,20 +101,37 @@ const lix = await openLix({
 });
 
 await lix.execute(
-	"INSERT INTO lix_file (path, data) VALUES ($1, $2) ON CONFLICT (path) DO UPDATE SET data = excluded.data",
+	"INSERT INTO lix_file (path, content) VALUES ($1, $2) ON CONFLICT (path) DO UPDATE SET content = excluded.content",
 	["/hello.txt", new TextEncoder().encode("world")],
 );
 
-const result = await lix.execute("SELECT data FROM lix_file WHERE path = $1", [
+const result = await lix.execute("SELECT content FROM lix_file WHERE path = $1", [
 	"/hello.txt",
 ]);
-const bytes = result.rows[0]?.value("data").asBytes();
+const bytes = result.rows[0]?.value("content").asBytes();
 
 console.log(bytes && new TextDecoder().decode(bytes));
 
 await lix.close();
 ```
 
+## Discover the SQL contract
+
+Lix extends the standard `information_schema.columns` relation with
+`lix_value_kind` and `lix_insert_policy`. Inspect it before generating writes:
+
+```sql
+SELECT table_name, column_name, data_type, is_nullable, column_default,
+       lix_value_kind, lix_insert_policy
+FROM information_schema.columns
+WHERE table_name = 'lix_file'
+ORDER BY ordinal_position;
+```
+
+`lix_insert_policy` distinguishes `REQUIRED`, `DEFAULT`, `CONDITIONAL`, and
+`READ_ONLY` columns. For the complete table and history-function map, see
+[SQL Surfaces](https://lix.dev/docs/surfaces).
+
 ## Branches
 
 ```ts
@@ -123,7 +140,7 @@ const draft = await lix.createBranch({ name: "Draft" });
 
 await lix.switchBranch({ branchId: draft.id });
 await lix.execute(
-	"INSERT INTO lix_file (path, data) VALUES ($1, $2) ON CONFLICT (path) DO UPDATE SET data = excluded.data",
+	"INSERT INTO lix_file (path, content) VALUES ($1, $2) ON CONFLICT (path) DO UPDATE SET content = excluded.content",
 	["/status.txt", new TextEncoder().encode("draft")],
 );
 
@@ -139,11 +156,11 @@ const tx = await lix.beginTransaction();
 
 try {
 	await tx.execute(
-		"INSERT INTO lix_file (path, data) VALUES ($1, $2) ON CONFLICT (path) DO UPDATE SET data = excluded.data",
+		"INSERT INTO lix_file (path, content) VALUES ($1, $2) ON CONFLICT (path) DO UPDATE SET content = excluded.content",
 		["/a.txt", new TextEncoder().encode("1")],
 	);
 	await tx.execute(
-		"INSERT INTO lix_file (path, data) VALUES ($1, $2) ON CONFLICT (path) DO UPDATE SET data = excluded.data",
+		"INSERT INTO lix_file (path, content) VALUES ($1, $2) ON CONFLICT (path) DO UPDATE SET content = excluded.content",
 		["/b.txt", new TextEncoder().encode("2")],
 	);
 	await tx.commit();
@@ -170,10 +187,10 @@ try {
   WebAssembly binding. Vite follows this split without consumer configuration.
 - Every browser `openLix()` owns one dedicated worker, so database work does
   not block the page's main thread. Node.js uses the native binding's actor.
-- Node.js executes installed Component API v2 plugins with the Rust SDK's
+- Node.js executes installed Component API v1 plugins with the Rust SDK's
   Wasmtime runtime. The browser and Workerd bindings currently open without a
   component runtime: they can use ordinary Lix storage and SQL, but do not
-  execute installed plugins. A browser V2 host is a separate follow-up.
+  execute installed plugins. A browser Component host is a separate follow-up.
 - A page Content Security Policy only needs to permit the package's same-origin
   worker. WebAssembly compilation happens inside that worker, so the required
   permission can be scoped to the worker script's HTTP response instead of

package/dist/binding-types.d.ts

@@ -1,4 +1,4 @@
-import type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, ExecuteOptions, LixBatchOptions, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, SwitchBranchOptions, SwitchBranchReceipt, LixTelemetrySpan, JsonValue } from "./types.js";
+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 = {
     columns: string[];
@@ -26,6 +26,7 @@ export type LixBinding = {
     observe(sql: string, params: BindingParam[]): Promise<ObserveEventsBinding>;
     beginTransaction(): Promise<LixTransactionBinding>;
     activeBranchId(): Promise<string>;
+    activeAccountId(): Promise<string>;
     clientStateEntries?(): Promise<Array<{
         key: string;
         value: JsonValue;
@@ -35,6 +36,8 @@ export type LixBinding = {
     clientStateDelete?(key: string): Promise<void>;
     createBranch(options: CreateBranchOptions): Promise<CreateBranchReceipt>;
     createCheckpoint(): Promise<CreateCheckpointReceipt>;
+    undo(): Promise<UndoReceipt>;
+    redo(): Promise<RedoReceipt>;
     switchBranch(options: SwitchBranchOptions): Promise<SwitchBranchReceipt>;
     importFilesystemPaths(paths: string[]): Promise<void>;
     mergeBranchPreview(options: MergeBranchOptions): Promise<MergeBranchPreview>;

package/dist/binding.node.js

@@ -48,10 +48,18 @@ export function openLixBinding(storage, telemetry) {
             if (storage.snapshot !== undefined) {
                 throw new Error("Memory snapshots are only available in the browser binding");
             }
-            return addon.Lix.openMemory(nativeTelemetry);
+            if (nativeTelemetry)
+                return addon.Lix.openMemory(nativeTelemetry);
+            return addon.Lix.openMemory();
         case "sqlite":
-            return addon.Lix.openSQLite(storage.path, nativeTelemetry);
+            if (nativeTelemetry) {
+                return addon.Lix.openSQLite(storage.path, nativeTelemetry);
+            }
+            return addon.Lix.openSQLite(storage.path);
         case "localFilesystem":
-            return addon.Lix.openLocalFilesystem(storage.path, storage.lixDir, storage.syncAllFiles, nativeTelemetry);
+            if (nativeTelemetry) {
+                return addon.Lix.openLocalFilesystem(storage.path, storage.lixDir, storage.syncAllFiles, nativeTelemetry);
+            }
+            return addon.Lix.openLocalFilesystem(storage.path, storage.lixDir, storage.syncAllFiles);
     }
 }

package/dist/bundled-plugins.js

@@ -1,11 +1,11 @@
 const BUNDLED_PLUGIN_MANIFEST = [
     {
-        key: "plugin_markdown_incremental_v2",
-        fileName: "plugin_markdown_incremental_v2.lixplugin",
+        key: "plugin_markdown",
+        fileName: "plugin_markdown.lixplugin",
     },
     {
-        key: "plugin_csv_v2",
-        fileName: "plugin_csv_v2.lixplugin",
+        key: "plugin_csv",
+        fileName: "plugin_csv.lixplugin",
     },
 ];
 export async function bundledPluginArchives() {

package/dist/client-state.d.ts

@@ -1,16 +1,20 @@
 import type { LixBinding } from "./binding-types.js";
-import type { JsonValue } from "./types.js";
+import type { JsonValue, LixSnapshotStorage } from "./types.js";
 export declare const ACTIVE_BRANCH_CLIENT_STATE_KEY = "lix_active_branch_id";
+export declare const ACTIVE_ACCOUNT_CLIENT_STATE_KEY = "lix_active_account_id";
 export type LixClientState = {
     /** Returns the hydrated client-local value without a network round trip. */
     get<T extends JsonValue = JsonValue>(key: string): T | undefined;
-    /** Commits the value through the local Rust Lix and then persists its snapshot. */
+    /** Persists a client-local value in the configured client storage. */
     set(key: string, value: JsonValue): Promise<void>;
-    /** Deletes the value through the local Rust Lix and then persists its snapshot. */
+    /** Deletes a client-local value from the configured client storage. */
     delete(key: string): Promise<void>;
     /** Subscribes to successful mutations made through this client-state handle. */
     subscribe(listener: () => void): () => void;
 };
+export type ManagedClientState = LixClientState & {
+    close(): Promise<void>;
+};
 export declare function unavailableClientState(): LixClientState;
 type ClientStateBinding = LixBinding & {
     exportSnapshot?: () => Promise<Uint8Array>;
@@ -37,4 +41,13 @@ export declare class ManagedLixClientState implements LixClientState {
     subscribe(listener: () => void): () => void;
     close(): Promise<void>;
 }
+/**
+ * Opens client state directly over snapshot storage without starting a local
+ * Lix runtime. This is used by remote Lix connections, where the storage
+ * option persists client-local state rather than the remote workspace.
+ */
+export declare function openStoredClientState(options: {
+    readonly storage: LixSnapshotStorage;
+    readonly namespace: string;
+}): Promise<ManagedClientState>;
 export {};

package/dist/client-state.js

@@ -1,6 +1,8 @@
 import { isSnapshotPersistenceAfterCommitError } from "./snapshot-persistence.js";
 import { Value } from "./value.js";
 export const ACTIVE_BRANCH_CLIENT_STATE_KEY = "lix_active_branch_id";
+export const ACTIVE_ACCOUNT_CLIENT_STATE_KEY = "lix_active_account_id";
+const STORED_CLIENT_STATE_HEADER = "lix-client-state-v1\n";
 export function unavailableClientState() {
     const unavailable = () => {
         const error = new Error("Lix client state requires client storage; pass storage to openLix()");
@@ -158,6 +160,144 @@ export class ManagedLixClientState {
         }
     }
 }
+/**
+ * Opens client state directly over snapshot storage without starting a local
+ * Lix runtime. This is used by remote Lix connections, where the storage
+ * option persists client-local state rather than the remote workspace.
+ */
+export async function openStoredClientState(options) {
+    const snapshot = await options.storage.load(options.namespace);
+    if (snapshot !== undefined && !(snapshot instanceof Uint8Array)) {
+        throw new TypeError("Client-state storage load() must return a Uint8Array");
+    }
+    return new StoredClientState(options.storage, options.namespace, decodeStoredClientState(snapshot));
+}
+class StoredClientState {
+    #storage;
+    #namespace;
+    #values;
+    #listeners = new Set();
+    #operationQueue = Promise.resolve();
+    #closePromise;
+    #acceptingOperations = true;
+    #dirty = false;
+    constructor(storage, namespace, values) {
+        this.#storage = storage;
+        this.#namespace = namespace;
+        this.#values = values;
+    }
+    get(key) {
+        assertClientStateKey(key);
+        const value = this.#values.get(key);
+        return value === undefined ? undefined : cloneJsonValue(value);
+    }
+    set(key, value) {
+        assertClientStateKey(key);
+        assertJsonValue(value);
+        this.#assertOpen();
+        const nextValue = cloneJsonValue(value);
+        return this.#enqueue(async () => {
+            this.#values.set(key, nextValue);
+            this.#dirty = true;
+            this.#publish();
+            await this.#persist();
+        });
+    }
+    delete(key) {
+        assertClientStateKey(key);
+        this.#assertOpen();
+        return this.#enqueue(async () => {
+            if (this.#values.delete(key))
+                this.#publish();
+            this.#dirty = true;
+            await this.#persist();
+        });
+    }
+    subscribe(listener) {
+        if (typeof listener !== "function") {
+            throw new TypeError("clientState.subscribe() requires a function");
+        }
+        this.#assertOpen();
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+    }
+    async close() {
+        if (this.#closePromise)
+            return this.#closePromise;
+        this.#acceptingOperations = false;
+        this.#closePromise = (async () => {
+            await this.#operationQueue;
+            if (this.#dirty)
+                await this.#persist();
+            this.#listeners.clear();
+        })();
+        return this.#closePromise;
+    }
+    #enqueue(operation) {
+        const result = this.#operationQueue.then(operation, operation);
+        this.#operationQueue = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async #persist() {
+        await this.#storage.save(this.#namespace, encodeStoredClientState(this.#values));
+        this.#dirty = false;
+    }
+    #publish() {
+        for (const listener of [...this.#listeners]) {
+            try {
+                listener();
+            }
+            catch {
+                // Subscribers do not participate in the completed mutation.
+            }
+        }
+    }
+    #assertOpen() {
+        if (!this.#acceptingOperations) {
+            throw new Error("Lix client state is closed");
+        }
+    }
+}
+function encodeStoredClientState(values) {
+    const entries = [...values].map(([key, value]) => [
+        key,
+        cloneJsonValue(value),
+    ]);
+    return new TextEncoder().encode(`${STORED_CLIENT_STATE_HEADER}${JSON.stringify(entries)}`);
+}
+function decodeStoredClientState(snapshot) {
+    if (snapshot === undefined)
+        return new Map();
+    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();
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder().decode(snapshot.subarray(header.length)));
+    }
+    catch (error) {
+        throw new Error("Stored Lix client state is invalid", { cause: error });
+    }
+    if (!Array.isArray(parsed)) {
+        throw new Error("Stored Lix client state entries must be an array");
+    }
+    const values = new Map();
+    for (const entry of parsed) {
+        if (!Array.isArray(entry) || entry.length !== 2) {
+            throw new Error("Stored Lix client state entry is invalid");
+        }
+        const [key, value] = entry;
+        assertClientStateKey(key);
+        assertJsonValue(value);
+        values.set(key, cloneJsonValue(value));
+    }
+    return values;
+}
 function assertClientStateKey(key) {
     if (typeof key !== "string" || key.length === 0) {
         throw new TypeError("clientState key must be a non-empty string");

package/dist/index.d.ts

@@ -3,4 +3,4 @@ export { bundledPluginArchives, type BundledPluginArchive, } from "./bundled-plu
 export { Row } from "./result.js";
 export { Value } from "./value.js";
 export type { LixClientState } from "./client-state.js";
-export type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, ExecuteOptions, ExecuteResult, LixBatchOptions, LixBatchStatement, LocalFilesystemOptions, JsonValue, LixValue, MergeBranchOptions, MergeBranchOutcome, MergeBranchPreview, MergeBranchReceipt, MergeChangeStats, MergeConflict, MergeConflictSide, ObserveEvent, OpenLixOptions, LixTelemetryOptions, LixTelemetrySpan, LixSnapshotStorage, RemoteLixFetch, RemoteLixServerOptions, 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, SQLiteOptions, SwitchBranchOptions, SwitchBranchReceipt, } from "./types.js";

package/dist/lix.d.ts

@@ -1,22 +1,25 @@
-import { type LixClientState, type ManagedLixClientState } from "./client-state.js";
+import { type LixClientState, type ManagedClientState } from "./client-state.js";
 import type { LixBinding, LixTransactionBinding, ObserveEventsBinding } from "./binding-types.js";
-import type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, ExecuteOptions, ExecuteResult, LixBatchOptions, LixBatchStatement, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, ObserveEvent, SqlParam, SwitchBranchOptions, SwitchBranchReceipt } from "./types.js";
+import type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, LixBatchOptions, LixBatchStatement, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, ObserveEvent, SqlParam, SwitchBranchOptions, SwitchBranchReceipt, UndoReceipt } from "./types.js";
 export declare class Lix {
     #private;
     private readonly binding;
     private readonly managedClientState?;
     private closePromise;
     readonly clientState: LixClientState;
-    constructor(binding: LixBinding, managedClientState?: ManagedLixClientState | undefined);
+    constructor(binding: LixBinding, managedClientState?: ManagedClientState | undefined);
     execute(sql: string, params?: SqlParam[], options?: ExecuteOptions): Promise<ExecuteResult>;
     executeBatch(statements: readonly LixBatchStatement[], options?: LixBatchOptions): Promise<readonly ExecuteResult[]>;
     observe(sql: string, params?: SqlParam[]): ObserveEvents;
     beginTransaction(): Promise<LixTransaction>;
     activeBranchId(): Promise<string>;
+    activeAccountId(): Promise<string>;
     /** Subscribes to successful branch switches made through this Lix handle. */
     subscribeActiveBranch(listener: () => void): () => void;
     createBranch(options: CreateBranchOptions): Promise<CreateBranchReceipt>;
     createCheckpoint(): Promise<CreateCheckpointReceipt>;
+    undo(): Promise<UndoReceipt>;
+    redo(): Promise<RedoReceipt>;
     switchBranch(options: SwitchBranchOptions): Promise<SwitchBranchReceipt>;
     mergeBranchPreview(options: MergeBranchOptions): Promise<MergeBranchPreview>;
     mergeBranch(options: MergeBranchOptions): Promise<MergeBranchReceipt>;

package/dist/lix.js

@@ -83,6 +83,9 @@ export class Lix {
     async activeBranchId() {
         return this.#runOperation(() => this.binding.activeBranchId());
     }
+    async activeAccountId() {
+        return this.#runOperation(() => this.binding.activeAccountId());
+    }
     /** Subscribes to successful branch switches made through this Lix handle. */
     subscribeActiveBranch(listener) {
         if (typeof listener !== "function") {
@@ -98,6 +101,12 @@ export class Lix {
     async createCheckpoint() {
         return this.#runOperation(() => this.binding.createCheckpoint());
     }
+    async undo() {
+        return this.#runOperation(() => this.binding.undo());
+    }
+    async redo() {
+        return this.#runOperation(() => this.binding.redo());
+    }
     async switchBranch(options) {
         return this.#runOperation(async () => {
             const receipt = await this.binding.switchBranch(options);

package/dist/open-lix.js

@@ -1,5 +1,5 @@
 import { localFilesystemAlreadyOpen, localFilesystemNotOpen, } from "./errors.js";
-import { ACTIVE_BRANCH_CLIENT_STATE_KEY, openClientState, } from "./client-state.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 {
@@ -78,39 +78,35 @@ export async function openLix(options = {}) {
             return new Lix(await openRemoteLixBinding(options.server));
         }
         assertSnapshotStorage(options.storage);
-        const { openPersistentLixWorkerBinding } = await import("./worker/client.js");
-        const clientBinding = await openPersistentLixWorkerBinding({
+        const clientState = await openStoredClientState({
             storage: options.storage,
             namespace: remoteClientStateNamespace(options.server.url),
         });
-        let clientState;
-        try {
-            clientState = await openClientState({
-                binding: clientBinding,
-                closeBinding: true,
-            });
-        }
-        catch (error) {
-            await clientBinding.close().catch(() => undefined);
-            throw error;
-        }
         const restoredBranchId = clientState.get(ACTIVE_BRANCH_CLIENT_STATE_KEY);
+        const restoredAccountId = clientState.get(ACTIVE_ACCOUNT_CLIENT_STATE_KEY);
         let remoteBinding;
         try {
             try {
                 remoteBinding = await openRemoteLixBinding(options.server, {
                     initialActiveBranchId: restoredBranchId,
+                    initialActiveAccountId: restoredAccountId,
                 });
             }
             catch (error) {
                 if (!restoredBranchId || !isBranchNotFoundError(error))
                     throw error;
-                remoteBinding = await openRemoteLixBinding(options.server);
+                remoteBinding = await openRemoteLixBinding(options.server, {
+                    initialActiveAccountId: restoredAccountId,
+                });
             }
             const activeBranchId = await remoteBinding.activeBranchId();
+            const activeAccountId = await remoteBinding.activeAccountId();
             if (activeBranchId !== restoredBranchId) {
                 await clientState.set(ACTIVE_BRANCH_CLIENT_STATE_KEY, activeBranchId);
             }
+            if (activeAccountId !== restoredAccountId) {
+                await clientState.set(ACTIVE_ACCOUNT_CLIENT_STATE_KEY, activeAccountId);
+            }
             return new Lix(remoteBinding, clientState);
         }
         catch (error) {

package/dist/remote/client.d.ts

@@ -3,6 +3,7 @@ import type { RemoteLixServerOptions } from "../types.js";
 import { type RemoteHandshakeRequest } from "./protocol.js";
 type RemoteLixClientOptions = {
     initialActiveBranchId?: RemoteHandshakeRequest["activeBranchId"];
+    initialActiveAccountId?: RemoteHandshakeRequest["activeAccountId"];
 };
 export declare function openRemoteLixBinding(options: RemoteLixServerOptions, clientOptions?: RemoteLixClientOptions): Promise<LixBinding>;
 export {};

package/dist/remote/client.js

@@ -3,6 +3,7 @@ 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,28 @@ 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),
         });
     }
     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();
@@ -142,7 +156,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 +226,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 +271,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 () => {

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;
@@ -122,6 +124,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;
 };

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) {
@@ -66,6 +66,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 +77,7 @@ export function decodeHandshake(value) {
     return {
         protocolVersion: REMOTE_PROTOCOL_VERSION,
         activeBranchId: handshake.activeBranchId,
+        activeAccountId: handshake.activeAccountId,
         sessionId: handshake.sessionId,
     };
 }
@@ -127,7 +132,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 +159,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/types.d.ts

@@ -132,6 +132,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_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 __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_120697(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: 30501, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_120695);
             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_120695(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_120695(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_120697(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_120697(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_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 __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.js

@@ -1,4 +1,4 @@
-import { createWorkerConnection } from "#worker-factory";
+import { createWorkerConnection, openDirectLixBinding } from "#worker-factory";
 import { snapshotPersistenceAfterCommitError } from "../snapshot-persistence.js";
 import { deserializeWorkerError, } from "./protocol.js";
 const MAX_IDLE_WORKERS = 1;
@@ -26,6 +26,41 @@ export async function openLixWorker(storage, onDisposed, telemetry) {
 }
 /** Opens the local worker transport behind the semantic Lix binding. */
 export async function openLixWorkerBinding(storage, onDisposed, telemetry) {
+    if (openDirectLixBinding) {
+        const telemetryDispatch = telemetry
+            ? (span) => {
+                try {
+                    telemetry.onSpan(span);
+                }
+                catch {
+                    // Telemetry is observational and must not fail engine commands.
+                }
+            }
+            : undefined;
+        const binding = await openDirectLixBinding(storage, telemetryDispatch);
+        if (!onDisposed)
+            return binding;
+        let disposed = false;
+        return new Proxy(binding, {
+            get(target, property, receiver) {
+                if (property === "close") {
+                    return async () => {
+                        try {
+                            await target.close();
+                        }
+                        finally {
+                            if (!disposed) {
+                                disposed = true;
+                                onDisposed();
+                            }
+                        }
+                    };
+                }
+                const value = Reflect.get(target, property, receiver);
+                return typeof value === "function" ? value.bind(target) : value;
+            },
+        });
+    }
     const client = await openLixWorker(storage, onDisposed, telemetry);
     return workerBinding(client);
 }
@@ -95,12 +130,15 @@ function workerBinding(client) {
             return workerTransactionBinding(request, transactionId);
         },
         activeBranchId: () => request({ kind: "activeBranchId" }),
+        activeAccountId: () => request({ kind: "activeAccountId" }),
         clientStateEntries: () => request({ kind: "clientState.entries" }),
         clientStateGet: (key) => request({ kind: "clientState.get", key }),
         clientStateSet: (key, value) => request({ kind: "clientState.set", key, value }),
         clientStateDelete: (key) => request({ kind: "clientState.delete", key }),
         createBranch: (options) => request({ kind: "createBranch", options }),
         createCheckpoint: () => request({ kind: "createCheckpoint" }),
+        undo: () => request({ kind: "undo" }),
+        redo: () => request({ kind: "redo" }),
         switchBranch: (options) => request({ kind: "switchBranch", options }),
         importFilesystemPaths: (paths) => request({ kind: "importFilesystemPaths", paths }),
         mergeBranchPreview: (options) => request({ kind: "mergeBranchPreview", options }),
@@ -158,6 +196,7 @@ function persistentSnapshotBinding(binding, storage, namespace) {
             };
         },
         activeBranchId: () => binding.activeBranchId(),
+        activeAccountId: () => binding.activeAccountId(),
         clientStateEntries: () => {
             const method = binding.clientStateEntries;
             if (!method)
@@ -184,6 +223,8 @@ function persistentSnapshotBinding(binding, storage, namespace) {
         },
         createBranch: (branchOptions) => afterMutation(binding.createBranch(branchOptions)),
         createCheckpoint: () => afterMutation(binding.createCheckpoint()),
+        undo: () => afterMutation(binding.undo()),
+        redo: () => afterMutation(binding.redo()),
         switchBranch: (branchOptions) => afterMutation(binding.switchBranch(branchOptions)),
         importFilesystemPaths: (paths) => afterMutation(binding.importFilesystemPaths(paths)),
         mergeBranchPreview: (branchOptions) => binding.mergeBranchPreview(branchOptions),

package/dist/worker/factory.browser.d.ts

@@ -1,2 +1,4 @@
+import type { LixBinding, LixStorageConfig, TelemetryDispatch } from "../binding-types.js";
 import type { WorkerConnection } from "./protocol.js";
+export declare const openDirectLixBinding: undefined | ((storage: LixStorageConfig, telemetry?: TelemetryDispatch) => Promise<LixBinding>);
 export declare function createWorkerConnection(): WorkerConnection;

package/dist/worker/factory.browser.js

@@ -1,4 +1,6 @@
 /// <reference lib="webworker" />
+// Browser/Wasm execution stays off the main thread.
+export const openDirectLixBinding = undefined;
 export function createWorkerConnection() {
     const worker = new Worker(new URL("./entry.browser.js", import.meta.url), {
         type: "module",

package/dist/worker/factory.node.d.ts

@@ -1,2 +1,4 @@
+import type { LixBinding, LixStorageConfig, TelemetryDispatch } from "../binding-types.js";
 import type { WorkerConnection } from "./protocol.js";
 export declare function createWorkerConnection(): WorkerConnection;
+export declare const openDirectLixBinding: (storage: LixStorageConfig, telemetry?: TelemetryDispatch) => Promise<LixBinding>;

package/dist/worker/factory.node.js

@@ -1,4 +1,5 @@
 import { Worker } from "node:worker_threads";
+import { openLixBinding } from "../binding.node.js";
 export function createWorkerConnection() {
     const worker = new Worker(new URL("./entry.node.js", import.meta.url), {
         name: "lix",
@@ -33,3 +34,7 @@ export function createWorkerConnection() {
         },
     };
 }
+/// Native Lix already owns a dedicated serialized engine actor. Routing it
+/// through a second JavaScript worker adds two message-port hops per query
+/// without adding isolation or concurrency.
+export const openDirectLixBinding = (storage, telemetry) => openLixBinding(storage, telemetry);

package/dist/worker/host.js

@@ -87,6 +87,8 @@ export function startWorkerHost(endpoint) {
             }
             case "activeBranchId":
                 return requiredLix().activeBranchId();
+            case "activeAccountId":
+                return requiredLix().activeAccountId();
             case "clientState.entries":
                 return requiredClientStateMethod("clientStateEntries")();
             case "clientState.get":
@@ -99,6 +101,10 @@ export function startWorkerHost(endpoint) {
                 return requiredLix().createBranch(operation.options);
             case "createCheckpoint":
                 return requiredLix().createCheckpoint();
+            case "undo":
+                return requiredLix().undo();
+            case "redo":
+                return requiredLix().redo();
             case "switchBranch":
                 return requiredLix().switchBranch(operation.options);
             case "mergeBranchPreview":

package/dist/worker/protocol.d.ts

@@ -33,6 +33,8 @@ export type WorkerOperation = {
     transactionId: number;
 } | {
     kind: "activeBranchId";
+} | {
+    kind: "activeAccountId";
 } | {
     kind: "clientState.entries";
 } | {
@@ -50,6 +52,10 @@ export type WorkerOperation = {
     options: CreateBranchOptions;
 } | {
     kind: "createCheckpoint";
+} | {
+    kind: "undo";
+} | {
+    kind: "redo";
 } | {
     kind: "switchBranch";
     options: SwitchBranchOptions;

package/package.json

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