@delali/sirannon-db 0.3.4-next.62 → 0.3.4

package/dist/client/index.d.ts

@@ -1,20 +1,20 @@
-export { F as FieldMergeResolver, L as LWWResolver, P as PrimaryWinsResolver } from '../primary-wins-B0np8JS3.js';
-import { C as ConflictResolver, R as ReplicationBatch } from '../types-CjhxcjhA.js';
-export { a as ConflictContext, b as ConflictResolution } from '../types-CjhxcjhA.js';
-import { C as ClientOptions, B as BulkLoadDurability } from '../server-options-Bj5iJnjx.js';
-import { D as DatabaseClient, T as Transport, L as LiveHandlers, R as RemoteSubscription, a as RemoteSubscriptionBuilder, S as SubscribeOptions, b as RegistryDigestSource } from '../client-base-Cmd9EVme.js';
-export { c as LoadAllOptions, d as RemoteDatabase, e as RemoteError, f as SQL_REFUSED_MESSAGE, g as ServerCapabilities, h as ServerCapabilityCheck } from '../client-base-Cmd9EVme.js';
-import { a as LiveQuery, b as LiveQueryState, c as LiveUpdate } from '../types-DTO4CYhW.js';
-import { l as DeviceSyncPort, D as Database } from '../database-BLQvqjsw.js';
-import { C as ChangeEvent, P as Params, R as ReadConcern, W as WriteConcern } from '../query-types-p1liOP-b.js';
-import { Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-HI-nY8DD.js';
-import '../operation-registry-oiPuSYI6.js';
-import '../types-DPSmjU54.js';
-import '../database-backup-B7oszQ2n.js';
-import '../change-tracker-CjRFuZdB.js';
+export { F as FieldMergeResolver, L as LWWResolver, P as PrimaryWinsResolver } from '../primary-wins-CHNOYuN7.js';
+import { C as ConflictResolver, R as ReplicationBatch } from '../types-DqODKeOq.js';
+export { a as ConflictContext, b as ConflictResolution } from '../types-DqODKeOq.js';
+import { C as ClientOptions, B as BulkLoadDurability } from '../server-options-aYtCkefX.js';
+import { D as DatabaseClient, T as Transport, L as LiveHandlers, R as RemoteSubscription, a as RemoteSubscriptionBuilder, S as SubscribeOptions, b as RegistryDigestSource } from '../client-base-BxTocU1x.js';
+export { c as LoadAllOptions, d as RemoteDatabase, e as RemoteError, f as SQL_REFUSED_MESSAGE, g as ServerCapabilities, h as ServerCapabilityCheck } from '../client-base-BxTocU1x.js';
+import { a as LiveQuery, b as LiveQueryState, c as LiveUpdate } from '../types-CEJG0eFS.js';
+import { l as DeviceSyncPort, D as Database } from '../database-CGDsXW1K.js';
+import { C as ChangeEvent, P as Params, R as ReadConcern, W as WriteConcern } from '../query-types-5B02ixH0.js';
+import { Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-DFpNNsIT.js';
+import '../operation-registry-CGhNT-Sn.js';
+import '../types-Dc8oWlxj.js';
+import '../database-backup-DcLhxoa1.js';
+import '../change-tracker-DqCdeEyx.js';
 
 /**
- * Connects to one sirannon-db server and hands out a {@link RemoteDatabase} per database.
+ * Connects to one sirannon-db server and returns a {@link RemoteDatabase} for each database on it.
  *
  * @public
  */
@@ -22,14 +22,14 @@ declare class SirannonClient extends DatabaseClient {
     private readonly baseUrl;
     constructor(url: string, options?: ClientOptions);
     /**
-     * Builds the transport a database's requests travel over.
+     * Builds the transport that sends one database's requests.
      *
      * @param databaseId - Identifier of the database.
      * @returns A transport bound to that database.
      */
     protected createTransport(databaseId: string): Transport;
     /**
-     * Returns the address requests are sent to.
+     * Returns the address that this client sends requests to.
      *
      * @returns The server's base address.
      */
@@ -37,7 +37,7 @@ declare class SirannonClient extends DatabaseClient {
 }
 
 /**
- * A live query running against a remote server, which keeps its rows current as the tables behind it change.
+ * A live query on a remote server, which keeps its rows current as rows change in the tables that the query selects from.
  *
  * @public
  */
@@ -51,18 +51,18 @@ declare class RemoteLiveQuery<T> implements LiveQuery<T> {
     /** @internal */
     static open<T>(subscribe: (handlers: LiveHandlers) => Promise<RemoteSubscription>, onError?: (error: Error) => void): Promise<RemoteLiveQuery<T>>;
     /**
-     * Returns the rows the query holds right now.
+     * Returns the query's current state, which is its status with either its rows or its error.
      */
     getState(): LiveQueryState<T>;
     /**
-     * Calls back on each update and returns a function that stops the listener.
+     * Calls the listener with each update, and returns a function that removes it.
      *
      * @param listener - Receives each update.
      * @returns A function that removes the listener.
      */
     subscribe(listener: (update: LiveUpdate<T>) => void): () => void;
     /**
-     * Ends the query and releases its subscription.
+     * Ends the query and unsubscribes it from the server.
      */
     close(): Promise<void>;
     private handlers;
@@ -74,62 +74,62 @@ declare class RemoteLiveQuery<T> implements LiveQuery<T> {
 }
 
 /**
- * How far a snapshot download has progressed, for the table in flight and overall.
+ * The progress of a snapshot download, for the current table and across every table.
  *
  * @public
  */
 interface SnapshotProgress {
-    /** Table the download is reading right now. */
+    /** The table that `downloadDatabaseSnapshot` is copying now. */
     table: string;
-    /** Rows loaded from that table so far. */
+    /** The number of that table's rows in the local database so far. */
     tableLoadedRows: number;
-    /** Rows that table holds in total. */
+    /** The total number of rows in that table, from the server's manifest. */
     tableTotalRows: number;
-    /** Rows loaded across every table so far. */
+    /** The number of rows in the local database so far, across every table. */
     loadedRows: number;
-    /** Rows the whole snapshot holds. */
+    /** The total number of rows in the snapshot. */
     totalRows: number;
 }
 /**
- * Where a snapshot comes from and how it is read.
+ * The server and database that a snapshot comes from, and the settings for reading it.
  *
  * @public
  */
 interface SnapshotDownloadOptions {
-    /** Address of the server serving the snapshot. */
+    /** The address of the server that serves the snapshot. */
     url: string;
-    /** Identifier of the database to copy. */
+    /** The identifier of the database to copy. */
     databaseId: string;
-    /** Headers attached to each snapshot request. */
+    /** Headers that `downloadDatabaseSnapshot` adds to each snapshot request. */
     headers?: Record<string, string>;
-    /** Rows requested per page. Default: 500. */
+    /** The number of rows to request per page. Defaults to 500. */
     pageSize?: number;
-    /** Milliseconds a single page request may take. */
+    /** The time limit, in milliseconds, for each request. */
     requestTimeoutMs?: number;
-    /** Called as each page arrives. */
+    /** Called after `downloadDatabaseSnapshot` loads each page that contains rows. */
     onProgress?: (progress: SnapshotProgress) => void;
 }
 /**
- * What one snapshot download produced.
+ * The result of one snapshot download.
  *
  * @public
  */
 interface SnapshotDownloadResult {
-    /** Change-log position the device resumes its subscription from. */
+    /** The change-log position from which the device resumes its subscription. */
     startSeq: bigint;
-    /** Sequence space that position belongs to. */
+    /** The epoch that identifies the sequence space of that position. */
     epoch: string;
-    /** Tables the snapshot carried. */
+    /** The tables in the snapshot. */
     tables: string[];
-    /** Rows the download wrote. */
+    /** The number of rows that `downloadDatabaseSnapshot` wrote. */
     loadedRows: number;
 }
 /**
- * Copies a database from a server into a local one, replacing what the local database holds.
+ * Copies a database from a server into a local database, and replaces every local table that the snapshot contains.
  *
- * @param port - The local database the snapshot is written into.
- * @param options - Where the snapshot comes from and how it is read.
- * @returns The change-log position and sequence space to resume from, the tables copied, and the rows written.
+ * @param port - The local database to write the snapshot into.
+ * @param options - The server and database that the snapshot comes from, and the settings for reading it.
+ * @returns The change-log position and epoch to resume from, the tables that this function copied, and the number of rows that it wrote.
  *
  * @public
  */
@@ -137,9 +137,8 @@ declare function downloadDatabaseSnapshot(port: DeviceSyncPort, options: Snapsho
 
 /**
  * Builds a remote CDC subscription with optional row-level filters.
- * Mirrors the core `SubscriptionBuilder` interface but returns
- * a promise from `subscribe()` since confirming the subscription
- * requires a server round-trip.
+ * It has the same methods as the core `SubscriptionBuilder`, but `subscribe()`
+ * returns a promise, because the server has to confirm the subscription first.
  *
  * @internal
  */
@@ -153,83 +152,83 @@ declare class RemoteSubscriptionBuilderImpl implements RemoteSubscriptionBuilder
 }
 
 /**
- * How a device keeps its local database in step with a server.
+ * Settings that control how a device keeps its local database in step with a server.
  *
  * @public
  */
 interface SyncControllerOptions {
-    /** Address of the server this device syncs with. */
+    /** The address of the server that this device syncs with. */
     url: string;
-    /** Identifier of the database on that server. */
+    /** The identifier of the database on that server. */
     databaseId: string;
-    /** Tables this device syncs. */
+    /** The tables that this device syncs. */
     tables: readonly string[];
-    /** Headers attached to every HTTP request, and to the pull subscription's WebSocket upgrade in a runtime whose WebSocket carries a handshake header. */
+    /** Headers that the controller adds to every HTTP request, and to the pull subscription's WebSocket upgrade in a runtime whose WebSocket constructor accepts handshake headers. */
     headers?: Record<string, string>;
-    /** Subprotocols offered on the pull subscription's WebSocket upgrade, which is how a browser device carries a credential. The controller offers `sirannon.v1` ahead of them. */
+    /** Subprotocols that the controller offers on the pull subscription's WebSocket upgrade, which is how a browser device sends a credential. The controller offers `sirannon.v1` ahead of them. */
     webSocketProtocols?: string | string[];
-    /** Changes sent in one push. */
+    /** The number of changes that the controller reads from the outbox for one push. */
     batchSize?: number;
     /** Milliseconds between pushes of locally recorded changes. */
     pushIntervalMs?: number;
     /** Milliseconds between acknowledgements of pulled changes. */
     ackIntervalMs?: number;
-    /** Longest delay, in milliseconds, between retries of a failed push. */
+    /** The longest delay, in milliseconds, between retries of a failed push. */
     maxPushRetryDelayMs?: number;
-    /** Milliseconds a single request may take. */
+    /** The time, in milliseconds, that the controller allows for a single request. */
     requestTimeout?: number;
-    /** Downloads a fresh snapshot on its own when the server says the cursor is too old. Default: true. */
+    /** Whether the controller downloads a fresh snapshot automatically when it marks the device for a resync. Defaults to true. */
     autoResync?: boolean;
     /** Milliseconds before the first retry of a failed snapshot download. */
     snapshotRetryDelayMs?: number;
-    /** Longest delay, in milliseconds, between snapshot retries. */
+    /** The longest delay, in milliseconds, between snapshot retries. */
     maxSnapshotRetryDelayMs?: number;
-    /** Rows requested per snapshot page. */
+    /** The number of rows that the controller requests per snapshot page. */
     snapshotPageSize?: number;
-    /** Changes after which the device acknowledges at once instead of waiting for the interval. */
+    /** The number of unacknowledged pulled changes above which the device acknowledges at once, ahead of `ackIntervalMs`. */
     immediateAckAfterChanges?: number;
-    /** Resolves which version of a row wins when a pulled change meets a local one. */
+    /** The conflict resolver that the controller applies when a pulled change conflicts with a local change, or a function that returns one for each table. */
     resolver?: ConflictResolver | ((table: string) => ConflictResolver);
-    /** Called for each change this device pulls. */
+    /** Called with each change that this device pulls. */
     onChange?: (event: ChangeEvent) => void;
-    /** Called with this device's status when the controller changes state, pushes a batch, applies a pulled batch, needs a resync, or records or clears an error. */
+    /** Called with this device's status when the controller changes state, pushes a batch, applies a pulled batch, marks the device for a resync, or records or clears an error. */
     onStatusChange?: (status: SyncStatus) => void;
-    /** Called when the server says the device must download a fresh snapshot. */
+    /** Called when the controller marks the device for a fresh snapshot download. */
     onResyncRequired?: () => void;
-    /** Called as each snapshot page arrives. */
+    /** Called after the controller loads each snapshot page that contains rows. */
     onSnapshotProgress?: (progress: SnapshotProgress) => void;
-    /** Called once a snapshot download settles, whether it succeeded or failed. */
+    /** Called with the outcome when a snapshot download succeeds or fails. */
     onSnapshotComplete?: (outcome: SnapshotOutcome) => void;
 }
 /**
- * How a snapshot download settled, and whether the local database is usable afterwards.
+ * The result of a snapshot download, and whether the local database is usable afterwards.
  *
  * @public
  */
 type SnapshotOutcome = {
-    /** True where the download finished and its rows are in place. */
+    /** True when the download finishes and its rows are in place. */
     ok: true;
-    /** Null on a download that finished. */
+    /** Null when the download finishes. */
     error: null;
-    /** True, because a finished download leaves the local database ready to read. */
+    /** True, because the local database is ready to read after a download finishes. */
     databaseUsable: true;
-    /** False, because a finished download needs no further attempt. */
+    /** False, because the controller schedules no retry after a download finishes. */
     retrying: false;
 } | {
-    /** False where the download failed. */
+    /** False when the download fails. */
     ok: false;
-    /** The code and message of what stopped the download. */
+    /** The code and message of the error that stopped the download. */
     error: {
         code: string;
         message: string;
     };
-    /** Whether the local database still answers reads after the failure. */
+    /** Whether the local database still accepts reads and writes after the failure. */
     databaseUsable: boolean;
-    /** True while the controller is making another attempt. */
+    /** True when the controller has another attempt scheduled. */
     retrying: boolean;
 };
 /**
- * What a sync controller is doing right now.
+ * The current state of a sync controller.
  *
  * @public
  */
@@ -240,36 +239,36 @@ type SyncState = 'stopped' | 'starting' | 'running' | 'paused' | 'snapshotting';
  * @public
  */
 interface SnapshotOptions {
-    /** Rows requested per page. */
+    /** The number of rows that the controller requests per page. */
     pageSize?: number;
-    /** Called as each page arrives. */
+    /** Called after the controller loads each page that contains rows. */
     onProgress?: (progress: SnapshotProgress) => void;
 }
 /**
- * Where a device stands against its server.
+ * The sync status of a device against its server.
  *
  * @public
  */
 interface SyncStatus {
-    /** What the controller is doing right now. */
+    /** The controller's current state. */
     state: SyncState;
-    /** Identifier this device is known by on the server. */
+    /** The identifier that this device uses with the server, or null before the controller starts. */
     deviceId: string | null;
-    /** Capabilities the server announced, or null before the device has asked. */
+    /** The capabilities that the server announces, or null before the controller fetches them. */
     serverCapabilities: string[] | null;
-    /** Schema version the local database is at. */
+    /** The schema version of the local database. */
     schemaVersion: number | null;
-    /** Local changes waiting to be pushed. */
+    /** The number of local changes that the controller has not yet pushed. */
     pendingPushCount: number;
-    /** Highest local change-log position the server has accepted. */
+    /** The highest local change-log position that the server acknowledges. */
     lastPushedSeq: bigint;
-    /** Highest server change-log position this device has applied. */
+    /** The server change-log position up to which the local database is current, or null before the device first subscribes. */
     lastPulledSeq: bigint | null;
-    /** Whether every local change has reached the server. */
+    /** True when the pending push count is 0. */
     pushCaughtUp: boolean;
-    /** Whether the server has told this device to download a fresh snapshot. */
+    /** Whether this device must download a fresh snapshot before it can pull changes again. */
     resyncRequired: boolean;
-    /** The most recent failure, or null when the last try succeeded. */
+    /** The most recent failure, or null when there is none or the controller clears it after a later success. */
     lastError: {
         code: string;
         message: string;
@@ -277,7 +276,7 @@ interface SyncStatus {
 }
 
 /**
- * Keeps one device's local database in step with a server: it pushes local changes, pulls the server's, and downloads a fresh snapshot when the device falls too far behind.
+ * Keeps one device's local database in step with a server by pushing local changes, pulling the server's changes, and downloading a fresh snapshot when the server requires a resync.
  *
  * @public
  */
@@ -285,19 +284,16 @@ declare class SyncController {
     private readonly db;
     private readonly options;
     private readonly baseUrl;
-    private readonly pushIntervalMs;
-    private readonly maxPushRetryDelayMs;
     private readonly pull;
     private readonly push;
     private readonly resync;
+    private readonly reconnect;
     private readonly statusChanges;
     private port;
     private deviceId;
     private capabilities;
     private schemaVersion;
     private syncState;
-    private pullRetryTimer;
-    private consecutivePullFailures;
     private pendingPushCount;
     private lastError;
     constructor(db: Database, options: SyncControllerOptions);
@@ -306,10 +302,17 @@ declare class SyncController {
     private setError;
     /**
      * Connects to the server and starts pushing and pulling changes.
+     *
+     * When the server is unreachable, the promise still resolves, `status()` reports `running` with the failure in
+     * `lastError`, and the controller retries the connection with growing waits. It makes no attempt while the device
+     * reports no network, and it retries at once when the network returns.
+     *
+     * @throws A `RemoteError` when the server refuses device sync, such as `DEVICE_SYNC_NOT_ACCEPTED`, `UNAUTHORIZED`, or
+     * `FORBIDDEN`.
      */
     start(): Promise<void>;
     /**
-     * Holds pushing and pulling without disconnecting.
+     * Pauses pushing and pulling and closes the pull connection until you call {@link SyncController.resume}.
      */
     pause(): void;
     /**
@@ -321,7 +324,7 @@ declare class SyncController {
      */
     stop(): Promise<void>;
     /**
-     * Reports where this device stands against the server.
+     * Returns this device's sync status, with the pending push count read fresh from the outbox.
      *
      * @returns The device's state, cursors, pending push count, and last failure.
      */
@@ -329,7 +332,7 @@ declare class SyncController {
     private captureStatus;
     private refreshOutboxCount;
     /**
-     * Pushes local changes now instead of waiting for the next interval.
+     * Pushes local changes now, ahead of the next push interval.
      */
     triggerPush(): void;
     private verifyCapabilities;
@@ -342,22 +345,15 @@ declare class SyncController {
      * @param options - Page size and the progress callback for this download.
      */
     downloadSnapshot(options?: SnapshotOptions): Promise<void>;
-    /**
-     * Answers whether the local database serves reads and writes again. A failure
-     * before the wipe begins leaves it intact, while one after it leaves every
-     * statement refused with `SNAPSHOT_IN_PROGRESS` until a later copy succeeds,
-     * so the application learns which of the two it is rather than assuming.
-     */
-    private snapshotGateOpen;
     private recordError;
     private handleApplyFailure;
     private reopenPull;
     /**
-     * Opens the pull subscription, reconciling migrations when the server refuses
-     * it because this device is behind. A device that only reads never pushes, so
-     * the subscribe refusal is the sole point at which it can learn that the
-     * server has migrated; without this it would retry the same refused
-     * subscription forever and silently receive nothing.
+     * Opens the pull subscription, and reconciles migrations when the server refuses
+     * it with `MIGRATION_REQUIRED` because this device's schema is behind. A device
+     * that only reads never pushes, so the refused subscription is the only signal
+     * that the server has migrated. Without this step, the controller would retry the
+     * same refused subscription indefinitely and the device would receive no changes.
      */
     private openPull;
     private teardownStream;
@@ -395,23 +391,23 @@ interface ChangesResponse {
 }
 
 /**
- * Encodes a device-sync batch into the shape the changes route accepts.
+ * Encodes a device-sync batch into the shape that the changes route accepts.
  *
  * @internal
  */
 declare function encodeSyncBatch(batch: ReplicationBatch): ChangesRequest['batch'];
 /**
- * Sends a device-sync batch to the server and returns what the server applied.
+ * Sends a device-sync batch to the server and returns how many changes the server applied, skipped, and counted as conflicts.
  *
  * @internal
  */
 declare function pushSyncBatch(baseUrl: string, databaseId: string, batch: ReplicationBatch, headers?: Record<string, string>, timeoutMs?: number, schemaVersion?: number): Promise<ChangesResponse>;
 
 /**
- * HTTP transport for sirannon-db. Sends requests via `fetch` to the
- * server's REST endpoints. Supports query, execute, transaction, batch,
- * and load operations. Real-time subscriptions are not available over
- * HTTP; use {@link WebSocketTransport} for CDC subscriptions.
+ * Sends queries, writes, transactions, batches, bulk loads, and registered
+ * operations to a sirannon-db server's HTTP routes with `fetch`. Change
+ * subscriptions and live queries need a WebSocket connection, so use
+ * {@link WebSocketTransport} for them.
  *
  * @public
  */
@@ -426,37 +422,36 @@ declare class HttpTransport implements Transport {
     query(sql: string, params?: Params, readConcern?: ReadConcern): Promise<QueryResponse>;
     /** Sends one write. */
     execute(sql: string, params?: Params): Promise<ExecuteResponse>;
-    /** Sends several statements the server runs in one transaction. */
+    /** Sends several statements that the server executes in one transaction. */
     transaction(statements: Array<{
         sql: string;
         params?: Params;
     }>): Promise<TransactionResponse>;
-    /** Sends one statement over many parameter sets, which the server runs in one transaction. */
+    /** Sends one statement with many parameter sets, which the server executes in one transaction. */
     batch(sql: string, paramsBatch: Params[], writeConcern?: WriteConcern): Promise<BatchResponse>;
-    /** Sends a bulk load, which the server runs at relaxed durability. */
+    /** Sends a bulk load, which the server executes at relaxed durability. */
     load(sql: string, paramsBatch: Params[], durability?: BulkLoadDurability, checkpoint?: boolean): Promise<LoadResponse>;
-    /** Runs a registered read by name and returns its rows. */
+    /** Executes a registered read by name and returns its rows. */
     queryNamed(name: string, args?: Record<string, unknown>, readConcern?: ReadConcern): Promise<QueryResponse>;
-    /** Runs a registered write by name. */
+    /** Executes a registered write by name. */
     executeNamed(name: string, args?: Record<string, unknown>, writeConcern?: WriteConcern): Promise<TransactionResponse>;
-    /** Opens a live query on a registered read and delivers its updates to the handlers. */
+    /** Throws a `RemoteError` with code `TRANSPORT_ERROR`, because live queries need the WebSocket transport. */
     liveSubscribe(): Promise<RemoteSubscription>;
-    /** Opens a change subscription on a watched table. */
+    /** Throws a `RemoteError` with code `TRANSPORT_ERROR`, because change subscriptions need the WebSocket transport. */
     subscribe(_table: string, _filter: Record<string, unknown> | undefined, _callback: (event: ChangeEvent) => void): Promise<RemoteSubscription>;
-    /** Closes the transport and every subscription running on it. */
+    /** Closes the transport, so every later request throws a `RemoteError` with code `TRANSPORT_ERROR`. */
     close(): void;
     private post;
 }
 
 /**
- * WebSocket transport for sirannon-db. Connects to
- * `ws(s)://host:port/db/{id}` and supports query, execute, transaction,
- * batch, load, and real-time CDC subscriptions over a single persistent
- * connection.
+ * Sends queries, writes, transactions, batches, bulk loads, and change
+ * subscriptions to sirannon-db over one WebSocket connection to
+ * `ws(s)://host:port/db/{id}`.
  *
- * Connections are established lazily on first use and will
- * auto-reconnect (with subscription restoration) when
- * `autoReconnect` is enabled.
+ * The transport opens the connection on first use. When `autoReconnect` is on
+ * and a subscription or live query is open, it reconnects after a disconnect
+ * and subscribes again; otherwise it reconnects on the next request.
  *
  * @public
  */
@@ -478,6 +473,8 @@ declare class WebSocketTransport implements Transport {
     private closed;
     private connectPromise;
     private reconnectTimer;
+    private subscriptionsRestored;
+    private restorePromise;
     constructor(url: string, options?: {
         autoReconnect?: boolean;
         reconnectInterval?: number;
@@ -489,33 +486,34 @@ declare class WebSocketTransport implements Transport {
     query(sql: string, params?: Params, readConcern?: ReadConcern): Promise<QueryResponse>;
     /** Sends one write. */
     execute(sql: string, params?: Params): Promise<ExecuteResponse>;
-    /** Sends several statements the server runs in one transaction. */
+    /** Sends several statements that the server executes in one transaction. */
     transaction(statements: Array<{
         sql: string;
         params?: Params;
     }>): Promise<TransactionResponse>;
-    /** Sends one statement over many parameter sets, which the server runs in one transaction. */
+    /** Sends one statement with many parameter sets, which the server executes in one transaction. */
     batch(sql: string, paramsBatch: Params[], writeConcern?: WriteConcern): Promise<BatchResponse>;
-    /** Sends a bulk load, which the server runs at relaxed durability. */
+    /** Sends a bulk load, which the server executes at relaxed durability. */
     load(sql: string, paramsBatch: Params[], durability?: BulkLoadDurability, checkpoint?: boolean): Promise<LoadResponse>;
-    /** Runs a registered read by name and returns its rows. */
+    /** Executes a registered read by name and returns its rows. */
     queryNamed(name: string, args?: Record<string, unknown>, readConcern?: ReadConcern): Promise<QueryResponse>;
-    /** Runs a registered write by name. */
+    /** Executes a registered write by name. */
     executeNamed(name: string, args?: Record<string, unknown>, writeConcern?: WriteConcern): Promise<TransactionResponse>;
-    /** Opens a live query on a registered read and delivers its updates to the handlers. */
+    /** Opens a live query on a registered read and passes its updates to the handlers. */
     liveSubscribe(name: string, args: Record<string, unknown> | undefined, handlers: LiveHandlers, registryDigest?: RegistryDigestSource): Promise<RemoteSubscription>;
-    /** Opens a change subscription on a watched table. */
+    /** Opens a change subscription on a table. */
     subscribe(table: string, filter: Record<string, unknown> | undefined, callback: (event: ChangeEvent) => void, options?: SubscribeOptions): Promise<RemoteSubscription>;
     private sendUnsubscribe;
     /** @internal */
     ack(deviceId: string, seq: bigint): Promise<AckResponse>;
-    /** Closes the transport and every subscription running on it. */
+    /** Closes the transport and ends every subscription on it. */
     close(): void;
     private nextId;
     private ensureConnected;
     private connect;
     private handleDisconnect;
     private scheduleReconnect;
+    private restoreSubscriptions;
     private resubscribeAll;
     private request;
     private cancelReconnect;