@lix-js/sdk 0.12.2 → 0.14.0

package/dist/worker/host.d.ts

@@ -1,2 +1,3 @@
-import { type WorkerHostEndpoint } from "./protocol.js";
+import { type WorkerHostEndpoint, type WorkerSyncFetchResponse } from "./protocol.js";
 export declare function startWorkerHost(endpoint: WorkerHostEndpoint): void;
+export declare function responseFromSyncFetch(resolved: WorkerSyncFetchResponse): Response;

package/dist/worker/host.js

@@ -1,24 +1,66 @@
 import { openLixBinding } from "#binding";
-import { serializeWorkerError, } from "./protocol.js";
+import { deserializeWorkerError, serializeWorkerError, } from "./protocol.js";
 export function startWorkerHost(endpoint) {
-    let lix;
+    const sessions = new Map();
+    let nextSessionId = 1;
     let nextTransactionId = 1;
     let nextObserveId = 1;
     const transactions = new Map();
     const observations = new Map();
+    let nextSnapshotExportId = 1;
+    const snapshotExports = new Map();
+    const snapshotInputs = new Map();
+    let nextSyncRequestId = 1;
+    const pendingSyncHeaders = new Map();
+    const pendingSyncFetch = new Map();
     let finiteQueue = Promise.resolve();
     endpoint.onMessage((message) => {
         if (!("id" in message)) {
             handleNotification(message);
             return;
         }
-        if (message.operation.kind === "observe.next") {
-            const observeId = message.operation.observeId;
-            void respond(message, () => handleObserveNext(observeId));
+        if (message.operation.kind === "openSnapshot.write" ||
+            message.operation.kind === "openSnapshot.finish") {
+            const operation = message.operation;
+            void respond(message, () => handleSnapshotInput(operation));
+            return;
+        }
+        if (message.operation.kind === "open" &&
+            message.operation.snapshotId !== undefined) {
+            ensureSnapshotInput(message.operation.snapshotId);
+        }
+        if (message.operation.kind === "observe.next" ||
+            message.operation.kind === "exportSnapshot.next" ||
+            message.operation.kind === "exportSnapshot.cancel") {
+            if (message.operation.kind === "observe.next") {
+                const observeId = message.operation.observeId;
+                void respond(message, () => handleObserveNext(observeId, message.telemetryParent));
+            }
+            else if (message.operation.kind === "exportSnapshot.next") {
+                const exportId = message.operation.exportId;
+                void respond(message, () => handleSnapshotNext(exportId));
+            }
+            else {
+                const exportId = message.operation.exportId;
+                void respond(message, () => handleSnapshotCancel(exportId));
+            }
             return;
         }
         finiteQueue = finiteQueue.then(async () => {
-            await respond(message, () => handleFiniteOperation(message.operation));
+            try {
+                await respond(message, async () => {
+                    if (message.operation.kind !== "open") {
+                        requiredLix(message.sessionId).setTelemetryParent(message.telemetryParent);
+                    }
+                    return handleFiniteOperation(message.sessionId, message.operation, message.telemetryParent);
+                });
+            }
+            finally {
+                // The mutable FFI carrier is safe only within this serialized
+                // operation. Clear it before another request or background task
+                // can accidentally inherit a stale remote parent.
+                (sessions.get(message.sessionId) ?? sessions.get(0))?.setTelemetryParent();
+            }
         });
     });
     function handleNotification(message) {
@@ -29,6 +71,13 @@ export function startWorkerHost(endpoint) {
                 events?.close();
                 break;
             }
+            case "openSnapshot.cancel": {
+                const input = snapshotInputs.get(message.snapshotId);
+                snapshotInputs.delete(message.snapshotId);
+                if (input)
+                    void input.writer.abort().catch(() => undefined);
+                break;
+            }
             case "transaction.abandon":
                 finiteQueue = finiteQueue.then(async () => {
                     const transaction = transactions.get(message.transactionId);
@@ -37,6 +86,28 @@ export function startWorkerHost(endpoint) {
                         await transaction.rollback().catch(() => undefined);
                 });
                 break;
+            case "sync.headers.result": {
+                const pending = pendingSyncHeaders.get(message.requestId);
+                pendingSyncHeaders.delete(message.requestId);
+                if (!pending)
+                    break;
+                if (message.result.ok)
+                    pending.resolve(message.result.headers);
+                else
+                    pending.reject(deserializeWorkerError(message.result.error));
+                break;
+            }
+            case "sync.fetch.result": {
+                const pending = pendingSyncFetch.get(message.requestId);
+                pendingSyncFetch.delete(message.requestId);
+                if (!pending)
+                    break;
+                if (message.result.ok)
+                    pending.resolve(message.result.response);
+                else
+                    pending.reject(deserializeWorkerError(message.result.error));
+                break;
+            }
         }
     }
     async function respond(request, operation) {
@@ -52,21 +123,45 @@ export function startWorkerHost(endpoint) {
             });
         }
     }
