@sqlite-sync/core 0.8.1 → 0.9.0

package/dist/index-Ct_YbBmV.d.ts

@@ -0,0 +1,1159 @@
+import { ColumnDataType, ColumnDefinitionBuilderCallback, ColumnType, Compilable, CompiledQuery, CreateIndexBuilder, CreateTableBuilder, Expression, Kysely, SchemaModule } from "kysely";
+import { Database, FunctionOptions, SqlValue, Sqlite3Static } from "@sqlite.org/sqlite-wasm";
+//#region src/dummy-kysely.d.ts
+declare const dummyKysely: Kysely<any>;
+//#endregion
+//#region src/sqlite-crdt/crdt-table-schema.d.ts
+type NewCrdtEvent = {
+  type: CrdtEventType;
+  dataset: string;
+  item_id: string;
+  payload: Record<string, unknown>;
+};
+type CrdtEventType = "item-created" | "item-updated" | "item-deleted";
+type CrdtEventStatus = "pending" | "applied" | "failed" | "deduped";
+/** Persisted on applied events that were accepted but did not mutate materialized state. */
+declare const CRDT_EVENT_NO_OP_PAYLOAD = "no-op";
+declare function isNoOpCrdtEventPayload(payload: string): payload is "no-op";
+type CrdtEventOrigin = "remote" | "own" | "own-applied" | "local";
+type PersistedCrdtEvent = {
+  schema_version: number;
+  sync_id: number;
+  status: CrdtEventStatus;
+  type: CrdtEventType;
+  timestamp: string;
+  origin: CrdtEventOrigin;
+  source_node_id: string;
+  dataset: string;
+  item_id: string;
+  payload: string;
+};
+type CrdtUpdateLogItem = {
+  dataset: string;
+  item_id: string;
+  payload: string;
+};
+type CrdtUpdateLogPayload = Record<string, string>;
+//#endregion
+//#region src/sqlite-crdt/stored-value.d.ts
+type StoredValue<T> = {
+  get current(): T;
+  set current(newValue: T);
+};
+declare function createStoredValue<T>({ initialValue, saveToStorage }: {
+  initialValue: T;
+  saveToStorage?: (value: T) => void;
+}): StoredValue<T>;
+//#endregion
+//#region src/migrations/migrator.d.ts
+type MigratableEvent = {
+  schema_version: number;
+  type: CrdtEventType;
+  dataset: string;
+  item_id: string;
+  payload: string;
+};
+type CrdtEventTransformer = (event: NewCrdtEvent) => NewCrdtEvent | null;
+type MigrationStepSql = {
+  sql: string;
+  parameters?: readonly unknown[];
+} | Compilable | ((db: Kysely<unknown>) => Compilable);
+type UpdateLogMutation = {
+  type: "rename-table";
+  oldTable: string;
+  newTable: string;
+} | {
+  type: "drop-table";
+  table: string;
+} | {
+  type: "rename-column";
+  table: string;
+  oldColumn: string;
+  newColumn: string;
+} | {
+  type: "add-column";
+  table: string;
+  column: string;
+} | {
+  type: "drop-column";
+  table: string;
+  column: string;
+};
+type MigrationStep = {
+  sql: MigrationStepSql | MigrationStepSql[];
+  eventTransformer?: MigrationEventTransformers;
+  updateLogMutations?: UpdateLogMutation[];
+};
+type RawMigrationStep = {
+  sql: MigrationSql[];
+  eventTransformer?: CompiledMigrationEventTransformer;
+  updateLogMutations?: UpdateLogMutation[];
+};
+type MigrationSql = {
+  sql: string;
+  parameters: readonly unknown[];
+};
+type DataTypeExpression = ColumnDataType | Expression<any>;
+declare const migrationSteps: {
+  createTable: (table: string, build: (table: CreateTableBuilder<string, never>) => Compilable) => MigrationStep;
+  dropTable: (table: string) => MigrationStep;
+  createIndex: (indexName: string, build: (index: CreateIndexBuilder) => Compilable) => MigrationStep;
+  dropIndex: (indexName: string) => MigrationStep;
+  renameTable: ({ oldTable, newTable }: {
+    oldTable: string;
+    newTable: string;
+  }) => MigrationStep;
+  renameColumn: ({ table, oldColumn, newColumn }: {
+    table: string;
+    oldColumn: string;
+    newColumn: string;
+  }) => MigrationStep;
+  addColumn: ({ table, column, type, defaultValue, build }: {
+    table: string;
+    column: string;
+    type: DataTypeExpression;
+    defaultValue: number | boolean | string | null;
+    build?: ColumnDefinitionBuilderCallback;
+  }) => MigrationStep;
+  dropColumn: ({ table, column }: {
+    table: string;
+    column: string;
+  }) => MigrationStep;
+};
+type MigrationEventTransformers = Record<string, CrdtEventTransformer>;
+type CompiledMigrationEventTransformer = (event: NewCrdtEvent) => NewCrdtEvent | null;
+declare function createMigrations(buildMigrations: (builder: typeof migrationSteps) => Record<number, MigrationStep[]>): Record<number, RawMigrationStep>;
+type Migrations = ReturnType<typeof createMigrations>;
+type MigrationsDb = {
+  startTransaction: (callback: (tx: MigrationsTransaction) => void) => void;
+};
+type MigrationsTransaction = {
+  execute: (sql: string, parameters: readonly unknown[], meta?: {
+    loggerLevel?: "system";
+  }) => void;
+};
+declare function createMigrator({ migrations, schemaVersion, updateLogTableName }: {
+  migrations: Migrations;
+  schemaVersion: StoredValue<number>;
+  updateLogTableName?: string;
+}): {
+  latestSchemaVersion: number;
+  readonly currentSchemaVersion: number;
+  migrateDbToLatest: (db: MigrationsDb) => void;
+  migrateEvent: <Event extends MigratableEvent>(event: Event, targetVersion?: number) => Event | null;
+  migrateEvents: <Event extends MigratableEvent>(events: Event[], targetVersion?: number) => Event[];
+};
+type SyncDbMigrator = ReturnType<typeof createMigrator>;
+//#endregion
+//#region src/schema/table-builder.d.ts
+type ColumnKind = "text" | "integer" | "real" | "boolean" | "enum";
+type SqliteStorageType = "text" | "integer" | "real";
+type ColumnMeta = {
+  kind: ColumnKind;
+  /** Storage type used in generated DDL. Booleans store as integer 0/1. */
+  sqlType: SqliteStorageType;
+  nullable: boolean;
+  hasDefault: boolean;
+  /** Declared default in JS form (booleans as booleans). */
+  defaultValue?: unknown;
+  /** Allowed values for `enum` columns. */
+  enumValues?: readonly string[];
+  description?: string;
+};
+declare class ColumnBuilder<Value, HasDefault extends boolean = false> {
+  readonly meta: ColumnMeta;
+  readonly "~types": {
+    value: Value;
+    hasDefault: HasDefault;
+  };
+  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. */
+  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>;
+  /** Human/AI-readable description, surfaced in generated schema docs. */
+  describe(description: string): ColumnBuilder<Value, HasDefault>;
+}
+type AnyColumnBuilder = ColumnBuilder<any, boolean>;
+type TableColumns = Record<string, AnyColumnBuilder>;
+type AnyTableBuilder = TableBuilder<any, any>;
+type SyncSchemaTables = Record<string, AnyTableBuilder>;
+type TableOptions<BaseName extends string | undefined = string | undefined> = {
+  /** Override the materialized base table name (defaults to the crdt table name prefixed with "_"). */
+  baseName?: BaseName;
+  description?: string;
+};
+type Simplify$1<T> = { [K in keyof T]: T[K]; } & {};
+type ColumnValue<Column> = Column extends ColumnBuilder<infer Value, boolean> ? Value : never;
+type InferRow<Cols extends TableColumns> = Simplify$1<{
+  id: string;
+} & { [K in keyof Cols]: ColumnValue<Cols[K]>; } & {
+  tombstone?: boolean;
+}>;
+type PayloadValidationResult = {
+  success: true;
+} | {
+  success: false;
+  errors: string[];
+};
+declare class TableBuilder<Cols extends TableColumns, BaseName extends string | undefined = undefined> {
+  readonly userColumns: Cols;
+  readonly "~baseName": BaseName;
+  /** All columns in DDL order, including the auto-injected `id` and `tombstone`. */
+  readonly columns: Record<string, ColumnMeta>;
+  readonly baseName: BaseName;
+  readonly description: string | undefined;
+  constructor(userColumns: Cols, options?: TableOptions<BaseName>);
+  describe(description: string): TableBuilder<Cols, BaseName>;
+  /** Type-only: the row shape returned by queries. Do not access at runtime. */
+  get $row(): InferRow<Cols>;
+  /**
+   * Validate a CRDT event payload against the declared columns.
+   * `item-created` payloads must contain every column without a default (nullable columns may be omitted);
+   * `item-updated` payloads are partial and must not touch `id` or set `tombstone` to a deleted value.
+   */
+  validatePayload(payload: Record<string, unknown>, options?: {
+    event?: "item-created" | "item-updated";
+  }): PayloadValidationResult;
+}
+declare const t: {
+  text: () => ColumnBuilder<string, false>;
+  integer: () => ColumnBuilder<number, false>;
+  real: () => ColumnBuilder<number, false>;
+  /** Stored as INTEGER 0/1; always bind booleans as 0/1 when writing raw SQL. */
+  boolean: () => ColumnBuilder<boolean, false>;
+  /**
+   * Union of string literals stored as TEXT, e.g. `t.enum(["movie", "tv"])`. Unlike `$type`, the
+   * allowed values are kept as runtime metadata, so payloads are validated against them.
+   * For an open-ended set, use `t.text().$type<"idle" | (string & {})>()` instead.
+   */
+  enum: <const Values extends readonly [string, ...string[]]>(values: Values) => ColumnBuilder<Values[number], false>;
+  table: <Cols extends TableColumns, const BaseName extends string | undefined = undefined>(columns: Cols, options?: TableOptions<BaseName>) => TableBuilder<Cols, BaseName>;
+};
+//#endregion
+//#region src/sqlite-crdt/crdt-schema.d.ts
+type CrdtTableConfig = {
+  baseTableName: string;
+  crdtTableName: string;
+};
+interface SyncDbSchema<ClientDB = {}, ServerDB = {}, MutationsDB = {}> {
+  get tablesConfig(): CrdtTableConfig[];
+  get migrations(): Migrations;
+  get tables(): SyncSchemaTables;
+  "~clientSchema": ClientDB;
+  "~serverSchema": ServerDB;
+  "~mutationsSchema": MutationsDB;
+}
+type ReadonlyTable<Table extends Record<string, unknown>> = { [K in keyof Table]: ColumnType<Table[K], never, never>; };
+//#endregion
+//#region src/hlc.d.ts
+interface HLC {
+  timestamp: number;
+  counter: number;
+  nodeId: string;
+}
+declare class HLCCounter {
+  private timestamp;
+  private counter;
+  private nodeId;
+  private readonly getTimestamp;
+  private readonly maxDrift;
+  constructor(nodeId: string, getTimestamp: () => number, maxDrift?: number);
+  getCurrentHLC(): HLC;
+  getNextHLC(): HLC;
+  mergeHLC(hlc: HLC): void;
+}
+declare function serializeHLC(hlc: HLC): string;
+declare function deserializeHLC(serialized: string): HLC;
+declare function compareHLC(one: HLC, two: HLC): number;
+//#endregion
+//#region src/introspection.d.ts
+type TableMetadata = {
+  name: string;
+  isView: boolean;
+  columns: ColumnMetadata[];
+};
+type DatabaseIntrospection = Record<string, TableMetadata>;
+type ColumnMetadata = {
+  name: string;
+  dataType: string;
+  isNullable: boolean;
+  isAutoIncrementing: boolean;
+  hasDefaultValue: boolean;
+  defaultValueSql: string | null;
+  isPrimaryKey: boolean;
+  comment: undefined;
+};
+declare function introspectDb<BaseDatabase>(_db: SQLiteDbWrapper<BaseDatabase>): DatabaseIntrospection;
+//#endregion
+//#region src/logger.d.ts
+type LogLevel = "info" | "warning" | "error" | "trace" | "system";
+type Logger = (type: string, message: string, level?: LogLevel) => void;
+type PerformanceLogger = {
+  restart: () => void;
+  logEnd: (type: string, message: string, level?: LogLevel) => void;
+};
+declare const startPerformanceLogger: (logger: Logger | undefined, level?: LogLevel) => PerformanceLogger;
+//#endregion
+//#region src/sqlite-db-wrapper.d.ts
+type ExecuteParams = {
+  sql: string;
+  parameters: readonly unknown[];
+};
+type ExecuteResult<T> = {
+  rows: T[];
+};
+type PreparedStatement<TParams extends unknown[], TResult> = {
+  execute: (parameters: TParams) => TResult[];
+  finalize: () => void;
+  isFinalized: boolean;
+};
+type ScalarFunctionOptions<TArgs extends readonly SqlValue[], TResult extends SqlValue | undefined> = {
+  name: string;
+  callback: (...args: TArgs) => TResult;
+} & Pick<FunctionOptions, "deterministic" | "directOnly" | "innocuous">;
+type SqliteWrapperOptions = {
+  logger?: Logger;
+  loggerPrefix?: string;
+  sqlite3: Sqlite3Static;
+  db: () => Database;
+};
+type SQLiteTransactionWrapper<TDatabase = unknown> = Pick<SQLiteDbWrapper<TDatabase>, "sql" | "execute" | "executePrepared" | "executePreparedRaw" | "executeKysely">;
+type InternalSQLiteTransactionWrapper<TDatabase = unknown> = Pick<SQLiteDbWrapper<TDatabase>, "executePrepared" | "executePreparedRaw">;
+type InternalSQLiteWrapper<TDatabase = unknown> = InternalSQLiteTransactionWrapper<TDatabase> & {
+  executeTransaction: (callback: (db: InternalSQLiteTransactionWrapper<TDatabase>) => void) => void;
+};
+type QueryMetaOpts = {
+  loggerLevel?: "info" | "system";
+};
+/** Runs after user SQL succeeds, before its transaction or savepoint is committed. */
+type AfterMutatingStatement<TDatabase> = (db: InternalSQLiteTransactionWrapper<TDatabase>) => void;
+type ExecuteOptions = QueryMetaOpts & {
+  /** For internal mutations whose effects must not be processed by afterMutatingStatement. */
+  skipAfterMutatingStatement?: boolean;
+};
+declare class SQLiteDbWrapper<TDatabase = unknown> {
+  private db;
+  private sqlite3;
+  private logger?;
+  private loggerPrefix?;
+  private loadedDbSchema;
+  private readonly dataPointers;
+  private preparedStatements;
+  private preparedStatementsMap;
+  private preparedRawStatementsMap;
+  private afterMutatingStatement;
+  constructor(opts: SqliteWrapperOptions);
+  get ensureDb(): Database;
+  get dbSchema(): DatabaseIntrospection;
+  private executeSql;
+  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;
+  };
+  private beginStatementTransaction;
+  prepare<TParams extends unknown[], TResult>(sql: string, opts?: QueryMetaOpts): PreparedStatement<TParams, TResult>;
+  prepareKysely<TParams extends Record<string, unknown>>(opts?: QueryMetaOpts): <TQuery extends Compilable<TResult>, TResult = QueryBuilderOutput<TQuery>>(factory: KyselyStatementFactory<TParams, TDatabase, TQuery, TResult>) => TypedStatement<TParams, TResult>;
+  executeKysely<TQuery extends Compilable<TResult>, TResult = QueryBuilderOutput<TQuery>>(factory: KyselyQueryFactory<TDatabase, TQuery, TResult>, options?: ExecuteOptions): ExecuteResult<TResult>;
+  executePrepared<TParams extends Record<string, unknown>, TQuery extends Compilable<TResult>, TResult = QueryBuilderOutput<TQuery>>(key: string, params: TParams, factory: KyselyStatementFactory<TParams, TDatabase, TQuery, TResult>, meta?: QueryMetaOpts): TResult[];
+  executePreparedRaw<TParams extends unknown[], TResult>({ key, sql, params, meta }: {
+    key: string;
+    sql: string;
+    params?: TParams;
+    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;
+  useSnapshot(snapshot: Uint8Array<ArrayBufferLike>): void;
+  createSnapshot(): Uint8Array<ArrayBuffer>;
+  invalidateDbSchema(): void;
+  cleanup(): void;
+  close(): void;
+}
+type QueryBuilderOutput<QB> = QB extends Compilable<infer O> ? O : never;
+type ParamsGetter<TParams> = <TKey extends keyof TParams>(key: TKey) => TParams[TKey];
+type TypedStatement<TParams extends Record<string, unknown>, TResult> = {
+  execute: (parameters: TParams) => TResult[];
+};
+type KyselyStatementFactory<TParams extends Record<string, unknown>, TDatabase, TQuery extends Compilable<TResult>, TResult = QueryBuilderOutput<TQuery>> = (kysely: Kysely<TDatabase>, params: ParamsGetter<TParams>) => TQuery;
+type KyselyQueryFactory<TDatabase, TQuery extends Compilable<TResult>, TResult = QueryBuilderOutput<TQuery>> = (kysely: Kysely<TDatabase>) => TQuery;
+//#endregion
+//#region src/sqlite-kv-store.d.ts
+type KvStoreItem = {
+  key: string;
+  value: string;
+};
+declare function createKvStoreTableQuery(schema: SchemaModule, tableName: string): import("kysely").CreateTableBuilder<string, "key" | "value">;
+declare function createSQLiteKvStore({ db, metaTableName }: {
+  db: InternalSQLiteWrapper<any>;
+  metaTableName: string;
+}): {
+  get: (key: string) => string | null;
+  set: (key: string, value: string) => void;
+  remove: (key: string) => void;
+  createStringStoredValue: (key: string, defaultValue: string) => StoredValue<string>;
+  createNumberStoredValue: (key: string, defaultValue: number) => StoredValue<number>;
+};
+//#endregion
+//#region src/utils.d.ts
+type DeferredPromise<T> = {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (error: Error) => void;
+};
+type DeferredPromiseOptions = {
+  timeout?: number;
+  onTimeout?: () => void;
+};
+declare function createDeferredPromise<T>(opts?: DeferredPromiseOptions): DeferredPromise<T>;
+declare const generateId: () => `${string}-${string}-${string}-${string}-${string}`;
+type DistributiveOmit<T, K extends keyof T> = T extends any ? Omit<T, K> : never;
+declare class TypedBroadcastChannel<TMessage> {
+  private readonly channel;
+  constructor(name: string);
+  postMessage(message: TMessage): void;
+  set onmessage(callback: ((event: MessageEvent<TMessage>) => void) | null);
+  close(): void;
+}
+declare class TypedEvent<T = unknown> extends Event {
+  readonly payload: T;
+  constructor(type: string, payload: T);
+}
+type TypedEventTarget<T extends Record<string, unknown>> = {
+  addEventListener: <K extends keyof T & string>(type: K, listener: (event: TypedEvent<T[K]>) => void) => {
+    unsubscribe: () => void;
+  };
+  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;
+};
+declare const createTypedEventTarget: <T extends Record<string, unknown>>() => TypedEventTarget<T>;
+type TryCatchResult<T> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: unknown;
+};
+declare function tryCatch<T>(fn: () => T): TryCatchResult<T>;
+declare function tryCatchAsync<T>(fn: () => Promise<T>): Promise<TryCatchResult<T>>;
+declare function jsonSafeParse<T>(json: string): TryCatchResult<T>;
+/** Quote a SQLite identifier (table/column name), handling dot-separated schema qualifiers. */
+declare function quoteId(name: string): string;
+type ParsedTableName = {
+  schema: "main" | (string & {});
+  table: string;
+  fullIdentifier: string;
+};
+//#endregion
+//#region src/migrations/system-schema.d.ts
+type SystemDbConfig = {
+  eventsTable: ParsedTableName;
+  updateLogTable: ParsedTableName;
+};
+declare function createSystemDbConfig({ eventsTableName, updateLogTableName }: {
+  eventsTableName: string;
+  updateLogTableName: string;
+}): SystemDbConfig;
+type SystemMigrationContext = SystemDbConfig & {
+  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[];
+  dbConfig: SystemDbConfig;
+  execute: (sql: string) => void;
+  transaction: (callback: () => void) => void;
+}): void;
+declare function applyWorkerDbSchema(db: SQLiteDbWrapper<any>): {
+  kvStore: {
+    get: (key: string) => string | null;
+    set: (key: string, value: string) => void;
+    remove: (key: string) => void;
+    createStringStoredValue: (key: string, defaultValue: string) => StoredValue<string>;
+    createNumberStoredValue: (key: string, defaultValue: number) => StoredValue<number>;
+  };
+};
+declare function applyMemoryDbSchema(db: SQLiteDbWrapper<any>): void;
+//#endregion
+//#region src/sqlite-crdt/crdt-storage.d.ts
+type LocalCrdtEvent = {
+  type: CrdtEventType;
+  dataset: string;
+  item_id: string;
+  payload: string;
+  timestamp: string;
+  schema_version: number;
+};
+type OwnCrdtEvent = {
+  type: CrdtEventType;
+  dataset: string;
+  item_id: string;
+  payload: string;
+  timestamp?: undefined;
+  schema_version?: undefined;
+};
+type OwnCrdtSnapshot = {
+  dataset: string;
+  item_id: string;
+  patch: Record<string, unknown>;
+};
+type CrdtChangeIntent = {
+  seq: number;
+  dataset: string;
+  type: CrdtEventType;
+  item_id: string;
+  new_item_id: string | null;
+  payload_json: string;
+};
+type RemoteCrdtEvent = {
+  type: CrdtEventType;
+  dataset: string;
+  item_id: string;
+  payload: string;
+  timestamp: string;
+  schema_version: number;
+};
+type GetEventsBatchQuery = {
+  afterSyncId: number;
+  status: CrdtEventStatus;
+  limit: number;
+} & ({
+  excludeOrigin: CrdtEventOrigin;
+  excludeNodeId?: undefined;
+} | {
+  excludeOrigin?: undefined;
+  excludeNodeId: string;
+});
+type GetEventsBatch = {
+  events: PersistedCrdtEvent[];
+  hasMore: boolean;
+  nextSyncId: number;
+};
+type EnqueueEventsResult = {
+  beforeSyncId: number;
+  afterSyncId: number;
+  /** Resolves when the enqueued events have been processed (applied/deduped/failed). */
+  processed: Promise<void>;
+};
+type StorageHLC = Pick<HLCCounter, "getNextHLC" | "mergeHLC">;
+type DbSyncerStorage = {
+  nodeId: string;
+  initialLocalSyncId: number;
+  migrator: SyncDbMigrator;
+  db: InternalSQLiteWrapper<any>;
+  dbConfig: SystemDbConfig;
+  hlc: StorageHLC;
+  eventHlcAccumulator?: StoredValue<string>;
+  onEventApplied?: (event: PersistedCrdtEvent) => void;
+  schema: Pick<SyncDbSchema, "tables" | "tablesConfig">;
+};
+type CrdtStorage = Omit<ReturnType<typeof createCrdtStorage>, "internal">;
+type InternalCrdtStorage = ReturnType<typeof createCrdtStorage>;
+type EventsAppliedPayload = {
+  syncId: number;
+  eventHlcSum: string | null;
+};
+type InternalDbSchema = {
+  _crdt_events: PersistedCrdtEvent;
+  _crdt_update_log: CrdtUpdateLogItem;
+};
+declare function createCrdtStorage(storage: DbSyncerStorage): {
+  getEventsBatch: (options: GetEventsBatchQuery) => GetEventsBatch;
+  enqueueLocalEvents: (events: LocalCrdtEvent[], sourceNodeId: string) => EnqueueEventsResult;
+  enqueueOwnEvents: (events: OwnCrdtEvent[]) => EnqueueEventsResult;
+  enqueueRemoteEvents: (events: RemoteCrdtEvent[]) => EnqueueEventsResult;
+  applyOwnEvents: (events: OwnCrdtEvent[]) => void;
+  applyOwnSnapshot: (snapshot: OwnCrdtSnapshot) => void;
+  checkIsQuiescent: (pushedSyncId: number) => boolean;
+  getEventHlcAccumulator: () => string | null;
+  addEventListener: <K extends "events-applied" | "remote-event-apply-failed">(type: K, listener: (event: TypedEvent<{
+    "events-applied": EventsAppliedPayload;
+    "remote-event-apply-failed": {
+      syncId: number;
+    };
+  }[K]>) => void) => {
+    unsubscribe: () => void;
+  };
+  removeEventListener: <K extends "events-applied" | "remote-event-apply-failed">(type: K, listener: (event: TypedEvent<{
+    "events-applied": EventsAppliedPayload;
+    "remote-event-apply-failed": {
+      syncId: number;
+    };
+  }[K]>) => void) => void;
+  internal: {
+    applyOwnEventFromTransaction: (tx: InternalSQLiteTransactionWrapper<InternalDbSchema>, event: OwnCrdtEvent) => void;
+    applyOwnIntentsFromTransaction: (tx: InternalSQLiteTransactionWrapper<InternalDbSchema>, intents: CrdtChangeIntent[]) => {
+      appliedEvents: number;
+    };
+    processEnqueuedEvents: {
+      (): Promise<void>;
+      promise(): Promise<void> | null;
+      isExecuting(): boolean;
+    };
+  };
+};
+//#endregion
+//#region src/export-import.d.ts
+/**
+ * A portable, schema-version-aware dump of every active entity in a synced DB.
+ * Unlike a raw SQLite snapshot, it carries no event history — just the current
+ * `tombstone = 0` rows, ready to be replayed as fresh create events on import.
+ */
+type SyncedDbExport = {
+  schemaVersion: number;
+  exportedAt: string;
+  /** base table name -> active rows (each includes `id`, excludes `tombstone`). */
+  tables: Record<string, Array<Record<string, unknown>>>;
+};
+type ImportDataOptions = {
+  validate?: boolean;
+};
+type ImportDataResult = {
+  imported: number;
+};
+type ExportImportReactiveDb = {
+  db: {
+    execute<T>(sql: string, meta: {
+      loggerLevel: "system";
+    }): ExecuteResult<T>;
+  };
+};
+type ApplyImportEvents = (events: OwnCrdtEvent[]) => void | Promise<void>;
+type ImportMigrator = Pick<SyncDbMigrator, "currentSchemaVersion" | "migrateEvents">;
+type CreateExportDataOptions = {
+  reactiveDb: ExportImportReactiveDb;
+  tablesConfig: CrdtTableConfig[];
+  schemaVersion: number;
+};
+type CreateImportDataOptions = {
+  migrator: ImportMigrator;
+  tablesConfig?: CrdtTableConfig[];
+  applyEvents: ApplyImportEvents;
+};
+declare function createImportData({ migrator, tablesConfig, applyEvents }: CreateImportDataOptions): (data: SyncedDbExport, opts?: ImportDataOptions) => ImportDataResult | Promise<ImportDataResult>;
+declare function createExportData({ reactiveDb, tablesConfig, schemaVersion }: CreateExportDataOptions): (opts?: {
+  tables?: string[];
+}) => SyncedDbExport;
+//#endregion
+//#region src/hash.d.ts
+declare function ensureLoaded(): Promise<void>;
+declare function h64(input: string, seed?: bigint): bigint;
+declare const xxhash: {
+  ensureLoaded: typeof ensureLoaded;
+  h64: typeof h64;
+};
+//#endregion
+//#region src/memory-db/sqlite-reactive-db.d.ts
+type SQLiteReactiveDbOptions = {
+  snapshot: Uint8Array<ArrayBufferLike>;
+  logger: Logger;
+};
+type EventsMap = {
+  "transaction-committed": undefined;
+  "transaction-rolled-back": undefined;
+  "any-table-changed": undefined;
+} & Record<`table:${string}`, void>;
+type LiveQuery<TResult> = {
+  getRows: () => TResult[];
+  refresh: () => void;
+  subscribe: (onchange: () => void) => () => void;
+};
+type SharedLiveQuery<TResult> = LiveQuery<TResult> & {
+  readonly sql: string;
+  readonly parameters: readonly unknown[];
+  getSubscriberCount: () => number;
+};
+type SharedLiveQuerySnapshot = {
+  sql: string;
+  parameters: readonly unknown[];
+  subscriberCount: number;
+};
+declare class SQLiteReactiveDb<Database> {
+  readonly db: SQLiteDbWrapper<Database>;
+  private sqlite3;
+  private readonly logger;
+  private tablesUsedStatement;
+  private eventTarget;
+  private mutationVersion;
+  private tableMutationVersions;
+  private constructor();
+  static create<Database>(opts: SQLiteReactiveDbOptions): Promise<SQLiteReactiveDb<Database>>;
+  private liveQueryStatements;
+  private sharedLiveQueries;
+  createLiveQuery<TResult>(query: {
+    sql: string;
+    parameters: readonly unknown[];
+  }): {
+    getRows: () => TResult[];
+    refresh: (parameters?: readonly unknown[]) => void;
+    subscribe: (onchange: () => void) => () => void;
+  };
+  getSharedLiveQuery<TResult>(query: {
+    sql: string;
+    parameters: readonly unknown[];
+  }): SharedLiveQuery<TResult>;
+  private registerSharedLiveQueryEntry;
+  getSharedLiveQueriesSnapshot(): SharedLiveQuerySnapshot[];
+  private scheduleSharedLiveQueryCleanup;
+  private cancelSharedLiveQueryCleanup;
+  private releaseSharedLiveQuery;
+  subscribeToQueryChanges(params: {
+    sql: string;
+    onDataChange: () => void;
+  }): {
+    unsubscribe: () => void;
+  };
+  subscribeToTableChanges(table: string, onChanges: () => void): {
+    unsubscribe: () => void;
+  };
+  getTablesUsed(query: string): {
+    name: string;
+    isWrite: boolean;
+  }[];
+  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;
+  getTableMutationVersion(table: string): number;
+  private notifyTableSubscribers;
+  private registerDbHooks;
+  createSnapshot(): Uint8Array<ArrayBuffer>;
+  useSnapshot(snapshot: Uint8Array<ArrayBufferLike>): void;
+  dispose(): void;
+}
+declare function parametersAreEqual(a: readonly unknown[] | undefined, b: readonly unknown[] | undefined): boolean;
+//#endregion
+//#region src/schema/define-sync-schema.d.ts
+type Simplify<T> = { [K in keyof T]: T[K]; } & {};
+type RowOf<Table extends AnyTableBuilder> = Table extends TableBuilder<infer Cols extends TableColumns, any> ? InferRow<Cols> : never;
+type BaseNameOf<CrdtName, Table extends AnyTableBuilder> = string extends Table["~baseName"] ? `_${CrdtName & string}` : [Table["~baseName"]] extends [string] ? Table["~baseName"] : `_${CrdtName & string}`;
+type ClientSchemaOf<Tables extends SyncSchemaTables> = Simplify<{ [K in keyof Tables]: RowOf<Tables[K]>; } & { [K in keyof Tables as BaseNameOf<K, Tables[K]>]: ReadonlyTable<RowOf<Tables[K]>>; }>;
+type ServerSchemaOf<Tables extends SyncSchemaTables> = Simplify<{ [K in keyof Tables]: ReadonlyTable<RowOf<Tables[K]>>; } & { [K in keyof Tables as BaseNameOf<K, Tables[K]>]: ReadonlyTable<RowOf<Tables[K]>>; }>;
+type MutationsSchemaOf<Tables extends SyncSchemaTables> = Simplify<{ [K in keyof Tables as BaseNameOf<K, Tables[K]>]: RowOf<Tables[K]>; }>;
+interface DefinedSyncSchema<Tables extends SyncSchemaTables> extends SyncDbSchema<ClientSchemaOf<Tables>, ServerSchemaOf<Tables>, MutationsSchemaOf<Tables>> {
+  /** The table builders, for type extraction (`typeof schema.tables.item.$row`) and runtime metadata. */
+  tables: Tables;
+}
+type DefineSyncSchemaConfig<Tables extends SyncSchemaTables> = {
+  tables: Tables;
+  /** Full migration history (including the initial createTable version), built with `createMigrations`. */
+  migrations: Migrations;
+};
+/**
+ * Define a sync database schema from `t.table()` builders.
+ *
+ * Record keys are the crdt (view) table names; base table names default to the key
+ * prefixed with "_", overridable per table via `t.table(cols, { baseName })`.
+ */
+declare function defineSyncSchema<Tables extends SyncSchemaTables>({ tables, migrations }: DefineSyncSchemaConfig<Tables>): DefinedSyncSchema<Tables>;
+//#endregion
+//#region src/schema/validate-crdt-event.d.ts
+type NewCrdtEventValidationResult = {
+  success: true;
+  event: NewCrdtEvent;
+} | {
+  success: false;
+  errors: string[];
+};
+declare class CrdtEventValidationError extends Error {
+  readonly errors: string[];
+  constructor(errors: string[]);
+}
+declare function validateNewCrdtEvent(schema: Pick<SyncDbSchema, "tables" | "tablesConfig">, input: unknown): NewCrdtEventValidationResult;
+//#endregion
+//#region src/schema/verify-sync-schema.d.ts
+type SchemaVerificationIssue = {
+  table: string;
+  column?: string;
+  message: string;
+};
+/**
+ * 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.
+ *
+ * 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 formatSchemaVerificationIssues(issues: SchemaVerificationIssue[]): string;
+//#endregion
+//#region src/sqlite-crdt/apply-crdt-event.d.ts
+type PendingCrdtEvent = {
+  type: CrdtEventType;
+  dataset: string;
+  item_id: string;
+  timestamp: string;
+  payload: string;
+};
+declare const createSQLiteCrdtApplyFunction: ({ db, dbConfig }: {
+  db: InternalSQLiteWrapper<any>;
+  dbConfig: SystemDbConfig;
+}) => (event: PendingCrdtEvent) => void;
+type CreateCrdtApplyOpts = {
+  getCrdtUpdateLog: (opts: {
+    itemId: string;
+    dataset: string;
+  }) => CrdtUpdateLogPayload | null;
+  insertItem: (opts: {
+    dataset: string;
+    payload: Record<string, unknown>;
+  }) => void;
+  insertCrdtUpdateLog: (opts: {
+    dataset: string;
+    itemId: string;
+    payload: string;
+  }) => void;
+  updateItem: (opts: {
+    dataset: string;
+    itemId: string;
+    payload: Record<string, unknown>;
+  }) => void;
+  updateCrdtUpdateLog: (opts: {
+    dataset: string;
+    itemId: string;
+    payload: string;
+  }) => void;
+};
+declare function createCrdtApplyFunction({ 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>>;
+type CommitEventOptions<Database, Table extends keyof Database & string> = {
+  type: "item-created";
+  dataset: Table;
+  item_id: string;
+  payload: CreateEventPayload<Database, Table>;
+} | {
+  type: "item-updated";
+  dataset: Table;
+  item_id: string;
+  payload: UpdateEventPayload<Database, Table>;
+} | {
+  type: "item-deleted";
+  dataset: Table;
+  item_id: string;
+};
+type CreateEventPayload<Database, Table extends keyof Database> = Omit<Database[Table], "tombstone">;
+type UpdateEventPayload<Database, Table extends keyof Database> = Omit<Partial<Database[Table]>, "id" | "tombstone">;
+type SnapshotOptions<Database, Table extends keyof Database & string> = {
+  dataset: Table;
+  id: string;
+  patch: UpdateEventPayload<Database, Table>;
+};
+declare function createCrdtStorageMutator<Database>({ storage }: {
+  storage: CrdtStorage;
+}): {
+  enqueueEvents: (events: CommitEventOptions<Database, keyof Database & string>[]) => void;
+  createEvent: <Table extends keyof Database & string>(event: CommitEventOptions<Database, Table>) => CommitEventOptions<Database, Table>;
+  enqueueEvent: (event: CommitEventOptions<Database, keyof Database & string>) => void;
+  enqueueSnapshot: <Table extends keyof Database & string>(snapshot: SnapshotOptions<Database, Table>) => void;
+};
+//#endregion
+//#region src/sqlite-crdt/crdt-sync-producer.d.ts
+type CrdtSyncProducer = {
+  storage: CrdtStorage;
+  broadcastEvents: (request: {
+    newSyncId: number;
+    eventHlcSum: string | null;
+  }) => void;
+};
+declare const createCrdtSyncProducer: ({ storage, broadcastEvents }: CrdtSyncProducer) => void;
+//#endregion
+//#region src/worker-db/worker-common.d.ts
+type WorkerNotificationMessage = {
+  notificationType: "new-event-chunk-applied";
+  newSyncId: number;
+  /** Worker's HLC checksum after applying up to `newSyncId`. */
+  eventHlcSum: string | null;
+} | {
+  notificationType: "state-changed";
+  state: WorkerState;
+} | {
+  notificationType: "reload-requested";
+  reloadEpoch: string;
+  clean: boolean;
+} | {
+  notificationType: "de-sync-detected";
+  reason: DeSyncDetectedReason;
+} | {
+  notificationType: "remote-schema-version-mismatch";
+  remoteSchemaVersion: number;
+  localSchemaVersion: number;
+};
+type WorkerState = {
+  remoteState: "online" | "offline" | "pending";
+  deSynced: boolean;
+  schemaVersionMismatched: boolean;
+};
+type EventsPullResponse = {
+  events: {
+    schema_version: number;
+    type: CrdtEventType;
+    timestamp: string;
+    dataset: string;
+    item_id: string;
+    payload: string;
+  }[];
+  hasMore: boolean;
+  nextSyncId: number;
+};
+type WorkerConfig<Props = any> = {
+  dbId: string;
+  clientId: string;
+  props: Props;
+};
+//#endregion
+//#region src/sqlite-crdt/crdt-sync-remote-source.d.ts
+type CrdtSyncRemoteSourceConfig = {
+  bufferSize: number;
+  storage: CrdtStorage;
+  migrator: SyncDbMigrator;
+  pullSyncId: StoredValue<number>;
+  pushSyncId: StoredValue<number>;
+  nodeId: string;
+  remoteFactory?: CreateRemoteSourceFactory;
+};
+type EventsPullRequest = {
+  afterSyncId: number;
+  excludeNodeId?: string;
+};
+type EventsPushRequest = {
+  nodeId: string;
+  events: (PendingCrdtEvent & {
+    schema_version: number;
+  })[];
+};
+type EventsPushResponse = {
+  ok: boolean;
+  /** Remote sync_id right before the pushed events were enqueued. */
+  beforeSyncId?: number;
+  /** Remote sync_id right after the pushed events were enqueued. */
+  afterSyncId?: number;
+};
+type CrdtSyncRemoteSource = ReturnType<typeof createCrdtSyncRemoteSource>;
+type EventsAvailable = {
+  newSyncId: number;
+  remoteEventHlcSum: string | null;
+};
+type CreateRemoteSourceFactory = (opts: {
+  onEventsAvailable: (event: EventsAvailable) => void;
+}) => RemoteSource | Promise<RemoteSource>;
+type RemoteSource = {
+  pullEvents: (request: EventsPullRequest) => Promise<EventsPullResponse>;
+  pushEvents: (request: EventsPushRequest) => Promise<EventsPushResponse>;
+  disconnect?: () => void | Promise<void>;
+};
+type RemoteSourceState = {
+  type: "pending";
+  deSynced: boolean;
+  schemaVersionMismatched: boolean;
+} | {
+  type: "offline";
+  reason: OfflineReason;
+  deSynced: boolean;
+  schemaVersionMismatched: boolean;
+} | {
+  type: "online";
+  source: RemoteSource;
+  deSynced: boolean;
+  schemaVersionMismatched: boolean;
+};
+type OfflineReason = "NOT_INITIALIZED" | "INITIALIZATION_FAILED" | "REMOTE_PUSH_ERROR" | "REMOTE_PULL_ERROR" | "DISCONNECTED";
+type DeSyncDetectedReason = "CHECKSUM_MISMATCH" | "ERROR_APPLYING_REMOTE_EVENT";
+declare const createCrdtSyncRemoteSource: ({ bufferSize, storage, migrator, pullSyncId, pushSyncId, nodeId, remoteFactory }: CrdtSyncRemoteSourceConfig) => {
+  goOnline: () => Promise<void>;
+  goOffline: {
+    (reason: OfflineReason): Promise<void>;
+    promise(): Promise<void> | null;
+    isExecuting(): boolean;
+  };
+  syncWithRemote: {
+    (): Promise<void>;
+    promise(): Promise<void> | null;
+    isExecuting(): boolean;
+  };
+  getState: () => WorkerState;
+  dispose: () => Promise<void>;
+  addEventListener: <K extends "state-changed" | "de-sync-detected" | "remote-schema-version-mismatch">(type: K, listener: (event: TypedEvent<{
+    "state-changed": RemoteSourceState["type"];
+    "de-sync-detected": {
+      reason: DeSyncDetectedReason;
+    };
+    "remote-schema-version-mismatch": {
+      remoteSchemaVersion: number;
+      localSchemaVersion: number;
+    };
+  }[K]>) => void) => {
+    unsubscribe: () => void;
+  };
+  removeEventListener: <K extends "state-changed" | "de-sync-detected" | "remote-schema-version-mismatch">(type: K, listener: (event: TypedEvent<{
+    "state-changed": RemoteSourceState["type"];
+    "de-sync-detected": {
+      reason: DeSyncDetectedReason;
+    };
+    "remote-schema-version-mismatch": {
+      remoteSchemaVersion: number;
+      localSchemaVersion: number;
+    };
+  }[K]>) => void) => void;
+};
+//#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 }: {
+  db: SQLiteDbWrapper<any>;
+  baseTableName: string;
+  crdtTableName: string;
+}): void;
+declare function createCrdtViewStatements({ baseTableName, crdtTableName, columnNames }: {
+  baseTableName: string;
+  crdtTableName: string;
+  columnNames: string[];
+}): 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;
+  workerProps: Props;
+  syncDbSchema: SyncDbSchema<Database>;
+};
+/** SQL execution that participates in CRDT intent draining. */
+type SyncedDbSqlExecutor<Database> = {
+  execute<TResult = unknown>(query: ExecuteParams | string | CompiledQuery<TResult>): ExecuteResult<TResult>;
+  executeKysely<TQuery extends Compilable<TResult>, TResult = QueryBuilderOutput<TQuery>>(factory: KyselyQueryFactory<Database, TQuery, TResult>): ExecuteResult<TResult>;
+};
+/**
+ * SQL execution that deliberately bypasses CRDT intent draining.
+ *
+ * Mutating a synced view through this executor can leave undrained intents and
+ * must only be done by sqlite-sync internals or recovery tooling.
+ */
+type UnsafeSyncedDbSqlExecutor<Database> = SyncedDbSqlExecutor<Database>;
+type SyncedDbTransaction<Database> = SyncedDbSqlExecutor<Database> & {
+  unsafe: UnsafeSyncedDbSqlExecutor<Database>;
+  sql<TResult = unknown>(templateOrString: TemplateStringsArray | string, ...parameters: unknown[]): ExecuteResult<TResult>;
+};
+type SyncedDbDatabase<Database> = SyncedDbSqlExecutor<Database> & {
+  unsafe: UnsafeSyncedDbSqlExecutor<Database>;
+  executeTransaction<TResult>(callback: (tx: SyncedDbTransaction<Database>) => TResult): TResult;
+  createLiveQuery<TResult>(query: {
+    sql: string;
+    parameters: readonly unknown[];
+  }): {
+    getRows: () => TResult[];
+    refresh: (parameters?: readonly unknown[]) => void;
+    subscribe: (onchange: () => void) => () => void;
+  };
+  getSharedLiveQuery<TResult>(query: {
+    sql: string;
+    parameters: readonly unknown[];
+  }): SharedLiveQuery<TResult>;
+};
+declare function createSyncedDb<Database, Props = undefined>(options: SyncedDbOptions<Database, Props>): Promise<{
+  db: SyncedDbDatabase<Database>;
+  state: {
+    getState: () => WorkerState;
+    subscribe: (onChange: () => void) => () => void;
+    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 "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;
+    };
+    "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) => {
+    unsubscribe: () => void;
+  };
+  exportData: (opts?: {
+    tables?: string[];
+  }) => SyncedDbExport;
+  importData: (data: SyncedDbExport, opts?: ImportDataOptions) => Promise<ImportDataResult>;
+  dispose: () => Promise<void>;
+  _internal: {
+    executeAsync: (query: ExecuteParams) => Promise<ExecuteResult<unknown>>;
+    getMemoryQueryTables: (query: string) => {
+      name: string;
+      isWrite: boolean;
+    }[];
+    getSharedLiveQueriesSnapshot: () => SharedLiveQuerySnapshot[];
+    crdtTableNames: string[];
+    crdtTablesConfig: CrdtTableConfig[];
+    schemaVersion: number;
+    migrationVersions: number[];
+  };
+}>;
+type SyncedDb<Database> = Awaited<ReturnType<typeof createSyncedDb<Database>>>;
+//#endregion
+//#region src/worker-db/reset-state.d.ts
+type ResetRequest = {
+  epoch: string;
+  requestedAt: number;
+};
+/** Durable async key-value storage for reset state. Injectable for tests. */
+type ResetStore = {
+  get: <T>(key: string) => Promise<T | undefined>;
+  set: (key: string, value: unknown) => Promise<void>;
+  delete: (key: string) => Promise<void>;
+};
+/**
+ * A clean reset is a recovery action for a de-sync detected now. If the reload
+ * never happens (broadcast lost, tab crashed mid-reload, browser killed the page),
+ * the request must not fire on an arbitrary later cold start and silently wipe
+ * local-only writes accumulated since.
+ */
+declare const RESET_REQUEST_TTL_MS: number;
+//#endregion
+export { GetEventsBatch as $, ColumnKind as $t, createCrdtApplyFunction as A, KyselyStatementFactory as At, defineSyncSchema as B, TableMetadata as Bt, WorkerNotificationMessage as C, PersistedCrdtEvent as Cn, KvStoreItem as Ct, SnapshotOptions as D, ExecuteResult as Dt, CrdtStorageMutator as E, ExecuteParams as Et, CrdtEventValidationError as F, LogLevel as Ft, xxhash as G, deserializeHLC as Gt, SharedLiveQuery as H, HLC as Ht, NewCrdtEventValidationResult as I, Logger as It, SyncedDbExport as J, ReadonlyTable as Jt, ImportDataOptions as K, serializeHLC as Kt, validateNewCrdtEvent as L, startPerformanceLogger as Lt, SchemaVerificationIssue as M, QueryBuilderOutput as Mt, formatSchemaVerificationIssues as N, SQLiteDbWrapper as Nt, createCrdtStorageMutator as O, InternalSQLiteWrapper as Ot, verifySyncSchema as P, SQLiteTransactionWrapper as Pt, CrdtStorage as Q, ColumnBuilder as Qt, DefineSyncSchemaConfig as R, ColumnMetadata as Rt, WorkerConfig as S, CrdtUpdateLogPayload as Sn, tryCatchAsync as St, createCrdtSyncProducer as T, dummyKysely as Tn, createSQLiteKvStore as Tt, SharedLiveQuerySnapshot as U, HLCCounter as Ut, SQLiteReactiveDb as V, introspectDb as Vt, parametersAreEqual as W, compareHLC as Wt, createImportData as X, AnyColumnBuilder as Xt, createExportData as Y, SyncDbSchema as Yt, CrdtChangeIntent as Z, AnyTableBuilder as Zt, EventsPullRequest as _, CRDT_EVENT_NO_OP_PAYLOAD as _n, createTypedEventTarget as _t, SyncedDbDatabase as a, TableBuilder as an, SystemMigrationContext as at, createCrdtSyncRemoteSource as b, CrdtEventType as bn, quoteId as bt, SyncedDbTransaction as c, t as cn, baseSystemMigrations as ct, CRDT_CHANGE_INTENTS_TABLE as d, MigrationsDb as dn, DeferredPromise as dt, ColumnMeta as en, OwnCrdtEvent as et, createCrdtViewStatements as f, SyncDbMigrator as fn, DistributiveOmit as ft, CreateRemoteSourceFactory as g, createStoredValue as gn, createDeferredPromise as gt, CrdtSyncRemoteSource as h, StoredValue as hn, TypedEventTarget as ht, SyncedDb as i, SyncSchemaTables as in, SystemMigration as it, createSQLiteCrdtApplyFunction as j, PreparedStatement as jt, PendingCrdtEvent as k, KyselyQueryFactory as kt, UnsafeSyncedDbSqlExecutor as l, MigratableEvent as ln, createSystemDbConfig as lt, makeCrdtTable as m, createMigrator as mn, TypedEvent as mt, ResetRequest as n, PayloadValidationResult as nn, createCrdtStorage as nt, SyncedDbOptions as o, TableColumns as on, applyMemoryDbSchema as ot, drainCrdtChangeIntents as p, createMigrations as pn, TypedBroadcastChannel as pt, ImportDataResult as q, CrdtTableConfig as qt, ResetStore as r, SqliteStorageType as rn, SystemDbConfig as rt, SyncedDbSqlExecutor as s, TableOptions as sn, applyWorkerDbSchema as st, RESET_REQUEST_TTL_MS as t, InferRow as tn, OwnCrdtSnapshot as tt, createSyncedDb as u, Migrations as un, runSystemMigrations as ut, EventsPushRequest as v, CrdtEventOrigin as vn, generateId as vt, WorkerState as w, isNoOpCrdtEventPayload as wn, createKvStoreTableQuery as wt, EventsPullResponse as x, CrdtUpdateLogItem as xn, tryCatch as xt, EventsPushResponse as y, CrdtEventStatus as yn, jsonSafeParse as yt, DefinedSyncSchema as z, DatabaseIntrospection as zt };
+//# sourceMappingURL=index-Ct_YbBmV.d.ts.map