@replit/river 0.16.1 → 0.17.0

package/dist/transport/index.cjs

@@ -55,18 +55,18 @@ var ControlMessageAckSchema = import_typebox.Type.Object({
 var ControlMessageCloseSchema = import_typebox.Type.Object({
   type: import_typebox.Type.Literal("CLOSE")
 });
-var PROTOCOL_VERSION = "v1";
+var PROTOCOL_VERSION = "v1.1";
 var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
   type: import_typebox.Type.Literal("HANDSHAKE_REQ"),
   protocolVersion: import_typebox.Type.String(),
-  instanceId: import_typebox.Type.String()
+  sessionId: import_typebox.Type.String()
 });
 var ControlMessageHandshakeResponseSchema = import_typebox.Type.Object({
   type: import_typebox.Type.Literal("HANDSHAKE_RESP"),
   status: import_typebox.Type.Union([
     import_typebox.Type.Object({
       ok: import_typebox.Type.Literal(true),
-      instanceId: import_typebox.Type.String()
+      sessionId: import_typebox.Type.String()
     }),
     import_typebox.Type.Object({
       ok: import_typebox.Type.Literal(false),
@@ -83,7 +83,7 @@ var ControlMessagePayloadSchema = import_typebox.Type.Union([
 var OpaqueTransportMessageSchema = TransportMessageSchema(
   import_typebox.Type.Unknown()
 );
-function handshakeRequestMessage(from, to, instanceId) {
+function handshakeRequestMessage(from, to, sessionId) {
   return {
     id: (0, import_nanoid.nanoid)(),
     from,
@@ -95,11 +95,11 @@ function handshakeRequestMessage(from, to, instanceId) {
     payload: {
       type: "HANDSHAKE_REQ",
       protocolVersion: PROTOCOL_VERSION,
-      instanceId
+      sessionId
     }
   };
 }
-function handshakeResponseMessage(from, instanceId, to, ok, reason) {
+function handshakeResponseMessage(from, to, status) {
   return {
     id: (0, import_nanoid.nanoid)(),
     from,
@@ -108,18 +108,9 @@ function handshakeResponseMessage(from, instanceId, to, ok, reason) {
     ack: 0,
     streamId: (0, import_nanoid.nanoid)(),
     controlFlags: 0,
-    payload: ok ? {
-      type: "HANDSHAKE_RESP",
-      status: {
-        ok: true,
-        instanceId
-      }
-    } : {
+    payload: {
       type: "HANDSHAKE_RESP",
-      status: {
-        ok: false,
-        reason: reason ?? "Unknown reason"
-      }
+      status
     }
   };
 }
@@ -134,7 +125,8 @@ var log;
 var ProtocolError = {
   RetriesExceeded: "conn_retry_exceeded",
   HandshakeFailed: "handshake_failed",
-  UseAfterDestroy: "use_after_destroy"
+  UseAfterDestroy: "use_after_destroy",
+  MessageOrderingViolated: "message_ordering_violated"
 };
 var EventDispatcher = class {
   eventListeners = {};
@@ -189,7 +181,12 @@ var Session = class {
   /**
    * The unique ID of this session.
    */
-  debugId;
+  id;
+  /**
+   * What the other side advertised as their session ID
+   * for this session.
+   */
+  advertisedSessionId;
   /**
    * Number of messages we've sent along this session (excluding handshake and acks)
    */
@@ -211,11 +208,11 @@ var Session = class {
    * The interval for sending heartbeats.
    */
   heartbeat;
-  constructor(from, connectedTo, conn, options) {
+  constructor(conn, from, to, options) {
+    this.id = `session-${nanoid2(12)}`;
     this.options = options;
-    this.debugId = `sess-${unsafeId()}`;
     this.from = from;
-    this.to = connectedTo;
+    this.to = to;
     this.connection = conn;
     this.codec = options.codec;
     this.heartbeatMisses = 0;
@@ -255,7 +252,7 @@ var Session = class {
         log?.info(
           `${this.from} -- closing connection (id: ${this.connection.debugId}) to ${this.to} due to inactivity`
         );
-        this.closeStaleConnection(this.connection);
+        this.closeStaleConnection();
       }
       return;
     }
@@ -286,33 +283,37 @@ var Session = class {
       log?.debug(`${this.from} -- resending ${msg.id} (seq: ${msg.seq})`);
       const ok = this.connection.send(this.codec.toBuffer(msg));
       if (!ok) {
-        const msg2 = `${this.from} -- failed to send buffered message to ${this.to} in session (id: ${this.debugId}) (if you hit this code path something is seriously wrong)`;
+        const msg2 = `${this.from} -- failed to send buffered message to ${this.to} in session (id: ${this.id}) (if you hit this code path something is seriously wrong)`;
         log?.error(msg2);
         throw new Error(msg2);
       }
     }
   }
   updateBookkeeping(ack, seq) {
+    if (seq + 1 < this.ack) {
+      log?.error(`${this.from} -- received stale seq ${seq} + 1 < ${this.ack}`);
+      return;
+    }
     this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq > ack);
     this.ack = seq + 1;
   }
   closeStaleConnection(conn) {
-    if (!this.connection || this.connection !== conn)
+    if (this.connection === void 0 || this.connection === conn)
       return;
     log?.info(
-      `${this.from} -- closing old inner connection (id: ${this.connection.debugId}) from session (id: ${this.debugId}) to ${this.to}`
+      `${this.from} -- closing old inner connection (id: ${this.connection.debugId}) from session (id: ${this.id}) to ${this.to}`
     );
     this.connection.close();
     this.connection = void 0;
   }
   replaceWithNewConnection(newConn) {
-    this.closeStaleConnection(this.connection);
+    this.closeStaleConnection(newConn);
     this.cancelGrace();
     this.connection = newConn;
   }
   beginGrace(cb) {
     log?.info(
-      `${this.from} -- starting ${this.options.sessionDisconnectGraceMs}ms grace period until session (id: ${this.debugId}) to ${this.to} is closed`
+      `${this.from} -- starting ${this.options.sessionDisconnectGraceMs}ms grace period until session (id: ${this.id}) to ${this.to} is closed`
     );
     this.disconnectionGrace = setTimeout(() => {
       this.close();
@@ -323,11 +324,12 @@ var Session = class {
   cancelGrace() {
     this.heartbeatMisses = 0;
     clearTimeout(this.disconnectionGrace);
+    this.disconnectionGrace = void 0;
   }
   // closed when we want to discard the whole session
   // (i.e. shutdown or session disconnect)
   close() {
-    this.closeStaleConnection(this.connection);
+    this.closeStaleConnection();
     this.cancelGrace();
     this.resetBufferedMessages();
     clearInterval(this.heartbeat);
@@ -356,9 +358,6 @@ var Session = class {
   }
 };
 
-// transport/transport.ts
-var import_nanoid3 = require("nanoid");
-
 // util/stringify.ts
 function coerceErrorString(err) {
   if (err instanceof Error) {
@@ -505,17 +504,10 @@ var defaultConnectionRetryOptions = {
   budgetRestoreIntervalMs: 200
 };
 var defaultClientTransportOptions = {
-  connectionRetryOptions: defaultConnectionRetryOptions,
-  ...defaultTransportOptions
+  ...defaultTransportOptions,
+  ...defaultConnectionRetryOptions
 };
 var Transport = class {
-  /**
-   * Unique per instance of the transport.
-   * This allows us to distinguish reconnects to different
-   * transports.
-   */
-  instanceId = (0, import_nanoid3.nanoid)();
-  connectedInstanceIds = /* @__PURE__ */ new Map();
   /**
    * A flag indicating whether the transport has been destroyed.
    * A destroyed transport will not attempt to reconnect and cannot be used again.
@@ -568,41 +560,41 @@ var Transport = class {
    * and we know the identity of the connected client.
    * @param conn The connection object.
    */
-  onConnect(conn, connectedTo, instanceId) {
+  onConnect(conn, connectedTo, advertisedSessionId) {
     this.eventDispatcher.dispatchEvent("connectionStatus", {
       status: "connect",
       conn
     });
     let oldSession = this.sessions.get(connectedTo);
-    const lastInstanceId = this.connectedInstanceIds.get(connectedTo);
-    if (oldSession && lastInstanceId !== void 0 && lastInstanceId !== instanceId) {
+    if (oldSession?.advertisedSessionId && oldSession.advertisedSessionId !== advertisedSessionId) {
       log?.warn(
-        `${this.clientId} -- connection from ${connectedTo} is a different instance (got: ${instanceId}, last connected to: ${lastInstanceId}), starting a new session`
+        `${this.clientId} -- connection from ${connectedTo} is a different session (id: ${advertisedSessionId}, last connected to: ${oldSession.advertisedSessionId}), starting a new session`
       );
       oldSession.close();
       this.deleteSession(oldSession);
       oldSession = void 0;
     }
-    this.connectedInstanceIds.set(connectedTo, instanceId);
     if (oldSession === void 0) {
       const newSession = this.createSession(connectedTo, conn);
+      newSession.advertisedSessionId = advertisedSessionId;
       log?.info(
-        `${this.clientId} -- new connection (id: ${conn.debugId}) for new session (id: ${newSession.debugId}) to ${connectedTo}`
+        `${this.clientId} -- new connection (id: ${conn.debugId}) for new session (id: ${newSession.id}) to ${connectedTo}`
       );
       return newSession;
     }
     log?.info(
-      `${this.clientId} -- new connection (id: ${conn.debugId}) for existing session (id: ${oldSession.debugId}) to ${connectedTo}`
+      `${this.clientId} -- new connection (id: ${conn.debugId}) for existing session (id: ${oldSession.id}) to ${connectedTo}`
     );
     oldSession.replaceWithNewConnection(conn);
     oldSession.sendBufferedMessages();
+    oldSession.advertisedSessionId = advertisedSessionId;
     return oldSession;
   }
-  createSession(connectedTo, conn) {
+  createSession(to, conn) {
     const session = new Session(
-      this.clientId,
-      connectedTo,
       conn,
+      this.clientId,
+      to,
       this.options
     );
     this.sessions.set(session.to, session);
@@ -612,10 +604,20 @@ var Transport = class {
     });
     return session;
   }
+  getOrCreateSession(to, conn) {
+    let session = this.sessions.get(to);
+    if (!session) {
+      session = this.createSession(to, conn);
+      log?.info(
+        `${this.clientId} -- no session for ${to}, created a new one (id: ${session.id})`
+      );
+    }
+    return session;
+  }
   deleteSession(session) {
     this.sessions.delete(session.to);
     log?.info(
-      `${this.clientId} -- session ${session.debugId} disconnect from ${session.to}`
+      `${this.clientId} -- session ${session.id} disconnect from ${session.to}`
     );
     this.eventDispatcher.dispatchEvent("sessionStatus", {
       status: "disconnect",
@@ -683,11 +685,14 @@ var Transport = class {
           )}`
         );
       } else {
+        const errMsg = `received out-of-order msg (got seq: ${msg.seq}, wanted seq: ${session.nextExpectedSeq})`;
         log?.error(
-          `${this.clientId} -- received out-of-order msg (got: ${msg.seq}, wanted: ${session.nextExpectedSeq}), marking connection as dead: ${JSON.stringify(msg)}`
+          `${this.clientId} -- fatal: ${errMsg}, marking connection as dead: ${JSON.stringify(
+            msg
+          )}`
         );
+        this.protocolError(ProtocolError.MessageOrderingViolated, errMsg);
         session.close();
-        this.deleteSession(session);
       }
       return;
     }
@@ -734,14 +739,7 @@ var Transport = class {
       );
       return void 0;
     }
-    let session = this.sessions.get(to);
-    if (!session) {
-      session = this.createSession(to, void 0);
-      log?.info(
-        `${this.clientId} -- no session for ${to}, created a new one (id: ${session.debugId})`
-      );
-    }
-    return session.send(msg);
+    return this.getOrCreateSession(to).send(msg);
   }
   // control helpers
   sendCloseStream(to, streamId) {
@@ -793,7 +791,13 @@ var ClientTransport = class extends Transport {
    */
   inflightConnectionPromises;
   retryBudget;
-  tryReconnecting = true;
+  /**
+   * A flag indicating whether the transport should automatically reconnect
+   * when a connection is dropped.
+   * Realistically, this should always be true for clients unless you are writing
+   * tests or a special case where you don't want to reconnect.
+   */
+  reconnectOnConnectionDrop = true;
   constructor(clientId, providedOptions) {
     super(clientId, providedOptions);
     this.options = {
@@ -801,21 +805,20 @@ var ClientTransport = class extends Transport {
       ...providedOptions
     };
     this.inflightConnectionPromises = /* @__PURE__ */ new Map();
-    this.retryBudget = new LeakyBucketRateLimit(
-      this.options.connectionRetryOptions
-    );
+    this.retryBudget = new LeakyBucketRateLimit(this.options);
   }
   handleConnection(conn, to) {
     if (this.state !== "open")
       return;
     let session = void 0;
     const handshakeHandler = (data) => {
-      const handshake = this.receiveHandshakeResponseMessage(data);
-      if (!handshake) {
+      const maybeSession = this.receiveHandshakeResponseMessage(data, conn);
+      if (!maybeSession) {
         conn.close();
         return;
+      } else {
+        session = maybeSession;
       }
-      session = this.onConnect(conn, handshake.from, handshake.instanceId);
       conn.removeDataListener(handshakeHandler);
       conn.addDataListener((data2) => {
         const parsed = this.parseMsg(data2);
@@ -835,7 +838,7 @@ var ClientTransport = class extends Transport {
         `${this.clientId} -- connection (id: ${conn.debugId}) to ${to} disconnected`
       );
       this.inflightConnectionPromises.delete(to);
-      if (this.tryReconnecting) {
+      if (this.reconnectOnConnectionDrop) {
         void this.connect(to);
       }
     });
@@ -845,7 +848,7 @@ var ClientTransport = class extends Transport {
       );
     });
   }
-  receiveHandshakeResponseMessage(data) {
+  receiveHandshakeResponseMessage(data, conn) {
     const parsed = this.parseMsg(data);
     if (!parsed) {
       this.protocolError(
@@ -878,12 +881,14 @@ var ClientTransport = class extends Transport {
       );
       return false;
     }
-    const instanceId = parsed.payload.status.instanceId;
-    log?.debug(
-      `${this.clientId} -- handshake from ${parsed.from} ok (instance: ${instanceId})`
+    log?.debug(`${this.clientId} -- handshake from ${parsed.from} ok`);
+    const session = this.onConnect(
+      conn,
+      parsed.from,
+      parsed.payload.status.sessionId
     );
     this.retryBudget.startRestoringBudget(parsed.from);
-    return { instanceId, from: parsed.from };
+    return session;
   }
   /**
    * Manually attempts to connect to a client.
@@ -941,7 +946,7 @@ var ClientTransport = class extends Transport {
     } catch (error) {
       this.inflightConnectionPromises.delete(to);
       const errStr = coerceErrorString(error);
-      if (!this.tryReconnecting || !canProceedWithConnection()) {
+      if (!this.reconnectOnConnectionDrop || !canProceedWithConnection()) {
         log?.warn(`${this.clientId} -- connection to ${to} failed (${errStr})`);
       } else {
         log?.warn(
@@ -952,11 +957,8 @@ var ClientTransport = class extends Transport {
     }
   }
   sendHandshake(to, conn) {
-    const requestMsg = handshakeRequestMessage(
-      this.clientId,
-      to,
-      this.instanceId
-    );
+    const session = this.getOrCreateSession(to, conn);
+    const requestMsg = handshakeRequestMessage(this.clientId, to, session.id);
     log?.debug(`${this.clientId} -- sending handshake request to ${to}`);
     conn.send(this.codec.toBuffer(requestMsg));
   }
@@ -969,7 +971,7 @@ var ServerTransport = class extends Transport {
   constructor(clientId, providedOptions) {
     super(clientId, providedOptions);
     log?.info(
-      `${this.clientId} -- initiated server transport (instance id: ${this.instanceId}, protocol: ${PROTOCOL_VERSION})`
+      `${this.clientId} -- initiated server transport (protocol: ${PROTOCOL_VERSION})`
     );
   }
   handleConnection(conn) {
@@ -981,12 +983,13 @@ var ServerTransport = class extends Transport {
     let session = void 0;
     const client = () => session?.to ?? "unknown";
     const handshakeHandler = (data) => {
-      const handshake = this.receiveHandshakeRequestMessage(data, conn);
-      if (!handshake) {
+      const maybeSession = this.receiveHandshakeRequestMessage(data, conn);
+      if (!maybeSession) {
         conn.close();
         return;
+      } else {
+        session = maybeSession;
       }
-      session = this.onConnect(conn, handshake.from, handshake.instanceId);
       conn.removeDataListener(handshakeHandler);
       conn.addDataListener((data2) => {
         const parsed = this.parseMsg(data2);
@@ -1024,18 +1027,13 @@ var ServerTransport = class extends Transport {
       return false;
     }
     if (!import_value.Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {
-      const responseMsg2 = handshakeResponseMessage(
-        this.clientId,
-        this.instanceId,
-        parsed.from,
-        false
-      );
+      const reason = "received invalid handshake msg";
+      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
+        ok: false,
+        reason
+      });
       conn.send(this.codec.toBuffer(responseMsg2));
-      log?.warn(
-        `${this.clientId} -- received invalid handshake msg: ${JSON.stringify(
-          parsed
-        )}`
-      );
+      log?.warn(`${this.clientId} -- ${reason}: ${JSON.stringify(parsed)}`);
       this.protocolError(
         ProtocolError.HandshakeFailed,
         "invalid handshake request"
@@ -1044,34 +1042,28 @@ var ServerTransport = class extends Transport {
     }
     const gotVersion = parsed.payload.protocolVersion;
     if (gotVersion !== PROTOCOL_VERSION) {
-      const responseMsg2 = handshakeResponseMessage(
-        this.clientId,
-        this.instanceId,
-        parsed.from,
-        false
-      );
+      const reason = `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`;
+      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
+        ok: false,
+        reason
+      });
       conn.send(this.codec.toBuffer(responseMsg2));
       log?.warn(
         `${this.clientId} -- received handshake msg with incompatible protocol version (got: ${gotVersion}, expected: ${PROTOCOL_VERSION})`
       );
-      this.protocolError(
-        ProtocolError.HandshakeFailed,
-        `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`
-      );
+      this.protocolError(ProtocolError.HandshakeFailed, reason);
       return false;
     }
-    const instanceId = parsed.payload.instanceId;
+    const session = this.getOrCreateSession(parsed.from, conn);
     log?.debug(
-      `${this.clientId} -- handshake from ${parsed.from} ok (instance id: ${instanceId}), responding with handshake success`
-    );
-    const responseMsg = handshakeResponseMessage(
-      this.clientId,
-      this.instanceId,
-      parsed.from,
-      true
+      `${this.clientId} -- handshake from ${parsed.from} ok, responding with handshake success`
     );
+    const responseMsg = handshakeResponseMessage(this.clientId, parsed.from, {
+      ok: true,
+      sessionId: session.id
+    });
     conn.send(this.codec.toBuffer(responseMsg));
-    return { instanceId, from: parsed.from };
+    return this.onConnect(conn, parsed.from, parsed.payload.sessionId);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/transport/index.d.cts

@@ -1,3 +1,3 @@
-export { a as ClientTransport, c as ClientTransportOptions, C as Connection, m as EventHandler, E as EventMap, l as EventTypes, O as OpaqueTransportMessage, h as OpaqueTransportMessageSchema, n as ProtocolError, o as ProtocolErrorType, S as ServerTransport, e as Session, T as Transport, b as TransportClientId, i as TransportMessage, g as TransportMessageSchema, d as TransportOptions, f as TransportStatus, k as isStreamClose, j as isStreamOpen } from '../index-2e402bb8.js';
+export { a as ClientTransport, c as ClientTransportOptions, C as Connection, n as EventHandler, E as EventMap, m as EventTypes, O as OpaqueTransportMessage, i as OpaqueTransportMessageSchema, o as ProtocolError, p as ProtocolErrorType, d as ServerTransport, f as Session, T as Transport, b as TransportClientId, j as TransportMessage, h as TransportMessageSchema, e as TransportOptions, g as TransportStatus, l as isStreamClose, k as isStreamOpen } from '../index-8df0bdfb.js';
 import '../types-3e5768ec.js';
 import '@sinclair/typebox';

package/dist/transport/index.d.ts

@@ -1,3 +1,3 @@
-export { a as ClientTransport, c as ClientTransportOptions, C as Connection, m as EventHandler, E as EventMap, l as EventTypes, O as OpaqueTransportMessage, h as OpaqueTransportMessageSchema, n as ProtocolError, o as ProtocolErrorType, S as ServerTransport, e as Session, T as Transport, b as TransportClientId, i as TransportMessage, g as TransportMessageSchema, d as TransportOptions, f as TransportStatus, k as isStreamClose, j as isStreamOpen } from '../index-2e402bb8.js';
+export { a as ClientTransport, c as ClientTransportOptions, C as Connection, n as EventHandler, E as EventMap, m as EventTypes, O as OpaqueTransportMessage, i as OpaqueTransportMessageSchema, o as ProtocolError, p as ProtocolErrorType, d as ServerTransport, f as Session, T as Transport, b as TransportClientId, j as TransportMessage, h as TransportMessageSchema, e as TransportOptions, g as TransportStatus, l as isStreamClose, k as isStreamOpen } from '../index-8df0bdfb.js';
 import '../types-3e5768ec.js';
 import '@sinclair/typebox';

package/dist/transport/index.js

@@ -6,11 +6,11 @@ import {
   ServerTransport,
   Session,
   Transport
-} from "../chunk-7SPCAA6Q.js";
+} from "../chunk-LQMPJI3S.js";
 import {
   OpaqueTransportMessageSchema,
   TransportMessageSchema
-} from "../chunk-GFRAOY75.js";
+} from "../chunk-VH3NGOXQ.js";
 import "../chunk-H4BYJELI.js";
 import "../chunk-GZ7HCLLM.js";
 export {

package/dist/util/testHelpers.cjs

@@ -49,6 +49,9 @@ module.exports = __toCommonJS(testHelpers_exports);
 var import_isomorphic_ws = __toESM(require("isomorphic-ws"), 1);
 var import_ws = require("ws");
 
+// transport/transport.ts
+var import_value = require("@sinclair/typebox/value");
+
 // logging/index.ts
 var log;
 
@@ -72,7 +75,12 @@ var Session = class {
   /**
    * The unique ID of this session.
    */
-  debugId;
+  id;
+  /**
+   * What the other side advertised as their session ID
+   * for this session.
+   */
+  advertisedSessionId;
   /**
    * Number of messages we've sent along this session (excluding handshake and acks)
    */
@@ -94,11 +102,11 @@ var Session = class {
    * The interval for sending heartbeats.
    */
   heartbeat;
-  constructor(from, connectedTo, conn, options) {
+  constructor(conn, from, to, options) {
+    this.id = `session-${nanoid(12)}`;
     this.options = options;
-    this.debugId = `sess-${unsafeId()}`;
     this.from = from;
-    this.to = connectedTo;
+    this.to = to;
     this.connection = conn;
     this.codec = options.codec;
     this.heartbeatMisses = 0;
@@ -138,7 +146,7 @@ var Session = class {
         log?.info(
           `${this.from} -- closing connection (id: ${this.connection.debugId}) to ${this.to} due to inactivity`
         );
-        this.closeStaleConnection(this.connection);
+        this.closeStaleConnection();
       }
       return;
     }
@@ -169,33 +177,37 @@ var Session = class {
       log?.debug(`${this.from} -- resending ${msg.id} (seq: ${msg.seq})`);
       const ok = this.connection.send(this.codec.toBuffer(msg));
       if (!ok) {
-        const msg2 = `${this.from} -- failed to send buffered message to ${this.to} in session (id: ${this.debugId}) (if you hit this code path something is seriously wrong)`;
+        const msg2 = `${this.from} -- failed to send buffered message to ${this.to} in session (id: ${this.id}) (if you hit this code path something is seriously wrong)`;
         log?.error(msg2);
         throw new Error(msg2);
       }
     }
   }
   updateBookkeeping(ack, seq) {
+    if (seq + 1 < this.ack) {
+      log?.error(`${this.from} -- received stale seq ${seq} + 1 < ${this.ack}`);
+      return;
+    }
     this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq > ack);
     this.ack = seq + 1;
   }
   closeStaleConnection(conn) {
-    if (!this.connection || this.connection !== conn)
+    if (this.connection === void 0 || this.connection === conn)
       return;
     log?.info(
-      `${this.from} -- closing old inner connection (id: ${this.connection.debugId}) from session (id: ${this.debugId}) to ${this.to}`
+      `${this.from} -- closing old inner connection (id: ${this.connection.debugId}) from session (id: ${this.id}) to ${this.to}`
     );
     this.connection.close();
     this.connection = void 0;
   }
   replaceWithNewConnection(newConn) {
-    this.closeStaleConnection(this.connection);
+    this.closeStaleConnection(newConn);
     this.cancelGrace();
     this.connection = newConn;
   }
   beginGrace(cb) {
     log?.info(
-      `${this.from} -- starting ${this.options.sessionDisconnectGraceMs}ms grace period until session (id: ${this.debugId}) to ${this.to} is closed`
+      `${this.from} -- starting ${this.options.sessionDisconnectGraceMs}ms grace period until session (id: ${this.id}) to ${this.to} is closed`
     );
     this.disconnectionGrace = setTimeout(() => {
       this.close();
@@ -206,11 +218,12 @@ var Session = class {
   cancelGrace() {
     this.heartbeatMisses = 0;
     clearTimeout(this.disconnectionGrace);
+    this.disconnectionGrace = void 0;
   }
   // closed when we want to discard the whole session
   // (i.e. shutdown or session disconnect)
   close() {
-    this.closeStaleConnection(this.connection);
+    this.closeStaleConnection();
     this.cancelGrace();
     this.resetBufferedMessages();
     clearInterval(this.heartbeat);
@@ -299,6 +312,25 @@ var NaiveJsonCodec = {
   }
 };
 
+// transport/transport.ts
+var defaultTransportOptions = {
+  heartbeatIntervalMs: 1e3,
+  heartbeatsUntilDead: 2,
+  sessionDisconnectGraceMs: 5e3,
+  codec: NaiveJsonCodec
+};
+var defaultConnectionRetryOptions = {
+  baseIntervalMs: 250,
+  maxJitterMs: 200,
+  maxBackoffMs: 32e3,
+  attemptBudgetCapacity: 5,
+  budgetRestoreIntervalMs: 200
+};
+var defaultClientTransportOptions = {
+  ...defaultTransportOptions,
+  ...defaultConnectionRetryOptions
+};
+
 // node_modules/p-defer/index.js
 function pDefer() {
   const deferred = {};
@@ -663,17 +695,12 @@ function catchProcError(err) {
     }
   };
 }
-var testingSessionOptions = {
-  heartbeatIntervalMs: 1e3,
-  heartbeatsUntilDead: 2,
-  sessionDisconnectGraceMs: 5e3,
-  codec: NaiveJsonCodec
-};
+var testingSessionOptions = defaultTransportOptions;
 function dummyCtx(state, extendedContext) {
   const session = new Session(
+    void 0,
     "client",
     "SERVER",
-    void 0,
     testingSessionOptions
   );
   return {