@lix-js/sdk 0.15.1 → 0.16.1

package/README.md

@@ -22,10 +22,51 @@ console.log(result.rows[0]?.message);
 await lix.close();
 ```
 
+## Hosted lifecycle
+
+`openLix()` selects execution from the supplied locations:
+
+| Options | Behavior |
+| --- | --- |
+| Neither | Fresh in-memory repository |
+| `storage` | Local repository, initialized if empty |
+| `server` | Execute against an existing hosted repository |
+| `storage` and `server` | Local reads and writes with background synchronization |
+
+Creation and deletion are explicit server operations:
+
+```ts
+import { createLix, deleteLix, openLix } from "@lix-js/sdk";
+
+const repository = await createLix({
+  server: { url: "https://example.com", headers: getAuthHeaders },
+  from: localLix, // Omit to create an empty repository.
+});
+
+const remote = await openLix({
+  server: { url: repository.url, headers: getAuthHeaders },
+});
+await remote.close();
+await deleteLix({ server: { url: repository.url, headers: getAuthHeaders } });
+```
+
+`from` captures a consistent repository snapshot, including history and untracked
+rows. The source remains open. Creation returns `{ id, url }`, not a session.
+Use the same optional `idempotencyKey` when retrying creation after an uncertain
+response. Deletion removes the hosted repository and leaves local copies intact. Opening
+or synchronizing never implicitly creates a missing hosted repository.
+
+Browser creation from a local repository requires Fetch request streaming.
+Browsers without that support return `LIX_UNSUPPORTED_OPERATION`; Lix does not
+buffer the complete repository as a fallback. Browser Fetch may also require an
+HTTP/2 or HTTP/3 connection for streaming uploads. Empty creation and remote
+execution do not require streaming uploads.
+
 ## Synchronized local repositories
 
-Use sync mode when reads and writes should execute locally while Lix exchanges
-commits with a hosted repository in the background:
+Combine storage with a server to keep a synchronized local replica. Reads and
+writes execute locally; background synchronization exchanges changes with the
+server:
 
 ```ts
 import { openLix } from "@lix-js/sdk";
