@syncular/client 0.1.3 → 0.2.0

package/dist/worker-entry.js

@@ -1,479 +1,323 @@
-import { resolveSyncularClientConfig } from './client-config.js';
-import { syncularDiagnosticAttemptFields } from './diagnostics.js';
-import { classifySyncularError, SyncularClientError, syncularErrorDetails, syncularErrorMessage, syncularErrorStatus, } from './errors.js';
-import { dispatchGeneratedSyncularWorkerRequest, generatedSyncularWorkerRequestDiagnosticSource, isGeneratedSyncularAbortableWorkerRequestType, isGeneratedSyncularDiagnosedSuccessWorkerRequestType, } from './generated-bridge.js';
-import { createSyncularRuntimeInfo } from './runtime-contract.js';
-import { openSyncularRustClient } from './rust-client.js';
-import { getSyncularRustRuntimeInfo, getSyncularWasmGlueUrl, getSyncularWasmUrl, } from './wasm-runtime.js';
-import { createSyncularWorkerErrorPayload, SYNCULAR_WORKER_PROTOCOL_VERSION, } from './worker-protocol.js';
-import { SyncularWorkerRealtimeController } from './worker-realtime.js';
-let client;
-let openedConfig;
-let openedRuntime;
-let removeRowsChangedListener;
-const canceledRequests = new Set();
-const abortControllers = new Map();
-const realtime = new SyncularWorkerRealtimeController({
-    getClient: requireClient,
-    getConfig: () => openedConfig,
-    getLocationOrigin: () => typeof self.location?.origin === 'string'
-        ? self.location.origin
-        : 'http://localhost',
-    createWebSocket: (url) => new WebSocket(url),
-    postEvent: (event) => self.postMessage(event),
-    postDiagnostic,
-});
-self.onmessage = (event) => {
-    void handleRequest(event.data);
-};
-async function handleRequest(request) {
-    if (request.protocolVersion !== SYNCULAR_WORKER_PROTOCOL_VERSION) {
-        post({
-            id: request.id,
-            protocolVersion: SYNCULAR_WORKER_PROTOCOL_VERSION,
-            ok: false,
-            error: createSyncularWorkerErrorPayload('worker.protocol_mismatch', `Unsupported Syncular worker protocol ${request.protocolVersion}`, { details: { supported: SYNCULAR_WORKER_PROTOCOL_VERSION } }),
-        });
-        return;
+/**
+ * Worker-side bootstrap (Direction decision 2): constructs the WHOLE
+ * client core — SyncClient + transports + realtime + SQLite — inside the
+ * worker and serves the `worker-protocol` RPC over postMessage.
+ *
+ * Browsers get the defaults: opfs-sahpool persistence and the fetch/WS
+ * transports from `./http`, wired from `WorkerInitConfig.endpoints`.
+ * Tests inject a database factory (bun:sqlite) through `overrides` — the
+ * same bootstrap, the same RPC, a different SQLite.
+ *
+ * The §8.4 host loop lives HERE: wake-ups (hello/`sync` events, delta
+ * drops) coalesce into one jittered `syncUntilIdle` round in the worker;
+ * RPC-driven and auto-driven sync rounds serialize on one queue because
+ * the core owns exactly one loop.
+ */
+import { SyncClient } from './client.js';
+import { ClientSyncError } from './errors.js';
+import { httpBlobTransport, httpSegmentDownloader, httpSyncTransport, webSocketRealtimeConnector, } from './http.js';
+import { openPersistentWasmDatabase } from './wasm-database.js';
+import { WORKER_FAILED_CODE, } from './worker-protocol.js';
+function toErrorShape(error) {
+    if (error instanceof ClientSyncError) {
+        return {
+            code: error.code,
+            message: error.message,
+            retryable: error.retryable,
+        };
     }
-    if (request.type === 'cancel') {
-        canceledRequests.add(request.requestId);
-        const controller = abortControllers.get(request.requestId);
-        controller?.abort();
-        if (controller) {
-            postDiagnostic({
-                level: 'warn',
-                source: 'worker',
-                code: 'worker.request_aborted',
-                message: 'Syncular worker request aborted',
-                details: { requestId: request.requestId },
-            });
+    return {
+        code: WORKER_FAILED_CODE,
+        message: error instanceof Error ? error.message : String(error),
+        retryable: false,
+    };
+}
+/**
+ * ArrayBuffers safe to transfer out of a query result: whole-buffer
+ * views only (a view into a larger/pooled buffer is cloned instead —
+ * transferring would detach unrelated data), deduplicated because a
+ * buffer may only appear once in a transfer list.
+ */
+function queryTransferables(rows) {
+    const buffers = new Set();
+    for (const row of rows) {
+        if (row === null || typeof row !== 'object')
+            continue;
+        for (const value of Object.values(row)) {
+            if (value instanceof Uint8Array &&
+                value.buffer instanceof ArrayBuffer &&
+                value.byteOffset === 0 &&
+                value.byteLength === value.buffer.byteLength) {
+                buffers.add(value.buffer);
+            }
         }
-        post({
-            id: request.id,
-            protocolVersion: request.protocolVersion,
-            ok: true,
-        });
-        return;
     }
-    const startedAt = Date.now();
-    const abortController = createAbortController(request.type);
-    if (abortController) {
-        abortControllers.set(request.id, abortController);
+    return [...buffers];
+}
+/**
+ * Register the RPC server on the current worker scope. Call this once
+ * from a worker entry script; the main-thread handle drives everything
+ * else through `init`/`call` messages.
+ */
+export function startSyncWorker(overrides = {}) {
+    const scope = globalThis;
+    const post = (message, transfer) => {
+        if (transfer !== undefined && transfer.length > 0) {
+            scope.postMessage(message, transfer);
+        }
+        else {
+            scope.postMessage(message);
+        }
+    };
+    let client;
+    let database;
+    let offline = false;
+    let closed = false;
+    // -- one sync loop: RPC-driven and auto-driven rounds serialize ----------
+    let syncChain = Promise.resolve();
+    function serializedSync(fn) {
+        const next = syncChain.then(fn, fn);
+        syncChain = next.then(() => undefined, () => undefined);
+        return next;
     }
-    try {
-        if (abortController)
-            client?.setAbortSignal(abortController.signal);
-        const value = await dispatch(request);
-        if (canceledRequests.delete(request.id))
+    // -- §8.4 host loop: coalesced, jittered, inside the worker --------------
+    let autoSync = true;
+    let wakeJitterMs = 200;
+    let autoSyncScheduled = false;
+    function scheduleAutoSync() {
+        if (!autoSync || autoSyncScheduled || closed || client === undefined) {
             return;
-        post({
-            id: request.id,
-            protocolVersion: request.protocolVersion,
-            ok: true,
-            value,
+        }
+        autoSyncScheduled = true;
+        setTimeout(() => {
+            autoSyncScheduled = false;
+            if (closed || client === undefined)
+                return;
+            const running = client;
+            void serializedSync(() => running.syncUntilIdle())
+                .then((summary) => {
+                if (!closed)
+                    post({ t: 'event', event: { kind: 'synced', summary } });
+            })
+                .catch((error) => {
+                if (!closed) {
+                    post({
+                        t: 'event',
+                        event: { kind: 'synced', error: toErrorShape(error) },
+                    });
+                }
+            });
+        }, Math.floor(Math.random() * wakeJitterMs));
+    }
+    function requireClient() {
+        if (client === undefined) {
+            throw new ClientSyncError(WORKER_FAILED_CODE, 'the worker received a call before init completed');
+        }
+        return client;
+    }
+    function assertOnline() {
+        if (offline) {
+            throw new ClientSyncError('sync.transport_failed', 'the worker transport is offline (setOffline(true))', true);
+        }
+    }
+    function gateOffline(inner) {
+        return (request) => {
+            assertOnline();
+            return inner(request);
+        };
+    }
+    /** Offline gate that preserves the §5.4 `fetchUrl` capability marker. */
+    function gateSegmentsOffline(inner) {
+        const fetchUrl = inner.fetchUrl;
+        return Object.assign(gateOffline(inner), {
+            ...(fetchUrl !== undefined
+                ? {
+                    fetchUrl: (url) => {
+                        assertOnline();
+                        return fetchUrl(url);
+                    },
+                }
+                : {}),
         });
-        postRequestSuccessDiagnostic(request, value, Date.now() - startedAt);
     }
-    catch (err) {
-        if (canceledRequests.delete(request.id))
-            return;
-        const source = requestDiagnosticSource(request.type);
-        const resyncRequired = errorRequiresFullRefresh(err);
-        const encodedError = encodeWorkerError(err);
-        const diagnosticCode = resyncRequired
-            ? `${source}.resync_required`
-            : encodedError.code.startsWith(`${source}.`)
-                ? encodedError.code
-                : `${source}.${request.type}.failed`;
-        postDiagnostic({
-            level: requestDiagnosticLevel(request.type, err),
-            source,
-            code: diagnosticCode,
-            message: resyncRequired
-                ? `Syncular worker request ${request.type} requires full resync`
-                : `Syncular worker request ${request.type} failed`,
-            details: {
-                requestType: request.type,
-                durationMs: Date.now() - startedAt,
-                error: errorMessage(err),
-                errorCode: encodedError.code,
-                ...(encodedError.category ? { category: encodedError.category } : {}),
-                ...(encodedError.retryable != null
-                    ? { retryable: encodedError.retryable }
-                    : {}),
-                ...(encodedError.recommendedAction
-                    ? { recommendedAction: encodedError.recommendedAction }
-                    : {}),
-                ...(resyncRequired ? { resyncRequired: true } : {}),
-                ...diagnosticStatus(err),
+    async function init(config) {
+        if (client !== undefined) {
+            throw new ClientSyncError(WORKER_FAILED_CODE, 'the worker is already initialized');
+        }
+        autoSync = config.autoSync ?? true;
+        wakeJitterMs = config.wakeJitterMs ?? 200;
+        database =
+            overrides.openDatabase !== undefined
+                ? await overrides.openDatabase(config)
+                : await defaultOpenDatabase(config);
+        const transport = gateOffline(overrides.createTransport !== undefined
+            ? overrides.createTransport(config)
+            : httpSyncTransport(config.endpoints.syncUrl));
+        const segments = overrides.createSegments !== undefined
+            ? overrides.createSegments(config)
+            : config.endpoints.segmentsUrl !== undefined
+                ? httpSegmentDownloader(config.endpoints.segmentsUrl)
+                : undefined;
+        // §5.9 blob transport: only when a blobs URL is configured.
+        const blobs = config.endpoints.blobsUrl !== undefined
+            ? httpBlobTransport(config.endpoints.blobsUrl)
+            : undefined;
+        // Realtime needs the (possibly persisted) clientId for the
+        // `{clientId}` URL placeholder — start the client first, then attach
+        // the connector through a mutable slot read at connect time.
+        let realtimeConnector;
+        const started = new SyncClient({
+            database,
+            schema: config.schema,
+            transport,
+            ...(segments !== undefined
+                ? { segments: gateSegmentsOffline(segments) }
+                : {}),
+            ...(blobs !== undefined ? { blobs } : {}),
+            realtime: (handlers) => {
+                if (offline) {
+                    throw new ClientSyncError('sync.transport_failed', 'the worker realtime channel is offline (setOffline(true))', true);
+                }
+                if (realtimeConnector === undefined) {
+                    throw new ClientSyncError('sync.invalid_request', 'no realtime connector configured');
+                }
+                return realtimeConnector(handlers);
+            },
+            ...(config.clientId !== undefined ? { clientId: config.clientId } : {}),
+            ...(config.limits !== undefined ? { limits: config.limits } : {}),
+            onSyncNeeded: (reason) => {
+                post({ t: 'event', event: { kind: 'sync-needed', reason } });
+                scheduleAutoSync();
+            },
+            onConflict: (conflict) => {
+                post({ t: 'event', event: { kind: 'conflict', conflict } });
+            },
+            onUpgrading: (upgrading) => {
+                // §7.4.5: surface the schema-bump reset + completion to the UI thread.
+                post({ t: 'event', event: { kind: 'upgrading', upgrading } });
+            },
+            onPresence: (scopeKey) => {
+                // §8.6: surface a presence change to the UI thread.
+                post({ t: 'event', event: { kind: 'presence', scopeKey } });
             },
-            ...requestSyncAttemptDiagnosticFields(request),
         });
-        post({
-            id: request.id,
-            protocolVersion: request.protocolVersion,
-            ok: false,
-            error: encodedError,
+        // TODO 3.1 / I1: forward every coalesced apply-batch invalidation to the
+        // UI thread so `SyncClientHandle.onInvalidate` fires with worker parity.
+        started.onInvalidate((event) => {
+            if (!closed)
+                post({ t: 'event', event: { kind: 'invalidate', event } });
         });
+        await started.start();
+        realtimeConnector =
+            overrides.createRealtime !== undefined
+                ? overrides.createRealtime(config, started.clientId)
+                : config.endpoints.realtimeUrl !== undefined
+                    ? webSocketRealtimeConnector(config.endpoints.realtimeUrl.replace('{clientId}', encodeURIComponent(started.clientId)))
+                    : undefined;
+        client = started;
+        return { clientId: started.clientId };
     }
-    finally {
-        abortControllers.delete(request.id);
-        if (abortController)
-            clearClientAbortSignal();
-    }
-}
-async function dispatch(request) {
-    return dispatchGeneratedSyncularWorkerRequest({
-        requireClient,
-        openClient,
-        startRealtime: (options) => {
-            realtime.start(options);
-            return true;
+    const api = {
+        subscribe: (input) => requireClient().subscribe(input),
+        unsubscribe: (id) => requireClient().unsubscribe(id),
+        setWindow: async (base, units) => {
+            await requireClient().setWindow(base, units);
+            // A window change adds/removes value-sharded subscriptions; a widened
+            // unit needs a bootstrap pull to become visible. In autoSync mode the
+            // host loop owns rounds, so schedule one now — otherwise the new unit
+            // waits for an unrelated server wake-up (§8.4). A no-op change still
+            // schedules a harmless idempotent round.
+            scheduleAutoSync();
         },
-        stopRealtime: () => {
-            realtime.stop();
-            return true;
+        windowState: (base) => requireClient().windowState(base),
+        mutate: (mutations) => {
+            const id = requireClient().mutate(mutations);
+            // In autoSync mode the host loop owns rounds (§8.4): a local write must
+            // push without the app orchestrating sync, so schedule a jittered round
+            // to drain the outbox promptly. `mutate` is synchronous — its outbox
+            // write has committed before this line — and the round itself serializes
+            // on SyncClient's operation chain, so no ordering hack is needed here;
+            // the §8.4 jitter in `scheduleAutoSync` is the only deferral, and it
+            // coalesces bursts. (Historically this used setTimeout to dodge a
+            // nested-transaction flake; that race is fixed at the source now — the
+            // real cause was cross-operation interleaving, serialized in the core.)
+            scheduleAutoSync();
+            return id;
         },
-        sendPresence: (action, scopeKey, metadata) => {
-            realtime.sendPresence(action, scopeKey, metadata);
-            return true;
+        sync: () => {
+            const running = requireClient();
+            return serializedSync(() => running.sync());
         },
-        runtimeInfo,
-        closeClient,
-    }, request);
-}
-async function openClient(request) {
-    const config = resolveSyncularClientConfig(request.config);
-    realtime.stop();
-    detachRowsChangedListener();
-    client?.close();
-    client = undefined;
-    openedConfig = undefined;
-    openedRuntime = undefined;
-    const runtime = request.runtime;
-    client = await openSyncularRustClient({
-        config,
-        module: runtime?.wasmGlueUrl
-            ? loadWorkerWasmGlue(runtime.wasmGlueUrl)
-            : undefined,
-        wasmGlueUrl: runtime?.wasmGlueUrl,
-        wasmUrl: runtime?.wasmUrl,
-    });
-    attachRowsChangedListener(client);
-    openedConfig = config;
-    openedRuntime = runtime;
-    return true;
-}
-function closeClient() {
-    realtime.stop();
-    detachRowsChangedListener();
-    client?.close();
-    client = undefined;
-    openedConfig = undefined;
-    openedRuntime = undefined;
-    return true;
-}
-async function runtimeInfo() {
-    const wasmUrl = getSyncularWasmUrl();
-    const selectedWasmUrl = openedRuntime?.wasmUrl ?? wasmUrl;
-    const selectedWasmGlueUrl = openedRuntime?.wasmGlueUrl ?? getSyncularWasmGlueUrl();
-    return createSyncularRuntimeInfo({
-        storage: openedConfig?.storage,
-        workerUrl: typeof self.location?.href === 'string' ? self.location.href : '',
-        wasmGlueUrl: selectedWasmGlueUrl,
-        wasmUrl: selectedWasmUrl,
-        rust: await getSyncularRustRuntimeInfo(openedRuntime?.wasmGlueUrl
-            ? loadWorkerWasmGlue(openedRuntime.wasmGlueUrl)
-            : undefined, selectedWasmUrl),
-    });
-}
-function loadWorkerWasmGlue(wasmGlueUrl) {
-    return import(/* @vite-ignore */ wasmGlueUrl);
-}
-function requireClient() {
-    if (!client) {
-        throw createSyncularWorkerErrorPayload('worker.not_open', 'Syncular worker client is not open');
-    }
-    return client;
-}
-function attachRowsChangedListener(nextClient) {
-    removeRowsChangedListener = nextClient.addRowsChangedListener((event) => {
-        post({
-            protocolVersion: SYNCULAR_WORKER_PROTOCOL_VERSION,
-            type: 'rowsChanged',
-            source: event.source,
-            changedTables: event.changedTables,
-            changedRows: event.changedRows,
-            changedRowsTruncated: event.changedRowsTruncated,
-        });
-    });
-}
-function detachRowsChangedListener() {
-    removeRowsChangedListener?.();
-    removeRowsChangedListener = undefined;
-}
-function post(message) {
-    self.postMessage(message);
-}
-function createAbortController(type) {
-    if (!isAbortableRequest(type) || typeof AbortController === 'undefined') {
-        return undefined;
-    }
-    return new AbortController();
-}
-function isAbortableRequest(type) {
-    return isGeneratedSyncularAbortableWorkerRequestType(type);
-}
-function clearClientAbortSignal() {
-    try {
-        client?.setAbortSignal(null);
-    }
-    catch {
-        // Best effort after a request completed, failed, or closed the client.
-    }
-}
-function postDiagnostic(event) {
-    self.postMessage({
-        protocolVersion: SYNCULAR_WORKER_PROTOCOL_VERSION,
-        type: 'diagnostic',
-        event: {
-            at: event.at ?? Date.now(),
-            level: event.level,
-            source: event.source,
-            code: event.code,
-            message: event.message,
-            ...(event.syncAttemptId ? { syncAttemptId: event.syncAttemptId } : {}),
-            ...(event.traceId ? { traceId: event.traceId } : {}),
-            ...(event.spanId ? { spanId: event.spanId } : {}),
-            ...(event.clientId ? { clientId: event.clientId } : {}),
-            ...(event.subscriptionId ? { subscriptionId: event.subscriptionId } : {}),
-            ...(event.table ? { table: event.table } : {}),
-            ...(event.rowId ? { rowId: event.rowId } : {}),
-            ...(event.cursor !== undefined ? { cursor: event.cursor } : {}),
-            ...(event.details ? { details: event.details } : {}),
+        syncUntilIdle: (maxRounds) => {
+            const running = requireClient();
+            return serializedSync(() => running.syncUntilIdle(maxRounds));
         },
-    });
-}
-function postRequestSuccessDiagnostic(request, value, durationMs) {
-    if (!isDiagnosedSuccessRequest(request.type))
-        return;
-    const syncRevocation = syncScopeRevocationDetails(value);
-    postDiagnostic({
-        level: 'info',
-        source: requestDiagnosticSource(request.type),
-        code: `${requestDiagnosticSource(request.type)}.${request.type}.completed`,
-        message: `Syncular worker request ${request.type} completed`,
-        ...requestSyncAttemptDiagnosticFields(request),
-        details: {
-            requestType: request.type,
-            durationMs,
-            ...requestSuccessDetails(request, value),
+        query: (sql, params) => requireClient().query(sql, params),
+        conflicts: () => requireClient().conflicts,
+        rejections: () => requireClient().rejections,
+        schemaFloor: () => requireClient().schemaFloor,
+        leaseState: () => requireClient().leaseState,
+        upgrading: () => requireClient().upgrading,
+        syncNeeded: () => requireClient().syncNeeded,
+        pendingCommits: () => requireClient().pendingCommits(),
+        subscriptions: () => requireClient().subscriptions(),
+        subscription: (id) => requireClient().subscription(id),
+        connectRealtime: () => requireClient().connectRealtime(),
+        disconnectRealtime: () => requireClient().disconnectRealtime(),
+        setPresence: (scopeKey, doc) => requireClient().setPresence(scopeKey, doc),
+        presence: (scopeKey) => requireClient().presence(scopeKey),
+        uploadBlob: (bytes, options) => requireClient().uploadBlob(bytes, options),
+        fetchBlob: (blobIdOrRef) => requireClient().fetchBlob(blobIdOrRef),
+        setOffline: (value) => {
+            offline = value;
+            if (offline)
+                client?.disconnectRealtime();
         },
-    });
-    if (syncRevocation &&
-        (request.type === 'syncPull' ||
-            request.type === 'syncPush' ||
-            request.type === 'syncOnce')) {
-        postDiagnostic({
-            level: 'warn',
-            source: 'sync',
-            code: 'sync.scope_revoked',
-            message: 'Syncular subscription scope revoked',
-            ...requestSyncAttemptDiagnosticFields(request),
-            details: {
-                requestType: request.type,
-                ...syncRevocation,
-            },
-        });
+        close: async () => {
+            closed = true;
+            await client?.close();
+            database?.close();
+            client = undefined;
+            database = undefined;
+        },
+    };
+    async function dispatch(message) {
+        const method = api[message.method];
+        return await method.apply(api, message.args);
     }
-}
-function requestSyncAttemptDiagnosticFields(request) {
-    if (request.type !== 'syncPull' &&
-        request.type !== 'syncPush' &&
-        request.type !== 'syncOnce') {
-        return {};
+    function run(id, fn, transfer) {
+        void (async () => {
+            try {
+                const value = await fn();
+                post({ t: 'result', id, value }, transfer !== undefined ? transfer(value) : undefined);
+            }
+            catch (error) {
+                post({ t: 'error', id, error: toErrorShape(error) });
+            }
+        })();
     }
-    return syncularDiagnosticAttemptFields(request.syncAttempt);
-}
-function isDiagnosedSuccessRequest(type) {
-    return isGeneratedSyncularDiagnosedSuccessWorkerRequestType(type);
-}
-function requestDiagnosticSource(type) {
-    return generatedSyncularWorkerRequestDiagnosticSource(type);
-}
-function requestDiagnosticLevel(type, error) {
-    if (type === 'setAuthHeaders' || syncularErrorStatus(error))
-        return 'warn';
-    return 'error';
-}
-function requestSuccessDetails(request, value) {
-    switch (request.type) {
-        case 'open':
-            return {
-                storage: openedConfig?.storage,
-                clientId: openedConfig?.clientId,
-            };
-        case 'setAuthHeaders':
-            return { headerCount: Object.keys(request.headers).length };
-        case 'setFieldEncryption':
-            return {
-                enabled: request.config != null,
-                ruleCount: request.config?.rules.length ?? 0,
-            };
-        case 'setEncryptedCrdt':
-            return {
-                enabled: request.config != null,
-                keyCount: request.config ? Object.keys(request.config.keys).length : 0,
-            };
-        case 'setBlobEncryption':
-            return {
-                enabled: request.config != null,
-                keyCount: request.config ? Object.keys(request.config.keys).length : 0,
-            };
-        case 'syncPull':
-        case 'syncPush':
-        case 'syncOnce':
-            return syncResultDetails(value);
-        case 'storeBlob':
-            return { immediate: request.options?.immediate === true };
-        case 'pruneBlobCache':
-            return { maxBytes: request.maxBytes ?? null, prunedBytes: value };
-        case 'compactStorage':
-            return objectRecord(value);
-        case 'localHealthCheck': {
-            const report = objectRecord(value);
-            const findings = Array.isArray(report.findings) ? report.findings : [];
-            return {
-                ok: report.ok === true,
-                findingCount: findings.length,
-            };
-        }
-        case 'exportLocalSupportBundle': {
-            const bundle = objectRecord(value);
-            const health = objectRecord(bundle.health);
-            const findings = Array.isArray(health.findings) ? health.findings : [];
-            return {
-                redacted: bundle.redacted === true,
-                source: bundle.source,
-                findingCount: findings.length,
-            };
+    scope.addEventListener('message', (event) => {
+        const message = event.data;
+        if (message.t === 'init') {
+            run(message.id, () => init(message.config));
+            return;
         }
-        case 'importLocalSupportBundle':
-            return objectRecord(value);
-        case 'repairLocalHealth':
-            return objectRecord(value);
-        case 'resetLocalSyncState':
-            return objectRecord(value);
-        case 'processBlobUploadQueue':
-            return objectRecord(value);
-        default:
-            return {};
-    }
-}
-function syncResultDetails(value) {
-    const result = objectRecord(value);
-    const changedTables = Array.isArray(result.changedTables)
-        ? result.changedTables
-        : [];
-    const changedRows = Array.isArray(result.changedRows)
-        ? result.changedRows
-        : [];
-    return {
-        changedTables,
-        changedRows,
-        changedRowsTruncated: result.changedRowsTruncated === true,
-        changedTableCount: changedTables.length,
-        changedRowCount: changedRows.length,
-        bootstrap: objectRecord(result.bootstrap),
-        pushedCommits: typeof result.pushedCommits === 'number' ? result.pushedCommits : 0,
-    };
-}
-function syncScopeRevocationDetails(value) {
-    const result = objectRecord(value);
-    const subscriptions = Array.isArray(result.subscriptions)
-        ? result.subscriptions
-        : [];
-    const revokedSubscriptionIds = subscriptions
-        .filter((subscription) => {
-        return (subscription !== null &&
-            typeof subscription === 'object' &&
-            subscription.status === 'revoked' &&
-            typeof subscription.id === 'string');
-    })
-        .map((subscription) => subscription.id);
-    return revokedSubscriptionIds.length > 0
-        ? {
-            revokedSubscriptionIds,
-            revokedSubscriptionCount: revokedSubscriptionIds.length,
+        if (message.t === 'call') {
+            run(message.id, () => dispatch(message), message.method === 'query'
+                ? (value) => queryTransferables(value)
+                : undefined);
         }
-        : null;
-}
-function diagnosticStatus(error) {
-    const status = syncularErrorStatus(error);
-    return status ? { status } : {};
-}
-function objectRecord(value) {
-    return value && typeof value === 'object'
-        ? value
-        : {};
-}
-function errorMessage(error) {
-    return syncularErrorMessage(error);
-}
-function errorRequiresFullRefresh(error) {
-    return errorMessage(error).includes('full snapshot resync required');
+    });
+    post({ t: 'ready' });
 }
-function encodeWorkerError(error) {
-    if (isWorkerErrorPayload(error) && !(error instanceof Error))
-        return error;
-    if (error instanceof SyncularClientError) {
-        return {
-            code: error.code,
-            message: error.message,
-            category: error.category,
-            retryable: error.retryable,
-            recommendedAction: error.recommendedAction,
-            name: error.name,
-            stack: error.stack,
-            details: error.details,
-        };
+async function defaultOpenDatabase(config) {
+    if (config.database.mode !== 'persistent') {
+        throw new ClientSyncError(WORKER_FAILED_CODE, "database mode 'custom' requires an openDatabase override in the " +
+            'worker bootstrap (startSyncWorker({ openDatabase }))');
     }
-    if (error instanceof Error) {
-        const details = syncularErrorDetails(error);
-        const classification = classifySyncularError(error, error.message, details);
-        if (!classification) {
-            return createSyncularWorkerErrorPayload('worker.failed', error.message, {
-                name: error.name,
-                stack: error.stack,
-                details,
-            });
-        }
-        return {
-            code: classification.code,
-            message: error.message,
-            category: classification.category,
-            retryable: classification.retryable,
-            recommendedAction: classification.recommendedAction,
-            name: error.name,
-            stack: error.stack,
-            details,
-        };
-    }
-    const message = String(error);
-    const classification = classifySyncularError(error, message);
-    if (!classification) {
-        return createSyncularWorkerErrorPayload('worker.failed', message);
-    }
-    return {
-        code: classification.code,
-        message,
-        category: classification.category,
-        retryable: classification.retryable,
-        recommendedAction: classification.recommendedAction,
-    };
-}
-function isWorkerErrorPayload(value) {
-    return Boolean(value && typeof value === 'object' && 'code' in value && 'message' in value);
+    return openPersistentWasmDatabase(config.database.name, {
+        ...(config.database.directory !== undefined
+            ? { directory: config.database.directory }
+            : {}),
+    });
 }
-//# sourceMappingURL=worker-entry.js.map