@sqlite-sync/core 0.1.1 → 0.3.0

package/dist/index.d.ts

@@ -1,14 +1,20 @@
 import * as kysely from 'kysely';
-import { Kysely, SchemaModule, SelectQueryBuilder } from 'kysely';
-import { S as SQLiteDbWrapper, L as Logger, T as TypedEvent, a as SQLiteTransactionWrapper, b as StoredValue, C as CrdtStorage, P as PersistedCrdtEvent, G as GetEventsOptions, E as ExecuteParams, c as ExecuteResult, Q as QueryBuilderOutput, K as KyselyQueryFactory, W as WorkerState } from './crdt-sync-remote-source-idoIjMcs.js';
-export { z as CrdtEventOrigin, A as CrdtEventStatus, B as CrdtEventType, u as CrdtSyncRemoteSource, F as CrdtUpdateLogItem, I as CrdtUpdateLogPayload, D as DatabaseIntrospection, U as DeferredPromise, V as DistributiveOmit, w as EventsPullRequest, x as EventsPushRequest, y as EventsPushResponse, H as HLC, f as HLCCounter, h as LogLevel, M as MigratableEvent, m as Migrations, n as MigrationsDb, r as PendingCrdtEvent, N as PreparedStatement, o as SyncDbMigrator, g as TableMetadata, _ as TypedBroadcastChannel, $ as TypedEventTarget, a2 as WorkerConfig, d as compareHLC, p as createCrdtApplyFunction, t as createCrdtStorage, v as createCrdtSyncRemoteSource, O as createDeferredPromise, k as createMigrations, l as createMigrator, q as createSQLiteCrdtApplyFunction, J as createStoredValue, R as createTypedEventTarget, e as deserializeHLC, X as generateId, i as introspectDb, Y as jsonSafeParse, Z as quoteId, s as serializeHLC, j as startPerformanceLogger, a0 as tryCatch, a1 as tryCatchAsync } from './crdt-sync-remote-source-idoIjMcs.js';
-import { S as SyncDbSchema } from './crdt-schema-DQ1cYsFE.js';
-export { C as CreateCrdtSchemaOptions, c as createSyncDbSchema } from './crdt-schema-DQ1cYsFE.js';
+import { Kysely, SchemaModule } from 'kysely';
+import { S as SQLiteDbWrapper, L as Logger, T as TypedEvent, I as InternalSQLiteWrapper, a as StoredValue, C as CrdtStorage, E as ExecuteParams, b as ExecuteResult, Q as QueryBuilderOutput, K as KyselyQueryFactory, c as SQLiteTransactionWrapper, W as WorkerState, D as DeSyncDetectedReason } from './crdt-sync-remote-source-Da77s4k0.js';
+export { R as CRDT_EVENT_NO_OP_PAYLOAD, U as CrdtEventOrigin, V as CrdtEventStatus, X as CrdtEventType, F as CrdtSyncRemoteSource, Y as CrdtUpdateLogItem, Z as CrdtUpdateLogPayload, g as DatabaseIntrospection, a5 as DeferredPromise, a6 as DistributiveOmit, J as EventsPullRequest, N as EventsPushRequest, O as EventsPushResponse, H as HLC, f as HLCCounter, a1 as KyselyStatementFactory, j as LogLevel, M as MigratableEvent, n as Migrations, o as MigrationsDb, P as PendingCrdtEvent, $ as PersistedCrdtEvent, a2 as PreparedStatement, p as SyncDbMigrator, w as SystemDbConfig, x as SystemMigration, y as SystemMigrationContext, h as TableMetadata, aa as TypedBroadcastChannel, ab as TypedEventTarget, ae as WorkerConfig, q as applyMemoryDbSchema, r as applyWorkerDbSchema, t as baseSystemMigrations, d as compareHLC, z as createCrdtApplyFunction, B as createCrdtStorage, G as createCrdtSyncRemoteSource, a3 as createDeferredPromise, l as createMigrations, m as createMigrator, A as createSQLiteCrdtApplyFunction, a0 as createStoredValue, u as createSystemDbConfig, a4 as createTypedEventTarget, e as deserializeHLC, a7 as generateId, i as introspectDb, _ as isNoOpCrdtEventPayload, a8 as jsonSafeParse, a9 as quoteId, v as runSystemMigrations, s as serializeHLC, k as startPerformanceLogger, ac as tryCatch, ad as tryCatchAsync } from './crdt-sync-remote-source-Da77s4k0.js';
+import { S as SyncDbSchema, C as CrdtTableConfig } from './reset-state-0LGwO78x.js';
+export { a as CreateCrdtSchemaOptions, R as RESET_REQUEST_TTL_MS, b as ResetRequest, d as ResetStore, c as createSyncDbSchema } from './reset-state-0LGwO78x.js';
 import '@sqlite.org/sqlite-wasm';
 
 declare const dummyKysely: Kysely<any>;
 
