@sqlite-sync/core 0.0.1

package/dist/crdt-sync-remote-source-rrqinqLn.d.ts

@@ -0,0 +1,271 @@
+import { Sqlite3Static, Database, SqlValue, FunctionOptions } from '@sqlite.org/sqlite-wasm';
+import * as kysely from 'kysely';
+import { CompiledQuery, Compilable, Kysely, SchemaModule } from 'kysely';
+
+type DeferredPromise<T> = {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (error: Error) => void;
+};
+declare function createDeferredPromise<T>(): 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 function ensureSingletonExecution(fn: () => Promise<void>): {
+    (): void;
+    isExecuting(): boolean;
+};
+declare function orderBy<T>(inputArray: T[], picker: (item: T) => any, opts?: {
+    direction?: "asc" | "desc";
+    inPlace?: boolean;
+}): T[];
+declare function createAutoFlushBuffer<T>({ size, flush, }: {
+    size: number;
+    flush: (items: T[]) => void;
+}): {
+    add(item: T): void;
+    flush(): void;
+};
+declare function createAsyncAutoFlushBuffer<T>({ size, flush, }: {
+    size: number;
+    flush: (items: T[]) => void | Promise<void>;
+}): {
+    add(item: T): Promise<void>;
+    flush(): Promise<void>;
+};
+declare class TypedBroadcastChannel<TMessage> {
+    private readonly channel;
+    constructor(name: string);
+    postMessage(message: TMessage): void;
+    set onmessage(callback: (event: MessageEvent<TMessage>) => void);
+}
+declare class TypedEvent<T = unknown> extends Event {
+    readonly payload: T;
+    constructor(type: string, payload: T);
+}
+declare const createTypedEventTarget: <T extends Record<string, unknown>>() => {
+    addEventListener: <K extends keyof T & string>(type: K, listener: (event: TypedEvent<T[K]>) => void) => 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 function jsonSafeParse<T>(json: string): {
+    status: "ok";
+    data: T;
+} | {
+    status: "error";
+    error: unknown;
+};
+
+type LogLevel = "info" | "warning" | "error" | "trace";
+type Logger = (type: string, message: string, level?: LogLevel) => void;
+declare const startPerformanceLogger: (logger: Logger) => {
+    restart: () => void;
+    logEnd: (type: string, message: string, level?: LogLevel) => void;
+};
+
+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 ExecuteParams = {
+    sql: string;
+    parameters: readonly unknown[];
+};
+type ExecuteResult<T> = {
+    rows: T[];
+};
+type PreparedStatement<TParams extends SqlValue[], TResult> = {
+    execute: (parameters: TParams) => TResult[];
+    finalize: () => void;
+    isFinalized: boolean;
+};
+type ScalarFunctionOptions<TArgs extends readonly SqlValue[], TResult extends SqlValue | void> = {
+    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>, "execute" | "sql" | "executeKysely" | "prepare" | "executePrepared" | "prepareKysely">;
+declare class SQLiteDbWrapper<TDatabase = unknown> {
+    private db;
+    private sqlite3;
+    private logger?;
+    private loggerPrefix?;
+    private loadedDbSchema;
+    private readonly dataPointers;
+    private preparedStatements;
+    private preparedStatementsMap;
+    constructor(opts: SqliteWrapperOptions);
+    get ensureDb(): Database;
+    get dbSchema(): DatabaseIntrospection;
+    execute<T = unknown>(opts: ExecuteParams | string | CompiledQuery<T>): ExecuteResult<T>;
+    executeTransaction<T>(callback: (db: SQLiteTransactionWrapper<TDatabase>) => T): T;
+    prepare<TParams extends SqlValue[], TResult>(sql: string): PreparedStatement<TParams, TResult>;
+    prepareKysely<TParams extends Record<string, unknown>>(): <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>): 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>): TResult[];
+    sql<T = unknown>(templateOrString: TemplateStringsArray | string, ...parameters: unknown[]): ExecuteResult<T>;
+    createScalarFunction<TArgs extends SqlValue[], TResult extends SqlValue | void>({ 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;
+
+type PendingCrdtEvent = {
+    type: CrdtEventType;
+    dataset: string;
+    item_id: string;
+    timestamp: string;
+    payload: string;
+};
+type ApplyCrdtParams = {
+    updateLogTableName: string;
+    db: SQLiteTransactionWrapper<any>;
+    event: PendingCrdtEvent;
+};
+declare function applyCrdtEventMutations({ db, event, updateLogTableName, }: ApplyCrdtParams): void;
+
+type CrdtEventType = "item-created" | "item-updated";
+type CrdtEventStatus = "pending" | "applied" | "failed";
+type CrdtEventOrigin = "remote" | (string & {});
+type PersistedCrdtEvent = {
+    sync_id: number;
+    status: CrdtEventStatus;
+    type: CrdtEventType;
+    timestamp: string;
+    origin: CrdtEventOrigin;
+    dataset: string;
+    item_id: string;
+    payload: string;
+};
+type CrdtUpdateLogItem = {
+    dataset: string;
+    item_id: string;
+    payload: string;
+};
+type CrdtUpdateLogPayload = Record<string, string>;
+type MetaItem = {
+    key: string;
+    value: string;
+};
+declare const crdtSchema: {
+    metaTable: typeof createMetaTableQuery;
+    persistedEventsTable: typeof createPersistedEventsTable;
+    crdtUpdateLogTable: typeof createCrdtUpdateLogTableQuery;
+};
+declare function createMetaTableQuery(schema: SchemaModule, tableName: string): kysely.CreateTableBuilder<string, "key" | "value">;
+declare function createPersistedEventsTable(schema: SchemaModule, tableName: string): kysely.CreateTableBuilder<string, "type" | "timestamp" | "sync_id" | "status" | "origin" | "dataset" | "item_id" | "payload">;
+declare function createCrdtUpdateLogTableQuery(schema: SchemaModule, tableName: string): kysely.CreateTableBuilder<string, "dataset" | "item_id" | "payload">;
+declare function registerCrdtFunctions({ db, onEventApplied, getNextTimestamp, getTableSchema, updateLogTableName, }: {
+    db: SQLiteDbWrapper<any>;
+    onEventApplied: (event: PendingCrdtEvent) => void;
+    getNextTimestamp: () => string;
+    getTableSchema: (dataset: string) => TableMetadata;
+    updateLogTableName: string;
+}): void;
+
+type SyncIdCounter = {
+    get current(): number;
+    set current(newSyncId: number);
+};
+declare function createSyncIdCounter({ initialSyncId, saveToStorage, }: {
+    initialSyncId: number;
+    saveToStorage?: (syncId: number) => void;
+}): SyncIdCounter;
+
+type LocalCrdtEvent = {
+    type: CrdtEventType;
+    timestamp: string;
+    dataset: string;
+    item_id: string;
+    payload: string;
+    origin: CrdtEventOrigin;
+};
+type PendingEventsBatch = {
+    events: PersistedCrdtEvent[];
+    hasMore: boolean;
+};
+type DbSyncerStorage = {
+    syncId: SyncIdCounter;
+    persistEvents: (events: PersistedCrdtEvent[]) => void;
+    popPendingEventsBatch: () => PendingEventsBatch;
+    updateEventStatus: (syncId: number, status: CrdtEventStatus) => void;
+    applyCrdtEventMutations: (event: PersistedCrdtEvent) => void;
+};
+type CrdtStorage = ReturnType<typeof createCrdtStorage>;
+declare function createCrdtStorage(storage: DbSyncerStorage): {
+    enqueueEvents: (events: LocalCrdtEvent[]) => {
+        firstEventSyncId: number;
+        lastEventSyncId: number;
+    };
+    addEventListener: <K extends "event-applied" | "event-processing-done">(type: K, listener: (event: TypedEvent<{
+        "event-applied": PersistedCrdtEvent;
+        "event-processing-done": void;
+    }[K]>) => void) => void;
+    removeEventListener: <K extends "event-applied" | "event-processing-done">(type: K, listener: (event: TypedEvent<{
+        "event-applied": PersistedCrdtEvent;
+        "event-processing-done": void;
+    }[K]>) => void) => void;
+    dispatchEvent: <K extends "event-applied" | "event-processing-done">(type: K, payload: {
+        "event-applied": PersistedCrdtEvent;
+        "event-processing-done": void;
+    }[K]) => void;
+};
+
+type CrdtSyncRemoteSourceConfig = {
+    bufferSize: number;
+    storage: CrdtStorage;
+    syncId: SyncIdCounter;
+    nodeId: string;
+    pullEvents: (request: EventsPullRequest) => EventsPullResponse | Promise<EventsPullResponse>;
+    pushEvents: (request: EventsPushRequest) => EventsPushResponse | Promise<EventsPushResponse>;
+};
+type EventsPullRequest = {
+    afterSyncId: number;
+    excludeNodeId?: string;
+};
+type EventsPullResponse = {
+    events: PersistedCrdtEvent[];
+    newSyncId: number;
+    hasMore: boolean;
+};
+type EventsPushRequest = {
+    nodeId: string;
+    events: PendingCrdtEvent[];
+};
+type EventsPushResponse = {
+    ok: boolean;
+};
+type CrdtSyncRemoteSource = ReturnType<typeof createCrdtSyncRemoteSource>;
+declare const createCrdtSyncRemoteSource: ({ bufferSize, storage, syncId, nodeId, pullEvents: pullEventsChunk, pushEvents, }: CrdtSyncRemoteSourceConfig) => {
+    pullEvents: (request?: {
+        afterSyncId?: number;
+        includeSelf?: boolean;
+    }) => Promise<void>;
+};
+
+export { createAutoFlushBuffer as A, createAsyncAutoFlushBuffer as B, type CrdtEventType as C, createTypedEventTarget as D, type EventsPushRequest as E, jsonSafeParse as F, type DeferredPromise as G, type DistributiveOmit as H, startPerformanceLogger as I, type LogLevel as J, type KyselyQueryFactory as K, type Logger as L, type MetaItem as M, introspectDb as N, type TableMetadata as O, type PersistedCrdtEvent as P, type QueryBuilderOutput as Q, type DatabaseIntrospection as R, SQLiteDbWrapper as S, TypedEvent as T, type CrdtEventOrigin as a, type EventsPushResponse as b, type ExecuteParams as c, type ExecuteResult as d, type EventsPullRequest as e, type EventsPullResponse as f, TypedBroadcastChannel as g, type PreparedStatement as h, type SQLiteTransactionWrapper as i, applyCrdtEventMutations as j, type PendingCrdtEvent as k, createCrdtStorage as l, type CrdtStorage as m, createCrdtSyncRemoteSource as n, type CrdtSyncRemoteSource as o, crdtSchema as p, type CrdtEventStatus as q, registerCrdtFunctions as r, type CrdtUpdateLogItem as s, type CrdtUpdateLogPayload as t, createSyncIdCounter as u, type SyncIdCounter as v, generateId as w, createDeferredPromise as x, ensureSingletonExecution as y, orderBy as z };

package/dist/index.d.ts

@@ -0,0 +1,268 @@
+import { S as SQLiteDbWrapper, L as Logger, T as TypedEvent, C as CrdtEventType, a as CrdtEventOrigin, P as PersistedCrdtEvent, E as EventsPushRequest, b as EventsPushResponse, c as ExecuteParams, d as ExecuteResult, e as EventsPullRequest, f as EventsPullResponse, g as TypedBroadcastChannel } from './crdt-sync-remote-source-rrqinqLn.js';
+export { q as CrdtEventStatus, m as CrdtStorage, o as CrdtSyncRemoteSource, s as CrdtUpdateLogItem, t as CrdtUpdateLogPayload, R as DatabaseIntrospection, G as DeferredPromise, H as DistributiveOmit, K as KyselyQueryFactory, J as LogLevel, M as MetaItem, k as PendingCrdtEvent, h as PreparedStatement, Q as QueryBuilderOutput, i as SQLiteTransactionWrapper, v as SyncIdCounter, O as TableMetadata, j as applyCrdtEventMutations, p as crdtSchema, B as createAsyncAutoFlushBuffer, A as createAutoFlushBuffer, l as createCrdtStorage, n as createCrdtSyncRemoteSource, x as createDeferredPromise, u as createSyncIdCounter, D as createTypedEventTarget, y as ensureSingletonExecution, w as generateId, N as introspectDb, F as jsonSafeParse, z as orderBy, r as registerCrdtFunctions, I as startPerformanceLogger } from './crdt-sync-remote-source-rrqinqLn.js';
+import { Driver, DatabaseConnection, Kysely, Migration, Migrator } from 'kysely';
+export { c as createCrdtSyncProducer, d as dummyKysely } from './crdt-sync-producer-0toEpGf0.js';
+import '@sqlite.org/sqlite-wasm';
+
+type TableName<Database> = keyof Database extends string ? keyof Database : never;
+type SQLiteReactiveDbOptions = {
+    snapshot?: Uint8Array<ArrayBufferLike>;
+    logger?: Logger;
+};
+type EventsMap = {
+    "transaction-committed": void;
+    "transaction-rolled-back": void;
+    "any-table-changed": void;
+} & Record<`table:${string}`, void>;
+declare function createSQLiteReactiveDb<Database>(opts: SQLiteReactiveDbOptions): Promise<SQLiteReactiveDb<Database>>;
+declare class SQLiteReactiveDb<Database> {
+    readonly db: SQLiteDbWrapper<Database>;
+    private sqlite3;
+    private readonly logger;
+    private tablesUsedStatement;
+    private eventTarget;
+    private constructor();
+    static create<Database>(opts: SQLiteReactiveDbOptions): Promise<SQLiteReactiveDb<Database>>;
+    createLiveQuery<TResult>(query: {
+        sql: string;
+        parameters: readonly unknown[];
+    }): {
+        getRows: () => TResult[];
+        refresh: () => void;
+        subscribe: (onchange: () => void) => () => void;
+    };
+    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;
+    notifyTableSubscribers(tables?: (TableName<Database> | (string & {}))[]): void;
+    private registerDbHooks;
+    createSnapshot(): Uint8Array<ArrayBuffer>;
+    useSnapshot(snapshot: Uint8Array<ArrayBufferLike>): void;
+}
+
+interface HLC {
+    timestamp: number;
+    counter: number;
+    nodeId: string;
+}
+declare class HLCCounter {
+    private timestamp;
+    private counter;
+    private nodeId;
+    private readonly getTimestamp;
+    constructor(nodeId: string, getTimestamp: () => number);
+    getCurrentHLC(): HLC;
+    getNextHLC(): HLC;
+    mergeHLC(hlc: HLC): void;
+}
+declare function serializeHLC(hlc: HLC): string;
+declare function deserializeHLC(serialized: string): {
+    timestamp: number;
+    counter: number;
+    nodeId: string;
+};
+declare function compareHLC(one: HLC, two: HLC): number;
+
+type MemoryDbCrdtTableConfig = {
+    baseTableName: string;
+    crdtTableName: string;
+};
+type MemoryDbOptions<Database> = {
+    reactiveDb: SQLiteReactiveDb<Database>;
+    hlcCounter: HLCCounter;
+    tabId: string;
+    crdtTables: MemoryDbCrdtTableConfig[];
+};
+declare function createMemoryDb<Database>({ reactiveDb: _reactiveDb, hlcCounter, tabId, crdtTables, }: MemoryDbOptions<Database>): Promise<{
+    crdtStorage: {
+        enqueueEvents: (events: {
+            type: CrdtEventType;
+            timestamp: string;
+            dataset: string;
+            item_id: string;
+            payload: string;
+            origin: CrdtEventOrigin;
+        }[]) => {
+            firstEventSyncId: number;
+            lastEventSyncId: number;
+        };
+        addEventListener: <K extends "event-applied" | "event-processing-done">(type: K, listener: (event: TypedEvent<{
+            "event-applied": PersistedCrdtEvent;
+            "event-processing-done": void;
+        }[K]>) => void) => void;
+        removeEventListener: <K extends "event-applied" | "event-processing-done">(type: K, listener: (event: TypedEvent<{
+            "event-applied": PersistedCrdtEvent;
+            "event-processing-done": void;
+        }[K]>) => void) => void;
+        dispatchEvent: <K extends "event-applied" | "event-processing-done">(type: K, payload: {
+            "event-applied": PersistedCrdtEvent;
+            "event-processing-done": void;
+        }[K]) => void;
+    };
+}>;
+
+type SyncedDbOptions = {
+    dbPath: string;
+    clearOnInit?: boolean;
+    crdtTables: MemoryDbCrdtTableConfig[];
+    worker: Worker;
+};
+declare function createSyncedDb<Database>(options: SyncedDbOptions): Promise<{
+    db: SQLiteDbWrapper<Database>;
+    reactiveDb: Omit<SQLiteReactiveDb<Database>, "db">;
+    workerDb: {
+        addEventListener: <K extends "new-notification">(type: K, listener: (event: TypedEvent<{
+            "new-notification": WorkerNotificationMessage;
+        }[K]>) => void) => void;
+        removeEventListener: <K extends "new-notification">(type: K, listener: (event: TypedEvent<{
+            "new-notification": WorkerNotificationMessage;
+        }[K]>) => void) => void;
+        getSnapshot: () => Promise<GetSnapshotResponse>;
+        pushTabEvents: (request: EventsPushRequest) => Promise<EventsPushResponse>;
+        execute: (query: ExecuteParams) => Promise<ExecuteResult<unknown>>;
+        pullEvents: (params: EventsPullRequest) => Promise<EventsPullResponse>;
+        postInitReady: () => Promise<void>;
+    };
+}>;
+type SyncedDb<Database> = Awaited<ReturnType<typeof createSyncedDb<Database>>>;
+
+type SqliteDatabase = {
+    execute: (opts: {
+        sql: string;
+        parameters: readonly unknown[];
+    }) => {
+        rows: unknown[];
+    };
+    close: () => void;
+};
+declare class SqliteDriver implements Driver {
+    #private;
+    constructor(db: SqliteDatabase);
+    init(): Promise<void>;
+    acquireConnection(): Promise<DatabaseConnection>;
+    beginTransaction(connection: DatabaseConnection): Promise<void>;
+    commitTransaction(connection: DatabaseConnection): Promise<void>;
+    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    releaseConnection(): Promise<void>;
+    destroy(): Promise<void>;
+}
+declare function createSQLiteKysely<Database>(sqliteDb: SqliteDatabase): Kysely<Database>;
+
+type SyncDbMigratorOptions = {
+    db: Kysely<unknown>;
+    migrations: Record<string, Migration>;
+};
+declare function createSyncDbMigrator(options: SyncDbMigratorOptions): Migrator;
+declare function createSyncDbMigrations(migrations: Record<number, Migration>): Record<number, Migration>;
+
+declare function applyWorkerDbSchema(db: SQLiteDbWrapper<any>): void;
+declare function applyMemoryDbSchema(db: SQLiteDbWrapper<any>): void;
+
+declare function makeCrdtTable({ db, baseTableName, crdtTableName, }: {
+    db: SQLiteDbWrapper<any>;
+    baseTableName: string;
+    crdtTableName: string;
+}): void;
+
+declare const syncDbWorkerLockName = "sync-db-worker-lock";
+type WorkerNotificationMessage = {
+    notificationType: "new-event-chunk-applied";
+    newSyncId: number;
+};
+type PushTabEventsResponse = {
+    firstEventSyncId: number;
+    lastEventSyncId: number;
+};
+type GetSnapshotResponse = {
+    file: Uint8Array<ArrayBufferLike>;
+    syncId: number;
+};
+interface WorkerRpc {
+    getSnapshot: () => GetSnapshotResponse;
+    pushTabEvents: (request: EventsPushRequest) => EventsPushResponse;
+    execute: (query: ExecuteParams) => ExecuteResult<unknown>;
+    pullEvents: (params: EventsPullRequest) => EventsPullResponse;
+    postInitReady: () => void;
+}
+type WorkerRequestMethod = keyof WorkerRpc;
+type WorkerRequestMessage<TMethod extends WorkerRequestMethod = WorkerRequestMethod> = {
+    type: "request";
+    requestId: string;
+    method: TMethod;
+    args: Parameters<WorkerRpc[TMethod]>;
+};
+type WorkerResponseMessage<TMethod extends WorkerRequestMethod = WorkerRequestMethod> = {
+    type: "response";
+    requestId: string;
+    data: ReturnType<WorkerRpc[TMethod]>;
+};
+type AsyncRpc<T> = {
+    [K in keyof T]: T[K] extends (...args: infer U) => infer V ? (...args: U) => V extends Promise<infer W> ? Promise<W> : Promise<V> : never;
+};
+declare const broadcastChannelNames: {
+    readonly requests: "sync-db-worker-requests";
+    readonly responses: "sync-db-worker-responses";
+};
+type WorkerBroadcastChannels = {
+    requests: TypedBroadcastChannel<WorkerRequestMessage>;
+    responses: TypedBroadcastChannel<WorkerResponseMessage | WorkerNotificationMessage | WorkerInitResponse>;
+};
+declare const createBroadcastChannels: () => WorkerBroadcastChannels;
+type WorkerConfig = {
+    dbPath: string;
+    clientId: string;
+    clearOnInit?: boolean;
+    syncServer: SyncServerConfig;
+};
+type SyncServerConfig = {
+    host: string;
+    room: string;
+};
+type WorkerInitMessage = {
+    type: "init";
+    config: WorkerConfig;
+};
+declare function isWorkerInitMessage(message: unknown): message is WorkerInitMessage;
+type WorkerInitResponse = {
+    type: "init-ready";
+};
+declare function isWorkerInitResponse(message: unknown): message is WorkerInitResponse;
+declare function isWorkerRequestMessage(message: unknown): message is WorkerRequestMessage;
+declare function isWorkerResponseMessage(message: unknown): message is WorkerResponseMessage;
+declare function isWorkerNotificationMessage(message: unknown): message is WorkerNotificationMessage;
+
+declare const createWorkerDbClient: ({ broadcastChannels, }: {
+    broadcastChannels: WorkerBroadcastChannels;
+}) => {
+    addEventListener: <K extends "new-notification">(type: K, listener: (event: TypedEvent<{
+        "new-notification": WorkerNotificationMessage;
+    }[K]>) => void) => void;
+    removeEventListener: <K extends "new-notification">(type: K, listener: (event: TypedEvent<{
+        "new-notification": WorkerNotificationMessage;
+    }[K]>) => void) => void;
+    getSnapshot: () => Promise<GetSnapshotResponse>;
+    pushTabEvents: (request: EventsPushRequest) => Promise<EventsPushResponse>;
+    execute: (query: ExecuteParams) => Promise<ExecuteResult<unknown>>;
+    pullEvents: (params: EventsPullRequest) => Promise<EventsPullResponse>;
+    postInitReady: () => Promise<void>;
+};
+declare function initializeWorkerDb({ worker, broadcastChannels, config, }: {
+    worker: Worker;
+    broadcastChannels: WorkerBroadcastChannels;
+    config: WorkerConfig;
+}): Promise<void>;
+
+export { type AsyncRpc, CrdtEventOrigin, CrdtEventType, EventsPullRequest, EventsPullResponse, EventsPushRequest, EventsPushResponse, ExecuteParams, ExecuteResult, type GetSnapshotResponse, type HLC, HLCCounter, Logger, type MemoryDbCrdtTableConfig, PersistedCrdtEvent, type PushTabEventsResponse, SQLiteDbWrapper, SQLiteReactiveDb, SqliteDriver, type SyncServerConfig, type SyncedDb, TypedBroadcastChannel, TypedEvent, type WorkerBroadcastChannels, type WorkerConfig, type WorkerInitMessage, type WorkerInitResponse, type WorkerNotificationMessage, type WorkerRequestMessage, type WorkerRequestMethod, type WorkerResponseMessage, type WorkerRpc, applyMemoryDbSchema, applyWorkerDbSchema, broadcastChannelNames, compareHLC, createBroadcastChannels, createMemoryDb, createSQLiteKysely, createSQLiteReactiveDb, createSyncDbMigrations, createSyncDbMigrator, createSyncedDb, createWorkerDbClient, deserializeHLC, initializeWorkerDb, isWorkerInitMessage, isWorkerInitResponse, isWorkerNotificationMessage, isWorkerRequestMessage, isWorkerResponseMessage, makeCrdtTable, serializeHLC, syncDbWorkerLockName };