@sqlite-sync/core 0.8.2 → 0.9.1

package/dist/index.js

@@ -1,1330 +1,1013 @@
-import {
-  CRDT_EVENT_NO_OP_PAYLOAD,
-  CrdtEventValidationError,
-  HLCCounter,
-  RESET_REQUEST_TTL_MS,
-  SQLiteDbWrapper,
-  applyMemoryDbSchema,
-  applyWorkerDbSchema,
-  baseSystemMigrations,
-  compareHLC,
-  createBroadcastChannels,
-  createCrdtApplyFunction,
-  createCrdtStorage,
-  createCrdtSyncProducer,
-  createCrdtSyncRemoteSource,
-  createExportData,
-  createImportData,
-  createKvStoreTableQuery,
-  createMigrations,
-  createMigrator,
-  createSQLiteCrdtApplyFunction,
-  createSQLiteKvStore,
-  createStoredValue,
-  createSystemDbConfig,
-  deserializeHLC,
-  dummyKysely,
-  formatSchemaVerificationIssues,
-  introspectDb,
-  isNoOpCrdtEventPayload,
-  isWorkerErrorResponseMessage,
-  isWorkerNotificationMessage,
-  isWorkerResponseMessage,
-  memoryDbConfig,
-  runSystemMigrations,
-  serializeHLC,
-  startPerformanceLogger,
-  syncDbClientLockName,
-  validateNewCrdtEvent,
-  verifySyncSchema,
-  xxhash
-} from "./chunk-GMF45NFH.js";
-import {
-  TypedBroadcastChannel,
-  TypedEvent,
-  createDeferredPromise,
-  createTypedEventTarget,
-  generateId,
-  jsonSafeParse,
-  noop,
-  quoteId,
-  tryCatch,
-  tryCatchAsync
-} from "./chunk-NHT3ELMN.js";
-
-// src/memory-db/sqlite-reactive-db.ts
+import { A as serializeHLC, C as createMigrator, D as HLCCounter, E as introspectDb, M as createExportData, N as createImportData, O as compareHLC, P as dummyKysely, S as createMigrations, T as startPerformanceLogger, _ as createSQLiteCrdtApplyFunction, a as createBroadcastChannels, b as CrdtEventValidationError, c as isWorkerNotificationMessage, d as syncDbClientLockName, g as createCrdtApplyFunction, h as createCrdtStorage, j as xxhash, k as deserializeHLC, m as createCrdtSyncProducer, o as isWorkerErrorResponseMessage, p as createCrdtSyncRemoteSource, t as RESET_REQUEST_TTL_MS, u as isWorkerResponseMessage, v as formatSchemaVerificationIssues, w as SQLiteDbWrapper, x as validateNewCrdtEvent, y as verifySyncSchema } from "./reset-state-D3nsfx_t.js";
+import { c as noop, d as tryCatch, f as tryCatchAsync, i as createTypedEventTarget, n as TypedEvent, o as generateId, r as createDeferredPromise, s as jsonSafeParse, t as TypedBroadcastChannel, u as quoteId } from "./utils-Dr5JwcTP.js";
+import { a as memoryDbConfig, c as createKvStoreTableQuery, d as CRDT_EVENT_NO_OP_PAYLOAD, f as isNoOpCrdtEventPayload, l as createSQLiteKvStore, n as applyWorkerDbSchema, t as applyMemoryDbSchema, u as createStoredValue } from "./system-schema-CkglcfTS.js";
+import { a as registerCrdtIntentDrainer, i as makeCrdtTable } from "./make-crdt-table-CvpTHmRY.js";
 import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
-
-// src/bound-map.ts
+//#region src/bound-map.ts
 var BoundMap = class {
-  map = /* @__PURE__ */ new Map();
-  maxSize;
-  onRemove;
-  constructor(opts) {
-    this.maxSize = opts.maxSize;
-    this.onRemove = opts.onRemove;
-  }
-  set = (key, value) => {
-    if (this.onRemove && this.map.has(key)) {
-      const old = this.map.get(key);
-      this.map.set(key, value);
-      this.onRemove(key, old);
-    } else {
-      this.map.set(key, value);
-    }
-    if (this.map.size > this.maxSize) {
-      const firstKey = this.map.keys().next().value;
-      this.delete(firstKey);
-    }
-  };
-  get = (key) => {
-    return this.map.get(key);
-  };
-  delete = (key) => {
-    if (this.onRemove && this.map.has(key)) {
-      const value = this.map.get(key);
-      this.map.delete(key);
-      this.onRemove(key, value);
-    } else {
-      this.map.delete(key);
-    }
-  };
-  clear = () => {
-    const onRemove = this.onRemove;
-    if (onRemove) {
-      this.map.forEach((value, key) => {
-        onRemove(key, value);
-      });
-    }
-    this.map.clear();
-  };
+	map = /* @__PURE__ */ new Map();
+	maxSize;
+	onRemove;
+	constructor(opts) {
+		this.maxSize = opts.maxSize;
+		this.onRemove = opts.onRemove;
+	}
+	set = (key, value) => {
+		if (this.onRemove && this.map.has(key)) {
+			const old = this.map.get(key);
+			this.map.set(key, value);
+			this.onRemove(key, old);
+		} else this.map.set(key, value);
+		if (this.map.size > this.maxSize) {
+			const firstKey = this.map.keys().next().value;
+			this.delete(firstKey);
+		}
+	};
+	get = (key) => {
+		return this.map.get(key);
+	};
+	delete = (key) => {
+		if (this.onRemove && this.map.has(key)) {
+			const value = this.map.get(key);
+			this.map.delete(key);
+			this.onRemove(key, value);
+		} else this.map.delete(key);
+	};
+	clear = () => {
+		const onRemove = this.onRemove;
+		if (onRemove) this.map.forEach((value, key) => {
+			onRemove(key, value);
+		});
+		this.map.clear();
+	};
 };
-
-// src/memory-db/sqlite-reactive-db.ts
-var sqliteModule = null;
+//#endregion
+//#region src/memory-db/sqlite-reactive-db.ts
+let sqliteModule = null;
 function createSQLiteReactiveDb(opts) {
-  return SQLiteReactiveDb.create(opts);
+	return SQLiteReactiveDb.create(opts);
 }
