@lix-js/sdk 0.15.1 → 0.16.1

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,8 +21,10 @@ 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_exportReplicaRecovery: (a: number, b: number, c: number) => number;
 export const wasmlix_exportSnapshot: (a: number) => number;
 export const wasmlix_importFilesystemPaths: (a: number, b: number) => number;
 export const wasmlix_mergeBranch: (a: number, b: number) => number;
@@ -28,7 +32,9 @@ export const wasmlix_mergeBranchPreview: (a: number, b: number) => number;
 export const wasmlix_observe: (a: number, b: number, c: number, d: number) => number;
 export const wasmlix_openAnotherSession: (a: number, b: number) => number;
 export const wasmlix_openReport: (a: number, b: number) => void;
+export const wasmlix_recoverReplica: (a: number, b: number, c: number) => number;
 export const wasmlix_redo: (a: number) => number;
+export const wasmlix_replicaRecoverySources: (a: number) => number;
 export const wasmlix_setTelemetryParent: (a: number, b: number, c: number) => void;
 export const wasmlix_switchBranch: (a: number, b: number) => number;
 export const wasmlix_syncDiskToLix: (a: number) => number;
@@ -46,13 +52,16 @@ 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_exportReplicaRecovery: (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;
 export const wasmremotelix_observe: (a: number, b: number, c: number, d: number) => number;
 export const wasmremotelix_openAnotherSession: (a: number, b: number) => number;
+export const wasmremotelix_recoverReplica: (a: number, b: number, c: number) => number;
 export const wasmremotelix_redo: (a: number) => number;
+export const wasmremotelix_replicaRecoverySources: (a: number) => number;
 export const wasmremotelix_setTelemetryParent: (a: number, b: number) => void;
 export const wasmremotelix_switchBranch: (a: number, b: number) => number;
 export const wasmremotelix_syncDiskToLix: (a: number) => number;
@@ -69,9 +78,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_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 __wasm_bindgen_func_elem_95812: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_95814: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_17860: (a: number, b: number, c: number) => number;
+export const __wasm_bindgen_func_elem_17859: (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

@@ -274,6 +274,9 @@ export function workerBinding(client, lease, sessionId) {
             });
             return workerTransactionBinding(request, transactionId);
         },
+        replicaRecoverySources: () => request({ kind: "replicaRecoverySources" }),
+        exportReplicaRecovery: (id) => request({ kind: "exportReplicaRecovery", id }),
+        recoverReplica: (id) => request({ kind: "recoverReplica", id }),
         activeBranchId: () => request({ kind: "activeBranchId" }),
         activeAccountId: () => request({ kind: "activeAccountId" }),
         createBranch: (options) => request({ kind: "createBranch", options }),
@@ -284,6 +287,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 +761,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");
@@ -218,6 +230,12 @@ export function startWorkerHost(endpoint, openBinding = openLixBinding) {
                 await transaction.rollback();
                 return undefined;
             }
+            case "replicaRecoverySources":
+                return requiredLix(sessionId).replicaRecoverySources();
+            case "exportReplicaRecovery":
+                return requiredLix(sessionId).exportReplicaRecovery(operation.id);
+            case "recoverReplica":
+                return requiredLix(sessionId).recoverReplica(operation.id);
             case "activeBranchId":
                 return requiredLix(sessionId).activeBranchId();
             case "activeAccountId":
