@lix-js/sdk 0.12.3 → 0.15.0

package/dist/worker/protocol.d.ts

@@ -1,13 +1,57 @@
 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;
+} & ({
+    responseMode: "buffered";
+    responseLimit: number;
+} | {
+    responseMode: "stream";
+});
+type WorkerSyncFetchResponseHead = {
+    status: number;
+    statusText: string;
+    headers: [string, string][];
+};
+export type WorkerSyncFetchResponse = WorkerSyncFetchResponseHead & ({
+    streaming: true;
+} | {
+    streaming?: false;
+    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 +82,6 @@ export type WorkerOperation = {
 } | {
     kind: "createBranch";
     options: CreateBranchOptions;
-} | {
-    kind: "createCheckpoint";
 } | {
     kind: "undo";
 } | {
@@ -58,6 +100,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 +124,43 @@ 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;
+    };
+} | {
+    kind: "sync.fetch.stream.result";
+    requestId: number;
+    result: {
+        ok: true;
+        done: true;
+    } | {
+        ok: true;
+        done: false;
+        chunk: Uint8Array;
+    } | {
+        ok: false;
+        error: SerializedWorkerError;
+    };
 };
 export type WorkerInput = WorkerRequest | WorkerNotification;
 export type WorkerConnection = {
@@ -107,6 +194,23 @@ 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.stream.pull";
+    requestId: number;
+} | {
+    kind: "sync.fetch.cancel";
+    requestId: number;
 };
 export declare function serializeWorkerError(error: unknown): SerializedWorkerError;
 export declare function deserializeWorkerError(error: SerializedWorkerError): Error;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@lix-js/sdk",
 	"type": "module",
-	"version": "0.12.3",
+	"version": "0.15.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.3",
-		"@lix-js/sdk-linux-arm64": "0.12.3",
-		"@lix-js/sdk-linux-x64": "0.12.3",
-		"@lix-js/sdk-win32-x64": "0.12.3"
+		"@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"
 	},
 	"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 {};

package/dist/indexeddb-backend.js

