@sqlite-sync/core 0.8.2 → 0.9.0

package/dist/worker.js

@@ -1,139 +1,99 @@
-import {
-  HLCCounter,
-  SQLiteDbWrapper,
-  applyWorkerDbSchema,
-  createBroadcastChannels,
-  createCrdtStorage,
-  createCrdtSyncProducer,
-  createCrdtSyncRemoteSource,
-  createIdbResetStore,
-  createImportData,
-  createMigrator,
-  createReloadRequestHandler,
-  createResetStateStore,
-  formatSchemaVerificationIssues,
-  isWorkerInitMessage,
-  isWorkerRequestMessage,
-  syncDbClientLockName,
-  syncDbWorkerLockName,
-  verifySyncSchema,
-  workerDbConfig,
-  xxhash
-} from "./chunk-GMF45NFH.js";
-import {
-  createDeferredPromise,
-  jsonSafeParse
-} from "./chunk-NHT3ELMN.js";
-
-// src/web-socket/ws-remote-source.ts
-var createWsRemoteSource = ({ createWebSocket }) => {
-  return async ({ onEventsAvailable }) => {
-    const socket = createWebSocket();
-    const openPromise = createDeferredPromise({
-      timeout: 5e3,
-      onTimeout: () => {
-        socket.close();
-      }
-    });
-    socket.addEventListener("open", () => {
-      openPromise.resolve(void 0);
-    });
-    await openPromise.promise;
-    const requestsMap = /* @__PURE__ */ new Map();
-    const pushEvents = async (request) => {
-      const requestId = crypto.randomUUID();
-      const promise = createDeferredPromise({ timeout: 5e3 });
-      requestsMap.set(requestId, promise);
-      const wsRequest = {
-        type: "push-events",
-        requestId,
-        nodeId: request.nodeId,
-        events: request.events
-      };
-      socket.send(JSON.stringify(wsRequest));
-      return promise.promise;
-    };
-    const pullEvents = async (request) => {
-      const requestId = crypto.randomUUID();
-      const promise = createDeferredPromise({ timeout: 2e3 });
-      requestsMap.set(requestId, promise);
-      const wsRequest = {
-        type: "pull-events",
-        requestId,
-        afterSyncId: request.afterSyncId,
-        excludeNodeId: request.excludeNodeId
-      };
-      socket.send(JSON.stringify(wsRequest));
-      return promise.promise;
-    };
-    socket.onmessage = (event) => {
-      const result = jsonSafeParse(event.data);
-      if (!result.success || !("type" in result.data) || !result.data.type) {
-        return;
-      }
-      const message = result.data;
-      switch (message.type) {
-        case "events-pull-response": {
-          const promise = requestsMap.get(message.requestId);
-          if (!promise) {
-            return;
-          }
-          promise.resolve(message.data);
-          requestsMap.delete(message.requestId);
-          break;
-        }
-        case "events-push-response": {
-          const promise = requestsMap.get(message.requestId);
-          if (!promise) {
-            return;
-          }
-          promise.resolve(message.data);
-          requestsMap.delete(message.requestId);
-          break;
-        }
-        case "events-applied":
-          onEventsAvailable({ newSyncId: message.newSyncId, remoteEventHlcSum: message.eventHlcSum });
-          break;
-        default:
-          message;
-          return;
-      }
-    };
-    return {
-      pushEvents,
-      pullEvents,
-      disconnect: () => {
-        socket.close();
-      }
-    };
-  };
-};
-
-// src/worker-db/db-worker.ts
+import { C as createMigrator, D as HLCCounter, N as createImportData, a as createBroadcastChannels, d as syncDbClientLockName, f as syncDbWorkerLockName, h as createCrdtStorage, i as createResetStateStore, j as xxhash, l as isWorkerRequestMessage, m as createCrdtSyncProducer, n as createIdbResetStore, p as createCrdtSyncRemoteSource, r as createReloadRequestHandler, s as isWorkerInitMessage, v as formatSchemaVerificationIssues, w as SQLiteDbWrapper, y as verifySyncSchema } from "./reset-state-D3nsfx_t.js";
+import { r as createDeferredPromise, s as jsonSafeParse } from "./utils-Dr5JwcTP.js";
+import { n as applyWorkerDbSchema, s as workerDbConfig } from "./system-schema-CkglcfTS.js";
 import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
