@sqlite-sync/core 0.9.3 → 0.10.0

package/dist/{reset-state-4Hn95CKG.js → reset-state-BVWEcT_z.js}

@@ -1,5 +1,6 @@
-import { a as ensureSingletonExecution, f as tryCatchAsync, i as createTypedEventTarget, o as generateId, t as TypedBroadcastChannel, u as quoteId } from "./utils-Dr5JwcTP.js";
-import { d as CRDT_EVENT_NO_OP_PAYLOAD, f as isNoOpCrdtEventPayload, u as createStoredValue } from "./system-schema-CkglcfTS.js";
+import { c as generateId, f as quoteId, n as isNoOpCrdtEventPayload, o as createTypedEventTarget, r as TypedBroadcastChannel, s as ensureSingletonExecution, t as CRDT_EVENT_NO_OP_PAYLOAD } from "./crdt-table-schema-2w_AIpsV.js";
+import { c as serializeHLC, n as CrdtEventValidationError, r as validateNewCrdtEvent, s as deserializeHLC } from "./crdt-sync-remote-source-Dtvyrk0R.js";
+import { u as createStoredValue } from "./system-schema-C2JZDv6L.js";
 import { DummyDriver, Kysely, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, sql } from "kysely";
 import initXxhash from "xxhash-wasm";
 import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
@@ -132,81 +133,6 @@ const xxhash = {
 	h64
 };
 //#endregion
