@lix-js/sdk 0.16.0 → 0.17.0

package/dist/worker/entry.shared.browser.js

@@ -0,0 +1,211 @@
+/// <reference lib="webworker" />
+import { openLixBinding, convertReplicaBinding } from "#binding";
+import { fetchTransport, HttpTransportError } from "../http-transport.js";
+import { SharedAdmissionCache, requestAdmission, sharedCredentialKey, sameAdmission, } from "./shared-admission.js";
+import { DurableLocalAdmission } from "./durable-local-admission.js";
+import { startWorkerHost } from "./host.js";
+import { SharedEngineOwner } from "./shared-engine.js";
+import { serializeWorkerError } from "./protocol.js";
+const scope = globalThis;
+let owner;
+let configuration;
+// Same-origin callers own the local store. Durable routing proofs can reopen
+// its cached data after worker shutdown, but never authorize remote requests.
+// Raw credentials remain in memory only.
+const admitted = new SharedAdmissionCache();
+let rootIdentity;
+scope.onconnect = (event) => {
+    const port = event.ports[0];
+    let client;
+    let disconnected = false;
+    let input;
+    const prepareClient = async (...args) => {
+        const [storage, telemetry, parent, server, progress, snapshot] = args;
+        if (!server || snapshot)
+            throw new Error("Shared partial engines require a server and existing storage");
+        const config = JSON.stringify([storage, server.url]);
+        if (configuration !== undefined && config !== configuration)
+            throw new Error("Shared engine configuration mismatch");
+        configuration = config;
+        const raw = server;
+        const readHeaders = async () => raw.headerProvider ? await raw.headerProvider() : raw.headers;
+        let verifiedKey;
+        let verifiedGeneration;
+        let candidateIdentity;
+        let candidateHeaders;
+        let candidateOnline = false;
+        let candidateGeneration = 0;
+        let candidateCredentialGeneration = 0;
+        const providerOptions = storage.kind === "jsStorage" ? storage.options : undefined;
+        const physicalScope = providerOptions && typeof providerOptions === "object" &&
+            "sharedEngineKey" in providerOptions && typeof providerOptions.sharedEngineKey === "string"
+            ? providerOptions.sharedEngineKey : undefined;
+        if (!physicalScope?.startsWith("lix:opfs:"))
+            throw new Error("Missing physical shared storage identity");
+        const localAdmission = new DurableLocalAdmission(physicalScope, raw.url);
+        const transport = raw.transport ?? fetchTransport();
+        const authenticate = async (headers, allowOffline) => {
+            const credentialGeneration = admitted.generation(raw.url, headers);
+            let result;
+            try {
+                result = await admitted.verify(raw.url, headers, rootIdentity, () => requestAdmission(raw.url, headers, transport), allowOffline);
+            }
+            catch (error) {
+                const code = error?.code;
+                if (code === "LIX_ADMISSION_AUTH_REJECTED") {
+                    if (candidateHeaders && sharedCredentialKey(raw.url, candidateHeaders) === sharedCredentialKey(raw.url, headers)) {
+                        candidateOnline = false;
+                        candidateGeneration++;
+                    }
+                    admitted.remove(raw.url, headers);
+                    await localAdmission.remove(headers).catch(() => undefined);
+                }
+                if (!allowOffline || code !== "LIX_IDENTITY_UNVERIFIED_OFFLINE")
+                    throw error;
+                const local = await localAdmission.read(headers).catch(() => undefined);
+                if (!local)
+                    throw error;
+                if (rootIdentity && !sameAdmission(local, rootIdentity)) {
+                    throw new HttpTransportError("LIX_SHARED_ENGINE_IDENTITY_MISMATCH", "Cached local repository/account does not match this owner");
+                }
+                result = { identity: local, online: false };
+            }
+            if (admitted.generation(raw.url, headers) !== credentialGeneration) {
+                throw new HttpTransportError("LIX_ADMISSION_AUTH_REJECTED", "Credentials were rejected while local admission was in flight");
+            }
+            if (result.online) {
+                verifiedKey = sharedCredentialKey(raw.url, headers);
+                verifiedGeneration = credentialGeneration;
+            }
+            candidateCredentialGeneration = credentialGeneration;
+            candidateGeneration++;
+            candidateIdentity = result.identity;
+            candidateHeaders = headers.map(([name, value]) => [name, value]);
+            candidateOnline = result.online;
+            return result;
+        };
+        const routed = {
+            ...raw,
+            transport: async (request) => {
+                try {
+                    const response = await transport(request);
+                    return response;
+                }
+                catch (error) {
+                    verifiedKey = undefined;
+                    throw error;
+                }
+            },
+            headerProvider: async () => {
+                const headers = await readHeaders();
+                if (sharedCredentialKey(raw.url, headers) !== verifiedKey || admitted.generation(raw.url, headers) !== verifiedGeneration) {
+                    // Failure only suspends this remote lease; local sessions survive.
+                    verifiedKey = undefined;
+                    await authenticate(headers, false);
+                }
+                return headers;
+            },
+        };
+        if (!owner) {
+            owner = new SharedEngineOwner(async (transport, backgroundTelemetry, opener) => {
+                return openLixBinding(storage, backgroundTelemetry, opener.parent, transport, opener.progress);
+            });
+        }
+        client = {
+            server: routed,
+            isDisconnected: () => disconnected,
+            telemetry,
+            parent,
+            progress,
+            rejectCredentials: async (headers) => {
+                const rejectedKey = sharedCredentialKey(raw.url, headers);
+                if (verifiedKey === rejectedKey)
+                    verifiedKey = undefined;
+                if (candidateHeaders && sharedCredentialKey(raw.url, candidateHeaders) === rejectedKey) {
+                    candidateOnline = false;
+                    candidateGeneration++;
+                }
+                admitted.remove(raw.url, headers);
+                await localAdmission.remove(headers).catch(() => undefined);
+            },
+            commitIdentity: async () => {
+                if (!candidateIdentity)
+                    throw new Error("Missing verified owner identity");
+                rootIdentity ??= candidateIdentity;
+                if (candidateOnline && candidateHeaders) {
+                    // The owner has checked the actual stored account before this call.
+                    // Failure to cache only disables later offline reopening.
+                    const generation = candidateGeneration;
+                    const headers = candidateHeaders;
+                    const identity = candidateIdentity;
+                    await admitted.persistLocal(raw.url, headers, candidateCredentialGeneration, () => localAdmission.record(headers, identity), () => localAdmission.remove(headers)).catch(() => undefined);
+                    // A rejection during the asynchronous write must not resurrect its proof.
+                    if (generation !== candidateGeneration)
+                        await localAdmission.remove(headers).catch(() => undefined);
+                }
+            },
+            verifyIdentity: async () => {
+                const headers = await readHeaders();
+                const { identity, online } = await authenticate(headers, true);
+                return { authorityUrl: raw.url, accountId: identity.principalId, headers, online };
+            },
+        };
+        return { owner, client };
+    };
+    const controller = startWorkerHost({
+        postMessage: (message) => port.postMessage(message),
+        onMessage: (listener) => { input = listener; },
+    }, async (...args) => {
+        const prepared = await prepareClient(...args);
+        const binding = await prepared.owner.attach(prepared.client);
+        if (disconnected) {
+            await binding.close();
+            throw new Error("Shared engine client disconnected during open");
+        }
+        return binding;
+    }, async (storage, server, branchId) => {
+        const prepared = await prepareClient(storage, undefined, undefined, server);
+        await prepared.owner.convert(prepared.client, transport => convertReplicaBinding(storage, transport, branchId), branchId);
+    });
+    const disconnect = async () => {
+        if (disconnected)
+            return;
+        disconnected = true;
+        if (client)
+            owner?.deactivate(client);
+        let failure;
+        try {
+            await controller.close();
+        }
+        catch (error) {
+            failure = error;
+        }
+        try {
+            if (client)
+                await owner?.detach(client);
+        }
+        catch (error) {
+            failure ??= error;
+        }
+        try {
+            port.postMessage({ kind: "shared.disconnected", error: failure === undefined ? undefined : serializeWorkerError(failure) });
+        }
+        finally {
+            port.close();
+        }
+    };
+    port.onmessage = (event) => {
+        const message = event.data;
+        if (message?.kind === "shared.disconnect") {
+            void disconnect();
+            return;
+        }
+        if (message?.kind === "shared.clientLease") {
+            // The page holds this lock. Acquisition means it closed or crashed.
+            void navigator.locks.request(message.name, () => disconnect());
+            return;
+        }
+        input?.(message);
+    };
+    port.start();
+};

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

