@lix-js/sdk 0.14.0 → 0.15.1

package/README.md

@@ -85,6 +85,20 @@ 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.
 
+Remote handles support branch creation, merge preview and merge through the
+server's Rust engine. `openAnotherSession()` inherits the active branch unless
+one is supplied, retains the authenticated account, and returns an independent
+handle with the same operations—including streaming `exportSnapshot()`. Snapshot
+export covers the complete repository, not only the active branch. Cancelling
+the returned stream releases the HTTP request.
+
+Internally, local and connected-sync bindings call `Lix`; remote bindings call
+the Rust protocol client. Both implement the required Rust session operation
+contract, and the WASM bindings share SQL and branch-operation forwarding and
+value conversion. Host-specific storage, telemetry, stream, and actor cleanup
+remain in the bindings. This does not make network availability or authentication
+constraints identical to an offline local engine.
+
 Filesystem sync uses native Node.js dependencies:
 
 ```ts

package/dist/binding-types.d.ts

@@ -58,7 +58,7 @@ export type LixBinding = {
     mergeBranchPreview(options: MergeBranchOptions): Promise<MergeBranchPreview>;
     mergeBranch(options: MergeBranchOptions): Promise<MergeBranchReceipt>;
     syncDiskToLix(): Promise<void>;
-    exportSnapshot?(): SnapshotExportBinding;
+    exportSnapshot(): SnapshotExportBinding;
     close(): Promise<void>;
 };
 export type LixTransactionBinding = {

package/dist/binding.browser.js

@@ -1,16 +1,8 @@
-import { initializeBrowserWasm } from "./browser-wasm-init.js";
+import { initializeWasm } from "./wasm-init.js";
 import { restoreSnapshot } from "./snapshot-restore.js";
 // Generated before TypeScript compilation and emitted beside this module.
 // @ts-ignore Generated by build:wasm and absent in source-only checks.
-import initWasm, { openJsStorage, openJsStorageFromSnapshot, openMemory, openMemoryFromSnapshot, } from "./wasm/lix_js_sdk.js";
-let wasmInitialized;
-function initializeWasm() {
-    if (wasmInitialized !== undefined)
-        return wasmInitialized;
-    const initialization = initializeBrowserWasm(initWasm, new URL("./wasm/lix_js_sdk_bg.wasm", import.meta.url));
-    wasmInitialized = initialization;
-    return wasmInitialized;
-}
+import { openJsStorage, openJsStorageFromSnapshot, openMemory, openMemoryFromSnapshot, } from "./wasm/lix_js_sdk.js";
 export async function openLixBinding(storage, telemetry, telemetryParent, server, openProgress, snapshot) {
     await initializeWasm();
     switch (storage.kind) {

package/dist/binding.node-wasm.js

@@ -1,14 +1,8 @@
-import { readFile } from "node:fs/promises";
 import { restoreSnapshot } from "./snapshot-restore.js";
+import { initializeWasm } from "./wasm-init.js";
 // Generated before TypeScript compilation and emitted beside this module.
 // @ts-ignore Generated by build:wasm and absent in source-only checks.
-import initWasm, { openMemory, openMemoryFromSnapshot } from "./wasm/lix_js_sdk.js";
-let wasmInitialized;
-function initializeWasm() {
-    return (wasmInitialized ??= initWasm({
-        module_or_path: readFile(new URL("./wasm/lix_js_sdk_bg.wasm", import.meta.url)),
-    }));
-}
+import { openMemory, openMemoryFromSnapshot } from "./wasm/lix_js_sdk.js";
 export async function openMemoryWasmBinding(telemetry, telemetryParent, openProgress, snapshot) {
     await initializeWasm();
     if (snapshot) {

package/dist/lix.js

@@ -118,14 +118,7 @@ export class Lix {
             });
             const operation = this.#runOperation(async () => {
                 try {
-                    const exportSnapshot = this.binding.exportSnapshot;
-                    if (!exportSnapshot) {
-                        const error = new Error("snapshot export is not available for remote Lix handles");
-                        error.name = "LixError";
-                        error.code = "LIX_UNSUPPORTED_STORAGE";
-                        throw error;
-                    }
-                    resolveBinding(exportSnapshot.call(this.binding));
+                    resolveBinding(this.binding.exportSnapshot());
                     await completed;
                 }
                 catch (error) {

package/dist/open-lix.js

@@ -59,7 +59,8 @@ async function openLixInternal(options, snapshot) {
     }
     const { openLixWorkerBinding } = await import("./worker/client.js");
     if (options.storage === undefined) {
-        return new Lix(await openLixWorkerBinding({ kind: "memory" }, undefined, options.telemetry, syncServer, options.onProgress, snapshot));
+        const binding = await openLixWorkerBinding({ kind: "memory" }, undefined, options.telemetry, syncServer, options.onProgress, snapshot);
+        return new Lix(binding);
     }
     if (isJsProviderLixStorage(options.storage)) {
         return openJsProviderStorage(options.storage, options.telemetry, syncServer, options.onProgress, snapshot);

package/dist/remote/client.js

@@ -1,26 +1,7 @@
-import { initializeBrowserWasm } from "../browser-wasm-init.js";
+import { initializeWasm } from "../wasm-init.js";
 // Generated before TypeScript compilation and emitted beside the JS SDK.
 // @ts-ignore Generated by build:wasm and absent in source-only checks.
-import initWasm, { openRemote } from "../wasm/lix_js_sdk.js";
-let wasmInitialized;
-function initializeWasm() {
-    if (wasmInitialized !== undefined)
-        return wasmInitialized;
-    let initialization;
-    if (typeof process !== "undefined" && process.versions?.node) {
-        initialization = import("node:fs/promises").then(({ readFile }) => initWasm({
-            module_or_path: readFile(new URL("../wasm/lix_js_sdk_bg.wasm", import.meta.url)),
-        }), (error) => {
-            wasmInitialized = undefined;
-            throw error;
-        });
-    }
-    else {
-        initialization = initializeBrowserWasm(initWasm, new URL("../wasm/lix_js_sdk_bg.wasm", import.meta.url));
-    }
-    wasmInitialized = initialization;
-    return wasmInitialized;
-}
+import { openRemote } from "../wasm/lix_js_sdk.js";
 export async function openRemoteLixBinding(options, clientOptions = {}) {
     if (!options || typeof options !== "object") {
         throw new TypeError("openLix() remote server must be an object");
@@ -41,9 +22,10 @@ export async function openRemoteLixBinding(options, clientOptions = {}) {
         clientOptions.initialActiveBranchId.length === 0) {
         throw new TypeError("initialActiveBranchId must be a non-empty string");
     }
-    const protocolLocator = connectionUrl(options.url).toString();
+    const locator = connectionUrl(options.url);
+    const protocolLocator = locator.toString();
     await initializeWasm();
-    return openRemote(protocolLocator, remoteFetch, options.headers, clientOptions.initialActiveBranchId);
+    return await openRemote(protocolLocator, remoteFetch, options.headers, clientOptions.initialActiveBranchId);
 }
 function connectionUrl(value) {
     let locator;

package/dist/types.d.ts

@@ -184,9 +184,9 @@ export type ObserveEvent = {
     sequence: number;
     mutationSequence: number;
     /**
-     * The current result of the observed query. Remote observations reconcile
-     * the first frame of every stream through execute before publishing it, so
-     * reconnects cannot expose a stale server snapshot to consumers.
+     * The current result of the observed query. Remote rows and
+     * `mutationSequence` come from the same authoritative observation frame;
+     * reconnect frames are coalesced when their rows are unchanged.
      */
     result: ExecuteResult;
 };

package/dist/wasm/lix_js_sdk.d.ts

@@ -55,9 +55,10 @@ export class WasmRemoteLix {
     createBranch(options: any): Promise<any>;
     execute(sql: string, params: any, options?: any | null): Promise<any>;
     executeBatch(statements: any, options?: any | null): Promise<any>;
+    exportSnapshot(): WasmSnapshotExport;
     importFilesystemPaths(_paths: any): Promise<void>;
-    mergeBranch(_options: any): Promise<any>;
-    mergeBranchPreview(_options: any): Promise<any>;
+    mergeBranch(options: any): Promise<any>;
+    mergeBranchPreview(options: any): Promise<any>;
     observe(sql: string, params: any): Promise<WasmRemoteObserveEvents>;
     openAnotherSession(options: any): Promise<WasmRemoteLix>;
     redo(): Promise<any>;
@@ -162,6 +163,7 @@ export interface InitOutput {
     readonly wasmremotelix_createBranch: (a: number, b: number) => number;
     readonly wasmremotelix_execute: (a: number, b: number, c: number, d: number, e: number) => number;
     readonly wasmremotelix_executeBatch: (a: number, b: number, c: number) => number;
+    readonly wasmremotelix_exportSnapshot: (a: number) => number;
     readonly wasmremotelix_importFilesystemPaths: (a: number, b: number) => number;
     readonly wasmremotelix_mergeBranch: (a: number, b: number) => number;
     readonly wasmremotelix_mergeBranchPreview: (a: number, b: number) => number;
@@ -184,9 +186,9 @@ export interface InitOutput {
     readonly wasmsnapshotrestore_finish: (a: number) => number;
     readonly wasmsnapshotrestore_isComplete: (a: number) => number;
     readonly wasmsnapshotrestore_write: (a: number, b: number, c: number) => number;
-    readonly __wasm_bindgen_func_elem_92059: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_92061: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_16459: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_92636: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_92638: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_16813: (a: number, b: 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

@@ -356,6 +356,13 @@ export class WasmRemoteLix {
         const ret = wasm.wasmremotelix_executeBatch(this.__wbg_ptr, addHeapObject(statements), isLikeNone(options) ? 0 : addHeapObject(options));
         return takeObject(ret);
     }
+    /**
+     * @returns {WasmSnapshotExport}
+     */
+    exportSnapshot() {
+        const ret = wasm.wasmremotelix_exportSnapshot(this.__wbg_ptr);
+        return WasmSnapshotExport.__wrap(ret);
+    }
     /**
      * @param {any} _paths
      * @returns {Promise<void>}
@@ -365,19 +372,19 @@ export class WasmRemoteLix {
         return takeObject(ret);
     }
     /**
-     * @param {any} _options
+     * @param {any} options
      * @returns {Promise<any>}
      */
-    mergeBranch(_options) {
-        const ret = wasm.wasmremotelix_mergeBranch(this.__wbg_ptr, addHeapObject(_options));
+    mergeBranch(options) {
+        const ret = wasm.wasmremotelix_mergeBranch(this.__wbg_ptr, addHeapObject(options));
         return takeObject(ret);
     }
     /**
-     * @param {any} _options
+     * @param {any} options
      * @returns {Promise<any>}
      */
-    mergeBranchPreview(_options) {
-        const ret = wasm.wasmremotelix_mergeBranchPreview(this.__wbg_ptr, addHeapObject(_options));
+    mergeBranchPreview(options) {
+        const ret = wasm.wasmremotelix_mergeBranchPreview(this.__wbg_ptr, addHeapObject(options));
         return takeObject(ret);
     }
     /**
@@ -760,19 +767,19 @@ function __wbg_get_imports() {
         __wbg__wbg_cb_unref_61db23ac97f16c31: function(arg0) {
             getObject(arg0)._wbg_cb_unref();
         },
-        __wbg_acquireSession_fbd9953aa76fbd06: function(arg0) {
+        __wbg_acquireSession_4217826058465f0a: function(arg0) {
             const ret = getObject(arg0).acquireSession();
             return addHeapObject(ret);
         },
-        __wbg_beginRead_114dd35fcf6a9a3d: function(arg0, arg1) {
+        __wbg_beginRead_94ff94b93b664ae5: function(arg0, arg1) {
             const ret = getObject(arg0).beginRead(takeObject(arg1));
             return addHeapObject(ret);
         },
-        __wbg_beginScan_87c5d513513b2fc1: function(arg0, arg1, arg2, arg3) {
+        __wbg_beginScan_51d1ffb7b76bed05: function(arg0, arg1, arg2, arg3) {
             const ret = getObject(arg0).beginScan(takeObject(arg1), takeObject(arg2), takeObject(arg3));
             return addHeapObject(ret);
         },
-        __wbg_beginWrite_ad3177b3fd6be002: function(arg0, arg1) {
+        __wbg_beginWrite_57e757a92c7a162f: function(arg0, arg1) {
             const ret = getObject(arg0).beginWrite(takeObject(arg1));
             return addHeapObject(ret);
         },
@@ -788,18 +795,18 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
         }, arguments); },
-        __wbg_changed_8b774e9361ffc108: function(arg0) {
+        __wbg_changed_58ce3f6384cfabf1: function(arg0) {
             const ret = getObject(arg0).changed();
             return addHeapObject(ret);
         },
-        __wbg_close_2ff8ceedc96b8813: function(arg0) {
+        __wbg_close_48f18a70bd365447: function(arg0) {
             getObject(arg0).close();
         },
-        __wbg_close_c35854fb9094c0b5: function(arg0) {
+        __wbg_close_c5652a29ac52dc7a: function(arg0) {
             const ret = getObject(arg0).close();
             return addHeapObject(ret);
         },
-        __wbg_commit_d64c4bd2c40c0b47: function(arg0) {
+        __wbg_commit_abef9a20db94a24b: function(arg0) {
             const ret = getObject(arg0).commit();
             return addHeapObject(ret);
         },
@@ -807,11 +814,11 @@ function __wbg_get_imports() {
             const ret = Reflect.construct(getObject(arg0), getObject(arg1));
             return addHeapObject(ret);
         }, arguments); },
-        __wbg_deleteMany_4e9717e44a5ce975: function(arg0, arg1, arg2) {
+        __wbg_deleteMany_fba03247e38ecd66: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).deleteMany(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
-        __wbg_deleteRange_c80634c355468a31: function(arg0, arg1, arg2) {
+        __wbg_deleteRange_d3f785b237515ef2: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).deleteRange(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
@@ -838,7 +845,7 @@ function __wbg_get_imports() {
             const ret = Array.from(getObject(arg0));
             return addHeapObject(ret);
         },
-        __wbg_getMany_a58fdfcbaeefb016: function(arg0, arg1) {
+        __wbg_getMany_274d167fafd6553d: function(arg0, arg1) {
             const ret = getObject(arg0).getMany(takeObject(arg1));
             return addHeapObject(ret);
         },
@@ -963,7 +970,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_92061(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_92638(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -993,7 +1000,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_92061(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_92638(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1004,7 +1011,7 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
-        __wbg_nextPage_ae3f298cfa6ac6c7: function(arg0, arg1) {
+        __wbg_nextPage_2c82fda0921c8144: function(arg0, arg1) {
             const ret = getObject(arg0).nextPage(arg1 >>> 0);
             return addHeapObject(ret);
         },
@@ -1043,7 +1050,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).push(getObject(arg1));
             return ret;
         },
-        __wbg_putMany_59c7c5f2646a2cd3: function(arg0, arg1, arg2) {
+        __wbg_putMany_232f0878d2013b1a: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).putMany(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
@@ -1054,7 +1061,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).queueMicrotask;
             return addHeapObject(ret);
         },
-        __wbg_replaceMany_31899cff00668d04: function(arg0, arg1, arg2) {
+        __wbg_replaceMany_79fe2cff87eae447: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).replaceMany(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
@@ -1062,7 +1069,7 @@ function __wbg_get_imports() {
             const ret = Promise.resolve(getObject(arg0));
             return addHeapObject(ret);
         },
-        __wbg_rollback_d6c4b2947a68cd53: function(arg0) {
+        __wbg_rollback_ff9a2e1df7d86a27: function(arg0) {
             const ret = getObject(arg0).rollback();
             return addHeapObject(ret);
         },
@@ -1146,18 +1153,18 @@ function __wbg_get_imports() {
             const ret = WasmRemoteObserveEvents.__wrap(arg0);
             return addHeapObject(ret);
         },
-        __wbg_watchForChanges_c00fffbd08c7f090: function(arg0) {
+        __wbg_watchForChanges_6e168a3d435984ae: function(arg0) {
             const ret = getObject(arg0).watchForChanges();
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 21300, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_92059);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 21338, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_92636);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 1612, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_16459);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 1647, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_16813);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0) {
@@ -1206,14 +1213,14 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_16459(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_16459(arg0, arg1);
+function __wasm_bindgen_func_elem_16813(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_16813(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_92059(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_92636(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_92059(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_92636(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -1224,8 +1231,8 @@ function __wasm_bindgen_func_elem_92059(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_92061(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_92061(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_92638(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_92638(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const WasmLixFinalization = (typeof FinalizationRegistry === 'undefined')

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

@@ -46,6 +46,7 @@ export const wasmremotelix_close: (a: number) => number;
 export const wasmremotelix_createBranch: (a: number, b: number) => number;
 export const wasmremotelix_execute: (a: number, b: number, c: number, d: number, e: number) => number;
 export const wasmremotelix_executeBatch: (a: number, b: number, c: number) => number;
+export const wasmremotelix_exportSnapshot: (a: number) => number;
 export const wasmremotelix_importFilesystemPaths: (a: number, b: number) => number;
 export const wasmremotelix_mergeBranch: (a: number, b: number) => number;
 export const wasmremotelix_mergeBranchPreview: (a: number, b: number) => number;
@@ -68,9 +69,9 @@ export const wasmsnapshotrestore_cancel: (a: number) => number;
 export const wasmsnapshotrestore_finish: (a: number) => number;
 export const wasmsnapshotrestore_isComplete: (a: number) => number;
 export const wasmsnapshotrestore_write: (a: number, b: number, c: number) => number;
-export const __wasm_bindgen_func_elem_92059: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_92061: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_16459: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_92636: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_92638: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_16813: (a: number, b: 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/wasm-init.d.ts

@@ -0,0 +1,2 @@
+/** All local and remote bindings share the same Wasm module in this realm. */
+export declare function initializeWasm(): Promise<unknown>;

package/dist/wasm-init.js

@@ -0,0 +1,23 @@
+// Generated before TypeScript compilation and emitted beside this module.
+// @ts-ignore Generated by build:wasm and absent in source-only checks.
+import initWasm from "./wasm/lix_js_sdk.js";
+let wasmInitialized;
+/** All local and remote bindings share the same Wasm module in this realm. */
+export function initializeWasm() {
+    return (wasmInitialized ??= loadWasm());
+}
+async function loadWasm() {
+    const moduleUrl = new URL("./wasm/lix_js_sdk_bg.wasm", import.meta.url);
+    if (typeof process !== "undefined" && process.versions?.node) {
+        const { readFile } = await import("node:fs/promises");
+        return initWasm({ module_or_path: await readFile(moduleUrl) });
+    }
+    // Chromium can abort a consumer when workers cold-load the same large
+    // response concurrently. Hold the cross-realm lock until compilation ends
+    // so later workers can consume the completed immutable HTTP cache entry.
+    const lockManager = globalThis.navigator?.locks;
+    const run = () => initWasm({ module_or_path: moduleUrl });
+    if (!lockManager)
+        return run();
+    return lockManager.request(`lix:browser-wasm:${moduleUrl.href}`, { mode: "exclusive" }, run);
+}

package/dist/worker/client.d.ts

@@ -29,6 +29,7 @@ export declare class LixWorkerClient {
     private onProgress?;
     openReport: LixOpenReport | undefined;
     private readonly syncFetchControllers;
+    private readonly syncFetchStreams;
     constructor(connection?: WorkerConnection);
     get isDisposed(): boolean;
     allocateSnapshotInputId(): number;
@@ -41,6 +42,9 @@ export declare class LixWorkerClient {
     private handleWorkerEvent;
     private resolveSyncHeaders;
     private resolveSyncFetch;
+    private resolveSyncFetchStreamPull;
+    private cancelSyncFetch;
+    private finishSyncFetchStream;
     private handleFatal;
     private rejectPending;
 }

package/dist/worker/client.js

@@ -368,6 +368,7 @@ export class LixWorkerClient {
     onProgress;
     openReport;
     syncFetchControllers = new Map();
+    syncFetchStreams = new Map();
     constructor(connection = createWorkerConnection()) {
         this.connection = connection;
         connection.onMessage((message) => this.handleMessage(message));
@@ -401,6 +402,10 @@ export class LixWorkerClient {
         for (const controller of this.syncFetchControllers.values())
             controller.abort();
         this.syncFetchControllers.clear();
+        for (const reader of this.syncFetchStreams.values()) {
+            void reader?.cancel().catch(() => undefined);
+        }
+        this.syncFetchStreams.clear();
         onDisposed?.();
     }
     request(operation, sessionId = 0) {
@@ -493,9 +498,11 @@ export class LixWorkerClient {
             case "sync.fetch":
                 void this.resolveSyncFetch(message.requestId, message.request);
                 break;
+            case "sync.fetch.stream.pull":
+                void this.resolveSyncFetchStreamPull(message.requestId);
+                break;
             case "sync.fetch.cancel":
-                this.syncFetchControllers.get(message.requestId)?.abort();
-                this.syncFetchControllers.delete(message.requestId);
+                this.cancelSyncFetch(message.requestId);
                 break;
         }
     }
@@ -532,6 +539,7 @@ export class LixWorkerClient {
         }
         const controller = new AbortController();
         this.syncFetchControllers.set(requestId, controller);
+        let retainedStream = false;
         try {
             const response = await fetcher(request.url, {
                 method: request.method,
@@ -542,6 +550,29 @@ export class LixWorkerClient {
                 credentials: request.credentials,
                 signal: controller.signal,
             });
+            if (this.syncFetchControllers.get(requestId) !== controller ||
+                controller.signal.aborted) {
+                await response.body?.cancel().catch(() => undefined);
+                return;
+            }
+            if (request.responseMode === "stream") {
+                this.syncFetchStreams.set(requestId, response.body?.getReader());
+                retainedStream = true;
+                this.notify({
+                    kind: "sync.fetch.result",
+                    requestId,
+                    result: {
+                        ok: true,
+                        response: {
+                            status: response.status,
+                            statusText: response.statusText,
+                            headers: headerEntries(response.headers),
+                            streaming: true,
+                        },
+                    },
+                });
+                return;
+            }
             const body = await readSyncResponseBody(response, request.responseLimit, controller);
             this.notify({
                 kind: "sync.fetch.result",
@@ -567,9 +598,61 @@ export class LixWorkerClient {
             }
         }
         finally {
-            this.syncFetchControllers.delete(requestId);
+            if (!retainedStream)
+                this.syncFetchControllers.delete(requestId);
         }
     }
+    async resolveSyncFetchStreamPull(requestId) {
+        if (!this.syncFetchStreams.has(requestId))
+            return;
+        const reader = this.syncFetchStreams.get(requestId);
+        try {
+            const result = reader ? await reader.read() : { done: true };
+            if (!this.syncFetchStreams.has(requestId) ||
+                this.syncFetchStreams.get(requestId) !== reader ||
+                this.syncFetchControllers.get(requestId)?.signal.aborted) {
+                return;
+            }
+            this.notify({
+                kind: "sync.fetch.stream.result",
+                requestId,
+                result: result.done
+                    ? { ok: true, done: true }
+                    : { ok: true, done: false, chunk: result.value.slice() },
+            });
+            if (result.done) {
+                reader?.releaseLock();
+                this.finishSyncFetchStream(requestId);
+            }
+        }
+        catch (error) {
+            const controller = this.syncFetchControllers.get(requestId);
+            if (!controller?.signal.aborted) {
+                this.notify({
+                    kind: "sync.fetch.stream.result",
+                    requestId,
+                    result: { ok: false, error: serializeWorkerError(error) },
+                });
+            }
+            try {
+                reader?.releaseLock();
+            }
+            catch {
+                // A cancellation can leave the read pending until its rejection settles.
+            }
+            this.finishSyncFetchStream(requestId);
+        }
+    }
+    cancelSyncFetch(requestId) {
+        this.syncFetchControllers.get(requestId)?.abort();
+        const reader = this.syncFetchStreams.get(requestId);
+        void reader?.cancel().catch(() => undefined);
+        this.finishSyncFetchStream(requestId);
+    }
+    finishSyncFetchStream(requestId) {
+        this.syncFetchStreams.delete(requestId);
+        this.syncFetchControllers.delete(requestId);
+    }
     handleFatal(error) {
         if (this.disposed)
             return;

package/dist/worker/host.d.ts

@@ -1,3 +1,4 @@
+import { openLixBinding } from "#binding";
 import { type WorkerHostEndpoint, type WorkerSyncFetchResponse } from "./protocol.js";
-export declare function startWorkerHost(endpoint: WorkerHostEndpoint): void;
+export declare function startWorkerHost(endpoint: WorkerHostEndpoint, openBinding?: typeof openLixBinding): void;
 export declare function responseFromSyncFetch(resolved: WorkerSyncFetchResponse): Response;

package/dist/worker/host.js

@@ -1,6 +1,6 @@
 import { openLixBinding } from "#binding";
 import { deserializeWorkerError, serializeWorkerError, } from "./protocol.js";
-export function startWorkerHost(endpoint) {
+export function startWorkerHost(endpoint, openBinding = openLixBinding) {
     const sessions = new Map();
     let nextSessionId = 1;
     let nextTransactionId = 1;
@@ -13,6 +13,8 @@ export function startWorkerHost(endpoint) {
     let nextSyncRequestId = 1;
     const pendingSyncHeaders = new Map();
     const pendingSyncFetch = new Map();
+    const pendingSyncStreamPulls = new Map();
+    const syncStreamCleanup = new Map();
     let finiteQueue = Promise.resolve();
     endpoint.onMessage((message) => {
         if (!("id" in message)) {
@@ -46,6 +48,15 @@ export function startWorkerHost(endpoint) {
             }
             return;
         }
+        if (message.operation.kind === "observe") {
+            const operation = message.operation;
+            // Observation setup is metadata-only. Keeping it behind the global
+            // finite-operation queue lets an authority mutation that is waiting for
+            // local publication block a newly mounted server-first History query.
+            // The live `next()` lane is already independent for the same reason.
+            void respond(message, () => handleObserveRegistration(message.sessionId, operation.sql, operation.params));
+            return;
+        }
         finiteQueue = finiteQueue.then(async () => {
             try {
                 await respond(message, async () => {
@@ -108,8 +119,35 @@ export function startWorkerHost(endpoint) {
                     pending.reject(deserializeWorkerError(message.result.error));
                 break;
             }
+            case "sync.fetch.stream.result": {
+                const pending = pendingSyncStreamPulls.get(message.requestId);
+                pendingSyncStreamPulls.delete(message.requestId);
+                if (!pending)
+                    break;
+                if (!message.result.ok) {
+                    const error = deserializeWorkerError(message.result.error);
+                    pending.controller.error(error);
+                    pending.reject(error);
+                    finishSyncStream(message.requestId);
+                }
+                else if (message.result.done) {
+                    pending.controller.close();
+                    pending.resolve();
+                    finishSyncStream(message.requestId);
+                }
+                else {
+                    pending.controller.enqueue(message.result.chunk);
+                    pending.resolve();
+                }
+                break;
+            }
         }
     }
+    function finishSyncStream(requestId) {
+        const cleanup = syncStreamCleanup.get(requestId);
+        syncStreamCleanup.delete(requestId);
+        cleanup?.();
+    }
     async function respond(request, operation) {
         try {
             const value = await operation();
@@ -133,7 +171,7 @@ export function startWorkerHost(endpoint) {
                         ? undefined
                         : requiredSnapshotInput(operation.snapshotId).readable;
                     try {
-                        const opened = await openLixBinding(operation.storage, operation.telemetryEnabled
+                        const opened = await openBinding(operation.storage, operation.telemetryEnabled
                             ? (span) => endpoint.postMessage({ kind: "telemetry", span })
                             : undefined, telemetryParent, createSyncServerBridge(operation.server), operation.progressEnabled
                             ? (progress) => endpoint.postMessage({ kind: "open.progress", progress })
@@ -216,12 +254,8 @@ export function startWorkerHost(endpoint) {
                 throw workerStateError("snapshot pulls bypass the finite operation queue");
             case "exportSnapshot.cancel":
                 throw workerStateError("snapshot cancellation bypasses the finite operation queue");
-            case "observe": {
-                const events = await requiredLix(sessionId).observe(operation.sql, operation.params);
-                const observeId = nextObserveId++;
-                observations.set(observeId, events);
-                return observeId;
-            }
+            case "observe":
+                throw workerStateError("observe must use the observation lane");
             case "close": {
                 const openLix = requiredLix(sessionId);
                 await openLix.close();
@@ -296,14 +330,17 @@ export function startWorkerHost(endpoint) {
         };
     }
     async function bridgeFetch(input, init) {
-        const responseLimit = init?.lixResponseLimit;
-        if (typeof responseLimit !== "number" ||
-            !Number.isSafeInteger(responseLimit) ||
-            responseLimit <= 0) {
+        const extension = init;
+        const streaming = extension?.lixResponseStream === true;
+        const responseLimit = extension?.lixResponseLimit;
+        if (!streaming &&
+            (typeof responseLimit !== "number" ||
+                !Number.isSafeInteger(responseLimit) ||
+                responseLimit <= 0)) {
             throw new TypeError("Browser sync fetch has no valid response limit");
         }
         const requestId = nextSyncRequestId++;
-        const request = {
+        const requestBase = {
             url: typeof input === "string"
                 ? input
                 : input instanceof URL
@@ -313,8 +350,14 @@ export function startWorkerHost(endpoint) {
             headers: headerEntries(init?.headers),
             body: serializableBody(init?.body),
             credentials: init?.credentials,
-            responseLimit,
         };
+        const request = streaming
+            ? { ...requestBase, responseMode: "stream" }
+            : {
+                ...requestBase,
+                responseMode: "buffered",
+                responseLimit: responseLimit,
+            };
         const response = new Promise((resolve, reject) => {
             pendingSyncFetch.set(requestId, { resolve, reject });
             endpoint.postMessage({ kind: "sync.fetch", requestId, request });
@@ -324,20 +367,77 @@ export function startWorkerHost(endpoint) {
             pendingSyncFetch.delete(requestId);
             if (pending) {
                 pending.reject(new DOMException("The operation was aborted", "AbortError"));
-                endpoint.postMessage({ kind: "sync.fetch.cancel", requestId });
             }
+            const pull = pendingSyncStreamPulls.get(requestId);
+            pendingSyncStreamPulls.delete(requestId);
+            if (pull) {
+                const error = new DOMException("The operation was aborted", "AbortError");
+                pull.controller.error(error);
+                pull.reject(error);
+            }
+            endpoint.postMessage({ kind: "sync.fetch.cancel", requestId });
+            finishSyncStream(requestId);
         };
         if (init?.signal?.aborted)
             abort();
         else
             init?.signal?.addEventListener("abort", abort, { once: true });
+        let streamEstablished = false;
         try {
             const resolved = await response;
+            if (resolved.streaming) {
+                const signal = init?.signal;
+                if (signal?.aborted) {
+                    abort();
+                    throw new DOMException("The operation was aborted", "AbortError");
+                }
+                if (resolved.status === 204 ||
+                    resolved.status === 205 ||
+                    resolved.status === 304) {
+                    endpoint.postMessage({ kind: "sync.fetch.cancel", requestId });
+                    return new Response(null, {
+                        status: resolved.status,
+                        statusText: resolved.statusText,
+                        headers: resolved.headers,
+                    });
+                }
+                syncStreamCleanup.set(requestId, () => signal?.removeEventListener("abort", abort));
+                const body = new ReadableStream({
+                    pull: (controller) => new Promise((resolve, reject) => {
+                        pendingSyncStreamPulls.set(requestId, {
+                            controller,
+                            resolve,
+                            reject,
+                        });
+                        endpoint.postMessage({
+                            kind: "sync.fetch.stream.pull",
+                            requestId,
+                        });
+                    }),
+                    cancel: abort,
+                });
+                const streamedResponse = new Response(body, {
+                    status: resolved.status,
+                    statusText: resolved.statusText,
+                    headers: resolved.headers,
+                });
+                streamEstablished = true;
+                return streamedResponse;
+            }
             return responseFromSyncFetch(resolved);
         }
+        catch (error) {
+            if (streaming && !streamEstablished) {
+                endpoint.postMessage({ kind: "sync.fetch.cancel", requestId });
+                finishSyncStream(requestId);
+            }
+            throw error;
+        }
         finally {
-            init?.signal?.removeEventListener("abort", abort);
             pendingSyncFetch.delete(requestId);
+            if (!streamEstablished) {
+                init?.signal?.removeEventListener("abort", abort);
+            }
         }
     }
     async function handleObserveNext(observeId, telemetryParent) {
@@ -347,6 +447,15 @@ export function startWorkerHost(endpoint) {
         events.setTelemetryParent(telemetryParent);
         return events.next();
     }
+    async function handleObserveRegistration(sessionId, sql, params) {
+        // Do not touch the mutable Lix telemetry carrier here: it belongs to the
+        // serialized finite lane. Each `observe.next` supplies telemetry directly
+        // to its observation binding.
+        const events = await requiredLix(sessionId).observe(sql, params);
+        const observeId = nextObserveId++;
+        observations.set(observeId, events);
+        return observeId;
+    }
     function requiredLix(sessionId) {
         const lix = sessions.get(sessionId);
         if (!lix)
@@ -364,6 +473,9 @@ export function startWorkerHost(endpoint) {
     }
 }
 export function responseFromSyncFetch(resolved) {
+    if (resolved.streaming) {
+        throw new TypeError("Streaming sync responses require the worker stream bridge");
+    }
     const body = resolved.status === 204 ||
         resolved.status === 205 ||
         resolved.status === 304

package/dist/worker/protocol.d.ts

@@ -12,14 +12,23 @@ export type WorkerSyncFetchRequest = {
     headers: [string, string][];
     body?: string | Uint8Array;
     credentials?: RequestCredentials;
+} & ({
+    responseMode: "buffered";
     responseLimit: number;
-};
-export type WorkerSyncFetchResponse = {
+} | {
+    responseMode: "stream";
+});
+type WorkerSyncFetchResponseHead = {
     status: number;
     statusText: string;
     headers: [string, string][];
-    body: Uint8Array;
 };
+export type WorkerSyncFetchResponse = WorkerSyncFetchResponseHead & ({
+    streaming: true;
+} | {
+    streaming?: false;
+    body: Uint8Array;
+});
 export type WorkerRequest = {
     id: number;
     sessionId: number;
@@ -138,6 +147,20 @@ export type WorkerNotification = {
         ok: false;
         error: SerializedWorkerError;
     };
+} | {
+    kind: "sync.fetch.stream.result";
+    requestId: number;
+    result: {
+        ok: true;
+        done: true;
+    } | {
+        ok: true;
+        done: false;
+        chunk: Uint8Array;
+    } | {
+        ok: false;
+        error: SerializedWorkerError;
+    };
 };
 export type WorkerInput = WorkerRequest | WorkerNotification;
 export type WorkerConnection = {
@@ -181,9 +204,13 @@ export type WorkerResponse = {
     kind: "sync.fetch";
     requestId: number;
     request: WorkerSyncFetchRequest;
+} | {
+    kind: "sync.fetch.stream.pull";
+    requestId: number;
 } | {
     kind: "sync.fetch.cancel";
     requestId: number;
 };
 export declare function serializeWorkerError(error: unknown): SerializedWorkerError;
 export declare function deserializeWorkerError(error: SerializedWorkerError): Error;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@lix-js/sdk",
 	"type": "module",
-	"version": "0.14.0",
+	"version": "0.15.1",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -49,10 +49,10 @@
 		"typecheck": "tsc -p tsconfig.test.json --noEmit"
 	},
 	"optionalDependencies": {
-		"@lix-js/sdk-darwin-arm64": "0.14.0",
-		"@lix-js/sdk-linux-arm64": "0.14.0",
-		"@lix-js/sdk-linux-x64": "0.14.0",
-		"@lix-js/sdk-win32-x64": "0.14.0"
+		"@lix-js/sdk-darwin-arm64": "0.15.1",
+		"@lix-js/sdk-linux-arm64": "0.15.1",
+		"@lix-js/sdk-linux-x64": "0.15.1",
+		"@lix-js/sdk-win32-x64": "0.15.1"
 	},
 	"devDependencies": {
 		"@vitest/browser-playwright": "4.1.10",

package/dist/browser-wasm-init.d.ts

@@ -1,14 +0,0 @@
-type WasmInitializer = (options: {
-    module_or_path: URL;
-}) => Promise<unknown>;
-/**
- * Initializes one fingerprinted Wasm asset without racing the browser's shared
- * HTTP cache across tabs.
- *
- * Chromium can abort one consumer when separate workers cold-load the same
- * large response concurrently. The lock lasts only for the initial streaming
- * compilation. Once it releases, later workers consume the completed immutable
- * cache entry and compile independently.
- */
-export declare function initializeBrowserWasm(initialize: WasmInitializer, moduleUrl: URL): Promise<unknown>;
-export {};

package/dist/browser-wasm-init.js

@@ -1,16 +0,0 @@
-/**
- * Initializes one fingerprinted Wasm asset without racing the browser's shared
- * HTTP cache across tabs.
- *
- * Chromium can abort one consumer when separate workers cold-load the same
- * large response concurrently. The lock lasts only for the initial streaming
- * compilation. Once it releases, later workers consume the completed immutable
- * cache entry and compile independently.
- */
-export function initializeBrowserWasm(initialize, moduleUrl) {
-    const lockManager = globalThis.navigator.locks;
-    const run = () => initialize({ module_or_path: moduleUrl });
-    if (!lockManager)
-        return run();
-    return lockManager.request(`lix:browser-wasm:${moduleUrl.href}`, { mode: "exclusive" }, run);
-}