@lix-js/sdk 0.11.0 → 0.12.1

package/README.md

@@ -22,28 +22,28 @@ console.log(result.rows[0]?.get("message"));
 await lix.close();
 ```
 
-## Remote workspaces
+## Remote repositories
 
-Use the same Lix client as a thin client against a hosted workspace:
+Use the same Lix client as a thin client against a hosted repository:
 
 ```ts
 const lix = await openLix({
-	server: {
-		mode: "remote",
-		url: "https://lixray.com/@namespace/workspace",
-		headers: async () => ({
-			Authorization: `Bearer ${await accessToken()}`,
-		}),
-	},
+  server: {
+    mode: "remote",
+    url: "https://example.com/repositories/acme",
+    headers: async () => ({
+      Authorization: `Bearer ${await accessToken()}`,
+    }),
+  },
 });
 
 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, content) VALUES ($1, $2)",
-	["/hello.txt", new TextEncoder().encode("hello")],
-);
+await lix.execute("INSERT INTO lix_file (path, content) VALUES ($1, $2)", [
+  "/hello.txt",
+  new TextEncoder().encode("hello"),
+]);
 const update = await files.next();
 
 files.close();
@@ -55,59 +55,29 @@ open a local engine. Dynamic headers are resolved for every request and
 observation reconnect. An injected `fetch` can route requests through a service
 binding or another authorized server-side transport.
 
-Browser clients can opt into private, durable client state with the local
-storage adapter:
-
-```ts
-import { openLix } from "@lix-js/sdk";
-import { LocalStorage } from "@lix-js/sdk/local-storage-adapter";
-
-const lix = await openLix({
-	server: {
-		mode: "remote",
-		url: "https://lixray.com/@namespace/workspace",
-	},
-	storage: new LocalStorage(),
-});
-
-const previousUiState = lix.clientState.get("atelier-ui");
-await lix.clientState.set("atelier-ui", { sidebar: "history" });
-```
-
-`lix.clientState` is hydrated before `openLix()` resolves, so reads are
-synchronous. Its JSON values and the client's active branch are stored in a
-private local Lix snapshot; workspace SQL continues to execute only on the
-server. Reopening the same remote URL with the same storage restores both. Each
-remote server session is branch-pinned, so switching one client does not switch
-another client.
-
-After a remote branch switch succeeds, saving that branch as the next-reopen
-preference is best effort: a client-storage failure does not turn the completed
-server switch into a rejected operation. Explicit `lix.clientState.set()` and
-`.delete()` calls report durability failures to their caller. Because the local
-Rust transaction has already committed, `get()` continues to expose that live
-session value; a later successful snapshot save can make it durable.
+Remote server sessions are branch-pinned, so switching one client does not
+switch another client. Browser-local application state belongs to the
+application rather than the remote Lix handle.
 
 Filesystem sync uses native Node.js dependencies:
 
 ```ts
-import { LocalFilesystem, openLix } from "@lix-js/sdk";
+import { openLix } from "@lix-js/sdk";
+import { FilesystemStorage } from "@lix-js/storage-filesystem";
 
 const lix = await openLix({
-	storage: new LocalFilesystem({
-		path: "./workspace",
-		syncAllFiles: true,
-	}),
+  storage: new FilesystemStorage({ path: "./repository" }),
 });
 
 await lix.execute(
-	"INSERT INTO lix_file (path, content) VALUES ($1, $2) ON CONFLICT (path) DO UPDATE SET content = excluded.content",
-	["/hello.txt", new TextEncoder().encode("world")],
+  "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 content FROM lix_file WHERE path = $1", [
-	"/hello.txt",
-]);
+const result = await lix.execute(
+  "SELECT content FROM lix_file WHERE path = $1",
+  ["/hello.txt"],
+);
 const bytes = result.rows[0]?.value("content").asBytes();
 
 console.log(bytes && new TextDecoder().decode(bytes));
@@ -140,8 +110,8 @@ const draft = await lix.createBranch({ name: "Draft" });
 
 await lix.switchBranch({ branchId: draft.id });
 await lix.execute(
-	"INSERT INTO lix_file (path, content) VALUES ($1, $2) ON CONFLICT (path) DO UPDATE SET content = excluded.content",
-	["/status.txt", new TextEncoder().encode("draft")],
+  "INSERT INTO lix_file (path, content) VALUES ($1, $2) ON CONFLICT (path) DO UPDATE SET content = excluded.content",
+  ["/status.txt", new TextEncoder().encode("draft")],
 );
 
 await lix.switchBranch({ branchId: main });
@@ -155,30 +125,31 @@ const merge = await lix.mergeBranch({ sourceBranchId: draft.id });
 const tx = await lix.beginTransaction();
 
 try {
-	await tx.execute(
-		"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, content) VALUES ($1, $2) ON CONFLICT (path) DO UPDATE SET content = excluded.content",
-		["/b.txt", new TextEncoder().encode("2")],
-	);
-	await tx.commit();
+  await tx.execute(
+    "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, content) VALUES ($1, $2) ON CONFLICT (path) DO UPDATE SET content = excluded.content",
+    ["/b.txt", new TextEncoder().encode("2")],
+  );
+  await tx.commit();
 } catch (error) {
-	await tx.rollback();
-	throw error;
+  await tx.rollback();
+  throw error;
 }
 ```
 
 ## Notes
 
