@sqlite-sync/core 0.8.2 → 0.9.1

package/dist/index-BB-tsxEF.d.ts

@@ -0,0 +1,1203 @@
+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";
+/**
+ * How much of a table an AI agent may use. Consumed by `@sqlite-sync/ai`, which rejects
+ * mutations to `read-only` tables, and leaves `hidden` tables out of the generated schema doc
+ * while rejecting queries that read them.
+ */
+type AiAccess = "read-write" | "read-only" | "hidden";
+/**
+ * Which replicas may author CRDT events for a table. `"any"` (the default) lets every replica
+ * write. `"server"` events are dropped from client pushes.
+ */
+type WriteOrigin = "any" | "server";
+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> {
+  #private;
+  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;
+  /** AI access declared via `.ai()`; "read-write" unless narrowed. */
+  get aiAccess(): AiAccess;
+  /** Who may author events for this table; "any" unless narrowed via `.writes()`. */
+  get writeOrigin(): WriteOrigin;
+  constructor(userColumns: Cols, options?: TableOptions<BaseName>);
+  /** Rebuilds the table with `overrides` applied, carrying over state kept outside the options. */
+  private withOptions;
+  describe(description: string): TableBuilder<Cols, BaseName>;
+  /** Restrict what an AI agent may do with this table; see {@link AiAccess}. */
+  ai(access: AiAccess): TableBuilder<Cols, BaseName>;
+  /** Restrict which replicas may author events for this table; see {@link WriteOrigin}. */
+  writes(origin: WriteOrigin): 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/admit-client-events.d.ts
+type AdmitClientEventsResult<T> = {
+  admitted: T[];
+  skipped: T[];
+};
+type SchemaForAdmitClientEvents = Pick<SyncDbSchema, "tables" | "tablesConfig"> & {
+  writeOriginByName?: ReadonlyMap<string, WriteOrigin>;
+};
+/**
+ * Splits a client push into events the hub should persist and events for tables declared
+ * `.writes("server")`. Unknown datasets stay admitted. Resolves either the crdt or the base
+ * table name.
+ */
+declare function admitClientEvents<T extends {
+  dataset: string;
+}>(opts: {
+  syncDbSchema: SchemaForAdmitClientEvents;
+  events: readonly T[];
+}): AdmitClientEventsResult<T>;
+//#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;
+  /** Write origin keyed by crdt and base table name. */
+  writeOriginByName: ReadonlyMap<string, WriteOrigin>;
+}
+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 { CrdtChangeIntent as $, AnyColumnBuilder as $t, createCrdtApplyFunction as A, InternalSQLiteWrapper as At, defineSyncSchema as B, ColumnMetadata as Bt, WorkerNotificationMessage as C, CrdtEventStatus as Cn, tryCatch as Ct, SnapshotOptions as D, PersistedCrdtEvent as Dn, createSQLiteKvStore as Dt, CrdtStorageMutator as E, CrdtUpdateLogPayload as En, createKvStoreTableQuery as Et, CrdtEventValidationError as F, SQLiteDbWrapper as Ft, SharedLiveQuerySnapshot as G, HLCCounter as Gt, admitClientEvents as H, TableMetadata as Ht, NewCrdtEventValidationResult as I, SQLiteTransactionWrapper as It, ImportDataOptions as J, serializeHLC as Jt, parametersAreEqual as K, compareHLC as Kt, validateNewCrdtEvent as L, LogLevel as Lt, SchemaVerificationIssue as M, KyselyStatementFactory as Mt, formatSchemaVerificationIssues as N, PreparedStatement as Nt, createCrdtStorageMutator as O, isNoOpCrdtEventPayload as On, ExecuteParams as Ot, verifySyncSchema as P, QueryBuilderOutput as Pt, createImportData as Q, AiAccess as Qt, DefineSyncSchemaConfig as R, Logger as Rt, WorkerConfig as S, CrdtEventOrigin as Sn, quoteId as St, createCrdtSyncProducer as T, CrdtUpdateLogItem as Tn, KvStoreItem as Tt, SQLiteReactiveDb as U, introspectDb as Ut, AdmitClientEventsResult as V, DatabaseIntrospection as Vt, SharedLiveQuery as W, HLC as Wt, SyncedDbExport as X, ReadonlyTable as Xt, ImportDataResult as Y, CrdtTableConfig as Yt, createExportData as Z, SyncDbSchema as Zt, EventsPullRequest as _, createMigrations as _n, TypedEventTarget as _t, SyncedDbDatabase as a, PayloadValidationResult as an, SystemDbConfig as at, createCrdtSyncRemoteSource as b, createStoredValue as bn, generateId as bt, SyncedDbTransaction as c, TableBuilder as cn, applyMemoryDbSchema as ct, CRDT_CHANGE_INTENTS_TABLE as d, WriteOrigin as dn, createSystemDbConfig as dt, AnyTableBuilder as en, CrdtStorage as et, createCrdtViewStatements as f, t as fn, runSystemMigrations as ft, CreateRemoteSourceFactory as g, SyncDbMigrator as gn, TypedEvent as gt, CrdtSyncRemoteSource as h, MigrationsDb as hn, TypedBroadcastChannel as ht, SyncedDb as i, InferRow as in, createCrdtStorage as it, createSQLiteCrdtApplyFunction as j, KyselyQueryFactory as jt, PendingCrdtEvent as k, dummyKysely as kn, ExecuteResult as kt, UnsafeSyncedDbSqlExecutor as l, TableColumns as ln, applyWorkerDbSchema as lt, makeCrdtTable as m, Migrations as mn, DistributiveOmit as mt, ResetRequest as n, ColumnKind as nn, OwnCrdtEvent as nt, SyncedDbOptions as o, SqliteStorageType as on, SystemMigration as ot, drainCrdtChangeIntents as p, MigratableEvent as pn, DeferredPromise as pt, xxhash as q, deserializeHLC as qt, ResetStore as r, ColumnMeta as rn, OwnCrdtSnapshot as rt, SyncedDbSqlExecutor as s, SyncSchemaTables as sn, SystemMigrationContext as st, RESET_REQUEST_TTL_MS as t, ColumnBuilder as tn, GetEventsBatch as tt, createSyncedDb as u, TableOptions as un, baseSystemMigrations as ut, EventsPushRequest as v, createMigrator as vn, createDeferredPromise as vt, WorkerState as w, CrdtEventType as wn, tryCatchAsync as wt, EventsPullResponse as x, CRDT_EVENT_NO_OP_PAYLOAD as xn, jsonSafeParse as xt, EventsPushResponse as y, StoredValue as yn, createTypedEventTarget as yt, DefinedSyncSchema as z, startPerformanceLogger as zt };
+//# sourceMappingURL=index-BB-tsxEF.d.ts.map