@lix-js/sdk 0.10.0 → 0.12.0

package/dist/lix.js

@@ -1,7 +1,5 @@
 import { invalidArgument } from "./errors.js";
-import { ACTIVE_BRANCH_CLIENT_STATE_KEY, unavailableClientState, } from "./client-state.js";
-import { normalizeOptionals, wrapExecuteResult } from "./result.js";
-import { isSnapshotPersistenceAfterCommitError } from "./snapshot-persistence.js";
+import { normalizeOptionals, wrapExecuteBatchResult, wrapExecuteResult, } from "./result.js";
 import { normalizeParam, toNativeValue } from "./value.js";
 const transactionFinalizer = new FinalizationRegistry(({ transaction, onFinish }) => {
     void transaction
@@ -17,9 +15,7 @@ const observeFinalizer = new FinalizationRegistry(({ observe, onClose }) => {
 });
 export class Lix {
     binding;
-    managedClientState;
     closePromise;
-    clientState;
     #activeBranchListeners = new Set();
     #inFlightOperations = new Set();
     #observations = new Map();
@@ -27,20 +23,8 @@ export class Lix {
     #transactionsOpening = 0;
     #activeTransactions = 0;
     #acceptingOperations = true;
-    constructor(binding, managedClientState) {
+    constructor(binding) {
         this.binding = binding;
-        this.managedClientState = managedClientState;
-        this.clientState = managedClientState
-            ? {
-                get: (key) => managedClientState.get(key),
-                set: (key, value) => this.#runOperation(() => managedClientState.set(key, value)),
-                delete: (key) => this.#runOperation(() => managedClientState.delete(key)),
-                subscribe: (listener) => {
-                    this.#assertAcceptingOperations();
-                    return managedClientState.subscribe(listener);
-                },
-            }
-            : unavailableClientState();
     }
     async execute(sql, params = [], options) {
         assertExecuteArgs("lix", sql, params, options);
@@ -50,7 +34,7 @@ export class Lix {
         const normalizedStatements = normalizeBatchStatements(statements, options);
         return this.#runOperation(async () => {
             const results = await this.binding.executeBatch(normalizedStatements, options);
-            return results.map(wrapExecuteResult);
+            return results.map(wrapExecuteBatchResult);
         });
     }
     observe(sql, params = []) {
@@ -110,16 +94,6 @@ export class Lix {
     async switchBranch(options) {
         return this.#runOperation(async () => {
             const receipt = await this.binding.switchBranch(options);
-            try {
-                if (this.managedClientState) {
-                    await this.managedClientState.set(ACTIVE_BRANCH_CLIENT_STATE_KEY, receipt.branchId);
-                }
-            }
-            catch {
-                // The remote branch switch already committed. Client persistence is a
-                // best-effort reopen preference and cannot turn that success into a
-                // rejected switch with ambiguous branch state.
-            }
             for (const listener of [...this.#activeBranchListeners]) {
                 try {
                     listener();
@@ -155,9 +129,13 @@ export class Lix {
             this.#observations.clear();
             this.closePromise = (async () => {
                 await Promise.allSettled([...this.#inFlightOperations]);
-                await this.binding.close();
-                await this.managedClientState?.close();
+                const results = await Promise.allSettled([
+                    Promise.resolve().then(() => this.binding.close()),
+                ]);
                 this.#activeBranchListeners.clear();
+                const failure = results.find((result) => result.status === "rejected");
+                if (failure)
+                    throw failure.reason;
             })();
         }
         await this.closePromise;
@@ -256,31 +234,22 @@ export class LixTransaction {
             throw transactionClosedError();
         if (!this.finishPromise) {
             this.finishPromise = (async () => {
-                if (kind === "transaction.commit")
-                    await this.binding.commit();
-                else
-                    await this.binding.rollback();
-                this.finished = true;
-                transactionFinalizer.unregister(this);
-                this.onFinish();
+                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();
+                }
             })();
         }
-        try {
-            await this.finishPromise;
-        }
-        catch (error) {
-            if (isSnapshotPersistenceAfterCommitError(error)) {
-                // The transaction finished in Rust; only durable snapshot saving
-                // failed. Release the transaction lifecycle while reporting that
-                // durability failure to the caller.
-                this.finished = true;
-                transactionFinalizer.unregister(this);
-                this.onFinish();
-                throw error;
-            }
-            this.finishPromise = undefined;
-            throw error;
-        }
+        await this.finishPromise;
     }
 }
 function transactionClosedError() {
@@ -336,9 +305,14 @@ function normalizeBatchStatements(statements, options) {
             if (!Array.isArray(params)) {
                 throw invalidArgument("executeBatch", `statements[${statementIndex}].params`, "array", typeof params);
             }
+            if (statement.label !== undefined &&
+                typeof statement.label !== "string") {
+                throw invalidArgument("executeBatch", `statements[${statementIndex}].label`, "string", typeof statement.label);
+            }
             return {
                 sql: statement.sql,
                 params: params.map((param, parameterIndex) => toNativeValue(normalizeParam(param, parameterIndex))),
+                ...(statement.label === undefined ? {} : { label: statement.label }),
             };
         }
         catch (error) {

package/dist/open-lix.d.ts

@@ -1,17 +1,8 @@
 import { Lix } from "./lix.js";
-import type { LocalFilesystemOptions, OpenLixOptions, SQLiteOptions } from "./types.js";
+import type { IndexedDbStorageOptions, OpenLixOptions } from "./types.js";
 export { Lix, LixTransaction, ObserveEvents } from "./lix.js";
-export declare class SQLite {
-    readonly path: string;
-    constructor(options: SQLiteOptions);
-}
-export declare class LocalFilesystem {
-    readonly path: string;
-    readonly lixDir: string | undefined;
-    readonly syncAllFiles: boolean;
-    constructor(options: LocalFilesystemOptions);
-    importPaths(paths: readonly string[]): Promise<void>;
-    syncDiskToLix(): Promise<void>;
-    private client;
+export declare class IndexedDbStorage {
+    readonly name: string;
+    constructor(options: IndexedDbStorageOptions);
 }
 export declare function openLix(options?: OpenLixOptions): Promise<Lix>;

package/dist/open-lix.js

@@ -1,63 +1,15 @@
-import { localFilesystemAlreadyOpen, localFilesystemNotOpen, } from "./errors.js";
-import { ACTIVE_ACCOUNT_CLIENT_STATE_KEY, ACTIVE_BRANCH_CLIENT_STATE_KEY, openClientState, openStoredClientState, } from "./client-state.js";
 import { Lix } from "./lix.js";
+import { isLixStorage } from "./storage-adapter.js";
 export { Lix, LixTransaction, ObserveEvents } from "./lix.js";
-export class SQLite {
-    path;
+const openStorages = new WeakSet();
+const openIndexedDbStorageNames = new Set();
+export class IndexedDbStorage {
+    name;
     constructor(options) {
-        if (!options ||
-            typeof options.path !== "string" ||
-            options.path.length === 0) {
-            throw new TypeError("SQLite requires a non-empty path");
+        if (!options || typeof options.name !== "string" || options.name.length === 0) {
+            throw new TypeError("IndexedDbStorage requires a non-empty name");
         }
-        this.path = options.path;
-    }
-}
-const openLocalFilesystems = new WeakMap();
-export class LocalFilesystem {
-    path;
-    lixDir;
-    syncAllFiles;
-    constructor(options) {
-        if (!options ||
-            typeof options.path !== "string" ||
-            options.path.length === 0) {
-            throw new TypeError("LocalFilesystem requires a non-empty path");
-        }
-        if (options.lixDir !== undefined &&
-            (typeof options.lixDir !== "string" || options.lixDir.length === 0)) {
-            throw new TypeError("LocalFilesystem lixDir must be a non-empty string");
-        }
-        if (typeof options.syncAllFiles !== "boolean") {
-            throw new TypeError("LocalFilesystem syncAllFiles must be a boolean");
-        }
-        this.path = options.path;
-        this.lixDir = options.lixDir;
-        this.syncAllFiles = options.syncAllFiles;
-    }
-    async importPaths(paths) {
-        if (!Array.isArray(paths)) {
-            throw new TypeError("importPaths() paths must be an array");
-        }
-        for (const path of paths) {
-            if (typeof path !== "string" || path.length === 0) {
-                throw new TypeError("importPaths() paths must contain non-empty strings");
-            }
-            if (path.endsWith("/")) {
-                throw new TypeError("importPaths() paths must not end with a trailing slash");
-            }
-        }
-        await this.client("importPaths").importFilesystemPaths([...paths]);
-    }
-    async syncDiskToLix() {
-        return this.client("syncDiskToLix").syncDiskToLix();
-    }
-    client(operation) {
-        const client = openLocalFilesystems.get(this);
-        if (!client) {
-            throw localFilesystemNotOpen(operation);
-        }
-        return client;
+        this.name = options.name;
     }
 }
 export async function openLix(options = {}) {
@@ -74,122 +26,63 @@ export async function openLix(options = {}) {
     }
     if (options.server !== undefined) {
         const { openRemoteLixBinding } = await import("./remote/client.js");
-        if (options.storage === undefined) {
-            return new Lix(await openRemoteLixBinding(options.server));
-        }
-        assertSnapshotStorage(options.storage);
-        const clientState = await openStoredClientState({
-            storage: options.storage,
-            namespace: remoteClientStateNamespace(options.server.url),
-        });
-        const restoredBranchId = clientState.get(ACTIVE_BRANCH_CLIENT_STATE_KEY);
-        const restoredAccountId = clientState.get(ACTIVE_ACCOUNT_CLIENT_STATE_KEY);
-        let remoteBinding;
-        try {
-            try {
-                remoteBinding = await openRemoteLixBinding(options.server, {
-                    initialActiveBranchId: restoredBranchId,
-                    initialActiveAccountId: restoredAccountId,
-                });
-            }
-            catch (error) {
-                if (!restoredBranchId || !isBranchNotFoundError(error))
-                    throw error;
-                remoteBinding = await openRemoteLixBinding(options.server, {
-                    initialActiveAccountId: restoredAccountId,
-                });
-            }
-            const activeBranchId = await remoteBinding.activeBranchId();
-            const activeAccountId = await remoteBinding.activeAccountId();
-            if (activeBranchId !== restoredBranchId) {
-                await clientState.set(ACTIVE_BRANCH_CLIENT_STATE_KEY, activeBranchId);
-            }
-            if (activeAccountId !== restoredAccountId) {
-                await clientState.set(ACTIVE_ACCOUNT_CLIENT_STATE_KEY, activeAccountId);
-            }
-            return new Lix(remoteBinding, clientState);
-        }
-        catch (error) {
-            await remoteBinding?.close().catch(() => undefined);
-            await clientState.close().catch(() => undefined);
-            throw error;
+        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 { openLixWorkerBinding } = await import("./worker/client.js");
     if (options.storage === undefined) {
         return new Lix(await openLixWorkerBinding({ kind: "memory" }, undefined, options.telemetry));
     }
-    if (options.storage instanceof SQLite) {
-        return new Lix(await openLixWorkerBinding({
-            kind: "sqlite",
-            path: options.storage.path,
-        }, undefined, options.telemetry));
-    }
-    if (options.storage instanceof LocalFilesystem) {
+    if (isLixStorage(options.storage)) {
         const storage = options.storage;
-        if (openLocalFilesystems.has(storage)) {
-            throw localFilesystemAlreadyOpen();
+        if (openStorages.has(storage)) {
+            throw storageAlreadyOpen();
         }
-        openLocalFilesystems.set(storage, null);
+        openStorages.add(storage);
+        let binding;
+        const disconnect = () => {
+            storage.lixStorage.connect(undefined);
+            openStorages.delete(storage);
+        };
         try {
-            const binding = await openLixWorkerBinding({
-                kind: "localFilesystem",
-                path: storage.path,
-                lixDir: storage.lixDir,
-                syncAllFiles: storage.syncAllFiles,
-            }, () => openLocalFilesystems.delete(storage), options.telemetry);
-            openLocalFilesystems.set(storage, binding);
+            binding = await openLixWorkerBinding(storage.lixStorage.config, disconnect, options.telemetry);
+            storage.lixStorage.connect({
+                importFilesystemPaths: (paths) => binding.importFilesystemPaths(paths),
+                syncDiskToLix: () => binding.syncDiskToLix(),
+            });
             return new Lix(binding);
         }
         catch (error) {
-            openLocalFilesystems.delete(storage);
+            disconnect();
+            await binding?.close().catch(() => undefined);
             throw error;
         }
     }
-    if (isSnapshotStorage(options.storage)) {
-        const { openPersistentLixWorkerBinding } = await import("./worker/client.js");
-        const binding = await openPersistentLixWorkerBinding({
-            storage: options.storage,
-            namespace: "local",
-            telemetry: options.telemetry,
-        });
+    if (options.storage instanceof IndexedDbStorage) {
+        const storage = options.storage;
+        const databaseName = storage.name;
+        if (openIndexedDbStorageNames.has(databaseName)) {
+            throw new Error("IndexedDbStorage is already open");
+        }
+        openIndexedDbStorageNames.add(databaseName);
+        let binding;
         try {
-            const clientState = await openClientState({ binding });
-            return new Lix(binding, clientState);
+            binding = await openLixWorkerBinding({ kind: "indexedDb", name: databaseName }, () => openIndexedDbStorageNames.delete(databaseName), options.telemetry);
+            return new Lix(binding);
         }
         catch (error) {
-            await binding.close().catch(() => undefined);
+            openIndexedDbStorageNames.delete(databaseName);
+            await binding?.close().catch(() => undefined);
             throw error;
         }
     }
-    throw new TypeError("openLix() requires storage to be SQLite, LocalFilesystem, or a Lix snapshot storage adapter");
-}
-function isSnapshotStorage(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        typeof value.load === "function" &&
-        typeof value.save === "function");
-}
-function assertSnapshotStorage(value) {
-    if (!isSnapshotStorage(value)) {
-        throw new TypeError("openLix() remote storage must implement load() and save()");
-    }
-}
-function remoteClientStateNamespace(value) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch {
-        throw new TypeError("openLix() remote server url must be an absolute URL");
-    }
-    url.pathname = url.pathname.replace(/\/$/, "");
-    url.search = "";
-    url.hash = "";
-    return `remote:${url.href}`;
+    throw new TypeError("openLix() requires a Lix storage adapter or IndexedDbStorage");
 }
-function isBranchNotFoundError(error) {
-    return (error instanceof Error &&
-        "code" in error &&
-        error.code === "LIX_BRANCH_NOT_FOUND");
+function storageAlreadyOpen() {
+    const error = new Error("openLix() storage is already open; close the existing Lix or create a new storage adapter");
+    error.name = "LixError";
+    error.code = "LIX_STORAGE_IN_USE";
+    return error;
 }

package/dist/remote/client.d.ts

@@ -1,9 +1,8 @@
 import type { LixBinding } from "../binding-types.js";
 import type { RemoteLixServerOptions } from "../types.js";
-import { type RemoteHandshakeRequest } from "./protocol.js";
+import { type ServerProtocolHandshakeRequest } from "./server-protocol.js";
 type RemoteLixClientOptions = {
-    initialActiveBranchId?: RemoteHandshakeRequest["activeBranchId"];
-    initialActiveAccountId?: RemoteHandshakeRequest["activeAccountId"];
+    initialActiveBranchId?: ServerProtocolHandshakeRequest["activeBranchId"];
 };
 export declare function openRemoteLixBinding(options: RemoteLixServerOptions, clientOptions?: RemoteLixClientOptions): Promise<LixBinding>;
 export {};

package/dist/remote/client.js

@@ -1,4 +1,4 @@
-import { decodeExecuteResult, decodeHandshake, decodeObserveEvent, encodeWireValue, errorFromResponseBody, protocolError, record, REMOTE_PROTOCOL_PATH, remoteError, } from "./protocol.js";
+import { decodeExecuteBatchResult, decodeExecuteResult, decodeHandshake, decodeObserveEvent, encodeWireValue, errorFromResponseBody, protocolError, record, SERVER_PROTOCOL_PATH, remoteError, } from "./server-protocol.js";
 import { readSseEvents } from "./sse.js";
 const OBSERVE_RETRY_BASE_MS = 100;
 const OBSERVE_RETRY_MAX_MS = 5_000;
@@ -32,7 +32,6 @@ class RemoteLixBinding {
     #fetch;
     #headers;
     #initialActiveBranchId;
-    #initialActiveAccountId;
     #observationHub;
     #requestBlobBases = new Map();
     #sessionId;
@@ -66,13 +65,9 @@ class RemoteLixBinding {
             throw new TypeError("initialActiveBranchId must be a non-empty string");
         }
         this.#initialActiveBranchId = clientOptions.initialActiveBranchId;
-        if (clientOptions.initialActiveAccountId !== undefined &&
-            clientOptions.initialActiveAccountId.length === 0) {
-            throw new TypeError("initialActiveAccountId must be a non-empty string");
-        }
-        this.#initialActiveAccountId = clientOptions.initialActiveAccountId;
         this.#observationHub = new RemoteObservationHub({
             openStream: (subscriptions, signal) => this.#requestObserveStream(subscriptions, signal),
+            refreshObservation: (subscription) => this.#refreshObservation(subscription),
         });
     }
     async open() {
@@ -80,9 +75,6 @@ class RemoteLixBinding {
         if (this.#initialActiveBranchId !== undefined) {
             query.set("activeBranchId", this.#initialActiveBranchId);
         }
-        if (this.#initialActiveAccountId !== undefined) {
-            query.set("activeAccountId", this.#initialActiveAccountId);
-        }
         const path = query.size === 0 ? "" : `?${query}`;
         const handshake = decodeHandshake(await this.#requestJson(path, { method: "GET" }));
         this.#sessionId = handshake.sessionId;
@@ -119,10 +111,12 @@ class RemoteLixBinding {
         const snapshot = statements.map((statement) => ({
             sql: statement.sql,
             params: snapshotParams(statement.params),
+            ...(statement.label === undefined ? {} : { label: statement.label }),
         }));
         return this.#enqueue(async () => {
             const preparedStatements = await Promise.all(snapshot.map(async (statement, statementIndex) => ({
                 sql: statement.sql,
+                label: statement.label,
                 prepared: await this.#prepareParams(statement.params, (paramIndex) => requestBlobSlot("batch", statement.sql, paramIndex, statementIndex)),
             })));
             const cacheBlobs = preparedStatements.some((statement) => statement.prepared.cacheBlobs);
@@ -133,6 +127,9 @@ class RemoteLixBinding {
                 body: JSON.stringify({
                     statements: preparedStatements.map((statement) => ({
                         sql: statement.sql,
+                        ...(statement.label === undefined
+                            ? {}
+                            : { label: statement.label }),
                         params: full
                             ? statement.prepared.fullParams()
                             : statement.prepared.params,
@@ -145,7 +142,7 @@ class RemoteLixBinding {
             if (!Array.isArray(value)) {
                 throw protocolError("execute batch response must be an array");
             }
-            const results = value.map(decodeExecuteResult);
+            const results = value.map(decodeExecuteBatchResult);
             this.#commitRequestBlobBases(preparedStatements.flatMap((statement) => statement.prepared.cacheUpdates));
             return results;
         });
@@ -219,7 +216,7 @@ class RemoteLixBinding {
             if (this.#activeBranchId === undefined) {
                 const handshake = decodeHandshake(await this.#requestJson("", { method: "GET" }));
                 if (handshake.sessionId !== this.#sessionId) {
-                    throw protocolError("remote handshake changed sessionId");
+                    throw protocolError("Lix Server Protocol handshake changed sessionId");
                 }
                 this.#activeBranchId = handshake.activeBranchId;
             }
@@ -232,7 +229,7 @@ class RemoteLixBinding {
             if (this.#activeAccountId === undefined) {
                 const handshake = decodeHandshake(await this.#requestJson("", { method: "GET" }));
                 if (handshake.sessionId !== this.#sessionId) {
-                    throw protocolError("remote handshake changed sessionId");
+                    throw protocolError("Lix Server Protocol handshake changed sessionId");
                 }
                 this.#activeAccountId = handshake.activeAccountId;
             }
@@ -442,6 +439,18 @@ class RemoteLixBinding {
             throw remoteError("LIX_REMOTE_UNAVAILABLE", "The remote Lix observation stream is unavailable", { details: { cause: errorMessage(cause) } });
         }
     }
+    async #refreshObservation(subscription) {
+        return this.#enqueue(async () => {
+            const value = await this.#requestJson("execute", {
+                method: "POST",
+                body: JSON.stringify({
+                    sql: subscription.sql,
+                    params: subscription.params,
+                }),
+            });
+            return decodeExecuteResult(value);
+        });
+    }
     async #prepareParams(params, slot) {
         const prepared = await Promise.all(params.map(async (param, index) => {
             if (param.kind !== "blob" ||
@@ -661,6 +670,7 @@ function copyArrayBuffer(bytes) {
 }
 class RemoteObservationHub {
     #openStream;
+    #refreshObservation;
     #observations = new Map();
     #nextObservationId = 0;
     #controller;
@@ -672,6 +682,7 @@ class RemoteObservationHub {
     #closed = false;
     constructor(options) {
         this.#openStream = options.openStream;
+        this.#refreshObservation = options.refreshObservation;
     }
     observe(sql, params) {
         const id = `observe-${++this.#nextObservationId}`;
@@ -743,6 +754,7 @@ class RemoteObservationHub {
             if (!this.#isCurrent(generation, controller))
                 return;
             streamOpened = true;
+            const initialSubscriptions = new Set(this.#observations.keys());
             if (!response.ok) {
                 if (isRetryableObserveStatus(response.status)) {
                     void response.body?.cancel();
@@ -781,7 +793,21 @@ class RemoteObservationHub {
                         const transportDelta = payload.delta !== undefined;
                         const event = decodeObserveEvent(payload, transportBases.get(subscriptionId));
                         transportBases.set(subscriptionId, event);
-                        observation.accept(event, transportDelta);
+                        if (initialSubscriptions.delete(subscriptionId)) {
+                            // The first frame after opening (including a reconnect) is a
+                            // synchronization point, not an authoritative snapshot. The
+                            // remote runtime may have observed the stream before its
+                            // external-storage watcher caught up. Reconcile through the
+                            // normal execute endpoint before publishing it to consumers.
+                            const rows = await this.#refreshObservation(observation.request());
+                            observation.accept({
+                                ...event,
+                                rows,
+                            }, false);
+                        }
+                        else {
+                            observation.accept(event, transportDelta);
+                        }
                         this.#retryAttempt = 0;
                     }
                     catch (error) {
@@ -1057,7 +1083,7 @@ function isRetryableObserveError(error) {
 function asObserveProtocolError(error, event) {
     if (error instanceof Error &&
         "code" in error &&
-        error.code === "LIX_REMOTE_PROTOCOL_ERROR") {
+        error.code === "LIX_SERVER_PROTOCOL_ERROR") {
         return error;
     }
     return protocolError(`remote observe ${event} event contains invalid data: ${errorMessage(error)}`);
@@ -1084,8 +1110,8 @@ function nativeValuesEqual(left, right) {
             return (right.kind === "blob" &&
                 left.blob.length === right.blob.length &&
                 left.blob.every((byte, index) => byte === right.blob[index]));
-        case "json":
-            return right.kind === "json" && jsonValuesEqual(left.value, right.value);
+        case "jsonb":
+            return right.kind === "jsonb" && jsonValuesEqual(left.value, right.value);
         default:
             return left.value === right.value;
     }
@@ -1117,21 +1143,22 @@ function stringArraysEqual(left, right) {
         left.every((value, index) => value === right[index]));
 }
 function protocolBaseUrl(value) {
-    let workspaceUrl;
+    let repositoryUrl;
     try {
-        workspaceUrl = new URL(value);
+        repositoryUrl = new URL(value);
     }
     catch {
         throw new TypeError("openLix() remote server url must be an absolute URL");
     }
-    if (workspaceUrl.protocol !== "http:" && workspaceUrl.protocol !== "https:") {
+    if (repositoryUrl.protocol !== "http:" &&
+        repositoryUrl.protocol !== "https:") {
         throw new TypeError("openLix() remote server url must use http or https");
     }
-    if (workspaceUrl.search || workspaceUrl.hash) {
+    if (repositoryUrl.search || repositoryUrl.hash) {
         throw new TypeError("openLix() remote server url must not contain a query or fragment");
     }
-    workspaceUrl.pathname = `${workspaceUrl.pathname.replace(/\/$/, "")}${REMOTE_PROTOCOL_PATH}`;
-    return workspaceUrl;
+    repositoryUrl.pathname = `${repositoryUrl.pathname.replace(/\/$/, "")}${SERVER_PROTOCOL_PATH}`;
+    return repositoryUrl;
 }
 function unsupportedRemoteOperation(operation) {
     return remoteError("LIX_UNSUPPORTED_REMOTE_OPERATION", `${operation} is not supported in remote mode`, { details: { operation } });