-- `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.
-- 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` is Node.js-only. Constructing it is safe in
+- `openLix()` opens a fresh in-memory Lix. Install `@lix-js/storage-filesystem` and pass `new FilesystemStorage({ path })` for a filesystem repository directory backed by `<path>/.lix/.internal/rocksdb`.
+- In browsers, pass `new IndexedDbStorage({ name })` to persist a complete local Lix across reloads.
+- Only one Lix handle may open an IndexedDB storage name at a time, including across browser tabs.
+- Pass `syncAllFiles: false` to start filesystem sync with no regular repository files, then call `storage.importPaths(["notes/today.md"])` on the `FilesystemStorage` instance to sync selected files. Imported paths are exact repository-relative file paths, not directories or globs.
+- In browsers, local mode and remote mode with IndexedDB storage load the Rust
+  engine as WebAssembly. In remote mode, the local engine contains only client
+  state.
+- `FilesystemStorage` 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
@@ -206,8 +177,9 @@ try {
   Hosts that apply one policy to every response can use
   `script-src 'self' 'wasm-unsafe-eval'; worker-src 'self'` globally
   instead. Worker-scoped headers keep those permissions out of the page.
+
 - SQL parameters use normal JavaScript values: `string`, finite `number`, `boolean`, `Uint8Array`, `null`, JSON-compatible arrays, and JSON-compatible plain objects.
-- Use `Value.integer(...)`, `Value.real(...)`, `Value.text(...)`, `Value.json(...)`, or `Value.blob(...)` only when you need to pass an explicit native Lix value.
+- Use `Value.integer(...)`, `Value.real(...)`, `Value.text(...)`, `Value.jsonb(...)`, `Value.timestamptz(...)`, or `Value.blob(...)` only when you need to pass an explicit native Lix value.
 
 ## Browser development
 

package/dist/binding-types.d.ts

@@ -1,5 +1,6 @@
-import type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, UndoReceipt, RedoReceipt, 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 } from "./types.js";
 import type { NativeLixValue } from "./value.js";
