@lix-js/sdk 0.15.0 → 0.16.0

package/README.md

@@ -22,10 +22,51 @@ console.log(result.rows[0]?.message);
 await lix.close();
 ```
 
+## Hosted lifecycle
+
+`openLix()` selects execution from the supplied locations:
+
+| Options | Behavior |
+| --- | --- |
+| Neither | Fresh in-memory repository |
+| `storage` | Local repository, initialized if empty |
+| `server` | Execute against an existing hosted repository |
+| `storage` and `server` | Synchronized local reads; mutations execute on the server |
+
+Creation and deletion are explicit server operations:
+
+```ts
+import { createLix, deleteLix, openLix } from "@lix-js/sdk";
+
+const repository = await createLix({
+  server: { url: "https://example.com", headers: getAuthHeaders },
+  from: localLix, // Omit to create an empty repository.
+});
+
+const remote = await openLix({
+  server: { url: repository.url, headers: getAuthHeaders },
+});
+await remote.close();
+await deleteLix({ server: { url: repository.url, headers: getAuthHeaders } });
+```
+
+`from` captures a consistent repository snapshot, including history and untracked
+rows. The source remains open. Creation returns `{ id, url }`, not a session.
+Use the same optional `idempotencyKey` when retrying creation after an uncertain
+response. Deletion removes the hosted repository and leaves local copies intact. Opening
+or synchronizing never implicitly creates a missing hosted repository.
+
+Browser creation from a local repository requires Fetch request streaming.
+Browsers without that support return `LIX_UNSUPPORTED_OPERATION`; Lix does not
+buffer the complete repository as a fallback. Browser Fetch may also require an
+HTTP/2 or HTTP/3 connection for streaming uploads. Empty creation and remote
+execution do not require streaming uploads.
+
 ## Synchronized local repositories
 
-Use sync mode when reads and writes should execute locally while Lix exchanges
-commits with a hosted repository in the background:
+Combine storage with a server to keep a synchronized local read replica.
+Certified current-state reads can execute locally; mutations execute on the
+server:
 
 ```ts
 import { openLix } from "@lix-js/sdk";