-
-// src/worker-db/event-log-gc.ts
-var WORKER_EVENT_LOG_GC_MIN_RETAINED_EVENTS = 100;
+//#region src/web-socket/ws-remote-source.ts
+const createWsRemoteSource = ({ createWebSocket }) => {
+	return async ({ onEventsAvailable }) => {
+		const socket = createWebSocket();
+		const openPromise = createDeferredPromise({
+			timeout: 5e3,
+			onTimeout: () => {
+				socket.close();
+			}
+		});
+		socket.addEventListener("open", () => {
+			openPromise.resolve(void 0);
+		});
+		await openPromise.promise;
+		const requestsMap = /* @__PURE__ */ new Map();
+		const pushEvents = async (request) => {
+			const requestId = crypto.randomUUID();
+			const promise = createDeferredPromise({ timeout: 5e3 });
+			requestsMap.set(requestId, promise);
+			const wsRequest = {
+				type: "push-events",
+				requestId,
+				nodeId: request.nodeId,
+				events: request.events
+			};
+			socket.send(JSON.stringify(wsRequest));
+			return promise.promise;
+		};
+		const pullEvents = async (request) => {
+			const requestId = crypto.randomUUID();
+			const promise = createDeferredPromise({ timeout: 2e3 });
+			requestsMap.set(requestId, promise);
+			const wsRequest = {
+				type: "pull-events",
+				requestId,
+				afterSyncId: request.afterSyncId,
+				excludeNodeId: request.excludeNodeId
+			};
+			socket.send(JSON.stringify(wsRequest));
+			return promise.promise;
+		};
+		socket.onmessage = (event) => {
+			const result = jsonSafeParse(event.data);
+			if (!result.success || !("type" in result.data) || !result.data.type) return;
+			const message = result.data;
+			switch (message.type) {
+				case "events-pull-response": {
+					const promise = requestsMap.get(message.requestId);
+					if (!promise) return;
+					promise.resolve(message.data);
+					requestsMap.delete(message.requestId);
+					break;
+				}
+				case "events-push-response": {
+					const promise = requestsMap.get(message.requestId);
+					if (!promise) return;
+					promise.resolve(message.data);
+					requestsMap.delete(message.requestId);
+					break;
+				}
+				case "events-applied":
+					onEventsAvailable({
+						newSyncId: message.newSyncId,
+						remoteEventHlcSum: message.eventHlcSum
+					});
+					break;
+				default: return;
+			}
+		};
+		return {
+			pushEvents,
+			pullEvents,
+			disconnect: () => {
+				socket.close();
+			}
+		};
+	};
+};
 function runWorkerEventLogGc({ db, dbConfig, pushSyncId, eventHlcAccumulator, logger }) {
-  const eventsTable = dbConfig.eventsTable.fullIdentifier;
-  if (eventHlcAccumulator.current === "") {
-    const [{ count }] = db.executePreparedRaw({
-      key: "event-log-gc-count-applied-events",
-      sql: `SELECT count(*) AS count FROM ${eventsTable} WHERE "status" = 'applied'`,
-      meta: { loggerLevel: "system" }
-    });
-    if (count > 0) {
-      logger?.(
-        "worker",
-        "Skipping event log GC until the event HLC checksum has been computed from full history",
-        "info"
-      );
-    }
-    return { skipped: true };
-  }
-  const [{ deleteBeforeSyncId }] = db.executePreparedRaw({
-    key: "event-log-gc-delete-before-sync-id",
-    sql: `
+	const eventsTable = dbConfig.eventsTable.fullIdentifier;
+	if (eventHlcAccumulator.current === "") {
+		const [{ count }] = db.executePreparedRaw({
+			key: "event-log-gc-count-applied-events",
+			sql: `SELECT count(*) AS count FROM ${eventsTable} WHERE "status" = 'applied'`,
+			meta: { loggerLevel: "system" }
+		});
+		if (count > 0) logger?.("worker", "Skipping event log GC until the event HLC checksum has been computed from full history", "info");
+		return { skipped: true };
+	}
+	const [{ deleteBeforeSyncId }] = db.executePreparedRaw({
+		key: "event-log-gc-delete-before-sync-id",
+		sql: `
       SELECT min("sync_id") AS deleteBeforeSyncId
       FROM (
         SELECT "sync_id"
@@ -143,369 +103,329 @@ function runWorkerEventLogGc({ db, dbConfig, pushSyncId, eventHlcAccumulator, lo
         LIMIT ?
       )
     `,
-    params: [WORKER_EVENT_LOG_GC_MIN_RETAINED_EVENTS],
-    meta: { loggerLevel: "system" }
-  });
-  if (deleteBeforeSyncId === null) {
-    return { skipped: false };
-  }
-  db.executePreparedRaw({
-    key: "event-log-gc-delete-events",
-    sql: `
+		params: [100],
+		meta: { loggerLevel: "system" }
+	});
+	if (deleteBeforeSyncId === null) return { skipped: false };
+	db.executePreparedRaw({
+		key: "event-log-gc-delete-events",
+		sql: `
       DELETE FROM ${eventsTable}
       WHERE "sync_id" < ?
         AND "status" IN ('applied', 'deduped')
         AND ("origin" = 'remote' OR "sync_id" <= ?)
     `,
-    params: [deleteBeforeSyncId, pushSyncId.current],
-    meta: { loggerLevel: "system" }
-  });
-  logger?.("worker", "Event log GC completed", "info");
-  return { skipped: false };
+		params: [deleteBeforeSyncId, pushSyncId.current],
+		meta: { loggerLevel: "system" }
+	});
+	logger?.("worker", "Event log GC completed", "info");
+	return { skipped: false };
 }
