@sqlite-sync/core 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,206 +1,98 @@
 import {
+  HLCCounter,
   SQLiteDbWrapper,
-  SqliteDriver,
+  applyKyselyEventsBatchFilters,
   applyMemoryDbSchema,
   applyWorkerDbSchema,
-  broadcastChannelNames,
+  baseSystemMigrations,
+  compareHLC,
   createBroadcastChannels,
+  createCrdtApplyFunction,
+  createCrdtStorage,
+  createCrdtSyncProducer,
   createCrdtSyncRemoteSource,
-  createSQLiteKysely,
-  createSyncDbMigrations,
-  createSyncDbMigrator,
+  createKvStoreTableQuery,
+  createMigrations,
+  createMigrator,
+  createSQLiteCrdtApplyFunction,
+  createSQLiteKvStore,
+  createStoredValue,
+  deserializeHLC,
+  dummyKysely,
   introspectDb,
-  isWorkerInitMessage,
-  isWorkerInitResponse,
+  isWorkerErrorResponseMessage,
   isWorkerNotificationMessage,
-  isWorkerRequestMessage,
   isWorkerResponseMessage,
+  runSystemMigrations,
+  serializeHLC,
   startPerformanceLogger,
-  syncDbWorkerLockName
-} from "./chunk-LK5FJCUD.js";
+  syncDbClientLockName
+} from "./chunk-627DSM2Q.js";
 import {
   TypedBroadcastChannel,
   TypedEvent,
-  applyCrdtEventMutations,
-  crdtSchema,
-  createAsyncAutoFlushBuffer,
-  createAutoFlushBuffer,
-  createCrdtStorage,
-  createCrdtSyncProducer,
   createDeferredPromise,
-  createSyncIdCounter,
   createTypedEventTarget,
-  dummyKysely,
-  ensureSingletonExecution,
   generateId,
   jsonSafeParse,
-  orderBy,
-  registerCrdtFunctions
-} from "./chunk-YLXMST5Z.js";
+  quoteId,
+  tryCatch,
+  tryCatchAsync
+} from "./chunk-UGF5IU53.js";
 
