@sqlite-sync/core 0.6.0 → 0.7.1

package/dist/{crdt-sync-remote-source-CJrVzW-B.d.ts → crdt-sync-remote-source-yXp-iMEd.d.ts}

@@ -1,6 +1,237 @@
-import { CompiledQuery, Compilable, Kysely, CreateTableBuilder, CreateIndexBuilder, ColumnDataType, Expression, ColumnDefinitionBuilderCallback } from 'kysely';
+import { CreateTableBuilder, Compilable, Kysely, CreateIndexBuilder, ColumnDataType, Expression, ColumnDefinitionBuilderCallback, ColumnType, CompiledQuery } from 'kysely';
 import { Sqlite3Static, Database, SqlValue, FunctionOptions } from '@sqlite.org/sqlite-wasm';
 
+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>;
+
+type StoredValue<T> = {
+    get current(): T;
+    set current(newValue: T);
+};
+declare function createStoredValue<T>({ initialValue, saveToStorage, }: {
+    initialValue: T;
+    saveToStorage?: (value: T) => void;
+}): StoredValue<T>;
+
+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 TableRename = {
+    oldTable: string;
+    newTable: string;
+};
+type MigrationStep = {
+    sql: MigrationStepSql | MigrationStepSql[];
+    eventTransformer?: MigrationEventTransformers;
+    tableRenames?: TableRename[];
+    tableDrops?: string[];
+};
+type RawMigrationStep = {
+    sql: MigrationSql[];
+    eventTransformer?: CompiledMigrationEventTransformer;
+    tableRenames?: TableRename[];
+    tableDrops?: string[];
+};
+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>;
+
+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<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type ColumnValue<Column> = Column extends ColumnBuilder<infer Value, boolean> ? Value : never;
+type InferRow<Cols extends TableColumns> = Simplify<{
+    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>;
+};
+
+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>;
+};
+
 interface HLC {
     timestamp: number;
     counter: number;
@@ -21,6 +252,24 @@ declare function serializeHLC(hlc: HLC): string;
 declare function deserializeHLC(serialized: string): HLC;
 declare function compareHLC(one: HLC, two: HLC): number;
 
+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;
+
 type LogLevel = "info" | "warning" | "error" | "trace" | "system";
 type Logger = (type: string, message: string, level?: LogLevel) => void;
 declare const startPerformanceLogger: (logger: Logger) => {
@@ -104,22 +353,6 @@ type TypedStatement<TParams extends Record<string, unknown>, 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;
 
-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;
-    comment: undefined;
-};
-declare function introspectDb<BaseDatabase>(_db: SQLiteDbWrapper<BaseDatabase>): DatabaseIntrospection;
-
 type DeferredPromise<T> = {
     promise: Promise<T>;
     resolve: (value: T) => void;
@@ -169,130 +402,6 @@ type ParsedTableName = {
     fullIdentifier: string;
 };
 
-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" | "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>;
-
-type StoredValue<T> = {
-    get current(): T;
-    set current(newValue: T);
-};
-declare function createStoredValue<T>({ initialValue, saveToStorage, }: {
-    initialValue: T;
-    saveToStorage?: (value: T) => void;
-}): StoredValue<T>;
-
-type CrdtEvent = {
-    type: CrdtEventType;
-    dataset: string;
-    item_id: string;
-    payload: Record<string, unknown>;
-};
-type MigratableEvent = {
-    schema_version: number;
-    type: CrdtEventType;
-    dataset: string;
-    item_id: string;
-    payload: string;
-};
-type CrdtEventTransformer = (event: CrdtEvent) => CrdtEvent | null;
-type MigrationStepSql = {
-    sql: string;
-    parameters?: readonly unknown[];
-} | Compilable | ((db: Kysely<unknown>) => Compilable);
-type TableRename = {
-    oldTable: string;
-    newTable: string;
-};
-type MigrationStep = {
-    sql: MigrationStepSql | MigrationStepSql[];
-    eventTransformer?: MigrationEventTransformers;
-    tableRenames?: TableRename[];
-    tableDrops?: string[];
-};
-type RawMigrationStep = {
-    sql: MigrationSql[];
-    eventTransformer?: CompiledMigrationEventTransformer;
-    tableRenames?: TableRename[];
-    tableDrops?: string[];
-};
-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: CrdtEvent) => CrdtEvent | 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>;
-
 type SystemDbConfig = {
     eventsTable: ParsedTableName;
     updateLogTable: ParsedTableName;
@@ -327,44 +436,6 @@ declare function applyWorkerDbSchema(db: SQLiteDbWrapper<any>): {
 };
 declare function applyMemoryDbSchema(db: SQLiteDbWrapper<any>): void;
 
-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;
-
 type LocalCrdtEvent = {
     type: CrdtEventType;
     dataset: string;
@@ -421,21 +492,23 @@ type DbSyncerStorage = {
     hlc: StorageHLC;
     eventHlcAccumulator?: StoredValue<string>;
     onEventApplied?: (event: PersistedCrdtEvent) => void;
+    schema: Pick<SyncDbSchema, "tables" | "tablesConfig">;
 };
-type CrdtStorage = ReturnType<typeof createCrdtStorage>;
+type CrdtStorage = Omit<ReturnType<typeof createCrdtStorage>, "internal">;
 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;
-    applyOwnEvent: (event: OwnCrdtEvent, { wrapInTransaction }?: {
-        wrapInTransaction?: boolean;
-    }) => void;
-    dispatchEventsApplied: (syncId?: number) => void;
+    applyOwnEvents: (events: OwnCrdtEvent[]) => void;
     checkIsQuiescent: (pushedSyncId: number) => boolean;
     getEventHlcAccumulator: () => string | null;
     addEventListener: <K extends "events-applied" | "remote-event-apply-failed">(type: K, listener: (event: TypedEvent<{
@@ -452,8 +525,54 @@ declare function createCrdtStorage(storage: DbSyncerStorage): {
             syncId: number;
         };
     }[K]>) => void) => void;
+    internal: {
+        applyOwnEventFromTransaction: (tx: InternalSQLiteTransactionWrapper<InternalDbSchema>, event: OwnCrdtEvent) => void;
+        processEnqueuedEvents: {
+            (): Promise<void>;
+            promise(): Promise<void> | null;
+            isExecuting(): boolean;
+        };
+    };
 };
 
+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;
+
 type WorkerNotificationMessage = {
     notificationType: "new-event-chunk-applied";
     newSyncId: number;
@@ -591,4 +710,4 @@ declare const createCrdtSyncRemoteSource: ({ bufferSize, storage, migrator, pull
     }[K]>) => void) => void;
 };
 
-export { type PersistedCrdtEvent as $, createSQLiteCrdtApplyFunction as A, createCrdtStorage as B, type CrdtStorage as C, type DeSyncDetectedReason as D, type ExecuteParams as E, type CrdtSyncRemoteSource as F, createCrdtSyncRemoteSource as G, type HLC as H, type InternalSQLiteWrapper as I, type EventsPullRequest as J, type KyselyQueryFactory as K, type Logger as L, type MigratableEvent as M, type EventsPushRequest as N, type EventsPushResponse as O, type PendingCrdtEvent as P, type QueryBuilderOutput as Q, CRDT_EVENT_NO_OP_PAYLOAD as R, SQLiteDbWrapper as S, TypedEvent as T, type CrdtEventOrigin as U, type CrdtEventStatus as V, type WorkerState as W, type CrdtEventType as X, type CrdtUpdateLogItem as Y, type CrdtUpdateLogPayload as Z, isNoOpCrdtEventPayload as _, type StoredValue as a, createStoredValue as a0, type KyselyStatementFactory as a1, type PreparedStatement as a2, createDeferredPromise as a3, createTypedEventTarget as a4, type DeferredPromise as a5, type DistributiveOmit as a6, generateId as a7, jsonSafeParse as a8, quoteId as a9, TypedBroadcastChannel as aa, type TypedEventTarget as ab, tryCatch as ac, tryCatchAsync as ad, type WorkerConfig as ae, type WorkerNotificationMessage as af, type CreateRemoteSourceFactory as ag, type GetEventsBatch as ah, type EventsPullResponse as ai, type ExecuteResult as b, type SQLiteTransactionWrapper as c, compareHLC as d, deserializeHLC as e, HLCCounter as f, type DatabaseIntrospection as g, type TableMetadata as h, introspectDb as i, type LogLevel as j, startPerformanceLogger as k, createMigrations as l, createMigrator as m, type Migrations as n, type MigrationsDb as o, type SyncDbMigrator as p, applyMemoryDbSchema as q, applyWorkerDbSchema as r, serializeHLC as s, baseSystemMigrations as t, createSystemDbConfig as u, runSystemMigrations as v, type SystemDbConfig as w, type SystemMigration as x, type SystemMigrationContext as y, createCrdtApplyFunction as z };
+export { type TableOptions as $, type AnyTableBuilder as A, baseSystemMigrations as B, type CrdtStorage as C, type DeSyncDetectedReason as D, type ExecuteResult as E, createSystemDbConfig as F, runSystemMigrations as G, type HLC as H, type InternalSQLiteWrapper as I, type SystemDbConfig as J, type KyselyQueryFactory as K, type Logger as L, type Migrations as M, type NewCrdtEvent as N, type SystemMigration as O, type SystemMigrationContext as P, type QueryBuilderOutput as Q, type ReadonlyTable as R, type StoredValue as S, TypedEvent as T, type AnyColumnBuilder as U, ColumnBuilder as V, type WorkerState as W, type ColumnKind as X, type ColumnMeta as Y, type PayloadValidationResult as Z, type SqliteStorageType as _, type CrdtTableConfig as a, t as a0, createCrdtApplyFunction as a1, createSQLiteCrdtApplyFunction as a2, type PendingCrdtEvent as a3, createCrdtStorage as a4, type OwnCrdtEvent as a5, type CrdtSyncRemoteSource as a6, createCrdtSyncRemoteSource as a7, type EventsPullRequest as a8, type EventsPushRequest as a9, type GetEventsBatch as aA, type EventsPullResponse as aB, type EventsPushResponse as aa, CRDT_EVENT_NO_OP_PAYLOAD as ab, type CrdtEventOrigin as ac, type CrdtEventStatus as ad, type CrdtEventType as ae, type CrdtUpdateLogItem as af, type CrdtUpdateLogPayload as ag, isNoOpCrdtEventPayload as ah, type PersistedCrdtEvent as ai, createStoredValue as aj, type KyselyStatementFactory as ak, type PreparedStatement as al, createDeferredPromise as am, createTypedEventTarget as an, type DeferredPromise as ao, type DistributiveOmit as ap, generateId as aq, jsonSafeParse as ar, quoteId as as, TypedBroadcastChannel as at, type TypedEventTarget as au, tryCatch as av, tryCatchAsync as aw, type WorkerConfig as ax, type WorkerNotificationMessage as ay, type CreateRemoteSourceFactory as az, SQLiteDbWrapper as b, type SyncSchemaTables as c, type SyncDbSchema as d, TableBuilder as e, type TableColumns as f, type InferRow as g, type ExecuteParams as h, type SQLiteTransactionWrapper as i, compareHLC as j, deserializeHLC as k, HLCCounter as l, type ColumnMetadata as m, type DatabaseIntrospection as n, introspectDb as o, type TableMetadata as p, type LogLevel as q, startPerformanceLogger as r, serializeHLC as s, createMigrations as t, createMigrator as u, type MigratableEvent as v, type MigrationsDb as w, type SyncDbMigrator as x, applyMemoryDbSchema as y, applyWorkerDbSchema as z };