@lix-js/sdk 0.10.0 → 0.12.0

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_641749f1dfe2d9cb: 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_7dfdae1bb5aa18be: 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_ca66ce538b54b55e: 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_120697(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_119241(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: 30501, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_120695);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 28427, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_119239);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0) {
@@ -696,10 +684,10 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_120695(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_119239(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_120695(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_119239(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_120695(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_120697(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_120697(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_119241(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_119241(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_120695: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_120697: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_119239: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_119241: (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) {

package/dist/worker/protocol.d.ts

@@ -1,5 +1,5 @@
 import type { BindingBatchStatement, BindingParam, LixStorageConfig } from "../binding-types.js";
-import type { CreateBranchOptions, ExecuteOptions, JsonValue, LixBatchOptions, MergeBranchOptions, SwitchBranchOptions, LixTelemetrySpan } from "../types.js";
+import type { CreateBranchOptions, ExecuteOptions, LixBatchOptions, MergeBranchOptions, SwitchBranchOptions, LixTelemetrySpan } from "../types.js";
 export type WorkerRequest = {
     id: number;
     operation: WorkerOperation;
@@ -35,18 +35,6 @@ export type WorkerOperation = {
     kind: "activeBranchId";
 } | {
     kind: "activeAccountId";
-} | {
-    kind: "clientState.entries";
-} | {
-    kind: "clientState.get";
-    key: string;
-} | {
-    kind: "clientState.set";
-    key: string;
-    value: JsonValue;
-} | {
-    kind: "clientState.delete";
-    key: string;
 } | {
     kind: "createBranch";
     options: CreateBranchOptions;
@@ -70,8 +58,6 @@ export type WorkerOperation = {
     paths: string[];
 } | {
     kind: "syncDiskToLix";
-} | {
-    kind: "exportSnapshot";
 } | {
     kind: "observe";
     sql: string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@lix-js/sdk",
 	"type": "module",
-	"version": "0.10.0",
+	"version": "0.12.0",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -17,13 +17,9 @@
 			"workerd": "./dist/workerd.js",
 			"default": "./dist/workerd.js"
 		},
-		"./remote-protocol": {
-			"types": "./dist/remote/protocol.d.ts",
-			"default": "./dist/remote/protocol.js"
-		},
-		"./local-storage-adapter": {
-			"types": "./dist/local-storage-adapter.d.ts",
-			"default": "./dist/local-storage-adapter.js"
+		"./server-protocol": {
+			"types": "./dist/remote/server-protocol.d.ts",
+			"default": "./dist/remote/server-protocol.js"
 		}
 	},
 	"imports": {
@@ -57,10 +53,10 @@
 		"typecheck": "tsc -p tsconfig.test.json --noEmit"
 	},
 	"optionalDependencies": {
-		"@lix-js/sdk-darwin-arm64": "0.10.0",
-		"@lix-js/sdk-linux-arm64": "0.10.0",
-		"@lix-js/sdk-linux-x64": "0.10.0",
-		"@lix-js/sdk-win32-x64": "0.10.0"
+		"@lix-js/sdk-darwin-arm64": "0.12.0",
+		"@lix-js/sdk-linux-arm64": "0.12.0",
+		"@lix-js/sdk-linux-x64": "0.12.0",
+		"@lix-js/sdk-win32-x64": "0.12.0"
 	},
 	"devDependencies": {
 		"@vitest/browser-playwright": "4.1.10",

package/dist/client-state.d.ts

@@ -1,53 +0,0 @@
-import type { LixBinding } from "./binding-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;
-    /** Persists a client-local value in the configured client storage. */
-    set(key: string, value: JsonValue): Promise<void>;
-    /** 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>;
-};
-export type OpenClientStateOptions = {
-    readonly binding: ClientStateBinding;
-    readonly saveSnapshot?: (snapshot: Uint8Array) => Promise<void>;
-    readonly closeBinding?: boolean;
-};
-/**
- * Opens the typed client-state facade over a private local Rust Lix.
- *
- * Values are ordinary global, untracked `lix_key_value` rows. The physical
- * prefix is intentionally private so built-in Lix key/value rows never leak
- * through this small API.
- */
-export declare function openClientState(options: OpenClientStateOptions): Promise<ManagedLixClientState>;
-export declare class ManagedLixClientState implements LixClientState {
-    #private;
-    constructor(options: OpenClientStateOptions, initial: Map<string, JsonValue>);
-    get<T extends JsonValue = JsonValue>(key: string): T | undefined;
-    set(key: string, value: JsonValue): Promise<void>;
-    delete(key: string): Promise<void>;
-    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 {};