-//#region src/hlc.ts
-const MAX_COUNTER = 36 ** 5 - 1;
-const DEFAULT_MAX_DRIFT_MS = 216e5;
-var HLCCounter = class {
-	timestamp;
-	counter;
-	nodeId;
-	getTimestamp;
-	maxDrift;
-	constructor(nodeId, getTimestamp, maxDrift = DEFAULT_MAX_DRIFT_MS) {
-		this.timestamp = getTimestamp();
-		this.counter = 0;
-		this.nodeId = nodeId;
-		this.getTimestamp = getTimestamp;
-		this.maxDrift = maxDrift;
-	}
-	getCurrentHLC() {
-		return {
-			timestamp: this.timestamp,
-			counter: this.counter,
-			nodeId: this.nodeId
-		};
-	}
-	getNextHLC() {
-		const now = this.getTimestamp();
-		if (now > this.timestamp) {
-			this.timestamp = now;
-			this.counter = 0;
-			return this.getCurrentHLC();
-		}
-		this.counter++;
-		if (this.counter > MAX_COUNTER) throw new Error(`HLC counter overflow: exceeded max value ${MAX_COUNTER}`);
-		return this.getCurrentHLC();
-	}
-	mergeHLC(hlc) {
-		const now = this.getTimestamp();
-		if (hlc.timestamp - now > this.maxDrift) {
-			console.warn(`HLC: ignoring far-future timestamp (remote=${hlc.timestamp}, local=${now}, drift=${hlc.timestamp - now}ms)`);
-			return;
-		}
-		if (this.timestamp === hlc.timestamp) this.counter = Math.max(this.counter, hlc.counter) + 1;
-		else if (this.timestamp > hlc.timestamp) this.counter++;
-		else {
-			this.timestamp = hlc.timestamp;
-			this.counter = hlc.counter + 1;
-		}
-		if (this.counter > MAX_COUNTER) throw new Error(`HLC counter overflow: exceeded max value ${MAX_COUNTER}`);
-	}
-};
-function serializeHLC(hlc) {
-	return `${hlc.timestamp.toString().padStart(15, "0")}:${hlc.counter.toString(36).padStart(5, "0")}:${hlc.nodeId}`;
-}
-function deserializeHLC(serialized) {
-	const parts = serialized.split(":");
-	if (parts.length < 3) throw new Error(`Invalid HLC format: expected at least 3 colon-separated segments, got ${parts.length}`);
-	const timestamp = parseInt(parts[0], 10);
-	const counter = parseInt(parts[1], 36);
-	if (Number.isNaN(timestamp) || Number.isNaN(counter)) throw new Error(`Invalid HLC values: timestamp=${parts[0]}, counter=${parts[1]}`);
-	return {
-		timestamp,
-		counter,
-		nodeId: parts.slice(2).join(":")
-	};
-}
-function compareHLC(one, two) {
-	if (one.timestamp === two.timestamp) {
-		if (one.counter === two.counter) {
-			if (one.nodeId === two.nodeId) return 0;
-			return one.nodeId < two.nodeId ? -1 : 1;
-		}
-		return one.counter - two.counter;
-	}
-	return one.timestamp - two.timestamp;
-}
-//#endregion
 //#region src/introspection.ts
 function tablesQuery(qb) {
 	return qb.selectFrom("sqlite_master").where("type", "in", ["table", "view"]).where("name", "not like", "sqlite_%").select([
@@ -775,93 +701,6 @@ WHERE "dataset" = ?
 	};
 }
 //#endregion
-//#region src/schema/validate-crdt-event.ts
-var CrdtEventValidationError = class extends Error {
-	errors;
-	constructor(errors) {
-		super(`Invalid CRDT events: ${errors.join("; ")}`);
-		this.errors = errors;
-		this.name = "CrdtEventValidationError";
-	}
-};
-const crdtEventTypes = [
-	"item-created",
-	"item-updated",
-	"item-deleted"
-];
-function validateNewCrdtEvent(schema, input) {
-	const errors = [];
-	if (!isRecord(input)) return {
-		success: false,
-		errors: ["Event must be an object"]
-	};
-	const type = input.type;
-	const dataset = input.dataset;
-	const itemId = input.item_id;
-	let payload = input.payload;
-	let payloadParseFailed = false;
-	if (typeof payload === "string") try {
-		payload = JSON.parse(payload);
-	} catch {
-		payloadParseFailed = true;
-		errors.push(`Event payload is not valid JSON`);
-	}
-	if (!isCrdtEventType(type)) errors.push(`Invalid event type "${String(type)}"`);
-	if (typeof dataset !== "string") errors.push(`Event dataset must be a string`);
-	if (typeof itemId !== "string") errors.push(`Event item_id must be a string`);
-	if (!payloadParseFailed && !isRecord(payload)) errors.push(`Event payload must be an object`);
-	const datasetMatch = typeof dataset === "string" ? findTableForDataset(schema, dataset) : null;
-	if (typeof dataset === "string" && !datasetMatch) errors.push(`Unknown dataset "${dataset}"`);
-	if (isCrdtEventType(type) && datasetMatch && isRecord(payload)) switch (type) {
-		case "item-created": {
-			const result = datasetMatch.table.validatePayload(payload, { event: "item-created" });
-			if (!result.success) errors.push(...result.errors.map((error) => `payload: ${error}`));
-			if (typeof itemId === "string" && "id" in payload && payload.id !== itemId) errors.push(`payload: Column "id" must match item_id "${itemId}"`);
-			break;
-		}
-		case "item-updated": {
-			const result = datasetMatch.table.validatePayload(payload, { event: "item-updated" });
-			if (!result.success) errors.push(...result.errors.map((error) => `payload: ${error}`));
-			break;
-		}
-		case "item-deleted": if (Object.keys(payload).length > 0) errors.push(`payload: item-deleted events must have an empty payload`);
-	}
-	if (errors.length > 0) return {
-		success: false,
-		errors
-	};
-	return {
-		success: true,
-		event: {
-			type,
-			dataset: datasetMatch?.baseTableName ?? dataset,
-			item_id: itemId,
-			payload
-		}
-	};
-}
-function findTableForDataset(schema, dataset) {
-	const config = schema.tablesConfig.find((tableConfig) => tableConfig.baseTableName === dataset || tableConfig.crdtTableName === dataset);
-	if (config) {
-		const table = schema.tables[config.crdtTableName];
-		return table ? {
-			table,
-			baseTableName: config.baseTableName
-		} : null;
-	}
-	const table = schema.tables[dataset];
-	return table ? {
-		table,
-		baseTableName: dataset
-	} : null;
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isCrdtEventType(value) {
-	return typeof value === "string" && crdtEventTypes.includes(value);
-}
-//#endregion
 //#region src/schema/verify-sync-schema.ts
 const acceptedDataTypes = {
 	text: ["TEXT"],
@@ -1098,6 +937,7 @@ function createCrdtApplyFunction({ getCrdtUpdateLog, insertItem, insertCrdtUpdat
 	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;
 		for (const [key, value] of Object.entries(eventPayload)) {
@@ -1178,6 +1018,17 @@ function createCrdtStorage(storage) {
 	const crdtEventsTable = storage.dbConfig.eventsTable.fullIdentifier;
 	const quotedEventsTable = quoteId(storage.dbConfig.eventsTable.fullIdentifier);
 	const noOpPayloadSqlLiteral = `'${CRDT_EVENT_NO_OP_PAYLOAD}'`;
+	const [persistedClock] = db.executePreparedRaw({
+		key: "get-persisted-hlc",
+		sql: `select max("timestamp") as "timestamp" from (
+      select max("timestamp") as "timestamp" from ${quotedEventsTable} where "status" = 'applied'
+      union all
+      select max(fields.value) as "timestamp"
+      from ${quoteId(storage.dbConfig.updateLogTable.fullIdentifier)} as updates, json_each(updates.payload) as fields
+    )`,
+		meta: { loggerLevel: "system" }
+	});
+	if (persistedClock?.timestamp) storage.hlc.restoreHLC(deserializeHLC(persistedClock.timestamp));
 	const getInitialSequentialSyncId = () => {
 		const [firstPendingEvent] = db.executePrepared("get-first-pending-event", { status: "pending" }, (db, params) => db.selectFrom(crdtEventsTable).select("sync_id").where("status", "=", params("status")).orderBy("sync_id", "asc").limit(sql.lit(1)), { loggerLevel: "system" });
 		return firstPendingEvent ? firstPendingEvent.sync_id - 1 : localSyncId;
@@ -1273,7 +1124,13 @@ function createCrdtStorage(storage) {
 		};
 	};
 	const enqueueLocalEvents = (events, sourceNodeId) => {
-		return enqueueEvents("local", sourceNodeId, events);
+		const known = getFirstAcceptedSyncIdsByTimestamp(db, events);
+		const newEvents = events.filter((event) => {
+			if (known.has(event.timestamp)) return false;
+			known.set(event.timestamp, 0);
+			return true;
+		});
+		return enqueueEvents("local", sourceNodeId, newEvents);
 	};
 	const enqueueOwnEvents = (events) => {
 		return enqueueEvents("own", storage.nodeId, events);
@@ -1359,7 +1216,19 @@ function createCrdtStorage(storage) {
 				sync_id: syncId,
 				status: "pending"
 			};
-			tx.executePreparedRaw({
+			const [newerEvent] = tx.executePreparedRaw({
+				key: "get-crdt-row-event-newer-than-snapshot",
+				sql: `select "sync_id" from ${quotedEventsTable}
+where "dataset" = ? and "item_id" = ? and "timestamp" > ? and "payload" <> ${noOpPayloadSqlLiteral}
+limit 1`,
+				params: [
+					event.dataset,
+					event.item_id,
+					event.timestamp
+				],
+				meta: { loggerLevel: "system" }
+			});
+			if (!newerEvent) tx.executePreparedRaw({
 				key: "replace-crdt-row-history-with-no-ops",
 				sql: `update ${quotedEventsTable}
 set "payload" = ?
@@ -1486,7 +1355,7 @@ where "dataset" = ? and "item_id" = ? and "payload" <> ${noOpPayloadSqlLiteral}`
 		persistEventHlcAccumulator();
 	};
 	const getFirstAcceptedSyncIdsByTimestamp = (tx, events) => {
-		const timestamps = Array.from(new Set(events.filter((event) => event.origin !== "own-applied").map((event) => event.timestamp)));
+		const timestamps = Array.from(new Set(events.map((event) => event.timestamp)));
 		if (timestamps.length === 0) return /* @__PURE__ */ new Map();
 		const rows = timestamps.length === 1 ? tx.executePreparedRaw({
 			key: "get-first-accepted-sync-id-by-timestamp",
@@ -1602,7 +1471,7 @@ where "dataset" = ? and "item_id" = ? and "payload" <> ${noOpPayloadSqlLiteral}`
 			const failedRemoteSyncIds = [];
 			const appliedEventsToNotify = [];
 			db.executeTransaction((tx) => {
-				const firstAcceptedSyncIdByTimestamp = getFirstAcceptedSyncIdsByTimestamp(tx, events);
+				const firstAcceptedSyncIdByTimestamp = getFirstAcceptedSyncIdsByTimestamp(tx, events.filter((event) => event.origin !== "own-applied"));
 				const statusOnlyEvents = [];
 				for (const event of events) {
 					processPersistedEvent(tx, event, firstAcceptedSyncIdByTimestamp, statusOnlyEvents);
@@ -1656,265 +1525,6 @@ const createCrdtSyncProducer = ({ storage, broadcastEvents }) => {
 	});
 };
 //#endregion
-//#region src/sqlite-crdt/retry-remote-operation.ts
-const REMOTE_RETRY_OPTIONS = {
-	maxAttempts: 3,
-	backoffBaseMs: 100,
-	backoffExponent: 1.5,
-	backoffJitterMs: 150,
-	timeoutMs: 1e4
-};
-var RetryTimeoutError = class extends Error {
-	previous;
-	constructor(message, previous) {
-		super(message);
-		this.previous = previous;
-		this.name = "TimeoutError";
-	}
-};
-const applyJitter = (delayMs, maxJitterMs) => {
-	const jitter = Math.random() * maxJitterMs * (Math.random() > .5 ? 1 : -1);
-	return Math.max(0, delayMs + jitter);
-};
-const delay = (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs));
-const withTimeout = async (operation, timeoutMs, previousError) => {
-	let timeoutId;
-	try {
-		return await Promise.race([operation(), new Promise((_, reject) => {
-			timeoutId = setTimeout(() => reject(new RetryTimeoutError("Remote operation timed out", previousError)), timeoutMs);
-		})]);
-	} finally {
-		if (timeoutId) clearTimeout(timeoutId);
-	}
-};
-const retryRemoteOperation = async (operation, options) => {
-	let lastError;
-	for (let attempt = 1; attempt <= options.maxAttempts; attempt++) try {
-		return await withTimeout(operation, options.timeoutMs, lastError);
-	} catch (error) {
-		lastError = error;
-		if (attempt >= options.maxAttempts) throw error;
-		const backoffDelay = applyJitter(options.backoffBaseMs * options.backoffExponent ** (attempt - 1), options.backoffJitterMs);
-		if (backoffDelay > 0) await delay(backoffDelay);
-	}
-	throw lastError;
-};
-//#endregion
-//#region src/sqlite-crdt/crdt-sync-remote-source.ts
-var SchemaVersionMismatchError = class extends Error {
-	remoteSchemaVersion;
-	localSchemaVersion;
-	constructor(remoteSchemaVersion, localSchemaVersion) {
-		super(`Schema version mismatch: remote ${remoteSchemaVersion} != local ${localSchemaVersion}`);
-		this.remoteSchemaVersion = remoteSchemaVersion;
-		this.localSchemaVersion = localSchemaVersion;
-		this.name = "SchemaVersionMismatchError";
-	}
-};
-const createCrdtSyncRemoteSource = ({ bufferSize, storage, migrator, pullSyncId, pushSyncId, nodeId, remoteFactory }) => {
-	const eventTarget = createTypedEventTarget();
-	let remoteState = {
-		type: "offline",
-		reason: "NOT_INITIALIZED",
-		deSynced: false,
-		schemaVersionMismatched: false
-	};
-	const patchRemoteState = (state) => {
-		remoteState = {
-			...remoteState,
-			...state
-		};
-		eventTarget.dispatchEvent("state-changed", remoteState.type);
-	};
-	const initRemote = ensureSingletonExecution(async () => {
-		if (remoteState.type !== "offline") throw new Error("Remote source is not offline");
-		if (!remoteFactory) {
-			console.warn("Remote source factory not provided. Going offline.");
-			patchRemoteState({
-				type: "offline",
-				reason: "NOT_INITIALIZED"
-			});
-			return;
-		}
-		patchRemoteState({ type: "pending" });
-		const factoryResult = await tryCatchAsync(async () => {
-			return await remoteFactory?.({ onEventsAvailable: ({ newSyncId, remoteEventHlcSum }) => {
-				pullEvents({
-					remoteSyncId: newSyncId,
-					remoteEventHlcSum,
-					includeSelf: false
-				});
-			} });
-		});
-		if (!factoryResult.success) {
-			patchRemoteState({
-				type: "offline",
-				reason: "INITIALIZATION_FAILED"
-			});
-			console.warn("Failed to create remote source", factoryResult.error);
-			return;
-		}
-		patchRemoteState({
-			type: "online",
-			source: factoryResult.data,
-			deSynced: false,
-			schemaVersionMismatched: false
-		});
-	}, { queueReExecution: false });
-	const syncWithRemote = ensureSingletonExecution(async () => {
-		if (remoteState.type !== "online") return;
-		await pullEvents();
-		await startPushingEvents();
-	}, { queueReExecution: false });
-	const goOffline = ensureSingletonExecution(async (reason) => {
-		if (remoteState.type !== "online") return;
-		const source = remoteState.source;
-		patchRemoteState({ type: "pending" });
-		const disconnectResult = await tryCatchAsync(async () => {
-			return await source.disconnect?.();
-		});
-		if (!disconnectResult.success) console.warn("Error while disconnecting from remote source", disconnectResult.error);
-		patchRemoteState({
-			type: "offline",
-			reason
-		});
-	}, { queueReExecution: false });
-	const goOnline = async () => {
-		if (remoteState.type !== "online") await initRemote();
-		if (remoteState.type === "online") await syncWithRemote();
-	};
-	let requestedPullSyncId = null;
-	let pullPromise = null;
-	const pullEvents = (request) => {
-		if (remoteState.type !== "online") return Promise.resolve();
-		const remoteSyncId = request?.remoteSyncId;
-		if (remoteSyncId !== void 0 && remoteSyncId <= pullSyncId.current) {
-			checkRemoteConsistency(remoteSyncId, request?.remoteEventHlcSum ?? null);
-			return Promise.resolve();
-		}
-		if (pullPromise) {
-			if (remoteSyncId !== void 0 && (!requestedPullSyncId || requestedPullSyncId < remoteSyncId)) requestedPullSyncId = remoteSyncId;
-			return pullPromise;
-		}
-		pullPromise = pullAllEvents({
-			afterSyncId: pullSyncId.current,
-			excludeNodeId: request?.includeSelf ? void 0 : nodeId
-		}).catch((error) => {
-			console.error("Error pulling events. Going offline.", error);
-			goOffline("REMOTE_PULL_ERROR");
-		}).finally(() => {
-			pullPromise = null;
-			const nextTarget = requestedPullSyncId;
-			requestedPullSyncId = null;
-			if (nextTarget && nextTarget > pullSyncId.current) pullEvents({ remoteSyncId: nextTarget });
-		});
-		return pullPromise;
-	};
-	const pullAllEvents = async (opts) => {
-		let hasMore = true;
-		let afterSyncId = opts.afterSyncId;
-		while (hasMore) {
-			if (remoteState.type !== "online") return;
-			const source = remoteState.source;
-			const response = await retryRemoteOperation(() => source.pullEvents({
-				...opts,
-				afterSyncId
-			}), REMOTE_RETRY_OPTIONS);
-			hasMore = response.hasMore;
-			afterSyncId = response.nextSyncId;
-			if (response.events) storage.enqueueRemoteEvents(response.events.map((x) => {
-				if (x.schema_version > migrator.currentSchemaVersion) {
-					eventTarget.dispatchEvent("remote-schema-version-mismatch", {
-						remoteSchemaVersion: x.schema_version,
-						localSchemaVersion: migrator.currentSchemaVersion
-					});
-					if (remoteState.type === "online" && !remoteState.schemaVersionMismatched) patchRemoteState({ schemaVersionMismatched: true });
-					throw new SchemaVersionMismatchError(x.schema_version, migrator.currentSchemaVersion);
-				}
-				return x;
-			}));
-			if (response.nextSyncId <= pullSyncId.current) break;
-			if (response.nextSyncId > pullSyncId.current) pullSyncId.current = response.nextSyncId;
-		}
-	};
-	const checkRemoteConsistency = (remoteSyncId, remoteEventHlcSum) => {
-		if (remoteEventHlcSum === null) return;
-		if (remoteSyncId !== pullSyncId.current) return;
-		if (!storage.checkIsQuiescent(pushSyncId.current)) return;
-		const localEventHlcSum = storage.getEventHlcAccumulator();
-		if (localEventHlcSum === null) return;
-		if (localEventHlcSum === remoteEventHlcSum) return;
-		eventTarget.dispatchEvent("de-sync-detected", { reason: "CHECKSUM_MISMATCH" });
-		console.warn(`[sqlite-sync] De-sync detected at syncId ${remoteSyncId}: local HLC checksum ${localEventHlcSum} != remote ${remoteEventHlcSum}. Local and remote have diverged despite being caught up.`);
-		if (remoteState.type === "online" && !remoteState.deSynced) patchRemoteState({ deSynced: true });
-	};
-	const startPushingEvents = ensureSingletonExecution(async () => {
-		while (true) {
-			const eventsBatch = storage.getEventsBatch({
-				status: "applied",
-				afterSyncId: pushSyncId.current,
-				excludeOrigin: "remote",
-				limit: bufferSize
-			});
-			if (eventsBatch.events.length === 0) break;
-			if (remoteState.type !== "online") break;
-			const source = remoteState.source;
-			let response;
-			try {
-				response = await retryRemoteOperation(() => source.pushEvents({
-					nodeId,
-					events: eventsBatch.events.map((event) => ({
-						schema_version: event.schema_version,
-						timestamp: event.timestamp,
-						type: event.type,
-						dataset: event.dataset,
-						item_id: event.item_id,
-						payload: event.payload
-					}))
-				}), REMOTE_RETRY_OPTIONS);
-			} catch (error) {
-				console.error("Error pushing events. Going offline.", error);
-				goOffline("REMOTE_PUSH_ERROR");
-				return;
-			}
-			if (!response.ok) {
-				console.error("Remote rejected pushed events. Going offline.");
-				goOffline("REMOTE_PUSH_ERROR");
-				return;
-			}
-			pushSyncId.current = eventsBatch.nextSyncId;
-			if (response.beforeSyncId !== void 0 && response.afterSyncId !== void 0 && response.beforeSyncId <= pullSyncId.current && response.afterSyncId > pullSyncId.current) pullSyncId.current = response.afterSyncId;
-			if (!eventsBatch.hasMore) break;
-		}
-	});
-	const eventsAppliedSubscription = storage.addEventListener("events-applied", () => {
-		startPushingEvents();
-	});
-	const remoteEventApplyFailedSubscription = storage.addEventListener("remote-event-apply-failed", () => {
-		eventTarget.dispatchEvent("de-sync-detected", { reason: "ERROR_APPLYING_REMOTE_EVENT" });
-		if (remoteState.type === "online" && !remoteState.deSynced) patchRemoteState({ deSynced: true });
-	});
-	const getState = () => ({
-		remoteState: remoteState.type,
-		deSynced: remoteState.deSynced,
-		schemaVersionMismatched: remoteState.schemaVersionMismatched
-	});
-	const dispose = async () => {
-		await goOffline("DISCONNECTED");
-		eventsAppliedSubscription.unsubscribe();
-		remoteEventApplyFailedSubscription.unsubscribe();
-	};
-	return {
-		goOnline,
-		goOffline,
-		syncWithRemote,
-		getState,
-		dispose,
-		addEventListener: eventTarget.addEventListener,
-		removeEventListener: eventTarget.removeEventListener
-	};
-};
-//#endregion
 //#region src/worker-db/worker-common.ts
 const syncDbWorkerLockName = "sync-db-worker-lock";
 const syncDbClientLockName = "sync-db-client-lock";
@@ -2023,6 +1633,6 @@ function createReloadRequestHandler({ resetState, broadcast, generateEpoch = gen
 	};
 }
 //#endregion
-export { serializeHLC as A, createMigrator as C, HLCCounter as D, introspectDb as E, createExportData as M, createImportData as N, compareHLC as O, dummyKysely as P, createMigrations as S, startPerformanceLogger as T, createSQLiteCrdtApplyFunction as _, createBroadcastChannels as a, CrdtEventValidationError as b, isWorkerNotificationMessage as c, syncDbClientLockName as d, syncDbWorkerLockName as f, createCrdtApplyFunction as g, createCrdtStorage as h, createResetStateStore as i, xxhash as j, deserializeHLC as k, isWorkerRequestMessage as l, createCrdtSyncProducer as m, createIdbResetStore as n, isWorkerErrorResponseMessage as o, createCrdtSyncRemoteSource as p, createReloadRequestHandler as r, isWorkerInitMessage as s, RESET_REQUEST_TTL_MS as t, isWorkerResponseMessage as u, formatSchemaVerificationIssues as v, SQLiteDbWrapper as w, validateNewCrdtEvent as x, verifySyncSchema as y };
+export { introspectDb as C, dummyKysely as D, createImportData as E, startPerformanceLogger as S, createExportData as T, formatSchemaVerificationIssues as _, createBroadcastChannels as a, createMigrator as b, isWorkerNotificationMessage as c, syncDbClientLockName as d, syncDbWorkerLockName as f, createSQLiteCrdtApplyFunction as g, createCrdtApplyFunction as h, createResetStateStore as i, isWorkerRequestMessage as l, createCrdtStorage as m, createIdbResetStore as n, isWorkerErrorResponseMessage as o, createCrdtSyncProducer as p, createReloadRequestHandler as r, isWorkerInitMessage as s, RESET_REQUEST_TTL_MS as t, isWorkerResponseMessage as u, verifySyncSchema as v, xxhash as w, SQLiteDbWrapper as x, createMigrations as y };
 
-//# sourceMappingURL=reset-state-4Hn95CKG.js.map
+//# sourceMappingURL=reset-state-BVWEcT_z.js.map