@@ -1,121 +0,0 @@
-const DATABASE_VERSION = 1;
-const ENTRY_STORE = "entries";
-/** Internal worker-local bridge used by the WASM IndexedDB storage adapter. */
-export class IndexedDbBackend {
-    #database;
-    #releaseLock;
-    #closed = false;
-    constructor(database, releaseLock) {
-        this.#database = database;
-        this.#releaseLock = releaseLock;
-    }
-    static async open(name) {
-        const releaseLock = await acquireDatabaseLock(name);
-        try {
-            const request = indexedDB.open(name, DATABASE_VERSION);
-            request.onupgradeneeded = () => {
-                if (!request.result.objectStoreNames.contains(ENTRY_STORE)) {
-                    request.result.createObjectStore(ENTRY_STORE);
-                }
-            };
-            return new IndexedDbBackend(await openDatabase(request), releaseLock);
-        }
-        catch (error) {
-            releaseLock();
-            throw error;
-        }
-    }
-    async loadEntries() {
-        const transaction = this.#database.transaction(ENTRY_STORE, "readonly");
-        const store = transaction.objectStore(ENTRY_STORE);
-        const entries = [];
-        await new Promise((resolve, reject) => {
-            const request = store.openCursor();
-            request.onerror = () => reject(request.error ?? transaction.error);
-            request.onsuccess = () => {
-                const cursor = request.result;
-                if (!cursor) {
-                    resolve();
-                    return;
-                }
-                try {
-                    entries.push({
-                        key: copyBytes(cursor.key, "IndexedDB entry key"),
-                        value: copyBytes(cursor.value, "IndexedDB entry value"),
-                    });
-                }
-                catch (error) {
-                    transaction.abort();
-                    reject(error);
-                    return;
-                }
-                cursor.continue();
-            };
-        });
-        await transactionDone(transaction);
-        return entries;
-    }
-    async applyChanges(changes) {
-        const transaction = this.#database.transaction(ENTRY_STORE, "readwrite", {
-            durability: changes.strictDurability ? "strict" : "default",
-        });
-        const store = transaction.objectStore(ENTRY_STORE);
-        for (const key of changes.deletes)
-            store.delete(binaryKey(key));
-        for (const entry of changes.puts) {
-            store.put(entry.value, binaryKey(entry.key));
-        }
-        await transactionDone(transaction);
-    }
-    async close() {
-        if (this.#closed)
-            return;
-        this.#closed = true;
-        this.#database.close();
-        this.#releaseLock();
-    }
-}
-function acquireDatabaseLock(name) {
-    let release;
-    const released = new Promise((resolve) => {
-        release = resolve;
-    });
-    return new Promise((resolve, reject) => {
-        void navigator.locks
-            .request(`lix:indexeddb:${name}`, { mode: "exclusive", ifAvailable: true }, async (lock) => {
-            if (!lock) {
-                reject(new Error(`IndexedDB storage '${name}' is already open`));
-                return;
-            }
-            resolve(release);
-            await released;
-        })
-            .catch(reject);
-    });
-}
-function openDatabase(request) {
-    return new Promise((resolve, reject) => {
-        request.onsuccess = () => resolve(request.result);
-        request.onerror = () => reject(request.error);
-        request.onblocked = () => reject(new Error("IndexedDB database open was blocked"));
-    });
-}
-function binaryKey(value) {
-    return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
-}
-function transactionDone(transaction) {
-    return new Promise((resolve, reject) => {
-        transaction.oncomplete = () => resolve();
-        transaction.onabort = () => reject(transaction.error);
-        transaction.onerror = () => reject(transaction.error);
-    });
-}
-function copyBytes(value, label) {
-    if (value instanceof ArrayBuffer) {
-        return new Uint8Array(value.slice(0));
-    }
-    if (ArrayBuffer.isView(value)) {
-        return new Uint8Array(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
-    }
-    throw new Error(`${label} is not binary data`);
-}

package/dist/remote/sse.d.ts

@@ -1,12 +0,0 @@
-export type SseEvent = {
-    event: string;
-    data: string;
-    retry?: number;
-};
-/**
- * Parses a fetch response body as a stream of server-sent events.
- *
- * The caller remains responsible for validating the response status and
- * content type before passing its body here.
- */
-export declare function readSseEvents(stream: ReadableStream<Uint8Array>): AsyncGenerator<SseEvent, void, void>;

package/dist/remote/sse.js

@@ -1,87 +0,0 @@
-/**
- * Parses a fetch response body as a stream of server-sent events.
- *
- * The caller remains responsible for validating the response status and
- * content type before passing its body here.
- */
-export async function* readSseEvents(stream) {
-    const decoder = new TextDecoder();
-    const reader = stream.getReader();
-    let bufferedText = "";
-    let eventName = "";
-    let retry;
-    let dataLines = [];
-    function processLine(line) {
-        if (line.length === 0) {
-            return dispatchEvent();
-        }
-        if (line.startsWith(":")) {
-            return undefined;
-        }
-        const colonIndex = line.indexOf(":");
-        const field = colonIndex === -1 ? line : line.slice(0, colonIndex);
-        let value = colonIndex === -1 ? "" : line.slice(colonIndex + 1);
-        if (value.startsWith(" "))
-            value = value.slice(1);
-        switch (field) {
-            case "event":
-                eventName = value;
-                break;
-            case "data":
-                dataLines.push(value);
-                break;
-            case "retry": {
-                if (/^\d+$/.test(value)) {
-                    const parsed = Number(value);
-                    if (Number.isSafeInteger(parsed))
-                        retry = parsed;
-                }
-                break;
-            }
-            // Event IDs and extension fields are intentionally ignored. Remote Lix
-            // observations use their payload sequence for resumption instead.
-            default:
-                break;
-        }
-        return undefined;
-    }
-    function dispatchEvent() {
-        const hasData = dataLines.length !== 0;
-        const event = hasData
-            ? {
-                event: eventName.length === 0 ? "message" : eventName,
-                data: dataLines.join("\n"),
-                ...(retry === undefined ? {} : { retry }),
-            }
-            : undefined;
-        eventName = "";
-        retry = undefined;
-        dataLines = [];
-        return event;
-    }
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            bufferedText += decoder.decode(value, { stream: true });
-            let newlineIndex = bufferedText.indexOf("\n");
-            while (newlineIndex !== -1) {
-                let line = bufferedText.slice(0, newlineIndex);
-                bufferedText = bufferedText.slice(newlineIndex + 1);
-                if (line.endsWith("\r"))
-                    line = line.slice(0, -1);
-                const event = processLine(line);
-                if (event !== undefined)
-                    yield event;
-                newlineIndex = bufferedText.indexOf("\n");
-            }
-        }
-        decoder.decode();
-        // SSE dispatches only at a blank line. An incomplete final frame indicates
-        // a truncated connection and is deliberately left for the caller to retry.
-    }
-    finally {
-        reader.releaseLock();
-    }
-}

