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

package/dist/server/index.d.ts

@@ -1,71 +1,71 @@
-import { g as BackupChain, k as BackupChainRecord, o as BackupCycleStatus, z as BackupVerifyResult } from '../types-DPSmjU54.js';
-import { b as BackupRestoreProgress, a as BackupRestoreReport } from '../restore-options-CksYsH1l.js';
-import { a as TransactionStatement, Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-HI-nY8DD.js';
-export { b as BatchRequest, c as ErrorResponse, d as ExecuteRequest, e as LoadRequest, f as QueryRequest, g as TransactionRequest, t as toExecuteResponse } from '../protocol-HI-nY8DD.js';
-import { S as Sirannon } from '../sirannon-BPxC5tC2.js';
-import { B as BulkLoadDurability, S as ServerOptions, W as WSHandlerOptions } from '../server-options-Bj5iJnjx.js';
-import { W as WriteConcern, R as ReadConcern } from '../query-types-p1liOP-b.js';
-import '../database-BLQvqjsw.js';
-import '../database-backup-B7oszQ2n.js';
-import '../change-tracker-CjRFuZdB.js';
-import '../types-CjhxcjhA.js';
-import '../types-DTO4CYhW.js';
-import '../operation-registry-oiPuSYI6.js';
+import { g as BackupChain, k as BackupChainRecord, o as BackupCycleStatus, z as BackupVerifyResult } from '../types-Dc8oWlxj.js';
+import { b as BackupRestoreProgress, a as BackupRestoreReport } from '../restore-options-CH8mE-Tb.js';
+import { a as TransactionStatement, Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-DFpNNsIT.js';
+export { b as BatchRequest, c as ErrorResponse, d as ExecuteRequest, e as LoadRequest, f as QueryRequest, g as TransactionRequest, t as toExecuteResponse } from '../protocol-DFpNNsIT.js';
+import { S as Sirannon } from '../sirannon-J3EgPVD7.js';
+import { B as BulkLoadDurability, S as ServerOptions, W as WSHandlerOptions } from '../server-options-aYtCkefX.js';
+import { W as WriteConcern, R as ReadConcern } from '../query-types-5B02ixH0.js';
+import '../database-CGDsXW1K.js';
+import '../database-backup-DcLhxoa1.js';
+import '../change-tracker-DqCdeEyx.js';
+import '../types-DqODKeOq.js';
+import '../types-CEJG0eFS.js';
+import '../operation-registry-CGhNT-Sn.js';
 
-/** The answer to a backup a caller triggered, which the server takes on and does not wait for.
+/** The server's answer when a caller triggers a backup, which it sends once it accepts the turn and before the backup finishes.
  * @public
  */
 interface BackupTriggerResponse {
-    /** True whenever the server answers, since it answers only once it has accepted the turn. */
+    /** Always true, because the server sends this answer only after it accepts the turn. */
     started: true;
 }
-/** What the cycle is doing, and what its recent turns produced.
+/** The checkpoint cycle's current activity, and the results of its recent turns.
  * @public
  */
 type BackupStatusResponse = BackupCycleStatus;
-/** Every chain the destination stores.
+/** Every chain in the backup destination.
  * @public
  */
 interface BackupChainResponse {
     /** One entry per chain, newest first, each with its full copy and its change pieces in order. */
     chains: BackupChain[];
 }
-/** Names the backup to read back out of the destination.
+/** The backup to read back from the destination.
  * @public
  */
 interface BackupVerifyRequest {
-    /** Name the backup is stored under, which every chain record states. */
+    /** The name under which the destination stores the backup, as it appears in every chain record. */
     name?: unknown;
 }
-/** What Sirannon found when it read one backup back.
+/** The result of reading one backup back from the destination.
  * @public
  */
 type BackupVerifyResponse = BackupVerifyResult;
-/** How far back a restore must still reach.
+/** How far back you must still be able to restore.
  * @public
  */
 interface BackupSafeToDeleteRequest {
-    /** Epoch milliseconds of the earliest moment a restore must still reach. Leave it out and the answer covers only the backups no restore could ever use. */
+    /** The earliest moment, in epoch milliseconds, that you must still be able to restore to. When it is absent, the server lists only the backups that you cannot restore from. */
     restorableFrom?: unknown;
 }
-/** The records no restore still needs.
+/** The records that you no longer need for any restore.
  * @public
  */
 interface BackupSafeToDeleteResponse {
-    /** The records you may delete, oldest first. */
+    /** The records that you can delete, oldest first. */
     records: BackupChainRecord[];
 }
-/** The moment to rebuild the database at, and how many change pieces one batch replays.
+/** The moment to which the server rebuilds the database, and how many change pieces it replays in one batch.
  * @public
  */
 interface BackupRestoreRequest {
-    /** Epoch milliseconds you want back. Leave it out for the newest backup the destination stores. */
+    /** The moment, in epoch milliseconds, to restore the database to. When it is absent, the server uses the current time, so it restores the newest state that the destination stores. */
     moment?: unknown;
-    /** How many change pieces to replay between one checkpoint and the next. Leave it out for the default of 16. */
+    /** How many change pieces the server replays between one checkpoint and the next. Defaults to 16. */
     batchSize?: unknown;
 }
 
-/** Where one database's restore stands. `idle` means that none has started since the server did.
+/** The state of one database's restore. `idle` means that no restore has started since the server started.
  * @public
  */
 type BackupRestoreState = 'idle' | 'running' | 'done' | 'failed';
@@ -73,28 +73,28 @@ type BackupRestoreState = 'idle' | 'running' | 'done' | 'failed';
  * @public
  */
 interface BackupRestoreStatus {
-    /** Where the restore stands. */
+    /** The state of the restore. */
     state: BackupRestoreState;
-    /** Epoch milliseconds the caller asked to be taken back to. */
+    /** The moment, in epoch milliseconds, that the caller asked to restore to. */
     moment?: number;
-    /** Epoch milliseconds the restore started. */
+    /** When the restore started, in epoch milliseconds. */
     startedAt?: number;
-    /** Epoch milliseconds it finished, whether it succeeded or failed. */
+    /** When the restore finished, in epoch milliseconds, whether it succeeded or failed. */
     finishedAt?: number;
-    /** How far it has got, reported after every piece it fetches. */
+    /** The restore's progress, which the server updates after it fetches each piece. */
     progress?: BackupRestoreProgress;
-    /** What a finished restore produced. */
+    /** The report of a finished restore. */
     report?: BackupRestoreReport;
     /**
-     * Why the database it replaced would not open again. The rebuilt data is on
-     * disk and the registry has nothing open under the identifier, so an operator
-     * who sees this restarts the process.
+     * The error that stopped the rebuilt database from opening again. The rebuilt
+     * data is on disk, but the registry has no database open under the identifier,
+     * so restart the process when you see this error.
      */
     reopenError?: {
         code: string;
         message: string;
     };
-    /** Why a failed restore stopped. */
+    /** The error that stopped a failed restore. */
     error?: {
         code: string;
         message: string;
@@ -102,358 +102,363 @@ interface BackupRestoreStatus {
 }
 
 /**
- * Every message a client sends over the WebSocket. Each carries a `type` and a
- * client-chosen `id` the reply echoes.
+ * Every message that a client sends over the WebSocket. Each message has a `type`
+ * and an `id` that the client chooses and the server repeats in its reply.
  *
  * @public
  */
 type WSClientMessage = WSSubscribeMessage | WSUnsubscribeMessage | WSAckMessage | WSQueryMessage | WSExecuteMessage | WSTransactionMessage | WSBatchMessage | WSLoadMessage;
 /**
- * Opens a change subscription on one or more tables, or a live query on a registered read.
+ * A request to open a change subscription on one or more tables, or a live query on a registered read.
  *
  * @public
  */
 interface WSSubscribeMessage {
-    /** Names this message as a subscribe. */
+    /** The message type for a subscribe. */
     type: 'subscribe';
-    /** Client-chosen identifier the replies and change events echo. */
+    /** The identifier that the client chooses, which the server repeats in its replies and change events. */
     id: string;
-    /** Table to subscribe to. */
+    /** The table to subscribe to. */
     table?: string;
     /** Several tables to subscribe to at once. */
     tables?: string[];
     /** Narrows the subscription to rows whose columns equal these values. */
     filter?: Record<string, unknown>;
-    /** Name of a registered read, which opens a live query instead of a change subscription. */
+    /** The name of a registered read, so that the server opens a live query on that read. */
     name?: string;
-    /** Arguments that registered read takes. */
+    /** The arguments that the registered read takes. */
     args?: Record<string, unknown>;
-    /** Digest of the operation registry the client built its live query against. */
+    /** The digest of the operation registry that the client built its live query against. */
     registryDigest?: string;
     /**
-     * Highest `seq` the client has already processed. When present, the server
-     * replays every retained change with a greater seq before delivering live
-     * events so that a reconnecting subscriber does not miss changes. Sent as a
-     * decimal string to preserve values beyond `Number.MAX_SAFE_INTEGER`.
+     * The highest `seq` that the client has processed. When it is present, the server
+     * replays every retained change with a greater seq before it sends live events, so
+     * that a reconnecting subscriber receives the changes that it missed. When the server
+     * answers with `resync: true`, it skips the replay. The client sends the value as a
+     * decimal string, so that a value beyond `Number.MAX_SAFE_INTEGER` stays exact.
      */
     sinceSeq?: string;
     /**
-     * The `epoch` the server reported when this cursor was issued. A `sinceSeq`
-     * only means something within the sequence space that produced it, so a
-     * mismatch tells the server the cursor came from another database and it must
-     * resync rather than replay foreign rows against it.
+     * The `epoch` that the server reported with this cursor. A `sinceSeq` is valid
+     * only within the sequence space that produced it, so when this epoch differs
+     * from the server's own, the server answers with `resync: true` and skips the
+     * replay.
      */
     epoch?: string;
-    /** Identifies the device, which turns this into a device-sync subscription. */
+    /** The device's identifier, which makes this a device-sync subscription. */
     deviceId?: string;
-    /** Schema version the device's local database is at, which the server gates the stream on. */
+    /** The schema version of the device's local database, which the server checks before it opens the stream. */
     schemaVersion?: number;
     /**
-     * Declares that this device stages pulled changes durably and
+     * Set to true when this device stages pulled changes durably and
      * acknowledges staged sequences. The server then packs several events
-     * into each `changes` frame and paces the delivery window continuously
-     * instead of per transaction. Meaningful only with `deviceId`.
+     * into each `changes` frame and can pause the stream at any event. The
+     * server accepts it only with `deviceId`.
      */
     stagedStream?: boolean;
 }
 /**
- * Ends a subscription.
+ * A request to end a subscription.
  *
  * @public
  */
 interface WSUnsubscribeMessage {
-    /** Names this message as an unsubscribe. */
+    /** The message type for an unsubscribe. */
     type: 'unsubscribe';
-    /** Identifier of the subscription to end. */
+    /** The identifier of the subscription to end. */
     id: string;
 }
 /**
- * Acknowledges every change a device has stored up to a sequence.
+ * A device's acknowledgement of every change that it has stored up to a sequence.
  *
  * @public
  */
 interface WSAckMessage {
-    /** Names this message as an acknowledgement. */
+    /** The message type for an acknowledgement. */
     type: 'ack';
-    /** Client-chosen identifier the reply echoes. */
+    /** The identifier that the client chooses, which the server repeats in its reply. */
     id: string;
-    /** Identifies the device acknowledging. */
+    /** The identifier of the device that sends the acknowledgement. */
     deviceId: string;
-    /** Highest sequence the device has stored, as a decimal string. */
+    /** The highest sequence that the device has stored, as a decimal string. */
     seq: string;
 }
 /**
- * Runs a read, either as SQL or by the name of a registered read.
+ * A request to execute a read, either as SQL or by the name of a registered read.
  *
  * @public
  */
 interface WSQueryMessage {
-    /** Names this message as a read. */
+    /** The message type for a read. */
     type: 'query';
-    /** Client-chosen identifier the reply echoes. */
+    /** The identifier that the client chooses, which the server repeats in its reply. */
     id: string;
-    /** The statement to run. The server refuses it unless it accepts SQL. */
+    /** The statement to execute, which the server executes only when it accepts SQL. */
     sql?: string;
-    /** Values bound to that statement, named or positional. */
+    /** The values to bind to that statement, by name or by position. */
     params?: Record<string, unknown> | unknown[];
-    /** Name of a registered read to run instead, which carries no SQL. */
+    /** The name of a registered read to execute in place of `sql`. */
     name?: string;
-    /** Arguments that registered read takes. */
+    /** The arguments that the registered read takes. */
     args?: Record<string, unknown>;
-    /** Currency this read requires. */
+    /** The read concern that this read requires. */
     readConcern?: ReadConcern;
 }
 /**
- * Runs a write, either as SQL or by the name of a registered write.
+ * A request to execute a write, either as SQL or by the name of a registered write.
  *
  * @public
  */
 interface WSExecuteMessage {
-    /** Names this message as a write. */
+    /** The message type for a write. */
     type: 'execute';
-    /** Client-chosen identifier the reply echoes. */
+    /** The identifier that the client chooses, which the server repeats in its reply. */
     id: string;
-    /** The statement to run. The server refuses it unless it accepts SQL. */
+    /** The statement to execute, which the server executes only when it accepts SQL. */
     sql?: string;
-    /** Values bound to that statement, named or positional. */
+    /** The values to bind to that statement, by name or by position. */
     params?: Record<string, unknown> | unknown[];
-    /** Name of a registered write to run instead, which carries no SQL. */
+    /** The name of a registered write to execute in place of `sql`. */
     name?: string;
-    /** Arguments that registered write takes. */
+    /** The arguments that the registered write takes. */
     args?: Record<string, unknown>;
-    /** Acknowledgements this write waits for. */
+    /** The acknowledgements that the server waits for before it confirms this write. */
     writeConcern?: WriteConcern;
 }
 /**
- * Runs every statement in one server-side transaction and replies once with
- * all results. The client is never in the loop between statements, so the
- * single writer lock is held only for the duration of local execution.
+ * A request to execute every statement in one server-side transaction, to which the
+ * server replies once with all the results. The server makes no round trip to the
+ * client between statements, so it holds the single writer lock only while the
+ * statements execute.
  *
  * @public
  */
 interface WSTransactionMessage {
-    /** Names this message as a transaction. */
+    /** The message type for a transaction. */
     type: 'transaction';
-    /** Client-chosen identifier the reply echoes. */
+    /** The identifier that the client chooses, which the server repeats in its reply. */
     id: string;
-    /** The statements to run, in order. */
+    /** The statements to execute, in order. */
     statements: TransactionStatement[];
-    /** Acknowledgements the transaction waits for. */
+    /** The acknowledgements that the server waits for before it confirms the transaction. */
     writeConcern?: WriteConcern;
 }
 /**
- * Applies one statement over many parameter sets in a single server-side transaction.
+ * A request to execute one statement with many parameter sets in a single server-side transaction.
  *
  * @public
  */
 interface WSBatchMessage {
-    /** Names this message as a batch. */
+    /** The message type for a batch. */
     type: 'batch';
-    /** Client-chosen identifier the reply echoes. */
+    /** The identifier that the client chooses, which the server repeats in its reply. */
     id: string;
-    /** The statement to run for each parameter set. */
+    /** The statement to execute for each parameter set. */
     sql: string;
-    /** One parameter set per run. */
+    /** One parameter set for each execution of the statement. */
     paramsBatch: (Record<string, unknown> | unknown[])[];
-    /** Acknowledgements the batch waits for. */
+    /** The acknowledgements that the server waits for before it confirms the batch. */
     writeConcern?: WriteConcern;
 }
 /**
- * Imports many rows at relaxed durability, which the server restores before it replies.
+ * A request to import many rows at relaxed durability, which the server restores before it replies.
  *
  * @public
  */
 interface WSLoadMessage {
-    /** Names this message as a load. */
+    /** The message type for a load. */
     type: 'load';
-    /** Client-chosen identifier the reply echoes. */
+    /** The identifier that the client chooses, which the server repeats in its reply. */
     id: string;
-    /** The statement to run for each parameter set. */
+    /** The statement to execute for each parameter set. */
     sql: string;
     /** One parameter set per row. */
     paramsBatch: (Record<string, unknown> | unknown[])[];
-    /** Durability in force while the load runs. Default: 'off'. */
+    /** The writer's durability level during the load. Defaults to 'off'. */
     durability?: BulkLoadDurability;
-    /** Whether this load ends with a checkpoint. */
+    /** Whether the server checkpoints the WAL after this load. Defaults to true. */
     checkpoint?: boolean;
 }
+
 /**
- * Every message the server sends over the WebSocket.
+ * Every message that the server sends over the WebSocket.
  *
  * @public
  */
 type WSServerMessage = WSSubscribedMessage | WSUnsubscribedMessage | WSChangeMessage | WSChangesMessage | WSLiveMessage | WSResultMessage | WSErrorMessage;
 /**
- * One edit to a live query's result set, as a position and the row at it.
+ * One edit to a live query's result set, as a position and the row at that position.
  *
  * @public
  */
 type WSLiveOp = {
     /** Which edit this is: `'insert'` for a row added, `'update'` for a row changed in place, `'delete'` for a row removed. */
     op: 'insert';
-    /** Position in the result set the edit applies to, counted from zero. */
+    /** The zero-based position in the result set that the edit applies to. */
     index: number;
-    /** The row that now sits at that position. */
+    /** The row that is now at that position. */
     row: unknown;
 } | {
-    /** Names this edit as a row changed in place. */
+    /** The edit type for a row changed in place. */
     op: 'update';
-    /** Position of the row that changed. */
+    /** The position of the row that changed. */
     index: number;
-    /** The row as it now reads. */
+    /** The row's new values. */
     row: unknown;
 } | {
-    /** Names this edit as a row removed. */
+    /** The edit type for a removed row. */
     op: 'delete';
-    /** Position the removed row held. */
+    /** The position of the removed row. */
     index: number;
 };
 /**
- * Carries a live query's new state: the edits that move it, a full replacement, or notice that a re-read has started.
+ * A live query's new state, which is the edits that move it, a full replacement, or a notice that the server has started to read the query again.
  *
  * @public
  */
 interface WSLiveMessage {
-    /** Names this message as a live-query update. */
+    /** The message type for a live-query update. */
     type: 'live';
-    /** Identifier of the subscription this update belongs to. */
+    /** The identifier of the subscription that this update is for. */
     id: string;
     /** The edits that move the result set to its new state. */
     ops?: WSLiveOp[];
     /** A complete replacement result set. */
     rows?: unknown[];
-    /** Set while the server re-reads the query. */
+    /** Set while the server reads the query again. */
     revalidating?: boolean;
 }
 /**
- * Confirms a subscription opened, and states the cursor and sequence space it streams from.
+ * The server's confirmation that a subscription is open, with the cursor and the epoch that it streams from.
  *
  * @public
  */
 interface WSSubscribedMessage {
-    /** Names this message as a subscription confirmation. */
+    /** The message type for a subscription confirmation. */
     type: 'subscribed';
-    /** Identifier of the subscription that opened. */
+    /** The identifier of the subscription that is now open. */
     id: string;
     /**
-     * How far a device may run ahead of its acknowledged cursor before the
-     * server holds delivery. Present only for a device subscription.
+     * The number of changes that the server sends past the device's acknowledged
+     * cursor before it pauses delivery. The server sends it only for a device subscription.
      */
     maxUnacknowledgedChanges?: number;
     /**
-     * The seq the subscription is live from. A client that has not yet seen any
-     * change adopts this as its resume cursor so that a reconnect during an idle
-     * spell still replays what it missed instead of silently skipping it.
+     * The seq from which the subscription is live. A client that has not yet received
+     * any change stores this seq as its resume cursor, so that after a reconnect during
+     * a quiet period, the server still replays every change that the client missed.
      */
     seq?: string;
     /**
-     * Set when a requested `sinceSeq` fell below the retained history, so the
-     * gap cannot be replayed. The subscription still starts live from now; the
-     * client must treat its prior state as stale and re-read.
+     * Set when the server cannot replay from the requested `sinceSeq`, because that seq
+     * is older than the history that the server retains, the client's `epoch` differs
+     * from the server's, or the replay fails. The server skips the replay and the
+     * subscription starts from the server's current position, so the client must treat
+     * its earlier state as stale and read it again.
      */
     resync?: boolean;
     /**
-     * Identifies the sequence space this subscription streams from. The client
-     * stores it and echoes it when resuming so that a cursor carried to a different
-     * database forces a resync instead of a silent replay of unrelated rows.
+     * The identifier of the sequence space that this subscription streams from. The
+     * client stores it and sends it back when it resumes, so that the server answers a
+     * cursor from a different database with `resync: true`.
      */
     epoch?: string;
-    /** First result set of a live query, sent when the subscription named a registered read. */
+    /** The first result set of a live query, which the server sends when the subscription names a registered read. */
     rows?: unknown[];
 }
 /**
- * Confirms a subscription ended.
+ * The server's confirmation that a subscription has ended.
  *
  * @public
  */
 interface WSUnsubscribedMessage {
-    /** Names this message as an unsubscribe confirmation. */
+    /** The message type for an unsubscribe confirmation. */
     type: 'unsubscribed';
-    /** Identifier of the subscription that ended. */
+    /** The identifier of the subscription that has ended. */
     id: string;
 }
 /**
- * One change event as it crosses the wire, with sequences as decimal strings
- * so a value beyond the safe integer range survives JSON.
+ * One change event in its wire form, with the sequence as a decimal string,
+ * so that JSON keeps a value beyond the safe integer range exact.
  *
  * @public
  */
 interface WSWireChangeEvent {
     /** Whether the row was inserted, updated, or deleted. */
     type: 'insert' | 'update' | 'delete';
-    /** Table the row belongs to. */
+    /** The table of the row. */
     table: string;
-    /** The row as it stands after the change. */
+    /** The row's values after the change. */
     row: Record<string, unknown>;
-    /** The row as it stood before an update or a delete. */
+    /** The row's values before an update or a delete. */
     oldRow?: Record<string, unknown>;
-    /** Position of this change in the database's change log, as a decimal string. */
+    /** The position of this change in the database's change log, as a decimal string. */
     seq: string;
-    /** Milliseconds since the Unix epoch, taken when the change was recorded. */
+    /** Milliseconds since the Unix epoch, from when the database recorded the change. */
     timestamp: number;
-    /** Hybrid logical clock stamp the writing node gave this change. */
+    /** The hybrid logical clock stamp that the writing node gave this change. */
     hlc?: string;
-    /** Identifier of the node that authored the change. */
+    /** The identifier of the node or device that wrote the change. */
     origin?: string;
-    /** Primary key of the changed row, encoded as a string. */
+    /** The primary key of the changed row, encoded as a string. */
     rowId?: string;
-    /** Identifier of the transaction that produced this change. */
+    /** The identifier of the transaction that made this change. */
     txId?: string;
     /** Set on the last change of a transaction. */
     txEnd?: boolean;
 }
 /**
- * Carries one change event to a subscriber.
+ * One change event for a subscriber.
  *
  * @public
  */
 interface WSChangeMessage {
-    /** Names this message as a single change event. */
+    /** The message type for a single change event. */
     type: 'change';
-    /** Identifier of the subscription this change belongs to. */
+    /** The identifier of the subscription that this change is for. */
     id: string;
     /** The change itself. */
     event: WSWireChangeEvent;
 }
 /**
- * Several change events in one frame, in ascending seq order. Sent only on
- * a device subscription that requested `stagedStream`; the events carry the
- * same fields as a `change` frame's event.
+ * Several change events in one frame, in ascending seq order. The server sends
+ * this frame only on a device subscription that asks for `stagedStream`, and
+ * each event has the same fields as the event in a `change` frame.
  *
  * @public
  */
 interface WSChangesMessage {
-    /** Names this message as a run of change events. */
+    /** The message type for several change events. */
     type: 'changes';
-    /** Identifier of the subscription these changes belong to. */
+    /** The identifier of the subscription that these changes are for. */
     id: string;
     /** The changes, in ascending sequence order. */
     events: WSWireChangeEvent[];
 }
 /**
- * Replies to a read, write, transaction, batch, load, or acknowledgement.
+ * The server's reply to a read, write, transaction, batch, load, or acknowledgement.
  *
  * @public
  */
 interface WSResultMessage {
-    /** Names this message as a reply to a read, write, transaction, batch, load, or acknowledgement. */
+    /** The message type for a reply to a read, write, transaction, batch, load, or acknowledgement. */
     type: 'result';
-    /** Identifier the request carried. */
+    /** The identifier from the request. */
     id: string;
-    /** The reply body, whose shape follows the request that produced it. */
+    /** The reply body, whose shape depends on the request. */
     data: QueryResponse | ExecuteResponse | TransactionResponse | BatchResponse | LoadResponse | AckResponse;
 }
 /**
- * Reports that a request failed.
+ * The server's report that a request failed.
  *
  * @public
  */
 interface WSErrorMessage {
-    /** Names this message as a failure. */
+    /** The message type for a failure. */
     type: 'error';
-    /** Identifier the request carried. */
+    /** The identifier from the request, or an empty string when the server cannot read one. */
     id: string;
-    /** Machine-readable code and human-readable message. */
+    /** A machine-readable code and a human-readable message. */
     error: {
         code: string;
         message: string;
@@ -468,7 +473,8 @@ interface WSErrorMessage {
  * @public
  */
 declare class SirannonServer<Identity = unknown> {
-    private app;
+    private runtime;
+    private runtimeLoad;
     private listenSocket;
     private readonly host;
     private readonly port;
@@ -476,6 +482,7 @@ declare class SirannonServer<Identity = unknown> {
     private readonly authenticateHook;
     private readonly acceptSql;
     private readonly acceptBackupRestore;
+    private readonly acceptDeviceSync;
     private readonly restoreRuns;
     private readonly operations;
     private readonly registryDigest;
@@ -489,77 +496,79 @@ declare class SirannonServer<Identity = unknown> {
     private readonly maxWsBackpressureBytes;
     constructor(sirannon: Sirannon, options?: ServerOptions<Identity>);
     /**
-     * Binds the configured host and port and starts serving.
+     * Loads uWebSockets.js and starts serving on the configured host and port.
      *
-     * @throws When the port is already in use.
+     * @throws A `SirannonError` with code `SERVER_DEPENDENCY_MISSING` when this process cannot load uWebSockets.js.
+     * @throws An `Error` when uWebSockets.js cannot listen on the host and port, for example because the port is already in use.
      */
     listen(): Promise<void>;
     /**
-     * Stops serving and closes every open connection.
+     * Stops listening for new connections and closes every open WebSocket connection.
      */
     close(): Promise<void>;
     /**
-     * Port the server bound to, which is the resolved port when you asked for 0.
+     * The port that the server listens on, which the operating system chooses when you set `port` to 0, or -1 while the server is not listening.
      */
     get listeningPort(): number;
+    private loadRuntime;
     private registerRoutes;
     private registerBackupRoutes;
-    private registerWebSocketRoute;
     private withCors;
+    private routeDeps;
     private wrapDbRoute;
-    private wrapOperationRoute;
     private wrapDbGetRoute;
+    private wrapOperationRoute;
 }
 /**
- * Builds a server over a database registry.
+ * Builds a server that exposes the databases of one registry.
  *
  * @param sirannon - The registry whose databases the server exposes.
  * @param options - Address, cross-origin rules, size limits, authentication, registered operations, and whether the server accepts SQL.
- * @returns The server, ready to listen.
+ * @returns The server, which starts serving when you call {@link SirannonServer.listen}.
  *
  * @public
  */
 declare function createServer<Identity = unknown>(sirannon: Sirannon, options?: ServerOptions<Identity>): SirannonServer<Identity>;
 
 /**
- * Result of writing a frame to a WebSocket connection.
+ * The outcome of writing one frame to a WebSocket connection.
  *
- * - `sent`: delivered with no backpressure.
- * - `buffered`: accepted into the socket's outbound buffer under the
- *   backpressure limit; it will drain over time and must not be resent.
- * - `dropped`: rejected because it would exceed the backpressure limit, so
- *   the frame was not delivered. The caller must fail loud rather than treat
- *   the request as answered.
+ * - `sent`: uWebSockets writes the whole frame with no backpressure.
+ * - `buffered`: uWebSockets queues the frame in the socket's outbound buffer,
+ *   under the backpressure limit, and sends it later, so the caller must not send it again.
+ * - `dropped`: uWebSockets discards the frame, because the socket is closed or the
+ *   frame would push its buffer past the backpressure limit, so the client never
+ *   receives it. The caller must then report the request as failed.
  */
 type WSSendOutcome = 'sent' | 'buffered' | 'dropped';
 /**
- * One open WebSocket, as the handler sends over it.
+ * The methods that the handler uses to write to one open WebSocket.
  *
  * @internal
  */
 interface WSConnection {
     /**
-     * Sends one frame and reports whether it went out, was buffered, or was dropped.
+     * Sends one frame and returns whether uWebSockets sent it, buffered it, or dropped it.
      */
     send(data: string): WSSendOutcome;
     /**
-     * Reports how many bytes the socket still holds unsent.
+     * Returns the number of bytes that the socket has buffered and not yet sent.
      *
-     * A `buffered` outcome promises no later drain notification, because a send that
-     * queues only the tail of a frame can flush that tail without the socket ever
-     * becoming writable again. A sender that paused itself reads this to find out
-     * whether it is still waiting on anything.
+     * After a `buffered` outcome, uWebSockets may never fire a drain event, because
+     * when it queues only the tail of a frame, it can flush that tail without the
+     * socket becoming writable again. A paused device stream calls this method to
+     * check whether the socket still has bytes left to send.
      */
     bufferedAmount(): number;
     /**
-     * Writes a control frame so the socket flushes what it is holding.
+     * Sends a ping frame so that uWebSockets flushes the bytes that the socket has buffered.
      *
      * uWebSockets keeps a partial write queued until the next write on that socket,
-     * so a sender with nothing left to send calls this to move the remainder.
+     * so a caller with nothing left to send calls this method to send the rest.
      */
     flush(): void;
     /**
-     * Closes the connection with a code and reason.
+     * Closes the connection with a close code and a reason.
      */
     close(code?: number, reason?: string): void;
 }
@@ -578,14 +587,15 @@ declare class WSHandler<Identity = unknown> {
     private readonly maxUnacknowledgedChanges;
     private readonly socketResumeBytes;
     private readonly acceptSql;
+    private readonly acceptDeviceSync;
     private readonly operations;
     private closed;
     constructor(sirannon: Sirannon, options?: WSHandlerOptions<Identity>);
     handleOpen(conn: WSConnection, databaseId: string, identity?: unknown): Promise<void>;
     /**
-     * Tears down a connection whose outbound buffer overflowed. Closing lets the
-     * client reject in-flight requests and reconnect; guarding on `overloaded`
-     * keeps a burst of dropped frames from repeatedly re-closing the socket.
+     * Closes a connection after the server drops a frame on it at the backpressure limit,
+     * so the client can reject its pending requests and reconnect. The `overloaded` flag
+     * makes the handler close the socket once, however many frames the server drops in a burst.
      */
     handleOverload(conn: WSConnection): void;
     handleMessage(conn: WSConnection, data: string): void;
@@ -608,7 +618,7 @@ declare class WSHandler<Identity = unknown> {
     private sendText;
 }
 /**
- * Builds the WebSocket handler a server routes its upgrades and messages through.
+ * Builds the handler that processes a server's WebSocket connections and messages.
  *
  * @internal
  */