@lix-js/sdk 0.6.2 → 0.8.0

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

@@ -0,0 +1,29 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_wasmlix_free: (a: number, b: number) => void;
+export const __wbg_wasmlixtransaction_free: (a: number, b: number) => void;
+export const __wbg_wasmobserveevents_free: (a: number, b: number) => void;
+export const openMemory: (a: number) => number;
+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_execute: (a: number, b: number, c: number, d: number, e: number) => number;
+export const wasmlix_mergeBranch: (a: number, b: number) => number;
+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_switchBranch: (a: number, b: number) => number;
+export const wasmlixtransaction_commit: (a: number) => number;
+export const wasmlixtransaction_execute: (a: number, b: number, c: number, d: number, e: number) => number;
+export const wasmlixtransaction_rollback: (a: number) => number;
+export const wasmobserveevents_close: (a: number) => void;
+export const wasmobserveevents_next: (a: number) => number;
+export const __wasm_bindgen_func_elem_100752: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_100754: (a: number, b: number, c: number, d: 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;
+export const __wbindgen_export4: (a: number, b: number, c: number) => void;
+export const __wbindgen_export5: (a: number, b: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;

package/dist/worker/client.d.ts

@@ -0,0 +1,17 @@
+import type { LixBackendConfig } from "../binding-types.js";
+import { type WorkerConnection, type WorkerNotification, type WorkerOperation } from "./protocol.js";
+export declare function openLixWorker(backend: LixBackendConfig, onDisposed?: () => void): Promise<LixWorkerClient>;
+export declare class LixWorkerClient {
+    private readonly onDisposed?;
+    private readonly connection;
+    private nextRequestId;
+    private readonly pending;
+    private disposed;
+    constructor(onDisposed?: (() => void) | undefined, connection?: WorkerConnection);
+    request<T>(operation: WorkerOperation): Promise<T>;
+    notify(notification: WorkerNotification): void;
+    terminate(): Promise<void>;
+    private handleMessage;
+    private handleFatal;
+    private rejectPending;
+}

package/dist/worker/client.js

@@ -0,0 +1,104 @@
+import { createWorkerConnection } from "#worker-factory";
+import { deserializeWorkerError, } from "./protocol.js";
+export async function openLixWorker(backend, onDisposed) {
+    const client = new LixWorkerClient(onDisposed);
+    try {
+        await client.request({ kind: "open", backend });
+        return client;
+    }
+    catch (error) {
+        await client.terminate();
+        throw error;
+    }
+}
+export class LixWorkerClient {
+    onDisposed;
+    connection;
+    nextRequestId = 1;
+    pending = new Map();
+    disposed = false;
+    constructor(onDisposed, connection = createWorkerConnection()) {
+        this.onDisposed = onDisposed;
+        this.connection = connection;
+        connection.onMessage((message) => this.handleMessage(message));
+        connection.onFatal((error) => this.handleFatal(error));
+    }
+    request(operation) {
+        if (this.disposed)
+            return Promise.reject(workerClosedError());
+        const id = this.nextRequestId++;
+        if (this.pending.size === 0)
+            this.connection.ref();
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, {
+                resolve: (value) => resolve(value),
+                reject,
+            });
+            try {
+                this.connection.postMessage({ id, operation });
+            }
+            catch (error) {
+                this.pending.delete(id);
+                if (this.pending.size === 0)
+                    this.connection.unref();
+                reject(error);
+            }
+        });
+    }
+    notify(notification) {
+        if (this.disposed)
+            return;
+        try {
+            this.connection.postMessage(notification);
+        }
+        catch {
+            // A best-effort finalizer/close notification can race worker shutdown.
+        }
+    }
+    async terminate() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.rejectPending(workerClosedError());
+        try {
+            await this.connection.terminate();
+        }
+        finally {
+            this.onDisposed?.();
+        }
+    }
+    handleMessage(message) {
+        const pending = this.pending.get(message.id);
+        if (!pending)
+            return;
+        this.pending.delete(message.id);
+        if (this.pending.size === 0)
+            this.connection.unref();
+        if (message.ok)
+            pending.resolve(message.value);
+        else
+            pending.reject(deserializeWorkerError(message.error));
+    }
+    handleFatal(error) {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        const fatal = error;
+        fatal.name = "LixError";
+        fatal.code ??= "LIX_WORKER_TERMINATED";
+        this.rejectPending(fatal);
+        this.onDisposed?.();
+    }
+    rejectPending(error) {
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+        this.connection.unref();
+    }
+}
+function workerClosedError() {
+    const error = new Error("Lix worker is closed");
+    error.name = "LixError";
+    error.code = "LIX_ERROR_CLOSED";
+    return error;
+}

package/dist/worker/entry.browser.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/worker/entry.browser.js

