@sqlite-sync/core 0.12.3 → 0.13.0

package/dist/{index-BHsKLqcK.d.ts → index-CH4lf3iX.d.ts}

@@ -1,5 +1,5 @@
 import { ColumnDataType, ColumnDefinitionBuilderCallback, ColumnType, Compilable, CompiledQuery, CreateIndexBuilder, CreateTableBuilder, Expression, Kysely, SchemaModule } from "kysely";
-import { Database, FunctionOptions, SqlValue, Sqlite3Static } from "@sqlite.org/sqlite-wasm";
+import { Database, Sqlite3Static } from "@sqlite.org/sqlite-wasm";
 //#region src/dummy-kysely.d.ts
 declare const dummyKysely: Kysely<any>;
 //#endregion
@@ -182,7 +182,7 @@ declare class ColumnBuilder<Value, HasDefault extends boolean = false> {
   constructor(meta: ColumnMeta);
   /** Allow SQL NULL; widens the value type with `null`. */
   nullable(): ColumnBuilder<Value | null, HasDefault>;
-  /** Declare a column default. The value is used both in DDL and when migrating older events. */
+  /** Declare a column default. Creates may omit the column; it must match the migrated DDL default. */
   default(value: Value): ColumnBuilder<Value, true>;
   /** Narrow the TypeScript value type without changing storage, e.g. `t.text().$type<"movie" | "tv">()`. */
   $type<Narrowed extends Value>(): ColumnBuilder<Narrowed, HasDefault>;
@@ -329,6 +329,52 @@ type PerformanceLogger = {
 };
 declare const startPerformanceLogger: (logger: Logger | undefined, level?: LogLevel) => PerformanceLogger;
 //#endregion
+//#region src/sqlite-driver.d.ts
+type SqliteDriverValue = string | number | bigint | Uint8Array | null;
+type SqliteDriverRows = {
+  columns: string[];
+  rows: SqliteDriverValue[][];
+};
+type SqliteDriverStatement = {
+  /** Binds, steps to completion and resets the statement. Must run synchronously. */
+  run: (parameters: readonly unknown[]) => SqliteDriverRows;
+  finalize: () => void;
+  /**
+   * `sqlite3_stmt_readonly`. Drivers that cannot report it leave it undefined
+   * and the wrapper classifies the statement through `tables_used`.
+   */
+  readonly?: boolean;
+};
+type SqliteDriverHooks = {
+  onUpdate: (table: string) => void;
+  onCommit: () => void;
+  onRollback: () => void;
+};
+type SqliteDriver = {
+  prepare: (sql: string) => SqliteDriverStatement;
+  totalChanges: () => number;
+  /**
+   * Installs update/commit/rollback hooks. Pass `null` to remove them.
+   *
+   * Hooks may be delivered after the statement that caused them returns, but
+   * they must be delivered in the order SQLite raised them.
+   */
+  setHooks: (hooks: SqliteDriverHooks | null) => void;
+  /** Whether hooks run inside the statement that raised them, before it returns. */
+  readonly synchronousHooks: boolean;
+  close: () => void;
+  serialize?: () => Uint8Array<ArrayBufferLike>;
+  deserialize?: (snapshot: Uint8Array<ArrayBufferLike>) => void;
+  createScalarFunction?: (options: {
+    name: string;
+    callback: (...args: SqliteDriverValue[]) => SqliteDriverValue | undefined;
+    arity: number;
+    deterministic?: boolean;
+    directOnly?: boolean;
+    innocuous?: boolean;
+  }) => void;
+};
+//#endregion
 //#region src/sqlite-db-wrapper.d.ts
 type ExecuteParams = {
   sql: string;
@@ -342,15 +388,17 @@ type PreparedStatement<TParams extends unknown[], TResult> = {
   finalize: () => void;
   isFinalized: boolean;
 };
-type ScalarFunctionOptions<TArgs extends readonly SqlValue[], TResult extends SqlValue | undefined> = {
+type ScalarFunctionOptions<TArgs extends readonly SqliteDriverValue[], TResult extends SqliteDriverValue | undefined> = {
   name: string;
   callback: (...args: TArgs) => TResult;
-} & Pick<FunctionOptions, "deterministic" | "directOnly" | "innocuous">;
+  deterministic?: boolean;
+  directOnly?: boolean;
+  innocuous?: boolean;
+};
 type SqliteWrapperOptions = {
   logger?: Logger;
   loggerPrefix?: string;
-  sqlite3: Sqlite3Static;
-  db: () => Database;
+  driver: SqliteDriver;
 };
 type SQLiteTransactionWrapper<TDatabase = unknown> = Pick<SQLiteDbWrapper<TDatabase>, "sql" | "execute" | "executePrepared" | "executePreparedRaw" | "executeKysely">;
 type InternalSQLiteTransactionWrapper<TDatabase = unknown> = Pick<SQLiteDbWrapper<TDatabase>, "executePrepared" | "executePreparedRaw">;
@@ -367,24 +415,24 @@ type ExecuteOptions = QueryMetaOpts & {
   skipAfterMutatingStatement?: boolean;
 };
 declare class SQLiteDbWrapper<TDatabase = unknown> {
-  private db;
-  private sqlite3;
+  private driver;
   private logger?;
   private loggerPrefix?;
   private loadedDbSchema;
-  private readonly dataPointers;
   private preparedStatements;
   private preparedStatementsMap;
   private preparedRawStatementsMap;
+  private readonlyStatementCache;
   private afterMutatingStatement;
   constructor(opts: SqliteWrapperOptions);
-  get ensureDb(): Database;
+  get ensureDriver(): SqliteDriver;
   get dbSchema(): DatabaseIntrospection;
   private executeSql;
+  private isReadonlyStatement;
+  private isReadonlyByTablesUsed;
   execute<T = unknown>(opts: ExecuteParams | string | CompiledQuery<T>, options?: ExecuteOptions): ExecuteResult<T>;
   setAfterMutatingStatement(callback: AfterMutatingStatement<TDatabase>): void;
   executeTransaction<T>(callback: (db: SQLiteTransactionWrapper<TDatabase>) => T): T;
-  isInTransaction(): boolean;
   beginTransaction(): {
     commit: () => void;
     rollback: () => void;
@@ -401,9 +449,9 @@ declare class SQLiteDbWrapper<TDatabase = unknown> {
     meta?: QueryMetaOpts;
   }): TResult[];
   sql<T = unknown>(templateOrString: TemplateStringsArray | string, ...parameters: unknown[]): ExecuteResult<T>;
-  createScalarFunction<TArgs extends SqlValue[], TResult extends SqlValue | undefined>({ name, callback, deterministic, directOnly, innocuous }: ScalarFunctionOptions<TArgs, TResult>): Database;
+  createScalarFunction<TArgs extends SqliteDriverValue[], TResult extends SqliteDriverValue | undefined>({ name, callback, deterministic, directOnly, innocuous }: ScalarFunctionOptions<TArgs, TResult>): void;
   useSnapshot(snapshot: Uint8Array<ArrayBufferLike>): void;
-  createSnapshot(): Uint8Array<ArrayBuffer>;
+  createSnapshot(): Uint8Array<ArrayBufferLike>;
   invalidateDbSchema(): void;
   cleanup(): void;
   close(): void;
@@ -420,6 +468,42 @@ declare function compileKyselyStatement<TParams extends Record<string, unknown>,
   bindParameters: (parameters: TParams) => unknown[];
 };
 //#endregion
+//#region src/sqlite-crdt/state-hash.d.ts
+/**
+ * Persistence for the state hash. Reads and writes must go through the same
+ * transaction that changes the update log, so a rollback reverts both.
+ */
+type StateHashStore = {
+  read: () => string | null;
+  write: (value: string) => void;
+};
+/** Returns the hashed columns for a dataset, or null to hash whichever cells the update log holds. */
+type StateHashColumns = (dataset: string) => readonly string[] | null;
+type StateHashAccumulator = ReturnType<typeof createStateHashAccumulator>;
+/**
+ * The state hash is a sum of per-cell hashes over the CRDT update log, tagged with
+ * the schema version it was computed for. It depends only on current state, not on
+ * history, so replicas that converged agree on it no matter how they got there.
+ *
+ * Cells are the dataset's schema columns except `id`. A cell missing from the
+ * update log hashes as written by the item's latest create (the HLC stored under
+ * `id`). Older builds filled column defaults into creates migrated through an
+ * add-column migration, so replicas that replayed history hold such cells while
+ * replicas that applied the creates earlier never stored them.
+ */
+declare function createStateHashAccumulator({ sum, getColumns }: {
+  sum: bigint;
+  getColumns: StateHashColumns;
+}): {
+  readonly sum: bigint;
+  addItem(dataset: string, itemId: string, meta: CrdtUpdateLogPayload): void;
+  /**
+   * `meta` is the item's update log after the write. `replacedCells` holds each written
+   * cell's HLC from before it, and `previousCreateHlc` the item's create HLC from before.
+   */
+  updateItem(dataset: string, itemId: string, meta: CrdtUpdateLogPayload, previousCreateHlc: string | undefined, replacedCells: readonly [column: string, previousHlc: string | undefined][]): void;
+};
+//#endregion
 //#region src/sqlite-kv-store.d.ts
 type KvStoreItem = {
   key: string;
@@ -448,7 +532,7 @@ type DeferredPromiseOptions = {
   onTimeout?: () => void;
 };
 declare function createDeferredPromise<T>(opts?: DeferredPromiseOptions): DeferredPromise<T>;
-declare const generateId: () => `${string}-${string}-${string}-${string}-${string}`;
+declare const generateId: () => string;
 type DistributiveOmit<T, K extends keyof T> = T extends any ? Omit<T, K> : never;
 declare class TypedBroadcastChannel<TMessage> {
   private readonly channel;
@@ -457,7 +541,8 @@ declare class TypedBroadcastChannel<TMessage> {
   set onmessage(callback: ((event: MessageEvent<TMessage>) => void) | null);
   close(): void;
 }
-declare class TypedEvent<T = unknown> extends Event {
+declare class TypedEvent<T = unknown> {
+  readonly type: string;
   readonly payload: T;
   constructor(type: string, payload: T);
 }
@@ -468,6 +553,7 @@ type TypedEventTarget<T extends Record<string, unknown>> = {
   removeEventListener: <K extends keyof T & string>(type: K, listener: (event: TypedEvent<T[K]>) => void) => void;
   dispatchEvent: <K extends keyof T & string>(type: K, payload: T[K]) => void;
 };
+/** Follows EventTarget semantics without requiring the global, which React Native lacks. */
 declare const createTypedEventTarget: <T extends Record<string, unknown>>() => TypedEventTarget<T>;
 type TryCatchResult<T> = {
   success: true;
@@ -590,7 +676,7 @@ type DbSyncerStorage = {
   db: InternalSQLiteWrapper<any>;
   dbConfig: SystemDbConfig;
   hlc: StorageHLC;
-  eventHlcAccumulator?: StoredValue<string>;
+  stateHash?: StateHashStore;
   onEventApplied?: (event: PersistedCrdtEvent) => void;
   schema: Pick<SyncDbSchema, "tables" | "tablesConfig">;
 };
@@ -598,7 +684,7 @@ type CrdtStorage = Omit<ReturnType<typeof createCrdtStorage>, "internal">;
 type InternalCrdtStorage = ReturnType<typeof createCrdtStorage>;
 type EventsAppliedPayload = {
   syncId: number;
-  eventHlcSum: string | null;
+  stateHash: string | null;
 };
 type InternalDbSchema = {
   _crdt_events: PersistedCrdtEvent;
@@ -611,7 +697,7 @@ declare function createCrdtStorage(storage: DbSyncerStorage): {
   applyOwnEvents: (events: OwnCrdtEvent[]) => void;
   applyOwnSnapshot: (snapshot: OwnCrdtSnapshot) => void;
   checkIsQuiescent: (pushedSyncId: number) => boolean;
-  getEventHlcAccumulator: () => string | null;
+  getStateHash: () => string | null;
   addEventListener: <K extends "events-applied" | "remote-event-apply-failed">(type: K, listener: (event: TypedEvent<{
     "events-applied": EventsAppliedPayload;
     "remote-event-apply-failed": {
@@ -691,8 +777,10 @@ declare const xxhash: {
 //#endregion
 //#region src/memory-db/sqlite-reactive-db.d.ts
 type SQLiteReactiveDbOptions = {
-  snapshot: Uint8Array<ArrayBufferLike>;
+  driver: SqliteDriver;
+  snapshot?: Uint8Array<ArrayBufferLike>;
   logger: Logger;
+  loggerPrefix?: string;
 };
 type EventsMap = {
   "transaction-committed": undefined;
@@ -716,14 +804,20 @@ type SharedLiveQuerySnapshot = {
 };
 declare class SQLiteReactiveDb<Database> {
   readonly db: SQLiteDbWrapper<Database>;
-  private sqlite3;
+  private readonly driver;
   private readonly logger;
   private tablesUsedStatement;
   private eventTarget;
+  private isDisposed;
   private mutationVersion;
   private tableMutationVersions;
   private constructor();
-  static create<Database>(opts: SQLiteReactiveDbOptions): Promise<SQLiteReactiveDb<Database>>;
+  static create<Database>(opts: SQLiteReactiveDbOptions): SQLiteReactiveDb<Database>;
+  /**
+   * When false, table mutation versions only advance after the writing statement
+   * returns, so they cannot tell whether that statement wrote to a table.
+   */
+  get hasSynchronousHooks(): boolean;
   private liveQueryStatements;
   private sharedLiveQueries;
   createLiveQuery<TResult>(query: {
@@ -762,7 +856,7 @@ declare class SQLiteReactiveDb<Database> {
   getTableMutationVersion(table: string): number;
   private notifyTableSubscribers;
   private registerDbHooks;
-  createSnapshot(): Uint8Array<ArrayBuffer>;
+  createSnapshot(): Uint8Array<ArrayBufferLike>;
   useSnapshot(snapshot: Uint8Array<ArrayBufferLike>): void;
   dispose(): void;
 }
@@ -836,15 +930,15 @@ type SchemaVerificationIssue = {
 };
 /**
  * Verify that replaying the full migration history on a fresh database produces
- * exactly the declared table schema. Creates a throwaway in-memory SQLite db,
- * applies all migrations, introspects the result, and diffs it against the
- * `t.table()` declarations.
+ * exactly the declared table schema. Applies all migrations to `driver`, which
+ * must be an empty throwaway database (it is closed afterwards), introspects the
+ * result, and diffs it against the `t.table()` declarations.
  *
  * Returns an empty array when migrations and schema agree. Intended for dev-time
  * checks (`startDbWorker({ verifySchema: true })`) and tests:
  * `expect(await verifySyncSchema(syncDbSchema)).toEqual([])`.
  */
-declare function verifySyncSchema(schema: SyncDbSchema): Promise<SchemaVerificationIssue[]>;
+declare function verifySyncSchemaWithDriver(schema: SyncDbSchema, driver: SqliteDriver): SchemaVerificationIssue[];
 declare function formatSchemaVerificationIssues(issues: SchemaVerificationIssue[]): string;
 //#endregion
 //#region src/sqlite-crdt/apply-crdt-event.d.ts
@@ -855,11 +949,13 @@ type PendingCrdtEvent = {
   timestamp: string;
   payload: string;
 };
-declare const createSQLiteCrdtApplyFunction: ({ db, dbConfig }: {
+declare const createSQLiteCrdtApplyFunction: ({ db, dbConfig, getStateHash }: {
   db: InternalSQLiteWrapper<any>;
   dbConfig: SystemDbConfig;
+  getStateHash?: () => StateHashAccumulator | null;
 }) => (event: PendingCrdtEvent) => void;
 type CreateCrdtApplyOpts = {
+  getStateHash?: () => StateHashAccumulator | null;
   getCrdtUpdateLog: (opts: {
     itemId: string;
     dataset: string;
@@ -884,7 +980,7 @@ type CreateCrdtApplyOpts = {
     payload: string;
   }) => void;
 };
-declare function createCrdtApplyFunction({ getCrdtUpdateLog, insertItem, insertCrdtUpdateLog, updateItem, updateCrdtUpdateLog }: CreateCrdtApplyOpts): (event: PendingCrdtEvent) => void;
+declare function createCrdtApplyFunction({ getStateHash, getCrdtUpdateLog, insertItem, insertCrdtUpdateLog, updateItem, updateCrdtUpdateLog }: CreateCrdtApplyOpts): (event: PendingCrdtEvent) => void;
 //#endregion
 //#region src/sqlite-crdt/crdt-storage-mutator.d.ts
 type CrdtStorageMutator<Database> = ReturnType<typeof createCrdtStorageMutator<Database>>;
@@ -924,7 +1020,7 @@ type CrdtSyncProducer = {
   storage: CrdtStorage;
   broadcastEvents: (request: {
     newSyncId: number;
-    eventHlcSum: string | null;
+    stateHash: string | null;
   }) => void;
 };
 declare const createCrdtSyncProducer: ({ storage, broadcastEvents }: CrdtSyncProducer) => void;
@@ -933,8 +1029,8 @@ declare const createCrdtSyncProducer: ({ storage, broadcastEvents }: CrdtSyncPro
 type WorkerNotificationMessage = {
   notificationType: "new-event-chunk-applied";
   newSyncId: number;
-  /** Worker's HLC checksum after applying up to `newSyncId`. */
-  eventHlcSum: string | null;
+  /** Worker's state hash after applying up to `newSyncId`. */
+  stateHash: string | null;
 } | {
   notificationType: "state-changed";
   state: WorkerState;
@@ -952,6 +1048,9 @@ type WorkerNotificationMessage = {
   remoteSchemaVersion: number;
   localSchemaVersion: number;
 };
+type WorkerNotificationEvents = { [K in WorkerNotificationMessage["notificationType"]]: Extract<WorkerNotificationMessage, {
+  notificationType: K;
+}>; };
 type WorkerState = {
   remoteState: "online" | "offline" | "connecting";
   deSynced: boolean;
@@ -1005,7 +1104,7 @@ type EventsPushResponse = {
 type CrdtSyncRemoteSource = ReturnType<typeof createCrdtSyncRemoteSource>;
 type EventsAvailable = {
   newSyncId: number;
-  remoteEventHlcSum: string | null;
+  remoteStateHash: string | null;
 };
 /**
  * Opens one connection to the remote. Each call must return a new source: the library calls `disconnect` on every
@@ -1075,36 +1174,33 @@ declare const createCrdtSyncRemoteSource: ({ bufferSize, storage, migrator, pull
 //#endregion
 //#region src/sqlite-crdt/make-crdt-table.d.ts
 declare const CRDT_CHANGE_INTENTS_TABLE = "crdt_change_intents";
-declare function makeCrdtTable({ db, baseTableName, crdtTableName }: {
+declare function makeCrdtTable({ db, baseTableName, crdtTableName, temp }: {
   db: SQLiteDbWrapper<any>;
   baseTableName: string;
   crdtTableName: string;
+  temp?: boolean;
 }): void;
 type CrdtViewColumn = {
   name: string;
   nullable: boolean;
 };
 declare function crdtViewColumnsFromTable(table: AnyTableBuilder): CrdtViewColumn[];
-declare function createCrdtViewStatements({ baseTableName, crdtTableName, columns }: {
+declare function createCrdtViewStatements({ baseTableName, crdtTableName, columns, temp }: {
   baseTableName: string;
   crdtTableName: string;
   columns: CrdtViewColumn[];
+  /**
+   * Create the view, its triggers and the intents table in the connection's temp schema,
+   * so a persisted database never stores them and they always match the current schema.
+   */
+  temp?: boolean;
 }): string[];
 declare function drainCrdtChangeIntents({ tx, storage }: {
   tx: InternalSQLiteTransactionWrapper<any>;
   storage: InternalCrdtStorage;
 }): boolean;
 //#endregion
-//#region src/sync-db.d.ts
-type SyncedDbOptions<Database, Props = undefined> = {
-  dbId: string;
-  worker: Worker;
-  syncDbSchema: SyncDbSchema<Database>;
-} & (undefined extends Props ? {
-  workerProps?: Props;
-} : {
-  workerProps: Props;
-});
+//#region src/synced-db-database.d.ts
 /** SQL execution that participates in CRDT intent draining. */
 type SyncedDbSqlExecutor<Database> = {
   execute<TResult = unknown>(query: ExecuteParams | string | CompiledQuery<TResult>): ExecuteResult<TResult>;
@@ -1137,6 +1233,17 @@ type SyncedDbDatabase<Database> = SyncedDbSqlExecutor<Database> & {
     parameters: readonly unknown[];
   }): SharedLiveQuery<TResult>;
 };
+//#endregion
+//#region src/sync-db.d.ts
+type SyncedDbOptions<Database, Props = undefined> = {
+  dbId: string;
+  worker: Worker;
+  syncDbSchema: SyncDbSchema<Database>;
+} & (undefined extends Props ? {
+  workerProps?: Props;
+} : {
+  workerProps: Props;
+});
 declare function createSyncedDb<Database, Props = undefined>(options: SyncedDbOptions<Database, Props>): Promise<{
   db: SyncedDbDatabase<Database>;
   state: {
@@ -1160,32 +1267,7 @@ declare function createSyncedDb<Database, Props = undefined>(options: SyncedDbOp
   requestReload: (options: {
     clean: boolean;
   }) => Promise<void>;
-  subscribe: <K extends "state-changed" | "de-sync-detected" | "remote-schema-version-mismatch" | "new-event-chunk-applied" | "reload-requested">(type: K, listener: (event: TypedEvent<{
-    "state-changed": {
-      notificationType: "state-changed";
-      state: WorkerState;
-      storageGeneration: string;
-    };
-    "de-sync-detected": {
-      notificationType: "de-sync-detected";
-      reason: DeSyncDetectedReason;
-    };
-    "remote-schema-version-mismatch": {
-      notificationType: "remote-schema-version-mismatch";
-      remoteSchemaVersion: number;
-      localSchemaVersion: number;
-    };
-    "new-event-chunk-applied": {
-      notificationType: "new-event-chunk-applied";
-      newSyncId: number;
-      eventHlcSum: string | null;
-    };
-    "reload-requested": {
-      notificationType: "reload-requested";
-      reloadEpoch: string;
-      clean: boolean;
-    };
-  }[K]>) => void) => {
+  subscribe: <K extends "state-changed" | "de-sync-detected" | "remote-schema-version-mismatch" | "new-event-chunk-applied" | "reload-requested">(type: K, listener: (event: TypedEvent<WorkerNotificationEvents[K]>) => void) => {
     unsubscribe: () => void;
   };
   exportData: (opts?: {
@@ -1228,5 +1310,17 @@ type ResetStore = {
  */
 declare const RESET_REQUEST_TTL_MS: number;
 //#endregion
-export { createExportData as $, ReadonlyTable as $t, PendingCrdtEvent as A, CrdtUpdateLogPayload as An, ExecuteParams as At, DefinedSyncSchema as B, LogLevel as Bt, WorkerConfig as C, StoredValue as Cn, jsonSafeParse as Ct, CrdtStorageMutator as D, CrdtEventStatus as Dn, KvStoreItem as Dt, createCrdtSyncProducer as E, CrdtEventOrigin as En, tryCatchAsync as Et, verifySyncSchema as F, PreparedStatement as Ft, SQLiteReactiveDb as G, TableMetadata as Gt, AdmitClientEventsResult as H, startPerformanceLogger as Ht, CrdtEventValidationError as I, QueryBuilderOutput as It, parametersAreEqual as J, HLCCounter as Jt, SharedLiveQuery as K, introspectDb as Kt, NewCrdtEventValidationResult as L, SQLiteDbWrapper as Lt, createSQLiteCrdtApplyFunction as M, isNoOpCrdtEventPayload as Mn, InternalSQLiteWrapper as Mt, SchemaVerificationIssue as N, dummyKysely as Nn, KyselyQueryFactory as Nt, SnapshotOptions as O, CrdtEventType as On, createKvStoreTableQuery as Ot, formatSchemaVerificationIssues as P, KyselyStatementFactory as Pt, SyncedDbExport as Q, CrdtTableConfig as Qt, validateNewCrdtEvent as R, SQLiteTransactionWrapper as Rt, EventsPullResponse as S, createMigrator as Sn, generateId as St, WorkerState as T, CRDT_EVENT_NO_OP_PAYLOAD as Tn, tryCatch as Tt, ClientDatasetRejectionReason as U, ColumnMetadata as Ut, defineSyncSchema as V, Logger as Vt, admitClientEvents as W, DatabaseIntrospection as Wt, ImportDataOptions as X, deserializeHLC as Xt, xxhash as Y, compareHLC as Yt, ImportDataResult as Z, serializeHLC as Zt, CreateRemoteSourceFactory as _, MigratableEvent as _n, TypedBroadcastChannel as _t, SyncedDbDatabase as a, ColumnKind as an, OwnCrdtSnapshot as at, EventsPushResponse as b, SyncDbMigrator as bn, createDeferredPromise as bt, SyncedDbTransaction as c, InferRow as cn, SystemMigration as ct, CRDT_CHANGE_INTENTS_TABLE as d, SyncSchemaTables as dn, applyWorkerDbSchema as dt, SyncDbSchema as en, createImportData as et, crdtViewColumnsFromTable as f, TableBuilder as fn, baseSystemMigrations as ft, CrdtSyncRemoteSource as g, t as gn, DistributiveOmit as gt, makeCrdtTable as h, WriteOrigin as hn, DeferredPromise as ht, SyncedDb as i, ColumnBuilder as in, OwnCrdtEvent as it, createCrdtApplyFunction as j, PersistedCrdtEvent as jn, ExecuteResult as jt, createCrdtStorageMutator as k, CrdtUpdateLogItem as kn, createSQLiteKvStore as kt, UnsafeSyncedDbSqlExecutor as l, PayloadValidationResult as ln, SystemMigrationContext as lt, drainCrdtChangeIntents as m, TableOptions as mn, runSystemMigrations as mt, ResetRequest as n, AnyColumnBuilder as nn, CrdtStorage as nt, SyncedDbOptions as o, ColumnMeta as on, createCrdtStorage as ot, createCrdtViewStatements as p, TableColumns as pn, createSystemDbConfig as pt, SharedLiveQuerySnapshot as q, HLC as qt, ResetStore as r, AnyTableBuilder as rn, GetEventsBatch as rt, SyncedDbSqlExecutor as s, ExportImportMode as sn, SystemDbConfig as st, RESET_REQUEST_TTL_MS as t, AiAccess as tn, CrdtChangeIntent as tt, createSyncedDb as u, SqliteStorageType as un, applyMemoryDbSchema as ut, EventsPullRequest as v, Migrations as vn, TypedEvent as vt, WorkerNotificationMessage as w, createStoredValue as wn, quoteId as wt, createCrdtSyncRemoteSource as x, createMigrations as xn, createTypedEventTarget as xt, EventsPushRequest as y, MigrationsDb as yn, TypedEventTarget as yt, DefineSyncSchemaConfig as z, compileKyselyStatement as zt };
-//# sourceMappingURL=index-BHsKLqcK.d.ts.map
+//#region src/memory-db/wasm-reactive-db.d.ts
+declare function createSQLiteReactiveDb<Database>(opts: Omit<SQLiteReactiveDbOptions, "driver">): Promise<SQLiteReactiveDb<Database>>;
+//#endregion
+//#region src/schema/verify-sync-schema-wasm.d.ts
+/** {@link verifySyncSchemaWithDriver} on a throwaway in-memory sqlite-wasm database. */
+declare function verifySyncSchema(schema: SyncDbSchema): Promise<SchemaVerificationIssue[]>;
+//#endregion
+//#region src/wasm-driver.d.ts
+declare function loadSqliteWasm(): Promise<Sqlite3Static>;
+declare function createWasmMemoryDriver(): Promise<SqliteDriver>;
+declare function createWasmSqliteDriver(sqlite3: Sqlite3Static, db: Database): SqliteDriver;
+//#endregion
+export { parametersAreEqual as $, ColumnMetadata as $t, WorkerState as A, SyncDbMigrator as An, tryCatch as At, verifySyncSchemaWithDriver as B, CrdtUpdateLogPayload as Bn, PreparedStatement as Bt, EventsPullRequest as C, TableColumns as Cn, TypedEvent as Ct, EventsPullResponse as D, MigratableEvent as Dn, generateId as Dt, createCrdtSyncRemoteSource as E, t as En, createTypedEventTarget as Et, PendingCrdtEvent as F, CRDT_EVENT_NO_OP_PAYLOAD as Fn, ExecuteParams as Ft, DefinedSyncSchema as G, SqliteDriver as Gt, NewCrdtEventValidationResult as H, isNoOpCrdtEventPayload as Hn, SQLiteDbWrapper as Ht, createCrdtApplyFunction as I, CrdtEventOrigin as In, ExecuteResult as It, ClientDatasetRejectionReason as J, SqliteDriverStatement as Jt, defineSyncSchema as K, SqliteDriverHooks as Kt, createSQLiteCrdtApplyFunction as L, CrdtEventStatus as Ln, InternalSQLiteWrapper as Lt, CrdtStorageMutator as M, createMigrator as Mn, KvStoreItem as Mt, SnapshotOptions as N, StoredValue as Nn, createKvStoreTableQuery as Nt, WorkerConfig as O, Migrations as On, jsonSafeParse as Ot, createCrdtStorageMutator as P, createStoredValue as Pn, createSQLiteKvStore as Pt, SharedLiveQuerySnapshot as Q, startPerformanceLogger as Qt, SchemaVerificationIssue as R, CrdtEventType as Rn, KyselyQueryFactory as Rt, CreateRemoteSourceFactory as S, TableBuilder as Sn, TypedBroadcastChannel as St, EventsPushResponse as T, WriteOrigin as Tn, createDeferredPromise as Tt, validateNewCrdtEvent as U, dummyKysely as Un, SQLiteTransactionWrapper as Ut, CrdtEventValidationError as V, PersistedCrdtEvent as Vn, QueryBuilderOutput as Vt, DefineSyncSchemaConfig as W, compileKyselyStatement as Wt, SQLiteReactiveDb as X, LogLevel as Xt, admitClientEvents as Y, SqliteDriverValue as Yt, SharedLiveQuery as Z, Logger as Zt, crdtViewColumnsFromTable as _, ExportImportMode as _n, baseSystemMigrations as _t, createSQLiteReactiveDb as a, compareHLC as an, createImportData as at, makeCrdtTable as b, SqliteStorageType as bn, DeferredPromise as bt, ResetStore as c, CrdtTableConfig as cn, GetEventsBatch as ct, createSyncedDb as d, AiAccess as dn, createCrdtStorage as dt, DatabaseIntrospection as en, xxhash as et, SyncedDbDatabase as f, AnyColumnBuilder as fn, SystemDbConfig as ft, CRDT_CHANGE_INTENTS_TABLE as g, ColumnMeta as gn, applyWorkerDbSchema as gt, UnsafeSyncedDbSqlExecutor as h, ColumnKind as hn, applyMemoryDbSchema as ht, verifySyncSchema as i, HLCCounter as in, createExportData as it, createCrdtSyncProducer as j, createMigrations as jn, tryCatchAsync as jt, WorkerNotificationMessage as k, MigrationsDb as kn, quoteId as kt, SyncedDb as l, ReadonlyTable as ln, OwnCrdtEvent as lt, SyncedDbTransaction as m, ColumnBuilder as mn, SystemMigrationContext as mt, createWasmSqliteDriver as n, introspectDb as nn, ImportDataResult as nt, RESET_REQUEST_TTL_MS as o, deserializeHLC as on, CrdtChangeIntent as ot, SyncedDbSqlExecutor as p, AnyTableBuilder as pn, SystemMigration as pt, AdmitClientEventsResult as q, SqliteDriverRows as qt, loadSqliteWasm as r, HLC as rn, SyncedDbExport as rt, ResetRequest as s, serializeHLC as sn, CrdtStorage as st, createWasmMemoryDriver as t, TableMetadata as tn, ImportDataOptions as tt, SyncedDbOptions as u, SyncDbSchema as un, OwnCrdtSnapshot as ut, createCrdtViewStatements as v, InferRow as vn, createSystemDbConfig as vt, EventsPushRequest as w, TableOptions as wn, TypedEventTarget as wt, CrdtSyncRemoteSource as x, SyncSchemaTables as xn, DistributiveOmit as xt, drainCrdtChangeIntents as y, PayloadValidationResult as yn, runSystemMigrations as yt, formatSchemaVerificationIssues as z, CrdtUpdateLogItem as zn, KyselyStatementFactory as zt };
+//# sourceMappingURL=index-CH4lf3iX.d.ts.map