-var SQLiteReactiveDb = class _SQLiteReactiveDb {
-  db;
-  sqlite3;
-  logger;
-  tablesUsedStatement = null;
-  eventTarget = createTypedEventTarget();
-  constructor(sqlite3, logger) {
-    this.sqlite3 = sqlite3;
-    this.logger = logger;
-    this.db = new SQLiteDbWrapper({
-      db: () => new sqlite3.oo1.DB({ filename: ":memory:" }),
-      logger: this.logger,
-      loggerPrefix: "memory",
-      sqlite3
-    });
-  }
-  static async create(opts) {
-    const logger = opts.logger;
-    const perf = startPerformanceLogger(logger);
-    if (!sqliteModule) {
-      sqliteModule = await sqlite3InitModule();
-    }
-    const db = new _SQLiteReactiveDb(sqliteModule, logger);
-    if (opts.snapshot) {
-      db.useSnapshot(opts.snapshot);
-    }
-    db.registerDbHooks();
-    perf.logEnd("createSQLiteMemoryDb", "success", "system");
-    return db;
-  }
-  liveQueryStatements = new BoundMap({
-    maxSize: 100,
-    onRemove(_, value) {
-      value.finalize();
-    }
-  });
-  sharedLiveQueries = /* @__PURE__ */ new Map();
-  createLiveQuery(query) {
-    const fetchRows = (parameters) => {
-      let statement = this.liveQueryStatements.get(query.sql);
-      if (!statement) {
-        statement = this.db.prepare(query.sql);
-        this.liveQueryStatements.set(query.sql, statement);
-      }
-      return statement.execute(parameters);
-    };
-    let rows = null;
-    const getRows = () => {
-      if (!rows) {
-        rows = fetchRows(query.parameters);
-      }
-      return rows;
-    };
-    let subscriber = null;
-    let lastParameters = query.parameters;
-    const refresh = (parameters) => {
-      if (parameters) {
-        lastParameters = parameters;
-      }
-      rows = fetchRows(lastParameters);
-      subscriber?.();
-    };
-    const subscribe = (onchange) => {
-      if (subscriber) {
-        throw new Error("Subscriber already exists");
-      }
-      subscriber = onchange;
-      const subscription = this.subscribeToQueryChanges({
-        sql: query.sql,
-        onDataChange: refresh
-      });
-      return () => {
-        subscription.unsubscribe();
-        subscriber = null;
-      };
-    };
-    return { getRows, refresh, subscribe };
-  }
-  getSharedLiveQuery(query) {
-    const existingEntry = this.sharedLiveQueries.get(query.sql)?.find((entry2) => parametersAreEqual(entry2.parameters, query.parameters));
-    if (existingEntry) {
-      if (existingEntry.listeners.size === 0) {
-        this.scheduleSharedLiveQueryCleanup(existingEntry);
-      }
-      return existingEntry;
-    }
-    const liveQuery = this.createLiveQuery(query);
-    let hasDetachedFromLiveQuery = false;
-    const entry = {
-      sql: query.sql,
-      parameters: query.parameters,
-      listeners: /* @__PURE__ */ new Set(),
-      unsubscribeFromLiveQuery: null,
-      cleanupTimeout: null,
-      getRows: () => liveQuery.getRows(),
-      refresh: () => {
-        liveQuery.refresh();
-      },
-      getSubscriberCount: () => entry.listeners.size,
-      subscribe: (onchange) => {
-        this.cancelSharedLiveQueryCleanup(entry);
-        this.registerSharedLiveQueryEntry(entry);
-        entry.listeners.add(onchange);
-        if (!entry.unsubscribeFromLiveQuery) {
-          entry.unsubscribeFromLiveQuery = liveQuery.subscribe(() => {
-            for (const listener of entry.listeners) {
-              listener();
-            }
-          });
-          if (hasDetachedFromLiveQuery) {
-            hasDetachedFromLiveQuery = false;
-            liveQuery.refresh();
-          }
-        }
-        return () => {
-          entry.listeners.delete(onchange);
-          if (entry.listeners.size === 0) {
-            entry.unsubscribeFromLiveQuery?.();
-            entry.unsubscribeFromLiveQuery = null;
-            hasDetachedFromLiveQuery = true;
-            this.scheduleSharedLiveQueryCleanup(entry);
-          }
-        };
-      }
-    };
-    this.registerSharedLiveQueryEntry(entry);
-    this.scheduleSharedLiveQueryCleanup(entry);
-    return entry;
-  }
-  registerSharedLiveQueryEntry(entry) {
-    const matchingSqlEntries = this.sharedLiveQueries.get(entry.sql) ?? [];
-    if (!matchingSqlEntries.includes(entry)) {
-      matchingSqlEntries.push(entry);
-      this.sharedLiveQueries.set(entry.sql, matchingSqlEntries);
-    }
-  }
-  getSharedLiveQueriesSnapshot() {
-    const snapshot = [];
-    for (const entries of this.sharedLiveQueries.values()) {
-      for (const entry of entries) {
-        snapshot.push({
-          sql: entry.sql,
-          parameters: entry.parameters,
-          subscriberCount: entry.listeners.size
-        });
-      }
-    }
-    return snapshot;
-  }
-  scheduleSharedLiveQueryCleanup(entry) {
-    this.cancelSharedLiveQueryCleanup(entry);
-    entry.cleanupTimeout = setTimeout(() => {
-      entry.cleanupTimeout = null;
-      this.releaseSharedLiveQuery(entry);
-    }, 0);
-  }
-  cancelSharedLiveQueryCleanup(entry) {
-    if (entry.cleanupTimeout) {
-      clearTimeout(entry.cleanupTimeout);
-      entry.cleanupTimeout = null;
-    }
-  }
-  releaseSharedLiveQuery(entry) {
-    if (entry.listeners.size > 0 || entry.unsubscribeFromLiveQuery) {
-      return;
-    }
-    const matchingSqlEntries = this.sharedLiveQueries.get(entry.sql);
-    if (!matchingSqlEntries) {
-      return;
-    }
-    const nextEntries = matchingSqlEntries.filter((candidate) => candidate !== entry);
-    if (nextEntries.length > 0) {
-      this.sharedLiveQueries.set(entry.sql, nextEntries);
-    } else {
-      this.sharedLiveQueries.delete(entry.sql);
-    }
-  }
-  subscribeToQueryChanges(params) {
-    const { sql, onDataChange } = params;
-    const tables = this.getTablesUsed(sql);
-    const readTables = /* @__PURE__ */ new Set();
-    for (const table of tables) {
-      if (!readTables.has(table.name)) {
-        readTables.add(table.name);
-      } else if (table.isWrite) {
-        throw new Error("This query writes and reads from the same table. This may cause infinite loops.");
-      }
-    }
-    const notifyDataChange = createDebouncedCallback(() => {
-      onDataChange();
-    }, 30);
-    for (const table of readTables) {
-      this.eventTarget.addEventListener(`table:${table}`, notifyDataChange);
-    }
-    this.eventTarget.addEventListener("any-table-changed", notifyDataChange);
-    return {
-      unsubscribe: () => {
-        for (const table of readTables) {
-          this.eventTarget.removeEventListener(`table:${table}`, notifyDataChange);
-        }
-        this.eventTarget.removeEventListener("any-table-changed", notifyDataChange);
-      }
-    };
-  }
-  subscribeToTableChanges(table, onChanges) {
-    this.eventTarget.addEventListener(`table:${table}`, onChanges);
-    this.eventTarget.addEventListener("any-table-changed", onChanges);
-    return {
-      unsubscribe: () => {
-        this.eventTarget.removeEventListener(`table:${table}`, onChanges);
-        this.eventTarget.removeEventListener("any-table-changed", onChanges);
-      }
-    };
-  }
-  getTablesUsed(query) {
-    if (!this.tablesUsedStatement) {
-      this.tablesUsedStatement = this.db.prepare(
-        "select t.tbl_name as name, u.wr as isWrite from tables_used(?) as u inner join sqlite_master as t on t.name = u.name where u.schema = 'main'",
-        { loggerLevel: "system" }
-      );
-    }
-    const tables = this.tablesUsedStatement.execute([query]);
-    if (tables.length === 0 && query.toLowerCase().includes("delete")) {
-      tables.push(...this.getClearedTables(query));
-    }
-    return tables;
-  }
-  getClearedTables(query) {
-    const operations = this.db.execute(`EXPLAIN ${query.split(";")[0]}`, { loggerLevel: "system" }).rows;
-    const clearedTablesRootPages = /* @__PURE__ */ new Set();
-    for (const operation of operations) {
-      if (operation.opcode === "Clear" && operation.p2 === 0) {
-        clearedTablesRootPages.add(operation.p1);
-      }
-    }
-    if (clearedTablesRootPages.size === 0) {
-      return [];
-    }
-    const tableNames = this.db.execute(
-      `select t.tbl_name as name, true as isWrite from sqlite_master as t where t.rootpage in (${Array.from(
-        clearedTablesRootPages
-      ).join(",")})`,
-      { loggerLevel: "system" }
-    ).rows;
-    return tableNames;
-  }
-  addEventListener(type, listener) {
-    this.eventTarget.addEventListener(type, listener);
-  }
-  removeEventListener(type, listener) {
-    this.eventTarget.removeEventListener(type, listener);
-  }
-  notifyTableSubscribers(tables = null) {
-    if (!tables) {
-      this.eventTarget.dispatchEvent("any-table-changed", void 0);
-      return;
-    }
-    for (const table of tables) {
-      this.eventTarget.dispatchEvent(`table:${table}`, void 0);
-    }
-  }
-  registerDbHooks() {
-    let updateQueue = /* @__PURE__ */ new Set();
-    this.sqlite3.capi.sqlite3_update_hook(
-      this.db.ensureDb,
-      (_ctx, _opId, _db, table) => {
-        updateQueue.add(table);
-      },
-      0
-    );
-    this.sqlite3.capi.sqlite3_rollback_hook(
-      this.db.ensureDb,
-      () => {
-        if (updateQueue.size === 0) {
-          return 0;
-        }
-        updateQueue.clear();
-        this.eventTarget.dispatchEvent("transaction-rolled-back", void 0);
-        return 0;
-      },
-      0
-    );
-    this.sqlite3.capi.sqlite3_commit_hook(
-      this.db.ensureDb,
-      () => {
-        if (updateQueue.size === 0) {
-          return 0;
-        }
-        const tables = updateQueue;
-        updateQueue = /* @__PURE__ */ new Set();
-        this.eventTarget.dispatchEvent("transaction-committed", void 0);
-        queueMicrotask(() => {
-          this.notifyTableSubscribers(tables);
-        });
-        return 0;
-      },
-      0
-    );
-  }
-  createSnapshot() {
-    const perf = startPerformanceLogger(this.logger);
-    const snapshot = this.sqlite3.capi.sqlite3_js_db_export(this.db.ensureDb);
-    perf.logEnd("createSnapshot", `snapshot size: ${snapshot.byteLength}`, "info");
-    return snapshot;
-  }
-  useSnapshot(snapshot) {
-    this.db.useSnapshot(snapshot);
-    this.notifyTableSubscribers();
-  }
-  dispose() {
-    for (const entries of this.sharedLiveQueries.values()) {
-      for (const entry of entries) {
-        this.cancelSharedLiveQueryCleanup(entry);
-        entry.unsubscribeFromLiveQuery?.();
-        entry.unsubscribeFromLiveQuery = null;
-        entry.listeners.clear();
-      }
-    }
-    this.sharedLiveQueries.clear();
-    this.liveQueryStatements.clear();
-    if (this.tablesUsedStatement) {
-      this.tablesUsedStatement.finalize();
-      this.tablesUsedStatement = null;
-    }
-    this.db.close();
-  }
+var SQLiteReactiveDb = class SQLiteReactiveDb {
+	db;
+	sqlite3;
+	logger;
+	tablesUsedStatement = null;
+	eventTarget = createTypedEventTarget();
+	mutationVersion = 0;
+	tableMutationVersions = /* @__PURE__ */ new Map();
+	constructor(sqlite3, logger) {
+		this.sqlite3 = sqlite3;
+		this.logger = logger;
+		this.db = new SQLiteDbWrapper({
+			db: () => new sqlite3.oo1.DB({ filename: ":memory:" }),
+			logger: this.logger,
+			loggerPrefix: "memory",
+			sqlite3
+		});
+	}
+	static async create(opts) {
+		const logger = opts.logger;
+		const perf = startPerformanceLogger(logger, "system");
+		if (!sqliteModule) sqliteModule = await sqlite3InitModule();
+		const db = new SQLiteReactiveDb(sqliteModule, logger);
+		if (opts.snapshot) db.useSnapshot(opts.snapshot);
+		db.registerDbHooks();
+		perf.logEnd("createSQLiteMemoryDb", "success", "system");
+		return db;
+	}
+	liveQueryStatements = new BoundMap({
+		maxSize: 100,
+		onRemove(_, value) {
+			value.finalize();
+		}
+	});
+	sharedLiveQueries = /* @__PURE__ */ new Map();
+	createLiveQuery(query) {
+		const fetchRows = (parameters) => {
+			let statement = this.liveQueryStatements.get(query.sql);
+			if (!statement) {
+				statement = this.db.prepare(query.sql);
+				this.liveQueryStatements.set(query.sql, statement);
+			}
+			return statement.execute(parameters);
+		};
+		let rows = null;
+		const getRows = () => {
+			if (!rows) rows = fetchRows(query.parameters);
+			return rows;
+		};
+		let subscriber = null;
+		let lastParameters = query.parameters;
+		const refresh = (parameters) => {
+			if (parameters) lastParameters = parameters;
+			rows = fetchRows(lastParameters);
+			subscriber?.();
+		};
+		const subscribe = (onchange) => {
+			if (subscriber) throw new Error("Subscriber already exists");
+			subscriber = onchange;
+			const subscription = this.subscribeToQueryChanges({
+				sql: query.sql,
+				onDataChange: refresh
+			});
+			return () => {
+				subscription.unsubscribe();
+				subscriber = null;
+			};
+		};
+		return {
+			getRows,
+			refresh,
+			subscribe
+		};
+	}
+	getSharedLiveQuery(query) {
+		const existingEntry = this.sharedLiveQueries.get(query.sql)?.find((entry) => parametersAreEqual(entry.parameters, query.parameters));
+		if (existingEntry) {
+			if (existingEntry.listeners.size === 0) this.scheduleSharedLiveQueryCleanup(existingEntry);
+			return existingEntry;
+		}
+		const liveQuery = this.createLiveQuery(query);
+		let hasDetachedFromLiveQuery = false;
+		const entry = {
+			sql: query.sql,
+			parameters: query.parameters,
+			listeners: /* @__PURE__ */ new Set(),
+			unsubscribeFromLiveQuery: null,
+			cleanupTimeout: null,
+			getRows: () => liveQuery.getRows(),
+			refresh: () => {
+				liveQuery.refresh();
+			},
+			getSubscriberCount: () => entry.listeners.size,
+			subscribe: (onchange) => {
+				this.cancelSharedLiveQueryCleanup(entry);
+				this.registerSharedLiveQueryEntry(entry);
+				entry.listeners.add(onchange);
+				if (!entry.unsubscribeFromLiveQuery) {
+					entry.unsubscribeFromLiveQuery = liveQuery.subscribe(() => {
+						for (const listener of entry.listeners) listener();
+					});
+					if (hasDetachedFromLiveQuery) {
+						hasDetachedFromLiveQuery = false;
+						liveQuery.refresh();
+					}
+				}
+				return () => {
+					entry.listeners.delete(onchange);
+					if (entry.listeners.size === 0) {
+						entry.unsubscribeFromLiveQuery?.();
+						entry.unsubscribeFromLiveQuery = null;
+						hasDetachedFromLiveQuery = true;
+						this.scheduleSharedLiveQueryCleanup(entry);
+					}
+				};
+			}
+		};
+		this.registerSharedLiveQueryEntry(entry);
+		this.scheduleSharedLiveQueryCleanup(entry);
+		return entry;
+	}
+	registerSharedLiveQueryEntry(entry) {
+		const matchingSqlEntries = this.sharedLiveQueries.get(entry.sql) ?? [];
+		if (!matchingSqlEntries.includes(entry)) {
+			matchingSqlEntries.push(entry);
+			this.sharedLiveQueries.set(entry.sql, matchingSqlEntries);
+		}
+	}
+	getSharedLiveQueriesSnapshot() {
+		const snapshot = [];
+		for (const entries of this.sharedLiveQueries.values()) for (const entry of entries) snapshot.push({
+			sql: entry.sql,
+			parameters: entry.parameters,
+			subscriberCount: entry.listeners.size
+		});
+		return snapshot;
+	}
+	scheduleSharedLiveQueryCleanup(entry) {
+		this.cancelSharedLiveQueryCleanup(entry);
+		entry.cleanupTimeout = setTimeout(() => {
+			entry.cleanupTimeout = null;
+			this.releaseSharedLiveQuery(entry);
+		}, 0);
+	}
+	cancelSharedLiveQueryCleanup(entry) {
+		if (entry.cleanupTimeout) {
+			clearTimeout(entry.cleanupTimeout);
+			entry.cleanupTimeout = null;
+		}
+	}
+	releaseSharedLiveQuery(entry) {
+		if (entry.listeners.size > 0 || entry.unsubscribeFromLiveQuery) return;
+		const matchingSqlEntries = this.sharedLiveQueries.get(entry.sql);
+		if (!matchingSqlEntries) return;
+		const nextEntries = matchingSqlEntries.filter((candidate) => candidate !== entry);
+		if (nextEntries.length > 0) this.sharedLiveQueries.set(entry.sql, nextEntries);
+		else this.sharedLiveQueries.delete(entry.sql);
+	}
+	subscribeToQueryChanges(params) {
+		const { sql, onDataChange } = params;
+		const tables = this.getTablesUsed(sql);
+		const readTables = /* @__PURE__ */ new Set();
+		for (const table of tables) if (!readTables.has(table.name)) readTables.add(table.name);
+		else if (table.isWrite) throw new Error("This query writes and reads from the same table. This may cause infinite loops.");
+		const notifyDataChange = createDebouncedCallback(() => {
+			onDataChange();
+		}, 30);
+		for (const table of readTables) this.eventTarget.addEventListener(`table:${table}`, notifyDataChange);
+		this.eventTarget.addEventListener("any-table-changed", notifyDataChange);
+		return { unsubscribe: () => {
+			for (const table of readTables) this.eventTarget.removeEventListener(`table:${table}`, notifyDataChange);
+			this.eventTarget.removeEventListener("any-table-changed", notifyDataChange);
+		} };
+	}
+	subscribeToTableChanges(table, onChanges) {
+		this.eventTarget.addEventListener(`table:${table}`, onChanges);
+		this.eventTarget.addEventListener("any-table-changed", onChanges);
+		return { unsubscribe: () => {
+			this.eventTarget.removeEventListener(`table:${table}`, onChanges);
+			this.eventTarget.removeEventListener("any-table-changed", onChanges);
+		} };
+	}
+	getTablesUsed(query) {
+		if (!this.tablesUsedStatement) this.tablesUsedStatement = this.db.prepare("select t.tbl_name as name, u.wr as isWrite from tables_used(?) as u inner join sqlite_master as t on t.name = u.name where u.schema = 'main'", { loggerLevel: "system" });
+		const tables = this.tablesUsedStatement.execute([query]);
+		if (tables.length === 0 && query.toLowerCase().includes("delete")) tables.push(...this.getClearedTables(query));
+		return tables;
+	}
+	getClearedTables(query) {
+		const operations = this.db.execute(`EXPLAIN ${query.split(";")[0]}`, { loggerLevel: "system" }).rows;
+		const clearedTablesRootPages = /* @__PURE__ */ new Set();
+		for (const operation of operations) if (operation.opcode === "Clear" && operation.p2 === 0) clearedTablesRootPages.add(operation.p1);
+		if (clearedTablesRootPages.size === 0) return [];
+		return this.db.execute(`select t.tbl_name as name, true as isWrite from sqlite_master as t where t.rootpage in (${Array.from(clearedTablesRootPages).join(",")})`, { loggerLevel: "system" }).rows;
+	}
+	addEventListener(type, listener) {
+		this.eventTarget.addEventListener(type, listener);
+	}
+	removeEventListener(type, listener) {
+		this.eventTarget.removeEventListener(type, listener);
+	}
+	getTableMutationVersion(table) {
+		return this.tableMutationVersions.get(table) ?? 0;
+	}
+	notifyTableSubscribers(tables = null) {
+		if (!tables) {
+			this.eventTarget.dispatchEvent("any-table-changed", void 0);
+			return;
+		}
+		for (const table of tables) this.eventTarget.dispatchEvent(`table:${table}`, void 0);
+	}
+	registerDbHooks() {
+		let updateQueue = /* @__PURE__ */ new Set();
+		this.sqlite3.capi.sqlite3_update_hook(this.db.ensureDb, (_ctx, _opId, _db, table) => {
+			updateQueue.add(table);
+			this.tableMutationVersions.set(table, ++this.mutationVersion);
+		}, 0);
+		this.sqlite3.capi.sqlite3_rollback_hook(this.db.ensureDb, () => {
+			if (updateQueue.size === 0) return 0;
+			updateQueue.clear();
+			this.eventTarget.dispatchEvent("transaction-rolled-back", void 0);
+			return 0;
+		}, 0);
+		this.sqlite3.capi.sqlite3_commit_hook(this.db.ensureDb, () => {
+			if (updateQueue.size === 0) return 0;
+			const tables = updateQueue;
+			updateQueue = /* @__PURE__ */ new Set();
+			this.eventTarget.dispatchEvent("transaction-committed", void 0);
+			queueMicrotask(() => {
+				this.notifyTableSubscribers(tables);
+			});
+			return 0;
+		}, 0);
+	}
+	createSnapshot() {
+		const perf = startPerformanceLogger(this.logger);
+		const snapshot = this.sqlite3.capi.sqlite3_js_db_export(this.db.ensureDb);
+		perf.logEnd("createSnapshot", `snapshot size: ${snapshot.byteLength}`, "info");
+		return snapshot;
+	}
+	useSnapshot(snapshot) {
+		this.db.useSnapshot(snapshot);
+		this.notifyTableSubscribers();
+	}
+	dispose() {
+		for (const entries of this.sharedLiveQueries.values()) for (const entry of entries) {
+			this.cancelSharedLiveQueryCleanup(entry);
+			entry.unsubscribeFromLiveQuery?.();
+			entry.unsubscribeFromLiveQuery = null;
+			entry.listeners.clear();
+		}
+		this.sharedLiveQueries.clear();
+		this.liveQueryStatements.clear();
+		if (this.tablesUsedStatement) {
+			this.tablesUsedStatement.finalize();
+			this.tablesUsedStatement = null;
+		}
+		this.db.close();
+	}
 };
 function createDebouncedCallback(callback, delay) {
-  let timeout = null;
-  let shouldCallWithoutDelay = true;
-  return (...args) => {
-    if (shouldCallWithoutDelay) {
-      callback(...args);
-      shouldCallWithoutDelay = false;
-      return;
-    }
-    const effect = () => {
-      timeout = null;
-      shouldCallWithoutDelay = true;
-      return callback(...args);
-    };
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-    timeout = setTimeout(effect, delay);
-  };
+	let timeout = null;
+	let shouldCallWithoutDelay = true;
+	return (...args) => {
+		if (shouldCallWithoutDelay) {
+			callback(...args);
+			shouldCallWithoutDelay = false;
+			return;
+		}
+		const effect = () => {
+			timeout = null;
+			shouldCallWithoutDelay = true;
+			return callback(...args);
+		};
+		if (timeout) clearTimeout(timeout);
+		timeout = setTimeout(effect, delay);
+	};
 }
 function parametersAreEqual(a, b) {
-  if (a === b) return true;
-  if (!a || !b) return false;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (!Object.is(a[i], b[i])) {
-      return false;
-    }
-  }
-  return true;
+	if (a === b) return true;
+	if (!a || !b) return false;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
+	return true;
 }