-// src/hlc.ts
-var HLCCounter = class {
-  timestamp;
-  counter;
-  nodeId;
-  getTimestamp;
-  constructor(nodeId, getTimestamp) {
-    this.timestamp = getTimestamp();
-    this.counter = 0;
-    this.nodeId = nodeId;
-    this.getTimestamp = getTimestamp;
-  }
-  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++;
-    return this.getCurrentHLC();
+// src/memory-db/sqlite-reactive-db.ts
+import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
+
+// src/bound-map.ts
+var BoundMap = class {
+  map = /* @__PURE__ */ new Map();
+  maxSize;
+  onRemove;
+  constructor(opts) {
+    this.maxSize = opts.maxSize;
+    this.onRemove = opts.onRemove;
   }
-  mergeHLC(hlc) {
-    if (this.timestamp === hlc.timestamp) {
-      this.counter = Math.max(this.counter, hlc.counter) + 1;
-    } else if (this.timestamp > hlc.timestamp) {
-      this.counter++;
+  set = (key, value) => {
+    if (this.onRemove && this.map.has(key)) {
+      const old = this.map.get(key);
+      this.map.set(key, value);
+      this.onRemove(key, old);
     } else {
-      this.timestamp = hlc.timestamp;
-      this.counter = hlc.counter + 1;
+      this.map.set(key, value);
     }
-  }
-};
-function serializeHLC(hlc) {
-  return hlc.timestamp.toString().padStart(15, "0") + ":" + hlc.counter.toString(36).padStart(5, "0") + ":" + hlc.nodeId;
-}
-function deserializeHLC(serialized) {
-  const [ts, count, ...node] = serialized.split(":");
-  return {
-    timestamp: parseInt(ts),
-    counter: parseInt(count, 36),
-    nodeId: node.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;
+    if (this.map.size > this.maxSize) {
+      const firstKey = this.map.keys().next().value;
+      this.delete(firstKey);
     }
-    return one.counter - two.counter;
-  }
-  return one.timestamp - two.timestamp;
-}
-
-// src/worker-db/db-worker-client.ts
-var createWorkerDbClient = ({
-  broadcastChannels
-}) => {
-  const eventTarget = createTypedEventTarget();
-  const workerRequestsMap = /* @__PURE__ */ new Map();
-  const queryWorker = (method, args) => {
-    const requestId = crypto.randomUUID();
-    const promise = createDeferredPromise();
-    workerRequestsMap.set(requestId, promise);
-    const request = {
-      type: "request",
-      requestId,
-      method,
-      args
-    };
-    broadcastChannels.requests.postMessage(request);
-    return promise.promise;
   };
-  const handleWorkerResponse = (message) => {
-    const promise = workerRequestsMap.get(message.requestId);
-    if (!promise) {
-      return;
-    }
-    promise.resolve(message.data);
-    workerRequestsMap.delete(message.requestId);
+  get = (key) => {
+    return this.map.get(key);
   };
-  broadcastChannels.responses.onmessage = (event) => {
-    const message = event.data;
-    if (isWorkerResponseMessage(message)) {
-      handleWorkerResponse(message);
-    } else if (isWorkerNotificationMessage(message)) {
-      eventTarget.dispatchEvent("new-notification", message);
+  delete = (key) => {
+    if (this.onRemove && this.map.has(key)) {
+      const value = this.map.get(key);
+      this.map.delete(key);
+      this.onRemove(key, value);
+    } else {
+      this.map.delete(key);
     }
   };
-  const rpc = {
-    execute: (query) => queryWorker("execute", [query]),
-    getSnapshot: () => queryWorker("getSnapshot", []),
-    pushTabEvents: (request) => queryWorker("pushTabEvents", [request]),
-    pullEvents: (params) => queryWorker("pullEvents", [params]),
-    postInitReady: () => queryWorker("postInitReady", [])
-  };
-  return {
-    ...rpc,
-    addEventListener: eventTarget.addEventListener,
-    removeEventListener: eventTarget.removeEventListener
-  };
-};
-function initializeWorkerDb({
-  worker,
-  broadcastChannels,
-  config
-}) {
-  const promise = createDeferredPromise();
-  broadcastChannels.responses.onmessage = (event) => {
-    const message = event.data;
-    if (!isWorkerInitResponse(message)) {
-      return;
+  clear = () => {
+    const onRemove = this.onRemove;
+    if (onRemove) {
+      this.map.forEach((value, key) => {
+        onRemove(key, value);
+      });
     }
-    promise.resolve();
-    worker.onmessage = null;
-  };
-  const configMessage = {
-    type: "init",
-    config
+    this.map.clear();
   };
-  worker.postMessage(configMessage);
-  broadcastChannels.requests.postMessage({
-    type: "request",
-    requestId: crypto.randomUUID(),
-    method: "postInitReady",
-    args: []
-  });
-  return promise.promise;
-}
+};
 
 // src/memory-db/sqlite-reactive-db.ts
-import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
 var sqliteModule = null;
 function createSQLiteReactiveDb(opts) {
   return SQLiteReactiveDb.create(opts);
 }
-var defaultLogger = (type, message, level = "info") => {
-  const logMessage = `[${type}] ${message}`;
-  switch (level) {
-    case "info":
-      console.log(logMessage);
-      break;
-    case "warning":
-      console.warn(logMessage);
-      break;
-    case "error":
-      console.error(logMessage);
-      break;
-    case "trace":
-      console.trace(logMessage);
-      break;
-  }
-};
 var SQLiteReactiveDb = class _SQLiteReactiveDb {
   db;
   sqlite3;
@@ -211,14 +103,14 @@ var SQLiteReactiveDb = class _SQLiteReactiveDb {
     this.sqlite3 = sqlite3;
     this.logger = logger;
     this.db = new SQLiteDbWrapper({
-      db: new sqlite3.oo1.DB({ filename: ":memory:" }),
+      db: () => new sqlite3.oo1.DB({ filename: ":memory:" }),
       logger: this.logger,
       loggerPrefix: "memory",
       sqlite3
     });
   }
   static async create(opts) {
-    const logger = opts.logger ?? defaultLogger;
+    const logger = opts.logger;
     const perf = startPerformanceLogger(logger);
     if (!sqliteModule) {
       sqliteModule = await sqlite3InitModule();
@@ -228,24 +120,38 @@ var SQLiteReactiveDb = class _SQLiteReactiveDb {
       db.useSnapshot(opts.snapshot);
     }
     db.registerDbHooks();
-    perf.logEnd("createSQLiteMemoryDb", "success", "info");
+    perf.logEnd("createSQLiteMemoryDb", "success", "system");
     return db;
   }
+  liveQueryStatements = new BoundMap({
+    maxSize: 100,
+    onRemove(_, value) {
+      value.finalize();
+    }
+  });
   createLiveQuery(query) {
-    const fetchRows = () => this.db.execute({
-      sql: query.sql,
-      parameters: query.parameters ?? []
-    }).rows;
+    const fetchRows = (parameters) => {
+      let statement = this.liveQueryStatements.get(query.sql);
+      if (!statement) {
+        statement = this.db.prepare(query.sql);
+        this.liveQueryStatements.set(query.sql, statement);
+      }
+      return statement.execute(parameters);
+    };
     let rows = null;
     const getRows = () => {
       if (!rows) {
-        rows = fetchRows();
+        rows = fetchRows(query.parameters);
       }
       return rows;
     };
     let subscriber = null;
-    const refresh = () => {
-      rows = fetchRows();
+    let lastParameters = query.parameters;
+    const refresh = (parameters) => {
+      if (parameters) {
+        lastParameters = parameters;
+      }
+      rows = fetchRows(lastParameters);
       subscriber?.();
     };
     const subscribe = (onchange) => {
@@ -265,16 +171,14 @@ var SQLiteReactiveDb = class _SQLiteReactiveDb {
     return { getRows, refresh, subscribe };
   }
   subscribeToQueryChanges(params) {
-    const { sql: sql2, onDataChange } = params;
-    const tables = this.getTablesUsed(sql2);
+    const { sql, onDataChange } = params;
+    const tables = this.getTablesUsed(sql);
     const readTables = /* @__PURE__ */ new Set();
     for (const table of tables) {
       if (!readTables.has(table.name)) {
         readTables.add(table.name);
       } else if (table.isWrite) {
-        throw new Error(
-          "This query writes and reads from the same table. This may cause infinite loops."
-        );
+        throw new Error("This query writes and reads from the same table. This may cause infinite loops.");
       }
     }
     const notifyDataChange = createDebouncedCallback(() => {
@@ -287,15 +191,9 @@ var SQLiteReactiveDb = class _SQLiteReactiveDb {
     return {
       unsubscribe: () => {
         for (const table of readTables) {
-          this.eventTarget.removeEventListener(
-            `table:${table}`,
-            notifyDataChange
-          );
-          this.eventTarget.removeEventListener(
-            "any-table-changed",
-            notifyDataChange
-          );
+          this.eventTarget.removeEventListener(`table:${table}`, notifyDataChange);
         }
+        this.eventTarget.removeEventListener("any-table-changed", notifyDataChange);
       }
     };
   }
@@ -312,17 +210,18 @@ var SQLiteReactiveDb = class _SQLiteReactiveDb {
   getTablesUsed(query) {
     if (!this.tablesUsedStatement) {
       this.tablesUsedStatement = this.db.prepare(
-        "select t.tbl_name as name, u.wr as isWrite from tables_used(?) as u inner join sqlite_master as t on t.name = u.name where u.schema = 'main'"
+        "select t.tbl_name as name, u.wr as isWrite from tables_used(?) as u inner join sqlite_master as t on t.name = u.name where u.schema = 'main'",
+        { loggerLevel: "system" }
       );
     }
     const tables = this.tablesUsedStatement.execute([query]);
-    if (tables.length == 0 && query.toLowerCase().includes("delete")) {
+    if (tables.length === 0 && query.toLowerCase().includes("delete")) {
       tables.push(...this.getClearedTables(query));
     }
     return tables;
   }
   getClearedTables(query) {
-    const operations = this.db.execute(`EXPLAIN ${query.split(";")[0]}`).rows;
+    const operations = this.db.execute(`EXPLAIN ${query.split(";")[0]}`, { loggerLevel: "system" }).rows;
     const clearedTablesRootPages = /* @__PURE__ */ new Set();
     for (const operation of operations) {
       if (operation.opcode === "Clear" && operation.p2 === 0) {
@@ -335,7 +234,8 @@ var SQLiteReactiveDb = class _SQLiteReactiveDb {
     const tableNames = this.db.execute(
       `select t.tbl_name as name, true as isWrite from sqlite_master as t where t.rootpage in (${Array.from(
         clearedTablesRootPages
-      ).join(",")})`
+      ).join(",")})`,
+      { loggerLevel: "system" }
     ).rows;
     return tableNames;
   }
@@ -395,17 +295,21 @@ var SQLiteReactiveDb = class _SQLiteReactiveDb {
   createSnapshot() {
     const perf = startPerformanceLogger(this.logger);
     const snapshot = this.sqlite3.capi.sqlite3_js_db_export(this.db.ensureDb);
-    perf.logEnd(
-      "createSnapshot",
-      `snapshot size: ${snapshot.byteLength}`,
-      "info"
-    );
+    perf.logEnd("createSnapshot", `snapshot size: ${snapshot.byteLength}`, "info");
     return snapshot;
   }
   useSnapshot(snapshot) {
     this.db.useSnapshot(snapshot);
     this.notifyTableSubscribers();
   }
+  dispose() {
+    this.liveQueryStatements.clear();
+    if (this.tablesUsedStatement) {
+      this.tablesUsedStatement.finalize();
+      this.tablesUsedStatement = null;
+    }
+    this.db.close();
+  }
 };
 function createDebouncedCallback(callback, delay) {
   let timeout = null;
@@ -428,8 +332,89 @@ function createDebouncedCallback(callback, delay) {
   };
 }
 
-// src/memory-db/memory-db.ts
-import { sql } from "kysely";
+// src/sqlite-crdt/crdt-schema.ts
+function createSyncDbSchema({ migrations }) {
+  return new CrdtSchemaBuilder({ tables: [], migrations });
+}
+var CrdtSchemaBuilder = class _CrdtSchemaBuilder {
+  constructor(config) {
+    this.config = config;
+  }
+  get tablesConfig() {
+    return this.config.tables;
+  }
+  get migrations() {
+    return this.config.migrations;
+  }
+  get "~clientSchema"() {
+    console.warn("~clientSchema should not be accessed on the client");
+    return null;
+  }
+  get "~serverSchema"() {
+    console.warn("~serverSchema should not be accessed on the server");
+    return null;
+  }
+  get "~mutationsSchema"() {
+    console.warn("~mutationsSchema should not be accessed on the client");
+    return null;
+  }
+  addTable() {
+    const withConfig = ({
+      baseTableName,
+      crdtTableName
+    }) => {
+      this.config.tables.push({ baseTableName, crdtTableName });
+      return new _CrdtSchemaBuilder(this.config);
+    };
+    return { withConfig };
+  }
+  build() {
+    return this;
+  }
+};
+
+// src/sqlite-crdt/crdt-storage-mutator.ts
+function createCrdtStorageMutator({ storage }) {
+  const mapToStorageEvent = (event) => {
+    switch (event.type) {
+      case "item-created":
+        return {
+          type: "item-created",
+          dataset: event.dataset,
+          item_id: event.item_id,
+          payload: JSON.stringify(event.payload)
+        };
+      case "item-updated":
+        return {
+          type: "item-updated",
+          dataset: event.dataset,
+          item_id: event.item_id,
+          payload: JSON.stringify(event.payload)
+        };
+      case "item-deleted":
+        return {
+          type: "item-updated",
+          dataset: event.dataset,
+          item_id: event.item_id,
+          payload: JSON.stringify({ tombstone: 1 })
+        };
+    }
+  };
+  const enqueueEvents = (events) => {
+    storage.enqueueOwnEvents(events.map(mapToStorageEvent));
+  };
+  const createEvent = (event) => {
+    return event;
+  };
+  const enqueueEvent = (event) => {
+    storage.enqueueOwnEvents([mapToStorageEvent(event)]);
+  };
+  return {
+    enqueueEvents,
+    createEvent,
+    enqueueEvent
+  };
+}
 
 // src/sqlite-crdt/make-crdt-table.ts
 function makeCrdtTable({
@@ -441,23 +426,54 @@ function makeCrdtTable({
   if (!tableSchema) {
     throw new Error(`Table ${baseTableName} not found`);
   }
-  db.execute(`
-create view ${crdtTableName} as
-select * from ${baseTableName}
-where tombstone = 0;`);
+  const columns = new Map(tableSchema.columns.map((c) => [c.name, c]));
+  const idColumn = columns.get("id");
+  if (!idColumn) {
+    throw new Error(
+      `Table "${baseTableName}" is missing a required "id" column. CRDT tables must have an "id" column to identify items.`
+    );
+  }
+  if (idColumn.dataType.toUpperCase() !== "TEXT") {
+    throw new Error(
+      `Table "${baseTableName}": "id" column must be of type TEXT, got "${idColumn.dataType}". CRDT item IDs are stored as strings.`
+    );
+  }
+  const tombstoneColumn = columns.get("tombstone");
+  if (!tombstoneColumn) {
+    throw new Error(
+      `Table "${baseTableName}" is missing a required "tombstone" column. CRDT tables must have a "tombstone" INTEGER column for soft deletes.`
+    );
+  }
+  const tombstoneType = tombstoneColumn.dataType.toUpperCase();
+  if (tombstoneType !== "INTEGER" && tombstoneType !== "BOOLEAN") {
+    throw new Error(
+      `Table "${baseTableName}": "tombstone" column must be of type INTEGER or BOOLEAN, got "${tombstoneColumn.dataType}". It is compared as 0/1 for soft deletes.`
+    );
+  }
+  db.execute(
+    `
+create view ${quoteId(crdtTableName)} as
+select * from ${quoteId(baseTableName)}
+where tombstone = 0;`,
+    { loggerLevel: "system" }
+  );
   const allColumnNames = tableSchema.columns.map((column) => column.name);
-  const jsonPayload = (from) => "'{'||" + allColumnNames.map((col) => `'"${col}":'||json_quote(${from}.${col})`).join("||','||") + "||'}'";
-  db.execute(`
-create trigger ${crdtTableName}_created
-instead of insert on ${crdtTableName}
+  const jsonPayload = (from) => `'{'||${allColumnNames.map((col) => `'"${col}":'||json_quote(${from}.${quoteId(col)})`).join("||','||")}||'}'`;
+  db.execute(
+    `
+create trigger ${quoteId(`${crdtTableName}_created`)}
+instead of insert on ${quoteId(crdtTableName)}
 for each row
 begin
 select handle_item_created('${baseTableName}', ${jsonPayload("new")});
 end;
-`);
-  db.execute(`
-create trigger ${crdtTableName}_updated
-instead of update on ${crdtTableName}
+`,
+    { loggerLevel: "system" }
+  );
+  db.execute(
+    `
+create trigger ${quoteId(`${crdtTableName}_updated`)}
+instead of update on ${quoteId(crdtTableName)}
 for each row
 begin
 select handle_item_updated(
@@ -466,23 +482,133 @@ select handle_item_updated(
   ${jsonPayload("new")}
 );
 end;
-`);
-  db.execute(`
-create trigger ${crdtTableName}_deleted
-instead of delete on ${crdtTableName}
+`,
+    { loggerLevel: "system" }
+  );
+  db.execute(
+    `
+create trigger ${quoteId(`${crdtTableName}_deleted`)}
+instead of delete on ${quoteId(crdtTableName)}
 for each row
 when old.tombstone = 0
 begin
 select handle_item_deleted('${baseTableName}', old.id);
 end;
-`);
+`,
+    { loggerLevel: "system" }
+  );
+}
+function registerCrdtFunctions({
+  reactiveDb,
+  storage
+}) {
+  let eventApplied = false;
+  reactiveDb.db.createScalarFunction({
+    name: "handle_item_created",
+    deterministic: false,
+    directOnly: false,
+    innocuous: false,
+    callback: (dataset, payloadRaw) => {
+      const payload = JSON.parse(payloadRaw);
+      storage.applyOwnEvent(
+        {
+          type: "item-created",
+          dataset,
+          item_id: payload.id,
+          payload: payloadRaw
+        },
+        {
+          wrapInTransaction: false
+        }
+      );
+      eventApplied = true;
+      return void 0;
+    }
+  });
+  reactiveDb.db.createScalarFunction({
+    name: "handle_item_updated",
+    deterministic: false,
+    directOnly: false,
+    innocuous: false,
+    callback: (dataset, oldPayloadRaw, newPayloadRaw) => {
+      const tableSchema = reactiveDb.db.dbSchema[dataset];
+      const oldPayload = JSON.parse(oldPayloadRaw);
+      const newPayload = JSON.parse(newPayloadRaw);
+      let hasDiff = false;
+      const updatePayload = {};
+      for (const column of tableSchema.columns) {
+        const oldValue = oldPayload[column.name];
+        const newValue = newPayload[column.name];
+        if (oldValue === newValue) {
+          continue;
+        }
+        hasDiff = true;
+        updatePayload[column.name] = newValue;
+      }
+      if (!hasDiff) {
+        return;
+      }
+      storage.applyOwnEvent(
+        {
+          type: "item-updated",
+          dataset,
+          item_id: oldPayload.id,
+          payload: JSON.stringify(updatePayload)
+        },
+        {
+          wrapInTransaction: false
+        }
+      );
+      eventApplied = true;
+      return void 0;
+    }
+  });
+  reactiveDb.db.createScalarFunction({
+    name: "handle_item_deleted",
+    deterministic: false,
+    directOnly: false,
+    innocuous: false,
+    callback: (dataset, itemId) => {
+      storage.applyOwnEvent(
+        {
+          type: "item-updated",
+          dataset,
+          item_id: itemId,
+          payload: JSON.stringify({ tombstone: 1 })
+        },
+        {
+          wrapInTransaction: false
+        }
+      );
+      eventApplied = true;
+      return void 0;
+    }
+  });
+  reactiveDb.addEventListener("transaction-committed", () => {
+    if (eventApplied) {
+      eventApplied = false;
+      storage.dispatchEventsApplied();
+    }
+  });
+  reactiveDb.addEventListener("transaction-rolled-back", () => {
+    eventApplied = false;
+  });
+}
+
+// src/db-id.ts
+var dbIdRegex = /^[a-zA-Z][a-zA-Z\-0-9]{2,63}$/;
+function validateDbId(dbId) {
+  if (!dbIdRegex.test(dbId)) {
+    throw new Error("Invalid dbId. Must be between 3 and 64 characters long and start with a letter.");
+  }
 }
 
 // src/memory-db/memory-db.ts
 async function createMemoryDb({
+  nodeId,
+  migrator,
   reactiveDb: _reactiveDb,
   hlcCounter,
-  tabId,
   crdtTables
 }) {
   const reactiveDb = _reactiveDb;
@@ -495,216 +621,347 @@ async function createMemoryDb({
       crdtTableName: table.crdtTableName
     });
   }
-  const localSyncId = createSyncIdCounter({
-    initialSyncId: 0
-  });
-  const pendingLocalEvents = [];
-  registerCrdtFunctions({
-    db,
-    getTableSchema: (dataset) => db.dbSchema[dataset],
-    getNextTimestamp: () => serializeHLC(hlcCounter.getNextHLC()),
-    updateLogTableName: "crdt_update_log",
-    onEventApplied: (event) => {
-      const persistedEvent = {
-        ...event,
-        origin: tabId,
-        sync_id: ++localSyncId.current,
-        status: "applied"
-      };
-      enqueueCrdtEvent(db, persistedEvent);
-      pendingLocalEvents.push(persistedEvent);
-    }
-  });
-  db.createScalarFunction({
-    name: "gen_id",
-    callback: () => generateId(),
-    deterministic: false,
-    directOnly: false,
-    innocuous: true
-  });
-  reactiveDb.addEventListener("transaction-rolled-back", () => {
-    pendingLocalEvents.length = 0;
-  });
-  reactiveDb.addEventListener("transaction-committed", () => {
-    const appliedEvents = pendingLocalEvents.splice(0);
-    queueMicrotask(() => {
-      for (const event of appliedEvents) {
-        crdtStorage.dispatchEvent("event-applied", event);
-      }
-      crdtStorage.dispatchEvent("event-processing-done", void 0);
-    });
+  const localSyncId = createStoredValue({
+    initialValue: 0
   });
   const crdtStorage = createCrdtStorage({
+    nodeId,
     syncId: localSyncId,
-    persistEvents: (events) => persistEvents(db, events),
-    popPendingEventsBatch: () => popPendingEventsBatch(db, 50),
-    applyCrdtEventMutations: (event) => applyCrdtEventMutations({
+    hlc: hlcCounter,
+    persistEvent: (event) => persistEvent(db, event),
+    getEventsBatch: (opts) => getEventsBatch(db, opts),
+    migrator,
+    handleCrdtEventApply: createSQLiteCrdtApplyFunction({
       db,
-      event,
       updateLogTableName: "crdt_update_log"
     }),
-    updateEventStatus: (syncId, status) => updateEventStatus(db, syncId, status)
+    updateEvent: (syncId, update) => updateEvent(db, syncId, update),
+    transaction: (callback) => db.executeTransaction(callback)
+  });
+  registerCrdtFunctions({
+    reactiveDb,
+    storage: crdtStorage
   });
   return {
     crdtStorage
   };
 }
-function enqueueCrdtEvent(db, event) {
+function persistEvent(db, event) {
   db.executePrepared(
-    "enqueue-crdt-events",
+    "persist-crdt-event",
     event,
     (db2, params) => db2.insertInto("persisted_crdt_events").values({
-      status: params("status"),
-      sync_id: params("sync_id"),
       type: params("type"),
-      timestamp: params("timestamp"),
       dataset: params("dataset"),
       item_id: params("item_id"),
       payload: params("payload"),
-      origin: params("origin")
-    })
+      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" }
   );
 }
-function persistEvents(db, events) {
-  db.executeTransaction((db2) => {
-    const chunkSize = 100;
-    for (let i = 0; i < events.length; i += chunkSize) {
-      const chunk = events.slice(i, i + chunkSize);
-      db2.executeKysely(
-        (db3) => db3.insertInto("persisted_crdt_events").values(chunk)
-      );
-    }
-  });
+function getEventsBatch(db, opts) {
+  return db.executeKysely(
+    (db2) => applyKyselyEventsBatchFilters(db2.selectFrom("persisted_crdt_events").selectAll(), {
+      limit: 50,
+      ...opts
+    }),
+    { loggerLevel: "system" }
+  ).rows;
 }
-function popPendingEventsBatch(db, limit) {
-  const events = db.executePrepared(
-    "pop-enqueued-crdt-events",
-    {
-      limit
-    },
-    (db2, param) => db2.selectFrom("persisted_crdt_events").where("status", "=", sql.lit("pending")).limit(param("limit")).orderBy("sync_id", "asc").selectAll()
+function updateEvent(db, syncId, update) {
+  db.executePrepared(
+    "update-crdt-event",
+    { syncId, ...update },
+    (db2, params) => db2.updateTable("persisted_crdt_events").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("syncId")),
+    { loggerLevel: "system" }
   );
+}
+
+// src/worker-db/db-worker-client.ts
+var createWorkerDbClient = async ({
+  broadcastChannels,
+  worker,
+  config
+}) => {
+  const eventTarget = createTypedEventTarget();
+  const workerRequestsMap = /* @__PURE__ */ new Map();
+  let isDisposed = false;
+  const queryWorker = (method, args) => {
+    if (isDisposed) {
+      return Promise.reject(new Error("Worker client disposed"));
+    }
+    const requestId = crypto.randomUUID();
+    const promise = createDeferredPromise({
+      timeout: 3e4,
+      onTimeout: () => workerRequestsMap.delete(requestId)
+    });
+    workerRequestsMap.set(requestId, promise);
+    const request = {
+      type: "request",
+      requestId,
+      method,
+      args
+    };
+    broadcastChannels.requests.postMessage(request);
+    return promise.promise;
+  };
+  const handleWorkerResponse = (message) => {
+    const promise = workerRequestsMap.get(message.requestId);
+    if (!promise) {
+      return;
+    }
+    promise.resolve(message.data);
+    workerRequestsMap.delete(message.requestId);
+  };
+  const handleWorkerError = (message) => {
+    const promise = workerRequestsMap.get(message.requestId);
+    if (!promise) {
+      return;
+    }
+    promise.reject(new Error(message.error));
+    workerRequestsMap.delete(message.requestId);
+  };
+  broadcastChannels.responses.onmessage = (event) => {
+    const message = event.data;
+    if (isWorkerResponseMessage(message)) {
+      handleWorkerResponse(message);
+    } else if (isWorkerErrorResponseMessage(message)) {
+      handleWorkerError(message);
+    } else if (isWorkerNotificationMessage(message)) {
+      eventTarget.dispatchEvent(message.notificationType, message);
+    }
+  };
+  const rpc = {
+    execute: (query) => queryWorker("execute", [query]),
+    getSnapshot: () => queryWorker("getSnapshot", []),
+    pushTabEvents: (request) => queryWorker("pushTabEvents", [request]),
+    pullEvents: (params) => queryWorker("pullEvents", [params]),
+    postState: () => queryWorker("postState", []),
+    goOnline: () => queryWorker("goOnline", []),
+    goOffline: () => queryWorker("goOffline", [])
+  };
+  const statePromise = awaitWorkerState(eventTarget);
+  postWorkerConfig(worker, config);
+  rpc.postState().catch(() => {
+  });
+  let workerState = await statePromise;
+  eventTarget.addEventListener("state-changed", (event) => {
+    workerState = event.payload.state;
+  });
+  const dispose = () => {
+    isDisposed = true;
+    broadcastChannels.responses.onmessage = null;
+    for (const [id, deferred] of workerRequestsMap) {
+      deferred.reject(new Error("Worker client disposed"));
+      workerRequestsMap.delete(id);
+    }
+  };
   return {
-    events,
-    hasMore: events.length === limit
+    ...rpc,
+    addEventListener: eventTarget.addEventListener,
+    removeEventListener: eventTarget.removeEventListener,
+    getState: () => workerState,
+    dispose
   };
+};
+function awaitWorkerState(eventTarget) {
+  const promise = createDeferredPromise({ timeout: 15e3 });
+  const onStateChanged = (event) => {
+    promise.resolve(event.payload.state);
+    eventTarget.removeEventListener("state-changed", onStateChanged);
+  };
+  eventTarget.addEventListener("state-changed", onStateChanged);
+  return promise.promise;
 }
-function updateEventStatus(db, syncId, status) {
-  db.executePrepared(
-    "update-crdt-event-status",
-    { syncId, status },
-    (db2, params) => db2.updateTable("persisted_crdt_events").set({ status: params("status") }).where("sync_id", "=", params("syncId"))
-  );
+function postWorkerConfig(worker, config) {
+  const configMessage = {
+    type: "init",
+    config
+  };
+  worker.postMessage(configMessage);
 }
 
 // src/sync-db.ts
-async function createSyncedDb(options) {
-  if (!options.dbPath.startsWith("/")) {
-    throw new Error("dbPath must be an absolute path");
+var defaultLogger = (type, message, level = "info") => {
+  const logMessage = `[${type}] ${message}`;
+  switch (level) {
+    case "info":
+      console.log(logMessage);
+      break;
+    case "warning":
+      console.warn(logMessage);
+      break;
+    case "error":
+      console.error(logMessage);
+      break;
+    case "trace":
+      console.trace(logMessage);
+      break;
   }
+};
+async function createSyncedDb(options) {
+  validateDbId(options.dbId);
+  const perf = startPerformanceLogger(defaultLogger);
   const tabId = generateId();
-  const broadcastChannels = createBroadcastChannels();
-  await initializeWorkerDb({
+  const broadcastChannels = createBroadcastChannels(options.dbId);
+  const clientLockAcquired = createDeferredPromise();
+  const clientLockRelease = createDeferredPromise();
+  navigator.locks.request(`${syncDbClientLockName}-${options.dbId}`, { mode: "shared" }, () => {
+    clientLockAcquired.resolve();
+    return clientLockRelease.promise;
+  });
+  await clientLockAcquired.promise;
+  const workerClient = await createWorkerDbClient({
     worker: options.worker,
-    broadcastChannels,
     config: {
       clientId: generateId(),
-      dbPath: options.dbPath,
+      dbId: options.dbId,
       clearOnInit: options.clearOnInit,
-      syncServer: {
-        host: "",
-        room: ""
-      }
-    }
-  });
-  const workerClient = createWorkerDbClient({
+      props: options.workerProps
+    },
     broadcastChannels
   });
   const hlcCounter = new HLCCounter(tabId, () => Date.now());
   const workerClientSnapshot = await workerClient.getSnapshot();
   const reactiveDb = await createSQLiteReactiveDb({
-    snapshot: workerClientSnapshot.file
+    snapshot: workerClientSnapshot.file,
+    logger: defaultLogger
   });
+  const memoryDbMigrator = {
+    currentSchemaVersion: workerClientSnapshot.schemaVersion,
+    latestSchemaVersion: workerClientSnapshot.schemaVersion,
+    migrateDbToLatest: () => {
+      throw new Error("Memory DB migrations are not implemented");
+    },
+    migrateEvent: (event, targetVersion) => {
+      if (event.schema_version === targetVersion) {
+        return event;
+      }
+      throw new Error("Memory DB migrations are not implemented");
+    },
+    migrateEvents: (events) => events
+  };
   const { crdtStorage } = await createMemoryDb({
+    nodeId: tabId,
+    migrator: memoryDbMigrator,
     reactiveDb,
     hlcCounter,
-    tabId,
-    crdtTables: options.crdtTables
+    crdtTables: options.syncDbSchema.tablesConfig
   });
-  const remoteSyncId = createSyncIdCounter({
-    initialSyncId: workerClientSnapshot.syncId
+  const pullSyncId = createStoredValue({
+    initialValue: workerClientSnapshot.syncId
   });
-  const remoteSyncSource = createCrdtSyncRemoteSource({
-    bufferSize: 100,
-    syncId: remoteSyncId,
+  const pushSyncId = createStoredValue({
+    initialValue: 0
+  });
+  const tabRemoteSource = createCrdtSyncRemoteSource({
+    bufferSize: 500,
+    pullSyncId,
+    pushSyncId,
     storage: crdtStorage,
     nodeId: tabId,
-    pullEvents: (request) => workerClient.pullEvents(request),
-    pushEvents: (request) => workerClient.pushTabEvents(request)
-  });
-  workerClient.addEventListener("new-notification", (event) => {
-    const notification = event.payload;
-    if (notification.notificationType === "new-event-chunk-applied" && notification.newSyncId > remoteSyncId.current) {
-      remoteSyncSource.pullEvents();
-    }
-  });
-  crdtStorage.addEventListener("event-applied", (event) => {
-    if (event.payload.origin === "remote") {
-      hlcCounter.mergeHLC(deserializeHLC(event.payload.timestamp));
+    migrator: memoryDbMigrator,
+    remoteFactory: ({ onEventsAvailable }) => {
+      const onNewEventChunkApplied = (event) => {
+        onEventsAvailable(event.payload.newSyncId);
+      };
+      workerClient.addEventListener("new-event-chunk-applied", onNewEventChunkApplied);
+      return {
+        pullEvents: (request) => workerClient.pullEvents(request),
+        pushEvents: (request) => workerClient.pushTabEvents(request),
+        disconnect: () => {
+          workerClient.removeEventListener("new-event-chunk-applied", onNewEventChunkApplied);
+        }
+      };
     }
   });
+  tabRemoteSource.goOnline();
+  perf.logEnd("createSyncedDb", "initialized", "info");
+  let isDisposed = false;
+  const dispose = async () => {
+    if (isDisposed) return;
+    isDisposed = true;
+    clientLockRelease.resolve();
+    await tabRemoteSource.dispose();
+    broadcastChannels.requests.close();
+    broadcastChannels.responses.close();
+    workerClient.dispose();
+    reactiveDb.dispose();
+  };
   return {
-    db: reactiveDb.db,
-    reactiveDb,
-    workerDb: workerClient
+    db: {
+      execute: reactiveDb.db.execute.bind(reactiveDb.db),
+      executeKysely: reactiveDb.db.executeKysely.bind(reactiveDb.db),
+      executeTransaction: reactiveDb.db.executeTransaction.bind(reactiveDb.db),
+      createLiveQuery: reactiveDb.createLiveQuery.bind(reactiveDb)
+    },
+    state: {
+      getState: workerClient.getState.bind(workerClient),
+      subscribe: (onChange) => {
+        workerClient.addEventListener("state-changed", onChange);
+        return () => {
+          workerClient.removeEventListener("state-changed", onChange);
+        };
+      },
+      goOnline: workerClient.goOnline.bind(workerClient),
+      goOffline: workerClient.goOffline.bind(workerClient)
+    },
+    dispose,
+    _internal: {
+      executeAsync: workerClient.execute.bind(workerClient)
+    }
   };
 }
 export {
   HLCCounter,
   SQLiteDbWrapper,
   SQLiteReactiveDb,
-  SqliteDriver,
   TypedBroadcastChannel,
   TypedEvent,
-  applyCrdtEventMutations,
+  applyKyselyEventsBatchFilters,
   applyMemoryDbSchema,
   applyWorkerDbSchema,
-  broadcastChannelNames,
+  baseSystemMigrations,
   compareHLC,
-  crdtSchema,
-  createAsyncAutoFlushBuffer,
-  createAutoFlushBuffer,
-  createBroadcastChannels,
+  createCrdtApplyFunction,
   createCrdtStorage,
+  createCrdtStorageMutator,
   createCrdtSyncProducer,
   createCrdtSyncRemoteSource,
   createDeferredPromise,
-  createMemoryDb,
-  createSQLiteKysely,
-  createSQLiteReactiveDb,
-  createSyncDbMigrations,
-  createSyncDbMigrator,
-  createSyncIdCounter,
+  createKvStoreTableQuery,
+  createMigrations,
+  createMigrator,
+  createSQLiteCrdtApplyFunction,
+  createSQLiteKvStore,
+  createStoredValue,
+  createSyncDbSchema,
   createSyncedDb,
   createTypedEventTarget,
-  createWorkerDbClient,
   deserializeHLC,
   dummyKysely,
-  ensureSingletonExecution,
   generateId,
-  initializeWorkerDb,
   introspectDb,
-  isWorkerInitMessage,
-  isWorkerInitResponse,
-  isWorkerNotificationMessage,
-  isWorkerRequestMessage,
-  isWorkerResponseMessage,
   jsonSafeParse,
   makeCrdtTable,
-  orderBy,
-  registerCrdtFunctions,
+  quoteId,
+  runSystemMigrations,
   serializeHLC,
   startPerformanceLogger,
-  syncDbWorkerLockName
+  tryCatch,
+  tryCatchAsync
 };
 //# sourceMappingURL=index.js.map