@sqlite-sync/core 0.8.2 → 0.9.1

package/dist/chunk-GMF45NFH.js

@@ -1,2298 +0,0 @@
-import {
-  TypedBroadcastChannel,
-  createTypedEventTarget,
-  ensureSingletonExecution,
-  generateId,
-  parseTableName,
-  quoteId,
-  tryCatchAsync
-} from "./chunk-NHT3ELMN.js";
-
-// src/dummy-kysely.ts
-import { DummyDriver, Kysely, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from "kysely";
-var dummyKysely = new Kysely({
-  dialect: {
-    createAdapter: () => new SqliteAdapter(),
-    createDriver: () => new DummyDriver(),
-    createQueryCompiler: () => new SqliteQueryCompiler(),
-    createIntrospector: (db) => new SqliteIntrospector(db)
-  }
-});
-
-// src/export-import.ts
-function createTableNameNormalizer(tablesConfig) {
-  const baseNamesByAlias = /* @__PURE__ */ new Map();
-  for (const { baseTableName, crdtTableName } of tablesConfig ?? []) {
-    baseNamesByAlias.set(baseTableName, baseTableName);
-    baseNamesByAlias.set(crdtTableName, baseTableName);
-  }
-  return (tableName) => baseNamesByAlias.get(tableName) ?? tableName;
-}
-function createImportData({ migrator, tablesConfig, applyEvents }) {
-  const normalizeTableName = createTableNameNormalizer(tablesConfig);
-  return (data, opts) => {
-    const validate = opts?.validate ?? true;
-    const currentVersion = migrator.currentSchemaVersion;
-    if (validate && data.schemaVersion > currentVersion) {
-      throw new Error(
-        `Cannot import data from schema version ${data.schemaVersion} into a database at older schema version ${currentVersion}. Exports migrate forward to newer schema versions, not backward.`
-      );
-    }
-    const sourceEvents = [];
-    for (const [tableName, rows] of Object.entries(data.tables)) {
-      for (const row of rows) {
-        sourceEvents.push({
-          schema_version: data.schemaVersion,
-          type: "item-created",
-          dataset: normalizeTableName(tableName),
-          item_id: row.id,
-          payload: JSON.stringify(row)
-        });
-      }
-    }
-    const events = migrator.migrateEvents(sourceEvents, currentVersion).map((event) => ({
-      type: event.type,
-      dataset: event.dataset,
-      item_id: event.item_id,
-      payload: event.payload
-    }));
-    const applied = applyEvents(events);
-    if (applied instanceof Promise) {
-      return applied.then(() => ({ imported: events.length }));
-    }
-    return { imported: events.length };
-  };
-}
-function createExportData({ reactiveDb, tablesConfig, schemaVersion }) {
-  const tableNames = tablesConfig.flatMap((config) => [config.crdtTableName, config.baseTableName]);
-  const resolveTables = (requested) => {
-    if (!requested) {
-      return tablesConfig;
-    }
-    const seenBaseTableNames = /* @__PURE__ */ new Set();
-    const resolved = [];
-    for (const name of requested) {
-      const config = tablesConfig.find(
-        (tableConfig) => tableConfig.crdtTableName === name || tableConfig.baseTableName === name
-      );
-      if (!config) {
-        throw new Error(`Unknown table "${name}". Known synced tables: ${tableNames.join(", ")}`);
-      }
-      if (!seenBaseTableNames.has(config.baseTableName)) {
-        seenBaseTableNames.add(config.baseTableName);
-        resolved.push(config);
-      }
-    }
-    return resolved;
-  };
-  return (opts) => {
-    const tables = {};
-    for (const { baseTableName, crdtTableName } of resolveTables(opts?.tables)) {
-      const { rows } = reactiveDb.db.execute(`select * from ${quoteId(crdtTableName)}`, {
-        loggerLevel: "system"
-      });
-      tables[baseTableName] = rows.map(({ tombstone: _tombstone, ...rest }) => rest);
-    }
-    return {
-      schemaVersion,
-      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      tables
-    };
-  };
-}
-
-// 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;
-var HLCCounter = class {
-  timestamp;
-  counter;
-  nodeId;
-  getTimestamp;
-  maxDrift;
-  constructor(nodeId, getTimestamp, maxDrift = DEFAULT_MAX_DRIFT_MS) {
-    this.timestamp = getTimestamp();
-    this.counter = 0;
-    this.nodeId = nodeId;
-    this.getTimestamp = getTimestamp;
-    this.maxDrift = maxDrift;
-  }
-  getCurrentHLC() {
-    return {
-      timestamp: this.timestamp,
-      counter: this.counter,
-      nodeId: this.nodeId
-    };
-  }
-  getNextHLC() {
-    const now = this.getTimestamp();
-    if (now > this.timestamp) {
-      this.timestamp = now;
-      this.counter = 0;
-      return this.getCurrentHLC();
-    }
-    this.counter++;
-    if (this.counter > MAX_COUNTER) {
-      throw new Error(`HLC counter overflow: exceeded max value ${MAX_COUNTER}`);
-    }
-    return this.getCurrentHLC();
-  }
-  mergeHLC(hlc) {
-    const now = this.getTimestamp();
-    if (hlc.timestamp - now > this.maxDrift) {
-      console.warn(
-        `HLC: ignoring far-future timestamp (remote=${hlc.timestamp}, local=${now}, drift=${hlc.timestamp - now}ms)`
-      );
-      return;
-    }
-    if (this.timestamp === hlc.timestamp) {
-      this.counter = Math.max(this.counter, hlc.counter) + 1;
-    } else if (this.timestamp > hlc.timestamp) {
-      this.counter++;
-    } else {
-      this.timestamp = hlc.timestamp;
-      this.counter = hlc.counter + 1;
-    }
-    if (this.counter > MAX_COUNTER) {
-      throw new Error(`HLC counter overflow: exceeded max value ${MAX_COUNTER}`);
-    }
-  }
-};
-function serializeHLC(hlc) {
-  return `${hlc.timestamp.toString().padStart(15, "0")}:${hlc.counter.toString(36).padStart(5, "0")}:${hlc.nodeId}`;
-}
-function deserializeHLC(serialized) {
-  const parts = serialized.split(":");
-  if (parts.length < 3) {
-    throw new Error(`Invalid HLC format: expected at least 3 colon-separated segments, got ${parts.length}`);
-  }
-  const timestamp = parseInt(parts[0], 10);
-  const counter = parseInt(parts[1], 36);
-  if (Number.isNaN(timestamp) || Number.isNaN(counter)) {
-    throw new Error(`Invalid HLC values: timestamp=${parts[0]}, counter=${parts[1]}`);
-  }
-  return {
-    timestamp,
-    counter,
-    nodeId: parts.slice(2).join(":")
-  };
-}
-function compareHLC(one, two) {
-  if (one.timestamp === two.timestamp) {
-    if (one.counter === two.counter) {
-      if (one.nodeId === two.nodeId) {
-        return 0;
-      }
-      return one.nodeId < two.nodeId ? -1 : 1;
-    }
-    return one.counter - two.counter;
-  }
-  return one.timestamp - two.timestamp;
-}
-
-// src/introspection.ts
-import { sql } from "kysely";
-function tablesQuery(qb) {
-  return qb.selectFrom("sqlite_master").where("type", "in", ["table", "view"]).where("name", "not like", "sqlite_%").select(["name", "sql", "type"]).orderBy("name");
-}
-function introspectDb(_db) {
-  const db = _db;
-  const tables = db.executeKysely((db2) => tablesQuery(db2), {
-    loggerLevel: "system"
-  }).rows;
-  const tablesMetadata = db.executeKysely(
-    (db2) => db2.with("table_list", (qb) => tablesQuery(qb)).selectFrom(["table_list as tl", sql`pragma_table_info(tl.name)`.as("p")]).select(["tl.name as table", "p.cid", "p.name", "p.type", "p.notnull", "p.dflt_value", "p.pk"]).orderBy("tl.name").orderBy("p.cid"),
-    { loggerLevel: "system" }
-  ).rows;
-  const columnsByTable = {};
-  for (const row of tablesMetadata) {
-    columnsByTable[row.table] ??= [];
-    columnsByTable[row.table].push(row);
-  }
-  return Object.fromEntries(
-    tables.map(({ name, sql: 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);
-        if (pkCols.length === 1 && pkCols[0].type.toLowerCase() === "integer") {
-          autoIncrementCol = pkCols[0].name;
-        }
-      }
-      return [
-        name,
-        {
-          name,
-          isView: type === "view",
-          columns: columns.map((col) => ({
-            name: col.name,
-            dataType: col.type,
-            isNullable: !col.notnull,
-            isAutoIncrementing: col.name === autoIncrementCol,
-            hasDefaultValue: col.dflt_value != null,
-            defaultValueSql: col.dflt_value == null ? null : String(col.dflt_value),
-            isPrimaryKey: col.pk > 0,
-            comment: void 0
-          }))
-        }
-      ];
-    })
-  );
-}
-
-// src/logger.ts
-var startPerformanceLogger = (logger) => {
-  let startTime = performance.now();
-  return {
-    restart: () => {
-      startTime = performance.now();
-    },
-    logEnd: (type, message, level = "info") => {
-      const elapsed = performance.now() - startTime;
-      logger(type, `${elapsed.toFixed(2)}ms - ${message}`, level);
-    }
-  };
-};
-
-// src/sqlite-db-wrapper.ts
-var SQLiteDbWrapper = class {
-  db = null;
-  sqlite3;
-  logger;
-  loggerPrefix;
-  loadedDbSchema = null;
-  dataPointers = [];
-  preparedStatements = [];
-  preparedStatementsMap = /* @__PURE__ */ new Map();
-  preparedRawStatementsMap = /* @__PURE__ */ new Map();
-  constructor(opts) {
-    this.db = opts.db();
-    this.sqlite3 = opts.sqlite3;
-    this.logger = opts.logger;
-    this.loggerPrefix = opts.loggerPrefix;
-  }
-  get ensureDb() {
-    if (!this.db) {
-      throw new Error("Database is already closed");
-    }
-    return this.db;
-  }
-  get dbSchema() {
-    if (!this.loadedDbSchema) {
-      this.loadedDbSchema = introspectDb(this);
-    }
-    return this.loadedDbSchema;
-  }
-  execute(opts, meta) {
-    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: sql4,
-      bind,
-      returnValue: "resultRows",
-      rowMode: "object"
-    });
-    perf?.logEnd(`${this.loggerPrefix ?? ""}:query`, sql4, meta?.loggerLevel);
-    return { rows };
-  }
-  executeTransaction(callback) {
-    const transaction = this.beginTransaction();
-    try {
-      const result = callback(this);
-      transaction.commit();
-      return result;
-    } catch (error) {
-      transaction.rollback();
-      throw error;
-    }
-  }
-  isInTransaction() {
-    return this.sqlite3.capi.sqlite3_get_autocommit(this.ensureDb) === 0;
-  }
-  beginTransaction() {
-    this.executePreparedRaw({
-      key: "$begin-transaction",
-      sql: "begin",
-      meta: {
-        loggerLevel: "system"
-      }
-    });
-    return {
-      commit: () => {
-        this.executePreparedRaw({
-          key: "$commit-transaction",
-          sql: "commit",
-          meta: {
-            loggerLevel: "system"
-          }
-        });
-      },
-      rollback: () => {
-        this.executePreparedRaw({
-          key: "$rollback-transaction",
-          sql: "rollback",
-          meta: {
-            loggerLevel: "system"
-          }
-        });
-      }
-    };
-  }
-  prepare(sql4, opts) {
-    const perf = this.logger ? startPerformanceLogger(this.logger) : void 0;
-    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;
-      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);
-      }
-    };
-    const finalize = () => {
-      isFinalized = true;
-      stmt.finalize();
-    };
-    const preparedStatement = {
-      execute,
-      finalize,
-      get isFinalized() {
-        return isFinalized;
-      }
-    };
-    this.preparedStatements.push(preparedStatement);
-    return preparedStatement;
-  }
-  prepareKysely(opts) {
-    return (factory) => {
-      const query = factory(dummyKysely, (key) => key).compile();
-      const statement = this.prepare(query.sql, opts);
-      return {
-        execute: (parameters) => {
-          const params = query.parameters.map((param) => parameters[param]);
-          const result = statement.execute(params);
-          return result;
-        }
-      };
-    };
-  }
-  executeKysely(factory, meta) {
-    const query = factory(dummyKysely).compile();
-    return this.execute(query, meta);
-  }
-  executePrepared(key, params, factory, meta) {
-    let statement = this.preparedStatementsMap.get(key);
-    if (!statement) {
-      statement = this.prepareKysely(meta)(factory);
-      this.preparedStatementsMap.set(key, statement);
-    }
-    return statement.execute(params);
-  }
-  executePreparedRaw({
-    key,
-    sql: sql4,
-    params,
-    meta
-  }) {
-    let statement = this.preparedRawStatementsMap.get(key);
-    if (!statement) {
-      statement = this.prepare(sql4, meta);
-      this.preparedRawStatementsMap.set(key, statement);
-    }
-    return statement.execute(params ?? []);
-  }
-  sql(templateOrString, ...parameters) {
-    if (typeof templateOrString === "string") {
-      return this.execute({
-        sql: templateOrString,
-        parameters
-      });
-    }
-    return this.execute({
-      sql: templateOrString.join("?"),
-      parameters
-    });
-  }
-  createScalarFunction({
-    name,
-    callback,
-    deterministic,
-    directOnly,
-    innocuous
-  }) {
-    return this.ensureDb.createFunction({
-      name,
-      xFunc: (_, ...args) => {
-        const result = callback(...args);
-        return result;
-      },
-      arity: callback.length,
-      deterministic,
-      directOnly,
-      innocuous
-    });
-  }
-  useSnapshot(snapshot) {
-    const perf = this.logger ? startPerformanceLogger(this.logger) : void 0;
-    const dataPointer = this.sqlite3.wasm.allocFromTypedArray(snapshot);
-    this.dataPointers.push(dataPointer);
-    const resultCode = this.sqlite3.capi.sqlite3_deserialize(
-      this.ensureDb,
-      "main",
-      dataPointer,
-      snapshot.byteLength,
-      snapshot.byteLength,
-      this.sqlite3.capi.SQLITE_DESERIALIZE_FREEONCLOSE | this.sqlite3.capi.SQLITE_DESERIALIZE_RESIZEABLE
-    );
-    this.ensureDb.checkRc(resultCode);
-    this.invalidateDbSchema();
-    perf?.logEnd("useSnapshot", "success", "system");
-  }
-  createSnapshot() {
-    return this.sqlite3.capi.sqlite3_js_db_export(this.ensureDb);
-  }
-  invalidateDbSchema() {
-    this.loadedDbSchema = null;
-  }
-  cleanup() {
-    this.preparedStatements.forEach((stmt) => {
-      stmt.finalize();
-    });
-    this.preparedStatements.splice(0);
-    this.preparedStatementsMap.clear();
-    this.preparedRawStatementsMap.clear();
-  }
-  close() {
-    this.cleanup();
-    this.db?.close();
-    this.db = null;
-  }
-};
-
-// 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) {
-  if (protectedColumns.includes(column)) {
-    throw new Error(`Cannot ${operation} protected column "${column}"`);
-  }
-}
-var migrationSteps = {
-  createTable: (table, build) => ({
-    sql: (db) => build(db.schema.createTable(table))
-  }),
-  dropTable: (table) => ({
-    sql: (db) => db.schema.dropTable(table),
-    eventTransformer: {
-      [table]: () => null
-    },
-    tableDrops: [table]
-  }),
-  createIndex: (indexName, build) => ({
-    sql: (db) => build(db.schema.createIndex(indexName))
-  }),
-  dropIndex: (indexName) => ({
-    sql: (db) => db.schema.dropIndex(indexName)
-  }),
-  renameTable: ({ oldTable, newTable }) => ({
-    sql: (db) => db.schema.alterTable(oldTable).renameTo(newTable),
-    eventTransformer: {
-      [oldTable]: (event) => {
-        event.dataset = newTable;
-        return event;
-      }
-    },
-    tableRenames: [{ oldTable, newTable }]
-  }),
-  renameColumn: ({
-    table,
-    oldColumn,
-    newColumn
-  }) => {
-    assertColumnNotProtected(oldColumn, "rename");
-    assertColumnNotProtected(newColumn, "rename to");
-    return {
-      sql: (db) => db.schema.alterTable(table).renameColumn(oldColumn, newColumn),
-      eventTransformer: {
-        [table]: (event) => {
-          if (event.type !== "item-updated" && event.type !== "item-created" || !(oldColumn in event.payload)) {
-            return event;
-          }
-          const oldVal = event.payload[oldColumn];
-          delete event.payload[oldColumn];
-          event.payload[newColumn] = oldVal;
-          return event;
-        }
-      }
-    };
-  },
-  addColumn: ({
-    table,
-    column,
-    type,
-    defaultValue,
-    build = (e) => e
-  }) => ({
-    sql: (db) => db.schema.alterTable(table).addColumn(column, type, (x) => build(x).defaultTo(defaultValue)),
-    eventTransformer: {
-      [table]: (event) => {
-        if (event.type !== "item-created") {
-          return event;
-        }
-        event.payload[column] = defaultValue;
-        return event;
-      }
-    }
-  }),
-  dropColumn: ({ table, column }) => {
-    assertColumnNotProtected(column, "drop");
-    return {
-      sql: (db) => db.schema.alterTable(table).dropColumn(column),
-      eventTransformer: {
-        [table]: (event) => {
-          if (!(column in event.payload)) {
-            return event;
-          }
-          delete event.payload[column];
-          if (event.type === "item-updated" && Object.keys(event.payload).length === 0) {
-            return null;
-          }
-          return event;
-        }
-      }
-    };
-  }
-};
-function buildMigrationSql(steps) {
-  return steps.flatMap((step) => Array.isArray(step.sql) ? step.sql : [step.sql]).map((sql4) => {
-    if (typeof sql4 === "string") {
-      return { sql: sql4, parameters: [] };
-    }
-    if (typeof sql4 === "function") {
-      const query = sql4(dummyKysely).compile();
-      return { sql: query.sql, parameters: query.parameters };
-    }
-    if ("compile" in sql4) {
-      const query = sql4.compile();
-      return { sql: query.sql, parameters: query.parameters };
-    }
-    return {
-      sql: sql4.sql,
-      parameters: sql4.parameters ?? []
-    };
-  });
-}
-function buildMigrationEventTransformer(steps) {
-  const transformers = [];
-  for (const step of steps) {
-    if (step.eventTransformer) {
-      transformers.push(...Object.entries(step.eventTransformer));
-    }
-  }
-  if (transformers.length === 0) {
-    return void 0;
-  }
-  return (event) => {
-    let transformedEvent = event;
-    for (const [table, transformer] of transformers) {
-      if (transformedEvent === null) {
-        return null;
-      }
-      if (transformedEvent.dataset !== table) {
-        continue;
-      }
-      transformedEvent = transformer(transformedEvent);
-      if (transformedEvent === null) {
-        return null;
-      }
-    }
-    return transformedEvent;
-  };
-}
-function createMigrations(buildMigrations) {
-  const migrations = Object.fromEntries(
-    Object.entries(buildMigrations(migrationSteps)).map(([version, steps]) => {
-      const versionNumber = Number(version);
-      if (Number.isNaN(versionNumber)) {
-        throw new Error(`Invalid migration version: ${version}`);
-      }
-      if (versionNumber < 0) {
-        throw new Error(`Migration version cannot be negative: ${version}`);
-      }
-      const tableRenames = steps.flatMap((s) => s.tableRenames ?? []);
-      const tableDrops = steps.flatMap((s) => s.tableDrops ?? []);
-      return [
-        version,
-        {
-          sql: buildMigrationSql(steps),
-          eventTransformer: buildMigrationEventTransformer(steps),
-          ...tableRenames.length > 0 && { tableRenames },
-          ...tableDrops.length > 0 && { tableDrops }
-        }
-      ];
-    })
-  );
-  return migrations;
-}
-function createMigrator({
-  migrations,
-  schemaVersion,
-  updateLogTableName
-}) {
-  const latestSchemaVersion = Math.max(...Object.keys(migrations).map(Number));
-  const sortedMigrations = Object.entries(migrations).map(([v, m]) => [Number(v), m]).sort((a, b) => a[0] - b[0]);
-  const applyMigration = (db, version, migration) => {
-    if (version <= schemaVersion.current) {
-      throw new Error(`Cannot apply migration ${version} to schema version ${schemaVersion.current}`);
-    }
-    db.startTransaction((tx) => {
-      for (const statement of migration.sql) {
-        tx.execute(statement.sql, statement.parameters);
-      }
-      if (updateLogTableName) {
-        if (migration.tableRenames) {
-          for (const { oldTable, newTable } of migration.tableRenames) {
-            tx.execute(`UPDATE ${updateLogTableName} SET "dataset" = ? WHERE "dataset" = ?`, [newTable, oldTable], {
-              loggerLevel: "system"
-            });
-          }
-        }
-        if (migration.tableDrops) {
-          for (const table of migration.tableDrops) {
-            tx.execute(`DELETE FROM ${updateLogTableName} WHERE "dataset" = ?`, [table], { loggerLevel: "system" });
-          }
-        }
-      }
-      schemaVersion.current = version;
-    });
-  };
-  const migrateEvent = (event, targetVersion) => {
-    targetVersion ??= latestSchemaVersion;
-    if (targetVersion > schemaVersion.current) {
-      throw new Error(
-        `Target schema version ${targetVersion} is greater than current schema version ${schemaVersion.current}`
-      );
-    }
-    if (isNoOpCrdtEventPayload(event.payload)) {
-      if (event.schema_version < targetVersion) {
-        event.schema_version = targetVersion;
-      }
-      return event;
-    }
-    if (event.schema_version >= targetVersion) {
-      return event;
-    }
-    const fromVersion = event.schema_version;
-    let crdtEvent = {
-      dataset: event.dataset,
-      item_id: event.item_id,
-      type: event.type,
-      payload: JSON.parse(event.payload)
-    };
-    for (let i = 0; i < sortedMigrations.length; i++) {
-      const [version, migration] = sortedMigrations[i];
-      if (version <= fromVersion) continue;
-      if (version > targetVersion) break;
-      const transformer = migration.eventTransformer;
-      if (transformer) {
-        crdtEvent = transformer(crdtEvent);
-        if (crdtEvent === null) return null;
-      }
-    }
-    if (crdtEvent === null) {
-      return null;
-    }
-    event.schema_version = targetVersion;
-    event.dataset = crdtEvent.dataset;
-    event.item_id = crdtEvent.item_id;
-    event.type = crdtEvent.type;
-    event.payload = JSON.stringify(crdtEvent.payload);
-    return event;
-  };
-  const migrateEvents = (events, targetVersion) => {
-    return events.map((event) => migrateEvent(event, targetVersion ?? latestSchemaVersion)).filter((event) => event !== null);
-  };
-  return {
-    latestSchemaVersion,
-    get currentSchemaVersion() {
-      return schemaVersion.current;
-    },
-    migrateDbToLatest: (db) => {
-      const currentSchemaVersion = schemaVersion.current;
-      if (currentSchemaVersion >= latestSchemaVersion) {
-        return;
-      }
-      for (let i = 0; i < sortedMigrations.length; i++) {
-        const [version, migration] = sortedMigrations[i];
-        if (version <= currentSchemaVersion) continue;
-        applyMigration(db, version, migration);
-      }
-    },
-    migrateEvent,
-    migrateEvents
-  };
-}
-
-// src/sqlite-crdt/stored-value.ts
-function createStoredValue({
-  initialValue,
-  saveToStorage
-}) {
-  let currentValue = initialValue;
-  return {
-    get current() {
-      return currentValue;
-    },
-    set current(newValue) {
-      saveToStorage?.(newValue);
-      currentValue = newValue;
-    }
-  };
-}
-
-// 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()).modifyEnd(sql2`without rowid`);
-}
-function createSQLiteKvStore({ db, metaTableName }) {
-  const metaDb = db;
-  const get2 = (key) => {
-    const [result] = metaDb.executePrepared(
-      "get-meta-value",
-      { key },
-      (db2, params) => db2.selectFrom(metaTableName).where("key", "=", params("key")).select("value").limit((eb) => eb.lit(1)),
-      { loggerLevel: "system" }
-    );
-    return result?.value ?? null;
-  };
-  const set2 = (key, value) => {
-    metaDb.executePrepared(
-      "set-meta-value",
-      { key, value },
-      (db2, params) => db2.insertInto(metaTableName).values({ key: params("key"), value: params("value") }).onConflict((oc) => oc.doUpdateSet({ value: params("value") })),
-      { loggerLevel: "system" }
-    );
-  };
-  const remove = (key) => {
-    metaDb.executePrepared(
-      "remove-meta-value",
-      { key },
-      (db2, params) => db2.deleteFrom(metaTableName).where("key", "=", params("key")),
-      { loggerLevel: "system" }
-    );
-  };
-  const getNumberOrDefault = (key, defaultValue) => {
-    const value = get2(key);
-    if (!value) return defaultValue;
-    const parsedValue = Number.parseInt(value, 10);
-    return Number.isNaN(parsedValue) ? defaultValue : parsedValue;
-  };
-  return {
-    get: get2,
-    set: set2,
-    remove,
-    createStringStoredValue: (key, defaultValue) => createStoredValue({
-      initialValue: get2(key) ?? defaultValue,
-      saveToStorage: (val) => set2(key, val)
-    }),
-    createNumberStoredValue: (key, defaultValue) => createStoredValue({
-      initialValue: getNumberOrDefault(key, defaultValue),
-      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.eventsTable.fullIdentifier} (
-        "sync_id" integer NOT NULL PRIMARY KEY,
-        "schema_version" integer NOT NULL,
-        "status" text NOT NULL,
-        "type" text NOT NULL,
-        "timestamp" text NOT NULL,
-        "origin" text NOT NULL,
-        "dataset" text NOT NULL,
-        "item_id" text NOT NULL,
-        "payload" text NOT NULL
-      )`);
-      ctx.execute(`CREATE TABLE IF NOT EXISTS ${ctx.updateLogTable.fullIdentifier} (
-        "dataset" text NOT NULL,
-        "item_id" text NOT NULL,
-        "payload" text NOT NULL,
-        PRIMARY KEY ("item_id", "dataset")
-      )`);
-    }
-  },
-  {
-    version: 1,
-    up: (ctx) => {
-      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 = {
-    ...opts.dbConfig,
-    execute: opts.execute
-  };
-  for (const migration of opts.migrations) {
-    if (migration.version > opts.version.current) {
-      opts.transaction(() => {
-        migration.up(ctx);
-        opts.version.current = migration.version;
-      });
-    }
-  }
-}
-function applyWorkerDbSchema(db) {
-  db.executeKysely((kysely) => createKvStoreTableQuery(kysely.schema, "worker.kv"), { loggerLevel: "system" });
-  const kvStore = createSQLiteKvStore({ db, metaTableName: "worker.kv" });
-  runSystemMigrations({
-    migrations: baseSystemMigrations,
-    version: kvStore.createNumberStoredValue("internal-schema-version", -1),
-    dbConfig: workerDbConfig,
-    execute: (sql4) => db.execute(sql4, { loggerLevel: "system" }),
-    transaction: (callback) => db.executeTransaction(callback)
-  });
-  return { kvStore };
-}
-function applyMemoryDbSchema(db) {
-  db.execute(
-    `CREATE TABLE IF NOT EXISTS ${memoryDbConfig.eventsTable.fullIdentifier} (
-  "sync_id" integer NOT NULL PRIMARY KEY,
-  "schema_version" integer NOT NULL,
-  "status" text NOT NULL,
-  "type" text NOT NULL,
-  "timestamp" text NOT NULL,
-  "origin" text NOT NULL,
-  "source_node_id" text NOT NULL DEFAULT '',
-  "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" }
-  );
-}
-
-// src/schema/validate-crdt-event.ts
-var CrdtEventValidationError = class extends Error {
-  constructor(errors) {
-    super(`Invalid CRDT events: ${errors.join("; ")}`);
-    this.errors = errors;
-    this.name = "CrdtEventValidationError";
-  }
-};
-var crdtEventTypes = ["item-created", "item-updated", "item-deleted"];
-function validateNewCrdtEvent(schema, input) {
-  const errors = [];
-  if (!isRecord(input)) {
-    return { success: false, errors: ["Event must be an object"] };
-  }
-  const type = input.type;
-  const dataset = input.dataset;
-  const itemId = input.item_id;
-  let payload = input.payload;
-  let payloadParseFailed = false;
-  if (typeof payload === "string") {
-    try {
-      payload = JSON.parse(payload);
-    } catch {
-      payloadParseFailed = true;
-      errors.push(`Event payload is not valid JSON`);
-    }
-  }
-  if (!isCrdtEventType(type)) {
-    errors.push(`Invalid event type "${String(type)}"`);
-  }
-  if (typeof dataset !== "string") {
-    errors.push(`Event dataset must be a string`);
-  }
-  if (typeof itemId !== "string") {
-    errors.push(`Event item_id must be a string`);
-  }
-  if (!payloadParseFailed && !isRecord(payload)) {
-    errors.push(`Event payload must be an object`);
-  }
-  const datasetMatch = typeof dataset === "string" ? findTableForDataset(schema, dataset) : null;
-  if (typeof dataset === "string" && !datasetMatch) {
-    errors.push(`Unknown dataset "${dataset}"`);
-  }
-  if (isCrdtEventType(type) && datasetMatch && isRecord(payload)) {
-    switch (type) {
-      case "item-created": {
-        const result = datasetMatch.table.validatePayload(payload, { event: "item-created" });
-        if (!result.success) {
-          errors.push(...result.errors.map((error) => `payload: ${error}`));
-        }
-        if (typeof itemId === "string" && "id" in payload && payload.id !== itemId) {
-          errors.push(`payload: Column "id" must match item_id "${itemId}"`);
-        }
-        break;
-      }
-      case "item-updated": {
-        const result = datasetMatch.table.validatePayload(payload, { event: "item-updated" });
-        if (!result.success) {
-          errors.push(...result.errors.map((error) => `payload: ${error}`));
-        }
-        break;
-      }
-      case "item-deleted":
-        if (Object.keys(payload).length > 0) {
-          errors.push(`payload: item-deleted events must have an empty payload`);
-        }
-        break;
-    }
-  }
-  if (errors.length > 0) {
-    return { success: false, errors };
-  }
-  return {
-    success: true,
-    event: {
-      type,
-      dataset: datasetMatch?.baseTableName ?? dataset,
-      item_id: itemId,
-      payload
-    }
-  };
-}
-function findTableForDataset(schema, dataset) {
-  const config = schema.tablesConfig.find(
-    (tableConfig) => tableConfig.baseTableName === dataset || tableConfig.crdtTableName === dataset
-  );
-  if (config) {
-    const table2 = schema.tables[config.crdtTableName];
-    return table2 ? { table: table2, baseTableName: config.baseTableName } : null;
-  }
-  const table = schema.tables[dataset];
-  return table ? { table, baseTableName: dataset } : null;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isCrdtEventType(value) {
-  return typeof value === "string" && crdtEventTypes.includes(value);
-}
-
-// src/schema/verify-sync-schema.ts
-import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
-var acceptedDataTypes = {
-  text: ["TEXT"],
-  integer: ["INTEGER", "INT"],
-  real: ["REAL", "DOUBLE", "FLOAT"],
-  boolean: ["BOOLEAN", "INTEGER", "INT"],
-  enum: ["TEXT"]
-};
-var sqliteModule = null;
-async function verifySyncSchema(schema) {
-  if (!sqliteModule) {
-    sqliteModule = await sqlite3InitModule();
-  }
-  const sqlite3 = sqliteModule;
-  const db = new SQLiteDbWrapper({
-    db: () => new sqlite3.oo1.DB({ filename: ":memory:" }),
-    logger: () => {
-    },
-    loggerPrefix: "schema-verify",
-    sqlite3
-  });
-  try {
-    const migrator = createMigrator({
-      migrations: schema.migrations,
-      schemaVersion: createStoredValue({ initialValue: -1 })
-    });
-    try {
-      migrator.migrateDbToLatest({
-        startTransaction: (callback) => {
-          db.executeTransaction(
-            (tx) => callback({ execute: (sql4, parameters, meta) => tx.execute({ sql: sql4, parameters }, meta) })
-          );
-        }
-      });
-    } catch (error) {
-      return [
-        {
-          table: "(migrations)",
-          message: `migration replay failed on an empty database: ${error instanceof Error ? error.message : String(error)}`
-        }
-      ];
-    }
-    const introspection = introspectDb(db);
-    const issues = [];
-    for (const { crdtTableName, baseTableName } of schema.tablesConfig) {
-      const declared = schema.tables[crdtTableName];
-      if (!declared) continue;
-      verifyTable(db, baseTableName, declared.columns, introspection[baseTableName], issues);
-    }
-    return issues;
-  } finally {
-    db.close();
-  }
-}
-function formatSchemaVerificationIssues(issues) {
-  const lines = issues.map(
-    (issue) => ` - table "${issue.table}"${issue.column ? ` column "${issue.column}"` : ""}: ${issue.message}`
-  );
-  return `sync schema verification failed (${issues.length} issue${issues.length === 1 ? "" : "s"}):
-${lines.join("\n")}`;
-}
-function verifyTable(db, table, declaredColumns, actual, issues) {
-  if (!actual) {
-    issues.push({
-      table,
-      message: "declared in the schema but missing after migrations \u2014 add a createTable step in a new version"
-    });
-    return;
-  }
-  if (actual.isView) {
-    issues.push({ table, message: "expected a base table, but migrations created a view with this name" });
-    return;
-  }
-  const actualColumns = new Map(actual.columns.map((column) => [column.name, column]));
-  for (const [name, meta] of Object.entries(declaredColumns)) {
-    const column = actualColumns.get(name);
-    if (!column) {
-      issues.push({
-        table,
-        column: name,
-        message: "declared in the schema but missing after migrations \u2014 add an addColumn step in a new version"
-      });
-      continue;
-    }
-    const accepted = acceptedDataTypes[meta.kind];
-    if (!accepted.includes(column.dataType.toUpperCase())) {
-      issues.push({
-        table,
-        column: name,
-        message: `type mismatch \u2014 schema declares ${meta.kind} (${accepted.join("/")}), migrated column is ${column.dataType.toUpperCase()}`
-      });
-    }
-    if (column.isNullable !== meta.nullable) {
-      issues.push({
-        table,
-        column: name,
-        message: meta.nullable ? "schema declares the column nullable, but the migrated column is NOT NULL" : "schema declares the column NOT NULL, but the migrated column is nullable"
-      });
-    }
-    if (name === "id" && !column.isPrimaryKey) {
-      issues.push({ table, column: name, message: "the id column must be the PRIMARY KEY" });
-    }
-    verifyDefault(db, table, name, meta, column.defaultValueSql, issues);
-  }
-  for (const column of actual.columns) {
-    if (!(column.name in declaredColumns)) {
-      issues.push({
-        table,
-        column: column.name,
-        message: "created by migrations but not declared in the schema \u2014 sync event payloads include every column, so declare it (or drop it in a new version)"
-      });
-    }
-  }
-}
-function verifyDefault(db, table, column, meta, defaultValueSql, issues) {
-  if (meta.hasDefault && meta.defaultValue !== null && defaultValueSql === null) {
-    issues.push({
-      table,
-      column,
-      message: `schema declares default ${formatExpected(meta)}, but the migrated column has no default`
-    });
-    return;
-  }
-  if (!meta.hasDefault && defaultValueSql !== null) {
-    issues.push({
-      table,
-      column,
-      message: `migrated column has default ${defaultValueSql}, but the schema declares none`
-    });
-    return;
-  }
-  if (!meta.hasDefault || defaultValueSql === null) {
-    return;
-  }
-  let actual;
-  try {
-    actual = db.execute({
-      sql: `SELECT (${defaultValueSql}) AS value`,
-      parameters: []
-    }).rows[0]?.value;
-  } catch {
-    actual = void 0;
-  }
-  if (actual !== expectedDefaultValue(meta)) {
-    issues.push({
-      table,
-      column,
-      message: `default mismatch \u2014 schema declares ${formatExpected(meta)}, migrated column default is ${defaultValueSql}`
-    });
-  }
-}
-function expectedDefaultValue(meta) {
-  if (meta.defaultValue === null) return null;
-  switch (meta.kind) {
-    case "boolean":
-      return meta.defaultValue ? 1 : 0;
-    case "integer":
-    case "real":
-      return Number(meta.defaultValue);
-    case "text":
-    case "enum":
-      return String(meta.defaultValue);
-  }
-}
-function formatExpected(meta) {
-  const expected = expectedDefaultValue(meta);
-  return typeof expected === "string" ? `'${expected}'` : String(expected);
-}
-
-// src/sqlite-crdt/apply-crdt-event.ts
-var createSQLiteCrdtApplyFunction = ({
-  db,
-  dbConfig
-}) => {
-  const applyCrdtEvent = createCrdtApplyFunction({
-    getCrdtUpdateLog(opts) {
-      const [metaRow] = db.executePrepared(
-        "get-item-crdt-meta",
-        {
-          item_id: opts.itemId,
-          dataset: opts.dataset
-        },
-        (db2, params) => {
-          return db2.selectFrom(dbConfig.updateLogTable.fullIdentifier).select("payload").where("item_id", "=", params("item_id")).where("dataset", "=", params("dataset"));
-        },
-        { loggerLevel: "system" }
-      );
-      const meta = metaRow ? JSON.parse(metaRow.payload) : null;
-      return meta;
-    },
-    insertCrdtUpdateLog(opts) {
-      db.executePrepared(
-        "insert-crdt-update-log",
-        {
-          item_id: opts.itemId,
-          dataset: opts.dataset,
-          payload: opts.payload
-        },
-        (db2, params) => db2.insertInto(dbConfig.updateLogTable.fullIdentifier).values({
-          item_id: params("item_id"),
-          dataset: params("dataset"),
-          payload: params("payload")
-        }),
-        { loggerLevel: "system" }
-      );
-    },
-    updateCrdtUpdateLog(opts) {
-      db.executePrepared(
-        "update-crdt-update-log",
-        {
-          item_id: opts.itemId,
-          dataset: opts.dataset,
-          payload: opts.payload
-        },
-        (db2, params) => db2.updateTable(dbConfig.updateLogTable.fullIdentifier).set({
-          payload: params("payload")
-        }).where("item_id", "=", params("item_id")).where("dataset", "=", params("dataset")),
-        { loggerLevel: "system" }
-      );
-    },
-    insertItem(opts) {
-      const keys = Object.keys(opts.payload).sort();
-      const insertPayload = {};
-      for (const key of keys) {
-        insertPayload[key] = key;
-      }
-      db.executePrepared(
-        `crdt-insert-item-${opts.dataset}-${keys.join("-")}`,
-        opts.payload,
-        (db2) => db2.insertInto(opts.dataset).values(insertPayload),
-        { loggerLevel: "system" }
-      );
-    },
-    updateItem(opts) {
-      const keys = Array.from(Object.keys(opts.payload));
-      keys.sort();
-      db.executePreparedRaw({
-        key: `update-item-${opts.dataset}-${keys.join("-")}`,
-        sql: `update ${quoteId(opts.dataset)} set ${keys.map((key) => `${quoteId(key)} = ?`).join(",")} where id = ?`,
-        params: [...keys.map((key) => opts.payload[key]), opts.itemId],
-        meta: { loggerLevel: "system" }
-      });
-    }
-  });
-  return applyCrdtEvent;
-};
-function createCrdtApplyFunction({
-  getCrdtUpdateLog,
-  insertItem,
-  insertCrdtUpdateLog,
-  updateItem,
-  updateCrdtUpdateLog
-}) {
-  const applyItemCreated = ({ event }) => {
-    const eventPayload = JSON.parse(event.payload);
-    eventPayload.tombstone = 0;
-    insertItem({ dataset: event.dataset, payload: eventPayload });
-    const newUpdateLog = {};
-    for (const key of Object.keys(eventPayload)) {
-      newUpdateLog[key] = event.timestamp;
-    }
-    insertCrdtUpdateLog({
-      dataset: event.dataset,
-      itemId: event.item_id,
-      payload: JSON.stringify(newUpdateLog)
-    });
-  };
-  const applyItemUpdated = ({ event, meta }) => {
-    if (!meta) {
-      throw new Error(`Item ${event.item_id} in dataset ${event.dataset} not found`);
-    }
-    const eventPayload = event.type === "item-deleted" ? { tombstone: 1 } : JSON.parse(event.payload);
-    const updatePayload = {};
-    let hasUpdates = false;
-    for (const [key, value] of Object.entries(eventPayload)) {
-      if (key === "id") {
-        continue;
-      }
-      const lastUpdateTimestamp = meta[key];
-      const currentUpdateTimestamp = event.timestamp;
-      if (!lastUpdateTimestamp || !currentUpdateTimestamp || currentUpdateTimestamp > lastUpdateTimestamp) {
-        updatePayload[key] = value;
-        meta[key] = currentUpdateTimestamp;
-        hasUpdates = true;
-      }
-    }
-    if (!hasUpdates) {
-      return;
-    }
-    updateItem({
-      dataset: event.dataset,
-      itemId: event.item_id,
-      payload: updatePayload
-    });
-    updateCrdtUpdateLog({
-      dataset: event.dataset,
-      itemId: event.item_id,
-      payload: JSON.stringify(meta)
-    });
-  };
-  return (event) => {
-    if (isNoOpCrdtEventPayload(event.payload)) {
-      return;
-    }
-    const meta = getCrdtUpdateLog({
-      itemId: event.item_id,
-      dataset: event.dataset
-    });
-    if (event.type !== "item-created" && event.type !== "item-updated" && event.type !== "item-deleted") {
-      throw new Error(`Unknown event type: ${event.type}`);
-    }
-    if (meta) {
-      applyItemUpdated({ event, meta });
-      return;
-    }
-    if (event.type === "item-created") {
-      applyItemCreated({ event });
-      return;
-    }
-    throw new Error(`Item ${event.item_id} in dataset ${event.dataset} not found`);
-  };
-}
-
-// 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) {
-  let localSyncId = storage.initialLocalSyncId;
-  const db = storage.db;
-  const crdtEventsTable = storage.dbConfig.eventsTable.fullIdentifier;
-  const getInitialSequentialSyncId = () => {
-    const [firstPendingEvent] = db.executePrepared(
-      "get-first-pending-event",
-      { status: "pending" },
-      (db2, params) => db2.selectFrom(crdtEventsTable).select("sync_id").where("status", "=", params("status")).orderBy("sync_id", "asc").limit(sql3.lit(1)),
-      { loggerLevel: "system" }
-    );
-    return firstPendingEvent ? firstPendingEvent.sync_id - 1 : localSyncId;
-  };
-  let sequentialSyncId = getInitialSequentialSyncId();
-  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 { beforeSyncId, afterSyncId: beforeSyncId, processed: Promise.resolve() };
-    }
-    db.executeTransaction((tx) => {
-      for (const event of events) {
-        persistEvent(tx, {
-          schema_version: event.schema_version ?? storage.migrator.currentSchemaVersion,
-          timestamp: event.timestamp ?? serializeHLC(storage.hlc.getNextHLC()),
-          type: event.type,
-          dataset: event.dataset,
-          item_id: event.item_id,
-          origin,
-          source_node_id: sourceNodeId,
-          payload: event.payload,
-          sync_id: ++localSyncId,
-          status: "pending"
-        });
-      }
-    });
-    return { beforeSyncId, afterSyncId: localSyncId, processed: processEnqueuedEvents() };
-  };
-  const enqueueLocalEvents = (events, sourceNodeId) => {
-    return enqueueEvents("local", sourceNodeId, events);
-  };
-  const enqueueOwnEvents = (events) => {
-    return enqueueEvents("own", storage.nodeId, events);
-  };
-  const enqueueRemoteEvents = (events) => {
-    return enqueueEvents("remote", "", events);
-  };
-  const notifyEventApplied = (event) => {
-    if (event.status === "applied") {
-      queueMicrotask(() => {
-        storage.onEventApplied?.(event);
-      });
-    }
-  };
-  const applyOwnEvents = (events) => {
-    const schema = storage.schema;
-    if (!schema) {
-      throw new Error("applyOwnEvents requires a sync schema; none was provided to createCrdtStorage");
-    }
-    const validatedEvents = [];
-    const errors = [];
-    for (const [index, event] of events.entries()) {
-      const result = validateNewCrdtEvent(schema, {
-        type: event.type,
-        dataset: event.dataset,
-        item_id: event.item_id,
-        payload: event.payload
-      });
-      if (!result.success) {
-        errors.push(...result.errors.map((error) => `[${index}] ${error}`));
-        continue;
-      }
-      validatedEvents.push(result.event);
-    }
-    if (errors.length > 0) {
-      throw new CrdtEventValidationError(errors);
-    }
-    db.executeTransaction((tx) => {
-      for (const event of validatedEvents) {
-        const persistedEvent = {
-          schema_version: storage.migrator.currentSchemaVersion,
-          timestamp: serializeHLC(storage.hlc.getNextHLC()),
-          type: event.type,
-          dataset: event.dataset,
-          item_id: event.item_id,
-          origin: "own-applied",
-          source_node_id: storage.nodeId,
-          payload: JSON.stringify(event.payload),
-          sync_id: ++localSyncId,
-          status: "pending"
-        };
-        persistEvent(tx, persistedEvent);
-        applyCrdtEvent(persistedEvent);
-      }
-    });
-    void processEnqueuedEvents();
-  };
-  const applyOwnEventFromTransaction = (tx, event) => {
-    const persistedEvent = {
-      schema_version: storage.migrator.currentSchemaVersion,
-      timestamp: serializeHLC(storage.hlc.getNextHLC()),
-      type: event.type,
-      dataset: event.dataset,
-      item_id: event.item_id,
-      origin: "own-applied",
-      source_node_id: storage.nodeId,
-      payload: event.payload,
-      sync_id: ++localSyncId,
-      status: "pending"
-    };
-    persistEvent(tx, persistedEvent);
-    applyCrdtEvent(persistedEvent);
-  };
-  const dispatchEventsApplied = (previousSequentialSyncId) => {
-    if (sequentialSyncId <= previousSequentialSyncId) {
-      return;
-    }
-    eventTarget.dispatchEvent("events-applied", {
-      syncId: sequentialSyncId,
-      eventHlcSum: sequentialSyncId === localSyncId ? eventHlcAccumulator?.current ?? null : 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 queryParams = {
-      limit: limit + 1,
-      status: options.status ?? null,
-      afterSyncId: options.afterSyncId ?? null,
-      excludeOrigin: options.excludeOrigin ?? null,
-      excludeNodeId: options.excludeNodeId ?? null,
-      maxSyncId: options.status === "applied" ? sequentialSyncId : localSyncId
-    };
-    const filterKeys = [
-      queryParams.excludeNodeId ? "nodeid" : "no-nodeid",
-      queryParams.excludeOrigin ? "origin" : "no-origin"
-    ];
-    const events = db.executePrepared(
-      `get-events-batch-${filterKeys.join("-")}`,
-      queryParams,
-      (db2, params) => db2.selectFrom(crdtEventsTable).where("sync_id", ">", params("afterSyncId")).where("sync_id", "<=", params("maxSyncId")).where("status", "=", params("status")).$if(!!queryParams.excludeNodeId, (qb) => qb.where("source_node_id", "!=", params("excludeNodeId"))).$if(!!queryParams.excludeOrigin, (qb) => qb.where("origin", "!=", params("excludeOrigin"))).selectAll().limit(params("limit")).orderBy("sync_id", "asc"),
-      { loggerLevel: "system" }
-    );
-    const hasMore = events.length > limit;
-    if (hasMore) {
-      events.pop();
-    }
-    const lastReturnedSyncId = events[events.length - 1]?.sync_id ?? options.afterSyncId ?? 0;
-    let nextSyncId = lastReturnedSyncId;
-    if (!hasMore && options.status === "applied") {
-      nextSyncId = Math.max(lastReturnedSyncId, queryParams.maxSyncId);
-    }
-    return {
-      events,
-      hasMore,
-      nextSyncId
-    };
-  };
-  const checkIsQuiescent = (pushedSyncId) => {
-    if (hasPendingEvents()) {
-      return false;
-    }
-    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 (event.origin === "own-applied") {
-        event.status = "applied";
-        return event;
-      }
-      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";
-        return event;
-      }
-      const migratedEvent = storage.migrator.migrateEvent(event, storage.migrator.latestSchemaVersion);
-      if (migratedEvent === null) {
-        event.schema_version = storage.migrator.latestSchemaVersion;
-        event.payload = CRDT_EVENT_NO_OP_PAYLOAD;
-        applyCrdtEvent(event);
-        event.status = "applied";
-        return event;
-      }
-      event.schema_version = migratedEvent.schema_version;
-      event.type = migratedEvent.type;
-      event.dataset = migratedEvent.dataset;
-      event.item_id = migratedEvent.item_id;
-      event.payload = migratedEvent.payload;
-      applyCrdtEvent(event);
-      event.status = "applied";
-    } catch (error) {
-      console.error("Error applying enqueued CRDT event", error);
-      event.status = "failed";
-    } finally {
-      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 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"),
-        { loggerLevel: "system" }
-      );
-      hasMore = events.length > batchSize;
-      if (hasMore) {
-        events.pop();
-      }
-      const previousSequentialSyncId = sequentialSyncId;
-      if (events.length === 0) {
-        sequentialSyncId = localSyncId;
-        dispatchEventsApplied(previousSequentialSyncId);
-        break;
-      }
-      const failedRemoteSyncIds = [];
-      db.executeTransaction((tx) => {
-        for (const event of events) {
-          processPersistedEvent(tx, event);
-          if (event.status === "applied") {
-            eventHlcAccumulator?.add(event.timestamp);
-          }
-          notifyEventApplied(event);
-          if (event.status === "failed" && event.origin === "remote") {
-            failedRemoteSyncIds.push(event.sync_id);
-          }
-        }
-        persistEventHlcAccumulator();
-      });
-      sequentialSyncId = hasMore ? events[events.length - 1]?.sync_id ?? sequentialSyncId : localSyncId;
-      dispatchEventsApplied(previousSequentialSyncId);
-      for (const syncId of failedRemoteSyncIds) {
-        eventTarget.dispatchEvent("remote-event-apply-failed", { syncId });
-      }
-    }
-  });
-  recomputeEventHlcAccumulatorIfNeeded();
-  void processEnqueuedEvents();
-  return {
-    getEventsBatch,
-    enqueueLocalEvents,
-    enqueueOwnEvents,
-    enqueueRemoteEvents,
-    applyOwnEvents,
-    checkIsQuiescent,
-    getEventHlcAccumulator: () => eventHlcAccumulator?.current ?? null,
-    addEventListener: eventTarget.addEventListener,
-    removeEventListener: eventTarget.removeEventListener,
-    internal: {
-      applyOwnEventFromTransaction,
-      processEnqueuedEvents
-    }
-  };
-}
-
-// src/sqlite-crdt/crdt-sync-producer.ts
-var createCrdtSyncProducer = ({ storage, broadcastEvents }) => {
-  storage.addEventListener("events-applied", (event) => {
-    broadcastEvents({
-      newSyncId: event.payload.syncId,
-      eventHlcSum: event.payload.eventHlcSum
-    });
-  });
-};
-
-// src/sqlite-crdt/retry-remote-operation.ts
-var REMOTE_RETRY_OPTIONS = {
-  maxAttempts: 3,
-  backoffBaseMs: 100,
-  backoffExponent: 1.5,
-  backoffJitterMs: 150,
-  timeoutMs: 1e4
-};
-var RetryTimeoutError = class extends Error {
-  constructor(message, previous) {
-    super(message);
-    this.previous = previous;
-    this.name = "TimeoutError";
-  }
-};
-var applyJitter = (delayMs, maxJitterMs) => {
-  const jitter = Math.random() * maxJitterMs * (Math.random() > 0.5 ? 1 : -1);
-  return Math.max(0, delayMs + jitter);
-};
-var delay = (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs));
-var withTimeout = async (operation, timeoutMs, previousError) => {
-  let timeoutId;
-  try {
-    return await Promise.race([
-      operation(),
-      new Promise((_, reject) => {
-        timeoutId = setTimeout(
-          () => reject(new RetryTimeoutError("Remote operation timed out", previousError)),
-          timeoutMs
-        );
-      })
-    ]);
-  } finally {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-  }
-};
-var retryRemoteOperation = async (operation, options) => {
-  let lastError;
-  for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
-    try {
-      return await withTimeout(operation, options.timeoutMs, lastError);
-    } catch (error) {
-      lastError = error;
-      if (attempt >= options.maxAttempts) {
-        throw error;
-      }
-      const backoffDelay = applyJitter(
-        options.backoffBaseMs * options.backoffExponent ** (attempt - 1),
-        options.backoffJitterMs
-      );
-      if (backoffDelay > 0) {
-        await delay(backoffDelay);
-      }
-    }
-  }
-  throw lastError;
-};
-
-// src/sqlite-crdt/crdt-sync-remote-source.ts
-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,
-  migrator,
-  pullSyncId,
-  pushSyncId,
-  nodeId,
-  remoteFactory
-}) => {
-  const eventTarget = createTypedEventTarget();
-  let remoteState = {
-    type: "offline",
-    reason: "NOT_INITIALIZED",
-    deSynced: false,
-    schemaVersionMismatched: false
-  };
-  const patchRemoteState = (state) => {
-    remoteState = { ...remoteState, ...state };
-    eventTarget.dispatchEvent("state-changed", remoteState.type);
-  };
-  const initRemote = ensureSingletonExecution(
-    async () => {
-      if (remoteState.type !== "offline") {
-        throw new Error("Remote source is not offline");
-      }
-      if (!remoteFactory) {
-        console.warn("Remote source factory not provided. Going offline.");
-        patchRemoteState({ type: "offline", reason: "NOT_INITIALIZED" });
-        return;
-      }
-      patchRemoteState({ type: "pending" });
-      const factoryResult = await tryCatchAsync(async () => {
-        return await remoteFactory?.({
-          onEventsAvailable: ({ newSyncId, remoteEventHlcSum }) => {
-            pullEvents({ remoteSyncId: newSyncId, remoteEventHlcSum, includeSelf: false });
-          }
-        });
-      });
-      if (!factoryResult.success) {
-        patchRemoteState({ type: "offline", reason: "INITIALIZATION_FAILED" });
-        console.warn("Failed to create remote source", factoryResult.error);
-        return;
-      }
-      patchRemoteState({
-        type: "online",
-        source: factoryResult.data,
-        deSynced: false,
-        schemaVersionMismatched: false
-      });
-    },
-    { queueReExecution: false }
-  );
-  const syncWithRemote = ensureSingletonExecution(
-    async () => {
-      if (remoteState.type !== "online") {
-        return;
-      }
-      await pullEvents();
-      await startPushingEvents();
-    },
-    { queueReExecution: false }
-  );
-  const goOffline = ensureSingletonExecution(
-    async (reason) => {
-      if (remoteState.type !== "online") {
-        return;
-      }
-      const source = remoteState.source;
-      patchRemoteState({ type: "pending" });
-      const disconnectResult = await tryCatchAsync(async () => {
-        return await source.disconnect?.();
-      });
-      if (!disconnectResult.success) {
-        console.warn("Error while disconnecting from remote source", disconnectResult.error);
-      }
-      patchRemoteState({ type: "offline", reason });
-    },
-    { queueReExecution: false }
-  );
-  const goOnline = async () => {
-    if (remoteState.type !== "online") {
-      await initRemote();
-    }
-    if (remoteState.type === "online") {
-      await syncWithRemote();
-    }
-  };
-  let requestedPullSyncId = null;
-  let pullPromise = null;
-  const pullEvents = (request) => {
-    if (remoteState.type !== "online") {
-      return Promise.resolve();
-    }
-    const remoteSyncId = request?.remoteSyncId;
-    if (remoteSyncId !== void 0 && remoteSyncId <= pullSyncId.current) {
-      checkRemoteConsistency(remoteSyncId, request?.remoteEventHlcSum ?? null);
-      return Promise.resolve();
-    }
-    if (pullPromise) {
-      if (remoteSyncId !== void 0 && (!requestedPullSyncId || requestedPullSyncId < remoteSyncId)) {
-        requestedPullSyncId = remoteSyncId;
-      }
-      return pullPromise;
-    }
-    pullPromise = pullAllEvents({
-      afterSyncId: pullSyncId.current,
-      excludeNodeId: request?.includeSelf ? void 0 : nodeId
-    }).catch((error) => {
-      console.error("Error pulling events. Going offline.", error);
-      goOffline("REMOTE_PULL_ERROR");
-    }).finally(() => {
-      pullPromise = null;
-      const nextTarget = requestedPullSyncId;
-      requestedPullSyncId = null;
-      if (nextTarget && nextTarget > pullSyncId.current) {
-        pullEvents({ remoteSyncId: nextTarget });
-      }
-    });
-    return pullPromise;
-  };
-  const pullAllEvents = async (opts) => {
-    let hasMore = true;
-    let afterSyncId = opts.afterSyncId;
-    while (hasMore) {
-      if (remoteState.type !== "online") {
-        return;
-      }
-      const source = remoteState.source;
-      const response = await retryRemoteOperation(
-        () => source.pullEvents({
-          ...opts,
-          afterSyncId
-        }),
-        REMOTE_RETRY_OPTIONS
-      );
-      hasMore = response.hasMore;
-      afterSyncId = response.nextSyncId;
-      if (response.events) {
-        storage.enqueueRemoteEvents(
-          response.events.map((x) => {
-            if (x.schema_version > migrator.currentSchemaVersion) {
-              eventTarget.dispatchEvent("remote-schema-version-mismatch", {
-                remoteSchemaVersion: x.schema_version,
-                localSchemaVersion: migrator.currentSchemaVersion
-              });
-              if (remoteState.type === "online" && !remoteState.schemaVersionMismatched) {
-                patchRemoteState({ schemaVersionMismatched: true });
-              }
-              throw new SchemaVersionMismatchError(x.schema_version, migrator.currentSchemaVersion);
-            }
-            return x;
-          })
-        );
-      }
-      if (response.nextSyncId <= pullSyncId.current) {
-        break;
-      }
-      if (response.nextSyncId > pullSyncId.current) {
-        pullSyncId.current = response.nextSyncId;
-      }
-    }
-  };
-  const checkRemoteConsistency = (remoteSyncId, remoteEventHlcSum) => {
-    if (remoteEventHlcSum === null) {
-      return;
-    }
-    if (remoteSyncId !== pullSyncId.current) {
-      return;
-    }
-    if (!storage.checkIsQuiescent(pushSyncId.current)) {
-      return;
-    }
-    const localEventHlcSum = storage.getEventHlcAccumulator();
-    if (localEventHlcSum === null) {
-      return;
-    }
-    if (localEventHlcSum === remoteEventHlcSum) {
-      return;
-    }
-    eventTarget.dispatchEvent("de-sync-detected", { reason: "CHECKSUM_MISMATCH" });
-    console.warn(
-      `[sqlite-sync] De-sync detected at syncId ${remoteSyncId}: local HLC checksum ${localEventHlcSum} != remote ${remoteEventHlcSum}. Local and remote have diverged despite being caught up.`
-    );
-    if (remoteState.type === "online" && !remoteState.deSynced) {
-      patchRemoteState({ deSynced: true });
-    }
-  };
-  const startPushingEvents = ensureSingletonExecution(async () => {
-    while (true) {
-      const eventsBatch = storage.getEventsBatch({
-        status: "applied",
-        afterSyncId: pushSyncId.current,
-        excludeOrigin: "remote",
-        limit: bufferSize
-      });
-      if (eventsBatch.events.length === 0) {
-        break;
-      }
-      if (remoteState.type !== "online") {
-        break;
-      }
-      const source = remoteState.source;
-      let response;
-      try {
-        response = await retryRemoteOperation(
-          () => source.pushEvents({
-            nodeId,
-            events: eventsBatch.events.map((event) => ({
-              schema_version: event.schema_version,
-              timestamp: event.timestamp,
-              type: event.type,
-              dataset: event.dataset,
-              item_id: event.item_id,
-              payload: event.payload
-            }))
-          }),
-          REMOTE_RETRY_OPTIONS
-        );
-      } catch (error) {
-        console.error("Error pushing events. Going offline.", error);
-        goOffline("REMOTE_PUSH_ERROR");
-        return;
-      }
-      if (!response.ok) {
-        console.error("Remote rejected pushed events. Going offline.");
-        goOffline("REMOTE_PUSH_ERROR");
-        return;
-      }
-      pushSyncId.current = eventsBatch.nextSyncId;
-      if (response.beforeSyncId !== void 0 && response.afterSyncId !== void 0 && response.beforeSyncId <= pullSyncId.current && response.afterSyncId > pullSyncId.current) {
-        pullSyncId.current = response.afterSyncId;
-      }
-      if (!eventsBatch.hasMore) {
-        break;
-      }
-    }
-  });
-  const eventsAppliedSubscription = storage.addEventListener("events-applied", () => {
-    startPushingEvents();
-  });
-  const remoteEventApplyFailedSubscription = storage.addEventListener("remote-event-apply-failed", () => {
-    eventTarget.dispatchEvent("de-sync-detected", { reason: "ERROR_APPLYING_REMOTE_EVENT" });
-    if (remoteState.type === "online" && !remoteState.deSynced) {
-      patchRemoteState({ deSynced: true });
-    }
-  });
-  const getState = () => ({
-    remoteState: remoteState.type,
-    deSynced: remoteState.deSynced,
-    schemaVersionMismatched: remoteState.schemaVersionMismatched
-  });
-  const dispose = async () => {
-    await goOffline("DISCONNECTED");
-    eventsAppliedSubscription.unsubscribe();
-    remoteEventApplyFailedSubscription.unsubscribe();
-  };
-  return {
-    goOnline,
-    goOffline,
-    syncWithRemote,
-    getState,
-    dispose,
-    addEventListener: eventTarget.addEventListener,
-    removeEventListener: eventTarget.removeEventListener
-  };
-};
-
-// 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
-var syncDbWorkerLockName = "sync-db-worker-lock";
-var syncDbClientLockName = "sync-db-client-lock";
-var broadcastChannelNames = {
-  requests: "sync-db-worker-requests",
-  responses: "sync-db-worker-responses"
-};
-var createBroadcastChannels = (prefix) => {
-  return {
-    requests: new TypedBroadcastChannel(`${prefix}-${broadcastChannelNames.requests}`),
-    responses: new TypedBroadcastChannel(`${prefix}-${broadcastChannelNames.responses}`)
-  };
-};
-function isWorkerInitMessage(message) {
-  return typeof message === "object" && message !== null && "type" in message && message.type === "init";
-}
-function isWorkerRequestMessage(message) {
-  return typeof message === "object" && message !== null && "type" in message && message.type === "request";
-}
-function isWorkerResponseMessage(message) {
-  return typeof message === "object" && message !== null && "type" in message && "requestId" in message && "data" in message;
-}
-function isWorkerErrorResponseMessage(message) {
-  return typeof message === "object" && message !== null && "type" in message && message.type === "error-response";
-}
-function isWorkerNotificationMessage(message) {
-  return typeof message === "object" && message !== null && "notificationType" in message && !!message.notificationType;
-}
-
-export {
-  dummyKysely,
-  createImportData,
-  createExportData,
-  xxhash,
-  HLCCounter,
-  serializeHLC,
-  deserializeHLC,
-  compareHLC,
-  introspectDb,
-  startPerformanceLogger,
-  SQLiteDbWrapper,
-  CRDT_EVENT_NO_OP_PAYLOAD,
-  isNoOpCrdtEventPayload,
-  createMigrations,
-  createMigrator,
-  createStoredValue,
-  createKvStoreTableQuery,
-  createSQLiteKvStore,
-  createSystemDbConfig,
-  workerDbConfig,
-  memoryDbConfig,
-  baseSystemMigrations,
-  runSystemMigrations,
-  applyWorkerDbSchema,
-  applyMemoryDbSchema,
-  CrdtEventValidationError,
-  validateNewCrdtEvent,
-  verifySyncSchema,
-  formatSchemaVerificationIssues,
-  createSQLiteCrdtApplyFunction,
-  createCrdtApplyFunction,
-  createCrdtStorage,
-  createCrdtSyncProducer,
-  createCrdtSyncRemoteSource,
-  syncDbWorkerLockName,
-  syncDbClientLockName,
-  createBroadcastChannels,
-  isWorkerInitMessage,
-  isWorkerRequestMessage,
-  isWorkerResponseMessage,
-  isWorkerErrorResponseMessage,
-  isWorkerNotificationMessage,
-  createIdbResetStore,
-  RESET_REQUEST_TTL_MS,
-  createResetStateStore,
-  createReloadRequestHandler
-};
-//# sourceMappingURL=chunk-GMF45NFH.js.map