@@ -34,7 +75,6 @@ import { OpfsStorage } from "@lix-js/storage-opfs";
 const lix = await openLix({
   storage: new OpfsStorage({ name: "acme" }),
   server: {
-    mode: "sync",
     url: "https://example.com/lix/01936f4e-7b6c-7c3d-8f9a-123456789abc",
     headers: async () => ({
       Authorization: `Bearer ${await accessToken()}`,
@@ -43,11 +83,59 @@ const lix = await openLix({
 });
 ```
 
-`await lix.execute(...)` means that the local transaction committed. It does
-not mean that the server has received the commit. Current data and new commits
-synchronize automatically; older history and binary content load when needed.
+A successful mutation confirms a local commit; it does not confirm server
+acceptance. Pending commits upload in the background. Cached reads and local
+writes work offline; older history and binary content load when needed.
 See [Collaboration and Sync](https://lix.dev/docs/collaboration-and-sync).
 
+### Upgrading a local replica
+
+Keep the same storage name across SDK upgrades. For a supported older synchronized
+replica, Lix preserves its existing storage generation and bootstraps a separate
+generation from the same authoritative repository and account. The replacement
+becomes active only after bootstrap and validation succeed. Pending work and
+local-only rows remain in the preserved generation; they do not block opening the
+current server state. An upgrade requires a server connection and enough local
+storage for both generations.
+
+Recovery is explicit and separate from opening:
+
+```ts
+const sources = await lix.replicaRecoverySources();
+for (const source of sources.filter((source) => source.recoveryRequired)) {
+  const exported = await lix.exportReplicaRecovery(source.id);
+  // Save exported as JSON when the user requests a portable recovery copy.
+  console.log(exported.unresolved);
+
+  const receipt = await lix.recoverReplica(source.id);
+  // Present these separate branches for review; the active branch is unchanged.
+  console.log(receipt.branchIds, receipt.restoredRows, receipt.unresolved);
+}
+```
+
+`exportReplicaRecovery()` captures available logical rows, blob contents, and
+original branch/checkpoint coordinates. `recoverReplica()` restores supported
+tracked rows into separate recovery branches. It does not automatically publish
+local-only rows or merge recovered work into the active branch. Inspect
+`unresolved`: original history and any unavailable content remain in the retained
+source. A recovery receipt describes local restoration, not a server durability
+acknowledgement. Neither operation deletes the retained generation, and retries
+reuse recovery branch receipts rather than overwriting previously recovered work.
+
+Recovery export currently allows up to 100,000 logical rows across all branches,
+64 MiB per blob, and 128 MiB of blob content in total. Unfinished upload parts
+have a separate 128 MiB content budget. A row-limit or upload-limit error leaves
+the source intact; omitted blob content is identified in `unresolved`. Exported
+JSON can be larger than these content budgets because binary data uses base64.
+This recovery file is not a complete repository backup.
+
+These methods require a local storage-backed handle; remote-only handles reject
+with `LIX_ERROR_LOCAL_STORAGE_REQUIRED`. Do not clear browser storage to resolve
+upgrade or recovery errors. Browser storage eviction or an unsupported old format
+can still require external recovery; retaining bytes alone is not proof that all
+work has been recovered. Standalone and authoritative repositories continue to
+use history-preserving format migrations.
+
 ## Remote repositories
 
 Use the same Lix client as a thin client against a hosted repository:
@@ -55,7 +143,6 @@ Use the same Lix client as a thin client against a hosted repository:
 ```ts
 const lix = await openLix({
   server: {
-    mode: "remote",
     url: "https://example.com/lix/01936f4e-7b6c-7c3d-8f9a-123456789abc",
     headers: async () => ({
       Authorization: `Bearer ${await accessToken()}`,
@@ -161,6 +248,11 @@ const merge = await lix.mergeBranch({ sourceBranchId: draft.id });
 
 ## Transactions
 
+`beginTransaction()` captures the current branch and account in an independent
+transaction context. Use `tx.execute()` for transaction work; its reads see staged
+writes. Ordinary reads and observers on `lix` continue to see committed data while
+the transaction is open. Commit or roll back before closing `lix`.
+
 ```ts
 const tx = await lix.beginTransaction();
 

package/dist/binding-types.d.ts

@@ -1,4 +1,4 @@
-import type { CreateBranchOptions, CreateBranchReceipt, UndoReceipt, RedoReceipt, ExecuteOptions, LixBatchOptions, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, SwitchBranchOptions, SwitchBranchReceipt, LixTelemetrySpan, LixTelemetryParentContext, LixOpenProgress, LixOpenReport, OpenAnotherSessionOptions, ResultColumn } from "./types.js";
+import type { CommitSpan, CreateBranchOptions, CreateBranchReceipt, UndoReceipt, RedoReceipt, ExecuteOptions, LixBatchOptions, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, SwitchBranchOptions, SwitchBranchReceipt, LixTelemetrySpan, LixTelemetryParentContext, LixOpenProgress, LixOpenReport, ReplicaRecoverySource, ReplicaRecoveryExport, ReplicaRecoveryReceipt, OpenAnotherSessionOptions, ResultColumn } from "./types.js";
 import type { NativeLixValue } from "./value.js";
 import type { LixStorageProvider } from "./storage-adapter.js";
 export type SyncServerBindingOptions = {
@@ -18,6 +18,7 @@ export type BindingExecuteResult = {
         message: string;
         hint?: string;
     }>;
+    commit?: CommitSpan;
 };
 export type BindingObserveEvent = {
     sequence: number;
@@ -41,6 +42,7 @@ export type BindingBatchStatement = {
     label?: string;
 };
 export type LixBinding = {
+    createHosted?(server: HostedServerBindingOptions): Promise<import("./types.js").HostedLix>;
     openReport?(): LixOpenReport | undefined;
     setTelemetryParent(parent?: TelemetryParentContext): void;
     openAnotherSession(options: OpenAnotherSessionOptions): Promise<LixBinding>;
@@ -48,6 +50,9 @@ export type LixBinding = {
     executeBatch(statements: BindingBatchStatement[], options?: LixBatchOptions): Promise<BindingExecuteResult[]>;
     observe(sql: string, params: BindingParam[]): Promise<ObserveEventsBinding>;
     beginTransaction(): Promise<LixTransactionBinding>;
+    replicaRecoverySources(): Promise<ReplicaRecoverySource[]>;
+    exportReplicaRecovery(id: string): Promise<ReplicaRecoveryExport>;
+    recoverReplica(id: string): Promise<ReplicaRecoveryReceipt>;
     activeBranchId(): Promise<string>;
     activeAccountId(): Promise<string>;
     createBranch(options: CreateBranchOptions): Promise<CreateBranchReceipt>;
@@ -88,3 +93,8 @@ export type LixStorageConfig = {
     path: string;
     syncAllFiles: boolean;
 };
+export type HostedServerBindingOptions = {
+    idempotencyKey?: string;
+    url: string;
+    headers: [string, string][];
+};

package/dist/binding.browser.d.ts

@@ -1,2 +1,4 @@
 import type { LixStorageConfig, LixBinding, SyncServerBindingOptions, TelemetryDispatch, TelemetryParentContext, OpenProgressDispatch } from "./binding-types.js";
 export declare function openLixBinding(storage: LixStorageConfig, telemetry?: TelemetryDispatch, telemetryParent?: TelemetryParentContext, server?: SyncServerBindingOptions, openProgress?: OpenProgressDispatch, snapshot?: ReadableStream<Uint8Array>): Promise<LixBinding>;
+export declare function createHostedBinding(server: import("./binding-types.js").HostedServerBindingOptions): Promise<import("./types.js").HostedLix>;
+export declare function deleteHostedBinding(server: import("./binding-types.js").HostedServerBindingOptions): Promise<void>;

package/dist/binding.browser.js

@@ -2,7 +2,9 @@ import { initializeWasm } from "./wasm-init.js";
 import { restoreSnapshot } from "./snapshot-restore.js";
 // Generated before TypeScript compilation and emitted beside this module.
 // @ts-ignore Generated by build:wasm and absent in source-only checks.
-import { openJsStorage, openJsStorageFromSnapshot, openMemory, openMemoryFromSnapshot, } from "./wasm/lix_js_sdk.js";
+import { createHosted, deleteHosted, openJsStorage, openJsStorageFromSnapshot, openMemory, openMemoryFromSnapshot,
+// @ts-ignore Generated by build:wasm and absent in source-only checks.
+ } from "./wasm/lix_js_sdk.js";
 export async function openLixBinding(storage, telemetry, telemetryParent, server, openProgress, snapshot) {
     await initializeWasm();
     switch (storage.kind) {
@@ -32,3 +34,11 @@ export async function openLixBinding(storage, telemetry, telemetryParent, server
             throw new Error("FilesystemStorage is only available in Node.js");
     }
 }
+export async function createHostedBinding(server) {
+    await initializeWasm();
+    return createHosted(server);
+}
+export async function deleteHostedBinding(server) {
+    await initializeWasm();
+    await deleteHosted(server);
+}

package/dist/binding.node.d.ts

@@ -1,3 +1,5 @@
 import type { LixStorageConfig, LixBinding, SyncServerBindingOptions, TelemetryDispatch, TelemetryParentContext, OpenProgressDispatch } from "./binding-types.js";
 export declare function openLixBinding(storage: LixStorageConfig, telemetry?: TelemetryDispatch, telemetryParent?: TelemetryParentContext, server?: SyncServerBindingOptions, openProgress?: OpenProgressDispatch, snapshot?: ReadableStream<Uint8Array>): Promise<LixBinding>;
 export declare function openNativeLixBinding(storage: LixStorageConfig, telemetry?: TelemetryDispatch, telemetryParent?: TelemetryParentContext, server?: SyncServerBindingOptions, openProgress?: OpenProgressDispatch, snapshot?: ReadableStream<Uint8Array>): Promise<LixBinding>;
+export declare function createHostedBinding(server: import("./binding-types.js").HostedServerBindingOptions): Promise<import("./types.js").HostedLix>;
+export declare function deleteHostedBinding(server: import("./binding-types.js").HostedServerBindingOptions): Promise<void>;

package/dist/binding.node.js

@@ -62,7 +62,7 @@ class NativeAddonUnavailableError extends Error {
         this.name = "NativeAddonUnavailableError";
     }
 }
-function loadNativeAddon() {
+function loadAddon() {
     if (addon)
         return addon;
     if (addonLoadError)
@@ -114,7 +114,7 @@ export async function openNativeLixBinding(storage, telemetry, telemetryParent,
         : undefined;
     switch (storage.kind) {
         case "memory": {
-            const nativeAddon = loadNativeAddon();
+            const nativeAddon = loadAddon();
             const nativeTelemetry = telemetry
                 ? (spanJson) => telemetry(JSON.parse(spanJson))
                 : undefined;
@@ -130,7 +130,7 @@ export async function openNativeLixBinding(storage, telemetry, telemetryParent,
         case "jsStorage":
             throw new Error("JavaScript storage providers are only available in browsers");
         case "filesystem": {
-            const nativeAddon = loadNativeAddon();
+            const nativeAddon = loadAddon();
             const nativeTelemetry = telemetry
                 ? (spanJson) => telemetry(JSON.parse(spanJson))
                 : undefined;
@@ -145,3 +145,9 @@ export async function openNativeLixBinding(storage, telemetry, telemetryParent,
         }
     }
 }
+export async function createHostedBinding(server) {
+    return loadAddon().createHosted(server.url, server.headers, server.idempotencyKey);
+}
+export async function deleteHostedBinding(server) {
+    await loadAddon().deleteHosted(server.url, server.headers);
+}

package/dist/hosted-lix.d.ts

@@ -0,0 +1,5 @@
+import type { CreateLixOptions, DeleteLixOptions, HostedLix } from "./types.js";
+/** Creates a hosted repository, optionally from a consistent snapshot of a local Lix. */
+export declare function createLix(options: CreateLixOptions): Promise<HostedLix>;
+/** Deletes the hosted repository. Local replicas are not deleted. */
+export declare function deleteLix(options: DeleteLixOptions): Promise<void>;

package/dist/hosted-lix.js

@@ -0,0 +1,36 @@
+import { createHostedFromLix } from "./lix.js";
+import { hostedLixWorkerOperation } from "./worker/client.js";
+async function resolveServer(server) {
+    if (!server || typeof server !== "object")
+        throw new TypeError("A server is required");
+    if ("fetch" in server && server.fetch !== undefined)
+        throw new TypeError("hosted lifecycle does not accept a custom fetch");
+    if ("mode" in server)
+        throw new TypeError("server.mode was removed");
+    const url = new URL(server.url).toString();
+    const headers = new Headers(typeof server.headers === "function"
+        ? await server.headers()
+        : server.headers);
+    const entries = [];
+    headers.forEach((value, key) => entries.push([key, value]));
+    return { url, headers: entries };
+}
+/** Creates a hosted repository, optionally from a consistent snapshot of a local Lix. */
+export async function createLix(options) {
+    if (options.from !== undefined) {
+        return createHostedFromLix(options.from, async () => ({
+            ...(await resolveServer(options.server)),
+            idempotencyKey: options.idempotencyKey,
+        }));
+    }
+    const server = await resolveServer(options.server);
+    return hostedLixWorkerOperation({
+        kind: "hosted.create",
+        server: { ...server, idempotencyKey: options.idempotencyKey },
+    });
+}
+/** Deletes the hosted repository. Local replicas are not deleted. */
+export async function deleteLix(options) {
+    const server = await resolveServer(options.server);
+    await hostedLixWorkerOperation({ kind: "hosted.delete", server });
+}

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export type { LixStorage, LixStorageBound, LixStorageChangeWatch, LixStorageComm
 export { LixStorageError } from "./storage-adapter.js";
 export { bundledPluginArchives, type BundledPluginArchive, } from "./bundled-plugins.js";
 export { Value } from "./value.js";
-export type { CreateBranchOptions, CreateBranchReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, ExecuteBatchResult, LixBatchOptions, LixBatchStatement, JsonValue, LixValue, ResultArrayRow, ResultColumn, ResultColumnType, ResultObjectRow, ResultRow, MergeBranchOptions, MergeBranchOutcome, MergeBranchPreview, MergeBranchReceipt, MergeChangeStats, MergeConflict, MergeConflictSide, ObserveEvent, OpenLixOptions, OpenAnotherSessionOptions, LixTelemetryOptions, LixTelemetryParentContext, LixTelemetrySpan, LixTelemetrySpanLink, LixOpenMigrationReport, LixOpenPhase, LixOpenProgress, LixOpenProgressOptions, LixOpenReport, RemoteLixFetch, RemoteLixServerOptions, SyncLixServerOptions, UndoReceipt, SqlParam, SwitchBranchOptions, SwitchBranchReceipt, } from "./types.js";
+export type { CreateBranchOptions, CreateBranchReceipt, RedoReceipt, CommitSpan, ExecuteOptions, ExecuteResult, ExecuteBatchResult, LixBatchOptions, LixBatchStatement, JsonValue, LixValue, ResultArrayRow, ResultColumn, ResultColumnType, ResultObjectRow, ResultRow, MergeBranchOptions, MergeBranchOutcome, MergeBranchPreview, MergeBranchReceipt, MergeChangeStats, MergeConflict, MergeConflictSide, ObserveEvent, OpenLixOptions, OpenAnotherSessionOptions, LixTelemetryOptions, LixTelemetryParentContext, LixTelemetrySpan, LixTelemetrySpanLink, LixOpenMigrationReport, LixOpenPhase, LixOpenProgress, LixOpenProgressOptions, LixOpenReport, ReplicaRecoverySource, ReplicaRecoveryRow, ReplicaRecoveryBranch, ReplicaRecoveryBlob, ReplicaRecoveryFile, ReplicaRecoveryExport, ReplicaRecoveryReceipt, RemoteLixFetch, LixServerOptions, HostedLix, CreateLixOptions, DeleteLixOptions, UndoReceipt, SqlParam, SwitchBranchOptions, SwitchBranchReceipt, } from "./types.js";
+export { createLix, deleteLix } from "./hosted-lix.js";

package/dist/index.js

@@ -2,3 +2,4 @@ export { Lix, LixTransaction, ObserveEvents, openLix } from "./open-lix.js";
 export { LixStorageError } from "./storage-adapter.js";
 export { bundledPluginArchives, } from "./bundled-plugins.js";
 export { Value } from "./value.js";
+export { createLix, deleteLix } from "./hosted-lix.js";

package/dist/lix.d.ts

@@ -1,5 +1,7 @@
 import type { LixBinding, LixTransactionBinding, ObserveEventsBinding } from "./binding-types.js";
-import type { CreateBranchOptions, CreateBranchReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, ExecuteBatchResult, LixBatchOptions, LixBatchStatement, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, ObserveEvent, OpenAnotherSessionOptions, LixOpenReport, SqlParam, ResultArrayRow, ResultObjectRow, ResultRow, SwitchBranchOptions, SwitchBranchReceipt, UndoReceipt } from "./types.js";
+import type { CreateBranchOptions, CreateBranchReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, ExecuteBatchResult, LixBatchOptions, LixBatchStatement, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, ObserveEvent, OpenAnotherSessionOptions, LixOpenReport, ReplicaRecoverySource, ReplicaRecoveryExport, ReplicaRecoveryReceipt, SqlParam, ResultArrayRow, ResultObjectRow, ResultRow, SwitchBranchOptions, SwitchBranchReceipt, UndoReceipt } from "./types.js";
+/** @internal Used by createLix without adding another method to Lix. */
+export declare function createHostedFromLix(lix: Lix, server: () => Promise<import("./binding-types.js").HostedServerBindingOptions>): Promise<import("./types.js").HostedLix>;
 export declare class Lix {
     #private;
     private readonly binding;
@@ -24,6 +26,12 @@ export declare class Lix {
     executeBatch(statements: readonly LixBatchStatement[], options?: LixBatchOptions): Promise<readonly ExecuteBatchResult<ResultRow>[]>;
     observe(sql: string, params?: SqlParam[]): ObserveEvents;
     beginTransaction(): Promise<LixTransaction>;
+    /** Lists preserved generations belonging to this local repository. */
+    replicaRecoverySources(): Promise<ReplicaRecoverySource[]>;
+    /** Exports retained work without deleting or changing its source. */
+    exportReplicaRecovery(id: string): Promise<ReplicaRecoveryExport>;
+    /** Restores supported rows onto separate recovery branches; preserves the source. */
+    recoverReplica(id: string): Promise<ReplicaRecoveryReceipt>;
     activeBranchId(): Promise<string>;
     activeAccountId(): Promise<string>;
     /** Subscribes to successful branch switches made through this Lix handle. */
@@ -50,7 +58,6 @@ export declare class ObserveEvents {
 export declare class LixTransaction {
     private readonly binding;
     private readonly onFinish;
-    private finishPromise;
     private finished;
     constructor(binding: LixTransactionBinding, onFinish?: () => void);
     execute(sql: string, params: SqlParam[] | undefined, options: ExecuteOptions & {

package/dist/lix.js

@@ -13,6 +13,14 @@ const observeFinalizer = new FinalizationRegistry(({ observe, onClose }) => {
         events?.close();
     });
 });
+const hostedCreators = new WeakMap();
+/** @internal Used by createLix without adding another method to Lix. */
+export function createHostedFromLix(lix, server) {
+    const create = hostedCreators.get(lix);
+    if (!create)
+        throw new TypeError("createLix() from must be an open local Lix");
+    return create(server);
+}
 export class Lix {
     binding;
     openReport;
@@ -27,6 +35,11 @@ export class Lix {
     #acceptingOperations = true;
     constructor(binding) {
         this.binding = binding;
+        hostedCreators.set(this, (server) => this.#runOperation(async () => {
+            if (!binding.createHosted)
+                throw new TypeError("createLix() from requires a local Lix");
+            return binding.createHosted(await server());
+        }));
         const report = binding.openReport?.();
         this.openReport = report
             ? Object.freeze({
@@ -82,6 +95,18 @@ export class Lix {
             }
         });
     }
+    /** Lists preserved generations belonging to this local repository. */
+    async replicaRecoverySources() {
+        return this.#runOperation(() => this.binding.replicaRecoverySources());
+    }
+    /** Exports retained work without deleting or changing its source. */
+    async exportReplicaRecovery(id) {
+        return this.#runOperation(() => this.binding.exportReplicaRecovery(id));
+    }
+    /** Restores supported rows onto separate recovery branches; preserves the source. */
+    async recoverReplica(id) {
+        return this.#runOperation(() => this.binding.recoverReplica(id));
+    }
     async activeBranchId() {
         return this.#runOperation(() => this.binding.activeBranchId());
     }
@@ -317,7 +342,6 @@ export class ObserveEvents {
 export class LixTransaction {
     binding;
     onFinish;
-    finishPromise;
     finished = false;
     constructor(binding, onFinish = () => undefined) {
         this.binding = binding;
@@ -325,6 +349,8 @@ export class LixTransaction {
         transactionFinalizer.register(this, { transaction: binding, onFinish: this.onFinish }, this);
     }
     async execute(sql, params = [], options) {
+        if (this.finished)
+            throw transactionClosedError();
         assertExecuteArgs("lixTransaction", sql, params, options);
         const { rowMode = "object", ...bindingOptions } = options ?? {};
         return wrapExecuteResult(await this.binding.execute(sql, params.map((param, index) => toNativeValue(normalizeParam(param, index))), bindingOptions), rowMode);
@@ -338,24 +364,21 @@ export class LixTransaction {
     async finish(kind) {
         if (this.finished)
             throw transactionClosedError();
-        if (!this.finishPromise) {
-            this.finishPromise = (async () => {
-                try {
-                    if (kind === "transaction.commit")
-                        await this.binding.commit();
-                    else
-                        await this.binding.rollback();
-                }
-                finally {
-                    // A terminal binding call consumes the underlying transaction even
-                    // when its durable commit or rollback reports an error.
-                    this.finished = true;
-                    transactionFinalizer.unregister(this);
-                    this.onFinish();
-                }
-            })();
+        // The first terminal call owns the handle immediately. In particular,
+        // a concurrent rollback must never report a pending commit's success.
+        this.finished = true;
+        try {
+            if (kind === "transaction.commit")
+                await this.binding.commit();
+            else
+                await this.binding.rollback();
+        }
+        finally {
+            // Keep the parent transaction lease until the binding settles. A
+            // terminal call consumes the handle even when it reports an error.
+            transactionFinalizer.unregister(this);
+            this.onFinish();
         }
-        await this.finishPromise;
     }
 }
 function transactionClosedError() {

package/dist/open-lix.js

@@ -26,37 +26,34 @@ async function openLixInternal(options, snapshot) {
         throw new TypeError("openLix() onProgress must be a function");
     }
     if (options.server !== undefined) {
+        if ("mode" in options.server)
+            throw new TypeError("server.mode was removed; provide storage for synchronization or omit it for remote execution");
         if (snapshot) {
             throw new TypeError("openLix.fromSnapshot() does not accept server mode");
         }
-        if (options.server.mode === "remote") {
+        if (options.storage === undefined) {
+            if (options.telemetry !== undefined || options.onProgress !== undefined)
+                throw new TypeError("remote execution does not accept local telemetry or onProgress");
             const { openRemoteLixBinding } = await import("./remote/client.js");
-            if ("storage" in options && options.storage !== undefined) {
-                throw new TypeError("openLix() remote mode does not accept storage");
-            }
             return new Lix(await openRemoteLixBinding(options.server));
         }
     }
-    const syncServer = options.server?.mode === "sync"
+    const syncServer = options.server !== undefined && options.storage !== undefined
         ? {
             url: new URL(options.server.url).toString(),
             headers: options.server.headers,
             fetch: options.server.fetch,
         }
         : undefined;
-    if (syncServer?.fetch !== undefined && typeof syncServer.fetch !== "function") {
+    if (syncServer?.fetch !== undefined &&
+        typeof syncServer.fetch !== "function") {
         throw new TypeError("openLix() sync server fetch must be a function");
     }
-    if (syncServer?.headers !== undefined && typeof syncServer.headers !== "function") {
+    if (syncServer?.headers !== undefined &&
+        typeof syncServer.headers !== "function") {
         // Validate static headers before opening a worker/native runtime.
         new Headers(syncServer.headers);
     }
-    if (options.server !== undefined && syncServer === undefined) {
-        throw new TypeError("openLix() server mode must be 'remote' or 'sync'");
-    }
-    if (syncServer !== undefined && options.storage === undefined) {
-        throw new TypeError("openLix() sync mode requires a durability-capable storage adapter");
-    }
     const { openLixWorkerBinding } = await import("./worker/client.js");
     if (options.storage === undefined) {
         const binding = await openLixWorkerBinding({ kind: "memory" }, undefined, options.telemetry, syncServer, options.onProgress, snapshot);

package/dist/remote/client.d.ts

@@ -1,7 +1,7 @@
 import type { LixBinding } from "../binding-types.js";
-import type { RemoteLixServerOptions } from "../types.js";
+import type { LixServerOptions } from "../types.js";
 type RemoteLixClientOptions = {
     initialActiveBranchId?: string;
 };
-export declare function openRemoteLixBinding(options: RemoteLixServerOptions, clientOptions?: RemoteLixClientOptions): Promise<LixBinding>;
+export declare function openRemoteLixBinding(options: LixServerOptions, clientOptions?: RemoteLixClientOptions): Promise<LixBinding>;
 export {};

package/dist/remote/client.js

@@ -6,9 +6,6 @@ export async function openRemoteLixBinding(options, clientOptions = {}) {
     if (!options || typeof options !== "object") {
         throw new TypeError("openLix() remote server must be an object");
     }
-    if (options.mode !== "remote") {
-        throw new TypeError("openLix() remote server mode must be 'remote'");
-    }
     const remoteFetch = options.fetch ?? globalThis.fetch?.bind(globalThis);
     if (typeof remoteFetch !== "function") {
         throw new TypeError("openLix() remote mode requires fetch");

package/dist/storage-adapter.d.ts

@@ -98,10 +98,6 @@ export type LixStoragePrecondition = {
     kind: "rangeEmpty";
     space: LixStorageSpace;
     range: LixStorageKeyRange;
-} | {
-    kind: "branchEquals";
-    refKey: Uint8Array;
-    expected: Uint8Array;
 };
 export type LixStorageGetManyRequest = {
     space: LixStorageSpace;