@replit/river 0.207.2 → 0.207.3

package/dist/transport/impls/ws/server.cjs

@@ -153,11 +153,12 @@ var WebSocketConnection = class extends Connection {
     };
   }
   send(payload) {
-    if (this.ws.readyState !== this.ws.OPEN) {
+    try {
+      this.ws.send(payload);
+      return true;
+    } catch {
       return false;
     }
-    this.ws.send(payload);
-    return true;
   }
   close() {
     this.ws.close(WS_HEALTHY_CLOSE_CODE);
@@ -314,23 +315,20 @@ var NaiveJsonCodec = {
     );
   },
   fromBuffer: (buff) => {
-    try {
-      const parsed = JSON.parse(
-        decoder.decode(buff),
-        function reviver(_key, val) {
-          if (val?.$t) {
-            return base64ToUint8Array(val.$t);
-          } else {
-            return val;
-          }
+    const parsed = JSON.parse(
+      decoder.decode(buff),
+      function reviver(_key, val) {
+        if (val?.$t) {
+          return base64ToUint8Array(val.$t);
+        } else {
+          return val;
         }
-      );
-      if (typeof parsed === "object")
-        return parsed;
-      return null;
-    } catch {
-      return null;
+      }
+    );
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new Error("unpacked msg is not an object");
     }
+    return parsed;
   }
 };
 
@@ -427,7 +425,8 @@ var ProtocolError = {
   RetriesExceeded: "conn_retry_exceeded",
   HandshakeFailed: "handshake_failed",
   MessageOrderingViolated: "message_ordering_violated",
-  InvalidMessage: "invalid_message"
+  InvalidMessage: "invalid_message",
+  MessageSendFailure: "message_send_failure"
 };
 var EventDispatcher = class {
   eventListeners = {};
@@ -461,7 +460,6 @@ var EventDispatcher = class {
 };
 
 // transport/sessionStateMachine/common.ts
-var import_value = require("@sinclair/typebox/value");
 var ERR_CONSUMED = `session state has been consumed and is no longer valid`;
 var StateMachineState = class {
   /*
@@ -521,34 +519,16 @@ var StateMachineState = class {
 var CommonSession = class extends StateMachineState {
   from;
   options;
+  codec;
   tracer;
   log;
-  constructor({ from, options, log, tracer }) {
+  constructor({ from, options, log, tracer, codec }) {
     super();
     this.from = from;
     this.options = options;
     this.log = log;
     this.tracer = tracer;
-  }
-  parseMsg(msg) {
-    const parsedMsg = this.options.codec.fromBuffer(msg);
-    if (parsedMsg === null) {
-      this.log?.error(
-        `received malformed msg: ${Buffer.from(msg).toString("base64")}`,
-        this.loggingMetadata
-      );
-      return null;
-    }
-    if (!import_value.Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
-      this.log?.error(`received invalid msg: ${JSON.stringify(parsedMsg)}`, {
-        ...this.loggingMetadata,
-        validationErrors: [
-          ...import_value.Value.Errors(OpaqueTransportMessageSchema, parsedMsg)
-        ]
-      });
-      return null;
-    }
-    return parsedMsg;
+    this.codec = codec;
   }
 };
 var IdentifiedSession = class extends CommonSession {
@@ -608,9 +588,6 @@ var IdentifiedSession = class extends CommonSession {
     return metadata;
   }
   constructMsg(partialMsg) {
-    if (this._isConsumed) {
-      throw new Error(ERR_CONSUMED);
-    }
     const msg = {
       ...partialMsg,
       id: generateId(),
@@ -628,7 +605,10 @@ var IdentifiedSession = class extends CommonSession {
   send(msg) {
     const constructedMsg = this.constructMsg(msg);
     this.sendBuffer.push(constructedMsg);
-    return constructedMsg.id;
+    return {
+      ok: true,
+      value: constructedMsg.id
+    };
   }
   _handleStateExit() {
   }
@@ -660,6 +640,23 @@ var IdentifiedSessionWithGracePeriod = class extends IdentifiedSession {
     super._handleClose();
   }
 };
+function sendMessage(conn, codec, msg) {
+  const buff = codec.toBuffer(msg);
+  if (!buff.ok) {
+    return buff;
+  }
+  const sent = conn.send(buff.value);
+  if (!sent) {
+    return {
+      ok: false,
+      reason: "failed to send message"
+    };
+  }
+  return {
+    ok: true,
+    value: msg.id
+  };
+}
 
 // transport/sessionStateMachine/SessionConnecting.ts
 var SessionConnecting = class extends IdentifiedSessionWithGracePeriod {
@@ -712,8 +709,8 @@ var SessionConnecting = class extends IdentifiedSessionWithGracePeriod {
     }
   }
   _handleClose() {
-    this.bestEffortClose();
     super._handleClose();
+    this.bestEffortClose();
   }
 };
 
@@ -740,7 +737,7 @@ function coerceErrorString(err) {
 }
 
 // package.json
-var version = "0.207.2";
+var version = "0.207.3";
 
 // tracing/index.ts
 function createSessionTelemetryInfo(tracer, sessionId, to, from, propagationCtx) {
@@ -804,18 +801,18 @@ var SessionWaitingForHandshake = class extends CommonSession {
     };
   }
   onHandshakeData = (msg) => {
-    const parsedMsg = this.parseMsg(msg);
-    if (parsedMsg === null) {
+    const parsedMsgRes = this.codec.fromBuffer(msg);
+    if (!parsedMsgRes.ok) {
       this.listeners.onInvalidHandshake(
-        "could not parse message",
+        `could not parse handshake message: ${parsedMsgRes.reason}`,
         "MALFORMED_HANDSHAKE"
       );
       return;
     }
-    this.listeners.onHandshake(parsedMsg);
+    this.listeners.onHandshake(parsedMsgRes.value);
   };
   sendHandshake(msg) {
-    return this.conn.send(this.options.codec.toBuffer(msg));
+    return sendMessage(this.conn, this.codec, msg);
   }
   _handleStateExit() {
     this.conn.removeDataListener(this.onHandshakeData);
@@ -853,18 +850,18 @@ var SessionHandshaking = class extends IdentifiedSessionWithGracePeriod {
     };
   }
   onHandshakeData = (msg) => {
-    const parsedMsg = this.parseMsg(msg);
-    if (parsedMsg === null) {
+    const parsedMsgRes = this.codec.fromBuffer(msg);
+    if (!parsedMsgRes.ok) {
       this.listeners.onInvalidHandshake(
-        "could not parse message",
+        `could not parse handshake message: ${parsedMsgRes.reason}`,
         "MALFORMED_HANDSHAKE"
       );
       return;
     }
-    this.listeners.onHandshake(parsedMsg);
+    this.listeners.onHandshake(parsedMsgRes.value);
   };
   sendHandshake(msg) {
-    return this.conn.send(this.options.codec.toBuffer(msg));
+    return sendMessage(this.conn, this.codec, msg);
   }
   _handleStateExit() {
     super._handleStateExit();
@@ -889,25 +886,15 @@ var SessionConnected = class extends IdentifiedSession {
   conn;
   listeners;
   heartbeatHandle;
-  heartbeatMisses = 0;
-  isActivelyHeartbeating;
-  lastConstructedMsgs = [];
-  pushLastConstructedMsgs = (msg) => {
-    const trackedMsg = {
-      id: msg.id,
-      seq: msg.seq,
-      streamId: msg.streamId,
-      stack: new Error().stack
-    };
-    this.lastConstructedMsgs.push(trackedMsg);
-    if (this.lastConstructedMsgs.length > 10) {
-      this.lastConstructedMsgs.shift();
-    }
-  };
+  heartbeatMissTimeout;
+  isActivelyHeartbeating = false;
   updateBookkeeping(ack, seq) {
     this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq >= ack);
     this.ack = seq + 1;
-    this.heartbeatMisses = 0;
+    if (this.heartbeatMissTimeout) {
+      clearTimeout(this.heartbeatMissTimeout);
+    }
+    this.startMissingHeartbeatTimeout();
   }
   assertSendOrdering(constructedMsg) {
     if (constructedMsg.seq > this.seqSent + 1) {
@@ -915,22 +902,22 @@ var SessionConnected = class extends IdentifiedSession {
       this.log?.error(msg, {
         ...this.loggingMetadata,
         transportMessage: constructedMsg,
-        tags: ["invariant-violation"],
-        extras: {
-          lastConstructedMsgs: this.lastConstructedMsgs
-        }
+        tags: ["invariant-violation"]
       });
       throw new Error(msg);
     }
   }
   send(msg) {
     const constructedMsg = this.constructMsg(msg);
-    this.pushLastConstructedMsgs(constructedMsg);
     this.assertSendOrdering(constructedMsg);
     this.sendBuffer.push(constructedMsg);
-    this.conn.send(this.options.codec.toBuffer(constructedMsg));
+    const res = sendMessage(this.conn, this.codec, constructedMsg);
+    if (!res.ok) {
+      this.listeners.onMessageSendFailure(constructedMsg, res.reason);
+      return res;
+    }
     this.seqSent = constructedMsg.seq;
-    return constructedMsg.id;
+    return res;
   }
   constructor(props) {
     super(props);
@@ -939,6 +926,8 @@ var SessionConnected = class extends IdentifiedSession {
     this.conn.addDataListener(this.onMessageData);
     this.conn.addCloseListener(this.listeners.onConnectionClosed);
     this.conn.addErrorListener(this.listeners.onConnectionErrored);
+  }
+  sendBufferedMessages() {
     if (this.sendBuffer.length > 0) {
       this.log?.info(
         `sending ${this.sendBuffer.length} buffered messages, starting at seq ${this.nextSeq()}`,
@@ -946,30 +935,15 @@ var SessionConnected = class extends IdentifiedSession {
       );
       for (const msg of this.sendBuffer) {
         this.assertSendOrdering(msg);
-        this.conn.send(this.options.codec.toBuffer(msg));
+        const res = sendMessage(this.conn, this.codec, msg);
+        if (!res.ok) {
+          this.listeners.onMessageSendFailure(msg, res.reason);
+          return res;
+        }
         this.seqSent = msg.seq;
       }
     }
-    this.isActivelyHeartbeating = false;
-    this.heartbeatHandle = setInterval(() => {
-      const misses = this.heartbeatMisses;
-      const missDuration = misses * this.options.heartbeatIntervalMs;
-      if (misses >= this.options.heartbeatsUntilDead) {
-        this.log?.info(
-          `closing connection to ${this.to} due to inactivity (missed ${misses} heartbeats which is ${missDuration}ms)`,
-          this.loggingMetadata
-        );
-        this.telemetry.span.addEvent("closing connection due to inactivity");
-        this.conn.close();
-        clearInterval(this.heartbeatHandle);
-        this.heartbeatHandle = void 0;
-        return;
-      }
-      if (this.isActivelyHeartbeating) {
-        this.sendHeartbeat();
-      }
-      this.heartbeatMisses++;
-    }, this.options.heartbeatIntervalMs);
+    return { ok: true, value: void 0 };
   }
   get loggingMetadata() {
     return {
@@ -977,25 +951,46 @@ var SessionConnected = class extends IdentifiedSession {
       ...this.conn.loggingMetadata
     };
   }
+  startMissingHeartbeatTimeout() {
+    const maxMisses = this.options.heartbeatsUntilDead;
+    const missDuration = maxMisses * this.options.heartbeatIntervalMs;
+    this.heartbeatMissTimeout = setTimeout(() => {
+      this.log?.info(
+        `closing connection to ${this.to} due to inactivity (missed ${maxMisses} heartbeats which is ${missDuration}ms)`,
+        this.loggingMetadata
+      );
+      this.telemetry.span.addEvent(
+        "closing connection due to missing heartbeat"
+      );
+      this.conn.close();
+    }, missDuration);
+  }
   startActiveHeartbeat() {
     this.isActivelyHeartbeating = true;
+    this.heartbeatHandle = setInterval(() => {
+      this.sendHeartbeat();
+    }, this.options.heartbeatIntervalMs);
   }
   sendHeartbeat() {
     this.log?.debug("sending heartbeat", this.loggingMetadata);
-    this.send({
+    const heartbeat = {
       streamId: "heartbeat",
       controlFlags: 1 /* AckBit */,
       payload: {
         type: "ACK"
       }
-    });
+    };
+    this.send(heartbeat);
   }
   onMessageData = (msg) => {
-    const parsedMsg = this.parseMsg(msg);
-    if (parsedMsg === null) {
-      this.listeners.onInvalidMessage("could not parse message");
+    const parsedMsgRes = this.codec.fromBuffer(msg);
+    if (!parsedMsgRes.ok) {
+      this.listeners.onInvalidMessage(
+        `could not parse message: ${parsedMsgRes.reason}`
+      );
       return;
     }
+    const parsedMsg = parsedMsgRes.value;
     if (parsedMsg.seq !== this.ack) {
       if (parsedMsg.seq < this.ack) {
         this.log?.debug(
@@ -1034,9 +1029,7 @@ var SessionConnected = class extends IdentifiedSession {
       transportMessage: parsedMsg
     });
     if (!this.isActivelyHeartbeating) {
-      void Promise.resolve().then(() => {
-        this.sendHeartbeat();
-      });
+      this.sendHeartbeat();
     }
   };
   _handleStateExit() {
@@ -1048,6 +1041,10 @@ var SessionConnected = class extends IdentifiedSession {
       clearInterval(this.heartbeatHandle);
       this.heartbeatHandle = void 0;
     }
+    if (this.heartbeatMissTimeout) {
+      clearTimeout(this.heartbeatMissTimeout);
+      this.heartbeatMissTimeout = void 0;
+    }
   }
   _handleClose() {
     super._handleClose();
@@ -1079,6 +1076,47 @@ var SessionBackingOff = class extends IdentifiedSessionWithGracePeriod {
   }
 };
 
+// codec/adapter.ts
+var import_value = require("@sinclair/typebox/value");
+var CodecMessageAdapter = class {
+  constructor(codec) {
+    this.codec = codec;
+  }
+  toBuffer(msg) {
+    try {
+      return {
+        ok: true,
+        value: this.codec.toBuffer(msg)
+      };
+    } catch (e) {
+      return {
+        ok: false,
+        reason: coerceErrorString(e)
+      };
+    }
+  }
+  fromBuffer(buf) {
+    try {
+      const parsedMsg = this.codec.fromBuffer(buf);
+      if (!import_value.Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
+        return {
+          ok: false,
+          reason: "transport message schema mismatch"
+        };
+      }
+      return {
+        ok: true,
+        value: parsedMsg
+      };
+    } catch (e) {
+      return {
+        ok: false,
+        reason: coerceErrorString(e)
+      };
+    }
+  }
+};
+
 // transport/sessionStateMachine/transitions.ts
 function inheritSharedSession(session) {
   return {
@@ -1093,7 +1131,8 @@ function inheritSharedSession(session) {
     options: session.options,
     log: session.log,
     tracer: session.tracer,
-    protocolVersion: session.protocolVersion
+    protocolVersion: session.protocolVersion,
+    codec: session.codec
   };
 }
 function inheritSharedSessionWithGrace(session) {
@@ -1122,7 +1161,8 @@ var SessionStateGraph = {
         options,
         protocolVersion,
         tracer,
-        log
+        log,
+        codec: new CodecMessageAdapter(options.codec)
       });
       session.log?.info(`session ${session.id} created in NoConnection state`, {
         ...session.loggingMetadata,
@@ -1137,7 +1177,8 @@ var SessionStateGraph = {
         from,
         options,
         tracer,
-        log
+        log,
+        codec: new CodecMessageAdapter(options.codec)
       });
       session.log?.info(`session created in WaitingForHandshake state`, {
         ...session.loggingMetadata,
@@ -1215,6 +1256,7 @@ var SessionStateGraph = {
         listeners,
         ...carriedState
       });
+      session.startMissingHeartbeatTimeout();
       session.log?.info(
         `session ${session.id} transition from Handshaking to Connected`,
         {
@@ -1250,7 +1292,8 @@ var SessionStateGraph = {
           options,
           tracer: pendingSession.tracer,
           log: pendingSession.log,
-          protocolVersion
+          protocolVersion,
+          codec: new CodecMessageAdapter(options.codec)
         }
       );
       pendingSession._handleStateExit();
@@ -1260,6 +1303,7 @@ var SessionStateGraph = {
         listeners,
         ...carriedState
       });
+      session.startMissingHeartbeatTimeout();
       conn.telemetry = createConnectionTelemetryInfo(
         session.tracer,
         conn,
@@ -1600,12 +1644,16 @@ var Transport = class {
         );
       }
       const sameSession = session.id === sessionId;
-      if (!sameSession) {
+      if (!sameSession || session._isConsumed) {
         throw new Error(
           `session scope for ${sessionId} has ended (transition), can't send`
         );
       }
-      return session.send(msg);
+      const res = session.send(msg);
+      if (!res.ok) {
+        throw new Error(res.reason);
+      }
+      return res.value;
     };
   }
 };
@@ -1725,17 +1773,28 @@ var ServerTransport = class extends Transport {
       message: reason
     });
     this.log?.warn(reason, metadata);
-    session.sendHandshake(
-      handshakeResponseMessage({
-        from: this.clientId,
-        to,
-        status: {
-          ok: false,
-          code,
-          reason
-        }
-      })
-    );
+    const responseMsg = handshakeResponseMessage({
+      from: this.clientId,
+      to,
+      status: {
+        ok: false,
+        code,
+        reason
+      }
+    });
+    const res = session.sendHandshake(responseMsg);
+    if (!res.ok) {
+      this.log?.error(`failed to send handshake response: ${res.reason}`, {
+        ...session.loggingMetadata,
+        transportMessage: responseMsg
+      });
+      this.protocolError({
+        type: ProtocolError.MessageSendFailure,
+        message: res.reason
+      });
+      this.deletePendingSession(session);
+      return;
+    }
     this.protocolError({
       type: ProtocolError.HandshakeFailed,
       code,
@@ -1919,7 +1978,20 @@ var ServerTransport = class extends Transport {
         sessionId
       }
     });
-    session.sendHandshake(responseMsg);
+    const res = session.sendHandshake(responseMsg);
+    if (!res.ok) {
+      this.log?.error(`failed to send handshake response: ${res.reason}`, {
+        ...session.loggingMetadata,
+        transportMessage: responseMsg
+      });
+      this.protocolError({
+        type: ProtocolError.MessageSendFailure,
+        message: res.reason
+      });
+      this.deletePendingSession(session);
+      return;
+    }
+    this.pendingSessions.delete(session);
     const connectedSession = ServerSessionStateGraph.transition.WaitingForHandshakeToConnected(
       session,
       // by this point oldSession is either no connection or we dont have an old session
@@ -1946,22 +2018,52 @@ var ServerTransport = class extends Transport {
           this.handleMsg(msg2);
         },
         onInvalidMessage: (reason) => {
+          this.log?.error(`invalid message: ${reason}`, {
+            ...connectedSession.loggingMetadata,
+            transportMessage: msg
+          });
           this.protocolError({
             type: ProtocolError.InvalidMessage,
             message: reason
           });
           this.deleteSession(connectedSession, { unhealthy: true });
+        },
+        onMessageSendFailure: (msg2, reason) => {
+          this.log?.error(`failed to send message: ${reason}`, {
+            ...connectedSession.loggingMetadata,
+            transportMessage: msg2
+          });
+          this.protocolError({
+            type: ProtocolError.MessageSendFailure,
+            message: reason
+          });
+          this.deleteSession(connectedSession, { unhealthy: true });
         }
       },
       gotVersion
     );
+    const bufferSendRes = connectedSession.sendBufferedMessages();
+    if (!bufferSendRes.ok) {
+      this.log?.error(
+        `failed to send buffered messages: ${bufferSendRes.reason}`,
+        {
+          ...connectedSession.loggingMetadata,
+          transportMessage: msg
+        }
+      );
+      this.protocolError({
+        type: ProtocolError.MessageSendFailure,
+        message: bufferSendRes.reason
+      });
+      this.deleteSession(connectedSession, { unhealthy: true });
+      return;
+    }
     this.sessionHandshakeMetadata.set(connectedSession.to, parsedMetadata);
     if (oldSession) {
       this.updateSession(connectedSession);
     } else {
       this.createSession(connectedSession);
     }
-    this.pendingSessions.delete(session);
     connectedSession.startActiveHeartbeat();
   }
 };