@sqlite-sync/core 0.11.0 → 0.12.1

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

@@ -415,6 +415,10 @@ 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;
+declare function compileKyselyStatement<TParams extends Record<string, unknown>, TDatabase>(factory: KyselyStatementFactory<TParams, TDatabase, Compilable<unknown>>): {
+  sql: string;
+  bindParameters: (parameters: TParams) => unknown[];
+};
 //#endregion
 //#region src/sqlite-kv-store.d.ts
 type KvStoreItem = {
@@ -949,7 +953,7 @@ type WorkerNotificationMessage = {
   localSchemaVersion: number;
 };
 type WorkerState = {
-  remoteState: "online" | "offline" | "pending";
+  remoteState: "online" | "offline" | "connecting";
   deSynced: boolean;
   schemaVersionMismatched: boolean;
 };
@@ -1004,24 +1008,26 @@ type EventsAvailable = {
   remoteEventHlcSum: string | null;
 };
 /**
- * Opens a connection to the remote. Each call must return an independent source: the library calls
- * `disconnect` on every returned source exactly once, including one that resolves after `signal`
- * has aborted. `signal` aborts when the connection attempt is cancelled or the connection is closed.
- * Call `onReconnected` when the transport re-establishes itself without a new source: broadcasts
- * sent while it was down are lost, so the library pulls and pushes to catch up.
+ * Opens one connection to the remote. Each call must return a new source: the library calls `disconnect` on every
+ * returned source exactly once. Call `onClosed` when the connection ends on its own, at any time including during
+ * this call; the library then reconnects with backoff. Requests may wait for the connection to open and should
+ * reject once it closes. The library times requests out and shows the remote as online after the first one succeeds.
+ * With `ping`, the library also checks idle connections and replaces one whose ping fails or times out. It calls `ping`
+ * only on an online connection, one at a time, and never after the connection closes; a ping does not need to settle
+ * once the source has closed.
  */
 type CreateRemoteSourceFactory = (opts: {
   onEventsAvailable: (event: EventsAvailable) => void;
-  onReconnected: () => void;
-  signal: AbortSignal;
-}) => RemoteSource | Promise<RemoteSource>;
+  onClosed: (error?: unknown) => void;
+}) => RemoteSource;
 type RemoteSource = {
   pullEvents: (request: EventsPullRequest) => Promise<EventsPullResponse>;
   pushEvents: (request: EventsPushRequest) => Promise<EventsPushResponse>;
+  ping?: () => Promise<void>;
   disconnect?: () => void | Promise<void>;
 };
 type RemoteSourceState = {
-  type: "pending";
+  type: "connecting";
   deSynced: boolean;
   schemaVersionMismatched: boolean;
 } | {
@@ -1034,11 +1040,12 @@ type RemoteSourceState = {
   deSynced: boolean;
   schemaVersionMismatched: boolean;
 };
-type OfflineReason = "NOT_INITIALIZED" | "INITIALIZATION_FAILED" | "REMOTE_PUSH_ERROR" | "REMOTE_PULL_ERROR" | "DISCONNECTED";
+type OfflineReason = "NOT_INITIALIZED" | "INITIALIZATION_FAILED" | "REMOTE_PUSH_ERROR" | "REMOTE_PULL_ERROR" | "CONNECTION_LOST" | "NETWORK_OFFLINE" | "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>;
+  dropConnection: (reason: OfflineReason) => void;
   syncWithRemote: () => Promise<void>;
   getState: () => WorkerState;
   dispose: () => Promise<void>;
@@ -1092,9 +1099,12 @@ declare function drainCrdtChangeIntents({ tx, storage }: {
 type SyncedDbOptions<Database, Props = undefined> = {
   dbId: string;
   worker: Worker;
-  workerProps: Props;
   syncDbSchema: SyncDbSchema<Database>;
-};
+} & (undefined extends Props ? {
+  workerProps?: Props;
+} : {
+  workerProps: Props;
+});
 /** SQL execution that participates in CRDT intent draining. */
 type SyncedDbSqlExecutor<Database> = {
   execute<TResult = unknown>(query: ExecuteParams | string | CompiledQuery<TResult>): ExecuteResult<TResult>;
@@ -1218,5 +1228,5 @@ type ResetStore = {
  */
 declare const RESET_REQUEST_TTL_MS: number;
 //#endregion
-export { createExportData as $, SyncDbSchema as $t, PendingCrdtEvent as A, PersistedCrdtEvent as An, ExecuteParams as At, DefinedSyncSchema as B, Logger as Bt, WorkerConfig as C, createStoredValue as Cn, jsonSafeParse as Ct, CrdtStorageMutator as D, CrdtEventType as Dn, KvStoreItem as Dt, createCrdtSyncProducer as E, CrdtEventStatus as En, tryCatchAsync as Et, verifySyncSchema as F, PreparedStatement as Ft, SQLiteReactiveDb as G, introspectDb as Gt, AdmitClientEventsResult as H, ColumnMetadata as Ht, CrdtEventValidationError as I, QueryBuilderOutput as It, parametersAreEqual as J, compareHLC as Jt, SharedLiveQuery as K, HLC as Kt, NewCrdtEventValidationResult as L, SQLiteDbWrapper as Lt, createSQLiteCrdtApplyFunction as M, dummyKysely as Mn, InternalSQLiteWrapper as Mt, SchemaVerificationIssue as N, KyselyQueryFactory as Nt, SnapshotOptions as O, CrdtUpdateLogItem as On, createKvStoreTableQuery as Ot, formatSchemaVerificationIssues as P, KyselyStatementFactory as Pt, SyncedDbExport as Q, ReadonlyTable as Qt, validateNewCrdtEvent as R, SQLiteTransactionWrapper as Rt, EventsPullResponse as S, StoredValue as Sn, generateId as St, WorkerState as T, CrdtEventOrigin as Tn, tryCatch as Tt, ClientDatasetRejectionReason as U, DatabaseIntrospection as Ut, defineSyncSchema as V, startPerformanceLogger as Vt, admitClientEvents as W, TableMetadata as Wt, ImportDataOptions as X, serializeHLC as Xt, xxhash as Y, deserializeHLC as Yt, ImportDataResult as Z, CrdtTableConfig as Zt, CreateRemoteSourceFactory as _, Migrations as _n, TypedBroadcastChannel as _t, SyncedDbDatabase as a, ColumnMeta as an, OwnCrdtSnapshot as at, EventsPushResponse as b, createMigrations as bn, createDeferredPromise as bt, SyncedDbTransaction as c, PayloadValidationResult as cn, SystemMigration as ct, CRDT_CHANGE_INTENTS_TABLE as d, TableBuilder as dn, applyWorkerDbSchema as dt, AiAccess as en, createImportData as et, crdtViewColumnsFromTable as f, TableColumns as fn, baseSystemMigrations as ft, CrdtSyncRemoteSource as g, MigratableEvent as gn, DistributiveOmit as gt, makeCrdtTable as h, t as hn, DeferredPromise as ht, SyncedDb as i, ColumnKind as in, OwnCrdtEvent as it, createCrdtApplyFunction as j, isNoOpCrdtEventPayload as jn, ExecuteResult as jt, createCrdtStorageMutator as k, CrdtUpdateLogPayload as kn, createSQLiteKvStore as kt, UnsafeSyncedDbSqlExecutor as l, SqliteStorageType as ln, SystemMigrationContext as lt, drainCrdtChangeIntents as m, WriteOrigin as mn, runSystemMigrations as mt, ResetRequest as n, AnyTableBuilder as nn, CrdtStorage as nt, SyncedDbOptions as o, ExportImportMode as on, createCrdtStorage as ot, createCrdtViewStatements as p, TableOptions as pn, createSystemDbConfig as pt, SharedLiveQuerySnapshot as q, HLCCounter as qt, ResetStore as r, ColumnBuilder as rn, GetEventsBatch as rt, SyncedDbSqlExecutor as s, InferRow as sn, SystemDbConfig as st, RESET_REQUEST_TTL_MS as t, AnyColumnBuilder as tn, CrdtChangeIntent as tt, createSyncedDb as u, SyncSchemaTables as un, applyMemoryDbSchema as ut, EventsPullRequest as v, MigrationsDb as vn, TypedEvent as vt, WorkerNotificationMessage as w, CRDT_EVENT_NO_OP_PAYLOAD as wn, quoteId as wt, createCrdtSyncRemoteSource as x, createMigrator as xn, createTypedEventTarget as xt, EventsPushRequest as y, SyncDbMigrator as yn, TypedEventTarget as yt, DefineSyncSchemaConfig as z, LogLevel as zt };
-//# sourceMappingURL=index-UfgvV97h.d.ts.map
+export { createExportData as $, ReadonlyTable as $t, PendingCrdtEvent as A, CrdtUpdateLogPayload as An, ExecuteParams as At, DefinedSyncSchema as B, LogLevel as Bt, WorkerConfig as C, StoredValue as Cn, jsonSafeParse as Ct, CrdtStorageMutator as D, CrdtEventStatus as Dn, KvStoreItem as Dt, createCrdtSyncProducer as E, CrdtEventOrigin as En, tryCatchAsync as Et, verifySyncSchema as F, PreparedStatement as Ft, SQLiteReactiveDb as G, TableMetadata as Gt, AdmitClientEventsResult as H, startPerformanceLogger as Ht, CrdtEventValidationError as I, QueryBuilderOutput as It, parametersAreEqual as J, HLCCounter as Jt, SharedLiveQuery as K, introspectDb as Kt, NewCrdtEventValidationResult as L, SQLiteDbWrapper as Lt, createSQLiteCrdtApplyFunction as M, isNoOpCrdtEventPayload as Mn, InternalSQLiteWrapper as Mt, SchemaVerificationIssue as N, dummyKysely as Nn, KyselyQueryFactory as Nt, SnapshotOptions as O, CrdtEventType as On, createKvStoreTableQuery as Ot, formatSchemaVerificationIssues as P, KyselyStatementFactory as Pt, SyncedDbExport as Q, CrdtTableConfig as Qt, validateNewCrdtEvent as R, SQLiteTransactionWrapper as Rt, EventsPullResponse as S, createMigrator as Sn, generateId as St, WorkerState as T, CRDT_EVENT_NO_OP_PAYLOAD as Tn, tryCatch as Tt, ClientDatasetRejectionReason as U, ColumnMetadata as Ut, defineSyncSchema as V, Logger as Vt, admitClientEvents as W, DatabaseIntrospection as Wt, ImportDataOptions as X, deserializeHLC as Xt, xxhash as Y, compareHLC as Yt, ImportDataResult as Z, serializeHLC as Zt, CreateRemoteSourceFactory as _, MigratableEvent as _n, TypedBroadcastChannel as _t, SyncedDbDatabase as a, ColumnKind as an, OwnCrdtSnapshot as at, EventsPushResponse as b, SyncDbMigrator as bn, createDeferredPromise as bt, SyncedDbTransaction as c, InferRow as cn, SystemMigration as ct, CRDT_CHANGE_INTENTS_TABLE as d, SyncSchemaTables as dn, applyWorkerDbSchema as dt, SyncDbSchema as en, createImportData as et, crdtViewColumnsFromTable as f, TableBuilder as fn, baseSystemMigrations as ft, CrdtSyncRemoteSource as g, t as gn, DistributiveOmit as gt, makeCrdtTable as h, WriteOrigin as hn, DeferredPromise as ht, SyncedDb as i, ColumnBuilder as in, OwnCrdtEvent as it, createCrdtApplyFunction as j, PersistedCrdtEvent as jn, ExecuteResult as jt, createCrdtStorageMutator as k, CrdtUpdateLogItem as kn, createSQLiteKvStore as kt, UnsafeSyncedDbSqlExecutor as l, PayloadValidationResult as ln, SystemMigrationContext as lt, drainCrdtChangeIntents as m, TableOptions as mn, runSystemMigrations as mt, ResetRequest as n, AnyColumnBuilder as nn, CrdtStorage as nt, SyncedDbOptions as o, ColumnMeta as on, createCrdtStorage as ot, createCrdtViewStatements as p, TableColumns as pn, createSystemDbConfig as pt, SharedLiveQuerySnapshot as q, HLC as qt, ResetStore as r, AnyTableBuilder as rn, GetEventsBatch as rt, SyncedDbSqlExecutor as s, ExportImportMode as sn, SystemDbConfig as st, RESET_REQUEST_TTL_MS as t, AiAccess as tn, CrdtChangeIntent as tt, createSyncedDb as u, SqliteStorageType as un, applyMemoryDbSchema as ut, EventsPullRequest as v, Migrations as vn, TypedEvent as vt, WorkerNotificationMessage as w, createStoredValue as wn, quoteId as wt, createCrdtSyncRemoteSource as x, createMigrations as xn, createTypedEventTarget as xt, EventsPushRequest as y, MigrationsDb as yn, TypedEventTarget as yt, DefineSyncSchemaConfig as z, compileKyselyStatement as zt };
+//# sourceMappingURL=index-BHsKLqcK.d.ts.map

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { $ as createExportData, $t as SyncDbSchema, A as PendingCrdtEvent, An as PersistedCrdtEvent, At as ExecuteParams, B as DefinedSyncSchema, Bt as Logger, C as WorkerConfig, Cn as createStoredValue, Ct as jsonSafeParse, D as CrdtStorageMutator, Dn as CrdtEventType, Dt as KvStoreItem, E as createCrdtSyncProducer, En as CrdtEventStatus, Et as tryCatchAsync, F as verifySyncSchema, Ft as PreparedStatement, G as SQLiteReactiveDb, Gt as introspectDb, H as AdmitClientEventsResult, Ht as ColumnMetadata, I as CrdtEventValidationError, It as QueryBuilderOutput, J as parametersAreEqual, Jt as compareHLC, K as SharedLiveQuery, Kt as HLC, L as NewCrdtEventValidationResult, Lt as SQLiteDbWrapper, M as createSQLiteCrdtApplyFunction, Mn as dummyKysely, N as SchemaVerificationIssue, Nt as KyselyQueryFactory, O as SnapshotOptions, On as CrdtUpdateLogItem, Ot as createKvStoreTableQuery, P as formatSchemaVerificationIssues, Q as SyncedDbExport, Qt as ReadonlyTable, R as validateNewCrdtEvent, Rt as SQLiteTransactionWrapper, Sn as StoredValue, St as generateId, T as WorkerState, Tn as CrdtEventOrigin, Tt as tryCatch, Ut as DatabaseIntrospection, V as defineSyncSchema, Vt as startPerformanceLogger, W as admitClientEvents, Wt as TableMetadata, X as ImportDataOptions, Xt as serializeHLC, Y as xxhash, Yt as deserializeHLC, Z as ImportDataResult, Zt as CrdtTableConfig, _n as Migrations, _t as TypedBroadcastChannel, a as SyncedDbDatabase, an as ColumnMeta, at as OwnCrdtSnapshot, b as EventsPushResponse, bn as createMigrations, bt as createDeferredPromise, c as SyncedDbTransaction, cn as PayloadValidationResult, ct as SystemMigration, dn as TableBuilder, dt as applyWorkerDbSchema, en as AiAccess, et as createImportData, fn as TableColumns, g as CrdtSyncRemoteSource, gn as MigratableEvent, gt as DistributiveOmit, h as makeCrdtTable, hn as t, ht as DeferredPromise, i as SyncedDb, in as ColumnKind, it as OwnCrdtEvent, j as createCrdtApplyFunction, jn as isNoOpCrdtEventPayload, jt as ExecuteResult, k as createCrdtStorageMutator, kn as CrdtUpdateLogPayload, kt as createSQLiteKvStore, l as UnsafeSyncedDbSqlExecutor, ln as SqliteStorageType, lt as SystemMigrationContext, mn as WriteOrigin, n as ResetRequest, nn as AnyTableBuilder, nt as CrdtStorage, o as SyncedDbOptions, on as ExportImportMode, ot as createCrdtStorage, pn as TableOptions, q as SharedLiveQuerySnapshot, qt as HLCCounter, r as ResetStore, rn as ColumnBuilder, s as SyncedDbSqlExecutor, sn as InferRow, st as SystemDbConfig, t as RESET_REQUEST_TTL_MS, tn as AnyColumnBuilder, u as createSyncedDb, un as SyncSchemaTables, ut as applyMemoryDbSchema, v as EventsPullRequest, vn as MigrationsDb, vt as TypedEvent, w as WorkerNotificationMessage, wn as CRDT_EVENT_NO_OP_PAYLOAD, wt as quoteId, x as createCrdtSyncRemoteSource, xn as createMigrator, xt as createTypedEventTarget, y as EventsPushRequest, yn as SyncDbMigrator, yt as TypedEventTarget, z as DefineSyncSchemaConfig, zt as LogLevel } from "./index-UfgvV97h.js";
+import { $ as createExportData, $t as ReadonlyTable, A as PendingCrdtEvent, An as CrdtUpdateLogPayload, At as ExecuteParams, B as DefinedSyncSchema, Bt as LogLevel, C as WorkerConfig, Cn as StoredValue, Ct as jsonSafeParse, D as CrdtStorageMutator, Dn as CrdtEventStatus, Dt as KvStoreItem, E as createCrdtSyncProducer, En as CrdtEventOrigin, Et as tryCatchAsync, F as verifySyncSchema, Ft as PreparedStatement, G as SQLiteReactiveDb, Gt as TableMetadata, H as AdmitClientEventsResult, Ht as startPerformanceLogger, I as CrdtEventValidationError, It as QueryBuilderOutput, J as parametersAreEqual, Jt as HLCCounter, K as SharedLiveQuery, Kt as introspectDb, L as NewCrdtEventValidationResult, Lt as SQLiteDbWrapper, M as createSQLiteCrdtApplyFunction, Mn as isNoOpCrdtEventPayload, N as SchemaVerificationIssue, Nn as dummyKysely, Nt as KyselyQueryFactory, O as SnapshotOptions, On as CrdtEventType, Ot as createKvStoreTableQuery, P as formatSchemaVerificationIssues, Q as SyncedDbExport, Qt as CrdtTableConfig, R as validateNewCrdtEvent, Rt as SQLiteTransactionWrapper, Sn as createMigrator, St as generateId, T as WorkerState, Tn as CRDT_EVENT_NO_OP_PAYLOAD, Tt as tryCatch, Ut as ColumnMetadata, V as defineSyncSchema, Vt as Logger, W as admitClientEvents, Wt as DatabaseIntrospection, X as ImportDataOptions, Xt as deserializeHLC, Y as xxhash, Yt as compareHLC, Z as ImportDataResult, Zt as serializeHLC, _n as MigratableEvent, _t as TypedBroadcastChannel, a as SyncedDbDatabase, an as ColumnKind, at as OwnCrdtSnapshot, b as EventsPushResponse, bn as SyncDbMigrator, bt as createDeferredPromise, c as SyncedDbTransaction, cn as InferRow, ct as SystemMigration, dn as SyncSchemaTables, dt as applyWorkerDbSchema, en as SyncDbSchema, et as createImportData, fn as TableBuilder, g as CrdtSyncRemoteSource, gn as t, gt as DistributiveOmit, h as makeCrdtTable, hn as WriteOrigin, ht as DeferredPromise, i as SyncedDb, in as ColumnBuilder, it as OwnCrdtEvent, j as createCrdtApplyFunction, jn as PersistedCrdtEvent, jt as ExecuteResult, k as createCrdtStorageMutator, kn as CrdtUpdateLogItem, kt as createSQLiteKvStore, l as UnsafeSyncedDbSqlExecutor, ln as PayloadValidationResult, lt as SystemMigrationContext, mn as TableOptions, n as ResetRequest, nn as AnyColumnBuilder, nt as CrdtStorage, o as SyncedDbOptions, on as ColumnMeta, ot as createCrdtStorage, pn as TableColumns, q as SharedLiveQuerySnapshot, qt as HLC, r as ResetStore, rn as AnyTableBuilder, s as SyncedDbSqlExecutor, sn as ExportImportMode, st as SystemDbConfig, t as RESET_REQUEST_TTL_MS, tn as AiAccess, u as createSyncedDb, un as SqliteStorageType, ut as applyMemoryDbSchema, v as EventsPullRequest, vn as Migrations, vt as TypedEvent, w as WorkerNotificationMessage, wn as createStoredValue, wt as quoteId, x as createCrdtSyncRemoteSource, xn as createMigrations, xt as createTypedEventTarget, y as EventsPushRequest, yn as MigrationsDb, yt as TypedEventTarget, z as DefineSyncSchemaConfig } from "./index-BHsKLqcK.js";
 export { type AdmitClientEventsResult, type AiAccess, type AnyColumnBuilder, type AnyTableBuilder, CRDT_EVENT_NO_OP_PAYLOAD, ColumnBuilder, type ColumnKind, type ColumnMeta, type ColumnMetadata, type CrdtEventOrigin, type CrdtEventStatus, type CrdtEventType, CrdtEventValidationError, type CrdtStorage, type CrdtStorageMutator, type CrdtSyncRemoteSource, type CrdtTableConfig, type CrdtUpdateLogItem, type CrdtUpdateLogPayload, type DatabaseIntrospection, type DeferredPromise, type DefineSyncSchemaConfig, type DefinedSyncSchema, type DistributiveOmit, type EventsPullRequest, type EventsPushRequest, type EventsPushResponse, type ExecuteParams, type ExecuteResult, type ExportImportMode, type HLC, HLCCounter, type ImportDataOptions, type ImportDataResult, type InferRow, type KvStoreItem, type KyselyQueryFactory, type LogLevel, type Logger, type MigratableEvent, type Migrations, type MigrationsDb, type NewCrdtEventValidationResult, type OwnCrdtEvent, type OwnCrdtSnapshot, type PayloadValidationResult, type PendingCrdtEvent, type PersistedCrdtEvent, type PreparedStatement, type QueryBuilderOutput, RESET_REQUEST_TTL_MS, type ReadonlyTable, type ResetRequest, type ResetStore, SQLiteDbWrapper, SQLiteReactiveDb, type SQLiteTransactionWrapper, type SchemaVerificationIssue, type SharedLiveQuery, type SharedLiveQuerySnapshot, type SnapshotOptions, type SqliteStorageType, type StoredValue, type SyncDbMigrator, type SyncDbSchema, type SyncSchemaTables, type SyncedDb, type SyncedDbDatabase, type SyncedDbExport, type SyncedDbOptions, type SyncedDbSqlExecutor, type SyncedDbTransaction, type SystemDbConfig, type SystemMigration, type SystemMigrationContext, TableBuilder, type TableColumns, type TableMetadata, type TableOptions, TypedBroadcastChannel, TypedEvent, type TypedEventTarget, type UnsafeSyncedDbSqlExecutor, type WorkerConfig, type WorkerNotificationMessage, type WorkerState, type WriteOrigin, admitClientEvents, applyMemoryDbSchema, applyWorkerDbSchema, compareHLC, createCrdtApplyFunction, createCrdtStorage, createCrdtStorageMutator, createCrdtSyncProducer, createCrdtSyncRemoteSource, createDeferredPromise, createExportData, createImportData, createKvStoreTableQuery, createMigrations, createMigrator, createSQLiteCrdtApplyFunction, createSQLiteKvStore, createStoredValue, createSyncedDb, createTypedEventTarget, defineSyncSchema, deserializeHLC, dummyKysely, formatSchemaVerificationIssues, generateId, introspectDb, isNoOpCrdtEventPayload, jsonSafeParse, makeCrdtTable, parametersAreEqual, quoteId, serializeHLC, startPerformanceLogger, t, tryCatch, tryCatchAsync, validateNewCrdtEvent, verifySyncSchema, xxhash };

package/dist/index.js

@@ -1,9 +1,9 @@
-import { C as introspectDb, D as dummyKysely, E as createImportData, S as startPerformanceLogger, T as createExportData, _ as formatSchemaVerificationIssues, a as createBroadcastChannels, b as createMigrator, c as isWorkerNotificationMessage, d as syncDbClientLockName, g as createSQLiteCrdtApplyFunction, h as createCrdtApplyFunction, m as createCrdtStorage, o as isWorkerErrorResponseMessage, p as createCrdtSyncProducer, t as RESET_REQUEST_TTL_MS, u as isWorkerResponseMessage, v as verifySyncSchema, w as xxhash, x as SQLiteDbWrapper, y as createMigrations } from "./reset-state-CchMrdoA.js";
-import { a as createDeferredPromise, c as generateId, f as quoteId, i as TypedEvent, l as jsonSafeParse, m as tryCatchAsync, n as isNoOpCrdtEventPayload, o as createTypedEventTarget, p as tryCatch, r as TypedBroadcastChannel, t as CRDT_EVENT_NO_OP_PAYLOAD, u as noop } from "./crdt-table-schema-2w_AIpsV.js";
-import { a as HLCCounter, c as serializeHLC, n as CrdtEventValidationError, o as compareHLC, r as validateNewCrdtEvent, s as deserializeHLC, t as createCrdtSyncRemoteSource } from "./crdt-sync-remote-source-CugbiosG.js";
-import { a as memoryDbConfig, c as createKvStoreTableQuery, l as createSQLiteKvStore, n as applyWorkerDbSchema, t as applyMemoryDbSchema, u as createStoredValue } from "./system-schema-C2JZDv6L.js";
+import { a as memoryDbConfig, c as createKvStoreTableQuery, d as SQLiteDbWrapper, h as dummyKysely, l as createSQLiteKvStore, m as introspectDb, n as applyWorkerDbSchema, p as startPerformanceLogger, t as applyMemoryDbSchema, u as createStoredValue } from "./system-schema-Dvl_BLId.js";
+import { a as acquireLock, d as noop, h as tryCatchAsync, i as TypedEvent, l as generateId, m as tryCatch, n as isNoOpCrdtEventPayload, o as createDeferredPromise, p as quoteId, r as TypedBroadcastChannel, s as createTypedEventTarget, t as CRDT_EVENT_NO_OP_PAYLOAD, u as jsonSafeParse } from "./crdt-table-schema-BRm_WdcW.js";
+import { C as xxhash, S as createMigrator, T as createImportData, _ as createCrdtApplyFunction, a as acquireReplicaLock, b as verifySyncSchema, c as isWorkerErrorResponseMessage, f as isWorkerResponseMessage, g as createCrdtStorage, h as createCrdtSyncProducer, p as syncDbClientLockName, s as createBroadcastChannels, t as RESET_REQUEST_TTL_MS, u as isWorkerNotificationMessage, v as createSQLiteCrdtApplyFunction, w as createExportData, x as createMigrations, y as formatSchemaVerificationIssues } from "./reset-state-t0tTGqoh.js";
+import { a as HLCCounter, c as serializeHLC, n as CrdtEventValidationError, o as compareHLC, r as validateNewCrdtEvent, s as deserializeHLC, t as createCrdtSyncRemoteSource } from "./crdt-sync-remote-source-CPXzmSIS.js";
 import { n as buildWriteOriginByName, t as admitClientEvents } from "./admit-client-events-BDrJw4SK.js";
-import { a as makeCrdtTable, o as registerCrdtIntentDrainer } from "./make-crdt-table-D8VQ-ptj.js";
+import { a as makeCrdtTable, o as registerCrdtIntentDrainer } from "./make-crdt-table-C6l0F-o_.js";
 import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
 //#region src/bound-map.ts
 var BoundMap = class {
@@ -689,18 +689,22 @@ const createWorkerDbClient = async ({ broadcastChannels, worker, config }) => {
 	const queryWorker = (method, args) => {
 		if (isDisposed) return Promise.reject(/* @__PURE__ */ new Error("Worker client disposed"));
 		const requestId = crypto.randomUUID();
-		const promise = createDeferredPromise({
-			timeout: 3e4,
-			onTimeout: () => workerRequestsMap.delete(requestId)
-		});
-		workerRequestsMap.set(requestId, promise);
 		const request = {
 			type: "request",
 			requestId,
 			method,
 			args
 		};
-		broadcastChannels.requests.postMessage(request);
+		try {
+			broadcastChannels.requests.postMessage(request);
+		} catch (error) {
+			return Promise.reject(error);
+		}
+		const promise = createDeferredPromise({
+			timeout: 3e4,
+			onTimeout: () => workerRequestsMap.delete(requestId)
+		});
+		workerRequestsMap.set(requestId, promise);
 		return promise.promise;
 	};
 	const handleWorkerResponse = (message) => {
@@ -730,17 +734,10 @@ const createWorkerDbClient = async ({ broadcastChannels, worker, config }) => {
 		postState: () => queryWorker("postState", []),
 		goOnline: () => queryWorker("goOnline", []),
 		goOffline: () => queryWorker("goOffline", []),
+		dropConnection: () => queryWorker("dropConnection", []),
 		sync: () => queryWorker("sync", []),
 		requestReload: (options) => queryWorker("requestReload", [options])
 	};
-	const statePromise = awaitWorkerState(eventTarget);
-	postWorkerConfig(worker, config);
-	rpc.postState().catch(noop);
-	let { state: workerState, storageGeneration } = await statePromise;
-	eventTarget.addEventListener("state-changed", (event) => {
-		workerState = event.payload.state;
-		storageGeneration = event.payload.storageGeneration;
-	});
 	const dispose = () => {
 		isDisposed = true;
 		broadcastChannels.responses.onmessage = null;
@@ -749,13 +746,25 @@ const createWorkerDbClient = async ({ broadcastChannels, worker, config }) => {
 			workerRequestsMap.delete(id);
 		}
 	};
-	return {
-		...rpc,
-		subscribe: eventTarget.addEventListener,
-		getState: () => workerState,
-		getStorageGeneration: () => storageGeneration,
-		dispose
-	};
+	try {
+		postWorkerConfig(worker, config);
+		rpc.postState().catch(noop);
+		let { state: workerState, storageGeneration } = await awaitWorkerState(eventTarget);
+		eventTarget.addEventListener("state-changed", (event) => {
+			workerState = event.payload.state;
+			storageGeneration = event.payload.storageGeneration;
+		});
+		return {
+			...rpc,
+			subscribe: eventTarget.addEventListener,
+			getState: () => workerState,
+			getStorageGeneration: () => storageGeneration,
+			dispose
+		};
+	} catch (error) {
+		dispose();
+		throw error;
+	}
 };
 function awaitWorkerState(eventTarget) {
 	const promise = createDeferredPromise({ timeout: 15e3 });
@@ -821,168 +830,191 @@ async function createSyncedDb(options) {
 	const instanceId = generateId();
 	const tabId = generateId();
 	const broadcastChannels = createBroadcastChannels(options.dbId);
-	const clientLockAcquired = createDeferredPromise();
-	const clientLockRelease = createDeferredPromise();
-	navigator.locks.request(`${syncDbClientLockName}-${options.dbId}`, { mode: "shared" }, () => {
-		clientLockAcquired.resolve();
-		return clientLockRelease.promise;
-	});
-	await clientLockAcquired.promise;
-	const workerClient = await createWorkerDbClient({
-		worker: options.worker,
-		config: {
-			clientId: generateId(),
-			dbId: options.dbId,
-			props: options.workerProps
-		},
-		broadcastChannels
-	});
-	const hlcCounter = new HLCCounter(tabId, () => Date.now());
-	const workerClientSnapshot = await workerClient.getSnapshot();
-	const reactiveDb = await createSQLiteReactiveDb({
-		snapshot: workerClientSnapshot.file,
-		logger: defaultLogger
-	});
-	const memoryDbMigrator = {
-		currentSchemaVersion: workerClientSnapshot.schemaVersion,
-		latestSchemaVersion: workerClientSnapshot.schemaVersion,
-		migrateDbToLatest: () => {
-			throw new Error("Memory DB migrations are not implemented");
-		},
-		migrateEvent: (event, targetVersion) => {
-			if (event.schema_version === targetVersion) return event;
-			throw new Error("Memory DB migrations are not implemented");
-		},
-		migrateEvents: (events) => events
-	};
-	const { crdtStorage } = await createMemoryDb({
-		nodeId: tabId,
-		migrator: memoryDbMigrator,
-		reactiveDb,
-		hlcCounter,
-		crdtTables: options.syncDbSchema.tablesConfig,
-		syncDbSchema: options.syncDbSchema
-	});
-	const pullSyncId = createStoredValue({ initialValue: workerClientSnapshot.syncId });
-	const pushSyncId = createStoredValue({ initialValue: 0 });
-	const tabRemoteSource = createCrdtSyncRemoteSource({
-		bufferSize: 500,
-		pullSyncId,
-		pushSyncId,
-		storage: crdtStorage,
-		nodeId: tabId,
-		migrator: memoryDbMigrator,
-		remoteFactory: ({ onEventsAvailable }) => {
-			const subscription = workerClient.subscribe("new-event-chunk-applied", (event) => {
-				onEventsAvailable({
-					newSyncId: event.payload.newSyncId,
-					remoteEventHlcSum: event.payload.eventHlcSum
-				});
-			});
-			return {
-				pullEvents: (request) => workerClient.pullEvents(request),
-				pushEvents: (request) => workerClient.pushTabEvents(request),
-				disconnect: () => {
-					subscription.unsubscribe();
-				}
-			};
-		}
-	});
-	tabRemoteSource.goOnline();
-	const reloadRequestedSubscription = workerClient.subscribe("reload-requested", () => {
-		globalThis.location?.reload();
-	});
-	const reloadIfStorageReplaced = (storageGeneration) => {
-		if (storageGeneration !== workerClientSnapshot.storageGeneration) {
-			storageReplacedSubscription.unsubscribe();
-			globalThis.location?.reload();
-		}
-	};
-	const storageReplacedSubscription = workerClient.subscribe("state-changed", (event) => {
-		reloadIfStorageReplaced(event.payload.storageGeneration);
-	});
-	reloadIfStorageReplaced(workerClient.getStorageGeneration());
-	const sync = () => {
-		workerClient.sync().catch((error) => console.warn("Failed to start sync", error));
-	};
-	const syncWhenVisible = () => {
-		if (globalThis.document?.visibilityState === "visible") sync();
-	};
-	globalThis.document?.addEventListener("visibilitychange", syncWhenVisible);
-	globalThis.addEventListener?.("online", sync);
-	perf.logEnd("createSyncedDb", "initialized", "info");
-	const exportData = createExportData({
-		reactiveDb,
-		tablesConfig: options.syncDbSchema.tablesConfig,
-		schemaVersion: workerClientSnapshot.schemaVersion
-	});
-	const importData = (data, opts) => workerClient.importData(data, opts);
-	let isDisposed = false;
+	let releaseClientLock;
+	let disposeWorkerClient;
+	let releaseReplicaLock;
+	let disposeReactiveDb;
+	let disposeRemoteSource;
+	const cleanupCallbacks = [];
 	let unregisterDevtools;
+	let isDisposed = false;
 	const dispose = async () => {
 		if (isDisposed) return;
 		isDisposed = true;
 		unregisterDevtools?.();
-		globalThis.document?.removeEventListener("visibilitychange", syncWhenVisible);
-		globalThis.removeEventListener?.("online", sync);
-		reloadRequestedSubscription.unsubscribe();
-		storageReplacedSubscription.unsubscribe();
-		clientLockRelease.resolve();
-		await tabRemoteSource.dispose();
-		broadcastChannels.requests.close();
-		broadcastChannels.responses.close();
-		workerClient.dispose();
-		reactiveDb.dispose();
-	};
-	const syncedDb = {
-		db: createSyncedDbDatabase(reactiveDb),
-		state: {
-			getState: workerClient.getState.bind(workerClient),
-			subscribe: (onChange) => {
-				const { unsubscribe } = workerClient.subscribe("state-changed", onChange);
-				return unsubscribe;
-			},
-			goOnline: workerClient.goOnline.bind(workerClient),
-			goOffline: workerClient.goOffline.bind(workerClient),
-			sync
-		},
-		/**
-		* 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: async (options) => {
-			await workerClient.requestReload(options);
-			setTimeout(() => globalThis.location?.reload(), 250);
-		},
-		subscribe: workerClient.subscribe,
-		exportData,
-		importData,
-		dispose,
-		_internal: {
-			executeAsync: workerClient.execute.bind(workerClient),
-			getMemoryQueryTables: reactiveDb.getTablesUsed.bind(reactiveDb),
-			getSharedLiveQueriesSnapshot: reactiveDb.getSharedLiveQueriesSnapshot.bind(reactiveDb),
-			crdtTableNames: options.syncDbSchema.tablesConfig.map((table) => table.crdtTableName),
-			crdtTablesConfig: options.syncDbSchema.tablesConfig,
-			tables: options.syncDbSchema.tables,
-			schemaVersion: workerClientSnapshot.schemaVersion,
-			migrationVersions: Object.keys(options.syncDbSchema.migrations).map(Number).sort((a, b) => a - b)
+		for (const cleanup of cleanupCallbacks) cleanup();
+		try {
+			await disposeRemoteSource?.();
+		} finally {
+			broadcastChannels.requests.close();
+			broadcastChannels.responses.close();
+			disposeWorkerClient?.();
+			try {
+				disposeReactiveDb?.();
+			} finally {
+				await Promise.all([releaseClientLock?.(), releaseReplicaLock?.()]);
+			}
 		}
 	};
-	unregisterDevtools = getOrCreateSQLiteSyncDevtoolsRegistry().register({
-		instanceId,
-		dbId: options.dbId,
-		createdAt: Date.now(),
-		instance: syncedDb
-	});
-	return syncedDb;
+	try {
+		releaseClientLock = await acquireLock(`${syncDbClientLockName}-${options.dbId}`, { mode: "shared" });
+		const workerClient = await createWorkerDbClient({
+			worker: options.worker,
+			config: {
+				clientId: generateId(),
+				dbId: options.dbId,
+				props: options.workerProps
+			},
+			broadcastChannels
+		});
+		disposeWorkerClient = () => workerClient.dispose();
+		const hlcCounter = new HLCCounter(tabId, () => Date.now());
+		releaseReplicaLock = await acquireReplicaLock({ dbId: options.dbId });
+		const workerClientSnapshot = await workerClient.getSnapshot();
+		const reactiveDb = await createSQLiteReactiveDb({
+			snapshot: workerClientSnapshot.file,
+			logger: defaultLogger
+		});
+		disposeReactiveDb = () => reactiveDb.dispose();
+		const memoryDbMigrator = {
+			currentSchemaVersion: workerClientSnapshot.schemaVersion,
+			latestSchemaVersion: workerClientSnapshot.schemaVersion,
+			migrateDbToLatest: () => {
+				throw new Error("Memory DB migrations are not implemented");
+			},
+			migrateEvent: (event, targetVersion) => {
+				if (event.schema_version === targetVersion) return event;
+				throw new Error("Memory DB migrations are not implemented");
+			},
+			migrateEvents: (events) => events
+		};
+		const { crdtStorage } = await createMemoryDb({
+			nodeId: tabId,
+			migrator: memoryDbMigrator,
+			reactiveDb,
+			hlcCounter,
+			crdtTables: options.syncDbSchema.tablesConfig,
+			syncDbSchema: options.syncDbSchema
+		});
+		const pullSyncId = createStoredValue({ initialValue: workerClientSnapshot.syncId });
+		const pushSyncId = createStoredValue({ initialValue: 0 });
+		const tabRemoteSource = createCrdtSyncRemoteSource({
+			bufferSize: 500,
+			pullSyncId,
+			pushSyncId,
+			storage: crdtStorage,
+			nodeId: tabId,
+			migrator: memoryDbMigrator,
+			remoteFactory: ({ onEventsAvailable }) => {
+				const subscription = workerClient.subscribe("new-event-chunk-applied", (event) => {
+					onEventsAvailable({
+						newSyncId: event.payload.newSyncId,
+						remoteEventHlcSum: event.payload.eventHlcSum
+					});
+				});
+				return {
+					pullEvents: (request) => workerClient.pullEvents(request),
+					pushEvents: (request) => workerClient.pushTabEvents(request),
+					disconnect: () => {
+						subscription.unsubscribe();
+					}
+				};
+			}
+		});
+		disposeRemoteSource = () => tabRemoteSource.dispose();
+		tabRemoteSource.goOnline();
+		const reloadRequestedSubscription = workerClient.subscribe("reload-requested", () => {
+			globalThis.location?.reload();
+		});
+		cleanupCallbacks.push(reloadRequestedSubscription.unsubscribe);
+		const reloadIfStorageReplaced = (storageGeneration) => {
+			if (storageGeneration !== workerClientSnapshot.storageGeneration) {
+				storageReplacedSubscription.unsubscribe();
+				globalThis.location?.reload();
+			}
+		};
+		const storageReplacedSubscription = workerClient.subscribe("state-changed", (event) => {
+			reloadIfStorageReplaced(event.payload.storageGeneration);
+		});
+		cleanupCallbacks.push(storageReplacedSubscription.unsubscribe);
+		reloadIfStorageReplaced(workerClient.getStorageGeneration());
+		const sync = () => {
+			workerClient.sync().catch((error) => console.warn("Failed to start sync", error));
+		};
+		const syncWhenVisible = () => {
+			if (globalThis.document?.visibilityState === "visible") sync();
+		};
+		const dropConnection = () => {
+			workerClient.dropConnection().catch((error) => console.warn("Failed to drop connection", error));
+		};
+		cleanupCallbacks.push(() => {
+			globalThis.document?.removeEventListener("visibilitychange", syncWhenVisible);
+			globalThis.removeEventListener?.("online", sync);
+			globalThis.removeEventListener?.("offline", dropConnection);
+		});
+		globalThis.document?.addEventListener("visibilitychange", syncWhenVisible);
+		globalThis.addEventListener?.("online", sync);
+		globalThis.addEventListener?.("offline", dropConnection);
+		perf.logEnd("createSyncedDb", "initialized", "info");
+		const exportData = createExportData({
+			reactiveDb,
+			tablesConfig: options.syncDbSchema.tablesConfig,
+			schemaVersion: workerClientSnapshot.schemaVersion
+		});
+		const importData = (data, opts) => workerClient.importData(data, opts);
+		const syncedDb = {
+			db: createSyncedDbDatabase(reactiveDb),
+			state: {
+				getState: workerClient.getState.bind(workerClient),
+				subscribe: (onChange) => {
+					const { unsubscribe } = workerClient.subscribe("state-changed", onChange);
+					return unsubscribe;
+				},
+				goOnline: workerClient.goOnline.bind(workerClient),
+				goOffline: workerClient.goOffline.bind(workerClient),
+				sync
+			},
+			/**
+			* 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: async (options) => {
+				await workerClient.requestReload(options);
+				setTimeout(() => globalThis.location?.reload(), 250);
+			},
+			subscribe: workerClient.subscribe,
+			exportData,
+			importData,
+			dispose,
+			_internal: {
+				executeAsync: workerClient.execute.bind(workerClient),
+				getMemoryQueryTables: reactiveDb.getTablesUsed.bind(reactiveDb),
+				getSharedLiveQueriesSnapshot: reactiveDb.getSharedLiveQueriesSnapshot.bind(reactiveDb),
+				crdtTableNames: options.syncDbSchema.tablesConfig.map((table) => table.crdtTableName),
+				crdtTablesConfig: options.syncDbSchema.tablesConfig,
+				tables: options.syncDbSchema.tables,
+				schemaVersion: workerClientSnapshot.schemaVersion,
+				migrationVersions: Object.keys(options.syncDbSchema.migrations).map(Number).sort((a, b) => a - b)
+			}
+		};
+		unregisterDevtools = getOrCreateSQLiteSyncDevtoolsRegistry().register({
+			instanceId,
+			dbId: options.dbId,
+			createdAt: Date.now(),
+			instance: syncedDb
+		});
+		return syncedDb;
+	} catch (error) {
+		await dispose();
+		throw error;
+	}
 }
 //#endregion
 export { CRDT_EVENT_NO_OP_PAYLOAD, ColumnBuilder, CrdtEventValidationError, HLCCounter, RESET_REQUEST_TTL_MS, SQLiteDbWrapper, SQLiteReactiveDb, TableBuilder, TypedBroadcastChannel, TypedEvent, admitClientEvents, applyMemoryDbSchema, applyWorkerDbSchema, compareHLC, createCrdtApplyFunction, createCrdtStorage, createCrdtStorageMutator, createCrdtSyncProducer, createCrdtSyncRemoteSource, createDeferredPromise, createExportData, createImportData, createKvStoreTableQuery, createMigrations, createMigrator, createSQLiteCrdtApplyFunction, createSQLiteKvStore, createStoredValue, createSyncedDb, createTypedEventTarget, defineSyncSchema, deserializeHLC, dummyKysely, formatSchemaVerificationIssues, generateId, introspectDb, isNoOpCrdtEventPayload, jsonSafeParse, makeCrdtTable, parametersAreEqual, quoteId, serializeHLC, startPerformanceLogger, t, tryCatch, tryCatchAsync, validateNewCrdtEvent, verifySyncSchema, xxhash };