@replit/river 0.25.1 → 0.26.0

package/dist/transport/index.d.cts

@@ -1,7 +1,7 @@
-export { b as ClientTransportOptions, C as Connection, j as EventHandler, E as EventMap, i as EventTypes, k as ProtocolError, l as ProtocolErrorType, c as ServerTransportOptions, S as Session, h as SessionConnected, f as SessionConnecting, g as SessionHandshaking, e as SessionNoConnection, d as SessionState, T as Transport, P as TransportOptions, a as TransportStatus } from '../handshake-3772d7ca.js';
-export { C as ClientTransport } from '../client-1321630c.js';
-export { S as ServerTransport, a as SessionWaitingForHandshake } from '../server-f0fd2b98.js';
-export { b as OpaqueTransportMessage, O as OpaqueTransportMessageSchema, c as TransportClientId, a as TransportMessage, T as TransportMessageSchema, d as isStreamClose, i as isStreamOpen } from '../message-e6c560fd.js';
+export { b as ClientTransportOptions, C as Connection, j as EventHandler, E as EventMap, i as EventTypes, k as ProtocolError, l as ProtocolErrorType, c as ServerTransportOptions, S as Session, h as SessionConnected, f as SessionConnecting, g as SessionHandshaking, e as SessionNoConnection, d as SessionState, T as Transport, P as TransportOptions, a as TransportStatus } from '../handshake-3342bb94.js';
+export { C as ClientTransport } from '../client-162c509c.js';
+export { S as ServerTransport, a as SessionWaitingForHandshake } from '../server-1b695374.js';
+export { b as OpaqueTransportMessage, O as OpaqueTransportMessageSchema, c as TransportClientId, a as TransportMessage, T as TransportMessageSchema, d as isStreamClose, i as isStreamOpen } from '../message-1a434848.js';
 import '@sinclair/typebox';
 import '../types-3e5768ec.js';
 import '@sinclair/typebox/value';

package/dist/transport/index.d.ts

@@ -1,7 +1,7 @@
-export { b as ClientTransportOptions, C as Connection, j as EventHandler, E as EventMap, i as EventTypes, k as ProtocolError, l as ProtocolErrorType, c as ServerTransportOptions, S as Session, h as SessionConnected, f as SessionConnecting, g as SessionHandshaking, e as SessionNoConnection, d as SessionState, T as Transport, P as TransportOptions, a as TransportStatus } from '../handshake-3772d7ca.js';
-export { C as ClientTransport } from '../client-1321630c.js';
-export { S as ServerTransport, a as SessionWaitingForHandshake } from '../server-f0fd2b98.js';
-export { b as OpaqueTransportMessage, O as OpaqueTransportMessageSchema, c as TransportClientId, a as TransportMessage, T as TransportMessageSchema, d as isStreamClose, i as isStreamOpen } from '../message-e6c560fd.js';
+export { b as ClientTransportOptions, C as Connection, j as EventHandler, E as EventMap, i as EventTypes, k as ProtocolError, l as ProtocolErrorType, c as ServerTransportOptions, S as Session, h as SessionConnected, f as SessionConnecting, g as SessionHandshaking, e as SessionNoConnection, d as SessionState, T as Transport, P as TransportOptions, a as TransportStatus } from '../handshake-3342bb94.js';
+export { C as ClientTransport } from '../client-162c509c.js';
+export { S as ServerTransport, a as SessionWaitingForHandshake } from '../server-1b695374.js';
+export { b as OpaqueTransportMessage, O as OpaqueTransportMessageSchema, c as TransportClientId, a as TransportMessage, T as TransportMessageSchema, d as isStreamClose, i as isStreamOpen } from '../message-1a434848.js';
 import '@sinclair/typebox';
 import '../types-3e5768ec.js';
 import '@sinclair/typebox/value';

package/dist/transport/index.js

