@sqlite-sync/core 0.12.2 → 0.13.0

package/dist/{reset-state-t0tTGqoh.js → crdt-sync-producer-BY-WobgO.js}

@@ -1,10 +1,7 @@
-import { d as SQLiteDbWrapper, h as dummyKysely, m as introspectDb, u as createStoredValue } from "./system-schema-Dvl_BLId.js";
-import { a as acquireLock, c as ensureSingletonExecution, l as generateId, n as isNoOpCrdtEventPayload, p as quoteId, r as TypedBroadcastChannel, s as createTypedEventTarget, t as CRDT_EVENT_NO_OP_PAYLOAD } from "./crdt-table-schema-BRm_WdcW.js";
-import { c as serializeHLC, n as CrdtEventValidationError, r as validateNewCrdtEvent, s as deserializeHLC } from "./crdt-sync-remote-source-CPXzmSIS.js";
+import { b as dummyKysely, h as SQLiteDbWrapper, m as createStoredValue, y as introspectDb } from "./system-schema-CXf3FmxN.js";
+import { c as ensureSingletonExecution, n as isNoOpCrdtEventPayload, p as quoteId, s as createTypedEventTarget, t as CRDT_EVENT_NO_OP_PAYLOAD } from "./crdt-table-schema-D6Yf61Ex.js";
+import { c as deserializeHLC, i as validateNewCrdtEvent, l as serializeHLC, n as createStateHashTracker, r as CrdtEventValidationError } from "./crdt-sync-remote-source-yeTEkOjH.js";
 import { sql } from "kysely";
-import initXxhash from "xxhash-wasm";
-import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
-import { createStore, del, get, set } from "idb-keyval";
 //#region src/export-import.ts
 function createTableNameNormalizer(tablesConfig) {
 	const tablesByAlias = /* @__PURE__ */ new Map();
@@ -107,24 +104,6 @@ function createExportData({ reactiveDb, tablesConfig, schemaVersion }) {
 	};
 }
 //#endregion