-
-// src/worker-db/storage-version.ts
-var LIB_STORAGE_VERSION = 1;
-var storageVersionKey = (dbId) => `sqlite-sync-storage-version-${dbId}`;
+const storageVersionKey = (dbId) => `sqlite-sync-storage-version-${dbId}`;
 function formatStorageVersion(appStorageVersion) {
-  return appStorageVersion === void 0 ? `lib-v${LIB_STORAGE_VERSION}` : `lib-v${LIB_STORAGE_VERSION}:app-${appStorageVersion}`;
+	return appStorageVersion === void 0 ? `lib-v2` : `lib-v2:app-${appStorageVersion}`;
 }
+/**
+* Worker-owned durable storage version. The current version combines the
+* internal lib version with the dev-provided app version; when the stored
+* version does not match (including a missing record), the elected worker
+* initializes with `clearOnInit: true`. Wiping on a missing record is
+* harmless for fresh installs and correctly resets databases persisted
+* before versioning existed.
+*/
 function createStorageVersionStore({ store, dbId, appStorageVersion }) {
-  const key = storageVersionKey(dbId);
-  const currentVersion = formatStorageVersion(appStorageVersion);
-  return {
-    currentVersion,
-    async isVersionMismatch() {
-      const storedVersion = await store.get(key);
-      return storedVersion !== currentVersion;
-    },
-    /**
-     * Record the current version. Must be called only after the worker has
-     * successfully initialized with the wiped DB, so a failed init can be
-     * retried by a later elected worker.
-     */
-    async markCurrentVersionApplied() {
-      await store.set(key, currentVersion);
-    }
-  };
+	const key = storageVersionKey(dbId);
+	const currentVersion = formatStorageVersion(appStorageVersion);
+	return {
+		currentVersion,
+		async isVersionMismatch() {
+			return await store.get(key) !== currentVersion;
+		},
+		/**
+		* Record the current version. Must be called only after the worker has
+		* successfully initialized with the wiped DB, so a failed init can be
+		* retried by a later elected worker.
+		*/
+		async markCurrentVersionApplied() {
+			await store.set(key, currentVersion);
+		}
+	};
 }
