@replit/river 0.25.1 → 0.25.2

package/dist/{chunk-YM5Y4NAT.js → chunk-Q3PZBJXR.js}

@@ -3,7 +3,7 @@ import {
   createSessionTelemetryInfo,
   generateId,
   isAck
-} from "./chunk-SZ5NBBX7.js";
+} from "./chunk-EHD2JJBW.js";
 import {
   NaiveJsonCodec
 } from "./chunk-4PVU7J25.js";
@@ -18,7 +18,7 @@ var defaultTransportOptions = {
   codec: NaiveJsonCodec
 };
 var defaultConnectionRetryOptions = {
-  baseIntervalMs: 250,
+  baseIntervalMs: 150,
   maxJitterMs: 200,
   maxBackoffMs: 32e3,
   attemptBudgetCapacity: 5,
@@ -36,6 +36,7 @@ var defaultServerTransportOptions = {
 import { Value } from "@sinclair/typebox/value";
 var SessionState = /* @__PURE__ */ ((SessionState2) => {
   SessionState2["NoConnection"] = "NoConnection";
+  SessionState2["BackingOff"] = "BackingOff";
   SessionState2["Connecting"] = "Connecting";
   SessionState2["Handshaking"] = "Handshaking";
   SessionState2["Connected"] = "Connected";
@@ -93,7 +94,7 @@ var CommonSession = class extends StateMachineState {
   from;
   options;
   log;
-  constructor(from, options, log) {
+  constructor({ from, options, log }) {
     super();
     this.from = from;
     this.options = options;
@@ -134,8 +135,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;
@@ -190,23 +192,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);
       }
     );
   }
@@ -232,9 +234,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);
@@ -257,16 +259,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);
@@ -303,16 +305,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);
@@ -344,16 +346,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);
@@ -361,13 +360,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`,
@@ -375,12 +374,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(
@@ -389,29 +387,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);
@@ -466,7 +453,6 @@ var SessionConnected = class extends IdentifiedSession {
     });
     if (!this.isActivelyHeartbeating) {
       this.sendHeartbeat();
-      this.waitForNextHeartbeat();
     }
   };
   _handleStateExit() {
@@ -474,10 +460,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();
@@ -485,52 +469,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"]
@@ -542,16 +550,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"]
@@ -559,10 +584,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`,
         {
@@ -572,11 +601,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`,
         {
@@ -586,7 +619,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 ? (
@@ -594,21 +627,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`,
         {
@@ -619,11 +661,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`,
         {
@@ -633,11 +688,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`,
         {
@@ -647,11 +702,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`,
         {
@@ -663,12 +718,39 @@ 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
+  }
+};
 
 export {
   defaultTransportOptions,
   defaultClientTransportOptions,
   defaultServerTransportOptions,
   SessionState,
-  SessionStateGraph
+  SessionStateGraph,
+  ClientSessionStateGraph,
+  ServerSessionStateGraph
 };
-//# sourceMappingURL=chunk-YM5Y4NAT.js.map
+//# sourceMappingURL=chunk-Q3PZBJXR.js.map