-//#region src/hash.ts
-let loadPromise = null;
-let api = null;
-function ensureLoaded() {
-	if (!loadPromise) loadPromise = initXxhash().then((hasher) => {
-		api = hasher;
-	});
-	return loadPromise;
-}
-function h64(input, seed = 0n) {
-	if (!api) throw new Error("xxhash is not initialized; call xxhash.ensureLoaded() first");
-	return api.h64(input, seed);
-}
-const xxhash = {
-	ensureLoaded,
-	h64
-};
-//#endregion
 //#region src/migrations/migrator.ts
 const protectedColumns = ["id", "tombstone"];
 function assertColumnNotProtected(column, operation) {
@@ -176,11 +155,6 @@ const migrationSteps = {
 	},
 	addColumn: ({ table, column, type, defaultValue, build = (e) => e }) => ({
 		sql: (db) => db.schema.alterTable(table).addColumn(column, type, (x) => build(x).defaultTo(defaultValue)),
-		eventTransformer: { [table]: (event) => {
-			if (event.type !== "item-created") return event;
-			event.payload[column] = defaultValue;
-			return event;
-		} },
 		updateLogMutations: [{
 			type: "add-column",
 			table,
@@ -384,25 +358,21 @@ const acceptedDataTypes = {
 	],
 	enum: ["TEXT"]
 };
-let sqliteModule = null;
 /**
 * Verify that replaying the full migration history on a fresh database produces
-* exactly the declared table schema. Creates a throwaway in-memory SQLite db,
-* applies all migrations, introspects the result, and diffs it against the
-* `t.table()` declarations.
+* exactly the declared table schema. Applies all migrations to `driver`, which
+* must be an empty throwaway database (it is closed afterwards), introspects the
+* result, and diffs it against the `t.table()` declarations.
 *
 * Returns an empty array when migrations and schema agree. Intended for dev-time
 * checks (`startDbWorker({ verifySchema: true })`) and tests:
 * `expect(await verifySyncSchema(syncDbSchema)).toEqual([])`.
 */
-async function verifySyncSchema(schema) {
-	if (!sqliteModule) sqliteModule = await sqlite3InitModule();
-	const sqlite3 = sqliteModule;
+function verifySyncSchemaWithDriver(schema, driver) {
 	const db = new SQLiteDbWrapper({
-		db: () => new sqlite3.oo1.DB({ filename: ":memory:" }),
+		driver,
 		logger: () => {},
-		loggerPrefix: "schema-verify",
-		sqlite3
+		loggerPrefix: "schema-verify"
 	});
 	try {
 		const migrator = createMigrator({
@@ -538,8 +508,9 @@ function formatExpected(meta) {
 }
 //#endregion
 //#region src/sqlite-crdt/apply-crdt-event.ts
-const createSQLiteCrdtApplyFunction = ({ db, dbConfig }) => {
+const createSQLiteCrdtApplyFunction = ({ db, dbConfig, getStateHash }) => {
 	return createCrdtApplyFunction({
+		getStateHash,
 		getCrdtUpdateLog(opts) {
 			const [metaRow] = db.executePrepared("get-item-crdt-meta", {
 				item_id: opts.itemId,
@@ -583,7 +554,7 @@ const createSQLiteCrdtApplyFunction = ({ db, dbConfig }) => {
 		}
 	});
 };
-function createCrdtApplyFunction({ getCrdtUpdateLog, insertItem, insertCrdtUpdateLog, updateItem, updateCrdtUpdateLog }) {
+function createCrdtApplyFunction({ getStateHash, getCrdtUpdateLog, insertItem, insertCrdtUpdateLog, updateItem, updateCrdtUpdateLog }) {
 	const applyItemCreated = ({ event }) => {
 		const eventPayload = JSON.parse(event.payload);
 		eventPayload.tombstone = 0;
@@ -598,25 +569,29 @@ function createCrdtApplyFunction({ getCrdtUpdateLog, insertItem, insertCrdtUpdat
 			itemId: event.item_id,
 			payload: JSON.stringify(newUpdateLog)
 		});
+		getStateHash?.()?.addItem(event.dataset, event.item_id, newUpdateLog);
 	};
 	const applyItemUpdated = ({ event, meta }) => {
 		if (!meta) throw new Error(`Item ${event.item_id} in dataset ${event.dataset} not found`);
 		const eventPayload = event.type === "item-deleted" ? { tombstone: 1 } : JSON.parse(event.payload);
 		if (event.type === "item-created") eventPayload.tombstone = 0;
 		const updatePayload = {};
-		let hasUpdates = false;
+		const replacedCells = [];
+		const previousCreateHlc = meta.id;
 		for (const [key, value] of Object.entries(eventPayload)) {
 			if (key === "id") continue;
 			const lastUpdateTimestamp = meta[key];
 			const currentUpdateTimestamp = event.timestamp;
 			if (!lastUpdateTimestamp || !currentUpdateTimestamp || currentUpdateTimestamp > lastUpdateTimestamp) {
 				updatePayload[key] = value;
+				replacedCells.push([key, lastUpdateTimestamp]);
 				meta[key] = currentUpdateTimestamp;
-				hasUpdates = true;
 			}
 		}
-		if (!hasUpdates) return;
-		updateItem({
+		const isLatestCreate = event.type === "item-created" && (!previousCreateHlc || event.timestamp > previousCreateHlc);
+		if (isLatestCreate) meta.id = event.timestamp;
+		if (replacedCells.length === 0 && !isLatestCreate) return;
+		if (replacedCells.length > 0) updateItem({
 			dataset: event.dataset,
 			itemId: event.item_id,
 			payload: updatePayload
@@ -626,6 +601,7 @@ function createCrdtApplyFunction({ getCrdtUpdateLog, insertItem, insertCrdtUpdat
 			itemId: event.item_id,
 			payload: JSON.stringify(meta)
 		});
+		getStateHash?.()?.updateItem(event.dataset, event.item_id, meta, previousCreateHlc, replacedCells);
 	};
 	return (event) => {
 		if (isNoOpCrdtEventPayload(event.payload)) return;
@@ -649,33 +625,6 @@ function createCrdtApplyFunction({ getCrdtUpdateLog, insertItem, insertCrdtUpdat
 	};
 }
 //#endregion
-//#region src/sqlite-crdt/event-consistency.ts
-const MASK_128 = (1n << 128n) - 1n;
-const HEX_128_PATTERN = /^[0-9a-f]{32}$/;
-function createEventHlcAccumulator(initialValue) {
-	let current = parseHex128(initialValue);
-	return {
-		add(timestamp) {
-			current = current + hash128BigInt(timestamp) & MASK_128;
-		},
-		get current() {
-			return toHex128(current);
-		}
-	};
-}
-function parseHex128(value) {
-	if (value === "") return 0n;
-	const normalized = value.toLowerCase();
-	if (!HEX_128_PATTERN.test(normalized)) throw new Error(`Invalid event HLC accumulator value: ${value}`);
-	return BigInt(`0x${normalized}`);
-}
-function toHex128(value) {
-	return value.toString(16).padStart(32, "0");
-}
-function hash128BigInt(value) {
-	return xxhash.h64(value, 0n) | xxhash.h64(value, 1n) << 64n;
-}
-//#endregion
 //#region src/sqlite-crdt/crdt-storage.ts
 function createCrdtStorage(storage) {
 	let localSyncId = storage.initialLocalSyncId;
@@ -848,7 +797,9 @@ function createCrdtStorage(storage) {
 				status: "pending"
 			}));
 			persistEvents(tx, persistedEvents);
-			for (const persistedEvent of persistedEvents) applyCrdtEvent(persistedEvent);
+			withStateHash(() => {
+				for (const persistedEvent of persistedEvents) applyCrdtEvent(persistedEvent);
+			});
 		});
 		processEnqueuedEvents();
 	};
@@ -924,7 +875,7 @@ where "dataset" = ? and "item_id" = ? and "payload" <> ${noOpPayloadSqlLiteral}`
 		persistEvents(tx, [persistedEvent]);
 		applyCrdtEvent(persistedEvent);
 	};
-	const applyOwnIntentsFromTransaction = (tx, intents) => {
+	const applyOwnIntentsFromTransaction = (tx, intents) => withStateHash(() => {
 		let appliedEvents = 0;
 		for (const intent of intents) {
 			if (intent.type === "item-updated") {
@@ -940,12 +891,12 @@ where "dataset" = ? and "item_id" = ? and "payload" <> ${noOpPayloadSqlLiteral}`
 			appliedEvents++;
 		}
 		return { appliedEvents };
-	};
+	});
 	const dispatchEventsApplied = (previousSequentialSyncId) => {
 		if (sequentialSyncId <= previousSequentialSyncId) return;
 		eventTarget.dispatchEvent("events-applied", {
 			syncId: sequentialSyncId,
-			eventHlcSum: sequentialSyncId === localSyncId ? eventHlcAccumulator?.current ?? null : null
+			stateHash: sequentialSyncId === localSyncId ? getStateHash() : null
 		});
 	};
 	const publishProcessedBatch = ({ previousSequentialSyncId, nextSequentialSyncId, appliedEvents }) => {
@@ -988,34 +939,21 @@ where "dataset" = ? and "item_id" = ? and "payload" <> ${noOpPayloadSqlLiteral}`
 			limit: 1
 		}).events.length === 0;
 	};
-	const applyCrdtEvent = createSQLiteCrdtApplyFunction({
+	const stateHash = createStateHashTracker({
 		db,
-		dbConfig: storage.dbConfig
+		updateLogTable: storage.dbConfig.updateLogTable.fullIdentifier,
+		schema: storage.schema,
+		getSchemaVersion: () => storage.migrator.currentSchemaVersion,
+		store: storage.stateHash ?? null
 	});
-	const eventHlcAccumulator = storage.eventHlcAccumulator ? createEventHlcAccumulator(storage.eventHlcAccumulator.current) : null;
-	const persistEventHlcAccumulator = () => {
-		if (eventHlcAccumulator && storage.eventHlcAccumulator) storage.eventHlcAccumulator.current = eventHlcAccumulator.current;
-	};
-	const recomputeEventHlcAccumulatorIfNeeded = () => {
-		if (!eventHlcAccumulator || !storage.eventHlcAccumulator) return;
-		if (storage.eventHlcAccumulator.current !== "") return;
-		const batchSize = 1e3;
-		let afterSyncId = 0;
-		for (;;) {
-			const rows = db.executePrepared("get-applied-event-timestamps", {
-				status: "applied",
-				afterSyncId,
-				limit: batchSize
-			}, (db, params) => db.selectFrom(crdtEventsTable).select(["sync_id", "timestamp"]).where("status", "=", params("status")).where("sync_id", ">", params("afterSyncId")).orderBy("sync_id", "asc").limit(params("limit")), { loggerLevel: "system" });
-			if (rows.length === 0) break;
-			for (const row of rows) {
-				eventHlcAccumulator.add(row.timestamp);
-				afterSyncId = row.sync_id;
-			}
-			if (rows.length < batchSize) break;
-		}
-		persistEventHlcAccumulator();
-	};
+	const withStateHash = stateHash.track;
+	const getStateHash = stateHash.read;
+	const applyCrdtEventWithoutStateHash = createSQLiteCrdtApplyFunction({
+		db,
+		dbConfig: storage.dbConfig,
+		getStateHash: () => stateHash.active
+	});
+	const applyCrdtEvent = (event) => withStateHash(() => applyCrdtEventWithoutStateHash(event));
 	const getFirstAcceptedSyncIdsByTimestamp = (tx, events) => {
 		const timestamps = Array.from(new Set(events.map((event) => event.timestamp)));
 		if (timestamps.length === 0) return /* @__PURE__ */ new Map();
@@ -1135,18 +1073,18 @@ where "dataset" = ? and "item_id" = ? and "payload" <> ${noOpPayloadSqlLiteral}`
 			db.executeTransaction((tx) => {
 				const firstAcceptedSyncIdByTimestamp = getFirstAcceptedSyncIdsByTimestamp(tx, events.filter((event) => event.origin !== "own-applied"));
 				const statusOnlyEvents = [];
-				for (const event of events) {
-					processPersistedEvent(tx, event, firstAcceptedSyncIdByTimestamp, statusOnlyEvents);
-					if (event.status === "applied") {
-						const firstAcceptedSyncId = firstAcceptedSyncIdByTimestamp.get(event.timestamp);
-						if (firstAcceptedSyncId === void 0 || event.sync_id < firstAcceptedSyncId) firstAcceptedSyncIdByTimestamp.set(event.timestamp, event.sync_id);
-						eventHlcAccumulator?.add(event.timestamp);
-						if (storage.onEventApplied) appliedEventsToNotify.push(event);
+				withStateHash(() => {
+					for (const event of events) {
+						processPersistedEvent(tx, event, firstAcceptedSyncIdByTimestamp, statusOnlyEvents);
+						if (event.status === "applied") {
+							const firstAcceptedSyncId = firstAcceptedSyncIdByTimestamp.get(event.timestamp);
+							if (firstAcceptedSyncId === void 0 || event.sync_id < firstAcceptedSyncId) firstAcceptedSyncIdByTimestamp.set(event.timestamp, event.sync_id);
+							if (storage.onEventApplied) appliedEventsToNotify.push(event);
+						}
+						if (event.status === "failed" && event.origin === "remote") failedRemoteSyncIds.push(event.sync_id);
 					}
-					if (event.status === "failed" && event.origin === "remote") failedRemoteSyncIds.push(event.sync_id);
-				}
+				});
 				updateEventStatuses(tx, statusOnlyEvents);
-				persistEventHlcAccumulator();
 			});
 			publishProcessedBatch({
 				previousSequentialSyncId,
@@ -1156,7 +1094,7 @@ where "dataset" = ? and "item_id" = ? and "payload" <> ${noOpPayloadSqlLiteral}`
 			for (const syncId of failedRemoteSyncIds) eventTarget.dispatchEvent("remote-event-apply-failed", { syncId });
 		}
 	});
-	recomputeEventHlcAccumulatorIfNeeded();
+	if (storage.stateHash) db.executeTransaction(stateHash.initialize);
 	processEnqueuedEvents();
 	return {
 		getEventsBatch,
@@ -1165,7 +1103,7 @@ where "dataset" = ? and "item_id" = ? and "payload" <> ${noOpPayloadSqlLiteral}`
 		applyOwnEvents,
 		applyOwnSnapshot,
 		checkIsQuiescent,
-		getEventHlcAccumulator: () => eventHlcAccumulator?.current ?? null,
+		getStateHash,
 		addEventListener: eventTarget.addEventListener,
 		removeEventListener: eventTarget.removeEventListener,
 		internal: {
@@ -1181,135 +1119,11 @@ const createCrdtSyncProducer = ({ storage, broadcastEvents }) => {
 	storage.addEventListener("events-applied", (event) => {
 		broadcastEvents({
 			newSyncId: event.payload.syncId,
-			eventHlcSum: event.payload.eventHlcSum
+			stateHash: event.payload.stateHash
 		});
 	});
 };
 //#endregion
-//#region src/worker-db/worker-common.ts
-const syncDbWorkerLockName = "sync-db-worker-lock";
-const syncDbClientLockName = "sync-db-client-lock";
-const broadcastChannelNames = {
-	requests: "sync-db-worker-requests",
-	responses: "sync-db-worker-responses"
-};
-const createBroadcastChannels = (prefix) => {
-	return {
-		requests: new TypedBroadcastChannel(`${prefix}-${broadcastChannelNames.requests}`),
-		responses: new TypedBroadcastChannel(`${prefix}-${broadcastChannelNames.responses}`)
-	};
-};
-function isWorkerInitMessage(message) {
-	return typeof message === "object" && message !== null && "type" in message && message.type === "init";
-}
-function isWorkerRequestMessage(message) {
-	return typeof message === "object" && message !== null && "type" in message && message.type === "request";
-}
-function isWorkerResponseMessage(message) {
-	return typeof message === "object" && message !== null && "type" in message && "requestId" in message && "data" in message;
-}
-function isWorkerErrorResponseMessage(message) {
-	return typeof message === "object" && message !== null && "type" in message && message.type === "error-response";
-}
-function isWorkerNotificationMessage(message) {
-	return typeof message === "object" && message !== null && "notificationType" in message && !!message.notificationType;
-}
-//#endregion
-//#region src/worker-db/replica-lock.ts
-const replicaLockName = (dbId) => `sync-db-replica-lock-${dbId}`;
-function acquireReplicaLock({ dbId }) {
-	return acquireLock(replicaLockName(dbId), { mode: "shared" });
-}
-function runWithNoActiveReplicas({ dbId, run }) {
-	return navigator.locks.request(replicaLockName(dbId), {
-		mode: "exclusive",
-		ifAvailable: true
-	}, async (lock) => {
-		if (!lock) return false;
-		await run();
-		return true;
-	});
-}
-//#endregion
-//#region src/worker-db/reset-state.ts
-/** Default IndexedDB-backed reset store (idb-keyval over a dedicated database). */
-function createIdbResetStore() {
-	const store = createStore("sqlite-sync", "kv");
-	return {
-		get: (key) => get(key, store),
-		set: (key, value) => set(key, value, store),
-		delete: (key) => del(key, store)
-	};
-}
-/**
-* A clean reset is a recovery action for a de-sync detected now. If the reload
-* never happens (broadcast lost, tab crashed mid-reload, browser killed the page),
-* the request must not fire on an arbitrary later cold start and silently wipe
-* local-only writes accumulated since.
-*/
-const RESET_REQUEST_TTL_MS = 6e5;
-const resetRequestKey = (dbId) => `sqlite-sync-reset-request-${dbId}`;
-const resetAppliedKey = (dbId) => `sqlite-sync-reset-applied-${dbId}`;
-/**
-* Worker-owned durable reset state. The reset decision must be owned by the
-* elected worker, not by tabs during `createSyncedDb` — otherwise a later
-* worker election could repeat an already-applied wipe.
-*/
-function createResetStateStore({ store, dbId, now = () => Date.now() }) {
-	const requestKey = resetRequestKey(dbId);
-	const appliedKey = resetAppliedKey(dbId);
-	return {
-		async writeResetRequest(epoch) {
-			const request = {
-				epoch,
-				requestedAt: now()
-			};
-			await store.set(requestKey, request);
-			return request;
-		},
-		/**
-		* Read the pending reset request after winning the worker election.
-		* Returns the request only when it has not been applied yet and is within
-		* the TTL. Stale requests are deleted so they cannot fire on a later cold start.
-		*/
-		async resolvePendingReset() {
-			const request = await store.get(requestKey);
-			if (!request) return;
-			if (now() - request.requestedAt > 6e5) {
-				await store.delete(requestKey);
-				return;
-			}
-			const appliedEpoch = await store.get(appliedKey);
-			if (request.epoch === appliedEpoch) return;
-			return request;
-		},
-		/**
-		* Record the epoch as applied. Must be called only after the worker has
-		* successfully initialized with `clearOnInit: true`, so a failed init can
-		* be retried by a later elected worker.
-		*/
-		async markResetApplied(epoch) {
-			await store.set(appliedKey, epoch);
-		}
-	};
-}
-/**
-* Worker-side `requestReload` RPC implementation. For `clean: true` the reset
-* request is durably stored before broadcasting and before the RPC resolves,
-* so the epoch survives no matter which path triggers the reload.
-*/
-function createReloadRequestHandler({ resetState, broadcast, generateEpoch = generateId }) {
-	return async (options) => {
-		const reloadEpoch = generateEpoch();
-		if (options.clean) await resetState.writeResetRequest(reloadEpoch);
-		broadcast({
-			notificationType: "reload-requested",
-			reloadEpoch,
-			clean: options.clean
-		});
-	};
-}
-//#endregion
-export { xxhash as C, createMigrator as S, createImportData as T, createCrdtApplyFunction as _, acquireReplicaLock as a, verifySyncSchema as b, isWorkerErrorResponseMessage as c, isWorkerRequestMessage as d, isWorkerResponseMessage as f, createCrdtStorage as g, createCrdtSyncProducer as h, createResetStateStore as i, isWorkerInitMessage as l, syncDbWorkerLockName as m, createIdbResetStore as n, runWithNoActiveReplicas as o, syncDbClientLockName as p, createReloadRequestHandler as r, createBroadcastChannels as s, RESET_REQUEST_TTL_MS as t, isWorkerNotificationMessage as u, createSQLiteCrdtApplyFunction as v, createExportData as w, createMigrations as x, formatSchemaVerificationIssues as y };
+export { formatSchemaVerificationIssues as a, createMigrator as c, createSQLiteCrdtApplyFunction as i, createExportData as l, createCrdtStorage as n, verifySyncSchemaWithDriver as o, createCrdtApplyFunction as r, createMigrations as s, createCrdtSyncProducer as t, createImportData as u };
 
-//# sourceMappingURL=reset-state-t0tTGqoh.js.map
+//# sourceMappingURL=crdt-sync-producer-BY-WobgO.js.map