+import type { LixStorageAdapterConfig } from "./storage-adapter.js";
 export type BindingExecuteResult = {
     statementIndex?: number;
     label?: string;
@@ -30,13 +31,6 @@ export type LixBinding = {
     beginTransaction(): Promise<LixTransactionBinding>;
     activeBranchId(): Promise<string>;
     activeAccountId(): Promise<string>;
-    clientStateEntries?(): Promise<Array<{
-        key: string;
-        value: JsonValue;
-    }>>;
-    clientStateGet?(key: string): Promise<JsonValue | undefined>;
-    clientStateSet?(key: string, value: JsonValue): Promise<void>;
-    clientStateDelete?(key: string): Promise<void>;
     createBranch(options: CreateBranchOptions): Promise<CreateBranchReceipt>;
     createCheckpoint(): Promise<CreateCheckpointReceipt>;
     undo(): Promise<UndoReceipt>;
@@ -46,7 +40,7 @@ export type LixBinding = {
     mergeBranchPreview(options: MergeBranchOptions): Promise<MergeBranchPreview>;
     mergeBranch(options: MergeBranchOptions): Promise<MergeBranchReceipt>;
     syncDiskToLix(): Promise<void>;
-    /** Internal snapshot capability implemented by browser memory bindings. */
+    /** Explicit snapshot utility available on direct in-memory WASM bindings. */
     exportSnapshot?(): Promise<Uint8Array>;
     close(): Promise<void>;
 };
@@ -62,10 +56,7 @@ export type ObserveEventsBinding = {
 export type TelemetryDispatch = (span: LixTelemetrySpan) => void;
 export type LixStorageConfig = {
     kind: "memory";
-    snapshot?: Uint8Array;
 } | {
-    kind: "localFilesystem";
-    path: string;
-    lixDir?: string;
-    syncAllFiles: boolean;
-};
+    kind: "indexedDb";
+    name: string;
+} | LixStorageAdapterConfig;

package/dist/binding.browser.js

@@ -1,14 +1,27 @@
+import { IndexedDbBackend } from "./indexeddb-backend.js";
 // Generated before TypeScript compilation and emitted beside this module.
 // @ts-expect-error Generated by build:wasm.
-import initWasm, { openMemoryFromSnapshot } from "./wasm/lix_js_sdk.js";
+import initWasm, { openIndexedDb, openMemory } from "./wasm/lix_js_sdk.js";
 let wasmInitialized;
 function initializeWasm() {
     return (wasmInitialized ??= initWasm());
 }
 export async function openLixBinding(storage, telemetry) {
-    if (storage.kind !== "memory") {
-        throw new Error("LocalFilesystem is only available in Node.js");
-    }
     await initializeWasm();
-    return openMemoryFromSnapshot(telemetry, storage.snapshot);
+    switch (storage.kind) {
+        case "memory":
+            return openMemory(telemetry);
+        case "indexedDb": {
+            const backend = await IndexedDbBackend.open(storage.name);
+            try {
+                return (await openIndexedDb(backend, telemetry));
+            }
+            catch (error) {
+                await backend.close().catch(() => undefined);
+                throw error;
+            }
+        }
+        case "filesystem":
+            throw new Error("FilesystemStorage is only available in Node.js");
+    }
 }

package/dist/binding.node.js

@@ -45,16 +45,15 @@ export function openLixBinding(storage, telemetry) {
         : undefined;
     switch (storage.kind) {
         case "memory":
-            if (storage.snapshot !== undefined) {
-                throw new Error("Memory snapshots are only available in the browser binding");
-            }
             if (nativeTelemetry)
                 return addon.Lix.openMemory(nativeTelemetry);
             return addon.Lix.openMemory();
-        case "localFilesystem":
+        case "indexedDb":
+            throw new Error("IndexedDbStorage is only available in browsers");
+        case "filesystem":
             if (nativeTelemetry) {
-                return addon.Lix.openLocalFilesystem(storage.path, storage.lixDir, storage.syncAllFiles, nativeTelemetry);
+                return addon.Lix.openFilesystemStorage(storage.path, storage.syncAllFiles, nativeTelemetry);
             }
-            return addon.Lix.openLocalFilesystem(storage.path, storage.lixDir, storage.syncAllFiles);
+            return addon.Lix.openFilesystemStorage(storage.path, storage.syncAllFiles);
     }
 }

package/dist/errors.d.ts

@@ -5,5 +5,3 @@ export type LixJsError = Error & {
 };
 export declare function invalidArgument(operation: string, argument: string, expected: string, actual: string, receiver?: string): LixJsError;
 export declare function invalidParam(index: number, message: string, actual: string): LixJsError;
-export declare function localFilesystemNotOpen(operation: string): LixJsError;
-export declare function localFilesystemAlreadyOpen(): LixJsError;

package/dist/errors.js

@@ -17,16 +17,3 @@ export function invalidParam(index, message, actual) {
     };
     return error;
 }
-export function localFilesystemNotOpen(operation) {
-    const error = new Error(`LocalFilesystem.${operation}() requires the storage to be opened with openLix() first`);
-    error.name = "LixError";
-    error.code = "LIX_LOCAL_FILESYSTEM_NOT_OPEN";
-    error.details = { operation };
-    return error;
-}
-export function localFilesystemAlreadyOpen() {
-    const error = new Error("openLix() LocalFilesystem is already open; close the existing Lix or create a new LocalFilesystem");
-    error.name = "LixError";
-    error.code = "LIX_LOCAL_FILESYSTEM_IN_USE";
-    return error;
-}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { LocalFilesystem, Lix, LixTransaction, ObserveEvents, openLix, } from "./open-lix.js";
+export { IndexedDbStorage, Lix, LixTransaction, ObserveEvents, openLix, } from "./open-lix.js";
+export type { LixStorage, LixStorageAdapterConfig, LixStorageConnection, } from "./storage-adapter.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, SwitchBranchOptions, SwitchBranchReceipt, } from "./types.js";
+export type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, LixBatchOptions, LixBatchStatement, IndexedDbStorageOptions, JsonValue, LixValue, MergeBranchOptions, MergeBranchOutcome, MergeBranchPreview, MergeBranchReceipt, MergeChangeStats, MergeConflict, MergeConflictSide, ObserveEvent, OpenLixOptions, LixTelemetryOptions, LixTelemetrySpan, RemoteLixFetch, RemoteLixServerOptions, UndoReceipt, SqlParam, SwitchBranchOptions, SwitchBranchReceipt, } from "./types.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { LocalFilesystem, Lix, LixTransaction, ObserveEvents, openLix, } from "./open-lix.js";
+export { IndexedDbStorage, 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/indexeddb-backend.d.ts

@@ -0,0 +1,19 @@
+type IndexedDbEntry = {
+    key: Uint8Array;
+    value: Uint8Array;
+};
+type IndexedDbChanges = {
+    deletes: Uint8Array[];
+    puts: IndexedDbEntry[];
+    strictDurability: boolean;
+};
+/** Internal worker-local bridge used by the WASM IndexedDB storage adapter. */
+export declare class IndexedDbBackend {
+    #private;
+    private constructor();
+    static open(name: string): Promise<IndexedDbBackend>;
+    loadEntries(): Promise<IndexedDbEntry[]>;
+    applyChanges(changes: IndexedDbChanges): Promise<void>;
+    close(): Promise<void>;
+}
+export {};

package/dist/indexeddb-backend.js

@@ -0,0 +1,121 @@
+const DATABASE_VERSION = 1;
+const ENTRY_STORE = "entries";
+/** Internal worker-local bridge used by the WASM IndexedDB storage adapter. */
+export class IndexedDbBackend {
+    #database;
+    #releaseLock;
+    #closed = false;
+    constructor(database, releaseLock) {
+        this.#database = database;
+        this.#releaseLock = releaseLock;
+    }
+    static async open(name) {
+        const releaseLock = await acquireDatabaseLock(name);
+        try {
+            const request = indexedDB.open(name, DATABASE_VERSION);
+            request.onupgradeneeded = () => {
+                if (!request.result.objectStoreNames.contains(ENTRY_STORE)) {
+                    request.result.createObjectStore(ENTRY_STORE);
+                }
+            };
+            return new IndexedDbBackend(await openDatabase(request), releaseLock);
+        }
+        catch (error) {
+            releaseLock();
+            throw error;
+        }
+    }
+    async loadEntries() {
+        const transaction = this.#database.transaction(ENTRY_STORE, "readonly");
+        const store = transaction.objectStore(ENTRY_STORE);
+        const entries = [];
+        await new Promise((resolve, reject) => {
+            const request = store.openCursor();
+            request.onerror = () => reject(request.error ?? transaction.error);
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (!cursor) {
+                    resolve();
+                    return;
+                }
+                try {
+                    entries.push({
+                        key: copyBytes(cursor.key, "IndexedDB entry key"),
+                        value: copyBytes(cursor.value, "IndexedDB entry value"),
+                    });
+                }
+                catch (error) {
+                    transaction.abort();
+                    reject(error);
+                    return;
+                }
+                cursor.continue();
+            };
+        });
+        await transactionDone(transaction);
+        return entries;
+    }
+    async applyChanges(changes) {
+        const transaction = this.#database.transaction(ENTRY_STORE, "readwrite", {
+            durability: changes.strictDurability ? "strict" : "default",
+        });
+        const store = transaction.objectStore(ENTRY_STORE);
+        for (const key of changes.deletes)
+            store.delete(binaryKey(key));
+        for (const entry of changes.puts) {
+            store.put(entry.value, binaryKey(entry.key));
+        }
+        await transactionDone(transaction);
+    }
+    async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#database.close();
+        this.#releaseLock();
+    }
+}
+function acquireDatabaseLock(name) {
+    let release;
+    const released = new Promise((resolve) => {
+        release = resolve;
+    });
+    return new Promise((resolve, reject) => {
+        void navigator.locks
+            .request(`lix:indexeddb:${name}`, { mode: "exclusive", ifAvailable: true }, async (lock) => {
+            if (!lock) {
+                reject(new Error(`IndexedDB storage '${name}' is already open`));
+                return;
+            }
+            resolve(release);
+            await released;
+        })
+            .catch(reject);
+    });
+}
+function openDatabase(request) {
+    return new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+        request.onblocked = () => reject(new Error("IndexedDB database open was blocked"));
+    });
+}
+function binaryKey(value) {
+    return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+}
+function transactionDone(transaction) {
+    return new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve();
+        transaction.onabort = () => reject(transaction.error);
+        transaction.onerror = () => reject(transaction.error);
+    });
+}
+function copyBytes(value, label) {
+    if (value instanceof ArrayBuffer) {
+        return new Uint8Array(value.slice(0));
+    }
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+    }
+    throw new Error(`${label} is not binary data`);
+}