@@ -1,22 +1,22 @@
 import {
   ClientTransport
-} from "../chunk-5CNNIOAO.js";
+} from "../chunk-5S64PXTU.js";
 import {
   ServerTransport
-} from "../chunk-PCBPPTXH.js";
+} from "../chunk-7ETNUCOL.js";
 import {
   Connection,
   ProtocolError,
   Transport
-} from "../chunk-D5O3ERJU.js";
+} from "../chunk-5FDAIAQ5.js";
 import "../chunk-TAH2GVTJ.js";
 import {
   SessionState
-} from "../chunk-YM5Y4NAT.js";
+} from "../chunk-JSU2KACV.js";
 import {
   OpaqueTransportMessageSchema,
   TransportMessageSchema
-} from "../chunk-SZ5NBBX7.js";
+} from "../chunk-CCUYKR5C.js";
 import "../chunk-4PVU7J25.js";
 export {
   ClientTransport,

package/dist/util/testHelpers.cjs

@@ -44,6 +44,7 @@ __export(testHelpers_exports, {
   numberOfConnections: () => numberOfConnections,
   onWsServerReady: () => onWsServerReady,
   payloadToTransportMessage: () => payloadToTransportMessage,
+  testingClientSessionOptions: () => testingClientSessionOptions,
   testingSessionOptions: () => testingSessionOptions,
   waitForMessage: () => waitForMessage
 });
@@ -389,11 +390,20 @@ var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
 var HandshakeErrorRetriableResponseCodes = import_typebox.Type.Union([
   import_typebox.Type.Literal("SESSION_STATE_MISMATCH")
 ]);
+var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox.Type.Union([
+  // The custom validation handler rejected the handler because the client is unsupported.
+  import_typebox.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
+  // The custom validation handler rejected the handshake.
+  import_typebox.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
+]);
 var HandshakeErrorFatalResponseCodes = import_typebox.Type.Union([
+  HandshakeErrorCustomHandlerFatalResponseCodes,
+  // The ciient sent a handshake that doesn't comply with the extended handshake metadata.
   import_typebox.Type.Literal("MALFORMED_HANDSHAKE_META"),
+  // The ciient sent a handshake that doesn't comply with ControlMessageHandshakeRequestSchema.
   import_typebox.Type.Literal("MALFORMED_HANDSHAKE"),
-  import_typebox.Type.Literal("PROTOCOL_VERSION_MISMATCH"),
-  import_typebox.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
+  // The client's protocol version does not match the server's.
+  import_typebox.Type.Literal("PROTOCOL_VERSION_MISMATCH")
 ]);
 var HandshakeErrorResponseCodes = import_typebox.Type.Union([
   HandshakeErrorRetriableResponseCodes,
@@ -450,7 +460,7 @@ function Err(error) {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.25.1";
+var version = "0.26.0";
 
 // tracing/index.ts
 function createSessionTelemetryInfo(sessionId, to, from, propagationCtx) {
@@ -542,7 +552,7 @@ var defaultTransportOptions = {
   codec: NaiveJsonCodec
 };
 var defaultConnectionRetryOptions = {
-  baseIntervalMs: 250,
+  baseIntervalMs: 150,
   maxJitterMs: 200,
   maxBackoffMs: 32e3,
   attemptBudgetCapacity: 5,
@@ -609,7 +619,7 @@ var CommonSession = class extends StateMachineState {
   from;
   options;
   log;
-  constructor(from, options, log) {
+  constructor({ from, options, log }) {
     super();
     this.from = from;
     this.options = options;
@@ -650,8 +660,9 @@ var IdentifiedSession = class extends CommonSession {
    */
   ack;
   sendBuffer;
-  constructor(id, from, to, seq, ack, sendBuffer, telemetry, options, log) {
-    super(from, options, log);
+  constructor(props) {
+    const { id, to, seq, ack, sendBuffer, telemetry, log } = props;
+    super(props);
     this.id = id;
     this.to = to;
     this.seq = seq;
@@ -706,23 +717,23 @@ var SessionConnecting = class extends IdentifiedSession {
   connPromise;
   listeners;
   connectionTimeout;
-  constructor(connPromise, listeners, ...args) {
-    super(...args);
-    this.connPromise = connPromise;
-    this.listeners = listeners;
+  constructor(props) {
+    super(props);
+    this.connPromise = props.connPromise;
+    this.listeners = props.listeners;
     this.connectionTimeout = setTimeout(() => {
-      listeners.onConnectionTimeout();
+      this.listeners.onConnectionTimeout();
     }, this.options.connectionTimeoutMs);
-    connPromise.then(
+    this.connPromise.then(
       (conn) => {
         if (this._isConsumed)
           return;
-        listeners.onConnectionEstablished(conn);
+        this.listeners.onConnectionEstablished(conn);
       },
       (err) => {
         if (this._isConsumed)
           return;
-        listeners.onConnectionFailed(err);
+        this.listeners.onConnectionFailed(err);
       }
     );
   }
@@ -748,9 +759,9 @@ var SessionNoConnection = class extends IdentifiedSession {
   state = "NoConnection" /* NoConnection */;
   listeners;
   gracePeriodTimeout;
-  constructor(listeners, ...args) {
-    super(...args);
-    this.listeners = listeners;
+  constructor(props) {
+    super(props);
+    this.listeners = props.listeners;
     this.gracePeriodTimeout = setTimeout(() => {
       this.listeners.onSessionGracePeriodElapsed();
     }, this.options.sessionDisconnectGraceMs);
@@ -773,16 +784,16 @@ var SessionWaitingForHandshake = class extends CommonSession {
   conn;
   listeners;
   handshakeTimeout;
-  constructor(conn, listeners, ...args) {
-    super(...args);
-    this.conn = conn;
-    this.listeners = listeners;
+  constructor(props) {
+    super(props);
+    this.conn = props.conn;
+    this.listeners = props.listeners;
     this.handshakeTimeout = setTimeout(() => {
-      listeners.onHandshakeTimeout();
+      this.listeners.onHandshakeTimeout();
     }, this.options.handshakeTimeoutMs);
     this.conn.addDataListener(this.onHandshakeData);
-    this.conn.addErrorListener(listeners.onConnectionErrored);
-    this.conn.addCloseListener(listeners.onConnectionClosed);
+    this.conn.addErrorListener(this.listeners.onConnectionErrored);
+    this.conn.addCloseListener(this.listeners.onConnectionClosed);
   }
   onHandshakeData = (msg) => {
     const parsedMsg = this.parseMsg(msg);
@@ -819,16 +830,16 @@ var SessionHandshaking = class extends IdentifiedSession {
   conn;
   listeners;
   handshakeTimeout;
-  constructor(conn, listeners, ...args) {
-    super(...args);
-    this.conn = conn;
-    this.listeners = listeners;
+  constructor(props) {
+    super(props);
+    this.conn = props.conn;
+    this.listeners = props.listeners;
     this.handshakeTimeout = setTimeout(() => {
-      listeners.onHandshakeTimeout();
+      this.listeners.onHandshakeTimeout();
     }, this.options.handshakeTimeoutMs);
     this.conn.addDataListener(this.onHandshakeData);
-    this.conn.addErrorListener(listeners.onConnectionErrored);
-    this.conn.addCloseListener(listeners.onConnectionClosed);
+    this.conn.addErrorListener(this.listeners.onConnectionErrored);
+    this.conn.addCloseListener(this.listeners.onConnectionClosed);
   }
   onHandshakeData = (msg) => {
     const parsedMsg = this.parseMsg(msg);
@@ -860,16 +871,13 @@ var SessionConnected = class extends IdentifiedSession {
   state = "Connected" /* Connected */;
   conn;
   listeners;
-  activeHeartbeatHandle;
-  activeHeartbeatMisses = 0;
-  passiveHeartbeatHandle;
-  get isActivelyHeartbeating() {
-    return this.activeHeartbeatHandle !== void 0;
-  }
+  heartbeatHandle;
+  heartbeatMisses = 0;
+  isActivelyHeartbeating;
   updateBookkeeping(ack, seq) {
     this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq >= ack);
     this.ack = seq + 1;
-    this.activeHeartbeatMisses = 0;
+    this.heartbeatMisses = 0;
   }
   send(msg) {
     const constructedMsg = this.constructMsg(msg);
@@ -877,13 +885,13 @@ var SessionConnected = class extends IdentifiedSession {
     this.conn.send(this.options.codec.toBuffer(constructedMsg));
     return constructedMsg.id;
   }
-  constructor(conn, listeners, ...args) {
-    super(...args);
-    this.conn = conn;
-    this.listeners = listeners;
+  constructor(props) {
+    super(props);
+    this.conn = props.conn;
+    this.listeners = props.listeners;
     this.conn.addDataListener(this.onMessageData);
-    this.conn.addCloseListener(listeners.onConnectionClosed);
-    this.conn.addErrorListener(listeners.onConnectionErrored);
+    this.conn.addCloseListener(this.listeners.onConnectionClosed);
+    this.conn.addErrorListener(this.listeners.onConnectionErrored);
     if (this.sendBuffer.length > 0) {
       this.log?.debug(
         `sending ${this.sendBuffer.length} buffered messages`,
@@ -891,12 +899,11 @@ var SessionConnected = class extends IdentifiedSession {
       );
     }
     for (const msg of this.sendBuffer) {
-      conn.send(this.options.codec.toBuffer(msg));
+      this.conn.send(this.options.codec.toBuffer(msg));
     }
-  }
-  startActiveHeartbeat() {
-    this.activeHeartbeatHandle = setInterval(() => {
-      const misses = this.activeHeartbeatMisses;
+    this.isActivelyHeartbeating = false;
+    this.heartbeatHandle = setInterval(() => {
+      const misses = this.heartbeatMisses;
       const missDuration = misses * this.options.heartbeatIntervalMs;
       if (misses >= this.options.heartbeatsUntilDead) {
         this.log?.info(
@@ -905,29 +912,18 @@ var SessionConnected = class extends IdentifiedSession {
         );
         this.telemetry.span.addEvent("closing connection due to inactivity");
         this.conn.close();
-        clearInterval(this.activeHeartbeatHandle);
-        this.activeHeartbeatHandle = void 0;
+        clearInterval(this.heartbeatHandle);
+        this.heartbeatHandle = void 0;
         return;
       }
-      this.sendHeartbeat();
-      this.activeHeartbeatMisses++;
+      if (this.isActivelyHeartbeating) {
+        this.sendHeartbeat();
+      }
+      this.heartbeatMisses++;
     }, this.options.heartbeatIntervalMs);
   }
-  waitForNextHeartbeat() {
-    const duration = this.options.heartbeatsUntilDead * this.options.heartbeatIntervalMs;
-    if (this.passiveHeartbeatHandle) {
-      clearTimeout(this.passiveHeartbeatHandle);
-      this.passiveHeartbeatHandle = void 0;
-    }
-    this.passiveHeartbeatHandle = setTimeout(() => {
-      this.log?.info(
-        `closing connection to ${this.to} due to not receiving a heartbeat in the last ${duration}ms`,
-        this.loggingMetadata
-      );
-      this.telemetry.span.addEvent("closing connection due to inactivity");
-      this.conn.close();
-      this.passiveHeartbeatHandle = void 0;
-    }, duration);
+  startActiveHeartbeat() {
+    this.isActivelyHeartbeating = true;
   }
   sendHeartbeat() {
     this.log?.debug("sending heartbeat", this.loggingMetadata);
@@ -982,7 +978,6 @@ var SessionConnected = class extends IdentifiedSession {
     });
     if (!this.isActivelyHeartbeating) {
       this.sendHeartbeat();
-      this.waitForNextHeartbeat();
     }
   };
   _handleStateExit() {
@@ -990,10 +985,8 @@ var SessionConnected = class extends IdentifiedSession {
     this.conn.removeDataListener(this.onMessageData);
     this.conn.removeCloseListener(this.listeners.onConnectionClosed);
     this.conn.removeErrorListener(this.listeners.onConnectionErrored);
-    clearInterval(this.activeHeartbeatHandle);
-    clearTimeout(this.passiveHeartbeatHandle);
-    this.activeHeartbeatHandle = void 0;
-    this.passiveHeartbeatHandle = void 0;
+    clearInterval(this.heartbeatHandle);
+    this.heartbeatHandle = void 0;
   }
   _handleClose() {
     super._handleClose();
@@ -1001,52 +994,76 @@ var SessionConnected = class extends IdentifiedSession {
   }
 };
 
+// transport/sessionStateMachine/SessionBackingOff.ts
+var SessionBackingOff = class extends IdentifiedSession {
+  state = "BackingOff" /* BackingOff */;
+  listeners;
+  backoffTimeout;
+  constructor(props) {
+    super(props);
+    this.listeners = props.listeners;
+    this.backoffTimeout = setTimeout(() => {
+      this.listeners.onBackoffFinished();
+    }, props.backoffMs);
+  }
+  _handleClose() {
+    super._handleClose();
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+    if (this.backoffTimeout) {
+      clearTimeout(this.backoffTimeout);
+      this.backoffTimeout = void 0;
+    }
+  }
+};
+
 // transport/sessionStateMachine/transitions.ts
 function inheritSharedSession(session) {
-  return [
-    session.id,
-    session.from,
-    session.to,
-    session.seq,
-    session.ack,
-    session.sendBuffer,
-    session.telemetry,
-    session.options,
-    session.log
-  ];
+  return {
+    id: session.id,
+    from: session.from,
+    to: session.to,
+    seq: session.seq,
+    ack: session.ack,
+    sendBuffer: session.sendBuffer,
+    telemetry: session.telemetry,
+    options: session.options,
+    log: session.log
+  };
 }
 var SessionStateGraph = {
   entrypoints: {
-    NoConnection(to, from, listeners, options, log) {
+    NoConnection: (to, from, listeners, options, log) => {
       const id = `session-${generateId()}`;
       const telemetry = createSessionTelemetryInfo(id, to, from);
       const sendBuffer = [];
-      const session = new SessionNoConnection(
+      const session = new SessionNoConnection({
         listeners,
         id,
         from,
         to,
-        0,
-        0,
+        seq: 0,
+        ack: 0,
         sendBuffer,
         telemetry,
         options,
         log
-      );
+      });
       session.log?.info(`session ${session.id} created in NoConnection state`, {
         ...session.loggingMetadata,
         tags: ["state-transition"]
       });
       return session;
     },
-    WaitingForHandshake(from, conn, listeners, options, log) {
-      const session = new SessionWaitingForHandshake(
+    WaitingForHandshake: (from, conn, listeners, options, log) => {
+      const session = new SessionWaitingForHandshake({
         conn,
         listeners,
         from,
         options,
         log
-      );
+      });
       session.log?.info(`session created in WaitingForHandshake state`, {
         ...session.loggingMetadata,
         tags: ["state-transition"]
@@ -1058,16 +1075,33 @@ var SessionStateGraph = {
   // After a session is transitioned, any usage of the old session will throw.
   transition: {
     // happy path transitions
-    NoConnectionToConnecting(oldSession, connPromise, listeners) {
+    NoConnectionToBackingOff: (oldSession, backoffMs, listeners) => {
       const carriedState = inheritSharedSession(oldSession);
       oldSession._handleStateExit();
-      const session = new SessionConnecting(
-        connPromise,
+      const session = new SessionBackingOff({
+        backoffMs,
         listeners,
         ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from NoConnection to BackingOff`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
       );
+      return session;
+    },
+    BackingOffToConnecting: (oldSession, connPromise, listeners) => {
+      const carriedState = inheritSharedSession(oldSession);
+      oldSession._handleStateExit();
+      const session = new SessionConnecting({
+        connPromise,
+        listeners,
+        ...carriedState
+      });
       session.log?.info(
-        `session ${session.id} transition from NoConnection to Connecting`,
+        `session ${session.id} transition from BackingOff to Connecting`,
         {
           ...session.loggingMetadata,
           tags: ["state-transition"]
@@ -1075,10 +1109,14 @@ var SessionStateGraph = {
       );
       return session;
     },
-    ConnectingToHandshaking(oldSession, conn, listeners) {
+    ConnectingToHandshaking: (oldSession, conn, listeners) => {
       const carriedState = inheritSharedSession(oldSession);
       oldSession._handleStateExit();
-      const session = new SessionHandshaking(conn, listeners, ...carriedState);
+      const session = new SessionHandshaking({
+        conn,
+        listeners,
+        ...carriedState
+      });
       session.log?.info(
         `session ${session.id} transition from Connecting to Handshaking`,
         {
@@ -1088,11 +1126,15 @@ var SessionStateGraph = {
       );
       return session;
     },
-    HandshakingToConnected(oldSession, listeners) {
+    HandshakingToConnected: (oldSession, listeners) => {
       const carriedState = inheritSharedSession(oldSession);
       const conn = oldSession.conn;
       oldSession._handleStateExit();
-      const session = new SessionConnected(conn, listeners, ...carriedState);
+      const session = new SessionConnected({
+        conn,
+        listeners,
+        ...carriedState
+      });
       session.log?.info(
         `session ${session.id} transition from Handshaking to Connected`,
         {
@@ -1102,7 +1144,7 @@ var SessionStateGraph = {
       );
       return session;
     },
-    WaitingForHandshakeToConnected(pendingSession, oldSession, sessionId, to, propagationCtx, listeners) {
+    WaitingForHandshakeToConnected: (pendingSession, oldSession, sessionId, to, propagationCtx, listeners) => {
       const conn = pendingSession.conn;
       const { from, options } = pendingSession;
       const carriedState = oldSession ? (
@@ -1110,21 +1152,30 @@ var SessionStateGraph = {
         inheritSharedSession(oldSession)
       ) : (
         // old session does not exist, create new state
-        [
-          sessionId,
+        {
+          id: sessionId,
           from,
           to,
-          0,
-          0,
-          [],
-          createSessionTelemetryInfo(sessionId, to, from, propagationCtx),
+          seq: 0,
+          ack: 0,
+          sendBuffer: [],
+          telemetry: createSessionTelemetryInfo(
+            sessionId,
+            to,
+            from,
+            propagationCtx
+          ),
           options,
-          pendingSession.log
-        ]
+          log: pendingSession.log
+        }
       );
       pendingSession._handleStateExit();
       oldSession?._handleStateExit();
-      const session = new SessionConnected(conn, listeners, ...carriedState);
+      const session = new SessionConnected({
+        conn,
+        listeners,
+        ...carriedState
+      });
       session.log?.info(
         `session ${session.id} transition from WaitingForHandshake to Connected`,
         {
@@ -1135,11 +1186,24 @@ var SessionStateGraph = {
       return session;
     },
     // disconnect paths
-    ConnectingToNoConnection(oldSession, listeners) {
+    BackingOffToNoConnection: (oldSession, listeners) => {
+      const carriedState = inheritSharedSession(oldSession);
+      oldSession._handleStateExit();
+      const session = new SessionNoConnection({ listeners, ...carriedState });
+      session.log?.info(
+        `session ${session.id} transition from BackingOff to NoConnection`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    ConnectingToNoConnection: (oldSession, listeners) => {
       const carriedState = inheritSharedSession(oldSession);
       oldSession.bestEffortClose();
       oldSession._handleStateExit();
-      const session = new SessionNoConnection(listeners, ...carriedState);
+      const session = new SessionNoConnection({ listeners, ...carriedState });
       session.log?.info(
         `session ${session.id} transition from Connecting to NoConnection`,
         {
@@ -1149,11 +1213,11 @@ var SessionStateGraph = {
       );
       return session;
     },
-    HandshakingToNoConnection(oldSession, listeners) {
+    HandshakingToNoConnection: (oldSession, listeners) => {
       const carriedState = inheritSharedSession(oldSession);
       oldSession.conn.close();
       oldSession._handleStateExit();
-      const session = new SessionNoConnection(listeners, ...carriedState);
+      const session = new SessionNoConnection({ listeners, ...carriedState });
       session.log?.info(
         `session ${session.id} transition from Handshaking to NoConnection`,
         {
@@ -1163,11 +1227,11 @@ var SessionStateGraph = {
       );
       return session;
     },
-    ConnectedToNoConnection(oldSession, listeners) {
+    ConnectedToNoConnection: (oldSession, listeners) => {
       const carriedState = inheritSharedSession(oldSession);
       oldSession.conn.close();
       oldSession._handleStateExit();
-      const session = new SessionNoConnection(listeners, ...carriedState);
+      const session = new SessionNoConnection({ listeners, ...carriedState });
       session.log?.info(
         `session ${session.id} transition from Connected to NoConnection`,
         {
@@ -1179,6 +1243,31 @@ var SessionStateGraph = {
     }
   }
 };
+var transitions = SessionStateGraph.transition;
+var ClientSessionStateGraph = {
+  entrypoint: SessionStateGraph.entrypoints.NoConnection,
+  transition: {
+    // happy paths
+    NoConnectionToBackingOff: transitions.NoConnectionToBackingOff,
+    BackingOffToConnecting: transitions.BackingOffToConnecting,
+    ConnectingToHandshaking: transitions.ConnectingToHandshaking,
+    HandshakingToConnected: transitions.HandshakingToConnected,
+    // disconnect paths
+    BackingOffToNoConnection: transitions.BackingOffToNoConnection,
+    ConnectingToNoConnection: transitions.ConnectingToNoConnection,
+    HandshakingToNoConnection: transitions.HandshakingToNoConnection,
+    ConnectedToNoConnection: transitions.ConnectedToNoConnection
+  }
+};
+var ServerSessionStateGraph = {
+  entrypoint: SessionStateGraph.entrypoints.WaitingForHandshake,
+  transition: {
+    // happy paths
+    WaitingForHandshakeToConnected: transitions.WaitingForHandshakeToConnected,
+    // disconnect paths
+    ConnectedToNoConnection: transitions.ConnectedToNoConnection
+  }
+};
 
 // util/testHelpers.ts
 function createLocalWebSocketClient(port) {
@@ -1239,6 +1328,7 @@ function catchProcError(err) {
   return Err({ code: UNCAUGHT_ERROR, message: errorMsg });
 }
 var testingSessionOptions = defaultTransportOptions;
+var testingClientSessionOptions = defaultClientTransportOptions;
 function dummySession() {
   return SessionStateGraph.entrypoints.NoConnection(
     "client",
@@ -1338,6 +1428,7 @@ function closeAllConnections(transport) {
   numberOfConnections,
   onWsServerReady,
   payloadToTransportMessage,
+  testingClientSessionOptions,
   testingSessionOptions,
   waitForMessage
 });