@@ -0,0 +1,11 @@
+/// <reference lib="webworker" />
+import { startWorkerHost } from "./host.js";
+const scope = globalThis;
+startWorkerHost({
+    postMessage(message) {
+        scope.postMessage(message);
+    },
+    onMessage(listener) {
+        scope.onmessage = (event) => listener(event.data);
+    },
+});

package/dist/worker/entry.node.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/worker/entry.node.js

@@ -0,0 +1,13 @@
+import { parentPort } from "node:worker_threads";
+import { startWorkerHost } from "./host.js";
+const port = parentPort;
+if (!port)
+    throw new Error("Lix worker requires a parent port");
+startWorkerHost({
+    postMessage(message) {
+        port.postMessage(message);
+    },
+    onMessage(listener) {
+        port.on("message", (message) => listener(message));
+    },
+});

package/dist/worker/factory.browser.d.ts

@@ -0,0 +1,2 @@
+import type { WorkerConnection } from "./protocol.js";
+export declare function createWorkerConnection(): WorkerConnection;

package/dist/worker/factory.browser.js

@@ -0,0 +1,23 @@
+/// <reference lib="webworker" />
+export function createWorkerConnection() {
+    const worker = new Worker(new URL("./entry.browser.js", import.meta.url), {
+        type: "module",
+        name: "lix",
+    });
+    return {
+        postMessage(message) {
+            worker.postMessage(message);
+        },
+        onMessage(listener) {
+            worker.onmessage = (event) => listener(event.data);
+        },
+        onFatal(listener) {
+            worker.onerror = (event) => listener(event.error ?? new Error(event.message ?? "Lix worker failed"));
+        },
+        ref() { },
+        unref() { },
+        async terminate() {
+            worker.terminate();
+        },
+    };
+}

package/dist/worker/factory.node.d.ts

@@ -0,0 +1,2 @@
+import type { WorkerConnection } from "./protocol.js";
+export declare function createWorkerConnection(): WorkerConnection;

package/dist/worker/factory.node.js

@@ -0,0 +1,35 @@
+import { Worker } from "node:worker_threads";
+export function createWorkerConnection() {
+    const worker = new Worker(new URL("./entry.node.js", import.meta.url), {
+        name: "lix",
+    });
+    let terminating = false;
+    return {
+        postMessage(message) {
+            worker.postMessage(message);
+        },
+        onMessage(listener) {
+            worker.on("message", (message) => listener(message));
+        },
+        onFatal(listener) {
+            worker.on("error", (error) => {
+                if (!terminating)
+                    listener(error);
+            });
+            worker.on("exit", (code) => {
+                if (!terminating)
+                    listener(new Error(`Lix worker exited with code ${code}`));
+            });
+        },
+        ref() {
+            worker.ref();
+        },
+        unref() {
+            worker.unref();
+        },
+        async terminate() {
+            terminating = true;
+            await worker.terminate();
+        },
+    };
+}

package/dist/worker/host.d.ts

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

package/dist/worker/host.js