package/dist/workerd.d.ts

@@ -1,25 +0,0 @@
-import type { LixBinding } from "./binding-types.js";
-export type SqlScriptPlan = {
-    statements: SqlScriptStatement[];
-};
-export type SqlScriptStatement = {
-    sql: string;
-    paramStart: number;
-    paramEnd: number;
-};
-export interface OpenMemoryLixOptions {
-    snapshot?: Uint8Array;
-}
-export interface WorkerdLixBinding extends LixBinding {
-    exportSnapshot(): Promise<Uint8Array>;
-}
-/** Parses SQL using the same DataFusion dialect and transaction policy as Lix. */
-export declare function parseSqlScript(sql: string, providedParamCount: number): SqlScriptPlan;
-/**
- * Opens an in-memory Lix binding directly in a Cloudflare Worker isolate.
- *
- * The browser SDK intentionally uses Web Workers. Workerd does not implement
- * that API, so this entry point initializes the precompiled module directly.
- * Plugin execution is deliberately unavailable in this environment.
- */
-export declare function openMemoryLix(options?: OpenMemoryLixOptions): Promise<WorkerdLixBinding>;

package/dist/workerd.js

@@ -1,35 +0,0 @@
-// Generated before TypeScript compilation and emitted beside this module.
-// @ts-expect-error Generated by build:wasm.
-import wasmModule from "./wasm/lix_js_sdk_bg.wasm";
-// @ts-expect-error Generated by build:wasm.
-import { initSync, openMemoryFromSnapshot, parseSqlScript as parseSqlScriptBinding } from "./wasm/lix_js_sdk.js";
-let initialized = false;
-function initializeWasm() {
-    if (initialized)
-        return;
-    initSync({ module: wasmModule });
-    initialized = true;
-}
-/** Parses SQL using the same DataFusion dialect and transaction policy as Lix. */
-export function parseSqlScript(sql, providedParamCount) {
-    initializeWasm();
-    return parseSqlScriptBinding(sql, providedParamCount);
-}
-/**
- * Opens an in-memory Lix binding directly in a Cloudflare Worker isolate.
- *
- * The browser SDK intentionally uses Web Workers. Workerd does not implement
- * that API, so this entry point initializes the precompiled module directly.
- * Plugin execution is deliberately unavailable in this environment.
- */
-export async function openMemoryLix(options = {}) {
-    if (!options || typeof options !== "object" || Array.isArray(options)) {
-        throw new TypeError("openMemoryLix() options must be an object");
-    }
-    if (options.snapshot !== undefined &&
-        !(options.snapshot instanceof Uint8Array)) {
-        throw new TypeError("openMemoryLix() snapshot must be a Uint8Array");
-    }
-    initializeWasm();
-    return openMemoryFromSnapshot(undefined, options.snapshot);
-}