@@ -34,7 +75,6 @@ import { OpfsStorage } from "@lix-js/storage-opfs";
 const lix = await openLix({
   storage: new OpfsStorage({ name: "acme" }),
   server: {
-    mode: "sync",
     url: "https://example.com/lix/01936f4e-7b6c-7c3d-8f9a-123456789abc",
     headers: async () => ({
       Authorization: `Bearer ${await accessToken()}`,
@@ -43,9 +83,10 @@ const lix = await openLix({
 });
 ```
 
-`await lix.execute(...)` means that the local transaction committed. It does
-not mean that the server has received the commit. Current data and new commits
-synchronize automatically; older history and binary content load when needed.
+A successful mutation confirms server acceptance. The local replica receives
+the resulting certified state automatically; older history and binary content
+load when needed. Connected mutations require the server, and cached reads may
+also need fresh server certification.
 See [Collaboration and Sync](https://lix.dev/docs/collaboration-and-sync).
 
 ## Remote repositories
@@ -55,7 +96,6 @@ Use the same Lix client as a thin client against a hosted repository:
 ```ts
 const lix = await openLix({
   server: {
-    mode: "remote",
     url: "https://example.com/lix/01936f4e-7b6c-7c3d-8f9a-123456789abc",
     headers: async () => ({
       Authorization: `Bearer ${await accessToken()}`,
@@ -161,6 +201,11 @@ const merge = await lix.mergeBranch({ sourceBranchId: draft.id });
 
 ## Transactions
 
+`beginTransaction()` captures the current branch and account in an independent
+transaction context. Use `tx.execute()` for transaction work; its reads see staged
+writes. Ordinary reads and observers on `lix` continue to see committed data while
+the transaction is open. Commit or roll back before closing `lix`.
+
 ```ts
 const tx = await lix.beginTransaction();
 

package/dist/binding-types.d.ts

@@ -41,6 +41,7 @@ export type BindingBatchStatement = {
     label?: string;
 };
 export type LixBinding = {
+    createHosted?(server: HostedServerBindingOptions): Promise<import("./types.js").HostedLix>;
     openReport?(): LixOpenReport | undefined;
     setTelemetryParent(parent?: TelemetryParentContext): void;
     openAnotherSession(options: OpenAnotherSessionOptions): Promise<LixBinding>;
@@ -88,3 +89,8 @@ export type LixStorageConfig = {
     path: string;
     syncAllFiles: boolean;
 };
+export type HostedServerBindingOptions = {
+    idempotencyKey?: string;
+    url: string;
+    headers: [string, string][];
+};

package/dist/binding.browser.d.ts

@@ -1,2 +1,4 @@
 import type { LixStorageConfig, LixBinding, SyncServerBindingOptions, TelemetryDispatch, TelemetryParentContext, OpenProgressDispatch } from "./binding-types.js";
 export declare function openLixBinding(storage: LixStorageConfig, telemetry?: TelemetryDispatch, telemetryParent?: TelemetryParentContext, server?: SyncServerBindingOptions, openProgress?: OpenProgressDispatch, snapshot?: ReadableStream<Uint8Array>): Promise<LixBinding>;
+export declare function createHostedBinding(server: import("./binding-types.js").HostedServerBindingOptions): Promise<import("./types.js").HostedLix>;
+export declare function deleteHostedBinding(server: import("./binding-types.js").HostedServerBindingOptions): Promise<void>;

package/dist/binding.browser.js

@@ -2,7 +2,9 @@ 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 { openJsStorage, openJsStorageFromSnapshot, openMemory, openMemoryFromSnapshot, } from "./wasm/lix_js_sdk.js";
+import { createHosted, deleteHosted, openJsStorage, openJsStorageFromSnapshot, openMemory, openMemoryFromSnapshot,
+// @ts-ignore Generated by build:wasm and absent in source-only checks.
+ } from "./wasm/lix_js_sdk.js";
 export async function openLixBinding(storage, telemetry, telemetryParent, server, openProgress, snapshot) {
     await initializeWasm();
     switch (storage.kind) {
@@ -32,3 +34,11 @@ export async function openLixBinding(storage, telemetry, telemetryParent, server
             throw new Error("FilesystemStorage is only available in Node.js");
     }
 }
+export async function createHostedBinding(server) {
+    await initializeWasm();
+    return createHosted(server);
+}
+export async function deleteHostedBinding(server) {
+    await initializeWasm();
+    await deleteHosted(server);
+}

package/dist/binding.node.d.ts

@@ -1,3 +1,5 @@
 import type { LixStorageConfig, LixBinding, SyncServerBindingOptions, TelemetryDispatch, TelemetryParentContext, OpenProgressDispatch } from "./binding-types.js";
 export declare function openLixBinding(storage: LixStorageConfig, telemetry?: TelemetryDispatch, telemetryParent?: TelemetryParentContext, server?: SyncServerBindingOptions, openProgress?: OpenProgressDispatch, snapshot?: ReadableStream<Uint8Array>): Promise<LixBinding>;
 export declare function openNativeLixBinding(storage: LixStorageConfig, telemetry?: TelemetryDispatch, telemetryParent?: TelemetryParentContext, server?: SyncServerBindingOptions, openProgress?: OpenProgressDispatch, snapshot?: ReadableStream<Uint8Array>): Promise<LixBinding>;
+export declare function createHostedBinding(server: import("./binding-types.js").HostedServerBindingOptions): Promise<import("./types.js").HostedLix>;
+export declare function deleteHostedBinding(server: import("./binding-types.js").HostedServerBindingOptions): Promise<void>;

package/dist/binding.node.js

@@ -62,7 +62,7 @@ class NativeAddonUnavailableError extends Error {
         this.name = "NativeAddonUnavailableError";
     }
 }
-function loadNativeAddon() {
+function loadAddon() {
     if (addon)
         return addon;
     if (addonLoadError)
@@ -114,7 +114,7 @@ export async function openNativeLixBinding(storage, telemetry, telemetryParent,
         : undefined;
     switch (storage.kind) {
         case "memory": {
-            const nativeAddon = loadNativeAddon();
+            const nativeAddon = loadAddon();
             const nativeTelemetry = telemetry
                 ? (spanJson) => telemetry(JSON.parse(spanJson))
                 : undefined;
@@ -130,7 +130,7 @@ export async function openNativeLixBinding(storage, telemetry, telemetryParent,
         case "jsStorage":
             throw new Error("JavaScript storage providers are only available in browsers");
         case "filesystem": {
-            const nativeAddon = loadNativeAddon();
+            const nativeAddon = loadAddon();
             const nativeTelemetry = telemetry
                 ? (spanJson) => telemetry(JSON.parse(spanJson))
                 : undefined;
@@ -145,3 +145,9 @@ export async function openNativeLixBinding(storage, telemetry, telemetryParent,
         }
     }
 }
+export async function createHostedBinding(server) {
+    return loadAddon().createHosted(server.url, server.headers, server.idempotencyKey);
+}
+export async function deleteHostedBinding(server) {
+    await loadAddon().deleteHosted(server.url, server.headers);
+}

package/dist/hosted-lix.d.ts

@@ -0,0 +1,5 @@
+import type { CreateLixOptions, DeleteLixOptions, HostedLix } from "./types.js";
+/** Creates a hosted repository, optionally from a consistent snapshot of a local Lix. */
+export declare function createLix(options: CreateLixOptions): Promise<HostedLix>;
+/** Deletes the hosted repository. Local replicas are not deleted. */
+export declare function deleteLix(options: DeleteLixOptions): Promise<void>;

package/dist/hosted-lix.js

@@ -0,0 +1,36 @@
+import { createHostedFromLix } from "./lix.js";
+import { hostedLixWorkerOperation } from "./worker/client.js";
+async function resolveServer(server) {
+    if (!server || typeof server !== "object")
+        throw new TypeError("A server is required");
+    if ("fetch" in server && server.fetch !== undefined)
+        throw new TypeError("hosted lifecycle does not accept a custom fetch");
+    if ("mode" in server)
+        throw new TypeError("server.mode was removed");
+    const url = new URL(server.url).toString();
+    const headers = new Headers(typeof server.headers === "function"
+        ? await server.headers()
+        : server.headers);
+    const entries = [];
+    headers.forEach((value, key) => entries.push([key, value]));
+    return { url, headers: entries };
+}
+/** Creates a hosted repository, optionally from a consistent snapshot of a local Lix. */
+export async function createLix(options) {
+    if (options.from !== undefined) {
+        return createHostedFromLix(options.from, async () => ({
+            ...(await resolveServer(options.server)),
+            idempotencyKey: options.idempotencyKey,
+        }));
+    }
+    const server = await resolveServer(options.server);
+    return hostedLixWorkerOperation({
+        kind: "hosted.create",
+        server: { ...server, idempotencyKey: options.idempotencyKey },
+    });
+}
+/** Deletes the hosted repository. Local replicas are not deleted. */
+export async function deleteLix(options) {
+    const server = await resolveServer(options.server);
+    await hostedLixWorkerOperation({ kind: "hosted.delete", server });
+}

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export type { LixStorage, LixStorageBound, LixStorageChangeWatch, LixStorageComm
 export { LixStorageError } from "./storage-adapter.js";
 export { bundledPluginArchives, type BundledPluginArchive, } from "./bundled-plugins.js";
 export { Value } from "./value.js";
-export type { CreateBranchOptions, CreateBranchReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, ExecuteBatchResult, LixBatchOptions, LixBatchStatement, JsonValue, LixValue, ResultArrayRow, ResultColumn, ResultColumnType, ResultObjectRow, ResultRow, MergeBranchOptions, MergeBranchOutcome, MergeBranchPreview, MergeBranchReceipt, MergeChangeStats, MergeConflict, MergeConflictSide, ObserveEvent, OpenLixOptions, OpenAnotherSessionOptions, LixTelemetryOptions, LixTelemetryParentContext, LixTelemetrySpan, LixTelemetrySpanLink, LixOpenMigrationReport, LixOpenPhase, LixOpenProgress, LixOpenProgressOptions, LixOpenReport, RemoteLixFetch, RemoteLixServerOptions, SyncLixServerOptions, UndoReceipt, SqlParam, SwitchBranchOptions, SwitchBranchReceipt, } from "./types.js";
+export type { CreateBranchOptions, CreateBranchReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, ExecuteBatchResult, LixBatchOptions, LixBatchStatement, JsonValue, LixValue, ResultArrayRow, ResultColumn, ResultColumnType, ResultObjectRow, ResultRow, MergeBranchOptions, MergeBranchOutcome, MergeBranchPreview, MergeBranchReceipt, MergeChangeStats, MergeConflict, MergeConflictSide, ObserveEvent, OpenLixOptions, OpenAnotherSessionOptions, LixTelemetryOptions, LixTelemetryParentContext, LixTelemetrySpan, LixTelemetrySpanLink, LixOpenMigrationReport, LixOpenPhase, LixOpenProgress, LixOpenProgressOptions, LixOpenReport, RemoteLixFetch, LixServerOptions, HostedLix, CreateLixOptions, DeleteLixOptions, UndoReceipt, SqlParam, SwitchBranchOptions, SwitchBranchReceipt, } from "./types.js";
+export { createLix, deleteLix } from "./hosted-lix.js";

package/dist/index.js

@@ -2,3 +2,4 @@ export { Lix, LixTransaction, ObserveEvents, openLix } from "./open-lix.js";
 export { LixStorageError } from "./storage-adapter.js";
 export { bundledPluginArchives, } from "./bundled-plugins.js";
 export { Value } from "./value.js";
+export { createLix, deleteLix } from "./hosted-lix.js";

package/dist/lix.d.ts

@@ -1,5 +1,7 @@
 import type { LixBinding, LixTransactionBinding, ObserveEventsBinding } from "./binding-types.js";
 import type { CreateBranchOptions, CreateBranchReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, ExecuteBatchResult, LixBatchOptions, LixBatchStatement, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, ObserveEvent, OpenAnotherSessionOptions, LixOpenReport, SqlParam, ResultArrayRow, ResultObjectRow, ResultRow, SwitchBranchOptions, SwitchBranchReceipt, UndoReceipt } from "./types.js";
+/** @internal Used by createLix without adding another method to Lix. */
+export declare function createHostedFromLix(lix: Lix, server: () => Promise<import("./binding-types.js").HostedServerBindingOptions>): Promise<import("./types.js").HostedLix>;
 export declare class Lix {
     #private;
     private readonly binding;

package/dist/lix.js

@@ -13,6 +13,14 @@ const observeFinalizer = new FinalizationRegistry(({ observe, onClose }) => {
         events?.close();
     });
 });
+const hostedCreators = new WeakMap();
+/** @internal Used by createLix without adding another method to Lix. */
+export function createHostedFromLix(lix, server) {
+    const create = hostedCreators.get(lix);
+    if (!create)
+        throw new TypeError("createLix() from must be an open local Lix");
+    return create(server);
+}
 export class Lix {
     binding;
     openReport;
@@ -27,6 +35,11 @@ export class Lix {
     #acceptingOperations = true;
     constructor(binding) {
         this.binding = binding;
+        hostedCreators.set(this, (server) => this.#runOperation(async () => {
+            if (!binding.createHosted)
+                throw new TypeError("createLix() from requires a local Lix");
+            return binding.createHosted(await server());
+        }));
         const report = binding.openReport?.();
         this.openReport = report
             ? Object.freeze({

package/dist/open-lix.js

@@ -26,37 +26,34 @@ async function openLixInternal(options, snapshot) {
         throw new TypeError("openLix() onProgress must be a function");
     }
     if (options.server !== undefined) {
+        if ("mode" in options.server)
+            throw new TypeError("server.mode was removed; provide storage for synchronization or omit it for remote execution");
         if (snapshot) {
             throw new TypeError("openLix.fromSnapshot() does not accept server mode");
         }
-        if (options.server.mode === "remote") {
+        if (options.storage === undefined) {
+            if (options.telemetry !== undefined || options.onProgress !== undefined)
+                throw new TypeError("remote execution does not accept local telemetry or onProgress");
             const { openRemoteLixBinding } = await import("./remote/client.js");
-            if ("storage" in options && options.storage !== undefined) {
-                throw new TypeError("openLix() remote mode does not accept storage");
-            }
             return new Lix(await openRemoteLixBinding(options.server));
         }
     }
-    const syncServer = options.server?.mode === "sync"
+    const syncServer = options.server !== undefined && options.storage !== undefined
         ? {
             url: new URL(options.server.url).toString(),
             headers: options.server.headers,
             fetch: options.server.fetch,
         }
         : undefined;
-    if (syncServer?.fetch !== undefined && typeof syncServer.fetch !== "function") {
+    if (syncServer?.fetch !== undefined &&
+        typeof syncServer.fetch !== "function") {
         throw new TypeError("openLix() sync server fetch must be a function");
     }
-    if (syncServer?.headers !== undefined && typeof syncServer.headers !== "function") {
+    if (syncServer?.headers !== undefined &&
+        typeof syncServer.headers !== "function") {
         // Validate static headers before opening a worker/native runtime.
         new Headers(syncServer.headers);
     }
-    if (options.server !== undefined && syncServer === undefined) {
-        throw new TypeError("openLix() server mode must be 'remote' or 'sync'");
-    }
-    if (syncServer !== undefined && options.storage === undefined) {
-        throw new TypeError("openLix() sync mode requires a durability-capable storage adapter");
-    }
     const { openLixWorkerBinding } = await import("./worker/client.js");
     if (options.storage === undefined) {
         const binding = await openLixWorkerBinding({ kind: "memory" }, undefined, options.telemetry, syncServer, options.onProgress, snapshot);

package/dist/remote/client.d.ts

@@ -1,7 +1,7 @@
 import type { LixBinding } from "../binding-types.js";
-import type { RemoteLixServerOptions } from "../types.js";
+import type { LixServerOptions } from "../types.js";
 type RemoteLixClientOptions = {
     initialActiveBranchId?: string;
 };
-export declare function openRemoteLixBinding(options: RemoteLixServerOptions, clientOptions?: RemoteLixClientOptions): Promise<LixBinding>;
+export declare function openRemoteLixBinding(options: LixServerOptions, clientOptions?: RemoteLixClientOptions): Promise<LixBinding>;
 export {};

package/dist/remote/client.js

@@ -6,9 +6,6 @@ export async function openRemoteLixBinding(options, clientOptions = {}) {
     if (!options || typeof options !== "object") {
         throw new TypeError("openLix() remote server must be an object");
     }
-    if (options.mode !== "remote") {
-        throw new TypeError("openLix() remote server mode must be 'remote'");
-    }
     const remoteFetch = options.fetch ?? globalThis.fetch?.bind(globalThis);
     if (typeof remoteFetch !== "function") {
         throw new TypeError("openLix() remote mode requires fetch");

package/dist/remote/server-protocol.d.ts

@@ -1,6 +1,6 @@
 import type { BindingExecuteResult, BindingObserveEvent } from "../binding-types.js";
 import type { NativeLixValue } from "../value.js";
-export declare const SERVER_PROTOCOL_VERSION = 6;
+export declare const SERVER_PROTOCOL_VERSION = 7;
 export type WireValue = {
     kind: "null";
     value: null;

package/dist/remote/server-protocol.js

@@ -1,4 +1,4 @@
-export const SERVER_PROTOCOL_VERSION = 6;
+export const SERVER_PROTOCOL_VERSION = 7;
 export function encodeWireValue(value) {
     switch (value.kind) {
         case "null":

package/dist/types.d.ts

@@ -1,24 +1,22 @@
 export type RemoteLixFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-export type RemoteLixServerOptions = {
-    mode: "remote";
-    /** Stable HTTPS locator whose path is exactly `/lix/{uuid}`. HTTP is loopback-only. */
+/** A Lix protocol endpoint. Host URL for creation; repository URL for opening/deletion. */
+export type LixServerOptions = {
     url: string | URL;
     headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
     fetch?: RemoteLixFetch;
 };
-/**
- * Opens a local native replica that synchronizes with the server in the
- * background. Sync mode keeps the normal local storage/read path and works
- * with browser storage such as OPFS as well as native storage.
- */
-export type SyncLixServerOptions = {
-    mode: "sync";
-    /** Stable HTTPS locator whose path is exactly `/lix/{uuid}`. HTTP is loopback-only. */
-    url: string | URL;
-    /** Resolved for every browser sync request, including reconnect handshakes. */
-    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
-    /** Browser fetch override. Functions cross the worker boundary through RPC. */
-    fetch?: RemoteLixFetch;
+export type HostedLix = {
+    id: string;
+    url: string;
+};
+export type CreateLixOptions = {
+    /** Reuse this key when retrying a creation whose outcome was uncertain. */
+    idempotencyKey?: string;
+    server: Pick<LixServerOptions, "url" | "headers">;
+    from?: import("./lix.js").Lix;
+};
+export type DeleteLixOptions = {
+    server: Pick<LixServerOptions, "url" | "headers">;
 };
 export type LixTelemetrySpanLink = {
     traceId: string;
@@ -81,20 +79,21 @@ export type LixOpenProgressOptions = {
     /** Observes local inspection, automatic migration, and opening. */
     onProgress?(progress: LixOpenProgress): void;
 };
-export type OpenLixOptions = {
+/** No options: memory. Storage: local. Server: remote. Storage + server: sync. */
+export type OpenLixOptions = ({
     storage?: import("./storage-adapter.js").LixStorage;
     server?: never;
     telemetry?: LixTelemetryOptions;
-} & LixOpenProgressOptions | {
+} & LixOpenProgressOptions) | {
     storage?: never;
-    server: RemoteLixServerOptions;
+    server: LixServerOptions;
     telemetry?: never;
     onProgress?: never;
-} | {
+} | ({
     storage: import("./storage-adapter.js").LixStorage;
-    server: SyncLixServerOptions;
+    server: LixServerOptions;
     telemetry?: LixTelemetryOptions;
-} & LixOpenProgressOptions;
+} & LixOpenProgressOptions);
 /** Selects the initial context for an additional independent session. */
 export type OpenAnotherSessionOptions = {
     /** Defaults to the current branch of the session opening it. */

package/dist/wasm/lix_js_sdk.d.ts

@@ -10,6 +10,7 @@ export class WasmLix {
     beginTransaction(): Promise<WasmLixTransaction>;
     close(): Promise<void>;
     createBranch(options: any): Promise<any>;
+    createHosted(server: any): Promise<any>;
     execute(sql: string, params: any, options?: any | null): Promise<any>;
     executeBatch(statements: any, options?: any | null): Promise<any>;
     exportSnapshot(): WasmSnapshotExport;
@@ -104,6 +105,10 @@ export class WasmSnapshotRestore {
     write(chunk: Uint8Array): Promise<void>;
 }
 
+export function createHosted(server: any): Promise<any>;
+
+export function deleteHosted(server: any): Promise<void>;
+
 export function openJsStorage(provider: any, telemetry_dispatch?: Function | null, telemetry_parent?: any | null, server?: any | null, open_progress_dispatch?: Function | null): Promise<WasmLix>;
 
 export function openJsStorageFromSnapshot(provider: any, telemetry_dispatch?: Function | null, telemetry_parent?: any | null, open_progress_dispatch?: Function | null): WasmSnapshotRestore;
@@ -126,6 +131,8 @@ export interface InitOutput {
     readonly __wbg_wasmremoteobserveevents_free: (a: number, b: number) => void;
     readonly __wbg_wasmsnapshotexport_free: (a: number, b: number) => void;
     readonly __wbg_wasmsnapshotrestore_free: (a: number, b: number) => void;
+    readonly createHosted: (a: number) => number;
+    readonly deleteHosted: (a: number) => number;
     readonly openJsStorage: (a: number, b: number, c: number, d: number, e: number) => number;
     readonly openJsStorageFromSnapshot: (a: number, b: number, c: number, d: number) => number;
     readonly openMemory: (a: number, b: number, c: number, d: number) => number;
@@ -136,6 +143,7 @@ export interface InitOutput {
     readonly wasmlix_beginTransaction: (a: number) => number;
     readonly wasmlix_close: (a: number) => number;
     readonly wasmlix_createBranch: (a: number, b: number) => number;
+    readonly wasmlix_createHosted: (a: number, b: number) => number;
     readonly wasmlix_execute: (a: number, b: number, c: number, d: number, e: number) => number;
     readonly wasmlix_executeBatch: (a: number, b: number, c: number) => number;
     readonly wasmlix_exportSnapshot: (a: number) => number;
@@ -186,9 +194,10 @@ 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_92635: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_92637: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_16813: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_95597: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_95599: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_17533: (a: number, b: number, c: number) => number;
+    readonly __wasm_bindgen_func_elem_17532: (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

@@ -53,6 +53,14 @@ export class WasmLix {
         const ret = wasm.wasmlix_createBranch(this.__wbg_ptr, addHeapObject(options));
         return takeObject(ret);
     }
+    /**
+     * @param {any} server
+     * @returns {Promise<any>}
+     */
+    createHosted(server) {
+        const ret = wasm.wasmlix_createHosted(this.__wbg_ptr, addHeapObject(server));
+        return takeObject(ret);
+    }
     /**
      * @param {string} sql
      * @param {any} params
@@ -611,6 +619,24 @@ export class WasmSnapshotRestore {
 }
 if (Symbol.dispose) WasmSnapshotRestore.prototype[Symbol.dispose] = WasmSnapshotRestore.prototype.free;
 
+/**
+ * @param {any} server
+ * @returns {Promise<any>}
+ */
+export function createHosted(server) {
+    const ret = wasm.createHosted(addHeapObject(server));
+    return takeObject(ret);
+}
+
+/**
+ * @param {any} server
+ * @returns {Promise<void>}
+ */
+export function deleteHosted(server) {
+    const ret = wasm.deleteHosted(addHeapObject(server));
+    return takeObject(ret);
+}
+
 /**
  * @param {any} provider
  * @param {Function | null} [telemetry_dispatch]
@@ -767,19 +793,19 @@ function __wbg_get_imports() {
         __wbg__wbg_cb_unref_61db23ac97f16c31: function(arg0) {
             getObject(arg0)._wbg_cb_unref();
         },
-        __wbg_acquireSession_57f1f2cd5f681c2d: function(arg0) {
+        __wbg_acquireSession_a8254a768d39837d: function(arg0) {
             const ret = getObject(arg0).acquireSession();
             return addHeapObject(ret);
         },
-        __wbg_beginRead_1138c26c0b47afd3: function(arg0, arg1) {
+        __wbg_beginRead_60aa15a811be5c9e: function(arg0, arg1) {
             const ret = getObject(arg0).beginRead(takeObject(arg1));
             return addHeapObject(ret);
         },
-        __wbg_beginScan_d935bfe04519622e: function(arg0, arg1, arg2, arg3) {
+        __wbg_beginScan_babac0f551e5944a: function(arg0, arg1, arg2, arg3) {
             const ret = getObject(arg0).beginScan(takeObject(arg1), takeObject(arg2), takeObject(arg3));
             return addHeapObject(ret);
         },
-        __wbg_beginWrite_4d84cc1cbfc72fa9: function(arg0, arg1) {
+        __wbg_beginWrite_1c425bc25b4478a9: function(arg0, arg1) {
             const ret = getObject(arg0).beginWrite(takeObject(arg1));
             return addHeapObject(ret);
         },
@@ -795,18 +821,18 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
         }, arguments); },
-        __wbg_changed_8b3c117efdd37fbf: function(arg0) {
+        __wbg_changed_528baf87aed58eeb: function(arg0) {
             const ret = getObject(arg0).changed();
             return addHeapObject(ret);
         },
-        __wbg_close_70069a5308f6a3d8: function(arg0) {
+        __wbg_close_f2aa9b20739360cc: function(arg0) {
+            getObject(arg0).close();
+        },
+        __wbg_close_f3e51c630f322069: function(arg0) {
             const ret = getObject(arg0).close();
             return addHeapObject(ret);
         },
-        __wbg_close_eb44b04eda5115d4: function(arg0) {
-            getObject(arg0).close();
-        },
-        __wbg_commit_9dc6a608a8f559f7: function(arg0) {
+        __wbg_commit_c3ce5649299748fc: function(arg0) {
             const ret = getObject(arg0).commit();
             return addHeapObject(ret);
         },
@@ -814,11 +840,11 @@ function __wbg_get_imports() {
             const ret = Reflect.construct(getObject(arg0), getObject(arg1));
             return addHeapObject(ret);
         }, arguments); },
-        __wbg_deleteMany_15f48563982d361e: function(arg0, arg1, arg2) {
+        __wbg_deleteMany_6d3b448de0ed189f: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).deleteMany(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
-        __wbg_deleteRange_29b8dd1d129b1f8c: function(arg0, arg1, arg2) {
+        __wbg_deleteRange_c657e89ac7d3019f: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).deleteRange(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
@@ -845,7 +871,7 @@ function __wbg_get_imports() {
             const ret = Array.from(getObject(arg0));
             return addHeapObject(ret);
         },
-        __wbg_getMany_946bf213edc127f3: function(arg0, arg1) {
+        __wbg_getMany_9a7d0535b6c9d8a8: function(arg0, arg1) {
             const ret = getObject(arg0).getMany(takeObject(arg1));
             return addHeapObject(ret);
         },
@@ -970,7 +996,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_92637(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_95599(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1000,7 +1026,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_92637(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_95599(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1011,7 +1037,7 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
-        __wbg_nextPage_6902443bcbff10d3: function(arg0, arg1) {
+        __wbg_nextPage_fa7414622954e329: function(arg0, arg1) {
             const ret = getObject(arg0).nextPage(arg1 >>> 0);
             return addHeapObject(ret);
         },
@@ -1050,7 +1076,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).push(getObject(arg1));
             return ret;
         },
-        __wbg_putMany_168141e3afba203c: function(arg0, arg1, arg2) {
+        __wbg_putMany_23a2adb09a5dbeb0: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).putMany(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
@@ -1061,7 +1087,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).queueMicrotask;
             return addHeapObject(ret);
         },
-        __wbg_replaceMany_b2dc402a4ff6b772: function(arg0, arg1, arg2) {
+        __wbg_replaceMany_ec7b95ae5e240784: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).replaceMany(takeObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         },
@@ -1069,7 +1095,7 @@ function __wbg_get_imports() {
             const ret = Promise.resolve(getObject(arg0));
             return addHeapObject(ret);
         },
-        __wbg_rollback_5632fb7c3f6f9b08: function(arg0) {
+        __wbg_rollback_5fba8ed172c77521: function(arg0) {
             const ret = getObject(arg0).rollback();
             return addHeapObject(ret);
         },
@@ -1153,46 +1179,51 @@ function __wbg_get_imports() {
             const ret = WasmRemoteObserveEvents.__wrap(arg0);
             return addHeapObject(ret);
         },
-        __wbg_watchForChanges_465d4036436d28da: function(arg0) {
+        __wbg_watchForChanges_c0eedd0a57ce54a9: 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: 21338, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_92635);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1280, ret: NamedExternref("Promise<any>"), inner_ret: Some(NamedExternref("Promise<any>")) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_17533);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // 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);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 21180, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_95597);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 1279, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_17532);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000003: function(arg0) {
+        __wbindgen_cast_0000000000000004: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000004: function(arg0) {
+        __wbindgen_cast_0000000000000005: function(arg0) {
             // Cast intrinsic for `I64 -> Externref`.
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
             const ret = getArrayU8FromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000007: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000007: function(arg0) {
+        __wbindgen_cast_0000000000000008: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000009: function(arg0, arg1) {
             var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_export4(arg0, arg1 * 1, 1);
             // Cast intrinsic for `Vector(U8) -> Externref`.
@@ -1213,14 +1244,19 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_16813(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_16813(arg0, arg1);
+function __wasm_bindgen_func_elem_17532(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_17532(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_17533(arg0, arg1, arg2) {
+    const ret = wasm.__wasm_bindgen_func_elem_17533(arg0, arg1, addHeapObject(arg2));
+    return takeObject(ret);
 }
 
-function __wasm_bindgen_func_elem_92635(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_95597(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_92635(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_95597(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -1231,8 +1267,8 @@ function __wasm_bindgen_func_elem_92635(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_92637(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_92637(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_95599(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_95599(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const WasmLixFinalization = (typeof FinalizationRegistry === 'undefined')

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

@@ -9,6 +9,8 @@ export const __wbg_wasmremotelixtransaction_free: (a: number, b: number) => void
 export const __wbg_wasmremoteobserveevents_free: (a: number, b: number) => void;
 export const __wbg_wasmsnapshotexport_free: (a: number, b: number) => void;
 export const __wbg_wasmsnapshotrestore_free: (a: number, b: number) => void;
+export const createHosted: (a: number) => number;
+export const deleteHosted: (a: number) => number;
 export const openJsStorage: (a: number, b: number, c: number, d: number, e: number) => number;
 export const openJsStorageFromSnapshot: (a: number, b: number, c: number, d: number) => number;
 export const openMemory: (a: number, b: number, c: number, d: number) => number;
@@ -19,6 +21,7 @@ export const wasmlix_activeBranchId: (a: number) => number;
 export const wasmlix_beginTransaction: (a: number) => number;
 export const wasmlix_close: (a: number) => number;
 export const wasmlix_createBranch: (a: number, b: number) => number;
+export const wasmlix_createHosted: (a: number, b: number) => number;
 export const wasmlix_execute: (a: number, b: number, c: number, d: number, e: number) => number;
 export const wasmlix_executeBatch: (a: number, b: number, c: number) => number;
 export const wasmlix_exportSnapshot: (a: number) => number;
@@ -69,9 +72,10 @@ 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_92635: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_92637: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_16813: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_95597: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_95599: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_17533: (a: number, b: number, c: number) => number;
+export const __wasm_bindgen_func_elem_17532: (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/worker/client.d.ts

@@ -1,7 +1,7 @@
 import type { LixBinding, LixStorageConfig } from "../binding-types.js";
-import type { LixTelemetryOptions, LixOpenProgress, LixOpenReport, SyncLixServerOptions } from "../types.js";
+import type { LixTelemetryOptions, LixOpenProgress, LixOpenReport, LixServerOptions } from "../types.js";
 import { type WorkerConnection, type WorkerNotification, type WorkerOperation } from "./protocol.js";
-type SyncServerRuntimeOptions = Omit<SyncLixServerOptions, "mode">;
+type SyncServerRuntimeOptions = LixServerOptions;
 export declare function openLixWorker(storage: LixStorageConfig, onDisposed?: () => void, telemetry?: LixTelemetryOptions, server?: SyncServerRuntimeOptions, onProgress?: (progress: LixOpenProgress) => void, snapshot?: ReadableStream<Uint8Array>): Promise<LixWorkerClient>;
 export declare function pumpSnapshotToWorker(client: LixWorkerClient, reader: ReadableStreamDefaultReader<Uint8Array>, snapshotId: number, open: Promise<unknown>): Promise<void>;
 /** Opens the local worker transport behind the semantic Lix binding. */
@@ -48,4 +48,7 @@ export declare class LixWorkerClient {
     private handleFatal;
     private rejectPending;
 }
+export declare function hostedLixWorkerOperation<T>(operation: Extract<WorkerOperation, {
+    kind: "hosted.create" | "hosted.delete";
+}>): Promise<T>;
 export {};

package/dist/worker/client.js

@@ -284,6 +284,7 @@ export function workerBinding(client, lease, sessionId) {
         mergeBranchPreview: (options) => request({ kind: "mergeBranchPreview", options }),
         mergeBranch: (options) => request({ kind: "mergeBranch", options }),
         syncDiskToLix: () => request({ kind: "syncDiskToLix" }),
+        createHosted: (server) => request({ kind: "hosted.createFrom", server }),
         exportSnapshot: () => {
             const exportId = request({ kind: "exportSnapshot" });
             let canceled = false;
@@ -757,3 +758,13 @@ async function resolveDirectSyncServer(server) {
         fetch: server.fetch,
     };
 }
+export async function hostedLixWorkerOperation(operation) {
+    const client = new LixWorkerClient();
+    client.beginLease();
+    try {
+        return await client.request(operation, 0);
+    }
+    finally {
+        await client.terminate();
+    }
+}

package/dist/worker/host.js

@@ -1,4 +1,4 @@
-import { openLixBinding } from "#binding";
+import { openLixBinding, createHostedBinding, deleteHostedBinding, } from "#binding";
 import { deserializeWorkerError, serializeWorkerError, } from "./protocol.js";
 export function startWorkerHost(endpoint, openBinding = openLixBinding) {
     const sessions = new Map();
@@ -51,8 +51,8 @@ export function startWorkerHost(endpoint, openBinding = openLixBinding) {
         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.
+            // finite-operation queue lets a long-running operation block a newly
+            // mounted query, including one that needs lazy history hydration.
             // The live `next()` lane is already independent for the same reason.
             void respond(message, () => handleObserveRegistration(message.sessionId, operation.sql, operation.params));
             return;
@@ -60,7 +60,9 @@ export function startWorkerHost(endpoint, openBinding = openLixBinding) {
         finiteQueue = finiteQueue.then(async () => {
             try {
                 await respond(message, async () => {
-                    if (message.operation.kind !== "open") {
+                    if (message.operation.kind !== "open" &&
+                        message.operation.kind !== "hosted.create" &&
+                        message.operation.kind !== "hosted.delete") {
                         requiredLix(message.sessionId).setTelemetryParent(message.telemetryParent);
                     }
                     return handleFiniteOperation(message.sessionId, message.operation, message.telemetryParent);
@@ -163,6 +165,16 @@ export function startWorkerHost(endpoint, openBinding = openLixBinding) {
     }
     async function handleFiniteOperation(sessionId, operation, telemetryParent) {
         switch (operation.kind) {
+            case "hosted.create":
+                return createHostedBinding(operation.server);
+            case "hosted.delete":
+                return deleteHostedBinding(operation.server);
+            case "hosted.createFrom": {
+                const binding = requiredLix(sessionId);
+                if (!binding.createHosted)
+                    throw new TypeError("createLix() from requires a local Lix");
+                return binding.createHosted(operation.server);
+            }
             case "open":
                 if (sessions.size > 0)
                     throw workerStateError("Lix worker is already open");
@@ -238,18 +250,17 @@ export function startWorkerHost(endpoint, openBinding = openLixBinding) {
                 return requiredLix(sessionId).importFilesystemPaths(operation.paths);
             case "syncDiskToLix":
                 return requiredLix(sessionId).syncDiskToLix();
-            case "exportSnapshot":
-                {
-                    const binding = requiredLix(sessionId);
-                    const exportSnapshot = binding.exportSnapshot;
-                    if (!exportSnapshot) {
-                        throw workerStateError("this Lix binding cannot export snapshots");
-                    }
-                    const snapshot = exportSnapshot.call(binding);
-                    const exportId = nextSnapshotExportId++;
-                    snapshotExports.set(exportId, snapshot);
-                    return exportId;
+            case "exportSnapshot": {
+                const binding = requiredLix(sessionId);
+                const exportSnapshot = binding.exportSnapshot;
+                if (!exportSnapshot) {
+                    throw workerStateError("this Lix binding cannot export snapshots");
                 }
+                const snapshot = exportSnapshot.call(binding);
+                const exportId = nextSnapshotExportId++;
+                snapshotExports.set(exportId, snapshot);
+                return exportId;
+            }
             case "exportSnapshot.next":
                 throw workerStateError("snapshot pulls bypass the finite operation queue");
             case "exportSnapshot.cancel":

package/dist/worker/protocol.d.ts

@@ -36,6 +36,15 @@ export type WorkerRequest = {
     operation: WorkerOperation;
 };
 export type WorkerOperation = {
+    kind: "hosted.create";
+    server: import("../binding-types.js").HostedServerBindingOptions;
+} | {
+    kind: "hosted.delete";
+    server: import("../binding-types.js").HostedServerBindingOptions;
+} | {
+    kind: "hosted.createFrom";
+    server: import("../binding-types.js").HostedServerBindingOptions;
+} | {
     kind: "open";
     storage: LixStorageConfig;
     telemetryEnabled: boolean;

package/package.json

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