@@ -0,0 +1,145 @@
+import { openLixBinding } from "#binding";
+import { createPluginRuntimeDispatch } from "../plugin-runtime.js";
+import { serializeWorkerError, } from "./protocol.js";
+export function startWorkerHost(endpoint) {
+    let lix;
+    let nextTransactionId = 1;
+    let nextObserveId = 1;
+    const transactions = new Map();
+    const observations = 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));
+            return;
+        }
+        finiteQueue = finiteQueue.then(async () => {
+            await respond(message, () => handleFiniteOperation(message.operation));
+        });
+    });
+    function handleNotification(message) {
+        switch (message.kind) {
+            case "observe.close": {
+                const events = observations.get(message.observeId);
+                observations.delete(message.observeId);
+                events?.close();
+                break;
+            }
+            case "transaction.abandon":
+                finiteQueue = finiteQueue.then(async () => {
+                    const transaction = transactions.get(message.transactionId);
+                    transactions.delete(message.transactionId);
+                    if (transaction)
+                        await transaction.rollback().catch(() => undefined);
+                });
+                break;
+        }
+    }
+    async function respond(request, operation) {
+        try {
+            const value = await operation();
+            endpoint.postMessage({ id: request.id, ok: true, value });
+        }
+        catch (error) {
+            endpoint.postMessage({
+                id: request.id,
+                ok: false,
+                error: serializeWorkerError(error),
+            });
+        }
+    }
+    async function handleFiniteOperation(operation) {
+        switch (operation.kind) {
+            case "open":
+                if (lix)
+                    throw workerStateError("Lix worker is already open");
+                lix = await openLixBinding(operation.backend, createPluginRuntimeDispatch());
+                return undefined;
+            case "execute":
+                return requiredLix().execute(operation.sql, operation.params, operation.options);
+            case "beginTransaction": {
+                const transaction = await requiredLix().beginTransaction();
+                const transactionId = nextTransactionId++;
+                transactions.set(transactionId, transaction);
+                return transactionId;
+            }
+            case "transaction.execute":
+                return requiredTransaction(operation.transactionId).execute(operation.sql, operation.params, operation.options);
+            case "transaction.commit": {
+                const transaction = requiredTransaction(operation.transactionId);
+                transactions.delete(operation.transactionId);
+                await transaction.commit();
+                return undefined;
+            }
+            case "transaction.rollback": {
+                const transaction = requiredTransaction(operation.transactionId);
+                transactions.delete(operation.transactionId);
+                await transaction.rollback();
+                return undefined;
+            }
+            case "activeBranchId":
+                return requiredLix().activeBranchId();
+            case "createBranch":
+                return requiredLix().createBranch(operation.options);
+            case "switchBranch":
+                return requiredLix().switchBranch(operation.options);
+            case "mergeBranchPreview":
+                return requiredLix().mergeBranchPreview(operation.options);
+            case "mergeBranch":
+                return requiredLix().mergeBranch(operation.options);
+            case "importFilesystemPaths":
+                return requiredLix().importFilesystemPaths(operation.paths);
+            case "syncDiskToLix":
+                return requiredLix().syncDiskToLix();
+            case "observe": {
+                const events = await requiredLix().observe(operation.sql, operation.params);
+                const observeId = nextObserveId++;
+                observations.set(observeId, events);
+                return observeId;
+            }
+            case "close": {
+                const openLix = requiredLix();
+                await openLix.close();
+                for (const events of observations.values())
+                    events.close();
+                observations.clear();
+                transactions.clear();
+                lix = undefined;
+                return undefined;
+            }
+            case "observe.next":
+                throw workerStateError("observe.next must use the observation lane");
+        }
+    }
+    async function handleObserveNext(observeId) {
+        const events = observations.get(observeId);
+        if (!events)
+            return undefined;
+        return events.next();
+    }
+    function requiredLix() {
+        if (!lix)
+            throw workerStateError("Lix worker is closed");
+        return lix;
+    }
+    function requiredTransaction(transactionId) {
+        const transaction = transactions.get(transactionId);
+        if (!transaction) {
+            const error = workerStateError("Lix transaction is closed");
+            error.code = "LIX_INVALID_TRANSACTION_STATE";
+            throw error;
+        }
+        return transaction;
+    }
+}
+function workerStateError(message) {
+    const error = new Error(message);
+    error.name = "LixError";
+    error.code = "LIX_ERROR_CLOSED";
+    return error;
+}

package/dist/worker/protocol.d.ts

@@ -0,0 +1,96 @@
+import type { BindingParam, LixBackendConfig } from "../binding-types.js";
+import type { CreateBranchOptions, ExecuteOptions, MergeBranchOptions, SwitchBranchOptions } from "../types.js";
+export type WorkerRequest = {
+    id: number;
+    operation: WorkerOperation;
+};
+export type WorkerOperation = {
+    kind: "open";
+    backend: LixBackendConfig;
+} | {
+    kind: "execute";
+    sql: string;
+    params: BindingParam[];
+    options?: ExecuteOptions;
+} | {
+    kind: "beginTransaction";
+} | {
+    kind: "transaction.execute";
+    transactionId: number;
+    sql: string;
+    params: BindingParam[];
+    options?: ExecuteOptions;
+} | {
+    kind: "transaction.commit";
+    transactionId: number;
+} | {
+    kind: "transaction.rollback";
+    transactionId: number;
+} | {
+    kind: "activeBranchId";
+} | {
+    kind: "createBranch";
+    options: CreateBranchOptions;
+} | {
+    kind: "switchBranch";
+    options: SwitchBranchOptions;
+} | {
+    kind: "mergeBranchPreview";
+    options: MergeBranchOptions;
+} | {
+    kind: "mergeBranch";
+    options: MergeBranchOptions;
+} | {
+    kind: "importFilesystemPaths";
+    paths: string[];
+} | {
+    kind: "syncDiskToLix";
+} | {
+    kind: "observe";
+    sql: string;
+    params: BindingParam[];
+} | {
+    kind: "observe.next";
+    observeId: number;
+} | {
+    kind: "close";
+};
+export type WorkerNotification = {
+    kind: "transaction.abandon";
+    transactionId: number;
+} | {
+    kind: "observe.close";
+    observeId: number;
+};
+export type WorkerInput = WorkerRequest | WorkerNotification;
+export type WorkerConnection = {
+    postMessage(message: WorkerInput): void;
+    onMessage(listener: (message: WorkerResponse) => void): void;
+    onFatal(listener: (error: Error) => void): void;
+    ref(): void;
+    unref(): void;
+    terminate(): Promise<void>;
+};
+export type WorkerHostEndpoint = {
+    postMessage(message: WorkerResponse): void;
+    onMessage(listener: (message: WorkerInput) => void): void;
+};
+export type SerializedWorkerError = {
+    name: string;
+    message: string;
+    stack?: string;
+    code?: string;
+    hint?: string;
+    details?: unknown;
+};
+export type WorkerResponse = {
+    id: number;
+    ok: true;
+    value?: unknown;
+} | {
+    id: number;
+    ok: false;
+    error: SerializedWorkerError;
+};
+export declare function serializeWorkerError(error: unknown): SerializedWorkerError;
+export declare function deserializeWorkerError(error: SerializedWorkerError): Error;