package/dist/lix.d.ts

@@ -1,13 +1,10 @@
-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, 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?: ManagedClientState | undefined);
+    constructor(binding: LixBinding);
     execute(sql: string, params?: SqlParam[], options?: ExecuteOptions): Promise<ExecuteResult>;
     executeBatch(statements: readonly LixBatchStatement[], options?: LixBatchOptions): Promise<readonly ExecuteBatchResult[]>;
     observe(sql: string, params?: SqlParam[]): ObserveEvents;

package/dist/lix.js

@@ -1,7 +1,5 @@
 import { invalidArgument } from "./errors.js";
-import { ACTIVE_BRANCH_CLIENT_STATE_KEY, unavailableClientState, } from "./client-state.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 }) => {
     void transaction
@@ -17,9 +15,7 @@ const observeFinalizer = new FinalizationRegistry(({ observe, onClose }) => {
 });
 export class Lix {
     binding;
-    managedClientState;
     closePromise;
-    clientState;
     #activeBranchListeners = new Set();
     #inFlightOperations = new Set();
     #observations = new Map();
@@ -27,20 +23,8 @@ export class Lix {
     #transactionsOpening = 0;
     #activeTransactions = 0;
     #acceptingOperations = true;
-    constructor(binding, managedClientState) {
+    constructor(binding) {
         this.binding = binding;
-        this.managedClientState = managedClientState;
-        this.clientState = managedClientState
-            ? {
-                get: (key) => managedClientState.get(key),
-                set: (key, value) => this.#runOperation(() => managedClientState.set(key, value)),
-                delete: (key) => this.#runOperation(() => managedClientState.delete(key)),
-                subscribe: (listener) => {
-                    this.#assertAcceptingOperations();
-                    return managedClientState.subscribe(listener);
-                },
-            }
-            : unavailableClientState();
     }
     async execute(sql, params = [], options) {
         assertExecuteArgs("lix", sql, params, options);
@@ -110,16 +94,6 @@ export class Lix {
     async switchBranch(options) {
         return this.#runOperation(async () => {
             const receipt = await this.binding.switchBranch(options);
-            try {
-                if (this.managedClientState) {
-                    await this.managedClientState.set(ACTIVE_BRANCH_CLIENT_STATE_KEY, receipt.branchId);
-                }
-            }
-            catch {
-                // The remote branch switch already committed. Client persistence is a
-                // best-effort reopen preference and cannot turn that success into a
-                // rejected switch with ambiguous branch state.
-            }
             for (const listener of [...this.#activeBranchListeners]) {
                 try {
                     listener();
@@ -155,9 +129,13 @@ export class Lix {
             this.#observations.clear();
             this.closePromise = (async () => {
                 await Promise.allSettled([...this.#inFlightOperations]);
-                await this.binding.close();
-                await this.managedClientState?.close();
+                const results = await Promise.allSettled([
+                    Promise.resolve().then(() => this.binding.close()),
+                ]);
                 this.#activeBranchListeners.clear();
+                const failure = results.find((result) => result.status === "rejected");
+                if (failure)
+                    throw failure.reason;
             })();
         }
         await this.closePromise;
@@ -256,31 +234,22 @@ export class LixTransaction {
             throw transactionClosedError();
         if (!this.finishPromise) {
             this.finishPromise = (async () => {
-                if (kind === "transaction.commit")
-                    await this.binding.commit();
-                else
-                    await this.binding.rollback();
-                this.finished = true;
-                transactionFinalizer.unregister(this);
-                this.onFinish();
+                try {
+                    if (kind === "transaction.commit")
+                        await this.binding.commit();
+                    else
+                        await this.binding.rollback();
+                }
+                finally {
+                    // A terminal binding call consumes the underlying transaction even
+                    // when its durable commit or rollback reports an error.
+                    this.finished = true;
+                    transactionFinalizer.unregister(this);
+                    this.onFinish();
+                }
             })();
         }
-        try {
-            await this.finishPromise;
-        }
-        catch (error) {
-            if (isSnapshotPersistenceAfterCommitError(error)) {
-                // The transaction finished in Rust; only durable snapshot saving
-                // failed. Release the transaction lifecycle while reporting that
-                // durability failure to the caller.
-                this.finished = true;
-                transactionFinalizer.unregister(this);
-                this.onFinish();
-                throw error;
-            }
-            this.finishPromise = undefined;
-            throw error;
-        }
+        await this.finishPromise;
     }
 }
 function transactionClosedError() {

package/dist/open-lix.d.ts

@@ -1,13 +1,8 @@
 import { Lix } from "./lix.js";
-import type { LocalFilesystemOptions, OpenLixOptions } from "./types.js";
+import type { IndexedDbStorageOptions, OpenLixOptions } from "./types.js";
 export { Lix, LixTransaction, ObserveEvents } from "./lix.js";
-export declare class LocalFilesystem {
-    readonly path: string;
-    readonly lixDir: string | undefined;
-    readonly syncAllFiles: boolean;
-    constructor(options: LocalFilesystemOptions);
-    importPaths(paths: readonly string[]): Promise<void>;
-    syncDiskToLix(): Promise<void>;
-    private client;
+export declare class IndexedDbStorage {
+    readonly name: string;
+    constructor(options: IndexedDbStorageOptions);
 }
 export declare function openLix(options?: OpenLixOptions): Promise<Lix>;