-
-// src/schema/define-sync-schema.ts
-var RESERVED_TABLE_NAMES = /* @__PURE__ */ new Set([
-  "change_history",
-  "crdt_events",
-  "worker.crdt_events",
-  "persisted_crdt_events",
-  "crdt_update_log",
-  "worker.kv"
+//#endregion
+//#region src/schema/admit-client-events.ts
+function buildWriteOriginByName(schema) {
+	const writeOriginByName = /* @__PURE__ */ new Map();
+	for (const { crdtTableName, baseTableName } of schema.tablesConfig) {
+		const writeOrigin = schema.tables[crdtTableName]?.writeOrigin ?? "any";
+		writeOriginByName.set(crdtTableName, writeOrigin);
+		writeOriginByName.set(baseTableName, writeOrigin);
+	}
+	return writeOriginByName;
+}
+/**
+* Splits a client push into events the hub should persist and events for tables declared
+* `.writes("server")`. Unknown datasets stay admitted. Resolves either the crdt or the base
+* table name.
+*/
+function admitClientEvents(opts) {
+	const writeOriginByName = opts.syncDbSchema.writeOriginByName ?? buildWriteOriginByName(opts.syncDbSchema);
+	const admitted = [];
+	const skipped = [];
+	for (const event of opts.events) if (writeOriginByName.get(event.dataset) === "server") skipped.push(event);
+	else admitted.push(event);
+	return {
+		admitted,
+		skipped
+	};
+}
+//#endregion
+//#region src/schema/define-sync-schema.ts
+const RESERVED_TABLE_NAMES = /* @__PURE__ */ new Set([
+	"change_history",
+	"crdt_events",
+	"worker.crdt_events",
+	"persisted_crdt_events",
+	"crdt_update_log",
+	"crdt_change_intents",
+	"worker.kv"
 ]);
-function defineSyncSchema({
-  tables,
-  migrations
-}) {
-  const tablesConfig = Object.entries(tables).map(([crdtTableName, table]) => ({
-    crdtTableName,
-    baseTableName: table.baseName ?? `_${crdtTableName}`
-  }));
-  const seenNames = /* @__PURE__ */ new Set();
-  for (const { crdtTableName, baseTableName } of tablesConfig) {
-    for (const name of [crdtTableName, baseTableName]) {
-      if (RESERVED_TABLE_NAMES.has(name)) {
-        throw new Error(`Table name "${name}" is reserved by sqlite-sync and cannot be used in a sync schema`);
-      }
-      if (seenNames.has(name)) {
-        throw new Error(`Duplicate table name "${name}" in sync schema`);
-      }
-      seenNames.add(name);
-    }
-  }
-  return {
-    tables,
-    get tablesConfig() {
-      return tablesConfig;
-    },
-    get migrations() {
-      return migrations;
-    },
-    get "~clientSchema"() {
-      throw new Error("~clientSchema is type-only and cannot be accessed at runtime");
-    },
-    get "~serverSchema"() {
-      throw new Error("~serverSchema is type-only and cannot be accessed at runtime");
-    },
-    get "~mutationsSchema"() {
-      throw new Error("~mutationsSchema is type-only and cannot be accessed at runtime");
-    }
-  };
+/**
+* Define a sync database schema from `t.table()` builders.
+*
+* Record keys are the crdt (view) table names; base table names default to the key
+* prefixed with "_", overridable per table via `t.table(cols, { baseName })`.
+*/
+function defineSyncSchema({ tables, migrations }) {
+	const tablesConfig = Object.entries(tables).map(([crdtTableName, table]) => ({
+		crdtTableName,
+		baseTableName: table.baseName ?? `_${crdtTableName}`
+	}));
+	const seenNames = /* @__PURE__ */ new Set();
+	for (const { crdtTableName, baseTableName } of tablesConfig) for (const name of [crdtTableName, baseTableName]) {
+		const normalizedName = name.toLowerCase();
+		if (RESERVED_TABLE_NAMES.has(normalizedName)) throw new Error(`Table name "${name}" is reserved by sqlite-sync and cannot be used in a sync schema`);
+		if (seenNames.has(normalizedName)) throw new Error(`Duplicate table name "${name}" in sync schema`);
+		seenNames.add(normalizedName);
+	}
+	const writeOriginByName = buildWriteOriginByName({
+		tables,
+		tablesConfig
+	});
+	return {
+		tables,
+		get tablesConfig() {
+			return tablesConfig;
+		},
+		get writeOriginByName() {
+			return writeOriginByName;
+		},
+		get migrations() {
+			return migrations;
+		},
+		get "~clientSchema"() {
+			throw new Error("~clientSchema is type-only and cannot be accessed at runtime");
+		},
+		get "~serverSchema"() {
+			throw new Error("~serverSchema is type-only and cannot be accessed at runtime");
+		},
+		get "~mutationsSchema"() {
+			throw new Error("~mutationsSchema is type-only and cannot be accessed at runtime");
+		}
+	};
 }
-
-// src/schema/table-builder.ts
-var ColumnBuilder = class _ColumnBuilder {
-  constructor(meta) {
-    this.meta = meta;
-  }
-  /** Allow SQL NULL; widens the value type with `null`. */
-  nullable() {
-    return new _ColumnBuilder({ ...this.meta, nullable: true });
-  }
-  /** Declare a column default. The value is used both in DDL and when migrating older events. */
-  default(value) {
-    return new _ColumnBuilder({ ...this.meta, hasDefault: true, defaultValue: value });
-  }
-  /** Narrow the TypeScript value type without changing storage, e.g. `t.text().$type<"movie" | "tv">()`. */
-  $type() {
-    return this;
-  }
-  /** Human/AI-readable description, surfaced in generated schema docs. */
-  describe(description) {
-    return new _ColumnBuilder({ ...this.meta, description });
-  }
+//#endregion
+//#region src/schema/table-builder.ts
+var ColumnBuilder = class ColumnBuilder {
+	meta;
+	constructor(meta) {
+		this.meta = meta;
+	}
+	/** Allow SQL NULL; widens the value type with `null`. */
+	nullable() {
+		return new ColumnBuilder({
+			...this.meta,
+			nullable: true
+		});
+	}
+	/** Declare a column default. The value is used both in DDL and when migrating older events. */
+	default(value) {
+		return new ColumnBuilder({
+			...this.meta,
+			hasDefault: true,
+			defaultValue: value
+		});
+	}
+	/** Narrow the TypeScript value type without changing storage, e.g. `t.text().$type<"movie" | "tv">()`. */
+	$type() {
+		return this;
+	}
+	/** Human/AI-readable description, surfaced in generated schema docs. */
+	describe(description) {
+		return new ColumnBuilder({
+			...this.meta,
+			description
+		});
+	}
 };
-var RESERVED_COLUMNS = ["id", "tombstone"];
-var idColumnMeta = {
-  kind: "text",
-  sqlType: "text",
-  nullable: false,
-  hasDefault: false,
-  description: "Unique immutable item id"
+const RESERVED_COLUMNS = ["id", "tombstone"];
+const idColumnMeta = {
+	kind: "text",
+	sqlType: "text",
+	nullable: false,
+	hasDefault: false,
+	description: "Unique immutable item id"
 };
-var tombstoneColumnMeta = {
-  kind: "boolean",
-  sqlType: "integer",
-  nullable: false,
-  hasDefault: true,
-  defaultValue: false,
-  description: "Soft-delete marker"
+const tombstoneColumnMeta = {
+	kind: "boolean",
+	sqlType: "integer",
+	nullable: false,
+	hasDefault: true,
+	defaultValue: false,
+	description: "Soft-delete marker"
 };
-var TableBuilder = class _TableBuilder {
-  constructor(userColumns, options) {
-    this.userColumns = userColumns;
-    for (const reserved of RESERVED_COLUMNS) {
-      if (reserved in userColumns) {
-        throw new Error(`Column "${reserved}" is added automatically to every synced table and cannot be declared`);
-      }
-    }
-    this.columns = {
-      id: idColumnMeta,
-      ...Object.fromEntries(Object.entries(userColumns).map(([name, column2]) => [name, column2.meta])),
-      tombstone: tombstoneColumnMeta
-    };
-    this.baseName = options?.baseName;
-    this.description = options?.description;
-  }
-  /** All columns in DDL order, including the auto-injected `id` and `tombstone`. */
-  columns;
-  baseName;
-  description;
-  describe(description) {
-    return new _TableBuilder(this.userColumns, { baseName: this.baseName, description });
-  }
-  /** Type-only: the row shape returned by queries. Do not access at runtime. */
-  get $row() {
-    return null;
-  }
-  /**
-   * Validate a CRDT event payload against the declared columns.
-   * `item-created` payloads must contain every column without a default (nullable columns may be omitted);
-   * `item-updated` payloads are partial and must not touch `id` or set `tombstone` to a deleted value.
-   */
-  validatePayload(payload, options) {
-    const event = options?.event ?? "item-created";
-    const errors = [];
-    for (const key of Object.keys(payload)) {
-      if (!(key in this.columns)) {
-        errors.push(`Unknown column "${key}"`);
-      }
-    }
-    if (event === "item-updated") {
-      if ("id" in payload) {
-        errors.push(`Column "id" is immutable and cannot appear in an update payload`);
-      }
-      if (payload.tombstone === true || payload.tombstone === 1) {
-        errors.push(`Column "tombstone" cannot be set to true/1 in an update payload; use an item-deleted event`);
-      }
-    }
-    if (event === "item-created") {
-      for (const [name, meta] of Object.entries(this.columns)) {
-        if (name in payload || name === "tombstone" || meta.nullable || meta.hasDefault) {
-          continue;
-        }
-        errors.push(`Missing required column "${name}"`);
-      }
-    }
-    for (const [name, value] of Object.entries(payload)) {
-      const meta = this.columns[name];
-      if (!meta || event === "item-updated" && name === "id") {
-        continue;
-      }
-      const error = validateValue(name, value, meta);
-      if (error) {
-        errors.push(error);
-      }
-    }
-    return errors.length === 0 ? { success: true } : { success: false, errors };
-  }
+var TableBuilder = class TableBuilder {
+	userColumns;
+	/** All columns in DDL order, including the auto-injected `id` and `tombstone`. */
+	columns;
+	baseName;
+	description;
+	#aiAccess = "read-write";
+	#writeOrigin = "any";
+	/** AI access declared via `.ai()`; "read-write" unless narrowed. */
+	get aiAccess() {
+		return this.#aiAccess;
+	}
+	/** Who may author events for this table; "any" unless narrowed via `.writes()`. */
+	get writeOrigin() {
+		return this.#writeOrigin;
+	}
+	constructor(userColumns, options) {
+		this.userColumns = userColumns;
+		for (const reserved of RESERVED_COLUMNS) if (reserved in userColumns) throw new Error(`Column "${reserved}" is added automatically to every synced table and cannot be declared`);
+		this.columns = {
+			id: idColumnMeta,
+			...Object.fromEntries(Object.entries(userColumns).map(([name, column]) => [name, column.meta])),
+			tombstone: tombstoneColumnMeta
+		};
+		this.baseName = options?.baseName;
+		this.description = options?.description;
+	}
+	/** Rebuilds the table with `overrides` applied, carrying over state kept outside the options. */
+	withOptions(overrides) {
+		const next = new TableBuilder(this.userColumns, {
+			baseName: this.baseName,
+			description: this.description,
+			...overrides
+		});
+		next.#aiAccess = this.#aiAccess;
+		next.#writeOrigin = this.#writeOrigin;
+		return next;
+	}
+	describe(description) {
+		return this.withOptions({ description });
+	}
+	/** Restrict what an AI agent may do with this table; see {@link AiAccess}. */
+	ai(access) {
+		const next = this.withOptions({});
+		next.#aiAccess = access;
+		return next;
+	}
+	/** Restrict which replicas may author events for this table; see {@link WriteOrigin}. */
+	writes(origin) {
+		const next = this.withOptions({});
+		next.#writeOrigin = origin;
+		return next;
+	}
+	/** Type-only: the row shape returned by queries. Do not access at runtime. */
+	get $row() {
+		return null;
+	}
+	/**
+	* Validate a CRDT event payload against the declared columns.
+	* `item-created` payloads must contain every column without a default (nullable columns may be omitted);
+	* `item-updated` payloads are partial and must not touch `id` or set `tombstone` to a deleted value.
+	*/
+	validatePayload(payload, options) {
+		const event = options?.event ?? "item-created";
+		const errors = [];
+		for (const key of Object.keys(payload)) if (!(key in this.columns)) errors.push(`Unknown column "${key}"`);
+		if (event === "item-updated") {
+			if ("id" in payload) errors.push(`Column "id" is immutable and cannot appear in an update payload`);
+			if (payload.tombstone === true || payload.tombstone === 1) errors.push(`Column "tombstone" cannot be set to true/1 in an update payload; use an item-deleted event`);
+		}
+		if (event === "item-created") for (const [name, meta] of Object.entries(this.columns)) {
+			if (name in payload || name === "tombstone" || meta.nullable || meta.hasDefault) continue;
+			errors.push(`Missing required column "${name}"`);
+		}
+		for (const [name, value] of Object.entries(payload)) {
+			const meta = this.columns[name];
+			if (!meta || event === "item-updated" && name === "id") continue;
+			const error = validateValue(name, value, meta);
+			if (error) errors.push(error);
+		}
+		return errors.length === 0 ? { success: true } : {
+			success: false,
+			errors
+		};
+	}
 };
 function describeValue(value) {
-  if (value === null) return "null";
-  if (Array.isArray(value)) return "array";
-  return typeof value;
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	return typeof value;
 }
 function validateValue(name, value, meta) {
-  if (value === null) {
-    return meta.nullable ? null : `Column "${name}" is not nullable, got null`;
-  }
-  switch (meta.kind) {
-    case "text":
-      return typeof value === "string" ? null : `Column "${name}" expects text, got ${describeValue(value)}`;
-    case "integer":
-      return typeof value === "number" && Number.isInteger(value) ? null : `Column "${name}" expects an integer, got ${describeValue(value)}`;
-    case "real":
-      return typeof value === "number" && Number.isFinite(value) ? null : `Column "${name}" expects a number, got ${describeValue(value)}`;
-    case "boolean":
-      return typeof value === "boolean" || value === 0 || value === 1 ? null : `Column "${name}" expects a boolean (true/false or 0/1), got ${describeValue(value)}`;
-    case "enum": {
-      if (typeof value !== "string") {
-        return `Column "${name}" expects one of ${formatEnumValues(meta)}, got ${describeValue(value)}`;
-      }
-      return meta.enumValues?.includes(value) ? null : `Column "${name}" expects one of ${formatEnumValues(meta)}, got "${value}"`;
-    }
-  }
+	if (value === null) return meta.nullable ? null : `Column "${name}" is not nullable, got null`;
+	switch (meta.kind) {
+		case "text": return typeof value === "string" ? null : `Column "${name}" expects text, got ${describeValue(value)}`;
+		case "integer": return typeof value === "number" && Number.isInteger(value) ? null : `Column "${name}" expects an integer, got ${describeValue(value)}`;
+		case "real": return typeof value === "number" && Number.isFinite(value) ? null : `Column "${name}" expects a number, got ${describeValue(value)}`;
+		case "boolean": return typeof value === "boolean" || value === 0 || value === 1 ? null : `Column "${name}" expects a boolean (true/false or 0/1), got ${describeValue(value)}`;
+		case "enum":
+			if (typeof value !== "string") return `Column "${name}" expects one of ${formatEnumValues(meta)}, got ${describeValue(value)}`;
+			return meta.enumValues?.includes(value) ? null : `Column "${name}" expects one of ${formatEnumValues(meta)}, got "${value}"`;
+	}
 }
 function formatEnumValues(meta) {
-  return (meta.enumValues ?? []).map((value) => `"${value}"`).join(" | ");
+	return (meta.enumValues ?? []).map((value) => `"${value}"`).join(" | ");
 }
 function column(kind, sqlType) {
-  return new ColumnBuilder({ kind, sqlType, nullable: false, hasDefault: false });
+	return new ColumnBuilder({
+		kind,
+		sqlType,
+		nullable: false,
+		hasDefault: false
+	});
 }
-var t = {
-  text: () => column("text", "text"),
-  integer: () => column("integer", "integer"),
-  real: () => column("real", "real"),
-  /** Stored as INTEGER 0/1; always bind booleans as 0/1 when writing raw SQL. */
-  boolean: () => column("boolean", "integer"),
-  /**
-   * Union of string literals stored as TEXT, e.g. `t.enum(["movie", "tv"])`. Unlike `$type`, the
-   * allowed values are kept as runtime metadata, so payloads are validated against them.
-   * For an open-ended set, use `t.text().$type<"idle" | (string & {})>()` instead.
-   */
-  enum: (values) => new ColumnBuilder({
-    kind: "enum",
-    sqlType: "text",
-    nullable: false,
-    hasDefault: false,
-    enumValues: values
-  }),
-  table: (columns, options) => new TableBuilder(columns, options)
+const t = {
+	text: () => column("text", "text"),
+	integer: () => column("integer", "integer"),
+	real: () => column("real", "real"),
+	/** Stored as INTEGER 0/1; always bind booleans as 0/1 when writing raw SQL. */
+	boolean: () => column("boolean", "integer"),
+	/**
+	* Union of string literals stored as TEXT, e.g. `t.enum(["movie", "tv"])`. Unlike `$type`, the
+	* allowed values are kept as runtime metadata, so payloads are validated against them.
+	* For an open-ended set, use `t.text().$type<"idle" | (string & {})>()` instead.
+	*/
+	enum: (values) => new ColumnBuilder({
+		kind: "enum",
+		sqlType: "text",
+		nullable: false,
+		hasDefault: false,
+		enumValues: values
+	}),
+	table: (columns, options) => new TableBuilder(columns, options)
 };
-
-// src/sqlite-crdt/crdt-storage-mutator.ts
+//#endregion
+//#region src/sqlite-crdt/crdt-storage-mutator.ts
 function createCrdtStorageMutator({ storage }) {
-  const mapToStorageEvent = (event) => {
-    switch (event.type) {
-      case "item-created":
-        return {
-          type: "item-created",
-          dataset: event.dataset,
-          item_id: event.item_id,
-          payload: JSON.stringify(event.payload)
-        };
-      case "item-updated":
-        return {
-          type: "item-updated",
-          dataset: event.dataset,
-          item_id: event.item_id,
-          payload: JSON.stringify(event.payload)
-        };
-      case "item-deleted":
-        return {
-          type: "item-deleted",
-          dataset: event.dataset,
-          item_id: event.item_id,
-          payload: "{}"
-        };
-    }
-  };
-  const enqueueEvents = (events) => {
-    storage.enqueueOwnEvents(events.map(mapToStorageEvent));
-  };
-  const createEvent = (event) => {
-    return event;
-  };
-  const enqueueEvent = (event) => {
-    storage.enqueueOwnEvents([mapToStorageEvent(event)]);
-  };
-  return {
-    enqueueEvents,
-    createEvent,
-    enqueueEvent
-  };
-}
-
-// src/sqlite-crdt/make-crdt-table.ts
-function makeCrdtTable({
-  db,
-  baseTableName,
-  crdtTableName
-}) {
-  const tableSchema = db.dbSchema[baseTableName];
-  if (!tableSchema) {
-    throw new Error(`Table ${baseTableName} not found`);
-  }
-  const columns = new Map(tableSchema.columns.map((c) => [c.name, c]));
-  const idColumn = columns.get("id");
-  if (!idColumn) {
-    throw new Error(
-      `Table "${baseTableName}" is missing a required "id" column. CRDT tables must have an "id" column to identify items.`
-    );
-  }
-  if (idColumn.dataType.toUpperCase() !== "TEXT") {
-    throw new Error(
-      `Table "${baseTableName}": "id" column must be of type TEXT, got "${idColumn.dataType}". CRDT item IDs are stored as strings.`
-    );
-  }
-  const tombstoneColumn = columns.get("tombstone");
-  if (!tombstoneColumn) {
-    throw new Error(
-      `Table "${baseTableName}" is missing a required "tombstone" column. CRDT tables must have a "tombstone" INTEGER column for soft deletes.`
-    );
-  }
-  const tombstoneType = tombstoneColumn.dataType.toUpperCase();
-  if (tombstoneType !== "INTEGER" && tombstoneType !== "BOOLEAN") {
-    throw new Error(
-      `Table "${baseTableName}": "tombstone" column must be of type INTEGER or BOOLEAN, got "${tombstoneColumn.dataType}". It is compared as 0/1 for soft deletes.`
-    );
-  }
-  db.execute(
-    `
-create view ${quoteId(crdtTableName)} as
-select * from ${quoteId(baseTableName)}
-where tombstone = 0;`,
-    { loggerLevel: "system" }
-  );
-  const allColumnNames = tableSchema.columns.map((column2) => column2.name);
-  const jsonPayload = (from) => `'{'||${allColumnNames.map((col) => `'"${col}":'||json_quote(${from}.${quoteId(col)})`).join("||','||")}||'}'`;
-  db.execute(
-    `
-create trigger ${quoteId(`${crdtTableName}_created`)}
-instead of insert on ${quoteId(crdtTableName)}
-for each row
-begin
-select handle_item_created('${baseTableName}', ${jsonPayload("new")});
-end;
-`,
-    { loggerLevel: "system" }
-  );
-  db.execute(
-    `
-create trigger ${quoteId(`${crdtTableName}_updated`)}
-instead of update on ${quoteId(crdtTableName)}
-for each row
-begin
-select handle_item_updated(
-  '${baseTableName}',
-  ${jsonPayload("old")},
-  ${jsonPayload("new")}
-);
-end;
-`,
-    { loggerLevel: "system" }
-  );
-  db.execute(
-    `
-create trigger ${quoteId(`${crdtTableName}_deleted`)}
-instead of delete on ${quoteId(crdtTableName)}
-for each row
-when old.tombstone = 0
-begin
-select handle_item_deleted('${baseTableName}', old.id);
-end;
-`,
-    { loggerLevel: "system" }
-  );
+	const mapToStorageEvent = (event) => {
+		switch (event.type) {
+			case "item-created": return {
+				type: "item-created",
+				dataset: event.dataset,
+				item_id: event.item_id,
+				payload: JSON.stringify(event.payload)
+			};
+			case "item-updated": return {
+				type: "item-updated",
+				dataset: event.dataset,
+				item_id: event.item_id,
+				payload: JSON.stringify(event.payload)
+			};
+			case "item-deleted": return {
+				type: "item-deleted",
+				dataset: event.dataset,
+				item_id: event.item_id,
+				payload: "{}"
+			};
+		}
+	};
+	const enqueueEvents = (events) => {
+		storage.enqueueOwnEvents(events.map(mapToStorageEvent));
+	};
+	const createEvent = (event) => {
+		return event;
+	};
+	const enqueueEvent = (event) => {
+		storage.enqueueOwnEvents([mapToStorageEvent(event)]);
+	};
+	const enqueueSnapshot = (snapshot) => {
+		storage.applyOwnSnapshot({
+			dataset: snapshot.dataset,
+			item_id: snapshot.id,
+			patch: { ...snapshot.patch }
+		});
+	};
+	return {
+		enqueueEvents,
+		createEvent,
+		enqueueEvent,
+		enqueueSnapshot
+	};
 }
-function registerCrdtFunctions({
-  reactiveDb,
-  storage
-}) {
-  let eventApplied = false;
-  reactiveDb.db.createScalarFunction({
-    name: "handle_item_created",
-    deterministic: false,
-    directOnly: false,
-    innocuous: false,
-    callback: (dataset, payloadRaw) => {
-      const payload = JSON.parse(payloadRaw);
-      storage.internal.applyOwnEventFromTransaction(reactiveDb.db, {
-        type: "item-created",
-        dataset,
-        item_id: payload.id,
-        payload: payloadRaw
-      });
-      eventApplied = true;
-      return void 0;
-    }
-  });
-  reactiveDb.db.createScalarFunction({
-    name: "handle_item_updated",
-    deterministic: false,
-    directOnly: false,
-    innocuous: false,
-    callback: (dataset, oldPayloadRaw, newPayloadRaw) => {
-      if (oldPayloadRaw === newPayloadRaw) {
-        return void 0;
-      }
-      const tableSchema = reactiveDb.db.dbSchema[dataset];
-      if (!tableSchema?.columns) {
-        throw new Error(`Schema not found for dataset: ${dataset}`);
-      }
-      const oldPayload = JSON.parse(oldPayloadRaw);
-      const newPayload = JSON.parse(newPayloadRaw);
-      let hasDiff = false;
-      const updatePayload = {};
-      for (const column2 of tableSchema.columns) {
-        const oldValue = oldPayload[column2.name];
-        const newValue = newPayload[column2.name];
-        if (oldValue === newValue) {
-          continue;
-        }
-        if (column2.name === "id") {
-          throw new Error(
-            `Cannot update the "id" column of an item. It is used to identify the item and must be immutable.`
-          );
-        }
-        hasDiff = true;
-        updatePayload[column2.name] = newValue;
-      }
-      if (!hasDiff) {
-        return;
-      }
-      storage.internal.applyOwnEventFromTransaction(reactiveDb.db, {
-        type: "item-updated",
-        dataset,
-        item_id: oldPayload.id,
-        payload: JSON.stringify(updatePayload)
-      });
-      eventApplied = true;
-      return void 0;
-    }
-  });
-  reactiveDb.db.createScalarFunction({
-    name: "handle_item_deleted",
-    deterministic: false,
-    directOnly: false,
-    innocuous: false,
-    callback: (dataset, itemId) => {
-      storage.internal.applyOwnEventFromTransaction(reactiveDb.db, {
-        type: "item-deleted",
-        dataset,
-        item_id: itemId,
-        payload: "{}"
-      });
-      eventApplied = true;
-      return void 0;
-    }
-  });
-  reactiveDb.addEventListener("transaction-committed", () => {
-    if (eventApplied) {
-      eventApplied = false;
-      void storage.internal.processEnqueuedEvents();
-    }
-  });
-  reactiveDb.addEventListener("transaction-rolled-back", () => {
-    eventApplied = false;
-  });
-}
-
-// src/db-id.ts
-var dbIdRegex = /^[a-zA-Z][a-zA-Z\-0-9]{2,63}$/;
+//#endregion
+//#region src/db-id.ts
+const dbIdRegex = /^[a-zA-Z][a-zA-Z\-0-9]{2,63}$/;
 function validateDbId(dbId) {
-  if (!dbIdRegex.test(dbId)) {
-    throw new Error("Invalid dbId. Must be between 3 and 64 characters long and start with a letter.");
-  }
+	if (!dbIdRegex.test(dbId)) throw new Error("Invalid dbId. Must be between 3 and 64 characters long and start with a letter.");
 }
-
-// src/devtools-registry.ts
-var devtoolsRegistrySymbol = Symbol.for("@sqlite-sync/devtools");
+//#endregion
+//#region src/devtools-registry.ts
+const devtoolsRegistrySymbol = Symbol.for("@sqlite-sync/devtools");
 function createSQLiteSyncDevtoolsRegistry() {
-  const instances = /* @__PURE__ */ new Map();
-  const listeners = /* @__PURE__ */ new Set();
-  let snapshot = {
-    instances: []
-  };
-  const notify = () => {
-    for (const listener of listeners) {
-      listener();
-    }
-  };
-  const updateSnapshot = () => {
-    snapshot = {
-      instances: Array.from(instances.values())
-    };
-    notify();
-  };
-  return {
-    version: 1,
-    instances,
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    getSnapshot() {
-      return snapshot;
-    },
-    register(instance) {
-      instances.set(instance.instanceId, instance);
-      updateSnapshot();
-      let isUnregistered = false;
-      return () => {
-        if (isUnregistered) return;
-        isUnregistered = true;
-        if (!instances.delete(instance.instanceId)) return;
-        updateSnapshot();
-      };
-    }
-  };
+	const instances = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let snapshot = { instances: [] };
+	const notify = () => {
+		for (const listener of listeners) listener();
+	};
+	const updateSnapshot = () => {
+		snapshot = { instances: Array.from(instances.values()) };
+		notify();
+	};
+	return {
+		version: 1,
+		instances,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		getSnapshot() {
+			return snapshot;
+		},
+		register(instance) {
+			instances.set(instance.instanceId, instance);
+			updateSnapshot();
+			let isUnregistered = false;
+			return () => {
+				if (isUnregistered) return;
+				isUnregistered = true;
+				if (!instances.delete(instance.instanceId)) return;
+				updateSnapshot();
+			};
+		}
+	};
 }
 function getOrCreateSQLiteSyncDevtoolsRegistry() {
-  const registryGlobal = globalThis;
-  registryGlobal[devtoolsRegistrySymbol] ??= createSQLiteSyncDevtoolsRegistry();
-  return registryGlobal[devtoolsRegistrySymbol];
+	const registryGlobal = globalThis;
+	registryGlobal[devtoolsRegistrySymbol] ??= createSQLiteSyncDevtoolsRegistry();
+	return registryGlobal[devtoolsRegistrySymbol];
 }
-
-// src/memory-db/memory-db.ts
-async function createMemoryDb({
-  nodeId,
-  migrator,
-  reactiveDb: _reactiveDb,
-  hlcCounter,
-  crdtTables,
-  initializeSchema = true,
-  initialSyncId,
-  eventHlcAccumulator,
-  syncDbSchema
-}) {
-  await xxhash.ensureLoaded();
-  const reactiveDb = _reactiveDb;
-  const db = reactiveDb.db;
-  if (initializeSchema) {
-    applyMemoryDbSchema(db);
-    for (const table of crdtTables) {
-      makeCrdtTable({
-        db,
-        baseTableName: table.baseTableName,
-        crdtTableName: table.crdtTableName
-      });
-    }
-  }
-  const crdtStorage = createCrdtStorage({
-    nodeId,
-    initialLocalSyncId: initialSyncId ?? getCurrentSyncId(db),
-    hlc: hlcCounter,
-    migrator,
-    db,
-    dbConfig: memoryDbConfig,
-    eventHlcAccumulator,
-    schema: syncDbSchema
-  });
-  registerCrdtFunctions({
-    reactiveDb,
-    storage: crdtStorage
-  });
-  return {
-    crdtStorage
-  };
+//#endregion
+//#region src/memory-db/memory-db.ts
+async function createMemoryDb({ nodeId, migrator, reactiveDb: _reactiveDb, hlcCounter, crdtTables, initializeSchema = true, initialSyncId, eventHlcAccumulator, syncDbSchema }) {
+	await xxhash.ensureLoaded();
+	const reactiveDb = _reactiveDb;
+	const db = reactiveDb.db;
+	if (initializeSchema) {
+		applyMemoryDbSchema(db);
+		for (const table of crdtTables) makeCrdtTable({
+			db,
+			baseTableName: table.baseTableName,
+			crdtTableName: table.crdtTableName
+		});
+	}
+	const crdtStorage = createCrdtStorage({
+		nodeId,
+		initialLocalSyncId: initialSyncId ?? getCurrentSyncId(db),
+		hlc: hlcCounter,
+		migrator,
+		db,
+		dbConfig: memoryDbConfig,
+		eventHlcAccumulator,
+		schema: syncDbSchema
+	});
+	registerCrdtIntentDrainer({
+		reactiveDb,
+		storage: crdtStorage
+	});
+	return { crdtStorage };
 }
 function getCurrentSyncId(db) {
-  return db.execute("SELECT coalesce(max(sync_id), 0) AS syncId FROM persisted_crdt_events", {
-    loggerLevel: "system"
-  }).rows[0]?.syncId ?? 0;
+	return db.execute("SELECT coalesce(max(sync_id), 0) AS syncId FROM persisted_crdt_events", { loggerLevel: "system" }).rows[0]?.syncId ?? 0;
 }
-
-// src/worker-db/db-worker-client.ts
-var createWorkerDbClient = async ({
-  broadcastChannels,
-  worker,
-  config
-}) => {
-  const eventTarget = createTypedEventTarget();
-  const workerRequestsMap = /* @__PURE__ */ new Map();
-  let isDisposed = false;
-  const queryWorker = (method, args) => {
-    if (isDisposed) {
-      return Promise.reject(new Error("Worker client disposed"));
-    }
-    const requestId = crypto.randomUUID();
-    const promise = createDeferredPromise({
-      timeout: 3e4,
-      onTimeout: () => workerRequestsMap.delete(requestId)
-    });
-    workerRequestsMap.set(requestId, promise);
-    const request = {
-      type: "request",
-      requestId,
-      method,
-      args
-    };
-    broadcastChannels.requests.postMessage(request);
-    return promise.promise;
-  };
-  const handleWorkerResponse = (message) => {
-    const promise = workerRequestsMap.get(message.requestId);
-    if (!promise) {
-      return;
-    }
-    promise.resolve(message.data);
-    workerRequestsMap.delete(message.requestId);
-  };
-  const handleWorkerError = (message) => {
-    const promise = workerRequestsMap.get(message.requestId);
-    if (!promise) {
-      return;
-    }
-    promise.reject(new Error(message.error));
-    workerRequestsMap.delete(message.requestId);
-  };
-  broadcastChannels.responses.onmessage = (event) => {
-    const message = event.data;
-    if (isWorkerResponseMessage(message)) {
-      handleWorkerResponse(message);
-    } else if (isWorkerErrorResponseMessage(message)) {
-      handleWorkerError(message);
-    } else if (isWorkerNotificationMessage(message)) {
-      eventTarget.dispatchEvent(message.notificationType, message);
-    }
-  };
-  const rpc = {
-    execute: (query) => queryWorker("execute", [query]),
-    getSnapshot: () => queryWorker("getSnapshot", []),
-    importData: (data, opts) => queryWorker("importData", [data, opts]),
-    pushTabEvents: (request) => queryWorker("pushTabEvents", [request]),
-    pullEvents: (params) => queryWorker("pullEvents", [params]),
-    postState: () => queryWorker("postState", []),
-    goOnline: () => queryWorker("goOnline", []),
-    goOffline: () => queryWorker("goOffline", []),
-    requestReload: (options) => queryWorker("requestReload", [options])
-  };
-  const statePromise = awaitWorkerState(eventTarget);
-  postWorkerConfig(worker, config);
-  rpc.postState().catch(noop);
-  let workerState = await statePromise;
-  eventTarget.addEventListener("state-changed", (event) => {
-    workerState = event.payload.state;
-  });
-  const dispose = () => {
-    isDisposed = true;
-    broadcastChannels.responses.onmessage = null;
-    for (const [id, deferred] of workerRequestsMap) {
-      deferred.reject(new Error("Worker client disposed"));
-      workerRequestsMap.delete(id);
-    }
-  };
-  return {
-    ...rpc,
-    subscribe: eventTarget.addEventListener,
-    getState: () => workerState,
-    dispose
-  };
+//#endregion
+//#region src/worker-db/db-worker-client.ts
+const createWorkerDbClient = async ({ broadcastChannels, worker, config }) => {
+	const eventTarget = createTypedEventTarget();
+	const workerRequestsMap = /* @__PURE__ */ new Map();
+	let isDisposed = false;
+	const queryWorker = (method, args) => {
+		if (isDisposed) return Promise.reject(/* @__PURE__ */ new Error("Worker client disposed"));
+		const requestId = crypto.randomUUID();
+		const promise = createDeferredPromise({
+			timeout: 3e4,
+			onTimeout: () => workerRequestsMap.delete(requestId)
+		});
+		workerRequestsMap.set(requestId, promise);
+		const request = {
+			type: "request",
+			requestId,
+			method,
+			args
+		};
+		broadcastChannels.requests.postMessage(request);
+		return promise.promise;
+	};
+	const handleWorkerResponse = (message) => {
+		const promise = workerRequestsMap.get(message.requestId);
+		if (!promise) return;
+		promise.resolve(message.data);
+		workerRequestsMap.delete(message.requestId);
+	};
+	const handleWorkerError = (message) => {
+		const promise = workerRequestsMap.get(message.requestId);
+		if (!promise) return;
+		promise.reject(new Error(message.error));
+		workerRequestsMap.delete(message.requestId);
+	};
+	broadcastChannels.responses.onmessage = (event) => {
+		const message = event.data;
+		if (isWorkerResponseMessage(message)) handleWorkerResponse(message);
+		else if (isWorkerErrorResponseMessage(message)) handleWorkerError(message);
+		else if (isWorkerNotificationMessage(message)) eventTarget.dispatchEvent(message.notificationType, message);
+	};
+	const rpc = {
+		execute: (query) => queryWorker("execute", [query]),
+		getSnapshot: () => queryWorker("getSnapshot", []),
+		importData: (data, opts) => queryWorker("importData", [data, opts]),
+		pushTabEvents: (request) => queryWorker("pushTabEvents", [request]),
+		pullEvents: (params) => queryWorker("pullEvents", [params]),
+		postState: () => queryWorker("postState", []),
+		goOnline: () => queryWorker("goOnline", []),
+		goOffline: () => queryWorker("goOffline", []),
+		requestReload: (options) => queryWorker("requestReload", [options])
+	};
+	const statePromise = awaitWorkerState(eventTarget);
+	postWorkerConfig(worker, config);
+	rpc.postState().catch(noop);
+	let workerState = await statePromise;
+	eventTarget.addEventListener("state-changed", (event) => {
+		workerState = event.payload.state;
+	});
+	const dispose = () => {
+		isDisposed = true;
+		broadcastChannels.responses.onmessage = null;
+		for (const [id, deferred] of workerRequestsMap) {
+			deferred.reject(/* @__PURE__ */ new Error("Worker client disposed"));
+			workerRequestsMap.delete(id);
+		}
+	};
+	return {
+		...rpc,
+		subscribe: eventTarget.addEventListener,
+		getState: () => workerState,
+		dispose
+	};
 };
 function awaitWorkerState(eventTarget) {
-  const promise = createDeferredPromise({ timeout: 15e3 });
-  const subscription = eventTarget.addEventListener("state-changed", (event) => {
-    promise.resolve(event.payload.state);
-    subscription.unsubscribe();
-  });
-  return promise.promise;
+	const promise = createDeferredPromise({ timeout: 15e3 });
+	const subscription = eventTarget.addEventListener("state-changed", (event) => {
+		promise.resolve(event.payload.state);
+		subscription.unsubscribe();
+	});
+	return promise.promise;
 }
 function postWorkerConfig(worker, config) {
-  const configMessage = {
-    type: "init",
-    config
-  };
-  worker.postMessage(configMessage);
+	const configMessage = {
+		type: "init",
+		config
+	};
+	worker.postMessage(configMessage);
 }
-
-// src/sync-db.ts
-var defaultLogger = (type, message, level = "info") => {
-  const logMessage = `[${type}] ${message}`;
-  switch (level) {
-    case "info":
-      console.log(logMessage);
-      break;
-    case "warning":
-      console.warn(logMessage);
-      break;
-    case "error":
-      console.error(logMessage);
-      break;
-    case "trace":
-      console.trace(logMessage);
-      break;
-  }
+//#endregion
+//#region src/sync-db.ts
+function createSqlExecutor(tx, unsafe) {
+	return {
+		execute: (query) => tx.execute(query, unsafe ? { skipAfterMutatingStatement: true } : void 0),
+		executeKysely: (factory) => tx.executeKysely(factory, unsafe ? { skipAfterMutatingStatement: true } : void 0)
+	};
+}
+/** @internal Exported from this module for focused facade tests, but not from the package entry point. */
+function createSyncedDbDatabase(reactiveDb) {
+	const safeExecutor = createSqlExecutor(reactiveDb.db, false);
+	const unsafeExecutor = createSqlExecutor(reactiveDb.db, true);
+	return {
+		...safeExecutor,
+		unsafe: unsafeExecutor,
+		executeTransaction: (callback) => reactiveDb.db.executeTransaction((tx) => {
+			const safeTransactionExecutor = createSqlExecutor(tx, false);
+			const unsafeTransactionExecutor = createSqlExecutor(tx, true);
+			return callback({
+				...safeTransactionExecutor,
+				unsafe: unsafeTransactionExecutor,
+				sql: tx.sql.bind(tx)
+			});
+		}),
+		createLiveQuery: reactiveDb.createLiveQuery.bind(reactiveDb),
+		getSharedLiveQuery: reactiveDb.getSharedLiveQuery.bind(reactiveDb)
+	};
+}
+const defaultLogger = (type, message, level = "info") => {
+	const logMessage = `[${type}] ${message}`;
+	switch (level) {
+		case "info":
+			console.log(logMessage);
+			break;
+		case "warning":
+			console.warn(logMessage);
+			break;
+		case "error":
+			console.error(logMessage);
+			break;
+		case "trace": console.trace(logMessage);
+	}
 };
 async function createSyncedDb(options) {
-  validateDbId(options.dbId);
-  const perf = startPerformanceLogger(defaultLogger);
-  const instanceId = generateId();
-  const tabId = generateId();
-  const broadcastChannels = createBroadcastChannels(options.dbId);
-  const clientLockAcquired = createDeferredPromise();
-  const clientLockRelease = createDeferredPromise();
-  navigator.locks.request(`${syncDbClientLockName}-${options.dbId}`, { mode: "shared" }, () => {
-    clientLockAcquired.resolve();
-    return clientLockRelease.promise;
-  });
-  await clientLockAcquired.promise;
-  const workerClient = await createWorkerDbClient({
-    worker: options.worker,
-    config: {
-      clientId: generateId(),
-      dbId: options.dbId,
-      props: options.workerProps
-    },
-    broadcastChannels
-  });
-  const hlcCounter = new HLCCounter(tabId, () => Date.now());
-  const workerClientSnapshot = await workerClient.getSnapshot();
-  const reactiveDb = await createSQLiteReactiveDb({
-    snapshot: workerClientSnapshot.file,
-    logger: defaultLogger
-  });
-  const memoryDbMigrator = {
-    currentSchemaVersion: workerClientSnapshot.schemaVersion,
-    latestSchemaVersion: workerClientSnapshot.schemaVersion,
-    migrateDbToLatest: () => {
-      throw new Error("Memory DB migrations are not implemented");
-    },
-    migrateEvent: (event, targetVersion) => {
-      if (event.schema_version === targetVersion) {
-        return event;
-      }
-      throw new Error("Memory DB migrations are not implemented");
-    },
-    migrateEvents: (events) => events
-  };
-  const { crdtStorage } = await createMemoryDb({
-    nodeId: tabId,
-    migrator: memoryDbMigrator,
-    reactiveDb,
-    hlcCounter,
-    crdtTables: options.syncDbSchema.tablesConfig,
-    syncDbSchema: options.syncDbSchema
-  });
-  const pullSyncId = createStoredValue({
-    initialValue: workerClientSnapshot.syncId
-  });
-  const pushSyncId = createStoredValue({
-    initialValue: 0
-  });
-  const tabRemoteSource = createCrdtSyncRemoteSource({
-    bufferSize: 500,
-    pullSyncId,
-    pushSyncId,
-    storage: crdtStorage,
-    nodeId: tabId,
-    migrator: memoryDbMigrator,
-    remoteFactory: ({ onEventsAvailable }) => {
-      const subscription = workerClient.subscribe("new-event-chunk-applied", (event) => {
-        onEventsAvailable({ newSyncId: event.payload.newSyncId, remoteEventHlcSum: event.payload.eventHlcSum });
-      });
-      return {
-        pullEvents: (request) => workerClient.pullEvents(request),
-        pushEvents: (request) => workerClient.pushTabEvents(request),
-        disconnect: () => {
-          subscription.unsubscribe();
-        }
-      };
-    }
-  });
-  tabRemoteSource.goOnline();
-  const reloadRequestedSubscription = workerClient.subscribe("reload-requested", () => {
-    globalThis.location?.reload();
-  });
-  perf.logEnd("createSyncedDb", "initialized", "info");
-  const exportData = createExportData({
-    reactiveDb,
-    tablesConfig: options.syncDbSchema.tablesConfig,
-    schemaVersion: workerClientSnapshot.schemaVersion
-  });
-  const importData = (data, opts) => workerClient.importData(data, opts);
-  let isDisposed = false;
-  let unregisterDevtools;
-  const dispose = async () => {
-    if (isDisposed) return;
-    isDisposed = true;
-    unregisterDevtools?.();
-    reloadRequestedSubscription.unsubscribe();
-    clientLockRelease.resolve();
-    await tabRemoteSource.dispose();
-    broadcastChannels.requests.close();
-    broadcastChannels.responses.close();
-    workerClient.dispose();
-    reactiveDb.dispose();
-  };
-  const syncedDb = {
-    db: {
-      execute: reactiveDb.db.execute.bind(reactiveDb.db),
-      executeKysely: reactiveDb.db.executeKysely.bind(reactiveDb.db),
-      executeTransaction: reactiveDb.db.executeTransaction.bind(reactiveDb.db),
-      createLiveQuery: reactiveDb.createLiveQuery.bind(reactiveDb),
-      getSharedLiveQuery: reactiveDb.getSharedLiveQuery.bind(reactiveDb)
-    },
-    state: {
-      getState: workerClient.getState.bind(workerClient),
-      subscribe: (onChange) => {
-        const { unsubscribe } = workerClient.subscribe("state-changed", onChange);
-        return unsubscribe;
-      },
-      goOnline: workerClient.goOnline.bind(workerClient),
-      goOffline: workerClient.goOffline.bind(workerClient)
-    },
-    /**
-     * Ask the elected worker to broadcast a page reload to all tabs for this dbId.
-     *
-     * With `clean: true` the worker durably records a reset request epoch before
-     * broadcasting, so the worker elected on the next startup initializes with
-     * `clearOnInit: true` and wipes the persisted DB. Destructive — use as a
-     * recovery path when the durable worker DB may be de-synced.
-     *
-     * Pending in-memory tab events are not preserved, and the returned promise
-     * may never settle in the caller — the page typically unloads first.
-     */
-    requestReload: async (options2) => {
-      await workerClient.requestReload(options2);
-      setTimeout(() => globalThis.location?.reload(), 250);
-    },
-    subscribe: workerClient.subscribe,
-    exportData,
-    importData,
-    dispose,
-    _internal: {
-      executeAsync: workerClient.execute.bind(workerClient),
-      getMemoryQueryTables: reactiveDb.getTablesUsed.bind(reactiveDb),
-      getSharedLiveQueriesSnapshot: reactiveDb.getSharedLiveQueriesSnapshot.bind(reactiveDb),
-      crdtTableNames: options.syncDbSchema.tablesConfig.map((table) => table.crdtTableName),
-      crdtTablesConfig: options.syncDbSchema.tablesConfig,
-      schemaVersion: workerClientSnapshot.schemaVersion,
-      migrationVersions: Object.keys(options.syncDbSchema.migrations).map(Number).sort((a, b) => a - b)
-    }
-  };
-  unregisterDevtools = getOrCreateSQLiteSyncDevtoolsRegistry().register({
-    instanceId,
-    dbId: options.dbId,
-    createdAt: Date.now(),
-    instance: syncedDb
-  });
-  return syncedDb;
+	validateDbId(options.dbId);
+	const perf = startPerformanceLogger(defaultLogger);
+	const instanceId = generateId();
+	const tabId = generateId();
+	const broadcastChannels = createBroadcastChannels(options.dbId);
+	const clientLockAcquired = createDeferredPromise();
+	const clientLockRelease = createDeferredPromise();
+	navigator.locks.request(`${syncDbClientLockName}-${options.dbId}`, { mode: "shared" }, () => {
+		clientLockAcquired.resolve();
+		return clientLockRelease.promise;
+	});
+	await clientLockAcquired.promise;
+	const workerClient = await createWorkerDbClient({
+		worker: options.worker,
+		config: {
+			clientId: generateId(),
+			dbId: options.dbId,
+			props: options.workerProps
+		},
+		broadcastChannels
+	});
+	const hlcCounter = new HLCCounter(tabId, () => Date.now());
+	const workerClientSnapshot = await workerClient.getSnapshot();
+	const reactiveDb = await createSQLiteReactiveDb({
+		snapshot: workerClientSnapshot.file,
+		logger: defaultLogger
+	});
+	const memoryDbMigrator = {
+		currentSchemaVersion: workerClientSnapshot.schemaVersion,
+		latestSchemaVersion: workerClientSnapshot.schemaVersion,
+		migrateDbToLatest: () => {
+			throw new Error("Memory DB migrations are not implemented");
+		},
+		migrateEvent: (event, targetVersion) => {
+			if (event.schema_version === targetVersion) return event;
+			throw new Error("Memory DB migrations are not implemented");
+		},
+		migrateEvents: (events) => events
+	};
+	const { crdtStorage } = await createMemoryDb({
+		nodeId: tabId,
+		migrator: memoryDbMigrator,
+		reactiveDb,
+		hlcCounter,
+		crdtTables: options.syncDbSchema.tablesConfig,
+		syncDbSchema: options.syncDbSchema
+	});
+	const pullSyncId = createStoredValue({ initialValue: workerClientSnapshot.syncId });
+	const pushSyncId = createStoredValue({ initialValue: 0 });
+	const tabRemoteSource = createCrdtSyncRemoteSource({
+		bufferSize: 500,
+		pullSyncId,
+		pushSyncId,
+		storage: crdtStorage,
+		nodeId: tabId,
+		migrator: memoryDbMigrator,
+		remoteFactory: ({ onEventsAvailable }) => {
+			const subscription = workerClient.subscribe("new-event-chunk-applied", (event) => {
+				onEventsAvailable({
+					newSyncId: event.payload.newSyncId,
+					remoteEventHlcSum: event.payload.eventHlcSum
+				});
+			});
+			return {
+				pullEvents: (request) => workerClient.pullEvents(request),
+				pushEvents: (request) => workerClient.pushTabEvents(request),
+				disconnect: () => {
+					subscription.unsubscribe();
+				}
+			};
+		}
+	});
+	tabRemoteSource.goOnline();
+	const reloadRequestedSubscription = workerClient.subscribe("reload-requested", () => {
+		globalThis.location?.reload();
+	});
+	perf.logEnd("createSyncedDb", "initialized", "info");
+	const exportData = createExportData({
+		reactiveDb,
+		tablesConfig: options.syncDbSchema.tablesConfig,
+		schemaVersion: workerClientSnapshot.schemaVersion
+	});
+	const importData = (data, opts) => workerClient.importData(data, opts);
+	let isDisposed = false;
+	let unregisterDevtools;
+	const dispose = async () => {
+		if (isDisposed) return;
+		isDisposed = true;
+		unregisterDevtools?.();
+		reloadRequestedSubscription.unsubscribe();
+		clientLockRelease.resolve();
+		await tabRemoteSource.dispose();
+		broadcastChannels.requests.close();
+		broadcastChannels.responses.close();
+		workerClient.dispose();
+		reactiveDb.dispose();
+	};
+	const syncedDb = {
+		db: createSyncedDbDatabase(reactiveDb),
+		state: {
+			getState: workerClient.getState.bind(workerClient),
+			subscribe: (onChange) => {
+				const { unsubscribe } = workerClient.subscribe("state-changed", onChange);
+				return unsubscribe;
+			},
+			goOnline: workerClient.goOnline.bind(workerClient),
+			goOffline: workerClient.goOffline.bind(workerClient)
+		},
+		/**
+		* Ask the elected worker to broadcast a page reload to all tabs for this dbId.
+		*
+		* With `clean: true` the worker durably records a reset request epoch before
+		* broadcasting, so the worker elected on the next startup initializes with
+		* `clearOnInit: true` and wipes the persisted DB. Destructive — use as a
+		* recovery path when the durable worker DB may be de-synced.
+		*
+		* Pending in-memory tab events are not preserved, and the returned promise
+		* may never settle in the caller — the page typically unloads first.
+		*/
+		requestReload: async (options) => {
+			await workerClient.requestReload(options);
+			setTimeout(() => globalThis.location?.reload(), 250);
+		},
+		subscribe: workerClient.subscribe,
+		exportData,
+		importData,
+		dispose,
+		_internal: {
+			executeAsync: workerClient.execute.bind(workerClient),
+			getMemoryQueryTables: reactiveDb.getTablesUsed.bind(reactiveDb),
+			getSharedLiveQueriesSnapshot: reactiveDb.getSharedLiveQueriesSnapshot.bind(reactiveDb),
+			crdtTableNames: options.syncDbSchema.tablesConfig.map((table) => table.crdtTableName),
+			crdtTablesConfig: options.syncDbSchema.tablesConfig,
+			schemaVersion: workerClientSnapshot.schemaVersion,
+			migrationVersions: Object.keys(options.syncDbSchema.migrations).map(Number).sort((a, b) => a - b)
+		}
+	};
+	unregisterDevtools = getOrCreateSQLiteSyncDevtoolsRegistry().register({
+		instanceId,
+		dbId: options.dbId,
+		createdAt: Date.now(),
+		instance: syncedDb
+	});
+	return syncedDb;
 }
-export {
-  CRDT_EVENT_NO_OP_PAYLOAD,
-  ColumnBuilder,
-  CrdtEventValidationError,
-  HLCCounter,
-  RESET_REQUEST_TTL_MS,
-  SQLiteDbWrapper,
-  SQLiteReactiveDb,
-  TableBuilder,
-  TypedBroadcastChannel,
-  TypedEvent,
-  applyMemoryDbSchema,
-  applyWorkerDbSchema,
-  baseSystemMigrations,
-  compareHLC,
-  createCrdtApplyFunction,
-  createCrdtStorage,
-  createCrdtStorageMutator,
-  createCrdtSyncProducer,
-  createCrdtSyncRemoteSource,
-  createDeferredPromise,
-  createExportData,
-  createImportData,
-  createKvStoreTableQuery,
-  createMigrations,
-  createMigrator,
-  createSQLiteCrdtApplyFunction,
-  createSQLiteKvStore,
-  createStoredValue,
-  createSyncedDb,
-  createSystemDbConfig,
-  createTypedEventTarget,
-  defineSyncSchema,
-  deserializeHLC,
-  dummyKysely,
-  formatSchemaVerificationIssues,
-  generateId,
-  introspectDb,
-  isNoOpCrdtEventPayload,
-  jsonSafeParse,
-  makeCrdtTable,
-  parametersAreEqual,
-  quoteId,
-  runSystemMigrations,
-  serializeHLC,
-  startPerformanceLogger,
-  t,
-  tryCatch,
-  tryCatchAsync,
-  validateNewCrdtEvent,
-  verifySyncSchema,
-  xxhash
-};
+//#endregion
+export { CRDT_EVENT_NO_OP_PAYLOAD, ColumnBuilder, CrdtEventValidationError, HLCCounter, RESET_REQUEST_TTL_MS, SQLiteDbWrapper, SQLiteReactiveDb, TableBuilder, TypedBroadcastChannel, TypedEvent, admitClientEvents, applyMemoryDbSchema, applyWorkerDbSchema, compareHLC, createCrdtApplyFunction, createCrdtStorage, createCrdtStorageMutator, createCrdtSyncProducer, createCrdtSyncRemoteSource, createDeferredPromise, createExportData, createImportData, createKvStoreTableQuery, createMigrations, createMigrator, createSQLiteCrdtApplyFunction, createSQLiteKvStore, createStoredValue, createSyncedDb, createTypedEventTarget, defineSyncSchema, deserializeHLC, dummyKysely, formatSchemaVerificationIssues, generateId, introspectDb, isNoOpCrdtEventPayload, jsonSafeParse, makeCrdtTable, parametersAreEqual, quoteId, serializeHLC, startPerformanceLogger, t, tryCatch, tryCatchAsync, validateNewCrdtEvent, verifySyncSchema, xxhash };
+
 //# sourceMappingURL=index.js.map