@sqlite-sync/core 0.12.0 → 0.12.1

package/dist/index.js

@@ -1,9 +1,9 @@
-import { C as introspectDb, D as dummyKysely, E as createImportData, S as startPerformanceLogger, T as createExportData, _ as formatSchemaVerificationIssues, a as createBroadcastChannels, b as createMigrator, c as isWorkerNotificationMessage, d as syncDbClientLockName, g as createSQLiteCrdtApplyFunction, h as createCrdtApplyFunction, m as createCrdtStorage, o as isWorkerErrorResponseMessage, p as createCrdtSyncProducer, t as RESET_REQUEST_TTL_MS, u as isWorkerResponseMessage, v as verifySyncSchema, w as xxhash, x as SQLiteDbWrapper, y as createMigrations } from "./reset-state-BQi96NLn.js";
-import { a as createDeferredPromise, c as generateId, f as quoteId, i as TypedEvent, l as jsonSafeParse, m as tryCatchAsync, n as isNoOpCrdtEventPayload, o as createTypedEventTarget, p as tryCatch, r as TypedBroadcastChannel, t as CRDT_EVENT_NO_OP_PAYLOAD, u as noop } from "./crdt-table-schema-2w_AIpsV.js";
-import { a as HLCCounter, c as serializeHLC, n as CrdtEventValidationError, o as compareHLC, r as validateNewCrdtEvent, s as deserializeHLC, t as createCrdtSyncRemoteSource } from "./crdt-sync-remote-source-Q6P6OiL0.js";
-import { a as memoryDbConfig, c as createKvStoreTableQuery, l as createSQLiteKvStore, n as applyWorkerDbSchema, t as applyMemoryDbSchema, u as createStoredValue } from "./system-schema-C2JZDv6L.js";
+import { a as memoryDbConfig, c as createKvStoreTableQuery, d as SQLiteDbWrapper, h as dummyKysely, l as createSQLiteKvStore, m as introspectDb, n as applyWorkerDbSchema, p as startPerformanceLogger, t as applyMemoryDbSchema, u as createStoredValue } from "./system-schema-Dvl_BLId.js";
+import { a as acquireLock, d as noop, h as tryCatchAsync, i as TypedEvent, l as generateId, m as tryCatch, n as isNoOpCrdtEventPayload, o as createDeferredPromise, p as quoteId, r as TypedBroadcastChannel, s as createTypedEventTarget, t as CRDT_EVENT_NO_OP_PAYLOAD, u as jsonSafeParse } from "./crdt-table-schema-BRm_WdcW.js";
+import { C as xxhash, S as createMigrator, T as createImportData, _ as createCrdtApplyFunction, a as acquireReplicaLock, b as verifySyncSchema, c as isWorkerErrorResponseMessage, f as isWorkerResponseMessage, g as createCrdtStorage, h as createCrdtSyncProducer, p as syncDbClientLockName, s as createBroadcastChannels, t as RESET_REQUEST_TTL_MS, u as isWorkerNotificationMessage, v as createSQLiteCrdtApplyFunction, w as createExportData, x as createMigrations, y as formatSchemaVerificationIssues } from "./reset-state-t0tTGqoh.js";
+import { a as HLCCounter, c as serializeHLC, n as CrdtEventValidationError, o as compareHLC, r as validateNewCrdtEvent, s as deserializeHLC, t as createCrdtSyncRemoteSource } from "./crdt-sync-remote-source-CPXzmSIS.js";
 import { n as buildWriteOriginByName, t as admitClientEvents } from "./admit-client-events-BDrJw4SK.js";
