@sqlite-sync/core 0.1.1 → 0.2.0

package/dist/{chunk-627DSM2Q.js → chunk-O4WYEB4H.js}

@@ -2,9 +2,11 @@ import {
   TypedBroadcastChannel,
   createTypedEventTarget,
   ensureSingletonExecution,
+  generateId,
+  parseTableName,
   quoteId,
   tryCatchAsync
-} from "./chunk-UGF5IU53.js";
+} from "./chunk-NHT3ELMN.js";
 
 // src/dummy-kysely.ts
 import { DummyDriver, Kysely, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from "kysely";
@@ -17,6 +19,29 @@ var dummyKysely = new Kysely({
   }
 });
 
+// src/hash.ts
+import initXxhash from "xxhash-wasm";
+var loadPromise = null;
+var 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);
+}
+var xxhash = {
+  ensureLoaded,
+  h64
+};
+
 // src/hlc.ts
 var MAX_COUNTER = 36 ** 5 - 1;
 var DEFAULT_MAX_DRIFT_MS = 6 * 60 * 60 * 1e3;
@@ -126,8 +151,8 @@ function introspectDb(_db) {
     columnsByTable[row.table].push(row);
   }
   return Object.fromEntries(
-    tables.map(({ name, sql: sql2, type }) => {
-      let autoIncrementCol = sql2?.split(/[(),]/)?.find((it) => it.toLowerCase().includes("autoincrement"))?.trimStart()?.split(/\s+/)?.[0]?.replace(/["`]/g, "");
+    tables.map(({ name, sql: sql4, type }) => {
+      let autoIncrementCol = sql4?.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);
@@ -198,16 +223,16 @@ var SQLiteDbWrapper = class {
     return this.loadedDbSchema;
   }
   execute(opts, meta) {
-    const sql2 = typeof opts === "string" ? opts : opts.sql;
+    const sql4 = typeof opts === "string" ? opts : opts.sql;
     const bind = typeof opts === "string" ? void 0 : opts.parameters;
     const perf = this.logger ? startPerformanceLogger(this.logger) : void 0;
     const rows = this.ensureDb.exec({
-      sql: sql2,
+      sql: sql4,
       bind,
       returnValue: "resultRows",
       rowMode: "object"
     });
-    perf?.logEnd(`${this.loggerPrefix ?? ""}:query`, sql2, meta?.loggerLevel);
+    perf?.logEnd(`${this.loggerPrefix ?? ""}:query`, sql4, meta?.loggerLevel);
     return { rows };
   }
   executeTransaction(callback) {
@@ -253,26 +278,29 @@ var SQLiteDbWrapper = class {
       }
     };
   }
-  prepare(sql2, opts) {
+  prepare(sql4, opts) {
     const perf = this.logger ? startPerformanceLogger(this.logger) : void 0;
-    const stmt = this.ensureDb.prepare(sql2);
-    perf?.logEnd(`${this.loggerPrefix ?? ""}:prepare`, sql2, opts?.loggerLevel);
+    const stmt = this.ensureDb.prepare(sql4);
+    perf?.logEnd(`${this.loggerPrefix ?? ""}:prepare`, sql4, opts?.loggerLevel);
     let isFinalized = false;
     const execute = (params) => {
       if (isFinalized) {
         throw new Error("Statement is finalized");
       }
       const perf2 = this.logger ? startPerformanceLogger(this.logger) : void 0;
-      if (params.length > 0) {
-        stmt.bind(params);
-      }
-      const results = [];
-      while (stmt.step()) {
-        results.push(stmt.get({}));
+      try {
+        if (params.length > 0) {
+          stmt.bind(params);
+        }
+        const results = [];
+        while (stmt.step()) {
+          results.push(stmt.get({}));
+        }
+        return results;
+      } finally {
+        stmt.reset(true);
+        perf2?.logEnd(`${this.loggerPrefix ?? ""}:prepare-execute`, sql4, opts?.loggerLevel);
       }
-      stmt.reset(true);
-      perf2?.logEnd(`${this.loggerPrefix ?? ""}:prepare-execute`, sql2, opts?.loggerLevel);
-      return results;
     };
     const finalize = () => {
       isFinalized = true;
@@ -315,13 +343,13 @@ var SQLiteDbWrapper = class {
   }
   executePreparedRaw({
     key,
-    sql: sql2,
+    sql: sql4,
     params,
     meta
   }) {
     let statement = this.preparedRawStatementsMap.get(key);
     if (!statement) {
-      statement = this.prepare(sql2, meta);
+      statement = this.prepare(sql4, meta);
       this.preparedRawStatementsMap.set(key, statement);
     }
     return statement.execute(params ?? []);
@@ -394,6 +422,12 @@ var SQLiteDbWrapper = class {
   }
 };
 
+// src/sqlite-crdt/crdt-table-schema.ts
+var CRDT_EVENT_NO_OP_PAYLOAD = "no-op";
+function isNoOpCrdtEventPayload(payload) {
+  return payload === CRDT_EVENT_NO_OP_PAYLOAD;
+}
+
 // src/migrations/migrator.ts
 var protectedColumns = ["id", "tombstone"];
 function assertColumnNotProtected(column, operation) {
@@ -488,21 +522,21 @@ var migrationSteps = {
   }
 };
 function buildMigrationSql(steps) {
-  return steps.flatMap((step) => Array.isArray(step.sql) ? step.sql : [step.sql]).map((sql2) => {
-    if (typeof sql2 === "string") {
-      return { sql: sql2, parameters: [] };
+  return steps.flatMap((step) => Array.isArray(step.sql) ? step.sql : [step.sql]).map((sql4) => {
+    if (typeof sql4 === "string") {
+      return { sql: sql4, parameters: [] };
     }
-    if (typeof sql2 === "function") {
-      const query = sql2(dummyKysely).compile();
+    if (typeof sql4 === "function") {
+      const query = sql4(dummyKysely).compile();
       return { sql: query.sql, parameters: query.parameters };
     }
-    if ("compile" in sql2) {
-      const query = sql2.compile();
+    if ("compile" in sql4) {
+      const query = sql4.compile();
       return { sql: query.sql, parameters: query.parameters };
     }
     return {
-      sql: sql2.sql,
-      parameters: sql2.parameters ?? []
+      sql: sql4.sql,
+      parameters: sql4.parameters ?? []
     };
   });
 }
@@ -595,6 +629,12 @@ function createMigrator({
         `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;
     }
@@ -667,15 +707,13 @@ function createStoredValue({
 }
 
 // src/sqlite-kv-store.ts
+import { sql as sql2 } from "kysely";
 function createKvStoreTableQuery(schema, tableName) {
-  return schema.createTable(tableName).ifNotExists().addColumn("key", "text", (col) => col.notNull().primaryKey()).addColumn("value", "text", (col) => col.notNull());
+  return schema.createTable(tableName).ifNotExists().addColumn("key", "text", (col) => col.notNull().primaryKey()).addColumn("value", "text", (col) => col.notNull()).modifyEnd(sql2`without rowid`);
 }
-function createSQLiteKvStore({
-  db,
-  metaTableName
-}) {
+function createSQLiteKvStore({ db, metaTableName }) {
   const metaDb = db;
-  const get = (key) => {
+  const get2 = (key) => {
     const [result] = metaDb.executePrepared(
       "get-meta-value",
       { key },
@@ -684,7 +722,7 @@ function createSQLiteKvStore({
     );
     return result?.value ?? null;
   };
-  const set = (key, value) => {
+  const set2 = (key, value) => {
     metaDb.executePrepared(
       "set-meta-value",
       { key, value },
@@ -701,32 +739,49 @@ function createSQLiteKvStore({
     );
   };
   const getNumberOrDefault = (key, defaultValue) => {
-    const value = get(key);
+    const value = get2(key);
     if (!value) return defaultValue;
     const parsedValue = Number.parseInt(value, 10);
     return Number.isNaN(parsedValue) ? defaultValue : parsedValue;
   };
   return {
-    get,
-    set,
+    get: get2,
+    set: set2,
     remove,
     createStringStoredValue: (key, defaultValue) => createStoredValue({
-      initialValue: get(key) ?? defaultValue,
-      saveToStorage: (val) => set(key, val)
+      initialValue: get2(key) ?? defaultValue,
+      saveToStorage: (val) => set2(key, val)
     }),
     createNumberStoredValue: (key, defaultValue) => createStoredValue({
       initialValue: getNumberOrDefault(key, defaultValue),
-      saveToStorage: (val) => set(key, val.toString())
+      saveToStorage: (val) => set2(key, val.toString())
     })
   };
 }
 
 // src/migrations/system-schema.ts
+function createSystemDbConfig({
+  eventsTableName,
+  updateLogTableName
+}) {
+  return {
+    eventsTable: parseTableName(eventsTableName),
+    updateLogTable: parseTableName(updateLogTableName)
+  };
+}
+var workerDbConfig = createSystemDbConfig({
+  eventsTableName: "worker.crdt_events",
+  updateLogTableName: "crdt_update_log"
+});
+var memoryDbConfig = createSystemDbConfig({
+  eventsTableName: "persisted_crdt_events",
+  updateLogTableName: "crdt_update_log"
+});
 var baseSystemMigrations = [
   {
     version: 0,
     up: (ctx) => {
-      ctx.execute(`CREATE TABLE IF NOT EXISTS ${ctx.eventsTableName} (
+      ctx.execute(`CREATE TABLE IF NOT EXISTS ${ctx.eventsTable.fullIdentifier} (
         "sync_id" integer NOT NULL PRIMARY KEY,
         "schema_version" integer NOT NULL,
         "status" text NOT NULL,
@@ -737,7 +792,7 @@ var baseSystemMigrations = [
         "item_id" text NOT NULL,
         "payload" text NOT NULL
       )`);
-      ctx.execute(`CREATE TABLE IF NOT EXISTS ${ctx.updateLogTableName} (
+      ctx.execute(`CREATE TABLE IF NOT EXISTS ${ctx.updateLogTable.fullIdentifier} (
         "dataset" text NOT NULL,
         "item_id" text NOT NULL,
         "payload" text NOT NULL,
@@ -748,14 +803,31 @@ var baseSystemMigrations = [
   {
     version: 1,
     up: (ctx) => {
-      ctx.execute(`ALTER TABLE ${ctx.eventsTableName} ADD COLUMN "source_node_id" TEXT NOT NULL DEFAULT ''`);
+      ctx.execute(`ALTER TABLE ${ctx.eventsTable.fullIdentifier} ADD COLUMN "source_node_id" TEXT NOT NULL DEFAULT ''`);
+    }
+  },
+  {
+    version: 2,
+    up: (ctx) => {
+      const indexName = `${ctx.eventsTable.table}_status_sync_id_idx`;
+      ctx.execute(
+        `CREATE INDEX IF NOT EXISTS ${ctx.eventsTable.schema}.${indexName} ON ${ctx.eventsTable.table} ("status", "sync_id")`
+      );
+    }
+  },
+  {
+    version: 3,
+    up: (ctx) => {
+      const indexName = `${ctx.eventsTable.table}_timestamp_status_sync_id_idx`;
+      ctx.execute(
+        `CREATE INDEX IF NOT EXISTS ${ctx.eventsTable.schema}.${indexName} ON ${ctx.eventsTable.table} ("timestamp", "status", "sync_id")`
+      );
     }
   }
 ];
 function runSystemMigrations(opts) {
   const ctx = {
-    eventsTableName: opts.eventsTableName,
-    updateLogTableName: opts.updateLogTableName,
+    ...opts.dbConfig,
     execute: opts.execute
   };
   for (const migration of opts.migrations) {
@@ -773,15 +845,15 @@ function applyWorkerDbSchema(db) {
   runSystemMigrations({
     migrations: baseSystemMigrations,
     version: kvStore.createNumberStoredValue("internal-schema-version", -1),
-    eventsTableName: '"worker"."crdt_events"',
-    updateLogTableName: '"crdt_update_log"',
-    execute: (sql2) => db.execute(sql2, { loggerLevel: "system" }),
+    dbConfig: workerDbConfig,
+    execute: (sql4) => db.execute(sql4, { loggerLevel: "system" }),
     transaction: (callback) => db.executeTransaction(callback)
   });
+  return { kvStore };
 }
 function applyMemoryDbSchema(db) {
   db.execute(
-    `CREATE TABLE "persisted_crdt_events" (
+    `CREATE TABLE IF NOT EXISTS ${memoryDbConfig.eventsTable.fullIdentifier} (
   "sync_id" integer NOT NULL PRIMARY KEY,
   "schema_version" integer NOT NULL,
   "status" text NOT NULL,
@@ -792,6 +864,27 @@ function applyMemoryDbSchema(db) {
   "dataset" text NOT NULL,
   "item_id" text NOT NULL,
   "payload" text NOT NULL
+  )`,
+    { loggerLevel: "system" }
+  );
+  db.execute(
+    `CREATE INDEX IF NOT EXISTS ${memoryDbConfig.eventsTable.table}_status_sync_id_idx ON ${memoryDbConfig.eventsTable.table} ("status", "sync_id")`,
+    {
+      loggerLevel: "system"
+    }
+  );
+  db.execute(
+    `CREATE INDEX IF NOT EXISTS ${memoryDbConfig.eventsTable.table}_timestamp_status_sync_id_idx ON ${memoryDbConfig.eventsTable.table} ("timestamp", "status", "sync_id")`,
+    {
+      loggerLevel: "system"
+    }
+  );
+  db.execute(
+    `CREATE TABLE IF NOT EXISTS ${memoryDbConfig.updateLogTable.fullIdentifier} (
+  "dataset" text NOT NULL,
+  "item_id" text NOT NULL,
+  "payload" text NOT NULL,
+  PRIMARY KEY ("item_id", "dataset")
 )`,
     { loggerLevel: "system" }
   );
@@ -800,7 +893,7 @@ function applyMemoryDbSchema(db) {
 // src/sqlite-crdt/apply-crdt-event.ts
 var createSQLiteCrdtApplyFunction = ({
   db,
-  updateLogTableName
+  dbConfig
 }) => {
   const applyCrdtEvent = createCrdtApplyFunction({
     getCrdtUpdateLog(opts) {
@@ -811,7 +904,7 @@ var createSQLiteCrdtApplyFunction = ({
           dataset: opts.dataset
         },
         (db2, params) => {
-          return db2.selectFrom(updateLogTableName).select("payload").where("item_id", "=", params("item_id")).where("dataset", "=", params("dataset"));
+          return db2.selectFrom(dbConfig.updateLogTable.fullIdentifier).select("payload").where("item_id", "=", params("item_id")).where("dataset", "=", params("dataset"));
         },
         { loggerLevel: "system" }
       );
@@ -826,7 +919,7 @@ var createSQLiteCrdtApplyFunction = ({
           dataset: opts.dataset,
           payload: opts.payload
         },
-        (db2, params) => db2.insertInto(updateLogTableName).values({
+        (db2, params) => db2.insertInto(dbConfig.updateLogTable.fullIdentifier).values({
           item_id: params("item_id"),
           dataset: params("dataset"),
           payload: params("payload")
@@ -842,7 +935,7 @@ var createSQLiteCrdtApplyFunction = ({
           dataset: opts.dataset,
           payload: opts.payload
         },
-        (db2, params) => db2.updateTable(updateLogTableName).set({
+        (db2, params) => db2.updateTable(dbConfig.updateLogTable.fullIdentifier).set({
           payload: params("payload")
         }).where("item_id", "=", params("item_id")).where("dataset", "=", params("dataset")),
         { loggerLevel: "system" }
@@ -862,13 +955,13 @@ var createSQLiteCrdtApplyFunction = ({
     },
     updateItem(opts) {
       const keys = Array.from(Object.keys(opts.payload));
-      db.execute(
-        {
-          sql: `update ${quoteId(opts.dataset)} set ${keys.map((key) => `${quoteId(key)} = ?`).join(",")} where id = ?`,
-          parameters: [...keys.map((key) => opts.payload[key]), opts.itemId]
-        },
-        { loggerLevel: "system" }
-      );
+      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" }
+      });
     }
   });
   return applyCrdtEvent;
@@ -880,11 +973,7 @@ function createCrdtApplyFunction({
   updateItem,
   updateCrdtUpdateLog
 }) {
-  const applyItemCreated = ({ event, meta }) => {
-    if (meta) {
-      applyItemUpdated({ event, meta });
-      return;
-    }
+  const applyItemCreated = ({ event }) => {
     const eventPayload = JSON.parse(event.payload);
     eventPayload.tombstone = false;
     insertItem({ dataset: event.dataset, payload: eventPayload });
@@ -906,6 +995,9 @@ function createCrdtApplyFunction({
     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) {
@@ -929,45 +1021,95 @@ function createCrdtApplyFunction({
     });
   };
   return (event) => {
+    if (isNoOpCrdtEventPayload(event.payload)) {
+      return;
+    }
     const meta = getCrdtUpdateLog({
       itemId: event.item_id,
       dataset: event.dataset
     });
-    switch (event.type) {
-      case "item-created": {
-        applyItemCreated({
-          event,
-          meta
-        });
-        break;
-      }
-      case "item-updated": {
-        if (!meta) {
-          throw new Error(`Item ${event.item_id} in dataset ${event.dataset} not found`);
-        }
-        applyItemUpdated({
-          event,
-          meta
-        });
-        break;
-      }
-      default:
-        event.type;
+    if (event.type !== "item-created" && event.type !== "item-updated") {
+      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`);
   };
 }
 
+// src/sqlite-crdt/crdt-storage.ts
+import { sql as sql3 } from "kysely";
+
+// src/sqlite-crdt/event-consistency.ts
+var MASK_128 = (1n << 128n) - 1n;
+var 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;
+}
+
 // src/sqlite-crdt/crdt-storage.ts
 function createCrdtStorage(storage) {
-  const transaction = storage.transaction ?? ((callback) => callback());
+  let localSyncId = storage.initialLocalSyncId;
+  const db = storage.db;
+  const crdtEventsTable = storage.dbConfig.eventsTable.fullIdentifier;
   const eventTarget = createTypedEventTarget();
+  const persistEvent = (tx, event) => {
+    tx.executePrepared(
+      "persist-crdt-event",
+      event,
+      (db2, params) => db2.insertInto(crdtEventsTable).values({
+        type: params("type"),
+        dataset: params("dataset"),
+        item_id: params("item_id"),
+        payload: params("payload"),
+        schema_version: params("schema_version"),
+        sync_id: params("sync_id"),
+        status: params("status"),
+        timestamp: params("timestamp"),
+        origin: params("origin"),
+        source_node_id: params("source_node_id")
+      }),
+      { loggerLevel: "system" }
+    );
+  };
   const enqueueEvents = (origin, sourceNodeId, events) => {
+    const beforeSyncId = localSyncId;
     if (events.length === 0) {
-      return;
+      return { beforeSyncId, afterSyncId: beforeSyncId, processed: Promise.resolve() };
     }
-    transaction(() => {
+    db.executeTransaction((tx) => {
       for (const event of events) {
-        storage.persistEvent({
+        persistEvent(tx, {
           schema_version: event.schema_version ?? storage.migrator.currentSchemaVersion,
           timestamp: event.timestamp ?? serializeHLC(storage.hlc.getNextHLC()),
           type: event.type,
@@ -976,21 +1118,26 @@ function createCrdtStorage(storage) {
           origin,
           source_node_id: sourceNodeId,
           payload: event.payload,
-          sync_id: ++storage.syncId.current,
+          sync_id: ++localSyncId,
           status: "pending"
         });
       }
     });
-    processEnqueuedEvents();
+    return { beforeSyncId, afterSyncId: localSyncId, processed: processEnqueuedEvents() };
   };
   const enqueueLocalEvents = (events, sourceNodeId) => {
-    enqueueEvents("local", sourceNodeId, events);
+    return enqueueEvents("local", sourceNodeId, events);
   };
   const enqueueOwnEvents = (events) => {
-    enqueueEvents("own", storage.nodeId, events);
+    return enqueueEvents("own", storage.nodeId, events);
   };
   const enqueueRemoteEvents = (events) => {
-    enqueueEvents("remote", "", events);
+    return enqueueEvents("remote", "", events);
+  };
+  const notifyEventApplied = (event) => {
+    if (event.status === "applied") {
+      storage.onEventApplied?.(event);
+    }
   };
   const applyOwnEvent = (event, { wrapInTransaction } = {}) => {
     const persistedEvent = {
@@ -1002,30 +1149,54 @@ function createCrdtStorage(storage) {
       origin: "own",
       source_node_id: storage.nodeId,
       payload: event.payload,
-      sync_id: ++storage.syncId.current,
+      sync_id: ++localSyncId,
       status: "pending"
     };
     if (wrapInTransaction) {
-      transaction(() => {
-        storage.persistEvent(persistedEvent);
-        processPersistedEvent(persistedEvent);
+      db.executeTransaction((tx) => {
+        persistEvent(tx, persistedEvent);
+        processPersistedEvent(tx, persistedEvent);
+        persistEventHlcAccumulator();
       });
     } else {
-      storage.persistEvent(persistedEvent);
-      processPersistedEvent(persistedEvent);
+      persistEvent(db, persistedEvent);
+      processPersistedEvent(db, persistedEvent);
+      persistEventHlcAccumulator();
     }
   };
-  const dispatchEventsApplied = () => {
+  const dispatchEventsApplied = (syncId = localSyncId) => {
     eventTarget.dispatchEvent("events-applied", {
-      syncId: storage.syncId.current
+      syncId,
+      eventHlcSum: eventHlcAccumulator?.current ?? null
     });
   };
+  const hasPendingEvents = () => {
+    const events = db.executePrepared(
+      "has-pending-events",
+      { status: "pending" },
+      (db2, params) => db2.selectFrom(crdtEventsTable).select("sync_id").where("status", "=", params("status")).limit(sql3.lit(1)),
+      { loggerLevel: "system" }
+    );
+    return events.length > 0;
+  };
   const getEventsBatch = (options) => {
     const limit = options.limit ?? 50;
-    const events = storage.getEventsBatch({
-      ...options,
-      limit: limit + 1
-    });
+    const queryParams = {
+      limit: limit + 1,
+      status: options.status ?? null,
+      afterSyncId: options.afterSyncId ?? null,
+      excludeOrigin: options.excludeOrigin ?? null,
+      excludeNodeId: options.excludeNodeId ?? null
+    };
+    const filterKeys = [
+      queryParams.excludeNodeId ? "nodeid" : "no-nodeid",
+      queryParams.excludeOrigin ? "origin" : "no-origin"
+    ];
+    const events = db.executePrepared(
+      `get-events-batch-${filterKeys.join("-")}`,
+      queryParams,
+      (db2, params) => db2.selectFrom(crdtEventsTable).where("sync_id", ">", params("afterSyncId")).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")
+    );
     const hasMore = events.length > limit;
     if (hasMore) {
       events.pop();
@@ -1036,18 +1207,94 @@ function createCrdtStorage(storage) {
       nextSyncId: events[events.length - 1]?.sync_id ?? options.afterSyncId ?? 0
     };
   };
-  const processPersistedEvent = (event) => {
+  const checkIsQuiescent = (pushedSyncId) => {
+    if (hasPendingEvents()) {
+      return false;
+    }
+    const unpushed = getEventsBatch({
+      status: "applied",
+      afterSyncId: pushedSyncId,
+      excludeOrigin: "remote",
+      limit: 1
+    });
+    return unpushed.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 },
+        (db2, params) => db2.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 hasAcceptedEventWithTimestamp = (tx, event) => {
+    const [existingEvent] = tx.executePrepared(
+      "get-accepted-crdt-event-by-timestamp",
+      {
+        timestamp: event.timestamp,
+        sync_id: event.sync_id
+      },
+      (db2, params) => db2.selectFrom(crdtEventsTable).select("sync_id").where("timestamp", "=", params("timestamp")).where("sync_id", "<", params("sync_id")).where("status", "=", sql3.lit("applied")).limit(sql3.lit(1)),
+      { loggerLevel: "system" }
+    );
+    return existingEvent !== void 0;
+  };
+  const processPersistedEvent = (tx, event) => {
     if (event.status !== "pending") {
       throw new Error(`Event ${event.sync_id} is not pending`);
     }
     try {
+      if (hasAcceptedEventWithTimestamp(tx, event)) {
+        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";
+        eventHlcAccumulator?.add(event.timestamp);
+        return event;
+      }
       const migratedEvent = storage.migrator.migrateEvent(event, storage.migrator.latestSchemaVersion);
       if (migratedEvent === null) {
-        event.status = "skipped";
         event.schema_version = storage.migrator.latestSchemaVersion;
+        event.payload = CRDT_EVENT_NO_OP_PAYLOAD;
+        applyCrdtEvent(event);
+        event.status = "applied";
+        eventHlcAccumulator?.add(event.timestamp);
         return event;
       }
       event.schema_version = migratedEvent.schema_version;
@@ -1055,40 +1302,72 @@ function createCrdtStorage(storage) {
       event.dataset = migratedEvent.dataset;
       event.item_id = migratedEvent.item_id;
       event.payload = migratedEvent.payload;
-      storage.handleCrdtEventApply(event);
+      applyCrdtEvent(event);
       event.status = "applied";
+      eventHlcAccumulator?.add(event.timestamp);
     } catch (error) {
       console.error("Error applying enqueued CRDT event", error);
       event.status = "failed";
     } finally {
-      storage.updateEvent(event.sync_id, {
-        status: event.status,
-        schema_version: event.schema_version,
-        type: event.type,
-        dataset: event.dataset,
-        item_id: event.item_id,
-        payload: event.payload
-      });
+      tx.executePrepared(
+        "update-crdt-event",
+        event,
+        (db2, params) => db2.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" }
+      );
     }
   };
   const processEnqueuedEvents = ensureSingletonExecution(async () => {
     let hasMore = true;
     while (hasMore) {
       await Promise.resolve();
-      const batch = getEventsBatch({ status: "pending", limit: 100 });
-      const events = batch.events;
-      hasMore = batch.hasMore;
+      const batchSize = 100;
+      const events = db.executePrepared(
+        "get-enqueued-pending-events",
+        {
+          status: "pending",
+          limit: batchSize + 1
+        },
+        (db2, params) => db2.selectFrom(crdtEventsTable).selectAll().where("status", "=", params("status")).limit(params("limit")).orderBy("sync_id", "asc")
+      );
+      hasMore = events.length > batchSize;
+      if (hasMore) {
+        events.pop();
+      }
       if (events.length === 0) {
         break;
       }
-      for (const event of events) {
-        transaction(() => {
-          processPersistedEvent(event);
-        });
+      let appliedSyncId = null;
+      const failedRemoteSyncIds = [];
+      db.executeTransaction((tx) => {
+        for (const event of events) {
+          processPersistedEvent(tx, event);
+          notifyEventApplied(event);
+          if (event.status === "applied") {
+            appliedSyncId = event.sync_id;
+          } else if (event.status === "failed" && event.origin === "remote") {
+            failedRemoteSyncIds.push(event.sync_id);
+          }
+        }
+        persistEventHlcAccumulator();
+      });
+      if (appliedSyncId !== null) {
+        dispatchEventsApplied(appliedSyncId);
+      }
+      for (const syncId of failedRemoteSyncIds) {
+        eventTarget.dispatchEvent("remote-event-apply-failed", { syncId });
       }
-      dispatchEventsApplied();
     }
   });
+  recomputeEventHlcAccumulatorIfNeeded();
+  void processEnqueuedEvents();
   return {
     getEventsBatch,
     enqueueLocalEvents,
@@ -1096,6 +1375,8 @@ function createCrdtStorage(storage) {
     enqueueRemoteEvents,
     applyOwnEvent,
     dispatchEventsApplied,
+    checkIsQuiescent,
+    getEventHlcAccumulator: () => eventHlcAccumulator?.current ?? null,
     addEventListener: eventTarget.addEventListener,
     removeEventListener: eventTarget.removeEventListener
   };
@@ -1104,12 +1385,23 @@ function createCrdtStorage(storage) {
 // src/sqlite-crdt/crdt-sync-producer.ts
 var createCrdtSyncProducer = ({ storage, broadcastEvents }) => {
   storage.addEventListener("events-applied", (event) => {
-    broadcastEvents({ newSyncId: event.payload.syncId });
+    broadcastEvents({
+      newSyncId: event.payload.syncId,
+      eventHlcSum: event.payload.eventHlcSum
+    });
   });
 };
 
 // src/sqlite-crdt/crdt-sync-remote-source.ts
 import retryAsPromised from "retry-as-promised";
+var SchemaVersionMismatchError = class extends Error {
+  constructor(remoteSchemaVersion, localSchemaVersion) {
+    super(`Schema version mismatch: remote ${remoteSchemaVersion} != local ${localSchemaVersion}`);
+    this.remoteSchemaVersion = remoteSchemaVersion;
+    this.localSchemaVersion = localSchemaVersion;
+    this.name = "SchemaVersionMismatchError";
+  }
+};
 var createCrdtSyncRemoteSource = ({
   bufferSize,
   storage,
@@ -1138,8 +1430,8 @@ var createCrdtSyncRemoteSource = ({
       setRemoteState({ type: "pending" });
       const factoryResult = await tryCatchAsync(async () => {
         return await remoteFactory?.({
-          onEventsAvailable: (newSyncId) => {
-            pullEvents({ remoteSyncId: newSyncId, includeSelf: false });
+          onEventsAvailable: ({ newSyncId, remoteEventHlcSum }) => {
+            pullEvents({ remoteSyncId: newSyncId, remoteEventHlcSum, includeSelf: false });
           }
         });
       });
@@ -1198,6 +1490,7 @@ var createCrdtSyncRemoteSource = ({
     }
     const remoteSyncId = request?.remoteSyncId;
     if (remoteSyncId !== void 0 && remoteSyncId <= pullSyncId.current) {
+      checkRemoteConsistency(remoteSyncId, request?.remoteEventHlcSum ?? null);
       return Promise.resolve();
     }
     if (pullPromise) {
@@ -1249,9 +1542,11 @@ var createCrdtSyncRemoteSource = ({
         storage.enqueueRemoteEvents(
           response.events.map((x) => {
             if (x.schema_version > migrator.currentSchemaVersion) {
-              throw new Error(
-                `Event schema version ${x.schema_version} is greater than current schema version ${migrator.currentSchemaVersion}`
-              );
+              eventTarget.dispatchEvent("remote-schema-version-mismatch", {
+                remoteSchemaVersion: x.schema_version,
+                localSchemaVersion: migrator.currentSchemaVersion
+              });
+              throw new SchemaVersionMismatchError(x.schema_version, migrator.currentSchemaVersion);
             }
             return x;
           })
@@ -1265,6 +1560,27 @@ var createCrdtSyncRemoteSource = ({
       }
     }
   };
+  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) {
+      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.`
+      );
+    }
+  };
   const startPushingEvents = ensureSingletonExecution(async () => {
     while (true) {
       const eventsBatch = storage.getEventsBatch({
@@ -1280,42 +1596,53 @@ var createCrdtSyncRemoteSource = ({
         break;
       }
       const source = remoteState.source;
-      const migratedEvents = migrator.migrateEvents(eventsBatch.events);
-      if (migratedEvents.length > 0) {
-        try {
-          await retryAsPromised(
-            () => source.pushEvents({
-              nodeId,
-              events: migratedEvents
-            }),
-            {
-              max: 3,
-              backoffBase: 100,
-              backoffExponent: 1.5,
-              backoffJitter: 150,
-              timeout: 1e4
-            }
-          );
-        } catch (error) {
-          console.error("Error pushing events. Going offline.", error);
-          goOffline("REMOTE_PUSH_ERROR");
-          return;
-        }
+      let response;
+      try {
+        response = await retryAsPromised(
+          () => 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
+            }))
+          }),
+          {
+            max: 3,
+            backoffBase: 100,
+            backoffExponent: 1.5,
+            backoffJitter: 150,
+            timeout: 1e4
+          }
+        );
+      } catch (error) {
+        console.error("Error pushing events. Going offline.", error);
+        goOffline("REMOTE_PUSH_ERROR");
+        return;
       }
       pushSyncId.current = eventsBatch.nextSyncId;
+      if (response.ok && 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 onEventsApplied = () => {
+  const eventsAppliedSubscription = storage.addEventListener("events-applied", () => {
     startPushingEvents();
-  };
-  storage.addEventListener("events-applied", onEventsApplied);
+  });
+  const remoteEventApplyFailedSubscription = storage.addEventListener("remote-event-apply-failed", () => {
+    eventTarget.dispatchEvent("de-sync-detected", { reason: "ERROR_APPLYING_REMOTE_EVENT" });
+  });
   const getState = () => remoteState.type;
   const dispose = async () => {
     await goOffline("DISCONNECTED");
-    storage.removeEventListener("events-applied", onEventsApplied);
+    eventsAppliedSubscription.unsubscribe();
+    remoteEventApplyFailedSubscription.unsubscribe();
   };
   return {
     goOnline,
@@ -1328,21 +1655,74 @@ var createCrdtSyncRemoteSource = ({
   };
 };
 
-// src/sqlite-crdt/events-batch-filters.ts
-function applyKyselyEventsBatchFilters(query, opts) {
-  if (opts.afterSyncId) {
-    query = query.where("sync_id", ">", opts.afterSyncId);
-  }
-  if (opts.status) {
-    query = query.where("status", "=", opts.status);
-  }
-  if (opts.excludeOrigin) {
-    query = query.where("origin", "!=", opts.excludeOrigin);
-  }
-  if (opts.excludeNodeId) {
-    query = query.where("source_node_id", "!=", opts.excludeNodeId);
-  }
-  return query.limit(opts.limit ?? 50).orderBy("sync_id", "asc");
+// src/worker-db/reset-state.ts
+import { createStore, del, get, set } from "idb-keyval";
+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)
+  };
+}
+var RESET_REQUEST_TTL_MS = 10 * 60 * 1e3;
+var resetRequestKey = (dbId) => `sqlite-sync-reset-request-${dbId}`;
+var resetAppliedKey = (dbId) => `sqlite-sync-reset-applied-${dbId}`;
+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 void 0;
+      }
+      if (now() - request.requestedAt > RESET_REQUEST_TTL_MS) {
+        await store.delete(requestKey);
+        return void 0;
+      }
+      const appliedEpoch = await store.get(appliedKey);
+      if (request.epoch === appliedEpoch) {
+        return void 0;
+      }
+      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);
+    }
+  };
+}
+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
+    });
+  };
 }
 
 // src/worker-db/worker-common.ts
@@ -1376,6 +1756,7 @@ function isWorkerNotificationMessage(message) {
 
 export {
   dummyKysely,
+  xxhash,
   HLCCounter,
   serializeHLC,
   deserializeHLC,
@@ -1383,11 +1764,16 @@ export {
   introspectDb,
   startPerformanceLogger,
   SQLiteDbWrapper,
+  CRDT_EVENT_NO_OP_PAYLOAD,
+  isNoOpCrdtEventPayload,
   createMigrations,
   createMigrator,
   createStoredValue,
   createKvStoreTableQuery,
   createSQLiteKvStore,
+  createSystemDbConfig,
+  workerDbConfig,
+  memoryDbConfig,
   baseSystemMigrations,
   runSystemMigrations,
   applyWorkerDbSchema,
@@ -1397,7 +1783,6 @@ export {
   createCrdtStorage,
   createCrdtSyncProducer,
   createCrdtSyncRemoteSource,
-  applyKyselyEventsBatchFilters,
   syncDbWorkerLockName,
   syncDbClientLockName,
   createBroadcastChannels,
@@ -1405,6 +1790,10 @@ export {
   isWorkerRequestMessage,
   isWorkerResponseMessage,
   isWorkerErrorResponseMessage,
-  isWorkerNotificationMessage
+  isWorkerNotificationMessage,
+  createIdbResetStore,
+  RESET_REQUEST_TTL_MS,
+  createResetStateStore,
+  createReloadRequestHandler
 };
-//# sourceMappingURL=chunk-627DSM2Q.js.map
+//# sourceMappingURL=chunk-O4WYEB4H.js.map