@lix-js/sdk 0.9.0 → 0.11.0

package/dist/worker/client.js

@@ -1,4 +1,4 @@
-import { createWorkerConnection } from "#worker-factory";
+import { createWorkerConnection, openDirectLixBinding } from "#worker-factory";
 import { snapshotPersistenceAfterCommitError } from "../snapshot-persistence.js";
 import { deserializeWorkerError, } from "./protocol.js";
 const MAX_IDLE_WORKERS = 1;
@@ -26,6 +26,41 @@ export async function openLixWorker(storage, onDisposed, telemetry) {
 }
 /** Opens the local worker transport behind the semantic Lix binding. */
 export async function openLixWorkerBinding(storage, onDisposed, telemetry) {
+    if (openDirectLixBinding) {
+        const telemetryDispatch = telemetry
+            ? (span) => {
+                try {
+                    telemetry.onSpan(span);
+                }
+                catch {
+                    // Telemetry is observational and must not fail engine commands.
+                }
+            }
+            : undefined;
+        const binding = await openDirectLixBinding(storage, telemetryDispatch);
+        if (!onDisposed)
+            return binding;
+        let disposed = false;
+        return new Proxy(binding, {
+            get(target, property, receiver) {
+                if (property === "close") {
+                    return async () => {
+                        try {
+                            await target.close();
+                        }
+                        finally {
+                            if (!disposed) {
+                                disposed = true;
+                                onDisposed();
+                            }
+                        }
+                    };
+                }
+                const value = Reflect.get(target, property, receiver);
+                return typeof value === "function" ? value.bind(target) : value;
+            },
+        });
+    }
     const client = await openLixWorker(storage, onDisposed, telemetry);
     return workerBinding(client);
 }
@@ -95,12 +130,15 @@ function workerBinding(client) {
             return workerTransactionBinding(request, transactionId);
         },
         activeBranchId: () => request({ kind: "activeBranchId" }),
+        activeAccountId: () => request({ kind: "activeAccountId" }),
         clientStateEntries: () => request({ kind: "clientState.entries" }),
         clientStateGet: (key) => request({ kind: "clientState.get", key }),
         clientStateSet: (key, value) => request({ kind: "clientState.set", key, value }),
         clientStateDelete: (key) => request({ kind: "clientState.delete", key }),
         createBranch: (options) => request({ kind: "createBranch", options }),
         createCheckpoint: () => request({ kind: "createCheckpoint" }),
+        undo: () => request({ kind: "undo" }),
+        redo: () => request({ kind: "redo" }),
         switchBranch: (options) => request({ kind: "switchBranch", options }),
         importFilesystemPaths: (paths) => request({ kind: "importFilesystemPaths", paths }),
         mergeBranchPreview: (options) => request({ kind: "mergeBranchPreview", options }),
@@ -158,6 +196,7 @@ function persistentSnapshotBinding(binding, storage, namespace) {
             };
         },
         activeBranchId: () => binding.activeBranchId(),
+        activeAccountId: () => binding.activeAccountId(),
         clientStateEntries: () => {
             const method = binding.clientStateEntries;
             if (!method)
@@ -184,6 +223,8 @@ function persistentSnapshotBinding(binding, storage, namespace) {
         },
         createBranch: (branchOptions) => afterMutation(binding.createBranch(branchOptions)),
         createCheckpoint: () => afterMutation(binding.createCheckpoint()),
+        undo: () => afterMutation(binding.undo()),
+        redo: () => afterMutation(binding.redo()),
         switchBranch: (branchOptions) => afterMutation(binding.switchBranch(branchOptions)),
         importFilesystemPaths: (paths) => afterMutation(binding.importFilesystemPaths(paths)),
         mergeBranchPreview: (branchOptions) => binding.mergeBranchPreview(branchOptions),

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

@@ -1,2 +1,4 @@
+import type { LixBinding, LixStorageConfig, TelemetryDispatch } from "../binding-types.js";
 import type { WorkerConnection } from "./protocol.js";
+export declare const openDirectLixBinding: undefined | ((storage: LixStorageConfig, telemetry?: TelemetryDispatch) => Promise<LixBinding>);
 export declare function createWorkerConnection(): WorkerConnection;

package/dist/worker/factory.browser.js

@@ -1,4 +1,6 @@
 /// <reference lib="webworker" />
+// Browser/Wasm execution stays off the main thread.
+export const openDirectLixBinding = undefined;
 export function createWorkerConnection() {
     const worker = new Worker(new URL("./entry.browser.js", import.meta.url), {
         type: "module",

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

@@ -1,2 +1,4 @@
+import type { LixBinding, LixStorageConfig, TelemetryDispatch } from "../binding-types.js";
 import type { WorkerConnection } from "./protocol.js";
 export declare function createWorkerConnection(): WorkerConnection;
+export declare const openDirectLixBinding: (storage: LixStorageConfig, telemetry?: TelemetryDispatch) => Promise<LixBinding>;

package/dist/worker/factory.node.js

@@ -1,4 +1,5 @@
 import { Worker } from "node:worker_threads";
+import { openLixBinding } from "../binding.node.js";
 export function createWorkerConnection() {
     const worker = new Worker(new URL("./entry.node.js", import.meta.url), {
         name: "lix",
@@ -33,3 +34,7 @@ export function createWorkerConnection() {
         },
     };
 }
+/// Native Lix already owns a dedicated serialized engine actor. Routing it
+/// through a second JavaScript worker adds two message-port hops per query
+/// without adding isolation or concurrency.
+export const openDirectLixBinding = (storage, telemetry) => openLixBinding(storage, telemetry);

package/dist/worker/host.js

@@ -87,6 +87,8 @@ export function startWorkerHost(endpoint) {
             }
             case "activeBranchId":
                 return requiredLix().activeBranchId();
+            case "activeAccountId":
+                return requiredLix().activeAccountId();
             case "clientState.entries":
                 return requiredClientStateMethod("clientStateEntries")();
             case "clientState.get":
@@ -99,6 +101,10 @@ export function startWorkerHost(endpoint) {
                 return requiredLix().createBranch(operation.options);
             case "createCheckpoint":
                 return requiredLix().createCheckpoint();
+            case "undo":
+                return requiredLix().undo();
+            case "redo":
+                return requiredLix().redo();
             case "switchBranch":
                 return requiredLix().switchBranch(operation.options);
             case "mergeBranchPreview":

package/dist/worker/protocol.d.ts

@@ -33,6 +33,8 @@ export type WorkerOperation = {
     transactionId: number;
 } | {
     kind: "activeBranchId";
+} | {
+    kind: "activeAccountId";
 } | {
     kind: "clientState.entries";
 } | {
@@ -50,6 +52,10 @@ export type WorkerOperation = {
     options: CreateBranchOptions;
 } | {
     kind: "createCheckpoint";
+} | {
+    kind: "undo";
+} | {
+    kind: "redo";
 } | {
     kind: "switchBranch";
     options: SwitchBranchOptions;

package/package.json

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