@replit/river 0.15.0 → 0.15.2

package/README.md

@@ -1,36 +1,60 @@
 # River
 
-## Long-lived Streaming Remote Procedure Calls
+River allows multiple clients to connect to and make remote procedure calls to a remote server as if they were local procedures.
 
-It's like tRPC/gRPC but with
+## Long-lived streaming remote procedure calls
+
+River provides a framework for long-lived streaming Remote Procedure Calls (RPCs) in modern web applications, featuring advanced error handling and customizable retry policies to ensure seamless communication between clients and servers.
+
+River provides a framework similar to [tRPC](https://trpc.io/) and [gRPC](https://grpc.io/) but with additional features:
 
 - JSON Schema Support + run-time schema validation
 - full-duplex streaming
 - service multiplexing
 - result types and error handling
-- snappy DX (no code-generation)
+- snappy DX (no code generation)
 - transparent reconnect support for long-lived sessions
 - over any transport (WebSockets and Unix Domain Socket out of the box)
 
 See [PROTOCOL.md](./PROTOCOL.md) for more information on the protocol.
 
-## Installation
+### Prerequisites
+
+Before proceeding, ensure you have TypeScript 5 installed and configured appropriately:
+
+1. **Ensure `"moduleResolution": "bundler"` in tsconfig.json**:
+
+   ```json
+   {
+     "compilerOptions": {
+       "moduleResolution": "bundler"
+       // Other compiler options...
+     }
+   }
+   ```
 
-To use River, you must be on least Typescript 5 with `"moduleResolution": "bundler"`.
+   If it exists but is set to a different value, modify it to `"bundler"`.
+
+2. Install River and Dependencies:
+
+To use River, install the required packages using npm:
 
 ```bash
-npm i @replit/river @sinclair/typebox
+  npm i @replit/river @sinclair/typebox
+```
 
-# if you plan on using WebSocket for transport, also install
+3. If you plan on using WebSocket for the underlying transport, also install
+
+```bash
 npm i ws isomorphic-ws
 ```
 
-## Writing Services
+## Writing services
 
 ### Concepts
 
 - Router: a collection of services, namespaced by service name.
-- Service: a collection of procedures with shared state.
+- Service: a collection of procedures with a shared state.
 - Procedure: a single procedure. A procedure declares its type, an input message type, an output message type, optionally an error type, and the associated handler. Valid types are:
   - `rpc` whose handler has a signature of `Input -> Result<Output, Error>`.
   - `upload` whose handler has a signature of `AsyncIterableIterator<Input> -> Result<Output, Error>`.
@@ -73,7 +97,7 @@ export const ExampleServiceConstructor = () =>
 export const serviceDefs = buildServiceDefs([ExampleServiceConstructor()]);
 ```
 
-Then, we create the server
+Then, we create the server:
 
 ```ts
 import http from 'http';
@@ -134,20 +158,16 @@ bindLogger(console.log);
 setLevel('info');
 ```
 
-### Connection Status
+### Connection status
 
-River define two types of reconnects:
+River defines two types of reconnects:
 
-1. Transparent reconnects: we lost the connection temporarily and reconnected without losing any messages. To the application level, nothing happened.
-2. Hard reconnect: we've lost all server state and the client should setup the world again.
+1. **Transparent reconnects:** These occur when the connection is temporarily lost and reestablished without losing any messages. From the application's perspective, this process is seamless and does not disrupt ongoing operations.
+2. **Hard reconnect:** This occurs when all server state is lost, requiring the client to reinitialize anything stateful (e.g. subscriptions).
 
-We can listen for transparent reconnects via the `connectionStatus` events but realistically
-no applications should need to listen for this unless it is for debug purposes. Hard reconnects
-are signalled via `sessionStatus` events.
+You can listen for transparent reconnects via the `connectionStatus` events, but realistically, no applications should need to listen for this unless it is for debugging purposes. Hard reconnects are signaled via `sessionStatus` events.
 
-If your application is stateful on either the server or the client, the service consumer _should_
-wrap all the client-side setup with `transport.addEventListener('sessionStatus', (evt) => ...)` to
-do appropriate setup and teardown.
+If your application is stateful on either the server or the client, the service consumer _should_ wrap all the client-side setup with `transport.addEventListener('sessionStatus', (evt) => ...)` to do appropriate setup and teardown.
 
 ```ts
 transport.addEventListener('connectionStatus', (evt) => {
@@ -169,8 +189,7 @@ transport.addEventListener('sessionStatus', (evt) => {
 
 ### Further examples
 
-We've also provided an end-to-end testing environment using Next.js, and a simple backend connected
-with the WebSocket transport that you can [play with on Replit](https://replit.com/@jzhao-replit/riverbed).
+We've also provided an end-to-end testing environment using `Next.js`, and a simple backend connected with the WebSocket transport that you can [play with on Replit](https://replit.com/@jzhao-replit/riverbed).
 
 You can find more service examples in the [E2E test fixtures](https://github.com/replit/river/blob/main/__tests__/fixtures/services.ts)
 

package/dist/{builder-ca6c4259.d.ts → builder-ebd945c0.d.ts}

@@ -1,6 +1,6 @@
 import { TObject, TUnion, TString, TSchema, TNever, TLiteral, Static } from '@sinclair/typebox';
 import { Pushable } from 'it-pushable';
-import { b as TransportClientId, d as Session, C as Connection } from './index-f922ec84.js';
+import { b as TransportClientId, e as Session, C as Connection } from './index-bbccacef.js';
 
 /**
  * The context for services/procedures. This is used only on

package/dist/{chunk-IVNV5HBI.js → chunk-B7VTDQR7.js}

@@ -16,12 +16,11 @@ import {
 } from "./chunk-GZ7HCLLM.js";
 
 // transport/events.ts
-var ProtocolErrorType = /* @__PURE__ */ ((ProtocolErrorType2) => {
-  ProtocolErrorType2["RetriesExceeded"] = "conn_retry_exceeded";
-  ProtocolErrorType2["HandshakeFailed"] = "handshake_failed";
-  ProtocolErrorType2["UseAfterDestroy"] = "use_after_destroy";
-  return ProtocolErrorType2;
-})(ProtocolErrorType || {});
+var ProtocolError = {
+  RetriesExceeded: "conn_retry_exceeded",
+  HandshakeFailed: "handshake_failed",
+  UseAfterDestroy: "use_after_destroy"
+};
 var EventDispatcher = class {
   eventListeners = {};
   numberOfListeners(eventType) {
@@ -59,15 +58,6 @@ var Connection = class {
     this.debugId = `conn-${unsafeId()}`;
   }
 };
-var HEARTBEAT_INTERVAL_MS = 1e3;
-var HEARTBEATS_TILL_DEAD = 2;
-var SESSION_DISCONNECT_GRACE_MS = 5e3;
-var defaultSessionOptions = {
-  heartbeatIntervalMs: HEARTBEAT_INTERVAL_MS,
-  heartbeatsUntilDead: HEARTBEATS_TILL_DEAD,
-  sessionDisconnectGraceMs: SESSION_DISCONNECT_GRACE_MS,
-  codec: NaiveJsonCodec
-};
 var Session = class {
   codec;
   options;
@@ -254,13 +244,95 @@ var Session = class {
 // transport/transport.ts
 import { Value } from "@sinclair/typebox/value";
 import { nanoid as nanoid2 } from "nanoid";
-var RECONNECT_JITTER_MAX_MS = 500;
-var RECONNECT_INTERVAL_MS = 250;
+
+// transport/rateLimit.ts
+var LeakyBucketRateLimit = class {
+  budgetConsumed;
+  intervalHandles;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.budgetConsumed = /* @__PURE__ */ new Map();
+    this.intervalHandles = /* @__PURE__ */ new Map();
+  }
+  getBackoffMs(user) {
+    if (!this.budgetConsumed.has(user))
+      return 0;
+    const exponent = Math.max(0, this.getBudgetConsumed(user) - 1);
+    const jitter = Math.floor(Math.random() * this.options.maxJitterMs);
+    const backoffMs = Math.min(
+      this.options.baseIntervalMs * 2 ** exponent,
+      this.options.maxBackoffMs
+    );
+    return backoffMs + jitter;
+  }
+  get totalBudgetRestoreTime() {
+    return this.options.budgetRestoreIntervalMs * this.options.attemptBudgetCapacity;
+  }
+  consumeBudget(user) {
+    this.stopLeak(user);
+    this.budgetConsumed.set(user, this.getBudgetConsumed(user) + 1);
+  }
+  getBudgetConsumed(user) {
+    return this.budgetConsumed.get(user) ?? 0;
+  }
+  hasBudget(user) {
+    return this.getBudgetConsumed(user) < this.options.attemptBudgetCapacity;
+  }
+  startRestoringBudget(user) {
+    if (this.intervalHandles.has(user)) {
+      return;
+    }
+    const restoreBudgetForUser = () => {
+      const currentBudget = this.budgetConsumed.get(user);
+      if (!currentBudget) {
+        this.stopLeak(user);
+        return;
+      }
+      const newBudget = currentBudget - 1;
+      if (newBudget === 0) {
+        this.budgetConsumed.delete(user);
+        return;
+      }
+      this.budgetConsumed.set(user, newBudget);
+    };
+    restoreBudgetForUser();
+    const intervalHandle = setInterval(
+      restoreBudgetForUser,
+      this.options.budgetRestoreIntervalMs
+    );
+    this.intervalHandles.set(user, intervalHandle);
+  }
+  stopLeak(user) {
+    if (!this.intervalHandles.has(user)) {
+      return;
+    }
+    clearInterval(this.intervalHandles.get(user));
+    this.intervalHandles.delete(user);
+  }
+  close() {
+    for (const user of this.intervalHandles.keys()) {
+      this.stopLeak(user);
+    }
+  }
+};
+
+// transport/transport.ts
 var defaultTransportOptions = {
-  retryIntervalMs: RECONNECT_INTERVAL_MS,
-  retryJitterMs: RECONNECT_JITTER_MAX_MS,
-  retryAttemptsMax: 5,
-  ...defaultSessionOptions
+  heartbeatIntervalMs: 1e3,
+  heartbeatsUntilDead: 2,
+  sessionDisconnectGraceMs: 5e3,
+  codec: NaiveJsonCodec
+};
+var defaultClientTransportOptions = {
+  connectionRetryOptions: {
+    baseIntervalMs: 250,
+    maxJitterMs: 200,
+    maxBackoffMs: 32e3,
+    attemptBudgetCapacity: 15,
+    budgetRestoreIntervalMs: 200
+  },
+  ...defaultTransportOptions
 };
 var Transport = class {
   /**
@@ -475,7 +547,7 @@ var Transport = class {
     if (this.state === "destroyed") {
       const err = "transport is destroyed, cant send";
       log?.error(`${this.clientId} -- ` + err + `: ${JSON.stringify(msg)}`);
-      this.protocolError("use_after_destroy" /* UseAfterDestroy */, err);
+      this.protocolError(ProtocolError.UseAfterDestroy, err);
       return void 0;
     } else if (this.state === "closed") {
       log?.info(
@@ -535,14 +607,26 @@ var Transport = class {
   }
 };
 var ClientTransport = class extends Transport {
+  /**
+   * The options for this transport.
+   */
+  options;
   /**
    * The map of reconnect promises for each client ID.
    */
   inflightConnectionPromises;
+  retryBudget;
   tryReconnecting = true;
   constructor(clientId, providedOptions) {
     super(clientId, providedOptions);
+    this.options = {
+      ...defaultClientTransportOptions,
+      ...providedOptions
+    };
     this.inflightConnectionPromises = /* @__PURE__ */ new Map();
+    this.retryBudget = new LeakyBucketRateLimit(
+      this.options.connectionRetryOptions
+    );
   }
   handleConnection(conn, to) {
     if (this.state !== "open")
@@ -573,7 +657,10 @@ var ClientTransport = class extends Transport {
       log?.info(
         `${this.clientId} -- connection (id: ${conn.debugId}) to ${to} disconnected`
       );
-      void this.connect(to);
+      this.inflightConnectionPromises.delete(to);
+      if (this.tryReconnecting) {
+        void this.connect(to);
+      }
     });
     conn.addErrorListener((err) => {
       log?.warn(
@@ -585,7 +672,7 @@ var ClientTransport = class extends Transport {
     const parsed = this.parseMsg(data);
     if (!parsed) {
       this.protocolError(
-        "handshake_failed" /* HandshakeFailed */,
+        ProtocolError.HandshakeFailed,
         "received non-transport message"
       );
       return false;
@@ -597,7 +684,7 @@ var ClientTransport = class extends Transport {
         )}`
       );
       this.protocolError(
-        "handshake_failed" /* HandshakeFailed */,
+        ProtocolError.HandshakeFailed,
         "invalid handshake resp"
       );
       return false;
@@ -609,7 +696,7 @@ var ClientTransport = class extends Transport {
         )}`
       );
       this.protocolError(
-        "handshake_failed" /* HandshakeFailed */,
+        ProtocolError.HandshakeFailed,
         parsed.payload.status.reason
       );
       return false;
@@ -624,41 +711,64 @@ var ClientTransport = class extends Transport {
    * Manually attempts to connect to a client.
    * @param to The client ID of the node to connect to.
    */
-  async connect(to, attempt = 0) {
-    if (this.state !== "open" || !this.tryReconnecting) {
+  async connect(to) {
+    const canProceedWithConnection = () => this.state === "open";
+    if (!canProceedWithConnection()) {
       log?.info(
-        `${this.clientId} -- transport state is no longer open, not attempting connection`
+        `${this.clientId} -- transport state is no longer open, cancelling attempt to connect to ${to}`
       );
       return;
     }
     let reconnectPromise = this.inflightConnectionPromises.get(to);
     if (!reconnectPromise) {
-      reconnectPromise = this.createNewOutgoingConnection(to).then((conn) => {
+      log?.info(`${this.clientId} -- attempting connection to ${to}`);
+      const budgetConsumed = this.retryBudget.getBudgetConsumed(to);
+      if (!this.retryBudget.hasBudget(to)) {
+        const errMsg = `not attempting to connect to ${to}, retry budget exceeded (more than ${budgetConsumed} attempts in the last ${this.retryBudget.totalBudgetRestoreTime}ms)`;
+        log?.warn(`${this.clientId} -- ${errMsg}`);
+        this.protocolError(ProtocolError.RetriesExceeded, errMsg);
+        return;
+      }
+      let sleep = Promise.resolve();
+      const backoffMs = this.retryBudget.getBackoffMs(to);
+      if (backoffMs > 0) {
+        sleep = new Promise((resolve) => setTimeout(resolve, backoffMs));
+      }
+      this.retryBudget.consumeBudget(to);
+      reconnectPromise = sleep.then(() => {
+        if (!canProceedWithConnection()) {
+          throw new Error("transport state is no longer open");
+        }
+      }).then(() => this.createNewOutgoingConnection(to)).then((conn) => {
+        if (!canProceedWithConnection()) {
+          log?.info(
+            `${this.clientId} -- transport state is no longer open, closing pre-handshake connection (id: ${conn.debugId}) to ${to}`
+          );
+          conn.close();
+          throw new Error("transport state is no longer open");
+        }
+        this.retryBudget.startRestoringBudget(to);
         this.sendHandshake(to, conn);
         return conn;
       });
       this.inflightConnectionPromises.set(to, reconnectPromise);
+    } else {
+      log?.info(
+        `${this.clientId} -- attempting connection to ${to} (reusing previous attempt)`
+      );
     }
     try {
       await reconnectPromise;
     } catch (error) {
-      const errStr = coerceErrorString(error);
       this.inflightConnectionPromises.delete(to);
-      const shouldRetry = this.state === "open" && this.tryReconnecting;
-      if (!shouldRetry)
-        return;
-      if (attempt >= this.options.retryAttemptsMax) {
-        const errMsg = `connection to ${to} failed after ${attempt} attempts (${errStr}), giving up`;
-        log?.error(`${this.clientId} -- ${errMsg}`);
-        this.protocolError("conn_retry_exceeded" /* RetriesExceeded */, errMsg);
-        return;
+      const errStr = coerceErrorString(error);
+      if (!this.tryReconnecting || !canProceedWithConnection()) {
+        log?.warn(`${this.clientId} -- connection to ${to} failed (${errStr})`);
       } else {
-        const jitter = Math.floor(Math.random() * this.options.retryJitterMs);
-        const backoffMs = this.options.retryIntervalMs * 2 ** attempt + jitter;
         log?.warn(
-          `${this.clientId} -- connection to ${to} failed (${errStr}), trying again in ${backoffMs}ms`
+          `${this.clientId} -- connection to ${to} failed (${errStr}), retrying`
         );
-        setTimeout(() => void this.connect(to, attempt + 1), backoffMs);
+        return this.connect(to);
       }
     }
   }
@@ -671,9 +781,9 @@ var ClientTransport = class extends Transport {
     log?.debug(`${this.clientId} -- sending handshake request to ${to}`);
     conn.send(this.codec.toBuffer(requestMsg));
   }
-  onDisconnect(conn, session) {
-    this.inflightConnectionPromises.delete(session.to);
-    super.onDisconnect(conn, session);
+  close() {
+    this.retryBudget.close();
+    super.close();
   }
 };
 var ServerTransport = class extends Transport {
@@ -729,7 +839,7 @@ var ServerTransport = class extends Transport {
     const parsed = this.parseMsg(data);
     if (!parsed) {
       this.protocolError(
-        "handshake_failed" /* HandshakeFailed */,
+        ProtocolError.HandshakeFailed,
         "received non-transport message"
       );
       return false;
@@ -748,7 +858,7 @@ var ServerTransport = class extends Transport {
         )}`
       );
       this.protocolError(
-        "handshake_failed" /* HandshakeFailed */,
+        ProtocolError.HandshakeFailed,
         "invalid handshake request"
       );
       return false;
@@ -766,7 +876,7 @@ var ServerTransport = class extends Transport {
         `${this.clientId} -- received handshake msg with incompatible protocol version (got: ${gotVersion}, expected: ${PROTOCOL_VERSION})`
       );
       this.protocolError(
-        "handshake_failed" /* HandshakeFailed */,
+        ProtocolError.HandshakeFailed,
         `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`
       );
       return false;
@@ -787,9 +897,8 @@ var ServerTransport = class extends Transport {
 };
 
 export {
-  ProtocolErrorType,
+  ProtocolError,
   Connection,
-  defaultSessionOptions,
   Session,
   Transport,
   ClientTransport,

package/dist/{chunk-BSAIT634.js → chunk-UJHTHOTT.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-IVNV5HBI.js";
+} from "./chunk-B7VTDQR7.js";
 
 // transport/transforms/messageFraming.ts
 import { Transform } from "node:stream";

package/dist/{chunk-FFT7PSUV.js → chunk-ZRB6IKPV.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-IVNV5HBI.js";
+} from "./chunk-B7VTDQR7.js";
 
 // transport/impls/ws/connection.ts
 var WebSocketConnection = class extends Connection {

package/dist/{connection-0c5eeb14.d.ts → connection-10a24478.d.ts}

@@ -1,4 +1,4 @@
-import { C as Connection } from './index-f922ec84.js';
+import { C as Connection } from './index-bbccacef.js';
 import { Socket } from 'node:net';
 import stream, { Transform, TransformCallback, TransformOptions } from 'node:stream';
 

package/dist/{connection-14675d77.d.ts → connection-f4492948.d.ts}

@@ -1,5 +1,5 @@
 import WebSocket from 'isomorphic-ws';
-import { C as Connection } from './index-f922ec84.js';
+import { C as Connection } from './index-bbccacef.js';
 
 declare class WebSocketConnection extends Connection {
     ws: WebSocket;

package/dist/{index-f922ec84.d.ts → index-bbccacef.d.ts}

@@ -129,9 +129,22 @@ declare abstract class Connection {
     abstract close(): void;
 }
 interface SessionOptions {
+    /**
+     * Frequency at which to send heartbeat acknowledgements
+     */
     heartbeatIntervalMs: number;
+    /**
+     * Number of elapsed heartbeats without a response message before we consider
+     * the connection dead.
+     */
     heartbeatsUntilDead: number;
+    /**
+     * Duration to wait between connection disconnect and actual session disconnect
+     */
     sessionDisconnectGraceMs: number;
+    /**
+     * The codec to use for encoding/decoding messages over the wire
+     */
     codec: Codec;
 }
 /**
@@ -205,11 +218,12 @@ declare class Session<ConnType extends Connection> {
 }
 
 type ConnectionStatus = 'connect' | 'disconnect';
-declare const enum ProtocolErrorType {
-    RetriesExceeded = "conn_retry_exceeded",
-    HandshakeFailed = "handshake_failed",
-    UseAfterDestroy = "use_after_destroy"
-}
+declare const ProtocolError: {
+    readonly RetriesExceeded: "conn_retry_exceeded";
+    readonly HandshakeFailed: "handshake_failed";
+    readonly UseAfterDestroy: "use_after_destroy";
+};
+type ProtocolErrorType = (typeof ProtocolError)[keyof typeof ProtocolError];
 interface EventMap {
     message: OpaqueTransportMessage;
     connectionStatus: {
@@ -235,6 +249,58 @@ declare class EventDispatcher<T extends EventTypes> {
     dispatchEvent<K extends T>(eventType: K, event: EventMap[K]): void;
 }
 
+/**
+ * Options to control the backoff and retry behavior of the client transport's connection behaviour.
+ *
+ * River implements exponential backoff with jitter to prevent flooding the server
+ * when there's an issue with connection establishment.
+ *
+ * The backoff is calculated via the following:
+ *   backOff = min(jitter + {@link baseIntervalMs} * 2 ^ budget_consumed, {@link maxBackoffMs})
+ *
+ * We use a leaky bucket rate limit with a budget of {@link attemptBudgetCapacity} reconnection attempts.
+ * Budget only starts to restore after a successful handshake at a rate of one budget per {@link budgetRestoreIntervalMs}.
+ */
+interface ConnectionRetryOptions {
+    /**
+     * The base interval to wait before retrying a connection.
+     */
+    baseIntervalMs: number;
+    /**
+     * The maximum random jitter to add to the total backoff time.
+     */
+    maxJitterMs: number;
+    /**
+     * The maximum amount of time to wait before retrying a connection.
+     * This does not include the jitter.
+     */
+    maxBackoffMs: number;
+    /**
+     * The max number of times to attempt a connection before a successful handshake.
+     * This persists across connections but starts restoring budget after a successful handshake.
+     * The restoration interval depends on {@link budgetRestoreIntervalMs}
+     */
+    attemptBudgetCapacity: number;
+    /**
+     * After a successful connection attempt, how long to wait before we restore a single budget.
+     */
+    budgetRestoreIntervalMs: number;
+}
+declare class LeakyBucketRateLimit {
+    private budgetConsumed;
+    private intervalHandles;
+    private readonly options;
+    constructor(options: ConnectionRetryOptions);
+    getBackoffMs(user: TransportClientId): number;
+    get totalBudgetRestoreTime(): number;
+    consumeBudget(user: TransportClientId): void;
+    getBudgetConsumed(user: TransportClientId): number;
+    hasBudget(user: TransportClientId): boolean;
+    startRestoringBudget(user: TransportClientId): void;
+    private stopLeak;
+    close(): void;
+}
+
 /**
  * Represents the possible states of a transport.
  * @property {'open'} open - The transport is open and operational (note that this doesn't mean it is actively connected)
@@ -242,11 +308,14 @@ declare class EventDispatcher<T extends EventTypes> {
  * @property {'destroyed'} destroyed - The transport is permanently destroyed and cannot be reopened.
  */
 type TransportStatus = 'open' | 'closed' | 'destroyed';
-type TransportOptions = {
-    retryIntervalMs: number;
-    retryJitterMs: number;
-    retryAttemptsMax: number;
-} & SessionOptions;
+type ProvidedTransportOptions = Partial<SessionOptions>;
+type TransportOptions = Required<ProvidedTransportOptions>;
+interface ProvidedClientTransportOptions extends ProvidedTransportOptions {
+    connectionRetryOptions?: Partial<ConnectionRetryOptions>;
+}
+interface ClientTransportOptions extends Required<ProvidedClientTransportOptions> {
+    connectionRetryOptions: ConnectionRetryOptions;
+}
 /**
  * Transports manage the lifecycle (creation/deletion) of sessions and connections. Its responsibilities include:
  *
@@ -320,7 +389,7 @@ declare abstract class Transport<ConnType extends Connection> {
      * @param codec The codec used to encode and decode messages.
      * @param clientId The client ID of this transport.
      */
-    constructor(clientId: TransportClientId, providedOptions?: Partial<TransportOptions>);
+    constructor(clientId: TransportClientId, providedOptions?: ProvidedTransportOptions);
     /**
      * This is called immediately after a new connection is established and we
      * may or may not know the identity of the connected client.
@@ -391,12 +460,17 @@ declare abstract class Transport<ConnType extends Connection> {
     destroy(): void;
 }
 declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {
+    /**
+     * The options for this transport.
+     */
+    protected options: ClientTransportOptions;
     /**
      * The map of reconnect promises for each client ID.
      */
     inflightConnectionPromises: Map<TransportClientId, Promise<ConnType>>;
+    retryBudget: LeakyBucketRateLimit;
     tryReconnecting: boolean;
-    constructor(clientId: TransportClientId, providedOptions?: Partial<TransportOptions>);
+    constructor(clientId: TransportClientId, providedOptions?: ProvidedTransportOptions);
     protected handleConnection(conn: ConnType, to: TransportClientId): void;
     receiveHandshakeResponseMessage(data: Uint8Array): false | {
         instanceId: string;
@@ -415,12 +489,12 @@ declare abstract class ClientTransport<ConnType extends Connection> extends Tran
      * Manually attempts to connect to a client.
      * @param to The client ID of the node to connect to.
      */
-    connect(to: TransportClientId, attempt?: number): Promise<void>;
+    connect(to: TransportClientId): Promise<void>;
     protected sendHandshake(to: TransportClientId, conn: ConnType): void;
-    protected onDisconnect(conn: ConnType, session: Session<ConnType>): void;
+    close(): void;
 }
 declare abstract class ServerTransport<ConnType extends Connection> extends Transport<ConnType> {
-    constructor(clientId: TransportClientId, providedOptions?: Partial<TransportOptions>);
+    constructor(clientId: TransportClientId, providedOptions?: Omit<Partial<ProvidedTransportOptions>, 'connectionRetryOptions'>);
     protected handleConnection(conn: ConnType): void;
     receiveHandshakeRequestMessage(data: Uint8Array, conn: ConnType): false | {
         instanceId: string;
@@ -428,4 +502,4 @@ declare abstract class ServerTransport<ConnType extends Connection> extends Tran
     };
 }
 
-export { Connection as C, EventMap as E, OpaqueTransportMessage as O, PartialTransportMessage as P, ServerTransport as S, Transport as T, ClientTransport as a, TransportClientId as b, TransportOptions as c, Session as d, TransportStatus as e, TransportMessageSchema as f, OpaqueTransportMessageSchema as g, TransportMessage as h, isStreamOpen as i, isStreamClose as j, EventTypes as k, EventHandler as l, ProtocolErrorType as m };
+export { Connection as C, EventMap as E, OpaqueTransportMessage as O, PartialTransportMessage as P, ServerTransport as S, Transport as T, ClientTransport as a, TransportClientId as b, ProvidedClientTransportOptions as c, ProvidedTransportOptions as d, Session as e, TransportStatus as f, TransportMessageSchema as g, OpaqueTransportMessageSchema as h, TransportMessage as i, isStreamOpen as j, isStreamClose as k, EventTypes as l, EventHandler as m, ProtocolError as n, ProtocolErrorType as o };