@lix-js/sdk 0.9.0 → 0.11.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();
@@ -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";
@@ -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();
@@ -158,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
@@ -170,10 +186,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,6 +1,8 @@
-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 = {
+    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>;
@@ -26,6 +29,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 +39,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>;
@@ -57,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

@@ -48,10 +48,13 @@ 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);
-        case "sqlite":
-            return addon.Lix.openSQLite(storage.path, nativeTelemetry);
+            if (nativeTelemetry)
+                return addon.Lix.openMemory(nativeTelemetry);
+            return addon.Lix.openMemory();
         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,141 @@ 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)) {
+        throw new Error("Stored Lix client state header is invalid");
+    }
+    let parsed;
+    try {
+        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 });
+    }
+    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

@@ -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, 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, 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,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, ExecuteBatchResult, 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[]>;
+    executeBatch(statements: readonly LixBatchStatement[], options?: LixBatchOptions): Promise<readonly ExecuteBatchResult[]>;
     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

@@ -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 = []) {
@@ -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);
@@ -327,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

@@ -1,18 +1,7 @@
 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 {
-    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;
@@ -78,39 +67,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) {
@@ -123,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)) {
@@ -166,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.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 {};