@sqlite-sync/core 0.8.2 → 0.9.0

package/dist/reset-state-D3nsfx_t.js

@@ -0,0 +1,2018 @@
+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 { DummyDriver, Kysely, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, 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/dummy-kysely.ts
+const dummyKysely = new Kysely({ dialect: {
+	createAdapter: () => new SqliteAdapter(),
+	createDriver: () => new DummyDriver(),
+	createQueryCompiler: () => new SqliteQueryCompiler(),
+	createIntrospector: (db) => new SqliteIntrospector(db)
+} });
+//#endregion
+//#region src/export-import.ts
+function createTableNameNormalizer(tablesConfig) {
+	const baseNamesByAlias = /* @__PURE__ */ new Map();
+	for (const { baseTableName, crdtTableName } of tablesConfig ?? []) {
+		baseNamesByAlias.set(baseTableName, baseTableName);
+		baseNamesByAlias.set(crdtTableName, baseTableName);
+	}
+	return (tableName) => baseNamesByAlias.get(tableName) ?? tableName;
+}
+function createImportData({ migrator, tablesConfig, applyEvents }) {
+	const normalizeTableName = createTableNameNormalizer(tablesConfig);
+	/**
+	* Replay an export as a sequence of `item-created` CRDT events, seeding the
+	* rows through the provided CRDT event applicator.
+	*
+	* Schema migration: a dump exported at an older schema version is forward-
+	* migrated up to the DB's current version (running the same event transformers
+	* remote events go through) before being authored — so an old backup can be
+	* restored into an upgraded app. Rows in tables removed by a later migration
+	* are dropped. The reverse (a dump from a *newer* version than this DB) cannot
+	* be down-migrated and is rejected.
+	*
+	* Overwrite-by-default: because the generated events carry fresh (newest) HLC
+	* timestamps, importing a row whose `id` already exists overwrites every field
+	* under last-write-wins, while new ids are inserted. Existing rows absent from
+	* the dump are never touched. This is a restore/seed, not a CRDT merge —
+	* original timestamps are not preserved.
+	*
+	* @param opts.validate When `false`, skip the too-new guard and author the rows
+	*   as-is at the current version (footgun — payloads are not down-migrated).
+	*   Forward migration and per-row payload validation always run regardless.
+	*/
+	return (data, opts) => {
+		const validate = opts?.validate ?? true;
+		const currentVersion = migrator.currentSchemaVersion;
+		if (validate && data.schemaVersion > currentVersion) throw new Error(`Cannot import data from schema version ${data.schemaVersion} into a database at older schema version ${currentVersion}. Exports migrate forward to newer schema versions, not backward.`);
+		const sourceEvents = [];
+		for (const [tableName, rows] of Object.entries(data.tables)) for (const row of rows) sourceEvents.push({
+			schema_version: data.schemaVersion,
+			type: "item-created",
+			dataset: normalizeTableName(tableName),
+			item_id: row.id,
+			payload: JSON.stringify(row)
+		});
+		const events = migrator.migrateEvents(sourceEvents, currentVersion).map((event) => ({
+			type: event.type,
+			dataset: event.dataset,
+			item_id: event.item_id,
+			payload: event.payload
+		}));
+		const applied = applyEvents(events);
+		if (applied instanceof Promise) return applied.then(() => ({ imported: events.length }));
+		return { imported: events.length };
+	};
+}
+function createExportData({ reactiveDb, tablesConfig, schemaVersion }) {
+	const tableNames = tablesConfig.flatMap((config) => [config.crdtTableName, config.baseTableName]);
+	const resolveTables = (requested) => {
+		if (!requested) return tablesConfig;
+		const seenBaseTableNames = /* @__PURE__ */ new Set();
+		const resolved = [];
+		for (const name of requested) {
+			const config = tablesConfig.find((tableConfig) => tableConfig.crdtTableName === name || tableConfig.baseTableName === name);
+			if (!config) throw new Error(`Unknown table "${name}". Known synced tables: ${tableNames.join(", ")}`);
+			if (!seenBaseTableNames.has(config.baseTableName)) {
+				seenBaseTableNames.add(config.baseTableName);
+				resolved.push(config);
+			}
+		}
+		return resolved;
+	};
+	/**
+	* Dump every active entity (the `tombstone = 0` rows) from the synced tables.
+	*
+	* Reads this tab's reactive (in-memory) DB — the state the user currently sees,
+	* which may differ slightly from the worker's authoritative DB while local
+	* writes are in flight.
+	*/
+	return (opts) => {
+		const tables = {};
+		for (const { baseTableName, crdtTableName } of resolveTables(opts?.tables)) {
+			const { rows } = reactiveDb.db.execute(`select * from ${quoteId(crdtTableName)}`, { loggerLevel: "system" });
+			tables[baseTableName] = rows.map(({ tombstone: _tombstone, ...rest }) => rest);
+		}
+		return {
+			schemaVersion,
+			exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			tables
+		};
+	};
+}
+//#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/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([
+		"name",
+		"sql",
+		"type"
+	]).orderBy("name");
+}
+function introspectDb(_db) {
+	const db = _db;
+	const tables = db.executeKysely((db) => tablesQuery(db), { loggerLevel: "system" }).rows;
+	const tablesMetadata = db.executeKysely((db) => db.with("table_list", (qb) => tablesQuery(qb)).selectFrom(["table_list as tl", sql`pragma_table_info(tl.name)`.as("p")]).select([
+		"tl.name as table",
+		"p.cid",
+		"p.name",
+		"p.type",
+		"p.notnull",
+		"p.dflt_value",
+		"p.pk"
+	]).orderBy("tl.name").orderBy("p.cid"), { loggerLevel: "system" }).rows;
+	const columnsByTable = {};
+	for (const row of tablesMetadata) {
+		columnsByTable[row.table] ??= [];
+		columnsByTable[row.table].push(row);
+	}
+	return Object.fromEntries(tables.map(({ name, sql, type }) => {
+		let autoIncrementCol = sql?.split(/[(),]/)?.find((it) => it.toLowerCase().includes("autoincrement"))?.trimStart()?.split(/\s+/)?.[0]?.replace(/["`]/g, "");
+		const columns = columnsByTable[name] ?? [];
+		if (!autoIncrementCol) {
+			const pkCols = columns.filter((r) => r.pk > 0);
+			if (pkCols.length === 1 && pkCols[0].type.toLowerCase() === "integer") autoIncrementCol = pkCols[0].name;
+		}
+		return [name, {
+			name,
+			isView: type === "view",
+			columns: columns.map((col) => ({
+				name: col.name,
+				dataType: col.type,
+				isNullable: !col.notnull,
+				isAutoIncrementing: col.name === autoIncrementCol,
+				hasDefaultValue: col.dflt_value != null,
+				defaultValueSql: col.dflt_value == null ? null : String(col.dflt_value),
+				isPrimaryKey: col.pk > 0,
+				comment: void 0
+			}))
+		}];
+	}));
+}
+//#endregion
+//#region src/logger.ts
+const noopPerformanceLogger = {
+	restart() {},
+	logEnd() {}
+};
+const startPerformanceLogger = (logger, level = "info") => {
+	if (!logger || level === "system") return noopPerformanceLogger;
+	let startTime = performance.now();
+	return {
+		restart: () => {
+			startTime = performance.now();
+		},
+		logEnd: (type, message, logLevel = level) => {
+			logger(type, `${(performance.now() - startTime).toFixed(2)}ms - ${message}`, logLevel);
+		}
+	};
+};
+//#endregion
+//#region src/sqlite-db-wrapper.ts
+var SQLiteDbWrapper = class {
+	db = null;
+	sqlite3;
+	logger;
+	loggerPrefix;
+	loadedDbSchema = null;
+	dataPointers = [];
+	preparedStatements = [];
+	preparedStatementsMap = /* @__PURE__ */ new Map();
+	preparedRawStatementsMap = /* @__PURE__ */ new Map();
+	afterMutatingStatement = null;
+	constructor(opts) {
+		this.db = opts.db();
+		this.sqlite3 = opts.sqlite3;
+		this.logger = opts.logger;
+		this.loggerPrefix = opts.loggerPrefix;
+	}
+	get ensureDb() {
+		if (!this.db) throw new Error("Database is already closed");
+		return this.db;
+	}
+	get dbSchema() {
+		if (!this.loadedDbSchema) this.loadedDbSchema = introspectDb(this);
+		return this.loadedDbSchema;
+	}
+	executeSql(sql, bind, loggerLevel, skipAfterMutatingStatement) {
+		const perf = startPerformanceLogger(this.logger, loggerLevel);
+		const statement = this.ensureDb.prepare(sql);
+		let transaction;
+		try {
+			const statementPointer = statement.pointer;
+			if (!statementPointer) throw new Error("Prepared statement is already finalized");
+			const afterMutatingStatement = !skipAfterMutatingStatement && this.afterMutatingStatement && this.sqlite3.capi.sqlite3_stmt_readonly(statementPointer) === 0 ? this.afterMutatingStatement : null;
+			let totalChangesBefore = 0;
+			if (afterMutatingStatement) {
+				transaction = this.beginStatementTransaction();
+				totalChangesBefore = this.sqlite3.capi.sqlite3_total_changes(this.ensureDb);
+			}
+			if (bind && bind.length > 0) statement.bind(bind);
+			const rows = [];
+			let columnNames;
+			while (statement.step()) {
+				columnNames ??= statement.getColumnNames([]);
+				const values = statement.get([]);
+				const row = Object.create(null);
+				for (let index = 0; index < columnNames.length; index++) row[columnNames[index]] = values[index];
+				rows.push(row);
+			}
+			statement.finalize();
+			perf.logEnd(`${this.loggerPrefix ?? ""}:query`, sql, loggerLevel);
+			if (transaction) {
+				if (this.sqlite3.capi.sqlite3_total_changes(this.ensureDb) !== totalChangesBefore) afterMutatingStatement?.(this);
+				transaction.commit();
+			}
+			return { rows };
+		} catch (error) {
+			statement.finalize();
+			transaction?.rollback();
+			throw error;
+		}
+	}
+	execute(opts, options) {
+		const sql = typeof opts === "string" ? opts : opts.sql;
+		const bind = typeof opts === "string" ? void 0 : opts.parameters;
+		return this.executeSql(sql, bind, options?.loggerLevel, options?.skipAfterMutatingStatement ?? false);
+	}
+	setAfterMutatingStatement(callback) {
+		if (this.afterMutatingStatement) throw new Error("An afterMutatingStatement callback is already registered");
+		this.afterMutatingStatement = callback;
+	}
+	executeTransaction(callback) {
+		const transaction = this.beginTransaction();
+		try {
+			const result = callback(this);
+			transaction.commit();
+			return result;
+		} catch (error) {
+			transaction.rollback();
+			throw error;
+		}
+	}
+	isInTransaction() {
+		return this.sqlite3.capi.sqlite3_get_autocommit(this.ensureDb) === 0;
+	}
+	beginTransaction() {
+		this.executePreparedRaw({
+			key: "$begin-transaction",
+			sql: "begin",
+			meta: { loggerLevel: "system" }
+		});
+		return {
+			commit: () => {
+				this.executePreparedRaw({
+					key: "$commit-transaction",
+					sql: "commit",
+					meta: { loggerLevel: "system" }
+				});
+			},
+			rollback: () => {
+				this.executePreparedRaw({
+					key: "$rollback-transaction",
+					sql: "rollback",
+					meta: { loggerLevel: "system" }
+				});
+			}
+		};
+	}
+	beginStatementTransaction() {
+		if (!this.isInTransaction()) return this.beginTransaction();
+		this.executePreparedRaw({
+			key: "$begin-statement-savepoint",
+			sql: "savepoint sqlite_sync_statement",
+			meta: { loggerLevel: "system" }
+		});
+		return {
+			commit: () => {
+				this.executePreparedRaw({
+					key: "$commit-statement-savepoint",
+					sql: "release savepoint sqlite_sync_statement",
+					meta: { loggerLevel: "system" }
+				});
+			},
+			rollback: () => {
+				this.executePreparedRaw({
+					key: "$rollback-statement-savepoint",
+					sql: "rollback to savepoint sqlite_sync_statement",
+					meta: { loggerLevel: "system" }
+				});
+				this.executePreparedRaw({
+					key: "$release-rolled-back-statement-savepoint",
+					sql: "release savepoint sqlite_sync_statement",
+					meta: { loggerLevel: "system" }
+				});
+			}
+		};
+	}
+	prepare(sql, opts) {
+		const perf = startPerformanceLogger(this.logger, opts?.loggerLevel);
+		const stmt = this.ensureDb.prepare(sql);
+		perf.logEnd(`${this.loggerPrefix ?? ""}:prepare`, sql, opts?.loggerLevel);
+		let isFinalized = false;
+		const execute = (params) => {
+			if (isFinalized) throw new Error("Statement is finalized");
+			const perf = startPerformanceLogger(this.logger, opts?.loggerLevel);
+			try {
+				if (params.length > 0) stmt.bind(params);
+				const results = [];
+				let columnNames;
+				while (stmt.step()) {
+					columnNames ??= stmt.getColumnNames([]);
+					const values = stmt.get([]);
+					const row = {};
+					for (let index = 0; index < columnNames.length; index++) row[columnNames[index]] = values[index];
+					results.push(row);
+				}
+				return results;
+			} finally {
+				stmt.reset(true);
+				perf.logEnd(`${this.loggerPrefix ?? ""}:prepare-execute`, sql, opts?.loggerLevel);
+			}
+		};
+		const finalize = () => {
+			isFinalized = true;
+			stmt.finalize();
+		};
+		const preparedStatement = {
+			execute,
+			finalize,
+			get isFinalized() {
+				return isFinalized;
+			}
+		};
+		this.preparedStatements.push(preparedStatement);
+		return preparedStatement;
+	}
+	prepareKysely(opts) {
+		return (factory) => {
+			const query = factory(dummyKysely, (key) => key).compile();
+			const statement = this.prepare(query.sql, opts);
+			return { execute: (parameters) => {
+				const params = query.parameters.map((param) => parameters[param]);
+				return statement.execute(params);
+			} };
+		};
+	}
+	executeKysely(factory, options) {
+		const query = factory(dummyKysely).compile();
+		return this.execute(query, options);
+	}
+	executePrepared(key, params, factory, meta) {
+		let statement = this.preparedStatementsMap.get(key);
+		if (!statement) {
+			statement = this.prepareKysely(meta)(factory);
+			this.preparedStatementsMap.set(key, statement);
+		}
+		return statement.execute(params);
+	}
+	executePreparedRaw({ key, sql, params, meta }) {
+		let statement = this.preparedRawStatementsMap.get(key);
+		if (!statement) {
+			statement = this.prepare(sql, meta);
+			this.preparedRawStatementsMap.set(key, statement);
+		}
+		return statement.execute(params ?? []);
+	}
+	sql(templateOrString, ...parameters) {
+		if (typeof templateOrString === "string") return this.execute({
+			sql: templateOrString,
+			parameters
+		});
+		return this.execute({
+			sql: templateOrString.join("?"),
+			parameters
+		});
+	}
+	createScalarFunction({ name, callback, deterministic, directOnly, innocuous }) {
+		return this.ensureDb.createFunction({
+			name,
+			xFunc: (_, ...args) => {
+				return callback(...args);
+			},
+			arity: callback.length,
+			deterministic,
+			directOnly,
+			innocuous
+		});
+	}
+	useSnapshot(snapshot) {
+		const perf = startPerformanceLogger(this.logger, "system");
+		const dataPointer = this.sqlite3.wasm.allocFromTypedArray(snapshot);
+		this.dataPointers.push(dataPointer);
+		const resultCode = this.sqlite3.capi.sqlite3_deserialize(this.ensureDb, "main", dataPointer, snapshot.byteLength, snapshot.byteLength, this.sqlite3.capi.SQLITE_DESERIALIZE_FREEONCLOSE | this.sqlite3.capi.SQLITE_DESERIALIZE_RESIZEABLE);
+		this.ensureDb.checkRc(resultCode);
+		this.invalidateDbSchema();
+		perf.logEnd("useSnapshot", "success", "system");
+	}
+	createSnapshot() {
+		return this.sqlite3.capi.sqlite3_js_db_export(this.ensureDb);
+	}
+	invalidateDbSchema() {
+		this.loadedDbSchema = null;
+	}
+	cleanup() {
+		this.preparedStatements.forEach((stmt) => {
+			stmt.finalize();
+		});
+		this.preparedStatements.splice(0);
+		this.preparedStatementsMap.clear();
+		this.preparedRawStatementsMap.clear();
+	}
+	close() {
+		this.cleanup();
+		this.db?.close();
+		this.db = null;
+	}
+};
+//#endregion
+//#region src/migrations/migrator.ts
+const protectedColumns = ["id", "tombstone"];
+function assertColumnNotProtected(column, operation) {
+	if (protectedColumns.includes(column)) throw new Error(`Cannot ${operation} protected column "${column}"`);
+}
+const migrationSteps = {
+	createTable: (table, build) => ({ sql: (db) => build(db.schema.createTable(table)) }),
+	dropTable: (table) => ({
+		sql: (db) => db.schema.dropTable(table),
+		eventTransformer: { [table]: () => null },
+		updateLogMutations: [{
+			type: "drop-table",
+			table
+		}]
+	}),
+	createIndex: (indexName, build) => ({ sql: (db) => build(db.schema.createIndex(indexName)) }),
+	dropIndex: (indexName) => ({ sql: (db) => db.schema.dropIndex(indexName) }),
+	renameTable: ({ oldTable, newTable }) => ({
+		sql: (db) => db.schema.alterTable(oldTable).renameTo(newTable),
+		eventTransformer: { [oldTable]: (event) => {
+			event.dataset = newTable;
+			return event;
+		} },
+		updateLogMutations: [{
+			type: "rename-table",
+			oldTable,
+			newTable
+		}]
+	}),
+	renameColumn: ({ table, oldColumn, newColumn }) => {
+		assertColumnNotProtected(oldColumn, "rename");
+		assertColumnNotProtected(newColumn, "rename to");
+		return {
+			sql: (db) => db.schema.alterTable(table).renameColumn(oldColumn, newColumn),
+			eventTransformer: { [table]: (event) => {
+				if (event.type !== "item-updated" && event.type !== "item-created" || !(oldColumn in event.payload)) return event;
+				const oldVal = event.payload[oldColumn];
+				delete event.payload[oldColumn];
+				event.payload[newColumn] = oldVal;
+				return event;
+			} },
+			updateLogMutations: [{
+				type: "rename-column",
+				table,
+				oldColumn,
+				newColumn
+			}]
+		};
+	},
+	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,
+			column
+		}]
+	}),
+	dropColumn: ({ table, column }) => {
+		assertColumnNotProtected(column, "drop");
+		return {
+			sql: (db) => db.schema.alterTable(table).dropColumn(column),
+			eventTransformer: { [table]: (event) => {
+				if (!(column in event.payload)) return event;
+				delete event.payload[column];
+				if (event.type === "item-updated" && Object.keys(event.payload).length === 0) return null;
+				return event;
+			} },
+			updateLogMutations: [{
+				type: "drop-column",
+				table,
+				column
+			}]
+		};
+	}
+};
+function buildMigrationSql(steps) {
+	return steps.flatMap((step) => Array.isArray(step.sql) ? step.sql : [step.sql]).map((sql) => {
+		if (typeof sql === "string") return {
+			sql,
+			parameters: []
+		};
+		if (typeof sql === "function") {
+			const query = sql(dummyKysely).compile();
+			return {
+				sql: query.sql,
+				parameters: query.parameters
+			};
+		}
+		if ("compile" in sql) {
+			const query = sql.compile();
+			return {
+				sql: query.sql,
+				parameters: query.parameters
+			};
+		}
+		return {
+			sql: sql.sql,
+			parameters: sql.parameters ?? []
+		};
+	});
+}
+function buildMigrationEventTransformer(steps) {
+	const transformers = [];
+	for (const step of steps) if (step.eventTransformer) transformers.push(...Object.entries(step.eventTransformer));
+	if (transformers.length === 0) return;
+	return (event) => {
+		let transformedEvent = event;
+		for (const [table, transformer] of transformers) {
+			if (transformedEvent === null) return null;
+			if (transformedEvent.dataset !== table) continue;
+			transformedEvent = transformer(transformedEvent);
+			if (transformedEvent === null) return null;
+		}
+		return transformedEvent;
+	};
+}
+function createMigrations(buildMigrations) {
+	return Object.fromEntries(Object.entries(buildMigrations(migrationSteps)).map(([version, steps]) => {
+		const versionNumber = Number(version);
+		if (Number.isNaN(versionNumber)) throw new Error(`Invalid migration version: ${version}`);
+		if (versionNumber < 0) throw new Error(`Migration version cannot be negative: ${version}`);
+		const updateLogMutations = steps.flatMap((step) => step.updateLogMutations ?? []);
+		return [version, {
+			sql: buildMigrationSql(steps),
+			eventTransformer: buildMigrationEventTransformer(steps),
+			...updateLogMutations.length > 0 && { updateLogMutations }
+		}];
+	}));
+}
+function createMigrator({ migrations, schemaVersion, updateLogTableName }) {
+	const latestSchemaVersion = Math.max(...Object.keys(migrations).map(Number));
+	const sortedMigrations = Object.entries(migrations).map(([v, m]) => [Number(v), m]).sort((a, b) => a[0] - b[0]);
+	const applyMigration = (db, version, migration) => {
+		if (version <= schemaVersion.current) throw new Error(`Cannot apply migration ${version} to schema version ${schemaVersion.current}`);
+		db.startTransaction((tx) => {
+			for (const statement of migration.sql) tx.execute(statement.sql, statement.parameters);
+			if (updateLogTableName && migration.updateLogMutations) for (const mutation of migration.updateLogMutations) switch (mutation.type) {
+				case "rename-table":
+					tx.execute(`DELETE FROM ${updateLogTableName} WHERE "dataset" = ?`, [mutation.newTable], { loggerLevel: "system" });
+					tx.execute(`UPDATE ${updateLogTableName} SET "dataset" = ? WHERE "dataset" = ?`, [mutation.newTable, mutation.oldTable], { loggerLevel: "system" });
+					break;
+				case "drop-table":
+					tx.execute(`DELETE FROM ${updateLogTableName} WHERE "dataset" = ?`, [mutation.table], { loggerLevel: "system" });
+					break;
+				case "rename-column":
+					tx.execute(`UPDATE ${updateLogTableName}
+SET "payload" = COALESCE(
+  (
+    SELECT json_group_object(CASE WHEN "key" = ? THEN ? ELSE "key" END, "value")
+    FROM json_each("payload")
+    WHERE "key" != ?
+  ),
+  '{}'
+)
+WHERE "dataset" = ?
+  AND EXISTS (SELECT 1 FROM json_each("payload") WHERE "key" = ? OR "key" = ?)`, [
+						mutation.oldColumn,
+						mutation.newColumn,
+						mutation.newColumn,
+						mutation.table,
+						mutation.oldColumn,
+						mutation.newColumn
+					], { loggerLevel: "system" });
+					break;
+				case "add-column":
+				case "drop-column":
+					tx.execute(`UPDATE ${updateLogTableName}
+SET "payload" = COALESCE(
+  (SELECT json_group_object("key", "value") FROM json_each("payload") WHERE "key" != ?),
+  '{}'
+)
+WHERE "dataset" = ?
+  AND EXISTS (SELECT 1 FROM json_each("payload") WHERE "key" = ?)`, [
+						mutation.column,
+						mutation.table,
+						mutation.column
+					], { loggerLevel: "system" });
+					break;
+				default: throw new Error(`Unsupported update-log mutation: ${JSON.stringify(mutation)}`);
+			}
+			schemaVersion.current = version;
+		});
+	};
+	const migrateEvent = (event, targetVersion) => {
+		targetVersion ??= latestSchemaVersion;
+		if (targetVersion > schemaVersion.current) throw new Error(`Target schema version ${targetVersion} is greater than current schema version ${schemaVersion.current}`);
+		if (isNoOpCrdtEventPayload(event.payload)) {
+			if (event.schema_version < targetVersion) event.schema_version = targetVersion;
+			return event;
+		}
+		if (event.schema_version >= targetVersion) return event;
+		const fromVersion = event.schema_version;
+		let crdtEvent = {
+			dataset: event.dataset,
+			item_id: event.item_id,
+			type: event.type,
+			payload: JSON.parse(event.payload)
+		};
+		for (let i = 0; i < sortedMigrations.length; i++) {
+			const [version, migration] = sortedMigrations[i];
+			if (version <= fromVersion) continue;
+			if (version > targetVersion) break;
+			const transformer = migration.eventTransformer;
+			if (transformer) {
+				crdtEvent = transformer(crdtEvent);
+				if (crdtEvent === null) return null;
+			}
+		}
+		if (crdtEvent === null) return null;
+		event.schema_version = targetVersion;
+		event.dataset = crdtEvent.dataset;
+		event.item_id = crdtEvent.item_id;
+		event.type = crdtEvent.type;
+		event.payload = JSON.stringify(crdtEvent.payload);
+		return event;
+	};
+	const migrateEvents = (events, targetVersion) => {
+		return events.map((event) => migrateEvent(event, targetVersion ?? latestSchemaVersion)).filter((event) => event !== null);
+	};
+	return {
+		latestSchemaVersion,
+		get currentSchemaVersion() {
+			return schemaVersion.current;
+		},
+		migrateDbToLatest: (db) => {
+			const currentSchemaVersion = schemaVersion.current;
+			if (currentSchemaVersion >= latestSchemaVersion) return;
+			for (let i = 0; i < sortedMigrations.length; i++) {
+				const [version, migration] = sortedMigrations[i];
+				if (version <= currentSchemaVersion) continue;
+				applyMigration(db, version, migration);
+			}
+		},
+		migrateEvent,
+		migrateEvents
+	};
+}
+//#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"],
+	integer: ["INTEGER", "INT"],
+	real: [
+		"REAL",
+		"DOUBLE",
+		"FLOAT"
+	],
+	boolean: [
+		"BOOLEAN",
+		"INTEGER",
+		"INT"
+	],
+	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.
+*
+* 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;
+	const db = new SQLiteDbWrapper({
+		db: () => new sqlite3.oo1.DB({ filename: ":memory:" }),
+		logger: () => {},
+		loggerPrefix: "schema-verify",
+		sqlite3
+	});
+	try {
+		const migrator = createMigrator({
+			migrations: schema.migrations,
+			schemaVersion: createStoredValue({ initialValue: -1 })
+		});
+		try {
+			migrator.migrateDbToLatest({ startTransaction: (callback) => {
+				db.executeTransaction((tx) => callback({ execute: (sql, parameters, meta) => tx.execute({
+					sql,
+					parameters
+				}, meta) }));
+			} });
+		} catch (error) {
+			return [{
+				table: "(migrations)",
+				message: `migration replay failed on an empty database: ${error instanceof Error ? error.message : String(error)}`
+			}];
+		}
+		const introspection = introspectDb(db);
+		const issues = [];
+		for (const { crdtTableName, baseTableName } of schema.tablesConfig) {
+			const declared = schema.tables[crdtTableName];
+			if (!declared) continue;
+			verifyTable(db, baseTableName, declared.columns, introspection[baseTableName], issues);
+		}
+		return issues;
+	} finally {
+		db.close();
+	}
+}
+function formatSchemaVerificationIssues(issues) {
+	const lines = issues.map((issue) => ` - table "${issue.table}"${issue.column ? ` column "${issue.column}"` : ""}: ${issue.message}`);
+	return `sync schema verification failed (${issues.length} issue${issues.length === 1 ? "" : "s"}):\n${lines.join("\n")}`;
+}
+function verifyTable(db, table, declaredColumns, actual, issues) {
+	if (!actual) {
+		issues.push({
+			table,
+			message: "declared in the schema but missing after migrations — add a createTable step in a new version"
+		});
+		return;
+	}
+	if (actual.isView) {
+		issues.push({
+			table,
+			message: "expected a base table, but migrations created a view with this name"
+		});
+		return;
+	}
+	const actualColumns = new Map(actual.columns.map((column) => [column.name, column]));
+	for (const [name, meta] of Object.entries(declaredColumns)) {
+		const column = actualColumns.get(name);
+		if (!column) {
+			issues.push({
+				table,
+				column: name,
+				message: "declared in the schema but missing after migrations — add an addColumn step in a new version"
+			});
+			continue;
+		}
+		const accepted = acceptedDataTypes[meta.kind];
+		if (!accepted.includes(column.dataType.toUpperCase())) issues.push({
+			table,
+			column: name,
+			message: `type mismatch — schema declares ${meta.kind} (${accepted.join("/")}), migrated column is ${column.dataType.toUpperCase()}`
+		});
+		if (column.isNullable !== meta.nullable) issues.push({
+			table,
+			column: name,
+			message: meta.nullable ? "schema declares the column nullable, but the migrated column is NOT NULL" : "schema declares the column NOT NULL, but the migrated column is nullable"
+		});
+		if (name === "id" && !column.isPrimaryKey) issues.push({
+			table,
+			column: name,
+			message: "the id column must be the PRIMARY KEY"
+		});
+		verifyDefault(db, table, name, meta, column.defaultValueSql, issues);
+	}
+	for (const column of actual.columns) if (!(column.name in declaredColumns)) issues.push({
+		table,
+		column: column.name,
+		message: "created by migrations but not declared in the schema — sync event payloads include every column, so declare it (or drop it in a new version)"
+	});
+}
+function verifyDefault(db, table, column, meta, defaultValueSql, issues) {
+	if (meta.hasDefault && meta.defaultValue !== null && defaultValueSql === null) {
+		issues.push({
+			table,
+			column,
+			message: `schema declares default ${formatExpected(meta)}, but the migrated column has no default`
+		});
+		return;
+	}
+	if (!meta.hasDefault && defaultValueSql !== null) {
+		issues.push({
+			table,
+			column,
+			message: `migrated column has default ${defaultValueSql}, but the schema declares none`
+		});
+		return;
+	}
+	if (!meta.hasDefault || defaultValueSql === null) return;
+	let actual;
+	try {
+		actual = db.execute({
+			sql: `SELECT (${defaultValueSql}) AS value`,
+			parameters: []
+		}).rows[0]?.value;
+	} catch {
+		actual = void 0;
+	}
+	if (actual !== expectedDefaultValue(meta)) issues.push({
+		table,
+		column,
+		message: `default mismatch — schema declares ${formatExpected(meta)}, migrated column default is ${defaultValueSql}`
+	});
+}
+/** The declared default normalized to how SQLite stores it (booleans as 0/1). */
+function expectedDefaultValue(meta) {
+	if (meta.defaultValue === null) return null;
+	switch (meta.kind) {
+		case "boolean": return meta.defaultValue ? 1 : 0;
+		case "integer":
+		case "real": return Number(meta.defaultValue);
+		case "text":
+		case "enum": return String(meta.defaultValue);
+	}
+}
+function formatExpected(meta) {
+	const expected = expectedDefaultValue(meta);
+	return typeof expected === "string" ? `'${expected}'` : String(expected);
+}
+//#endregion
+//#region src/sqlite-crdt/apply-crdt-event.ts
+const createSQLiteCrdtApplyFunction = ({ db, dbConfig }) => {
+	return createCrdtApplyFunction({
+		getCrdtUpdateLog(opts) {
+			const [metaRow] = db.executePrepared("get-item-crdt-meta", {
+				item_id: opts.itemId,
+				dataset: opts.dataset
+			}, (db, params) => {
+				return db.selectFrom(dbConfig.updateLogTable.fullIdentifier).select("payload").where("item_id", "=", params("item_id")).where("dataset", "=", params("dataset"));
+			}, { loggerLevel: "system" });
+			return metaRow ? JSON.parse(metaRow.payload) : null;
+		},
+		insertCrdtUpdateLog(opts) {
+			db.executePrepared("insert-crdt-update-log", {
+				item_id: opts.itemId,
+				dataset: opts.dataset,
+				payload: opts.payload
+			}, (db, params) => db.insertInto(dbConfig.updateLogTable.fullIdentifier).values({
+				item_id: params("item_id"),
+				dataset: params("dataset"),
+				payload: params("payload")
+			}), { loggerLevel: "system" });
+		},
+		updateCrdtUpdateLog(opts) {
+			db.executePrepared("update-crdt-update-log", {
+				item_id: opts.itemId,
+				dataset: opts.dataset,
+				payload: opts.payload
+			}, (db, params) => db.updateTable(dbConfig.updateLogTable.fullIdentifier).set({ payload: params("payload") }).where("item_id", "=", params("item_id")).where("dataset", "=", params("dataset")), { loggerLevel: "system" });
+		},
+		insertItem(opts) {
+			const keys = Object.keys(opts.payload).sort();
+			const insertPayload = {};
+			for (const key of keys) insertPayload[key] = key;
+			db.executePrepared(`crdt-insert-item-${opts.dataset}-${keys.join("-")}`, opts.payload, (db) => db.insertInto(opts.dataset).values(insertPayload), { loggerLevel: "system" });
+		},
+		updateItem(opts) {
+			const keys = Array.from(Object.keys(opts.payload));
+			keys.sort();
+			db.executePreparedRaw({
+				key: `update-item-${opts.dataset}-${keys.join("-")}`,
+				sql: `update ${quoteId(opts.dataset)} set ${keys.map((key) => `${quoteId(key)} = ?`).join(",")} where id = ?`,
+				params: [...keys.map((key) => opts.payload[key]), opts.itemId],
+				meta: { loggerLevel: "system" }
+			});
+		}
+	});
+};
+function createCrdtApplyFunction({ getCrdtUpdateLog, insertItem, insertCrdtUpdateLog, updateItem, updateCrdtUpdateLog }) {
+	const applyItemCreated = ({ event }) => {
+		const eventPayload = JSON.parse(event.payload);
+		eventPayload.tombstone = 0;
+		insertItem({
+			dataset: event.dataset,
+			payload: eventPayload
+		});
+		const newUpdateLog = {};
+		for (const key of Object.keys(eventPayload)) newUpdateLog[key] = event.timestamp;
+		insertCrdtUpdateLog({
+			dataset: event.dataset,
+			itemId: event.item_id,
+			payload: JSON.stringify(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);
+		const updatePayload = {};
+		let hasUpdates = false;
+		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;
+				meta[key] = currentUpdateTimestamp;
+				hasUpdates = true;
+			}
+		}
+		if (!hasUpdates) return;
+		updateItem({
+			dataset: event.dataset,
+			itemId: event.item_id,
+			payload: updatePayload
+		});
+		updateCrdtUpdateLog({
+			dataset: event.dataset,
+			itemId: event.item_id,
+			payload: JSON.stringify(meta)
+		});
+	};
+	return (event) => {
+		if (isNoOpCrdtEventPayload(event.payload)) return;
+		const meta = getCrdtUpdateLog({
+			itemId: event.item_id,
+			dataset: event.dataset
+		});
+		if (event.type !== "item-created" && event.type !== "item-updated" && event.type !== "item-deleted") throw new Error(`Unknown event type: ${event.type}`);
+		if (meta) {
+			applyItemUpdated({
+				event,
+				meta
+			});
+			return;
+		}
+		if (event.type === "item-created") {
+			applyItemCreated({ event });
+			return;
+		}
+		throw new Error(`Item ${event.item_id} in dataset ${event.dataset} not found`);
+	};
+}
+//#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;
+	const db = storage.db;
+	const crdtEventsTable = storage.dbConfig.eventsTable.fullIdentifier;
+	const quotedEventsTable = quoteId(storage.dbConfig.eventsTable.fullIdentifier);
+	const noOpPayloadSqlLiteral = `'${CRDT_EVENT_NO_OP_PAYLOAD}'`;
+	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;
+	};
+	let sequentialSyncId = getInitialSequentialSyncId();
+	const eventTarget = createTypedEventTarget();
+	const EVENT_COLUMNS = [
+		"sync_id",
+		"schema_version",
+		"status",
+		"type",
+		"timestamp",
+		"origin",
+		"source_node_id",
+		"dataset",
+		"item_id",
+		"payload"
+	];
+	const quotedEventColumns = EVENT_COLUMNS.map((column) => quoteId(column)).join(", ");
+	const persistEventsSql = `insert into ${quotedEventsTable} (${quotedEventColumns}) select ${EVENT_COLUMNS.map((_, index) => `"value"->>${index}`).join(", ")} from json_each(?)`;
+	const pendingEventsSql = `select json_group_array(json_array(${quotedEventColumns})) as "batch" from (select ${quotedEventColumns} from ${quotedEventsTable} where "status" = ? order by "sync_id" asc limit ?)`;
+	const PERSIST_EVENTS_CHUNK_SIZE = 100;
+	const eventToRow = (event) => [
+		event.sync_id,
+		event.schema_version,
+		event.status,
+		event.type,
+		event.timestamp,
+		event.origin,
+		event.source_node_id,
+		event.dataset,
+		event.item_id,
+		event.payload
+	];
+	const rowToEvent = (row) => ({
+		sync_id: row[0],
+		schema_version: row[1],
+		status: row[2],
+		type: row[3],
+		timestamp: row[4],
+		origin: row[5],
+		source_node_id: row[6],
+		dataset: row[7],
+		item_id: row[8],
+		payload: row[9]
+	});
+	const persistEvents = (tx, events) => {
+		for (let offset = 0; offset < events.length; offset += PERSIST_EVENTS_CHUNK_SIZE) {
+			const chunk = events.slice(offset, offset + PERSIST_EVENTS_CHUNK_SIZE);
+			tx.executePreparedRaw({
+				key: "persist-crdt-events",
+				sql: persistEventsSql,
+				params: [JSON.stringify(chunk.map(eventToRow))],
+				meta: { loggerLevel: "system" }
+			});
+		}
+	};
+	const readPendingEvents = (limit) => {
+		const [row] = db.executePreparedRaw({
+			key: "get-enqueued-pending-events",
+			sql: pendingEventsSql,
+			params: ["pending", limit],
+			meta: { loggerLevel: "system" }
+		});
+		return JSON.parse(row.batch).map(rowToEvent);
+	};
+	const enqueueEvents = (origin, sourceNodeId, events) => {
+		const beforeSyncId = localSyncId;
+		if (events.length === 0) return {
+			beforeSyncId,
+			afterSyncId: beforeSyncId,
+			processed: Promise.resolve()
+		};
+		db.executeTransaction((tx) => {
+			const persistedEvents = events.map((event) => ({
+				schema_version: event.schema_version ?? storage.migrator.currentSchemaVersion,
+				timestamp: event.timestamp ?? serializeHLC(storage.hlc.getNextHLC()),
+				type: event.type,
+				dataset: event.dataset,
+				item_id: event.item_id,
+				origin,
+				source_node_id: sourceNodeId,
+				payload: event.payload,
+				sync_id: ++localSyncId,
+				status: "pending"
+			}));
+			persistEvents(tx, persistedEvents);
+		});
+		return {
+			beforeSyncId,
+			afterSyncId: localSyncId,
+			processed: processEnqueuedEvents()
+		};
+	};
+	const enqueueLocalEvents = (events, sourceNodeId) => {
+		return enqueueEvents("local", sourceNodeId, events);
+	};
+	const enqueueOwnEvents = (events) => {
+		return enqueueEvents("own", storage.nodeId, events);
+	};
+	const enqueueRemoteEvents = (events) => {
+		return enqueueEvents("remote", "", events);
+	};
+	const notifyEventsApplied = (events) => {
+		const onEventApplied = storage.onEventApplied;
+		if (!onEventApplied || events.length === 0) return;
+		queueMicrotask(() => {
+			let callbackFailed = false;
+			let firstError;
+			for (const event of events) try {
+				onEventApplied(event);
+			} catch (error) {
+				callbackFailed = true;
+				firstError ??= error;
+			}
+			if (callbackFailed) throw firstError;
+		});
+	};
+	const applyOwnEvents = (events) => {
+		const schema = storage.schema;
+		if (!schema) throw new Error("applyOwnEvents requires a sync schema; none was provided to createCrdtStorage");
+		const validatedEvents = [];
+		const errors = [];
+		for (const [index, event] of events.entries()) {
+			const result = validateNewCrdtEvent(schema, {
+				type: event.type,
+				dataset: event.dataset,
+				item_id: event.item_id,
+				payload: event.payload
+			});
+			if (!result.success) {
+				errors.push(...result.errors.map((error) => `[${index}] ${error}`));
+				continue;
+			}
+			validatedEvents.push(result.event);
+		}
+		if (errors.length > 0) throw new CrdtEventValidationError(errors);
+		db.executeTransaction((tx) => {
+			const persistedEvents = validatedEvents.map((event) => ({
+				schema_version: storage.migrator.currentSchemaVersion,
+				timestamp: serializeHLC(storage.hlc.getNextHLC()),
+				type: event.type,
+				dataset: event.dataset,
+				item_id: event.item_id,
+				origin: "own-applied",
+				source_node_id: storage.nodeId,
+				payload: JSON.stringify(event.payload),
+				sync_id: ++localSyncId,
+				status: "pending"
+			}));
+			persistEvents(tx, persistedEvents);
+			for (const persistedEvent of persistedEvents) applyCrdtEvent(persistedEvent);
+		});
+		processEnqueuedEvents();
+	};
+	const applyOwnSnapshot = (snapshot) => {
+		const syncId = localSyncId + 1;
+		db.executeTransaction((tx) => {
+			const [currentRow] = tx.executePreparedRaw({
+				key: `get-crdt-snapshot-row-${snapshot.dataset}`,
+				sql: `select * from ${quoteId(snapshot.dataset)} where "id" = ? limit 1`,
+				params: [snapshot.item_id],
+				meta: { loggerLevel: "system" }
+			});
+			const event = {
+				schema_version: storage.migrator.currentSchemaVersion,
+				timestamp: serializeHLC(storage.hlc.getNextHLC()),
+				type: "item-created",
+				dataset: snapshot.dataset,
+				item_id: snapshot.item_id,
+				origin: "own-applied",
+				source_node_id: storage.nodeId,
+				payload: JSON.stringify({
+					...currentRow ?? {},
+					...snapshot.patch,
+					id: snapshot.item_id,
+					tombstone: false
+				}),
+				sync_id: syncId,
+				status: "pending"
+			};
+			tx.executePreparedRaw({
+				key: "replace-crdt-row-history-with-no-ops",
+				sql: `update ${quotedEventsTable}
+set "payload" = ?
+where "dataset" = ? and "item_id" = ? and "payload" <> ${noOpPayloadSqlLiteral}`,
+				params: [
+					CRDT_EVENT_NO_OP_PAYLOAD,
+					event.dataset,
+					event.item_id
+				],
+				meta: { loggerLevel: "system" }
+			});
+			persistEvents(tx, [event]);
+			applyCrdtEvent(event);
+		});
+		localSyncId = syncId;
+		processEnqueuedEvents();
+	};
+	const applyOwnEventFromTransaction = (tx, event) => {
+		const persistedEvent = {
+			schema_version: storage.migrator.currentSchemaVersion,
+			timestamp: serializeHLC(storage.hlc.getNextHLC()),
+			type: event.type,
+			dataset: event.dataset,
+			item_id: event.item_id,
+			origin: "own-applied",
+			source_node_id: storage.nodeId,
+			payload: event.payload,
+			sync_id: ++localSyncId,
+			status: "pending"
+		};
+		persistEvents(tx, [persistedEvent]);
+		applyCrdtEvent(persistedEvent);
+	};
+	const applyOwnIntentsFromTransaction = (tx, intents) => {
+		let appliedEvents = 0;
+		for (const intent of intents) {
+			if (intent.type === "item-updated") {
+				if (intent.item_id !== intent.new_item_id) throw new Error(`Cannot update the "id" column of an item. It is used to identify the item and must be immutable.`);
+				if (intent.payload_json === "{}") continue;
+			}
+			applyOwnEventFromTransaction(tx, {
+				type: intent.type,
+				dataset: intent.dataset,
+				item_id: intent.item_id,
+				payload: intent.payload_json
+			});
+			appliedEvents++;
+		}
+		return { appliedEvents };
+	};
+	const dispatchEventsApplied = (previousSequentialSyncId) => {
+		if (sequentialSyncId <= previousSequentialSyncId) return;
+		eventTarget.dispatchEvent("events-applied", {
+			syncId: sequentialSyncId,
+			eventHlcSum: sequentialSyncId === localSyncId ? eventHlcAccumulator?.current ?? null : null
+		});
+	};
+	const publishProcessedBatch = ({ previousSequentialSyncId, nextSequentialSyncId, appliedEvents }) => {
+		sequentialSyncId = nextSequentialSyncId;
+		notifyEventsApplied(appliedEvents);
+		dispatchEventsApplied(previousSequentialSyncId);
+	};
+	const hasPendingEvents = () => {
+		return db.executePrepared("has-pending-events", { status: "pending" }, (db, params) => db.selectFrom(crdtEventsTable).select("sync_id").where("status", "=", params("status")).limit(sql.lit(1)), { loggerLevel: "system" }).length > 0;
+	};
+	const getEventsBatch = (options) => {
+		const limit = options.limit ?? 50;
+		const queryParams = {
+			limit: limit + 1,
+			status: options.status ?? null,
+			afterSyncId: options.afterSyncId ?? null,
+			excludeOrigin: options.excludeOrigin ?? null,
+			excludeNodeId: options.excludeNodeId ?? null,
+			maxSyncId: options.status === "applied" ? sequentialSyncId : localSyncId
+		};
+		const filterKeys = [queryParams.excludeNodeId ? "nodeid" : "no-nodeid", queryParams.excludeOrigin ? "origin" : "no-origin"];
+		const events = db.executePrepared(`get-events-batch-${filterKeys.join("-")}`, queryParams, (db, params) => db.selectFrom(crdtEventsTable).where("sync_id", ">", params("afterSyncId")).where("sync_id", "<=", params("maxSyncId")).where("status", "=", params("status")).$if(!!queryParams.excludeNodeId, (qb) => qb.where("source_node_id", "!=", params("excludeNodeId"))).$if(!!queryParams.excludeOrigin, (qb) => qb.where("origin", "!=", params("excludeOrigin"))).selectAll().limit(params("limit")).orderBy("sync_id", "asc"), { loggerLevel: "system" });
+		const hasMore = events.length > limit;
+		if (hasMore) events.pop();
+		const lastReturnedSyncId = events[events.length - 1]?.sync_id ?? options.afterSyncId ?? 0;
+		let nextSyncId = lastReturnedSyncId;
+		if (!hasMore && options.status === "applied") nextSyncId = Math.max(lastReturnedSyncId, queryParams.maxSyncId);
+		return {
+			events,
+			hasMore,
+			nextSyncId
+		};
+	};
+	const checkIsQuiescent = (pushedSyncId) => {
+		if (hasPendingEvents()) return false;
+		return getEventsBatch({
+			status: "applied",
+			afterSyncId: pushedSyncId,
+			excludeOrigin: "remote",
+			limit: 1
+		}).events.length === 0;
+	};
+	const applyCrdtEvent = createSQLiteCrdtApplyFunction({
+		db,
+		dbConfig: storage.dbConfig
+	});
+	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 getFirstAcceptedSyncIdsByTimestamp = (tx, events) => {
+		const timestamps = Array.from(new Set(events.filter((event) => event.origin !== "own-applied").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",
+			sql: `select "timestamp", min("sync_id") as "first_sync_id" from ${quotedEventsTable} where "status" = 'applied' and "timestamp" = ? group by "timestamp"`,
+			params: timestamps,
+			meta: { loggerLevel: "system" }
+		}) : tx.executePreparedRaw({
+			key: "get-first-accepted-sync-ids-by-timestamp",
+			sql: `select "timestamp", min("sync_id") as "first_sync_id" from ${quotedEventsTable} where "status" = 'applied' and "timestamp" in (select "value" from json_each(?)) group by "timestamp"`,
+			params: [JSON.stringify(timestamps)],
+			meta: { loggerLevel: "system" }
+		});
+		return new Map(rows.map((row) => [row.timestamp, row.first_sync_id]));
+	};
+	const updateEventStatuses = (tx, events) => {
+		const syncIdsByStatus = /* @__PURE__ */ new Map();
+		for (const event of events) {
+			if (event.status === "pending") throw new Error(`Event ${event.sync_id} is still pending after processing`);
+			const syncIds = syncIdsByStatus.get(event.status) ?? [];
+			syncIds.push(event.sync_id);
+			syncIdsByStatus.set(event.status, syncIds);
+		}
+		for (const [status, syncIds] of syncIdsByStatus) {
+			if (syncIds.length === 1) {
+				tx.executePreparedRaw({
+					key: "update-crdt-event-status",
+					sql: `update ${quotedEventsTable} set "status" = ? where "sync_id" = ?`,
+					params: [status, syncIds[0]],
+					meta: { loggerLevel: "system" }
+				});
+				continue;
+			}
+			tx.executePreparedRaw({
+				key: "update-crdt-event-status-batch",
+				sql: `update ${quotedEventsTable} set "status" = ? where "sync_id" in (select "value" from json_each(?))`,
+				params: [status, JSON.stringify(syncIds)],
+				meta: { loggerLevel: "system" }
+			});
+		}
+	};
+	const processPersistedEvent = (tx, event, firstAcceptedSyncIdByTimestamp, statusOnlyEvents) => {
+		if (event.status !== "pending") throw new Error(`Event ${event.sync_id} is not pending`);
+		const persistedEventData = {
+			schema_version: event.schema_version,
+			type: event.type,
+			dataset: event.dataset,
+			item_id: event.item_id,
+			payload: event.payload
+		};
+		try {
+			if (event.origin === "own-applied") {
+				event.status = "applied";
+				return event;
+			}
+			const firstAcceptedSyncId = firstAcceptedSyncIdByTimestamp.get(event.timestamp);
+			if (firstAcceptedSyncId !== void 0 && firstAcceptedSyncId < event.sync_id) {
+				event.status = "deduped";
+				return event;
+			}
+			if (event.origin === "local" || event.origin === "remote") storage.hlc.mergeHLC(deserializeHLC(event.timestamp));
+			if (isNoOpCrdtEventPayload(event.payload)) {
+				applyCrdtEvent(event);
+				event.status = "applied";
+				return event;
+			}
+			const migratedEvent = storage.migrator.migrateEvent(event, storage.migrator.latestSchemaVersion);
+			if (migratedEvent === null) {
+				event.schema_version = storage.migrator.latestSchemaVersion;
+				event.payload = CRDT_EVENT_NO_OP_PAYLOAD;
+				applyCrdtEvent(event);
+				event.status = "applied";
+				return event;
+			}
+			event.schema_version = migratedEvent.schema_version;
+			event.type = migratedEvent.type;
+			event.dataset = migratedEvent.dataset;
+			event.item_id = migratedEvent.item_id;
+			event.payload = migratedEvent.payload;
+			applyCrdtEvent(event);
+			event.status = "applied";
+		} catch (error) {
+			console.error("Error applying enqueued CRDT event", error);
+			event.status = "failed";
+		} finally {
+			if (event.schema_version !== persistedEventData.schema_version || event.type !== persistedEventData.type || event.dataset !== persistedEventData.dataset || event.item_id !== persistedEventData.item_id || event.payload !== persistedEventData.payload) tx.executePrepared("update-crdt-event-full", event, (db, params) => db.updateTable(crdtEventsTable).set({
+				status: params("status"),
+				schema_version: params("schema_version"),
+				type: params("type"),
+				dataset: params("dataset"),
+				item_id: params("item_id"),
+				payload: params("payload")
+			}).where("sync_id", "=", params("sync_id")), { loggerLevel: "system" });
+			else statusOnlyEvents.push(event);
+		}
+	};
+	const processEnqueuedEvents = ensureSingletonExecution(async () => {
+		let hasMore = true;
+		while (hasMore) {
+			await Promise.resolve();
+			const batchSize = 100;
+			const events = readPendingEvents(101);
+			hasMore = events.length > batchSize;
+			if (hasMore) events.pop();
+			const previousSequentialSyncId = sequentialSyncId;
+			if (events.length === 0) {
+				publishProcessedBatch({
+					previousSequentialSyncId,
+					nextSequentialSyncId: localSyncId,
+					appliedEvents: []
+				});
+				break;
+			}
+			const failedRemoteSyncIds = [];
+			const appliedEventsToNotify = [];
+			db.executeTransaction((tx) => {
+				const firstAcceptedSyncIdByTimestamp = getFirstAcceptedSyncIdsByTimestamp(tx, events);
+				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);
+					}
+					if (event.status === "failed" && event.origin === "remote") failedRemoteSyncIds.push(event.sync_id);
+				}
+				updateEventStatuses(tx, statusOnlyEvents);
+				persistEventHlcAccumulator();
+			});
+			publishProcessedBatch({
+				previousSequentialSyncId,
+				nextSequentialSyncId: hasMore ? events[events.length - 1]?.sync_id ?? sequentialSyncId : localSyncId,
+				appliedEvents: appliedEventsToNotify
+			});
+			for (const syncId of failedRemoteSyncIds) eventTarget.dispatchEvent("remote-event-apply-failed", { syncId });
+		}
+	});
+	recomputeEventHlcAccumulatorIfNeeded();
+	processEnqueuedEvents();
+	return {
+		getEventsBatch,
+		enqueueLocalEvents,
+		enqueueOwnEvents,
+		enqueueRemoteEvents,
+		applyOwnEvents,
+		applyOwnSnapshot,
+		checkIsQuiescent,
+		getEventHlcAccumulator: () => eventHlcAccumulator?.current ?? null,
+		addEventListener: eventTarget.addEventListener,
+		removeEventListener: eventTarget.removeEventListener,
+		internal: {
+			applyOwnEventFromTransaction,
+			applyOwnIntentsFromTransaction,
+			processEnqueuedEvents
+		}
+	};
+}
+//#endregion
+//#region src/sqlite-crdt/crdt-sync-producer.ts
+const createCrdtSyncProducer = ({ storage, broadcastEvents }) => {
+	storage.addEventListener("events-applied", (event) => {
+		broadcastEvents({
+			newSyncId: event.payload.syncId,
+			eventHlcSum: event.payload.eventHlcSum
+		});
+	});
+};
+//#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";
+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/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 { 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 };
+
+//# sourceMappingURL=reset-state-D3nsfx_t.js.map