-    async function handleFiniteOperation(operation) {
+    async function handleFiniteOperation(sessionId, operation, telemetryParent) {
         switch (operation.kind) {
             case "open":
-                if (lix)
+                if (sessions.size > 0)
                     throw workerStateError("Lix worker is already open");
-                lix = await openLixBinding(operation.storage, operation.telemetryEnabled
-                    ? (span) => endpoint.postMessage({ kind: "telemetry", span })
-                    : undefined);
-                return undefined;
+                {
+                    const snapshot = operation.snapshotId === undefined
+                        ? undefined
+                        : requiredSnapshotInput(operation.snapshotId).readable;
+                    try {
+                        const opened = await openLixBinding(operation.storage, operation.telemetryEnabled
+                            ? (span) => endpoint.postMessage({ kind: "telemetry", span })
+                            : undefined, telemetryParent, createSyncServerBridge(operation.server), operation.progressEnabled
+                            ? (progress) => endpoint.postMessage({ kind: "open.progress", progress })
+                            : undefined, snapshot);
+                        sessions.set(0, opened);
+                        return opened.openReport?.();
+                    }
+                    finally {
+                        if (operation.snapshotId !== undefined) {
+                            snapshotInputs.delete(operation.snapshotId);
+                        }
+                    }
+                }
+            case "openSnapshot.write":
+            case "openSnapshot.finish":
+                throw workerStateError("snapshot input uses the restore lane");
+            case "openAnotherSession": {
+                const opened = await requiredLix(sessionId).openAnotherSession(operation.options);
+                const openedSessionId = nextSessionId++;
+                sessions.set(openedSessionId, opened);
+                return openedSessionId;
+            }
             case "execute":
-                return requiredLix().execute(operation.sql, operation.params, operation.options);
+                return requiredLix(sessionId).execute(operation.sql, operation.params, operation.options);
             case "executeBatch":
-                return requiredLix().executeBatch(operation.statements, operation.options);
+                return requiredLix(sessionId).executeBatch(operation.statements, operation.options);
             case "beginTransaction": {
-                const transaction = await requiredLix().beginTransaction();
+                const transaction = await requiredLix(sessionId).beginTransaction();
                 const transactionId = nextTransactionId++;
                 transactions.set(transactionId, transaction);
                 return transactionId;
@@ -86,56 +181,176 @@ export function startWorkerHost(endpoint) {
                 return undefined;
             }
             case "activeBranchId":
-                return requiredLix().activeBranchId();
+                return requiredLix(sessionId).activeBranchId();
             case "activeAccountId":
-                return requiredLix().activeAccountId();
+                return requiredLix(sessionId).activeAccountId();
             case "createBranch":
-                return requiredLix().createBranch(operation.options);
-            case "createCheckpoint":
-                return requiredLix().createCheckpoint();
+                return requiredLix(sessionId).createBranch(operation.options);
             case "undo":
-                return requiredLix().undo();
+                return requiredLix(sessionId).undo();
             case "redo":
-                return requiredLix().redo();
+                return requiredLix(sessionId).redo();
             case "switchBranch":
-                return requiredLix().switchBranch(operation.options);
+                return requiredLix(sessionId).switchBranch(operation.options);
             case "mergeBranchPreview":
-                return requiredLix().mergeBranchPreview(operation.options);
+                return requiredLix(sessionId).mergeBranchPreview(operation.options);
             case "mergeBranch":
-                return requiredLix().mergeBranch(operation.options);
+                return requiredLix(sessionId).mergeBranch(operation.options);
             case "importFilesystemPaths":
-                return requiredLix().importFilesystemPaths(operation.paths);
+                return requiredLix(sessionId).importFilesystemPaths(operation.paths);
             case "syncDiskToLix":
-                return requiredLix().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.next":
+                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().observe(operation.sql, operation.params);
+                const events = await requiredLix(sessionId).observe(operation.sql, operation.params);
                 const observeId = nextObserveId++;
                 observations.set(observeId, events);
                 return observeId;
             }
             case "close": {
-                const openLix = requiredLix();
+                const openLix = requiredLix(sessionId);
                 await openLix.close();
-                for (const events of observations.values())
-                    events.close();
-                observations.clear();
-                transactions.clear();
-                lix = undefined;
+                sessions.delete(sessionId);
                 return undefined;
             }
             case "observe.next":
                 throw workerStateError("observe.next must use the observation lane");
         }
     }
-    async function handleObserveNext(observeId) {
+    async function handleSnapshotNext(exportId) {
+        const snapshot = snapshotExports.get(exportId);
+        if (!snapshot)
+            return undefined;
+        try {
+            const chunk = await snapshot.next();
+            if (chunk == null)
+                snapshotExports.delete(exportId);
+            return chunk ?? undefined;
+        }
+        catch (error) {
+            snapshotExports.delete(exportId);
+            await Promise.resolve(snapshot.cancel()).catch(() => undefined);
+            throw error;
+        }
+    }
+    async function handleSnapshotCancel(exportId) {
+        const snapshot = snapshotExports.get(exportId);
+        snapshotExports.delete(exportId);
+        if (snapshot)
+            await snapshot.cancel();
+    }
+    function ensureSnapshotInput(snapshotId) {
+        if (snapshotInputs.has(snapshotId))
+            return;
+        const stream = new TransformStream(undefined, { highWaterMark: 0 }, { highWaterMark: 0 });
+        snapshotInputs.set(snapshotId, {
+            readable: stream.readable,
+            writer: stream.writable.getWriter(),
+        });
+    }
+    function requiredSnapshotInput(snapshotId) {
+        const input = snapshotInputs.get(snapshotId);
+        if (!input)
+            throw workerStateError("snapshot restore input is closed");
+        return input;
+    }
+    async function handleSnapshotInput(operation) {
+        const input = requiredSnapshotInput(operation.snapshotId);
+        if (operation.kind === "openSnapshot.write") {
+            await input.writer.write(operation.chunk);
+            return;
+        }
+        await input.writer.close();
+    }
+    function createSyncServerBridge(server) {
+        if (!server)
+            return undefined;
+        return {
+            url: server.url,
+            headers: server.headers ?? [],
+            headerProvider: server.dynamicHeaders
+                ? () => {
+                    const requestId = nextSyncRequestId++;
+                    return new Promise((resolve, reject) => {
+                        pendingSyncHeaders.set(requestId, { resolve, reject });
+                        endpoint.postMessage({ kind: "sync.headers", requestId });
+                    });
+                }
+                : undefined,
+            fetch: server.customFetch ? bridgeFetch : undefined,
+        };
+    }
+    async function bridgeFetch(input, init) {
+        const responseLimit = init?.lixResponseLimit;
+        if (typeof responseLimit !== "number" ||
+            !Number.isSafeInteger(responseLimit) ||
+            responseLimit <= 0) {
+            throw new TypeError("Browser sync fetch has no valid response limit");
+        }
+        const requestId = nextSyncRequestId++;
+        const request = {
+            url: typeof input === "string"
+                ? input
+                : input instanceof URL
+                    ? input.toString()
+                    : input.url,
+            method: init?.method ?? "GET",
+            headers: headerEntries(init?.headers),
+            body: serializableBody(init?.body),
+            credentials: init?.credentials,
+            responseLimit,
+        };
+        const response = new Promise((resolve, reject) => {
+            pendingSyncFetch.set(requestId, { resolve, reject });
+            endpoint.postMessage({ kind: "sync.fetch", requestId, request });
+        });
+        const abort = () => {
+            const pending = pendingSyncFetch.get(requestId);
+            pendingSyncFetch.delete(requestId);
+            if (pending) {
+                pending.reject(new DOMException("The operation was aborted", "AbortError"));
+                endpoint.postMessage({ kind: "sync.fetch.cancel", requestId });
+            }
+        };
+        if (init?.signal?.aborted)
+            abort();
+        else
+            init?.signal?.addEventListener("abort", abort, { once: true });
+        try {
+            const resolved = await response;
+            return responseFromSyncFetch(resolved);
+        }
+        finally {
+            init?.signal?.removeEventListener("abort", abort);
+            pendingSyncFetch.delete(requestId);
+        }
+    }
+    async function handleObserveNext(observeId, telemetryParent) {
         const events = observations.get(observeId);
         if (!events)
             return undefined;
+        events.setTelemetryParent(telemetryParent);
         return events.next();
     }
-    function requiredLix() {
+    function requiredLix(sessionId) {
+        const lix = sessions.get(sessionId);
         if (!lix)
-            throw workerStateError("Lix worker is closed");
+            throw workerStateError("Lix session is closed");
         return lix;
     }
     function requiredTransaction(transactionId) {
@@ -148,9 +363,40 @@ export function startWorkerHost(endpoint) {
         return transaction;
     }
 }
+export function responseFromSyncFetch(resolved) {
+    const body = resolved.status === 204 ||
+        resolved.status === 205 ||
+        resolved.status === 304
+        ? null
+        : resolved.body.slice().buffer;
+    return new Response(body, {
+        status: resolved.status,
+        statusText: resolved.statusText,
+        headers: resolved.headers,
+    });
+}
 function workerStateError(message) {
     const error = new Error(message);
     error.name = "LixError";
     error.code = "LIX_ERROR_CLOSED";
     return error;
 }
+function headerEntries(headers) {
+    const entries = [];
+    new Headers(headers).forEach((value, name) => entries.push([name, value]));
+    return entries;
+}
+function serializableBody(body) {
+    if (body === undefined || body === null)
+        return undefined;
+    if (typeof body === "string")
+        return body;
+    if (body instanceof Uint8Array)
+        return body;
+    if (body instanceof ArrayBuffer)
+        return new Uint8Array(body);
+    if (ArrayBuffer.isView(body)) {
+        return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+    }
+    throw new TypeError("Browser sync fetch body is not structured-cloneable");
+}

package/dist/worker/protocol.d.ts

@@ -1,13 +1,48 @@
 import type { BindingBatchStatement, BindingParam, LixStorageConfig } from "../binding-types.js";
-import type { CreateBranchOptions, ExecuteOptions, LixBatchOptions, MergeBranchOptions, SwitchBranchOptions, LixTelemetrySpan } from "../types.js";
+import type { CreateBranchOptions, ExecuteOptions, LixBatchOptions, MergeBranchOptions, SwitchBranchOptions, LixTelemetrySpan, LixTelemetryParentContext, LixOpenProgress, OpenAnotherSessionOptions } from "../types.js";
+export type WorkerSyncServerOptions = {
+    url: string;
+    headers?: [string, string][];
+    dynamicHeaders: boolean;
+    customFetch: boolean;
+};
+export type WorkerSyncFetchRequest = {
+    url: string;
+    method: string;
+    headers: [string, string][];
+    body?: string | Uint8Array;
+    credentials?: RequestCredentials;
+    responseLimit: number;
+};
+export type WorkerSyncFetchResponse = {
+    status: number;
+    statusText: string;
+    headers: [string, string][];
+    body: Uint8Array;
+};
 export type WorkerRequest = {
     id: number;
+    sessionId: number;
+    telemetryParent?: LixTelemetryParentContext;
     operation: WorkerOperation;
 };
 export type WorkerOperation = {
     kind: "open";
     storage: LixStorageConfig;
     telemetryEnabled: boolean;
+    progressEnabled: boolean;
+    snapshotId?: number;
+    server?: WorkerSyncServerOptions;
+} | {
+    kind: "openSnapshot.write";
+    snapshotId: number;
+    chunk: Uint8Array;
+} | {
+    kind: "openSnapshot.finish";
+    snapshotId: number;
+} | {
+    kind: "openAnotherSession";
+    options: OpenAnotherSessionOptions;
 } | {
     kind: "execute";
     sql: string;
@@ -38,8 +73,6 @@ export type WorkerOperation = {
 } | {
     kind: "createBranch";
     options: CreateBranchOptions;
-} | {
-    kind: "createCheckpoint";
 } | {
     kind: "undo";
 } | {
@@ -58,6 +91,14 @@ export type WorkerOperation = {
     paths: string[];
 } | {
     kind: "syncDiskToLix";
+} | {
+    kind: "exportSnapshot";
+} | {
+    kind: "exportSnapshot.next";
+    exportId: number;
+} | {
+    kind: "exportSnapshot.cancel";
+    exportId: number;
 } | {
     kind: "observe";
     sql: string;
@@ -74,6 +115,29 @@ export type WorkerNotification = {
 } | {
     kind: "observe.close";
     observeId: number;
+} | {
+    kind: "openSnapshot.cancel";
+    snapshotId: number;
+} | {
+    kind: "sync.headers.result";
+    requestId: number;
+    result: {
+        ok: true;
+        headers: [string, string][];
+    } | {
+        ok: false;
+        error: SerializedWorkerError;
+    };
+} | {
+    kind: "sync.fetch.result";
+    requestId: number;
+    result: {
+        ok: true;
+        response: WorkerSyncFetchResponse;
+    } | {
+        ok: false;
+        error: SerializedWorkerError;
+    };
 };
 export type WorkerInput = WorkerRequest | WorkerNotification;
 export type WorkerConnection = {
@@ -107,6 +171,19 @@ export type WorkerResponse = {
 } | {
     kind: "telemetry";
     span: LixTelemetrySpan;
+} | {
+    kind: "open.progress";
+    progress: LixOpenProgress;
+} | {
+    kind: "sync.headers";
+    requestId: number;
+} | {
+    kind: "sync.fetch";
+    requestId: number;
+    request: WorkerSyncFetchRequest;
+} | {
+    kind: "sync.fetch.cancel";
+    requestId: number;
 };
 export declare function serializeWorkerError(error: unknown): SerializedWorkerError;
 export declare function deserializeWorkerError(error: SerializedWorkerError): Error;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@lix-js/sdk",
 	"type": "module",
-	"version": "0.12.2",
+	"version": "0.14.0",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -12,11 +12,6 @@
 			"types": "./dist/index.d.ts",
 			"default": "./dist/index.js"
 		},
-		"./workerd": {
-			"types": "./dist/workerd.d.ts",
-			"workerd": "./dist/workerd.js",
-			"default": "./dist/workerd.js"
-		},
 		"./server-protocol": {
 			"types": "./dist/remote/server-protocol.d.ts",
 			"default": "./dist/remote/server-protocol.js"
@@ -43,6 +38,7 @@
 		"build:wasm:dev": "LIX_WASM_PROFILE=dev node ./scripts/build-wasm.js",
 		"build:plugins": "node ./scripts/build-bundled-plugins.js",
 		"benchmark:plugin-reopen": "node ./scripts/benchmark-plugin-reopen.mjs",
+		"benchmark:storage-boundary": "LIX_WASM_STORAGE_BENCH=1 npm run build:browser && LIX_WASM_STORAGE_BENCH=1 vitest run --config vitest.browser.config.ts src/storage-bridge.bench.browser.test.ts",
 		"clean": "node ./scripts/clean.js",
 		"prepare:native-package": "node ./scripts/prepare-native-package.js",
 		"build:ts": "tsc -p tsconfig.json",
@@ -53,10 +49,10 @@
 		"typecheck": "tsc -p tsconfig.test.json --noEmit"
 	},
 	"optionalDependencies": {
-		"@lix-js/sdk-darwin-arm64": "0.12.2",
-		"@lix-js/sdk-linux-arm64": "0.12.2",
-		"@lix-js/sdk-linux-x64": "0.12.2",
-		"@lix-js/sdk-win32-x64": "0.12.2"
+		"@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"
 	},
 	"devDependencies": {
 		"@vitest/browser-playwright": "4.1.10",

package/dist/indexeddb-backend.d.ts

@@ -1,19 +0,0 @@
-type IndexedDbEntry = {
-    key: Uint8Array;
-    value: Uint8Array;
-};
-type IndexedDbChanges = {
-    deletes: Uint8Array[];
-    puts: IndexedDbEntry[];
-    strictDurability: boolean;
-};
-/** Internal worker-local bridge used by the WASM IndexedDB storage adapter. */
-export declare class IndexedDbBackend {
-    #private;
-    private constructor();
-    static open(name: string): Promise<IndexedDbBackend>;
-    loadEntries(): Promise<IndexedDbEntry[]>;
-    applyChanges(changes: IndexedDbChanges): Promise<void>;
-    close(): Promise<void>;
-}
-export {};