package/dist/worker/protocol.js

@@ -0,0 +1,23 @@
+export function serializeWorkerError(error) {
+    if (!(error instanceof Error)) {
+        return { name: "Error", message: String(error) };
+    }
+    const lixError = error;
+    return {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+        code: typeof lixError.code === "string" ? lixError.code : undefined,
+        hint: typeof lixError.hint === "string" ? lixError.hint : undefined,
+        details: lixError.details,
+    };
+}
+export function deserializeWorkerError(error) {
+    const restored = new Error(error.message);
+    restored.name = error.name;
+    restored.stack = error.stack;
+    restored.code = error.code;
+    restored.hint = error.hint;
+    restored.details = error.details;
+    return restored;
+}

package/package.json

@@ -1,9 +1,8 @@
 {
 	"name": "@lix-js/sdk",
 	"type": "module",
-	"version": "0.6.2",
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
+	"version": "0.8.0",
+	"license": "MIT",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/opral/lix"
@@ -14,26 +13,56 @@
 			"default": "./dist/index.js"
 		}
 	},
+	"imports": {
+		"#binding": {
+			"node": "./dist/binding.node.js",
+			"default": "./dist/binding.browser.js"
+		},
+		"#jco-transpile": {
+			"node": "@bytecodealliance/jco-transpile",
+			"default": "./dist/jco-transpile.browser.js"
+		},
+		"#worker-factory": {
+			"node": "./dist/worker/factory.node.js",
+			"default": "./dist/worker/factory.browser.js"
+		}
+	},
 	"files": [
 		"dist"
 	],
 	"scripts": {
-		"build": "npm run build:native && npm run build:ts",
+		"build": "npm run clean && npm run build:native && npm run build:wasm && npm run build:ts && npm run build:jco-browser && npm run build:plugins",
+		"build:browser": "npm run clean && npm run build:wasm && npm run build:ts && npm run build:jco-browser && npm run build:plugins",
+		"build:jco-browser": "node ./scripts/build-jco-browser.js",
 		"build:native": "node ./scripts/build-native.js",
+		"build:wasm": "node ./scripts/build-wasm.js",
+		"build:wasm:dev": "LIX_WASM_PROFILE=dev node ./scripts/build-wasm.js",
+		"build:plugins": "node ./scripts/build-bundled-plugins.js",
+		"clean": "node ./scripts/clean.js",
 		"prepare:native-package": "node ./scripts/prepare-native-package.js",
 		"build:ts": "tsc -p tsconfig.json",
 		"test": "npm run build && vitest run",
+		"test:browser": "npm run build:browser && vitest run --config vitest.browser.config.ts",
+		"test:browser:built": "vitest run --config vitest.browser.config.ts",
+		"test:browser:production": "node ./scripts/test-packed-vite.js",
 		"typecheck": "tsc -p tsconfig.test.json --noEmit"
 	},
 	"optionalDependencies": {
-		"@lix-js/sdk-darwin-arm64": "0.6.2",
-		"@lix-js/sdk-linux-arm64": "0.6.2",
-		"@lix-js/sdk-linux-x64": "0.6.2",
-		"@lix-js/sdk-win32-x64": "0.6.2"
+		"@lix-js/sdk-darwin-arm64": "0.8.0",
+		"@lix-js/sdk-linux-arm64": "0.8.0",
+		"@lix-js/sdk-linux-x64": "0.8.0",
+		"@lix-js/sdk-win32-x64": "0.8.0"
 	},
 	"devDependencies": {
+		"@vitest/browser-playwright": "4.0.18",
 		"@types/node": "^24.10.2",
+		"playwright": "1.57.0",
 		"typescript": "^5.5.4",
 		"vitest": "^4.0.18"
+	},
+	"dependencies": {
+		"@bytecodealliance/jco-transpile": "0.4.2",
+		"@bytecodealliance/preview2-shim": "0.19.0",
+		"fflate": "^0.8.3"
 	}
 }

package/dist/native.d.ts

@@ -1 +0,0 @@
-export declare const addon: Record<string, any>;