-
-// src/worker-db/db-worker.ts
-var defaultLogger = (type, message, level = "info") => {
-  const logMessage = `[${type}] ${message}`;
-  switch (level) {
-    case "info":
-      console.log(logMessage);
-      break;
-    case "warning":
-      console.warn(logMessage);
-      break;
-    case "error":
-      console.error(logMessage);
-      break;
-    case "trace":
-      console.trace(logMessage);
-      break;
-  }
+//#endregion
+//#region src/worker-db/db-worker.ts
+const defaultLogger = (type, message, level = "info") => {
+	const logMessage = `[${type}] ${message}`;
+	switch (level) {
+		case "info":
+			console.log(logMessage);
+			break;
+		case "warning":
+			console.warn(logMessage);
+			break;
+		case "error":
+			console.error(logMessage);
+			break;
+		case "trace": console.trace(logMessage);
+	}
 };
 async function createDbWorker(config, opts) {
-  const broadcastChannels = createBroadcastChannels(config.dbId);
-  const logger = opts.logger ?? defaultLogger;
-  if (opts.verifySchema) {
-    const issues = await verifySyncSchema(opts.syncDbSchema);
-    if (issues.length > 0) {
-      throw new Error(formatSchemaVerificationIssues(issues));
-    }
-    logger("worker", "Schema verification passed: migrations match the declared schema", "info");
-  }
-  const [sqlite3] = await Promise.all([sqlite3InitModule(), xxhash.ensureLoaded()]);
-  const resetStore = opts.resetStore ?? createIdbResetStore();
-  const resetState = createResetStateStore({
-    store: resetStore,
-    dbId: config.dbId
-  });
-  const storageVersion = createStorageVersionStore({
-    store: resetStore,
-    dbId: config.dbId,
-    appStorageVersion: opts.storageVersion
-  });
-  const [pendingReset, isVersionMismatch] = await Promise.all([
-    resetState.resolvePendingReset(),
-    storageVersion.isVersionMismatch()
-  ]);
-  if (isVersionMismatch) {
-    logger("worker", `Storage version mismatch \u2014 resetting local DB to ${storageVersion.currentVersion}`, "warning");
-  }
-  const pool = await sqlite3.installOpfsSAHPoolVfs({
-    name: config.dbId,
-    directory: `.${config.dbId}`,
-    clearOnInit: !!pendingReset || isVersionMismatch,
-    initialCapacity: 8
-  });
-  const db = new SQLiteDbWrapper({
-    db: () => new pool.OpfsSAHPoolDb(`/${config.dbId}-main.db`),
-    logger,
-    loggerPrefix: "worker",
-    sqlite3
-  });
-  db.execute("PRAGMA locking_mode=exclusive", { loggerLevel: "system" });
-  db.execute("PRAGMA journal_mode=WAL", { loggerLevel: "system" });
-  db.execute("PRAGMA synchronous=NORMAL", { loggerLevel: "system" });
-  db.execute(`ATTACH DATABASE '/${config.dbId}-worker.db' as worker`, { loggerLevel: "system" });
-  db.execute("PRAGMA worker.locking_mode=exclusive", { loggerLevel: "system" });
-  db.execute("PRAGMA worker.journal_mode=WAL", { loggerLevel: "system" });
-  db.execute("PRAGMA worker.synchronous=NORMAL", { loggerLevel: "system" });
-  const { kvStore } = applyWorkerDbSchema(db);
-  const migrator = createMigrator({
-    migrations: opts.syncDbSchema.migrations,
-    schemaVersion: kvStore.createNumberStoredValue("schema-version", -1),
-    updateLogTableName: workerDbConfig.updateLogTable.fullIdentifier
-  });
-  migrator.migrateDbToLatest({
-    startTransaction: (callback) => {
-      db.executeTransaction(
-        (tx) => callback({ execute: (sql, parameters, meta) => tx.execute({ sql, parameters }, meta) })
-      );
-    }
-  });
-  db.invalidateDbSchema();
-  const pullSyncId = kvStore.createNumberStoredValue("pull-sync-id", -1);
-  const pushSyncId = kvStore.createNumberStoredValue("push-sync-id", -1);
-  const eventHlcAccumulator = kvStore.createStringStoredValue("crdt.consistency.event_hlc_sum.v2", "");
-  if (pendingReset) {
-    await resetState.markResetApplied(pendingReset.epoch);
-  }
-  if (isVersionMismatch) {
-    await storageVersion.markCurrentVersionApplied();
-  }
-  if (opts.eventLogGc === true) {
-    runWorkerEventLogGc({
-      db,
-      dbConfig: workerDbConfig,
-      pushSyncId,
-      eventHlcAccumulator,
-      logger
-    });
-  }
-  const crdtStorage = createCrdtStorage({
-    nodeId: config.clientId,
-    initialLocalSyncId: getMaxSyncId(db, "none"),
-    migrator,
-    hlc: new HLCCounter(config.clientId, () => Date.now()),
-    db,
-    dbConfig: workerDbConfig,
-    eventHlcAccumulator,
-    schema: opts.syncDbSchema
-  });
-  createCrdtSyncProducer({
-    storage: crdtStorage,
-    broadcastEvents: (chunk) => {
-      broadcastChannels.responses.postMessage({
-        notificationType: "new-event-chunk-applied",
-        newSyncId: chunk.newSyncId,
-        eventHlcSum: chunk.eventHlcSum
-      });
-    }
-  });
-  const remoteSource = createRemoteSource({
-    crdtStorage,
-    migrator,
-    clientId: config.clientId,
-    pullSyncId,
-    pushSyncId,
-    remoteFactory: opts.createRemoteSource
-  });
-  remoteSource.goOnline();
-  const broadcastNotification = (notification) => {
-    broadcastChannels.responses.postMessage(notification);
-  };
-  const postState = () => {
-    broadcastNotification({
-      notificationType: "state-changed",
-      state: remoteSource.getState()
-    });
-  };
-  const stateChangedSubscription = remoteSource.addEventListener("state-changed", () => {
-    postState();
-  });
-  const deSyncDetectedSubscription = remoteSource.addEventListener("de-sync-detected", (event) => {
-    broadcastNotification({
-      notificationType: "de-sync-detected",
-      reason: event.payload.reason
-    });
-  });
-  const remoteSchemaVersionMismatchSubscription = remoteSource.addEventListener(
-    "remote-schema-version-mismatch",
-    (event) => {
-      broadcastNotification({
-        notificationType: "remote-schema-version-mismatch",
-        remoteSchemaVersion: event.payload.remoteSchemaVersion,
-        localSchemaVersion: event.payload.localSchemaVersion
-      });
-    }
-  );
-  const rpcTarget = {
-    execute: (query) => db.execute(query),
-    getSnapshot: () => {
-      const appliedSyncId = getMaxSyncId(db, "pending");
-      db.execute("PRAGMA journal_mode=off", { loggerLevel: "system" });
-      const file = db.createSnapshot();
-      db.execute("PRAGMA journal_mode=WAL", { loggerLevel: "system" });
-      return {
-        file,
-        syncId: appliedSyncId,
-        schemaVersion: migrator.currentSchemaVersion
-      };
-    },
-    importData: createImportData({
-      migrator,
-      tablesConfig: opts.syncDbSchema.tablesConfig,
-      applyEvents: async (events) => {
-        crdtStorage.applyOwnEvents(events);
-        await crdtStorage.internal.processEnqueuedEvents();
-      }
-    }),
-    postState,
-    pushTabEvents: (request) => {
-      const { beforeSyncId, afterSyncId } = crdtStorage.enqueueLocalEvents(request.events, request.nodeId);
-      return {
-        ok: true,
-        beforeSyncId,
-        afterSyncId
-      };
-    },
-    pullEvents: (request) => {
-      return crdtStorage.getEventsBatch({
-        afterSyncId: request.afterSyncId,
-        status: "applied",
-        excludeNodeId: request.excludeNodeId ?? "",
-        limit: 100
-      });
-    },
-    goOnline: () => remoteSource.goOnline(),
-    goOffline: () => remoteSource.goOffline("DISCONNECTED"),
-    requestReload: createReloadRequestHandler({
-      resetState,
-      broadcast: broadcastNotification
-    })
-  };
-  broadcastChannels.requests.onmessage = (event) => {
-    const message = event.data;
-    if (!isWorkerRequestMessage(message)) {
-      return;
-    }
-    const sendError = (error) => {
-      const response = {
-        type: "error-response",
-        requestId: message.requestId,
-        error: error instanceof Error ? error.message : String(error)
-      };
-      broadcastChannels.responses.postMessage(response);
-    };
-    try {
-      const method = rpcTarget[message.method];
-      const data = method.apply(null, message.args);
-      if (data instanceof Promise) {
-        data.then((result) => {
-          const response = {
-            type: "response",
-            requestId: message.requestId,
-            data: result
-          };
-          broadcastChannels.responses.postMessage(response);
-        }).catch(sendError);
-      } else {
-        const response = {
-          type: "response",
-          requestId: message.requestId,
-          data
-        };
-        broadcastChannels.responses.postMessage(response);
-      }
-    } catch (error) {
-      sendError(error);
-    }
-  };
-  rpcTarget.postState();
-  return async () => {
-    stateChangedSubscription.unsubscribe();
-    deSyncDetectedSubscription.unsubscribe();
-    remoteSchemaVersionMismatchSubscription.unsubscribe();
-    await remoteSource.dispose();
-    broadcastChannels.requests.close();
-    broadcastChannels.responses.close();
-    db.close();
-  };
+	const broadcastChannels = createBroadcastChannels(config.dbId);
+	const logger = opts.logger ?? defaultLogger;
+	if (opts.verifySchema) {
+		const issues = await verifySyncSchema(opts.syncDbSchema);
+		if (issues.length > 0) throw new Error(formatSchemaVerificationIssues(issues));
+		logger("worker", "Schema verification passed: migrations match the declared schema", "info");
+	}
+	const [sqlite3] = await Promise.all([sqlite3InitModule(), xxhash.ensureLoaded()]);
+	const resetStore = opts.resetStore ?? createIdbResetStore();
+	const resetState = createResetStateStore({
+		store: resetStore,
+		dbId: config.dbId
+	});
+	const storageVersion = createStorageVersionStore({
+		store: resetStore,
+		dbId: config.dbId,
+		appStorageVersion: opts.storageVersion
+	});
+	const [pendingReset, isVersionMismatch] = await Promise.all([resetState.resolvePendingReset(), storageVersion.isVersionMismatch()]);
+	if (isVersionMismatch) logger("worker", `Storage version mismatch — resetting local DB to ${storageVersion.currentVersion}`, "warning");
+	const pool = await sqlite3.installOpfsSAHPoolVfs({
+		name: config.dbId,
+		directory: `.${config.dbId}`,
+		clearOnInit: !!pendingReset || isVersionMismatch,
+		initialCapacity: 8
+	});
+	const db = new SQLiteDbWrapper({
+		db: () => new pool.OpfsSAHPoolDb(`/${config.dbId}-main.db`),
+		logger,
+		loggerPrefix: "worker",
+		sqlite3
+	});
+	db.execute("PRAGMA locking_mode=exclusive", { loggerLevel: "system" });
+	db.execute("PRAGMA journal_mode=WAL", { loggerLevel: "system" });
+	db.execute("PRAGMA synchronous=NORMAL", { loggerLevel: "system" });
+	db.execute(`ATTACH DATABASE '/${config.dbId}-worker.db' as worker`, { loggerLevel: "system" });
+	db.execute("PRAGMA worker.locking_mode=exclusive", { loggerLevel: "system" });
+	db.execute("PRAGMA worker.journal_mode=WAL", { loggerLevel: "system" });
+	db.execute("PRAGMA worker.synchronous=NORMAL", { loggerLevel: "system" });
+	const { kvStore } = applyWorkerDbSchema(db);
+	const migrator = createMigrator({
+		migrations: opts.syncDbSchema.migrations,
+		schemaVersion: kvStore.createNumberStoredValue("schema-version", -1),
+		updateLogTableName: workerDbConfig.updateLogTable.fullIdentifier
+	});
+	migrator.migrateDbToLatest({ startTransaction: (callback) => {
+		db.executeTransaction((tx) => callback({ execute: (sql, parameters, meta) => tx.execute({
+			sql,
+			parameters
+		}, meta) }));
+	} });
+	db.invalidateDbSchema();
+	const pullSyncId = kvStore.createNumberStoredValue("pull-sync-id", -1);
+	const pushSyncId = kvStore.createNumberStoredValue("push-sync-id", -1);
+	const eventHlcAccumulator = kvStore.createStringStoredValue("crdt.consistency.event_hlc_sum.v2", "");
+	if (pendingReset) await resetState.markResetApplied(pendingReset.epoch);
+	if (isVersionMismatch) await storageVersion.markCurrentVersionApplied();
+	if (opts.eventLogGc === true) runWorkerEventLogGc({
+		db,
+		dbConfig: workerDbConfig,
+		pushSyncId,
+		eventHlcAccumulator,
+		logger
+	});
+	const crdtStorage = createCrdtStorage({
+		nodeId: config.clientId,
+		initialLocalSyncId: getMaxSyncId(db, "none"),
+		migrator,
+		hlc: new HLCCounter(config.clientId, () => Date.now()),
+		db,
+		dbConfig: workerDbConfig,
+		eventHlcAccumulator,
+		schema: opts.syncDbSchema
+	});
+	createCrdtSyncProducer({
+		storage: crdtStorage,
+		broadcastEvents: (chunk) => {
+			broadcastChannels.responses.postMessage({
+				notificationType: "new-event-chunk-applied",
+				newSyncId: chunk.newSyncId,
+				eventHlcSum: chunk.eventHlcSum
+			});
+		}
+	});
+	const remoteSource = createRemoteSource({
+		crdtStorage,
+		migrator,
+		clientId: config.clientId,
+		pullSyncId,
+		pushSyncId,
+		remoteFactory: opts.createRemoteSource
+	});
+	remoteSource.goOnline();
+	const broadcastNotification = (notification) => {
+		broadcastChannels.responses.postMessage(notification);
+	};
+	const postState = () => {
+		broadcastNotification({
+			notificationType: "state-changed",
+			state: remoteSource.getState()
+		});
+	};
+	const stateChangedSubscription = remoteSource.addEventListener("state-changed", () => {
+		postState();
+	});
+	const deSyncDetectedSubscription = remoteSource.addEventListener("de-sync-detected", (event) => {
+		broadcastNotification({
+			notificationType: "de-sync-detected",
+			reason: event.payload.reason
+		});
+	});
+	const remoteSchemaVersionMismatchSubscription = remoteSource.addEventListener("remote-schema-version-mismatch", (event) => {
+		broadcastNotification({
+			notificationType: "remote-schema-version-mismatch",
+			remoteSchemaVersion: event.payload.remoteSchemaVersion,
+			localSchemaVersion: event.payload.localSchemaVersion
+		});
+	});
+	const rpcTarget = {
+		execute: (query) => db.execute(query),
+		getSnapshot: () => {
+			const appliedSyncId = getMaxSyncId(db, "pending");
+			db.execute("PRAGMA journal_mode=off", { loggerLevel: "system" });
+			const file = db.createSnapshot();
+			db.execute("PRAGMA journal_mode=WAL", { loggerLevel: "system" });
+			return {
+				file,
+				syncId: appliedSyncId,
+				schemaVersion: migrator.currentSchemaVersion
+			};
+		},
+		importData: createImportData({
+			migrator,
+			tablesConfig: opts.syncDbSchema.tablesConfig,
+			applyEvents: async (events) => {
+				crdtStorage.applyOwnEvents(events);
+				await crdtStorage.internal.processEnqueuedEvents();
+			}
+		}),
+		postState,
+		pushTabEvents: (request) => {
+			const { beforeSyncId, afterSyncId } = crdtStorage.enqueueLocalEvents(request.events, request.nodeId);
+			return {
+				ok: true,
+				beforeSyncId,
+				afterSyncId
+			};
+		},
+		pullEvents: (request) => {
+			return crdtStorage.getEventsBatch({
+				afterSyncId: request.afterSyncId,
+				status: "applied",
+				excludeNodeId: request.excludeNodeId ?? "",
+				limit: 100
+			});
+		},
+		goOnline: () => remoteSource.goOnline(),
+		goOffline: () => remoteSource.goOffline("DISCONNECTED"),
+		requestReload: createReloadRequestHandler({
+			resetState,
+			broadcast: broadcastNotification
+		})
+	};
+	broadcastChannels.requests.onmessage = (event) => {
+		const message = event.data;
+		if (!isWorkerRequestMessage(message)) return;
+		const sendError = (error) => {
+			const response = {
+				type: "error-response",
+				requestId: message.requestId,
+				error: error instanceof Error ? error.message : String(error)
+			};
+			broadcastChannels.responses.postMessage(response);
+		};
+		try {
+			const data = rpcTarget[message.method].apply(null, message.args);
+			if (data instanceof Promise) data.then((result) => {
+				const response = {
+					type: "response",
+					requestId: message.requestId,
+					data: result
+				};
+				broadcastChannels.responses.postMessage(response);
+			}).catch(sendError);
+			else {
+				const response = {
+					type: "response",
+					requestId: message.requestId,
+					data
+				};
+				broadcastChannels.responses.postMessage(response);
+			}
+		} catch (error) {
+			sendError(error);
+		}
+	};
+	rpcTarget.postState();
+	return async () => {
+		stateChangedSubscription.unsubscribe();
+		deSyncDetectedSubscription.unsubscribe();
+		remoteSchemaVersionMismatchSubscription.unsubscribe();
+		await remoteSource.dispose();
+		broadcastChannels.requests.close();
+		broadcastChannels.responses.close();
+		db.close();
+	};
 }
-function createRemoteSource({
-  clientId,
-  crdtStorage,
-  migrator,
-  pullSyncId,
-  pushSyncId,
-  remoteFactory
-}) {
-  return createCrdtSyncRemoteSource({
-    bufferSize: 50,
-    pullSyncId,
-    pushSyncId,
-    nodeId: clientId,
-    storage: crdtStorage,
-    migrator,
-    remoteFactory
-  });
+function createRemoteSource({ clientId, crdtStorage, migrator, pullSyncId, pushSyncId, remoteFactory }) {
+	return createCrdtSyncRemoteSource({
+		bufferSize: 50,
+		pullSyncId,
+		pushSyncId,
+		nodeId: clientId,
+		storage: crdtStorage,
+		migrator,
+		remoteFactory
+	});
 }
 async function getWorkerConfig() {
-  let configSet = false;
-  const responsePromise = createDeferredPromise();
-  self.onmessage = (event) => {
-    if (configSet) {
-      console.error("Worker config already set");
-      return;
-    }
-    const message = event.data;
-    if (!isWorkerInitMessage(message)) {
-      return;
-    }
-    responsePromise.resolve(message.config);
-    configSet = true;
-  };
-  return responsePromise.promise;
+	let configSet = false;
+	const responsePromise = createDeferredPromise();
+	self.onmessage = (event) => {
+		if (configSet) {
+			console.error("Worker config already set");
+			return;
+		}
+		const message = event.data;
+		if (!isWorkerInitMessage(message)) return;
+		responsePromise.resolve(message.config);
+		configSet = true;
+	};
+	return responsePromise.promise;
 }
 async function startDbWorker(opts) {
-  const config = opts.workerConfig ?? await getWorkerConfig();
-  await navigator.locks.request(`${syncDbWorkerLockName}-${config.dbId}`, { mode: "exclusive" }, async (lock) => {
-    if (!lock) {
-      return;
-    }
-    const cleanup = await createDbWorker(config, opts);
-    const clientLockName = `${syncDbClientLockName}-${config.dbId}`;
-    await new Promise((resolve) => {
-      const interval = setInterval(async () => {
-        const { held } = await navigator.locks.query();
-        const hasClients = held?.some((l) => l.name === clientLockName && l.mode === "shared");
-        if (!hasClients) {
-          clearInterval(interval);
-          resolve();
-        }
-      }, 5e3);
-    });
-    await cleanup();
-  });
-  self.close();
+	const config = opts.workerConfig ?? await getWorkerConfig();
+	await navigator.locks.request(`${syncDbWorkerLockName}-${config.dbId}`, { mode: "exclusive" }, async (lock) => {
+		if (!lock) return;
+		const cleanup = await createDbWorker(config, opts);
+		const clientLockName = `${syncDbClientLockName}-${config.dbId}`;
+		await new Promise((resolve) => {
+			const interval = setInterval(async () => {
+				const { held } = await navigator.locks.query();
+				if (!held?.some((l) => l.name === clientLockName && l.mode === "shared")) {
+					clearInterval(interval);
+					resolve();
+				}
+			}, 5e3);
+		});
+		await cleanup();
+	});
+	self.close();
 }
 function getMaxSyncId(db, excludingStatus) {
-  const [result] = db.executePrepared(
-    "get-max-sync-id",
-    { excludingStatus },
-    (db2, params) => db2.selectFrom("worker.crdt_events").where("status", "!=", params("excludingStatus")).select((eb) => eb.fn.max("sync_id").as("sync_id")),
-    { loggerLevel: "system" }
-  );
-  return result?.sync_id ?? 0;
+	const [result] = db.executePrepared("get-max-sync-id", { excludingStatus }, (db, params) => db.selectFrom("worker.crdt_events").where("status", "!=", params("excludingStatus")).select((eb) => eb.fn.max("sync_id").as("sync_id")), { loggerLevel: "system" });
+	return result?.sync_id ?? 0;
 }
-export {
-  createWsRemoteSource,
-  getWorkerConfig,
-  startDbWorker
-};
+//#endregion
+export { createWsRemoteSource, getWorkerConfig, startDbWorker };
+
 //# sourceMappingURL=worker.js.map