@@ -2,3 +2,5 @@ import type { LixBinding, LixStorageConfig, TelemetryDispatch, TelemetryParentCo
 import type { WorkerConnection } from "./protocol.js";
 export declare const openDirectLixBinding: undefined | ((storage: LixStorageConfig, telemetry?: TelemetryDispatch, telemetryParent?: TelemetryParentContext, server?: SyncServerBindingOptions, openProgress?: OpenProgressDispatch, snapshot?: ReadableStream<Uint8Array>) => Promise<LixBinding>);
 export declare function createWorkerConnection(): WorkerConnection;
+/** Package-private provider identity selects one engine, not one engine per tab. */
+export declare function createSharedWorkerConnection(key: string): WorkerConnection;

package/dist/worker/factory.browser.js

@@ -1,4 +1,5 @@
 /// <reference lib="webworker" />
+import { deserializeWorkerError } from "./protocol.js";
 // Browser/Wasm execution stays off the main thread.
 export const openDirectLixBinding = undefined;
 export function createWorkerConnection() {
@@ -14,7 +15,7 @@ export function createWorkerConnection() {
             worker.onmessage = (event) => listener(event.data);
         },
         onFatal(listener) {
-            worker.onerror = (event) => listener(event.error ?? new Error(event.message ?? "Lix worker failed"));
+            worker.onerror = (event) => listener(workerFailure(event));
         },
         ref() { },
         unref() { },
@@ -23,3 +24,66 @@ export function createWorkerConnection() {
         },
     };
 }