-type TableName<Database> = keyof Database extends string ? keyof Database : never;
+declare function ensureLoaded(): Promise<void>;
+declare function h64(input: string, seed?: bigint): bigint;
+declare const xxhash: {
+    ensureLoaded: typeof ensureLoaded;
+    h64: typeof h64;
+};
+
 type SQLiteReactiveDbOptions = {
     snapshot: Uint8Array<ArrayBufferLike>;
     logger: Logger;
@@ -51,7 +57,7 @@ declare class SQLiteReactiveDb<Database> {
     private getClearedTables;
     addEventListener<K extends keyof EventsMap>(type: K, listener: (event: TypedEvent<EventsMap[K]>) => void): void;
     removeEventListener<K extends keyof EventsMap>(type: K, listener: (event: TypedEvent<EventsMap[K]>) => void): void;
-    notifyTableSubscribers(tables?: (TableName<Database> | (string & {}))[]): void;
+    private notifyTableSubscribers;
     private registerDbHooks;
     createSnapshot(): Uint8Array<ArrayBuffer>;
     useSnapshot(snapshot: Uint8Array<ArrayBufferLike>): void;
@@ -63,8 +69,8 @@ type KvStoreItem = {
     value: string;
 };
 declare function createKvStoreTableQuery(schema: SchemaModule, tableName: string): kysely.CreateTableBuilder<string, "key" | "value">;
-declare function createSQLiteKvStore({ db, metaTableName, }: {
-    db: SQLiteTransactionWrapper<any>;
+declare function createSQLiteKvStore({ db, metaTableName }: {
+    db: InternalSQLiteWrapper<any>;
     metaTableName: string;
 }): {
     get: (key: string) => string | null;
@@ -74,27 +80,6 @@ declare function createSQLiteKvStore({ db, metaTableName, }: {
     createNumberStoredValue: (key: string, defaultValue: number) => StoredValue<number>;
 };
 
-type SystemMigrationContext = {
-    eventsTableName: string;
-    updateLogTableName: string;
-    execute: (sql: string) => void;
-};
-type SystemMigration = {
-    version: number;
-    up: (ctx: SystemMigrationContext) => void;
-};
-declare const baseSystemMigrations: SystemMigration[];
-declare function runSystemMigrations(opts: {
-    version: StoredValue<number>;
-    migrations: SystemMigration[];
-    eventsTableName: string;
-    updateLogTableName: string;
-    execute: (sql: string) => void;
-    transaction: (callback: () => void) => void;
-}): void;
-declare function applyWorkerDbSchema(db: SQLiteDbWrapper<any>): void;
-declare function applyMemoryDbSchema(db: SQLiteDbWrapper<any>): void;
-
 type CrdtStorageMutator<Database> = ReturnType<typeof createCrdtStorageMutator<Database>>;
 type CommitEventOptions<Database, Table extends keyof Database & string> = {
     type: "item-created";
@@ -125,12 +110,11 @@ type CrdtSyncProducer = {
     storage: CrdtStorage;
     broadcastEvents: (request: {
         newSyncId: number;
+        eventHlcSum: string | null;
     }) => void;
 };
 declare const createCrdtSyncProducer: ({ storage, broadcastEvents }: CrdtSyncProducer) => void;
 
-declare function applyKyselyEventsBatchFilters(query: SelectQueryBuilder<any, any, PersistedCrdtEvent>, opts: GetEventsOptions): SelectQueryBuilder<any, any, PersistedCrdtEvent>;
-
 declare function makeCrdtTable({ db, baseTableName, crdtTableName, }: {
     db: SQLiteDbWrapper<any>;
     baseTableName: string;
@@ -139,7 +123,6 @@ declare function makeCrdtTable({ db, baseTableName, crdtTableName, }: {
 
 type SyncedDbOptions<Database, Props = undefined> = {
     dbId: string;
-    clearOnInit?: boolean;
     worker: Worker;
     workerProps: Props;
     syncDbSchema: SyncDbSchema<Database>;
@@ -168,11 +151,60 @@ declare function createSyncedDb<Database, Props = undefined>(options: SyncedDbOp
         goOnline: () => Promise<void>;
         goOffline: () => Promise<void>;
     };
+    /**
+     * Ask the elected worker to broadcast a page reload to all tabs for this dbId.
+     *
+     * With `clean: true` the worker durably records a reset request epoch before
+     * broadcasting, so the worker elected on the next startup initializes with
+     * `clearOnInit: true` and wipes the persisted DB. Destructive — use as a
+     * recovery path when the durable worker DB may be de-synced.
+     *
+     * Pending in-memory tab events are not preserved, and the returned promise
+     * may never settle in the caller — the page typically unloads first.
+     */
+    requestReload: (options: {
+        clean: boolean;
+    }) => Promise<void>;
+    subscribe: <K extends "new-event-chunk-applied" | "state-changed" | "reload-requested" | "de-sync-detected" | "remote-schema-version-mismatch">(type: K, listener: (event: TypedEvent<{
+        "new-event-chunk-applied": {
+            notificationType: "new-event-chunk-applied";
+            newSyncId: number;
+            eventHlcSum: string | null;
+        };
+        "state-changed": {
+            notificationType: "state-changed";
+            state: WorkerState;
+        };
+        "reload-requested": {
+            notificationType: "reload-requested";
+            reloadEpoch: string;
+            clean: boolean;
+        };
+        "de-sync-detected": {
+            notificationType: "de-sync-detected";
+            reason: DeSyncDetectedReason;
+        };
+        "remote-schema-version-mismatch": {
+            notificationType: "remote-schema-version-mismatch";
+            remoteSchemaVersion: number;
+            localSchemaVersion: number;
+        };
+    }[K]>) => void) => {
+        unsubscribe: () => void;
+    };
     dispose: () => Promise<void>;
     _internal: {
         executeAsync: (query: ExecuteParams) => Promise<ExecuteResult<unknown>>;
+        getMemoryQueryTables: (query: string) => {
+            name: string;
+            isWrite: boolean;
+        }[];
+        crdtTableNames: string[];
+        crdtTablesConfig: CrdtTableConfig[];
+        schemaVersion: number;
+        migrationVersions: number[];
     };
 }>;
 type SyncedDb<Database> = Awaited<ReturnType<typeof createSyncedDb<Database>>>;
 
-export { CrdtStorage, type CrdtStorageMutator, ExecuteParams, ExecuteResult, type KvStoreItem, KyselyQueryFactory, Logger, PersistedCrdtEvent, QueryBuilderOutput, SQLiteDbWrapper, SQLiteReactiveDb, SQLiteTransactionWrapper, StoredValue, SyncDbSchema, type SyncedDb, type SystemMigration, type SystemMigrationContext, TypedEvent, WorkerState, applyKyselyEventsBatchFilters, applyMemoryDbSchema, applyWorkerDbSchema, baseSystemMigrations, createCrdtStorageMutator, createCrdtSyncProducer, createKvStoreTableQuery, createSQLiteKvStore, createSyncedDb, dummyKysely, makeCrdtTable, runSystemMigrations };
+export { CrdtStorage, type CrdtStorageMutator, ExecuteParams, ExecuteResult, InternalSQLiteWrapper, type KvStoreItem, KyselyQueryFactory, Logger, QueryBuilderOutput, SQLiteDbWrapper, SQLiteReactiveDb, SQLiteTransactionWrapper, StoredValue, SyncDbSchema, type SyncedDb, TypedEvent, WorkerState, createCrdtStorageMutator, createCrdtSyncProducer, createKvStoreTableQuery, createSQLiteKvStore, createSyncedDb, dummyKysely, makeCrdtTable, xxhash };

package/dist/index.js

@@ -1,7 +1,8 @@
 import {
+  CRDT_EVENT_NO_OP_PAYLOAD,
   HLCCounter,
+  RESET_REQUEST_TTL_MS,
   SQLiteDbWrapper,
-  applyKyselyEventsBatchFilters,
   applyMemoryDbSchema,
   applyWorkerDbSchema,
   baseSystemMigrations,
@@ -17,17 +18,21 @@ import {
   createSQLiteCrdtApplyFunction,
   createSQLiteKvStore,
   createStoredValue,
+  createSystemDbConfig,
   deserializeHLC,
   dummyKysely,
   introspectDb,
+  isNoOpCrdtEventPayload,
   isWorkerErrorResponseMessage,
   isWorkerNotificationMessage,
   isWorkerResponseMessage,
+  memoryDbConfig,
   runSystemMigrations,
   serializeHLC,
   startPerformanceLogger,
-  syncDbClientLockName
-} from "./chunk-627DSM2Q.js";
+  syncDbClientLockName,
+  xxhash
+} from "./chunk-RKBTBPNC.js";
 import {
   TypedBroadcastChannel,
   TypedEvent,
@@ -35,10 +40,11 @@ import {
   createTypedEventTarget,
   generateId,
   jsonSafeParse,
+  noop,
   quoteId,
   tryCatch,
   tryCatchAsync
-} from "./chunk-UGF5IU53.js";
+} from "./chunk-NHT3ELMN.js";
 
 // src/memory-db/sqlite-reactive-db.ts
 import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
@@ -245,8 +251,8 @@ var SQLiteReactiveDb = class _SQLiteReactiveDb {
   removeEventListener(type, listener) {
     this.eventTarget.removeEventListener(type, listener);
   }
-  notifyTableSubscribers(tables = []) {
-    if (tables.length === 0) {
+  notifyTableSubscribers(tables = null) {
+    if (!tables) {
       this.eventTarget.dispatchEvent("any-table-changed", void 0);
       return;
     }
@@ -255,7 +261,7 @@ var SQLiteReactiveDb = class _SQLiteReactiveDb {
     }
   }
   registerDbHooks() {
-    const updateQueue = /* @__PURE__ */ new Set();
+    let updateQueue = /* @__PURE__ */ new Set();
     this.sqlite3.capi.sqlite3_update_hook(
       this.db.ensureDb,
       (_ctx, _opId, _db, table) => {
@@ -281,8 +287,8 @@ var SQLiteReactiveDb = class _SQLiteReactiveDb {
         if (updateQueue.size === 0) {
           return 0;
         }
-        const tables = Array.from(updateQueue);
-        updateQueue.clear();
+        const tables = updateQueue;
+        updateQueue = /* @__PURE__ */ new Set();
         this.eventTarget.dispatchEvent("transaction-committed", void 0);
         queueMicrotask(() => {
           this.notifyTableSubscribers(tables);
@@ -393,10 +399,10 @@ function createCrdtStorageMutator({ storage }) {
         };
       case "item-deleted":
         return {
-          type: "item-updated",
+          type: "item-deleted",
           dataset: event.dataset,
           item_id: event.item_id,
-          payload: JSON.stringify({ tombstone: 1 })
+          payload: "{}"
         };
     }
   };
@@ -531,7 +537,13 @@ function registerCrdtFunctions({
     directOnly: false,
     innocuous: false,
     callback: (dataset, oldPayloadRaw, newPayloadRaw) => {
+      if (oldPayloadRaw === newPayloadRaw) {
+        return void 0;
+      }
       const tableSchema = reactiveDb.db.dbSchema[dataset];
+      if (!tableSchema?.columns) {
+        throw new Error(`Schema not found for dataset: ${dataset}`);
+      }
       const oldPayload = JSON.parse(oldPayloadRaw);
       const newPayload = JSON.parse(newPayloadRaw);
       let hasDiff = false;
@@ -542,6 +554,11 @@ function registerCrdtFunctions({
         if (oldValue === newValue) {
           continue;
         }
+        if (column.name === "id") {
+          throw new Error(
+            `Cannot update the "id" column of an item. It is used to identify the item and must be immutable.`
+          );
+        }
         hasDiff = true;
         updatePayload[column.name] = newValue;
       }
@@ -571,10 +588,10 @@ function registerCrdtFunctions({
     callback: (dataset, itemId) => {
       storage.applyOwnEvent(
         {
-          type: "item-updated",
+          type: "item-deleted",
           dataset,
           item_id: itemId,
-          payload: JSON.stringify({ tombstone: 1 })
+          payload: "{}"
         },
         {
           wrapInTransaction: false
@@ -603,40 +620,88 @@ function validateDbId(dbId) {
   }
 }
 
+// src/devtools-registry.ts
+var devtoolsRegistrySymbol = Symbol.for("@sqlite-sync/devtools");
+function createSQLiteSyncDevtoolsRegistry() {
+  const instances = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = {
+    instances: []
+  };
+  const notify = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const updateSnapshot = () => {
+    snapshot = {
+      instances: Array.from(instances.values())
+    };
+    notify();
+  };
+  return {
+    version: 1,
+    instances,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot() {
+      return snapshot;
+    },
+    register(instance) {
+      instances.set(instance.instanceId, instance);
+      updateSnapshot();
+      let isUnregistered = false;
+      return () => {
+        if (isUnregistered) return;
+        isUnregistered = true;
+        if (!instances.delete(instance.instanceId)) return;
+        updateSnapshot();
+      };
+    }
+  };
+}
+function getOrCreateSQLiteSyncDevtoolsRegistry() {
+  const registryGlobal = globalThis;
+  registryGlobal[devtoolsRegistrySymbol] ??= createSQLiteSyncDevtoolsRegistry();
+  return registryGlobal[devtoolsRegistrySymbol];
+}
+
 // src/memory-db/memory-db.ts
 async function createMemoryDb({
   nodeId,
   migrator,
   reactiveDb: _reactiveDb,
   hlcCounter,
-  crdtTables
+  crdtTables,
+  initializeSchema = true,
+  initialSyncId,
+  eventHlcAccumulator
 }) {
+  await xxhash.ensureLoaded();
   const reactiveDb = _reactiveDb;
   const db = reactiveDb.db;
-  applyMemoryDbSchema(db);
-  for (const table of crdtTables) {
-    makeCrdtTable({
-      db,
-      baseTableName: table.baseTableName,
-      crdtTableName: table.crdtTableName
-    });
+  if (initializeSchema) {
+    applyMemoryDbSchema(db);
+    for (const table of crdtTables) {
+      makeCrdtTable({
+        db,
+        baseTableName: table.baseTableName,
+        crdtTableName: table.crdtTableName
+      });
+    }
   }
-  const localSyncId = createStoredValue({
-    initialValue: 0
-  });
   const crdtStorage = createCrdtStorage({
     nodeId,
-    syncId: localSyncId,
+    initialLocalSyncId: initialSyncId ?? getCurrentSyncId(db),
     hlc: hlcCounter,
-    persistEvent: (event) => persistEvent(db, event),
-    getEventsBatch: (opts) => getEventsBatch(db, opts),
     migrator,
-    handleCrdtEventApply: createSQLiteCrdtApplyFunction({
-      db,
-      updateLogTableName: "crdt_update_log"
-    }),
-    updateEvent: (syncId, update) => updateEvent(db, syncId, update),
-    transaction: (callback) => db.executeTransaction(callback)
+    db,
+    dbConfig: memoryDbConfig,
+    eventHlcAccumulator
   });
   registerCrdtFunctions({
     reactiveDb,
@@ -646,48 +711,10 @@ async function createMemoryDb({
     crdtStorage
   };
 }
-function persistEvent(db, event) {
-  db.executePrepared(
-    "persist-crdt-event",
-    event,
-    (db2, params) => db2.insertInto("persisted_crdt_events").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" }
-  );
-}
-function getEventsBatch(db, opts) {
-  return db.executeKysely(
-    (db2) => applyKyselyEventsBatchFilters(db2.selectFrom("persisted_crdt_events").selectAll(), {
-      limit: 50,
-      ...opts
-    }),
-    { loggerLevel: "system" }
-  ).rows;
-}
-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" }
-  );
+function getCurrentSyncId(db) {
+  return db.execute("SELECT coalesce(max(sync_id), 0) AS syncId FROM persisted_crdt_events", {
+    loggerLevel: "system"
+  }).rows[0]?.syncId ?? 0;
 }
 
 // src/worker-db/db-worker-client.ts
@@ -751,12 +778,12 @@ var createWorkerDbClient = async ({
     pullEvents: (params) => queryWorker("pullEvents", [params]),
     postState: () => queryWorker("postState", []),
     goOnline: () => queryWorker("goOnline", []),
-    goOffline: () => queryWorker("goOffline", [])
+    goOffline: () => queryWorker("goOffline", []),
+    requestReload: (options) => queryWorker("requestReload", [options])
   };
   const statePromise = awaitWorkerState(eventTarget);
   postWorkerConfig(worker, config);
-  rpc.postState().catch(() => {
-  });
+  rpc.postState().catch(noop);
   let workerState = await statePromise;
   eventTarget.addEventListener("state-changed", (event) => {
     workerState = event.payload.state;
@@ -771,19 +798,17 @@ var createWorkerDbClient = async ({
   };
   return {
     ...rpc,
-    addEventListener: eventTarget.addEventListener,
-    removeEventListener: eventTarget.removeEventListener,
+    subscribe: eventTarget.addEventListener,
     getState: () => workerState,
     dispose
   };
 };
 function awaitWorkerState(eventTarget) {
   const promise = createDeferredPromise({ timeout: 15e3 });
-  const onStateChanged = (event) => {
+  const subscription = eventTarget.addEventListener("state-changed", (event) => {
     promise.resolve(event.payload.state);
-    eventTarget.removeEventListener("state-changed", onStateChanged);
-  };
-  eventTarget.addEventListener("state-changed", onStateChanged);
+    subscription.unsubscribe();
+  });
   return promise.promise;
 }
 function postWorkerConfig(worker, config) {
@@ -815,6 +840,7 @@ var defaultLogger = (type, message, level = "info") => {
 async function createSyncedDb(options) {
   validateDbId(options.dbId);
   const perf = startPerformanceLogger(defaultLogger);
+  const instanceId = generateId();
   const tabId = generateId();
   const broadcastChannels = createBroadcastChannels(options.dbId);
   const clientLockAcquired = createDeferredPromise();
@@ -829,7 +855,6 @@ async function createSyncedDb(options) {
     config: {
       clientId: generateId(),
       dbId: options.dbId,
-      clearOnInit: options.clearOnInit,
       props: options.workerProps
     },
     broadcastChannels
@@ -875,25 +900,30 @@ async function createSyncedDb(options) {
     nodeId: tabId,
     migrator: memoryDbMigrator,
     remoteFactory: ({ onEventsAvailable }) => {
-      const onNewEventChunkApplied = (event) => {
-        onEventsAvailable(event.payload.newSyncId);
-      };
-      workerClient.addEventListener("new-event-chunk-applied", onNewEventChunkApplied);
+      const subscription = workerClient.subscribe("new-event-chunk-applied", (event) => {
+        onEventsAvailable({ newSyncId: event.payload.newSyncId, remoteEventHlcSum: event.payload.eventHlcSum });
+      });
       return {
         pullEvents: (request) => workerClient.pullEvents(request),
         pushEvents: (request) => workerClient.pushTabEvents(request),
         disconnect: () => {
-          workerClient.removeEventListener("new-event-chunk-applied", onNewEventChunkApplied);
+          subscription.unsubscribe();
         }
       };
     }
   });
   tabRemoteSource.goOnline();
+  const reloadRequestedSubscription = workerClient.subscribe("reload-requested", () => {
+    globalThis.location?.reload();
+  });
   perf.logEnd("createSyncedDb", "initialized", "info");
   let isDisposed = false;
+  let unregisterDevtools;
   const dispose = async () => {
     if (isDisposed) return;
     isDisposed = true;
+    unregisterDevtools?.();
+    reloadRequestedSubscription.unsubscribe();
     clientLockRelease.resolve();
     await tabRemoteSource.dispose();
     broadcastChannels.requests.close();
@@ -901,7 +931,7 @@ async function createSyncedDb(options) {
     workerClient.dispose();
     reactiveDb.dispose();
   };
-  return {
+  const syncedDb = {
     db: {
       execute: reactiveDb.db.execute.bind(reactiveDb.db),
       executeKysely: reactiveDb.db.executeKysely.bind(reactiveDb.db),
@@ -911,27 +941,54 @@ async function createSyncedDb(options) {
     state: {
       getState: workerClient.getState.bind(workerClient),
       subscribe: (onChange) => {
-        workerClient.addEventListener("state-changed", onChange);
-        return () => {
-          workerClient.removeEventListener("state-changed", onChange);
-        };
+        const { unsubscribe } = workerClient.subscribe("state-changed", onChange);
+        return unsubscribe;
       },
       goOnline: workerClient.goOnline.bind(workerClient),
       goOffline: workerClient.goOffline.bind(workerClient)
     },
+    /**
+     * Ask the elected worker to broadcast a page reload to all tabs for this dbId.
+     *
+     * With `clean: true` the worker durably records a reset request epoch before
+     * broadcasting, so the worker elected on the next startup initializes with
+     * `clearOnInit: true` and wipes the persisted DB. Destructive — use as a
+     * recovery path when the durable worker DB may be de-synced.
+     *
+     * Pending in-memory tab events are not preserved, and the returned promise
+     * may never settle in the caller — the page typically unloads first.
+     */
+    requestReload: async (options2) => {
+      await workerClient.requestReload(options2);
+      setTimeout(() => globalThis.location?.reload(), 250);
+    },
+    subscribe: workerClient.subscribe,
     dispose,
     _internal: {
-      executeAsync: workerClient.execute.bind(workerClient)
+      executeAsync: workerClient.execute.bind(workerClient),
+      getMemoryQueryTables: reactiveDb.getTablesUsed.bind(reactiveDb),
+      crdtTableNames: options.syncDbSchema.tablesConfig.map((table) => table.crdtTableName),
+      crdtTablesConfig: options.syncDbSchema.tablesConfig,
+      schemaVersion: workerClientSnapshot.schemaVersion,
+      migrationVersions: Object.keys(options.syncDbSchema.migrations).map(Number).sort((a, b) => a - b)
     }
   };
+  unregisterDevtools = getOrCreateSQLiteSyncDevtoolsRegistry().register({
+    instanceId,
+    dbId: options.dbId,
+    createdAt: Date.now(),
+    instance: syncedDb
+  });
+  return syncedDb;
 }
 export {
+  CRDT_EVENT_NO_OP_PAYLOAD,
   HLCCounter,
+  RESET_REQUEST_TTL_MS,
   SQLiteDbWrapper,
   SQLiteReactiveDb,
   TypedBroadcastChannel,
   TypedEvent,
-  applyKyselyEventsBatchFilters,
   applyMemoryDbSchema,
   applyWorkerDbSchema,
   baseSystemMigrations,
@@ -950,11 +1007,13 @@ export {
   createStoredValue,
   createSyncDbSchema,
   createSyncedDb,
+  createSystemDbConfig,
   createTypedEventTarget,
   deserializeHLC,
   dummyKysely,
   generateId,
   introspectDb,
+  isNoOpCrdtEventPayload,
   jsonSafeParse,
   makeCrdtTable,
   quoteId,
@@ -962,6 +1021,7 @@ export {
   serializeHLC,
   startPerformanceLogger,
   tryCatch,
-  tryCatchAsync
+  tryCatchAsync,
+  xxhash
 };
 //# sourceMappingURL=index.js.map