@lix-js/sdk 0.11.0 → 0.12.1

package/dist/types.d.ts

@@ -1,7 +1,9 @@
-export type LocalFilesystemOptions = {
-    path: string;
-    lixDir?: string;
-    syncAllFiles: boolean;
+export type IndexedDbStorageOptions = {
+    /**
+     * Identifies one persistent Lix database within the current origin.
+     * A database name can be opened by only one Lix handle at a time.
+     */
+    name: string;
 };
 export type RemoteLixFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 export type RemoteLixServerOptions = {
@@ -21,27 +23,12 @@ export type LixTelemetrySpan = {
 export type LixTelemetryOptions = {
     onSpan(span: LixTelemetrySpan): void;
 };
-/**
- * Persists opaque Lix snapshots under SDK-provided namespaces.
- *
- * Implementations must treat snapshots as bytes owned by Lix. The namespace
- * selects one logical Lix and allows a single adapter to persist more than one
- * instance without collisions.
- */
-export interface LixSnapshotStorage {
-    load(namespace: string): Promise<Uint8Array | undefined>;
-    save(namespace: string, snapshot: Uint8Array): Promise<void>;
-}
 export type OpenLixOptions = {
-    storage?: import("./open-lix.js").LocalFilesystem | LixSnapshotStorage;
+    storage?: import("./storage-adapter.js").LixStorage | import("./open-lix.js").IndexedDbStorage;
     server?: never;
     telemetry?: LixTelemetryOptions;
 } | {
-    /**
-     * Optional client-local storage. In remote mode workspace SQL remains on
-     * the server; only `lix.clientState` is stored here.
-     */
-    storage?: LixSnapshotStorage;
+    storage?: never;
     server: RemoteLixServerOptions;
     telemetry?: never;
 };
@@ -61,8 +48,11 @@ export type LixValue = {
     kind: "text";
     value: string;
 } | {
-    kind: "json";
+    kind: "jsonb";
     value: JsonValue;
+} | {
+    kind: "timestamptz";
+    value: string;
 } | {
     kind: "blob";
     value: Uint8Array;
@@ -188,9 +178,9 @@ export type MergeChangeStats = {
     removed: number;
 };
 export type MergeConflict = {
-    kind: "sameEntityChanged";
+    kind: "sameRowChanged";
     schemaKey: string;
-    entityPk: unknown;
+    rowPk: unknown;
     fileId: string | null;
     target: MergeConflictSide;
     source: MergeConflictSide;

package/dist/value.d.ts

@@ -8,7 +8,8 @@ export declare class Value {
     static integer(value: number): Value;
     static real(value: number): Value;
     static text(value: string): Value;
-    static json(value: JsonValue): Value;
+    static jsonb(value: JsonValue): Value;
+    static timestamptz(value: string): Value;
     static blob(value: Uint8Array): Value;
     static from(value: SqlParam): Value;
     static _fromNative(value: LixValue): Value;

package/dist/value.js

@@ -2,9 +2,9 @@ import { invalidParam } from "./errors.js";
 export class Value {
     kind;
     #raw;
-    constructor(raw) {
+    constructor(raw, clone = true) {
         validateExplicitValue(raw);
-        this.#raw = cloneValue(raw);
+        this.#raw = clone ? cloneValue(raw) : raw;
         this.kind = this.#raw.kind;
     }
     static null() {
@@ -22,8 +22,11 @@ export class Value {
     static text(value) {
         return new Value({ kind: "text", value });
     }
-    static json(value) {
-        return new Value({ kind: "json", value });
+    static jsonb(value) {
+        return new Value({ kind: "jsonb", value });
+    }
+    static timestamptz(value) {
+        return new Value({ kind: "timestamptz", value });
     }
     static blob(value) {
         return new Value({ kind: "blob", value });
@@ -32,7 +35,11 @@ export class Value {
         return new Value(normalizeParam(value));
     }
     static _fromNative(value) {
-        return new Value(value);
+        // Native execute results are newly materialized for this result set. Keep
+        // the native value as-is and defer the defensive copy until toJS(). This
+        // avoids cloning every structured result once during row wrapping and
+        // again when callers read it.
+        return new Value(value, false);
     }
     _toNative() {
         return toNativeValue(this.#raw);
@@ -101,7 +108,7 @@ export function normalizeParam(value, index = 0, seen = new WeakSet()) {
             throw invalidParam(index, "typed array SQL parameters must be Uint8Array", value.constructor.name);
         }
         assertJsonSerializable(value, seen, index);
-        return { kind: "json", value };
+        return { kind: "jsonb", value };
     }
     throw invalidParam(index, `${typeof value} is not a valid SQL parameter`, typeof value);
 }
@@ -113,7 +120,8 @@ function unwrapValue(value) {
         case "integer":
         case "real":
         case "text":
-        case "json":
+        case "timestamptz":
+        case "jsonb":
             return cloneJsonValue(value.value);
         case "blob":
             return new Uint8Array(value.value);
@@ -193,9 +201,14 @@ function validateExplicitValue(value) {
                 throw invalidParam(0, "string SQL parameters must be well-formed UTF-16", "string");
             }
             return;
-        case "json":
+        case "jsonb":
             assertJsonSerializable(value.value, new WeakSet(), 0);
             return;
+        case "timestamptz":
+            if (typeof value.value === "string" && !Number.isNaN(Date.parse(value.value))) {
+                return;
+            }
+            break;
         case "blob":
             if (value.value instanceof Uint8Array)
                 return;
@@ -209,8 +222,8 @@ function cloneValue(value) {
     if (value.kind === "blob") {
         return { kind: "blob", value: new Uint8Array(value.value) };
     }
-    if (value.kind === "json") {
-        return { kind: "json", value: cloneJsonValue(value.value) };
+    if (value.kind === "jsonb") {
+        return { kind: "jsonb", value: cloneJsonValue(value.value) };
     }
     return value;
 }

package/dist/wasm/lix_js_sdk.d.ts

@@ -8,10 +8,6 @@ export class WasmLix {
     activeAccountId(): Promise<string>;
     activeBranchId(): Promise<string>;
     beginTransaction(): Promise<WasmLixTransaction>;
-    clientStateDelete(key: string): Promise<void>;
-    clientStateEntries(): Promise<any>;
-    clientStateGet(key: string): Promise<any>;
-    clientStateSet(key: string, value: any): Promise<void>;
     close(): Promise<void>;
     createBranch(options: any): Promise<any>;
     createCheckpoint(): Promise<any>;
@@ -43,6 +39,8 @@ export class WasmObserveEvents {
     next(): Promise<any>;
 }
 
+export function openIndexedDb(backend: any, telemetry_dispatch?: Function | null): Promise<WasmLix>;
+
 export function openMemory(telemetry_dispatch?: Function | null): Promise<WasmLix>;
 
 export function openMemoryFromSnapshot(telemetry_dispatch?: Function | null, snapshot?: Uint8Array | null): Promise<WasmLix>;
@@ -56,16 +54,13 @@ export interface InitOutput {
     readonly __wbg_wasmlix_free: (a: number, b: number) => void;
     readonly __wbg_wasmlixtransaction_free: (a: number, b: number) => void;
     readonly __wbg_wasmobserveevents_free: (a: number, b: number) => void;
+    readonly openIndexedDb: (a: number, b: number) => number;
     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;
-    readonly wasmlix_clientStateEntries: (a: number) => number;
-    readonly wasmlix_clientStateGet: (a: number, b: number, c: number) => number;
-    readonly wasmlix_clientStateSet: (a: number, b: number, c: number, d: number) => number;
     readonly wasmlix_close: (a: number) => number;
     readonly wasmlix_createBranch: (a: number, b: number) => number;
     readonly wasmlix_createCheckpoint: (a: number) => number;
@@ -83,8 +78,8 @@ export interface InitOutput {
     readonly wasmlixtransaction_rollback: (a: number) => number;
     readonly wasmobserveevents_close: (a: number) => void;
     readonly wasmobserveevents_next: (a: number) => number;
-    readonly __wasm_bindgen_func_elem_122229: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_122231: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_119237: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_119239: (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

@@ -38,44 +38,6 @@ export class WasmLix {
         const ret = wasm.wasmlix_beginTransaction(this.__wbg_ptr);
         return takeObject(ret);
     }
-    /**
-     * @param {string} key
-     * @returns {Promise<void>}
-     */
-    clientStateDelete(key) {
-        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmlix_clientStateDelete(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
-    /**
-     * @returns {Promise<any>}
-     */
-    clientStateEntries() {
-        const ret = wasm.wasmlix_clientStateEntries(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-     * @param {string} key
-     * @returns {Promise<any>}
-     */
-    clientStateGet(key) {
-        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmlix_clientStateGet(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
-    /**
-     * @param {string} key
-     * @param {any} value
-     * @returns {Promise<void>}
-     */
-    clientStateSet(key, value) {
-        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmlix_clientStateSet(this.__wbg_ptr, ptr0, len0, addHeapObject(value));
-        return takeObject(ret);
-    }
     /**
      * @returns {Promise<void>}
      */
@@ -254,6 +216,16 @@ export class WasmObserveEvents {
 }
 if (Symbol.dispose) WasmObserveEvents.prototype[Symbol.dispose] = WasmObserveEvents.prototype.free;
 
+/**
+ * @param {any} backend
+ * @param {Function | null} [telemetry_dispatch]
+ * @returns {Promise<WasmLix>}
+ */
+export function openIndexedDb(backend, telemetry_dispatch) {
+    const ret = wasm.openIndexedDb(addHeapObject(backend), isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch));
+    return takeObject(ret);
+}
+
 /**
  * @param {Function | null} [telemetry_dispatch]
  * @returns {Promise<WasmLix>}
@@ -390,6 +362,10 @@ function __wbg_get_imports() {
         __wbg__wbg_cb_unref_61db23ac97f16c31: function(arg0) {
             getObject(arg0)._wbg_cb_unref();
         },
+        __wbg_applyChanges_e055d59b63743afd: function(arg0, arg1) {
+            const ret = getObject(arg0).applyChanges(takeObject(arg1));
+            return addHeapObject(ret);
+        },
         __wbg_call_8a89609d89f6608a: function() { return handleError(function (arg0, arg1) {
             const ret = getObject(arg0).call(getObject(arg1));
             return addHeapObject(ret);
@@ -398,6 +374,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_close_93c7ea4f94bb464a: function(arg0) {
+            const ret = getObject(arg0).close();
+            return addHeapObject(ret);
+        },
         __wbg_done_60cf307fcc680536: function(arg0) {
             const ret = getObject(arg0).done;
             return ret;
@@ -501,6 +481,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).length;
             return ret;
         },
+        __wbg_loadEntries_7336ebc0a13d5ac7: function(arg0) {
+            const ret = getObject(arg0).loadEntries();
+            return addHeapObject(ret);
+        },
         __wbg_new_0_445c13a750296eb6: function() {
             const ret = new Date();
             return addHeapObject(ret);
@@ -536,7 +520,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_122231(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_119239(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -625,6 +609,10 @@ function __wbg_get_imports() {
             const ret = typeof window === 'undefined' ? null : window;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         },
+        __wbg_then_18f476d590e58992: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        },
         __wbg_then_ac7b025999b52837: function(arg0, arg1) {
             const ret = getObject(arg0).then(getObject(arg1));
             return addHeapObject(ret);
@@ -646,8 +634,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: 30525, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_122229);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 28427, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_119237);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0) {
@@ -696,10 +684,10 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_122229(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_119237(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_122229(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_119237(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -710,8 +698,8 @@ function __wasm_bindgen_func_elem_122229(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_122231(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_122231(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_119239(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_119239(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const WasmLixFinalization = (typeof FinalizationRegistry === 'undefined')

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

@@ -4,16 +4,13 @@ export const memory: WebAssembly.Memory;
 export const __wbg_wasmlix_free: (a: number, b: number) => void;
 export const __wbg_wasmlixtransaction_free: (a: number, b: number) => void;
 export const __wbg_wasmobserveevents_free: (a: number, b: number) => void;
+export const openIndexedDb: (a: number, b: number) => number;
 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;
-export const wasmlix_clientStateEntries: (a: number) => number;
-export const wasmlix_clientStateGet: (a: number, b: number, c: number) => number;
-export const wasmlix_clientStateSet: (a: number, b: number, c: number, d: number) => number;
 export const wasmlix_close: (a: number) => number;
 export const wasmlix_createBranch: (a: number, b: number) => number;
 export const wasmlix_createCheckpoint: (a: number) => number;
@@ -31,8 +28,8 @@ export const wasmlixtransaction_execute: (a: number, b: number, c: number, d: nu
 export const wasmlixtransaction_rollback: (a: number) => number;
 export const wasmobserveevents_close: (a: number) => void;
 export const wasmobserveevents_next: (a: number) => number;
-export const __wasm_bindgen_func_elem_122229: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_122231: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_119237: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_119239: (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.d.ts

@@ -1,20 +1,9 @@
 import type { LixBinding, LixStorageConfig } from "../binding-types.js";
-import type { LixSnapshotStorage, LixTelemetryOptions } from "../types.js";
+import type { LixTelemetryOptions } from "../types.js";
 import { type WorkerConnection, type WorkerNotification, type WorkerOperation } from "./protocol.js";
 export declare function openLixWorker(storage: LixStorageConfig, onDisposed?: () => void, telemetry?: LixTelemetryOptions): Promise<LixWorkerClient>;
 /** Opens the local worker transport behind the semantic Lix binding. */
 export declare function openLixWorkerBinding(storage: LixStorageConfig, onDisposed?: () => void, telemetry?: LixTelemetryOptions): Promise<LixBinding>;
-export type OpenPersistentLixWorkerBindingOptions = {
-    storage: LixSnapshotStorage;
-    namespace: string;
-    telemetry?: LixTelemetryOptions;
-};
-/**
- * Opens a browser memory binding from an opaque snapshot and persists a fresh
- * snapshot after every successful mutation. This is an internal composition
- * seam for public storage adapters; it does not route workspace operations.
- */
-export declare function openPersistentLixWorkerBinding(options: OpenPersistentLixWorkerBindingOptions): Promise<LixBinding>;
 export declare class LixWorkerClient {
     private readonly connection;
     private nextRequestId;

package/dist/worker/client.js

@@ -1,5 +1,4 @@
 import { createWorkerConnection, openDirectLixBinding } from "#worker-factory";
-import { snapshotPersistenceAfterCommitError } from "../snapshot-persistence.js";
 import { deserializeWorkerError, } from "./protocol.js";
 const MAX_IDLE_WORKERS = 1;
 // The common serial reopen path retains one worker so its prepared plugin cache
@@ -64,43 +63,6 @@ export async function openLixWorkerBinding(storage, onDisposed, telemetry) {
     const client = await openLixWorker(storage, onDisposed, telemetry);
     return workerBinding(client);
 }
-/**
- * Opens a browser memory binding from an opaque snapshot and persists a fresh
- * snapshot after every successful mutation. This is an internal composition
- * seam for public storage adapters; it does not route workspace operations.
- */
-export async function openPersistentLixWorkerBinding(options) {
-    if (!options || typeof options !== "object") {
-        throw new TypeError("openPersistentLixWorkerBinding() options must be an object");
-    }
-    if (!options.storage ||
-        typeof options.storage.load !== "function" ||
-        typeof options.storage.save !== "function") {
-        throw new TypeError("openPersistentLixWorkerBinding() storage must implement load() and save()");
-    }
-    if (typeof options.namespace !== "string" || options.namespace.length === 0) {
-        throw new TypeError("openPersistentLixWorkerBinding() namespace must be a non-empty string");
-    }
-    const snapshot = await options.storage.load(options.namespace);
-    if (snapshot !== undefined && !(snapshot instanceof Uint8Array)) {
-        throw new TypeError("Snapshot storage load() must return a Uint8Array");
-    }
-    const binding = await openLixWorkerBinding({
-        kind: "memory",
-        ...(snapshot === undefined ? {} : { snapshot }),
-    }, undefined, options.telemetry);
-    const persistent = persistentSnapshotBinding(binding, options.storage, options.namespace);
-    if (snapshot === undefined) {
-        try {
-            await persistent.persist();
-        }
-        catch (error) {
-            await binding.close().catch(() => undefined);
-            throw error;
-        }
-    }
-    return persistent.binding;
-}
 function workerBinding(client) {
     let closed = false;
     const request = (operation) => {
@@ -131,10 +93,6 @@ function workerBinding(client) {
         },
         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" }),
@@ -144,7 +102,6 @@ function workerBinding(client) {
         mergeBranchPreview: (options) => request({ kind: "mergeBranchPreview", options }),
         mergeBranch: (options) => request({ kind: "mergeBranch", options }),
         syncDiskToLix: () => request({ kind: "syncDiskToLix" }),
-        exportSnapshot: () => request({ kind: "exportSnapshot" }),
         close: async () => {
             if (closed)
                 return;
@@ -154,124 +111,6 @@ function workerBinding(client) {
         },
     };
 }
-function persistentSnapshotBinding(binding, storage, namespace) {
-    let persistenceTail = Promise.resolve();
-    let closePromise;
-    let bindingClosed = false;
-    const persist = () => {
-        const operation = persistenceTail.then(async () => {
-            const exportSnapshot = binding.exportSnapshot;
-            if (!exportSnapshot) {
-                throw new Error("The open Lix binding does not support snapshot export");
-            }
-            const snapshot = await exportSnapshot.call(binding);
-            await storage.save(namespace, snapshot);
-        });
-        persistenceTail = operation.catch(() => undefined);
-        return operation;
-    };
-    const afterMutation = async (operation) => {
-        const result = await operation;
-        try {
-            await persist();
-        }
-        catch (error) {
-            // The Rust transaction is already committed. Preserve that fact so
-            // synchronous facades can reflect the live session value while still
-            // reporting that durability failed.
-            throw snapshotPersistenceAfterCommitError(error);
-        }
-        return result;
-    };
-    const persistentBinding = {
-        execute: (sql, params, executeOptions) => afterMutation(binding.execute(sql, params, executeOptions)),
-        executeBatch: (statements, batchOptions) => afterMutation(binding.executeBatch(statements, batchOptions)),
-        observe: (sql, params) => binding.observe(sql, params),
-        beginTransaction: async () => {
-            const transaction = await binding.beginTransaction();
-            return {
-                execute: (sql, params, executeOptions) => transaction.execute(sql, params, executeOptions),
-                commit: () => afterMutation(transaction.commit()),
-                rollback: () => transaction.rollback(),
-            };
-        },
-        activeBranchId: () => binding.activeBranchId(),
-        activeAccountId: () => binding.activeAccountId(),
-        clientStateEntries: () => {
-            const method = binding.clientStateEntries;
-            if (!method)
-                return Promise.reject(clientStateUnsupportedError());
-            return method.call(binding);
-        },
-        clientStateGet: (key) => {
-            const method = binding.clientStateGet;
-            if (!method)
-                return Promise.reject(clientStateUnsupportedError());
-            return method.call(binding, key);
-        },
-        clientStateSet: (key, value) => {
-            const method = binding.clientStateSet;
-            if (!method)
-                return Promise.reject(clientStateUnsupportedError());
-            return afterMutation(method.call(binding, key, value));
-        },
-        clientStateDelete: (key) => {
-            const method = binding.clientStateDelete;
-            if (!method)
-                return Promise.reject(clientStateUnsupportedError());
-            return afterMutation(method.call(binding, key));
-        },
-        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),
-        mergeBranch: (branchOptions) => afterMutation(binding.mergeBranch(branchOptions)),
-        syncDiskToLix: () => afterMutation(binding.syncDiskToLix()),
-        exportSnapshot: () => {
-            const exportSnapshot = binding.exportSnapshot;
-            if (!exportSnapshot) {
-                return Promise.reject(new Error("The open Lix binding does not support snapshot export"));
-            }
-            return exportSnapshot.call(binding);
-        },
-        close: () => {
-            if (closePromise)
-                return closePromise;
-            closePromise = (async () => {
-                let persistenceError;
-                try {
-                    await persist();
-                }
-                catch (error) {
-                    persistenceError = error;
-                }
-                await binding.close();
-                bindingClosed = true;
-                if (persistenceError !== undefined)
-                    throw persistenceError;
-            })();
-            void closePromise.catch((error) => {
-                if (!bindingClosed && isActiveTransactionCloseError(error)) {
-                    closePromise = undefined;
-                }
-            });
-            return closePromise;
-        },
-    };
-    return { binding: persistentBinding, persist };
-}
-function isActiveTransactionCloseError(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        error.code === "LIX_INVALID_TRANSACTION_STATE");
-}
-function clientStateUnsupportedError() {
-    return new Error("The open Lix binding does not support typed client state");
-}
 function workerTransactionBinding(request, transactionId) {
     return {
         execute: (sql, params, options) => request({

package/dist/worker/host.js

@@ -89,14 +89,6 @@ export function startWorkerHost(endpoint) {
                 return requiredLix().activeBranchId();
             case "activeAccountId":
                 return requiredLix().activeAccountId();
-            case "clientState.entries":
-                return requiredClientStateMethod("clientStateEntries")();
-            case "clientState.get":
-                return requiredClientStateMethod("clientStateGet")(operation.key);
-            case "clientState.set":
-                return requiredClientStateMethod("clientStateSet")(operation.key, operation.value);
-            case "clientState.delete":
-                return requiredClientStateMethod("clientStateDelete")(operation.key);
             case "createBranch":
                 return requiredLix().createBranch(operation.options);
             case "createCheckpoint":
@@ -115,14 +107,6 @@ export function startWorkerHost(endpoint) {
                 return requiredLix().importFilesystemPaths(operation.paths);
             case "syncDiskToLix":
                 return requiredLix().syncDiskToLix();
-            case "exportSnapshot": {
-                const lix = requiredLix();
-                const exportSnapshot = lix.exportSnapshot;
-                if (!exportSnapshot) {
-                    throw workerStateError("The open Lix storage does not support snapshot export");
-                }
-                return exportSnapshot.call(lix);
-            }
             case "observe": {
                 const events = await requiredLix().observe(operation.sql, operation.params);
                 const observeId = nextObserveId++;
@@ -154,13 +138,6 @@ export function startWorkerHost(endpoint) {
             throw workerStateError("Lix worker is closed");
         return lix;
     }
-    function requiredClientStateMethod(key) {
-        const method = requiredLix()[key];
-        if (!method) {
-            throw workerStateError("The open Lix binding does not support typed client state");
-        }
-        return method.bind(requiredLix());
-    }
     function requiredTransaction(transactionId) {
         const transaction = transactions.get(transactionId);
         if (!transaction) {