+/** Package-private provider identity selects one engine, not one engine per tab. */
+export function createSharedWorkerConnection(key) {
+    if (typeof SharedWorker === "undefined" || !navigator.locks)
+        throw new Error("Shared partial replicas require SharedWorker and Web Locks");
+    const worker = new SharedWorker(new URL("./entry.shared.browser.js", import.meta.url), { type: "module", name: key });
+    const port = worker.port;
+    const leaseName = `lix:shared-client:${crypto.randomUUID()}`;
+    let release;
+    const lifetime = new Promise(resolve => { release = resolve; });
+    let ready;
+    const acquired = new Promise(resolve => { ready = resolve; });
+    let failure;
+    void navigator.locks.request(leaseName, async () => { ready(); await lifetime; }).catch(error => failure?.(error));
+    void acquired.then(() => port.postMessage({ kind: "shared.clientLease", name: leaseName }));
+    port.start();
+    let closed = false;
+    let termination;
+    let disconnected;
+    const detached = new Promise((resolve, reject) => { disconnected = error => error ? reject(error) : resolve(); });
+    return {
+        postMessage(message) { if (closed)
+            throw new Error("Shared engine connection closed"); port.postMessage(message); },
+        onMessage(listener) {
+            port.onmessage = event => {
+                if (event.data?.kind === "shared.disconnected") {
+                    const error = event.data.error;
+                    disconnected(error ? deserializeWorkerError(error) : undefined);
+                }
+                else
+                    listener(event.data);
+            };
+        },
+        onFatal(listener) { failure = listener; worker.onerror = event => listener(workerFailure(event)); },
+        ref() { }, unref() { },
+        terminate() {
+            if (termination)
+                return termination;
+            termination = (async () => {
+                closed = true;
+                port.postMessage({ kind: "shared.disconnect" });
+                release();
+                let timeout;
+                try {
+                    await Promise.race([detached, new Promise((_, reject) => {
+                            timeout = setTimeout(() => reject(Object.assign(new Error("Shared engine close was not acknowledged"), { code: "LIX_SHARED_ENGINE_CLOSE_UNCONFIRMED" })), 10000);
+                        })]);
+                }
+                finally {
+                    if (timeout !== undefined)
+                        clearTimeout(timeout);
+                    port.close();
+                }
+            })();
+            return termination;
+        },
+    };
+}
+function workerFailure(event) {
+    if (event.error instanceof Error)
+        return event.error;
+    const location = event.filename ? ` (${event.filename}:${event.lineno ?? 0}:${event.colno ?? 0})` : "";
+    return Object.assign(new Error(`${event.message || "Lix worker failed to load or execute"}${location}`), { code: "LIX_WORKER_FAILED" });
+}

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

@@ -3,3 +3,4 @@ import type { WorkerConnection } from "./protocol.js";
 export declare function createWorkerConnection(): WorkerConnection;
 export declare function workerExecArgv(execArgv: readonly string[]): string[];
 export declare const openDirectLixBinding: (storage: LixStorageConfig, telemetry?: TelemetryDispatch, telemetryParent?: TelemetryParentContext, server?: SyncServerBindingOptions, openProgress?: OpenProgressDispatch, snapshot?: ReadableStream<Uint8Array>) => Promise<LixBinding | undefined>;