-import { a as makeCrdtTable, o as registerCrdtIntentDrainer } from "./make-crdt-table-D8VQ-ptj.js";
+import { a as makeCrdtTable, o as registerCrdtIntentDrainer } from "./make-crdt-table-C6l0F-o_.js";
 import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
 //#region src/bound-map.ts
 var BoundMap = class {
@@ -689,18 +689,22 @@ const createWorkerDbClient = async ({ broadcastChannels, worker, config }) => {
 	const queryWorker = (method, args) => {
 		if (isDisposed) return Promise.reject(/* @__PURE__ */ new Error("Worker client disposed"));
 		const requestId = crypto.randomUUID();
-		const promise = createDeferredPromise({
-			timeout: 3e4,
-			onTimeout: () => workerRequestsMap.delete(requestId)
-		});
-		workerRequestsMap.set(requestId, promise);
 		const request = {
 			type: "request",
 			requestId,
 			method,
 			args
 		};
-		broadcastChannels.requests.postMessage(request);
+		try {
+			broadcastChannels.requests.postMessage(request);
+		} catch (error) {
+			return Promise.reject(error);
+		}
+		const promise = createDeferredPromise({
+			timeout: 3e4,
+			onTimeout: () => workerRequestsMap.delete(requestId)
+		});
+		workerRequestsMap.set(requestId, promise);
 		return promise.promise;
 	};
 	const handleWorkerResponse = (message) => {
@@ -734,14 +738,6 @@ const createWorkerDbClient = async ({ broadcastChannels, worker, config }) => {
 		sync: () => queryWorker("sync", []),
 		requestReload: (options) => queryWorker("requestReload", [options])
 	};
-	const statePromise = awaitWorkerState(eventTarget);
-	postWorkerConfig(worker, config);
-	rpc.postState().catch(noop);
-	let { state: workerState, storageGeneration } = await statePromise;
-	eventTarget.addEventListener("state-changed", (event) => {
-		workerState = event.payload.state;
-		storageGeneration = event.payload.storageGeneration;
-	});
 	const dispose = () => {
 		isDisposed = true;
 		broadcastChannels.responses.onmessage = null;
@@ -750,13 +746,25 @@ const createWorkerDbClient = async ({ broadcastChannels, worker, config }) => {
 			workerRequestsMap.delete(id);
 		}
 	};
-	return {
-		...rpc,
-		subscribe: eventTarget.addEventListener,
-		getState: () => workerState,
-		getStorageGeneration: () => storageGeneration,
-		dispose
-	};
+	try {
+		postWorkerConfig(worker, config);
+		rpc.postState().catch(noop);
+		let { state: workerState, storageGeneration } = await awaitWorkerState(eventTarget);
+		eventTarget.addEventListener("state-changed", (event) => {
+			workerState = event.payload.state;
+			storageGeneration = event.payload.storageGeneration;
+		});
+		return {
+			...rpc,
+			subscribe: eventTarget.addEventListener,
+			getState: () => workerState,
+			getStorageGeneration: () => storageGeneration,
+			dispose
+		};
+	} catch (error) {
+		dispose();
+		throw error;
+	}
 };
 function awaitWorkerState(eventTarget) {
 	const promise = createDeferredPromise({ timeout: 15e3 });
@@ -822,173 +830,191 @@ async function createSyncedDb(options) {
 	const instanceId = generateId();
 	const tabId = generateId();
 	const broadcastChannels = createBroadcastChannels(options.dbId);
-	const clientLockAcquired = createDeferredPromise();
-	const clientLockRelease = createDeferredPromise();
-	navigator.locks.request(`${syncDbClientLockName}-${options.dbId}`, { mode: "shared" }, () => {
-		clientLockAcquired.resolve();
-		return clientLockRelease.promise;
-	});
-	await clientLockAcquired.promise;
-	const workerClient = await createWorkerDbClient({
-		worker: options.worker,
-		config: {
-			clientId: generateId(),
-			dbId: options.dbId,
-			props: options.workerProps
-		},
-		broadcastChannels
-	});
-	const hlcCounter = new HLCCounter(tabId, () => Date.now());
-	const workerClientSnapshot = await workerClient.getSnapshot();
-	const reactiveDb = await createSQLiteReactiveDb({
-		snapshot: workerClientSnapshot.file,
-		logger: defaultLogger
-	});
-	const memoryDbMigrator = {
-		currentSchemaVersion: workerClientSnapshot.schemaVersion,
-		latestSchemaVersion: workerClientSnapshot.schemaVersion,
-		migrateDbToLatest: () => {
-			throw new Error("Memory DB migrations are not implemented");
-		},
-		migrateEvent: (event, targetVersion) => {
-			if (event.schema_version === targetVersion) return event;
-			throw new Error("Memory DB migrations are not implemented");
-		},
-		migrateEvents: (events) => events
-	};
-	const { crdtStorage } = await createMemoryDb({
-		nodeId: tabId,
-		migrator: memoryDbMigrator,
-		reactiveDb,
-		hlcCounter,
-		crdtTables: options.syncDbSchema.tablesConfig,
-		syncDbSchema: options.syncDbSchema
-	});
-	const pullSyncId = createStoredValue({ initialValue: workerClientSnapshot.syncId });
-	const pushSyncId = createStoredValue({ initialValue: 0 });
-	const tabRemoteSource = createCrdtSyncRemoteSource({
-		bufferSize: 500,
-		pullSyncId,
-		pushSyncId,
-		storage: crdtStorage,
-		nodeId: tabId,
-		migrator: memoryDbMigrator,
-		remoteFactory: ({ onEventsAvailable }) => {
-			const subscription = workerClient.subscribe("new-event-chunk-applied", (event) => {
-				onEventsAvailable({
-					newSyncId: event.payload.newSyncId,
-					remoteEventHlcSum: event.payload.eventHlcSum
-				});
-			});
-			return {
-				pullEvents: (request) => workerClient.pullEvents(request),
-				pushEvents: (request) => workerClient.pushTabEvents(request),
-				disconnect: () => {
-					subscription.unsubscribe();
-				}
-			};
-		}
-	});
-	tabRemoteSource.goOnline();
-	const reloadRequestedSubscription = workerClient.subscribe("reload-requested", () => {
-		globalThis.location?.reload();
-	});
-	const reloadIfStorageReplaced = (storageGeneration) => {
-		if (storageGeneration !== workerClientSnapshot.storageGeneration) {
-			storageReplacedSubscription.unsubscribe();
-			globalThis.location?.reload();
-		}
-	};
-	const storageReplacedSubscription = workerClient.subscribe("state-changed", (event) => {
-		reloadIfStorageReplaced(event.payload.storageGeneration);
-	});
-	reloadIfStorageReplaced(workerClient.getStorageGeneration());
-	const sync = () => {
-		workerClient.sync().catch((error) => console.warn("Failed to start sync", error));
-	};
-	const syncWhenVisible = () => {
-		if (globalThis.document?.visibilityState === "visible") sync();
-	};
-	const dropConnection = () => {
-		workerClient.dropConnection().catch((error) => console.warn("Failed to drop connection", error));
-	};
-	globalThis.document?.addEventListener("visibilitychange", syncWhenVisible);
-	globalThis.addEventListener?.("online", sync);
-	globalThis.addEventListener?.("offline", dropConnection);
-	perf.logEnd("createSyncedDb", "initialized", "info");
-	const exportData = createExportData({
-		reactiveDb,
-		tablesConfig: options.syncDbSchema.tablesConfig,
-		schemaVersion: workerClientSnapshot.schemaVersion
-	});
-	const importData = (data, opts) => workerClient.importData(data, opts);
-	let isDisposed = false;
+	let releaseClientLock;
+	let disposeWorkerClient;
+	let releaseReplicaLock;
+	let disposeReactiveDb;
+	let disposeRemoteSource;
+	const cleanupCallbacks = [];
 	let unregisterDevtools;
+	let isDisposed = false;
 	const dispose = async () => {
 		if (isDisposed) return;
 		isDisposed = true;
 		unregisterDevtools?.();
-		globalThis.document?.removeEventListener("visibilitychange", syncWhenVisible);
-		globalThis.removeEventListener?.("online", sync);
-		globalThis.removeEventListener?.("offline", dropConnection);
-		reloadRequestedSubscription.unsubscribe();
-		storageReplacedSubscription.unsubscribe();
-		clientLockRelease.resolve();
-		await tabRemoteSource.dispose();
-		broadcastChannels.requests.close();
-		broadcastChannels.responses.close();
-		workerClient.dispose();
-		reactiveDb.dispose();
-	};
-	const syncedDb = {
-		db: createSyncedDbDatabase(reactiveDb),
-		state: {
-			getState: workerClient.getState.bind(workerClient),
-			subscribe: (onChange) => {
-				const { unsubscribe } = workerClient.subscribe("state-changed", onChange);
-				return unsubscribe;
-			},
-			goOnline: workerClient.goOnline.bind(workerClient),
-			goOffline: workerClient.goOffline.bind(workerClient),
-			sync
-		},
-		/**
-		* Ask the elected worker to broadcast a page reload to all tabs for this dbId.
-		*
-		* With `clean: true` the worker durably records a reset request epoch before
-		* broadcasting, so the worker elected on the next startup initializes with
-		* `clearOnInit: true` and wipes the persisted DB. Destructive — use as a
-		* recovery path when the durable worker DB may be de-synced.
-		*
-		* Pending in-memory tab events are not preserved, and the returned promise
-		* may never settle in the caller — the page typically unloads first.
-		*/
-		requestReload: async (options) => {
-			await workerClient.requestReload(options);
-			setTimeout(() => globalThis.location?.reload(), 250);
-		},
-		subscribe: workerClient.subscribe,
-		exportData,
-		importData,
-		dispose,
-		_internal: {
-			executeAsync: workerClient.execute.bind(workerClient),
-			getMemoryQueryTables: reactiveDb.getTablesUsed.bind(reactiveDb),
-			getSharedLiveQueriesSnapshot: reactiveDb.getSharedLiveQueriesSnapshot.bind(reactiveDb),
-			crdtTableNames: options.syncDbSchema.tablesConfig.map((table) => table.crdtTableName),
-			crdtTablesConfig: options.syncDbSchema.tablesConfig,
-			tables: options.syncDbSchema.tables,
-			schemaVersion: workerClientSnapshot.schemaVersion,
-			migrationVersions: Object.keys(options.syncDbSchema.migrations).map(Number).sort((a, b) => a - b)
+		for (const cleanup of cleanupCallbacks) cleanup();
+		try {
+			await disposeRemoteSource?.();
+		} finally {
+			broadcastChannels.requests.close();
+			broadcastChannels.responses.close();
+			disposeWorkerClient?.();
+			try {
+				disposeReactiveDb?.();
+			} finally {
+				await Promise.all([releaseClientLock?.(), releaseReplicaLock?.()]);
+			}
 		}
 	};
-	unregisterDevtools = getOrCreateSQLiteSyncDevtoolsRegistry().register({
-		instanceId,
-		dbId: options.dbId,
-		createdAt: Date.now(),
-		instance: syncedDb
-	});
-	return syncedDb;
+	try {
+		releaseClientLock = await acquireLock(`${syncDbClientLockName}-${options.dbId}`, { mode: "shared" });
+		const workerClient = await createWorkerDbClient({
+			worker: options.worker,
+			config: {
+				clientId: generateId(),
+				dbId: options.dbId,
+				props: options.workerProps
+			},
+			broadcastChannels
+		});
+		disposeWorkerClient = () => workerClient.dispose();
+		const hlcCounter = new HLCCounter(tabId, () => Date.now());
+		releaseReplicaLock = await acquireReplicaLock({ dbId: options.dbId });
+		const workerClientSnapshot = await workerClient.getSnapshot();
+		const reactiveDb = await createSQLiteReactiveDb({
+			snapshot: workerClientSnapshot.file,
+			logger: defaultLogger
+		});
+		disposeReactiveDb = () => reactiveDb.dispose();
+		const memoryDbMigrator = {
+			currentSchemaVersion: workerClientSnapshot.schemaVersion,
+			latestSchemaVersion: workerClientSnapshot.schemaVersion,
+			migrateDbToLatest: () => {
+				throw new Error("Memory DB migrations are not implemented");
+			},
+			migrateEvent: (event, targetVersion) => {
+				if (event.schema_version === targetVersion) return event;
+				throw new Error("Memory DB migrations are not implemented");
+			},
+			migrateEvents: (events) => events
+		};
+		const { crdtStorage } = await createMemoryDb({
+			nodeId: tabId,
+			migrator: memoryDbMigrator,
+			reactiveDb,
+			hlcCounter,
+			crdtTables: options.syncDbSchema.tablesConfig,
+			syncDbSchema: options.syncDbSchema
+		});
+		const pullSyncId = createStoredValue({ initialValue: workerClientSnapshot.syncId });
+		const pushSyncId = createStoredValue({ initialValue: 0 });
+		const tabRemoteSource = createCrdtSyncRemoteSource({
+			bufferSize: 500,
+			pullSyncId,
+			pushSyncId,
+			storage: crdtStorage,
+			nodeId: tabId,
+			migrator: memoryDbMigrator,
+			remoteFactory: ({ onEventsAvailable }) => {
+				const subscription = workerClient.subscribe("new-event-chunk-applied", (event) => {
+					onEventsAvailable({
+						newSyncId: event.payload.newSyncId,
+						remoteEventHlcSum: event.payload.eventHlcSum
+					});
+				});
+				return {
+					pullEvents: (request) => workerClient.pullEvents(request),
+					pushEvents: (request) => workerClient.pushTabEvents(request),
+					disconnect: () => {
+						subscription.unsubscribe();
+					}
+				};
+			}
+		});
+		disposeRemoteSource = () => tabRemoteSource.dispose();
+		tabRemoteSource.goOnline();
+		const reloadRequestedSubscription = workerClient.subscribe("reload-requested", () => {
+			globalThis.location?.reload();
+		});
+		cleanupCallbacks.push(reloadRequestedSubscription.unsubscribe);
+		const reloadIfStorageReplaced = (storageGeneration) => {
+			if (storageGeneration !== workerClientSnapshot.storageGeneration) {
+				storageReplacedSubscription.unsubscribe();
+				globalThis.location?.reload();
+			}
+		};
+		const storageReplacedSubscription = workerClient.subscribe("state-changed", (event) => {
+			reloadIfStorageReplaced(event.payload.storageGeneration);
+		});
+		cleanupCallbacks.push(storageReplacedSubscription.unsubscribe);
+		reloadIfStorageReplaced(workerClient.getStorageGeneration());
+		const sync = () => {
+			workerClient.sync().catch((error) => console.warn("Failed to start sync", error));
+		};
+		const syncWhenVisible = () => {
+			if (globalThis.document?.visibilityState === "visible") sync();
+		};
+		const dropConnection = () => {
+			workerClient.dropConnection().catch((error) => console.warn("Failed to drop connection", error));
+		};
+		cleanupCallbacks.push(() => {
+			globalThis.document?.removeEventListener("visibilitychange", syncWhenVisible);
+			globalThis.removeEventListener?.("online", sync);
+			globalThis.removeEventListener?.("offline", dropConnection);
+		});
+		globalThis.document?.addEventListener("visibilitychange", syncWhenVisible);
+		globalThis.addEventListener?.("online", sync);
+		globalThis.addEventListener?.("offline", dropConnection);
+		perf.logEnd("createSyncedDb", "initialized", "info");
+		const exportData = createExportData({
+			reactiveDb,
+			tablesConfig: options.syncDbSchema.tablesConfig,
+			schemaVersion: workerClientSnapshot.schemaVersion
+		});
+		const importData = (data, opts) => workerClient.importData(data, opts);
+		const syncedDb = {
+			db: createSyncedDbDatabase(reactiveDb),
+			state: {
+				getState: workerClient.getState.bind(workerClient),
+				subscribe: (onChange) => {
+					const { unsubscribe } = workerClient.subscribe("state-changed", onChange);
+					return unsubscribe;
+				},
+				goOnline: workerClient.goOnline.bind(workerClient),
+				goOffline: workerClient.goOffline.bind(workerClient),
+				sync
+			},
+			/**
+			* Ask the elected worker to broadcast a page reload to all tabs for this dbId.
+			*
+			* With `clean: true` the worker durably records a reset request epoch before
+			* broadcasting, so the worker elected on the next startup initializes with
+			* `clearOnInit: true` and wipes the persisted DB. Destructive — use as a
+			* recovery path when the durable worker DB may be de-synced.
+			*
+			* Pending in-memory tab events are not preserved, and the returned promise
+			* may never settle in the caller — the page typically unloads first.
+			*/
+			requestReload: async (options) => {
+				await workerClient.requestReload(options);
+				setTimeout(() => globalThis.location?.reload(), 250);
+			},
+			subscribe: workerClient.subscribe,
+			exportData,
+			importData,
+			dispose,
+			_internal: {
+				executeAsync: workerClient.execute.bind(workerClient),
+				getMemoryQueryTables: reactiveDb.getTablesUsed.bind(reactiveDb),
+				getSharedLiveQueriesSnapshot: reactiveDb.getSharedLiveQueriesSnapshot.bind(reactiveDb),
+				crdtTableNames: options.syncDbSchema.tablesConfig.map((table) => table.crdtTableName),
+				crdtTablesConfig: options.syncDbSchema.tablesConfig,
+				tables: options.syncDbSchema.tables,
+				schemaVersion: workerClientSnapshot.schemaVersion,
+				migrationVersions: Object.keys(options.syncDbSchema.migrations).map(Number).sort((a, b) => a - b)
+			}
+		};
+		unregisterDevtools = getOrCreateSQLiteSyncDevtoolsRegistry().register({
+			instanceId,
+			dbId: options.dbId,
+			createdAt: Date.now(),
+			instance: syncedDb
+		});
+		return syncedDb;
+	} catch (error) {
+		await dispose();
+		throw error;
+	}
 }
 //#endregion
 export { CRDT_EVENT_NO_OP_PAYLOAD, ColumnBuilder, CrdtEventValidationError, HLCCounter, RESET_REQUEST_TTL_MS, SQLiteDbWrapper, SQLiteReactiveDb, TableBuilder, TypedBroadcastChannel, TypedEvent, admitClientEvents, applyMemoryDbSchema, applyWorkerDbSchema, compareHLC, createCrdtApplyFunction, createCrdtStorage, createCrdtStorageMutator, createCrdtSyncProducer, createCrdtSyncRemoteSource, createDeferredPromise, createExportData, createImportData, createKvStoreTableQuery, createMigrations, createMigrator, createSQLiteCrdtApplyFunction, createSQLiteKvStore, createStoredValue, createSyncedDb, createTypedEventTarget, defineSyncSchema, deserializeHLC, dummyKysely, formatSchemaVerificationIssues, generateId, introspectDb, isNoOpCrdtEventPayload, jsonSafeParse, makeCrdtTable, parametersAreEqual, quoteId, serializeHLC, startPerformanceLogger, t, tryCatch, tryCatchAsync, validateNewCrdtEvent, verifySyncSchema, xxhash };