@sqlite-sync/core 0.0.1 → 0.0.2

package/dist/chunk-627DSM2Q.js

@@ -0,0 +1,1410 @@
+import {
+  TypedBroadcastChannel,
+  createTypedEventTarget,
+  ensureSingletonExecution,
+  quoteId,
+  tryCatchAsync
+} from "./chunk-UGF5IU53.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/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: sql2, type }) => {
+      let autoIncrementCol = sql2?.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,
+            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 sql2 = 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,
+      bind,
+      returnValue: "resultRows",
+      rowMode: "object"
+    });
+    perf?.logEnd(`${this.loggerPrefix ?? ""}:query`, sql2, 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(sql2, opts) {
+    const perf = this.logger ? startPerformanceLogger(this.logger) : void 0;
+    const stmt = this.ensureDb.prepare(sql2);
+    perf?.logEnd(`${this.loggerPrefix ?? ""}:prepare`, sql2, 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({}));
+      }
+      stmt.reset(true);
+      perf2?.logEnd(`${this.loggerPrefix ?? ""}:prepare-execute`, sql2, opts?.loggerLevel);
+      return results;
+    };
+    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: sql2,
+    params,
+    meta
+  }) {
+    let statement = this.preparedRawStatementsMap.get(key);
+    if (!statement) {
+      statement = this.prepare(sql2, 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/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((sql2) => {
+    if (typeof sql2 === "string") {
+      return { sql: sql2, parameters: [] };
+    }
+    if (typeof sql2 === "function") {
+      const query = sql2(dummyKysely).compile();
+      return { sql: query.sql, parameters: query.parameters };
+    }
+    if ("compile" in sql2) {
+      const query = sql2.compile();
+      return { sql: query.sql, parameters: query.parameters };
+    }
+    return {
+      sql: sql2.sql,
+      parameters: sql2.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]);
+          }
+        }
+        if (migration.tableDrops) {
+          for (const table of migration.tableDrops) {
+            tx.execute(`DELETE FROM ${updateLogTableName} WHERE "dataset" = ?`, [table]);
+          }
+        }
+      }
+      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 (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
+function createKvStoreTableQuery(schema, tableName) {
+  return schema.createTable(tableName).ifNotExists().addColumn("key", "text", (col) => col.notNull().primaryKey()).addColumn("value", "text", (col) => col.notNull());
+}
+function createSQLiteKvStore({
+  db,
+  metaTableName
+}) {
+  const metaDb = db;
+  const get = (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 set = (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 = get(key);
+    if (!value) return defaultValue;
+    const parsedValue = Number.parseInt(value, 10);
+    return Number.isNaN(parsedValue) ? defaultValue : parsedValue;
+  };
+  return {
+    get,
+    set,
+    remove,
+    createStringStoredValue: (key, defaultValue) => createStoredValue({
+      initialValue: get(key) ?? defaultValue,
+      saveToStorage: (val) => set(key, val)
+    }),
+    createNumberStoredValue: (key, defaultValue) => createStoredValue({
+      initialValue: getNumberOrDefault(key, defaultValue),
+      saveToStorage: (val) => set(key, val.toString())
+    })
+  };
+}
+
+// src/migrations/system-schema.ts
+var baseSystemMigrations = [
+  {
+    version: 0,
+    up: (ctx) => {
+      ctx.execute(`CREATE TABLE IF NOT EXISTS ${ctx.eventsTableName} (
+        "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.updateLogTableName} (
+        "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.eventsTableName} ADD COLUMN "source_node_id" TEXT NOT NULL DEFAULT ''`);
+    }
+  }
+];
+function runSystemMigrations(opts) {
+  const ctx = {
+    eventsTableName: opts.eventsTableName,
+    updateLogTableName: opts.updateLogTableName,
+    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),
+    eventsTableName: '"worker"."crdt_events"',
+    updateLogTableName: '"crdt_update_log"',
+    execute: (sql2) => db.execute(sql2, { loggerLevel: "system" }),
+    transaction: (callback) => db.executeTransaction(callback)
+  });
+}
+function applyMemoryDbSchema(db) {
+  db.execute(
+    `CREATE TABLE "persisted_crdt_events" (
+  "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" }
+  );
+}
+
+// src/sqlite-crdt/apply-crdt-event.ts
+var createSQLiteCrdtApplyFunction = ({
+  db,
+  updateLogTableName
+}) => {
+  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(updateLogTableName).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(updateLogTableName).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(updateLogTableName).set({
+          payload: params("payload")
+        }).where("item_id", "=", params("item_id")).where("dataset", "=", params("dataset")),
+        { loggerLevel: "system" }
+      );
+    },
+    insertItem(opts) {
+      const insertPayload = {};
+      for (const key of Object.keys(opts.payload)) {
+        insertPayload[key] = key;
+      }
+      db.executePrepared(
+        `crdt-insert-item-${opts.dataset}`,
+        opts.payload,
+        (db2) => db2.insertInto(opts.dataset).values(insertPayload),
+        { loggerLevel: "system" }
+      );
+    },
+    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" }
+      );
+    }
+  });
+  return applyCrdtEvent;
+};
+function createCrdtApplyFunction({
+  getCrdtUpdateLog,
+  insertItem,
+  insertCrdtUpdateLog,
+  updateItem,
+  updateCrdtUpdateLog
+}) {
+  const applyItemCreated = ({ event, meta }) => {
+    if (meta) {
+      applyItemUpdated({ event, meta });
+      return;
+    }
+    const eventPayload = JSON.parse(event.payload);
+    eventPayload.tombstone = false;
+    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 = JSON.parse(event.payload);
+    const updatePayload = {};
+    let hasUpdates = false;
+    for (const [key, value] of Object.entries(eventPayload)) {
+      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) => {
+    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;
+    }
+  };
+}
+
+// src/sqlite-crdt/crdt-storage.ts
+function createCrdtStorage(storage) {
+  const transaction = storage.transaction ?? ((callback) => callback());
+  const eventTarget = createTypedEventTarget();
+  const enqueueEvents = (origin, sourceNodeId, events) => {
+    if (events.length === 0) {
+      return;
+    }
+    transaction(() => {
+      for (const event of events) {
+        storage.persistEvent({
+          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: ++storage.syncId.current,
+          status: "pending"
+        });
+      }
+    });
+    processEnqueuedEvents();
+  };
+  const enqueueLocalEvents = (events, sourceNodeId) => {
+    enqueueEvents("local", sourceNodeId, events);
+  };
+  const enqueueOwnEvents = (events) => {
+    enqueueEvents("own", storage.nodeId, events);
+  };
+  const enqueueRemoteEvents = (events) => {
+    enqueueEvents("remote", "", events);
+  };
+  const applyOwnEvent = (event, { wrapInTransaction } = {}) => {
+    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",
+      source_node_id: storage.nodeId,
+      payload: event.payload,
+      sync_id: ++storage.syncId.current,
+      status: "pending"
+    };
+    if (wrapInTransaction) {
+      transaction(() => {
+        storage.persistEvent(persistedEvent);
+        processPersistedEvent(persistedEvent);
+      });
+    } else {
+      storage.persistEvent(persistedEvent);
+      processPersistedEvent(persistedEvent);
+    }
+  };
+  const dispatchEventsApplied = () => {
+    eventTarget.dispatchEvent("events-applied", {
+      syncId: storage.syncId.current
+    });
+  };
+  const getEventsBatch = (options) => {
+    const limit = options.limit ?? 50;
+    const events = storage.getEventsBatch({
+      ...options,
+      limit: limit + 1
+    });
+    const hasMore = events.length > limit;
+    if (hasMore) {
+      events.pop();
+    }
+    return {
+      events,
+      hasMore,
+      nextSyncId: events[events.length - 1]?.sync_id ?? options.afterSyncId ?? 0
+    };
+  };
+  const processPersistedEvent = (event) => {
+    if (event.status !== "pending") {
+      throw new Error(`Event ${event.sync_id} is not pending`);
+    }
+    try {
+      if (event.origin === "local" || event.origin === "remote") {
+        storage.hlc.mergeHLC(deserializeHLC(event.timestamp));
+      }
+      const migratedEvent = storage.migrator.migrateEvent(event, storage.migrator.latestSchemaVersion);
+      if (migratedEvent === null) {
+        event.status = "skipped";
+        event.schema_version = storage.migrator.latestSchemaVersion;
+        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;
+      storage.handleCrdtEventApply(event);
+      event.status = "applied";
+    } 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
+      });
+    }
+  };
+  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;
+      if (events.length === 0) {
+        break;
+      }
+      for (const event of events) {
+        transaction(() => {
+          processPersistedEvent(event);
+        });
+      }
+      dispatchEventsApplied();
+    }
+  });
+  return {
+    getEventsBatch,
+    enqueueLocalEvents,
+    enqueueOwnEvents,
+    enqueueRemoteEvents,
+    applyOwnEvent,
+    dispatchEventsApplied,
+    addEventListener: eventTarget.addEventListener,
+    removeEventListener: eventTarget.removeEventListener
+  };
+}
+
+// src/sqlite-crdt/crdt-sync-producer.ts
+var createCrdtSyncProducer = ({ storage, broadcastEvents }) => {
+  storage.addEventListener("events-applied", (event) => {
+    broadcastEvents({ newSyncId: event.payload.syncId });
+  });
+};
+
+// src/sqlite-crdt/crdt-sync-remote-source.ts
+import retryAsPromised from "retry-as-promised";
+var createCrdtSyncRemoteSource = ({
+  bufferSize,
+  storage,
+  migrator,
+  pullSyncId,
+  pushSyncId,
+  nodeId,
+  remoteFactory
+}) => {
+  const eventTarget = createTypedEventTarget();
+  let remoteState = { type: "offline", reason: "NOT_INITIALIZED" };
+  const setRemoteState = (state) => {
+    remoteState = state;
+    eventTarget.dispatchEvent("state-changed", state.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.");
+        setRemoteState({ type: "offline", reason: "NOT_INITIALIZED" });
+        return;
+      }
+      setRemoteState({ type: "pending" });
+      const factoryResult = await tryCatchAsync(async () => {
+        return await remoteFactory?.({
+          onEventsAvailable: (newSyncId) => {
+            pullEvents({ remoteSyncId: newSyncId, includeSelf: false });
+          }
+        });
+      });
+      if (!factoryResult.success) {
+        setRemoteState({ type: "offline", reason: "INITIALIZATION_FAILED" });
+        console.warn("Failed to create remote source", factoryResult.error);
+        return;
+      }
+      setRemoteState({
+        type: "online",
+        source: factoryResult.data
+      });
+    },
+    { 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;
+      setRemoteState({ type: "pending" });
+      const disconnectResult = await tryCatchAsync(async () => {
+        return await source.disconnect?.();
+      });
+      if (!disconnectResult.success) {
+        console.warn("Error while disconnecting from remote source", disconnectResult.error);
+      }
+      setRemoteState({ 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) {
+      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 retryAsPromised(
+        () => source.pullEvents({
+          ...opts,
+          afterSyncId
+        }),
+        {
+          max: 3,
+          backoffBase: 100,
+          backoffExponent: 1.5,
+          backoffJitter: 150,
+          timeout: 1e4
+        }
+      );
+      hasMore = response.hasMore;
+      afterSyncId = response.nextSyncId;
+      if (response.events) {
+        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}`
+              );
+            }
+            return x;
+          })
+        );
+      }
+      if (response.nextSyncId <= pullSyncId.current) {
+        break;
+      }
+      if (response.nextSyncId > pullSyncId.current) {
+        pullSyncId.current = response.nextSyncId;
+      }
+    }
+  };
+  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;
+      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;
+        }
+      }
+      pushSyncId.current = eventsBatch.nextSyncId;
+      if (!eventsBatch.hasMore) {
+        break;
+      }
+    }
+  });
+  const onEventsApplied = () => {
+    startPushingEvents();
+  };
+  storage.addEventListener("events-applied", onEventsApplied);
+  const getState = () => remoteState.type;
+  const dispose = async () => {
+    await goOffline("DISCONNECTED");
+    storage.removeEventListener("events-applied", onEventsApplied);
+  };
+  return {
+    goOnline,
+    goOffline,
+    syncWithRemote,
+    getState,
+    dispose,
+    addEventListener: eventTarget.addEventListener,
+    removeEventListener: eventTarget.removeEventListener
+  };
+};
+
+// 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/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,
+  HLCCounter,
+  serializeHLC,
+  deserializeHLC,
+  compareHLC,
+  introspectDb,
+  startPerformanceLogger,
+  SQLiteDbWrapper,
+  createMigrations,
+  createMigrator,
+  createStoredValue,
+  createKvStoreTableQuery,
+  createSQLiteKvStore,
+  baseSystemMigrations,
+  runSystemMigrations,
+  applyWorkerDbSchema,
+  applyMemoryDbSchema,
+  createSQLiteCrdtApplyFunction,
+  createCrdtApplyFunction,
+  createCrdtStorage,
+  createCrdtSyncProducer,
+  createCrdtSyncRemoteSource,
+  applyKyselyEventsBatchFilters,
+  syncDbWorkerLockName,
+  syncDbClientLockName,
+  createBroadcastChannels,
+  isWorkerInitMessage,
+  isWorkerRequestMessage,
+  isWorkerResponseMessage,
+  isWorkerErrorResponseMessage,
+  isWorkerNotificationMessage
+};
+//# sourceMappingURL=chunk-627DSM2Q.js.map