+export declare function createSharedWorkerConnection(_key: string): WorkerConnection | undefined;

package/dist/worker/factory.node.js

@@ -55,3 +55,6 @@ export function workerExecArgv(execArgv) {
 export const openDirectLixBinding = async (storage, telemetry, telemetryParent, server, openProgress, snapshot) => {
     return openLixBinding(storage, telemetry, telemetryParent, server, openProgress, snapshot);
 };
+export function createSharedWorkerConnection(_key) {
+    return undefined;
+}

package/dist/worker/host.d.ts

@@ -1,4 +1,6 @@
-import { openLixBinding } from "#binding";
+import { openLixBinding, convertReplicaBinding } from "#binding";
 import { type WorkerHostEndpoint, type WorkerSyncFetchResponse } from "./protocol.js";
-export declare function startWorkerHost(endpoint: WorkerHostEndpoint, openBinding?: typeof openLixBinding): void;
+export declare function startWorkerHost(endpoint: WorkerHostEndpoint, openBinding?: typeof openLixBinding, convertBinding?: typeof convertReplicaBinding): {
+    close(): Promise<void>;
+};
 export declare function responseFromSyncFetch(resolved: WorkerSyncFetchResponse): Response;

package/dist/worker/host.js

@@ -1,6 +1,8 @@
-import { openLixBinding, createHostedBinding, deleteHostedBinding, } from "#binding";
+import { validateHttpRequest } from "../http-transport.js";
+import { openLixBinding, convertReplicaBinding, retryReplicaMigrationCleanupBinding, createHostedBinding, deleteHostedBinding, } from "#binding";
 import { deserializeWorkerError, serializeWorkerError, } from "./protocol.js";
-export function startWorkerHost(endpoint, openBinding = openLixBinding) {
+export function startWorkerHost(endpoint, openBinding = openLixBinding, convertBinding = convertReplicaBinding) {
+    let closed = false;
     const sessions = new Map();
     let nextSessionId = 1;
     let nextTransactionId = 1;
@@ -16,7 +18,10 @@ export function startWorkerHost(endpoint, openBinding = openLixBinding) {
     const pendingSyncStreamPulls = new Map();
     const syncStreamCleanup = new Map();
     let finiteQueue = Promise.resolve();
+    const registrations = new Set();
     endpoint.onMessage((message) => {
+        if (closed && "id" in message)
+            return;
         if (!("id" in message)) {
             handleNotification(message);
             return;
@@ -54,15 +59,21 @@ export function startWorkerHost(endpoint, openBinding = openLixBinding) {
             // finite-operation queue lets a long-running operation block a newly
             // mounted query, including one that needs lazy history hydration.
             // The live `next()` lane is already independent for the same reason.
-            void respond(message, () => handleObserveRegistration(message.sessionId, operation.sql, operation.params));
+            const registration = respond(message, () => handleObserveRegistration(message.sessionId, operation.sql, operation.params));
+            registrations.add(registration);
+            void registration.finally(() => registrations.delete(registration));
             return;
         }
         finiteQueue = finiteQueue.then(async () => {
             try {
                 await respond(message, async () => {
+                    if (closed)
+                        throw workerStateError("Worker client disconnected");
                     if (message.operation.kind !== "open" &&
                         message.operation.kind !== "hosted.create" &&
-                        message.operation.kind !== "hosted.delete") {
+                        message.operation.kind !== "hosted.delete" &&
+                        message.operation.kind !== "replica.convert" &&
+                        message.operation.kind !== "replica.cleanup") {
                         requiredLix(message.sessionId).setTelemetryParent(message.telemetryParent);
                     }
                     return handleFiniteOperation(message.sessionId, message.operation, message.telemetryParent);
@@ -165,6 +176,14 @@ export function startWorkerHost(endpoint, openBinding = openLixBinding) {
     }
     async function handleFiniteOperation(sessionId, operation, telemetryParent) {
         switch (operation.kind) {
+            case "replica.cleanup":
+                if (sessions.size > 0)
+                    throw workerStateError("Migration cleanup requires closed storage");
+                return retryReplicaMigrationCleanupBinding(operation.storage, createSyncServerBridge(operation.server));
+            case "replica.convert":
+                if (sessions.size > 0)
+                    throw workerStateError("Conversion requires closed storage");
+                return convertBinding(operation.storage, createSyncServerBridge(operation.server), operation.branchId);
             case "hosted.create":
                 return createHostedBinding(operation.server);
             case "hosted.delete":
@@ -221,8 +240,7 @@ export function startWorkerHost(endpoint, openBinding = openLixBinding) {
             case "transaction.commit": {
                 const transaction = requiredTransaction(operation.transactionId);
                 transactions.delete(operation.transactionId);
-                await transaction.commit();
-                return undefined;
+                return await transaction.commit();
             }
             case "transaction.rollback": {
                 const transaction = requiredTransaction(operation.transactionId);
@@ -230,6 +248,16 @@ export function startWorkerHost(endpoint, openBinding = openLixBinding) {
                 await transaction.rollback();
                 return undefined;
             }
+            case "replicaRecoverySources":
+                return requiredLix(sessionId).replicaRecoverySources();
+            case "exportReplicaRecovery":
+                return requiredLix(sessionId).exportReplicaRecovery(operation.id);
+            case "recoverReplica":
+                return requiredLix(sessionId).recoverReplica(operation.id);
+            case "recoverReplicaWithServer":
+                return requiredLix(sessionId).recoverReplicaWithServer(operation.id, createSyncServerBridge(operation.server, operation.transportScope));
+            case "syncHealth":
+                return requiredLix(sessionId).syncHealth();
             case "activeBranchId":
                 return requiredLix(sessionId).activeBranchId();
             case "activeAccountId":
@@ -322,7 +350,46 @@ export function startWorkerHost(endpoint, openBinding = openLixBinding) {
         }
         await input.writer.close();
     }
-    function createSyncServerBridge(server) {
+    return { async close() {
+            if (closed)
+                return;
+            closed = true;
+            const failure = workerStateError("Worker client disconnected");
+            for (const pending of pendingSyncHeaders.values())
+                pending.reject(failure);
+            pendingSyncHeaders.clear();
+            for (const pending of pendingSyncFetch.values())
+                pending.reject(failure);
+            pendingSyncFetch.clear();
+            for (const cleanup of syncStreamCleanup.values())
+                cleanup();
+            syncStreamCleanup.clear();
+            for (const pending of pendingSyncStreamPulls.values()) {
+                pending.controller.error(failure);
+                pending.reject(failure);
+            }
+            pendingSyncStreamPulls.clear();
+            for (const observation of observations.values())
+                observation.close();
+            observations.clear();
+            for (const snapshot of snapshotExports.values())
+                await Promise.resolve(snapshot.cancel()).catch(() => undefined);
+            snapshotExports.clear();
+            await finiteQueue.catch(() => undefined);
+            await Promise.allSettled(registrations);
+            // The active finite operation has finished; never roll back a handle
+            // concurrently with its execute/commit operation.
+            for (const transaction of transactions.values())
+                await transaction.rollback().catch(() => undefined);
+            transactions.clear();
+            for (const snapshot of snapshotExports.values())
+                await Promise.resolve(snapshot.cancel()).catch(() => undefined);
+            snapshotExports.clear();
+            for (const session of sessions.values())
+                await session.close();
+            sessions.clear();
+        } };
+    function createSyncServerBridge(server, transportScope) {
         if (!server)
             return undefined;
         return {
@@ -330,48 +397,37 @@ export function startWorkerHost(endpoint, openBinding = openLixBinding) {
             headers: server.headers ?? [],
             headerProvider: server.dynamicHeaders
                 ? () => {
+                    if (closed)
+                        throw workerStateError("Worker client disconnected");
                     const requestId = nextSyncRequestId++;
                     return new Promise((resolve, reject) => {
                         pendingSyncHeaders.set(requestId, { resolve, reject });
-                        endpoint.postMessage({ kind: "sync.headers", requestId });
+                        endpoint.postMessage({ kind: "sync.headers", requestId, transportScope });
                     });
                 }
                 : undefined,
-            fetch: server.customFetch ? bridgeFetch : undefined,
+            transport: (request) => bridgeFetch(request, transportScope),
         };
     }
-    async function bridgeFetch(input, init) {
-        const extension = init;
-        const streaming = extension?.lixResponseStream === true;
-        const responseLimit = extension?.lixResponseLimit;
-        if (!streaming &&
-            (typeof responseLimit !== "number" ||
-                !Number.isSafeInteger(responseLimit) ||
-                responseLimit <= 0)) {
-            throw new TypeError("Browser sync fetch has no valid response limit");
-        }
+    async function bridgeFetch(httpRequest, transportScope) {
+        validateHttpRequest(httpRequest);
+        const { url: input, init, response: policy } = httpRequest;
+        const streaming = policy.mode === "streaming";
+        if (closed)
+            throw workerStateError("Worker client disconnected");
         const requestId = nextSyncRequestId++;
         const requestBase = {
-            url: typeof input === "string"
-                ? input
-                : input instanceof URL
-                    ? input.toString()
-                    : input.url,
+            url: input,
             method: init?.method ?? "GET",
             headers: headerEntries(init?.headers),
             body: serializableBody(init?.body),
             credentials: init?.credentials,
+            cache: init?.cache, redirect: init?.redirect,
         };
-        const request = streaming
-            ? { ...requestBase, responseMode: "stream" }
-            : {
-                ...requestBase,
-                responseMode: "buffered",
-                responseLimit: responseLimit,
-            };
+        const request = { ...requestBase, response: policy };
         const response = new Promise((resolve, reject) => {
             pendingSyncFetch.set(requestId, { resolve, reject });
-            endpoint.postMessage({ kind: "sync.fetch", requestId, request });
+            endpoint.postMessage({ kind: "sync.fetch", requestId, request, transportScope });
         });
         const abort = () => {
             const pending = pendingSyncFetch.get(requestId);
@@ -463,6 +519,10 @@ export function startWorkerHost(endpoint, openBinding = openLixBinding) {
         // serialized finite lane. Each `observe.next` supplies telemetry directly
         // to its observation binding.
         const events = await requiredLix(sessionId).observe(sql, params);
+        if (closed) {
+            events.close();
+            throw workerStateError("Worker client disconnected");
+        }
         const observeId = nextObserveId++;
         observations.set(observeId, events);
         return observeId;

package/dist/worker/protocol.d.ts

@@ -1,10 +1,10 @@
+import type { HttpResponsePolicy } from "../http-transport.js";
 import type { BindingBatchStatement, BindingParam, LixStorageConfig } from "../binding-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;
@@ -12,12 +12,10 @@ export type WorkerSyncFetchRequest = {
     headers: [string, string][];
     body?: string | Uint8Array;
     credentials?: RequestCredentials;
-} & ({
-    responseMode: "buffered";
-    responseLimit: number;
-} | {
-    responseMode: "stream";
-});
+    cache?: RequestCache;
+    redirect?: RequestRedirect;
+    response: HttpResponsePolicy;
+};
 type WorkerSyncFetchResponseHead = {
     status: number;
     statusText: string;
@@ -36,6 +34,15 @@ export type WorkerRequest = {
     operation: WorkerOperation;
 };
 export type WorkerOperation = {
+    kind: "replica.cleanup";
+    storage: LixStorageConfig;
+    server: WorkerSyncServerOptions;
+} | {
+    kind: "replica.convert";
+    storage: LixStorageConfig;
+    server: WorkerSyncServerOptions;
+    branchId?: string;
+} | {
     kind: "hosted.create";
     server: import("../binding-types.js").HostedServerBindingOptions;
 } | {
@@ -84,6 +91,21 @@ export type WorkerOperation = {
 } | {
     kind: "transaction.rollback";
     transactionId: number;
+} | {
+    kind: "replicaRecoverySources";
+} | {
+    kind: "exportReplicaRecovery";
+    id: string;
+} | {
+    kind: "recoverReplica";
+    id: string;
+} | {
+    kind: "recoverReplicaWithServer";
+    id: string;
+    server: WorkerSyncServerOptions;
+    transportScope: number;
+} | {
+    kind: "syncHealth";
 } | {
     kind: "activeBranchId";
 } | {
@@ -185,6 +207,7 @@ export type WorkerHostEndpoint = {
     onMessage(listener: (message: WorkerInput) => void): void;
 };
 export type SerializedWorkerError = {
+    cause?: SerializedWorkerError;
     name: string;
     message: string;
     stack?: string;
@@ -209,10 +232,12 @@ export type WorkerResponse = {
 } | {
     kind: "sync.headers";
     requestId: number;
+    transportScope?: number;
 } | {
     kind: "sync.fetch";
     requestId: number;
     request: WorkerSyncFetchRequest;
+    transportScope?: number;
 } | {
     kind: "sync.fetch.stream.pull";
     requestId: number;
@@ -220,6 +245,6 @@ export type WorkerResponse = {
     kind: "sync.fetch.cancel";
     requestId: number;
 };
-export declare function serializeWorkerError(error: unknown): SerializedWorkerError;
+export declare function serializeWorkerError(error: unknown, depth?: number): SerializedWorkerError;
 export declare function deserializeWorkerError(error: SerializedWorkerError): Error;
 export {};