@@ -238,18 +256,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;
@@ -75,6 +84,14 @@ export type WorkerOperation = {
 } | {
     kind: "transaction.rollback";
     transactionId: number;
+} | {
+    kind: "replicaRecoverySources";
+} | {
+    kind: "exportReplicaRecovery";
+    id: string;
+} | {
+    kind: "recoverReplica";
+    id: string;
 } | {
     kind: "activeBranchId";
 } | {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@lix-js/sdk",
 	"type": "module",
-	"version": "0.15.1",
+	"version": "0.16.1",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -11,10 +11,6 @@
 		".": {
 			"types": "./dist/index.d.ts",
 			"default": "./dist/index.js"
-		},
-		"./server-protocol": {
-			"types": "./dist/remote/server-protocol.d.ts",
-			"default": "./dist/remote/server-protocol.js"
 		}
 	},
 	"imports": {
@@ -49,10 +45,10 @@
 		"typecheck": "tsc -p tsconfig.test.json --noEmit"
 	},
 	"optionalDependencies": {
-		"@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"
+		"@lix-js/sdk-darwin-arm64": "0.16.1",
+		"@lix-js/sdk-linux-arm64": "0.16.1",
+		"@lix-js/sdk-linux-x64": "0.16.1",
+		"@lix-js/sdk-win32-x64": "0.16.1"
 	},
 	"devDependencies": {
 		"@vitest/browser-playwright": "4.1.10",

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

@@ -1,185 +0,0 @@
-import type { BindingExecuteResult, BindingObserveEvent } from "../binding-types.js";
-import type { NativeLixValue } from "../value.js";
-export declare const SERVER_PROTOCOL_VERSION = 6;
-export type WireValue = {
-    kind: "null";
-    value: null;
-} | {
-    kind: "bool";
-    value: boolean;
-} | {
-    kind: "int";
-    value: number;
-} | {
-    kind: "float";
-    value: number;
-} | {
-    kind: "text";
-    value: string;
-} | {
-    kind: "jsonb";
-    value: unknown;
-} | {
-    kind: "row_ref";
-    value: string;
-} | {
-    kind: "timestamptz";
-    value: string;
-} | {
-    kind: "blob";
-    base64: string;
-};
-export type WireRequestBlobSplice = {
-    kind: "blob-splice";
-    baseSha256: string;
-    resultSha256: string;
-    prefixBytes: number;
-    suffixBytes: number;
-    insertBase64: string;
-};
-export type WireRequestValue = WireValue | WireRequestBlobSplice;
-export type ServerProtocolHandshake = {
-    protocolVersion: number;
-    activeBranchId: string;
-    activeAccountId: string;
-    sessionId: string;
-};
-export type ServerProtocolHandshakeRequest = {
-    activeBranchId?: string;
-};
-export type ServerProtocolExecuteRequest = {
-    sql: string;
-    params: WireRequestValue[];
-    options?: {
-        originKey?: string;
-    };
-    cacheBlobs?: true;
-};
-export type ServerProtocolExecuteBatchRequest = {
-    statements: Array<{
-        sql: string;
-        params: WireRequestValue[];
-        label?: string;
-    }>;
-    options?: {
-        originKey?: string;
-    };
-    cacheBlobs?: true;
-};
-export type ServerProtocolExecuteResponse = {
-    columns: BindingExecuteResult["columns"];
-    rows: WireValue[][];
-    rowsAffected: number;
-    notices: Array<{
-        code: string;
-        message: string;
-        hint?: string;
-    }>;
-};
-export type ServerProtocolExecuteBatchResponse = ServerProtocolExecuteResponse & {
-    statementIndex: number;
-    label?: string;
-};
-export type ServerProtocolObserveRequest = {
-    sql: string;
-    params: WireValue[];
-};
-export type ServerProtocolObserveSubscription = ServerProtocolObserveRequest & {
-    id: string;
-};
-export type ServerProtocolMultiplexObserveRequest = {
-    subscriptions: ServerProtocolObserveSubscription[];
-};
-type ServerProtocolObserveEventBase = {
-    sequence: number;
-    mutationSequence: number;
-};
-export type ServerProtocolObserveBlobDelta = {
-    kind: "single-blob-splice";
-    baseSequence: number;
-    prefixBytes: number;
-    suffixBytes: number;
-    insertBase64: string;
-};
-type ServerProtocolObserveRowSplice = {
-    kind: "row-splice";
-    baseSequence: number;
-    prefixRows: number;
-    deleteRows: number;
-    insertRows: WireValue[][];
-};
-type ServerProtocolObserveDelta = ServerProtocolObserveBlobDelta | ServerProtocolObserveRowSplice;
-export type ServerProtocolObserveEvent = ServerProtocolObserveEventBase & ({
-    result: ServerProtocolExecuteResponse;
-    delta?: never;
-} | {
-    result?: never;
-    delta: ServerProtocolObserveDelta;
-});
-export type ServerProtocolMultiplexObserveEvent = ServerProtocolObserveEvent & {
-    subscriptionId: string;
-};
-export type ServerProtocolCreateBranchRequest = {
-    id?: string;
-    name: string;
-    fromCommitId?: string;
-};
-export type ServerProtocolCreateBranchResponse = {
-    id: string;
-    name: string;
-    hidden: boolean;
-    commitId: string;
-};
-export type ServerProtocolUndoResponse = {
-    branchId: string;
-    targetCommitId: string;
-    inverseCommitId: string;
-};
-export type ServerProtocolRedoResponse = {
-    branchId: string;
-    targetCommitId: string;
-    replayCommitId: string;
-};
-export type ServerProtocolSwitchBranchRequest = {
-    branchId: string;
-};
-export type ServerProtocolSwitchBranchResponse = {
-    branchId: string;
-};
-export type ServerProtocolErrorBody = {
-    error: {
-        code?: string;
-        message?: string;
-        hint?: string;
-        details?: unknown;
-    };
-};
-export type ServerProtocolObserveErrorEvent = ServerProtocolErrorBody & {
-    retryable?: boolean;
-};
-export type ServerProtocolMultiplexObserveErrorEvent = ServerProtocolObserveErrorEvent & {
-    subscriptionId?: string;
-};
-export declare function encodeWireValue(value: NativeLixValue): WireValue;
-export declare function decodeExecuteResult(value: unknown): BindingExecuteResult;
-export declare function decodeExecuteBatchResult(value: unknown): BindingExecuteResult;
-export declare function decodeHandshake(value: unknown): ServerProtocolHandshake;
-export declare function decodeObserveEvent(value: unknown, base?: BindingObserveEvent): BindingObserveEvent;
-export declare function remoteError(code: string, message: string, options?: {
-    hint?: string;
-    details?: unknown;
-    status?: number;
-}): Error & {
-    code: string;
-    hint?: string;
-    details?: unknown;
-    status?: number;
-};
-export declare function protocolError(message: string): Error & {
-    code: string;
-};
-export declare function errorFromResponseBody(value: unknown, status?: number): Error & {
-    code: string;
-};
-export declare function record(value: unknown, description: string): Record<string, unknown>;
-export {};