@replit/river 0.214.0 → 0.215.0

package/dist/transport/impls/ws/client.d.cts

@@ -1,12 +1,12 @@
-import { C as ClientTransport } from '../../../client-DXJRow2s.cjs';
-import { c as TransportClientId } from '../../../message-Dlsh5WDF.cjs';
-import { b as ProvidedClientTransportOptions } from '../../../transport-CxT7y8Qk.cjs';
-import { a as WebSocketConnection } from '../../../connection-Dzkqj18h.cjs';
+import { C as ClientTransport } from '../../../client-Dk4H7qeg.cjs';
+import { c as TransportClientId } from '../../../message-aABg0s5M.cjs';
+import { b as ProvidedClientTransportOptions } from '../../../transport-D3jzhFSi.cjs';
+import { a as WebSocketConnection } from '../../../connection-CS00EWuS.cjs';
 import { W as WsLike } from '../../../wslike-Dng9H1C7.cjs';
 import '@sinclair/typebox';
 import '@opentelemetry/api';
-import '../../../index-D9R6UTMl.cjs';
-import '../../../adapter-DjiEwOYi.cjs';
+import '../../../index-CHCzvZ9D.cjs';
+import '../../../adapter-IGrG4KLL.cjs';
 
 /**
  * A transport implementation that uses a WebSocket connection with automatic reconnection.

package/dist/transport/impls/ws/client.d.ts

@@ -1,12 +1,12 @@
-import { C as ClientTransport } from '../../../client-Dw0JBBs3.js';
-import { c as TransportClientId } from '../../../message-Dlsh5WDF.js';
-import { b as ProvidedClientTransportOptions } from '../../../transport-pdbkDzmJ.js';
-import { a as WebSocketConnection } from '../../../connection-C2lYgRh0.js';
+import { C as ClientTransport } from '../../../client-BhwlY0-L.js';
+import { c as TransportClientId } from '../../../message-aABg0s5M.js';
+import { b as ProvidedClientTransportOptions } from '../../../transport-BOL2p5s-.js';
+import { a as WebSocketConnection } from '../../../connection-DU9v3y8a.js';
 import { W as WsLike } from '../../../wslike-Dng9H1C7.js';
 import '@sinclair/typebox';
 import '@opentelemetry/api';
-import '../../../index-CSM8soK7.js';
-import '../../../adapter-Cp7_gIVA.js';
+import '../../../index-uF0cBM7z.js';
+import '../../../adapter-CgF7vQPu.js';
 
 /**
  * A transport implementation that uses a WebSocket connection with automatic reconnection.

package/dist/transport/impls/ws/client.js

@@ -1,9 +1,9 @@
 import {
   ClientTransport,
   WebSocketConnection
-} from "../../../chunk-DRYCLL6N.js";
+} from "../../../chunk-VXRAFUA3.js";
 import "../../../chunk-CC7RN7GI.js";
-import "../../../chunk-LECVFB2G.js";
+import "../../../chunk-RDTQZ7HO.js";
 
 // transport/impls/ws/client.ts
 var WebSocketClientTransport = class extends ClientTransport {

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

@@ -532,6 +532,7 @@ var IdentifiedSession = class extends CommonSession {
   telemetry;
   to;
   protocolVersion;
+  listeners;
   /**
    * Index of the message we will send next (excluding handshake)
    */
@@ -555,7 +556,8 @@ var IdentifiedSession = class extends CommonSession {
       telemetry,
       log,
       protocolVersion,
-      seqSent: messagesSent
+      seqSent: messagesSent,
+      listeners
     } = props;
     super(props);
     this.id = id;
@@ -567,6 +569,7 @@ var IdentifiedSession = class extends CommonSession {
     this.log = log;
     this.protocolVersion = protocolVersion;
     this.seqSent = messagesSent;
+    this.listeners = listeners;
   }
   get loggingMetadata() {
     const metadata = {
@@ -583,7 +586,7 @@ var IdentifiedSession = class extends CommonSession {
     }
     return metadata;
   }
-  constructMsg(partialMsg) {
+  encodeMsg(partialMsg) {
     const msg = {
       ...partialMsg,
       id: generateId(),
@@ -592,18 +595,37 @@ var IdentifiedSession = class extends CommonSession {
       seq: this.seq,
       ack: this.ack
     };
+    const encoded = this.codec.toBuffer(msg);
+    if (!encoded.ok) {
+      this.listeners.onMessageSendFailure(
+        { ...partialMsg, seq: this.seq },
+        encoded.reason
+      );
+      return encoded;
+    }
     this.seq++;
-    return msg;
+    return {
+      ok: true,
+      value: {
+        id: msg.id,
+        seq: msg.seq,
+        msg: partialMsg,
+        data: encoded.value
+      }
+    };
   }
   nextSeq() {
     return this.sendBuffer.length > 0 ? this.sendBuffer[0].seq : this.seq;
   }
   send(msg) {
-    const constructedMsg = this.constructMsg(msg);
-    this.sendBuffer.push(constructedMsg);
+    const encodeResult = this.encodeMsg(msg);
+    if (!encodeResult.ok) {
+      return encodeResult;
+    }
+    this.sendBuffer.push(encodeResult.value);
     return {
       ok: true,
-      value: constructedMsg.id
+      value: encodeResult.value.id
     };
   }
   _handleStateExit() {
@@ -636,23 +658,6 @@ 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 {
@@ -731,7 +736,7 @@ function coerceErrorString(err) {
 }
 
 // package.json
-var version = "0.214.0";
+var version = "0.215.0";
 
 // tracing/index.ts
 function createSessionTelemetryInfo(tracer, sessionId, to, from, propagationCtx) {
@@ -806,7 +811,21 @@ var SessionWaitingForHandshake = class extends CommonSession {
     this.listeners.onHandshake(parsedMsgRes.value);
   };
   sendHandshake(msg) {
-    return sendMessage(this.conn, this.codec, msg);
+    const buff = this.codec.toBuffer(msg);
+    if (!buff.ok) {
+      return buff;
+    }
+    const sent = this.conn.send(buff.value);
+    if (!sent) {
+      return {
+        ok: false,
+        reason: "failed to send handshake"
+      };
+    }
+    return {
+      ok: true,
+      value: msg.id
+    };
   }
   _handleStateExit() {
     this.conn.removeDataListener();
@@ -855,7 +874,21 @@ var SessionHandshaking = class extends IdentifiedSessionWithGracePeriod {
     this.listeners.onHandshake(parsedMsgRes.value);
   };
   sendHandshake(msg) {
-    return sendMessage(this.conn, this.codec, msg);
+    const buff = this.codec.toBuffer(msg);
+    if (!buff.ok) {
+      return buff;
+    }
+    const sent = this.conn.send(buff.value);
+    if (!sent) {
+      return {
+        ok: false,
+        reason: "failed to send handshake"
+      };
+    }
+    return {
+      ok: true,
+      value: msg.id
+    };
   }
   _handleStateExit() {
     super._handleStateExit();
@@ -890,28 +923,35 @@ var SessionConnected = class extends IdentifiedSession {
     }
     this.startMissingHeartbeatTimeout();
   }
-  assertSendOrdering(constructedMsg) {
-    if (constructedMsg.seq > this.seqSent + 1) {
-      const msg = `invariant violation: would have sent out of order msg (seq: ${constructedMsg.seq}, expected: ${this.seqSent} + 1)`;
+  assertSendOrdering(encodedMsg) {
+    if (encodedMsg.seq > this.seqSent + 1) {
+      const msg = `invariant violation: would have sent out of order msg (seq: ${encodedMsg.seq}, expected: ${this.seqSent} + 1)`;
       this.log?.error(msg, {
         ...this.loggingMetadata,
-        transportMessage: constructedMsg,
         tags: ["invariant-violation"]
       });
       throw new Error(msg);
     }
   }
   send(msg) {
-    const constructedMsg = this.constructMsg(msg);
-    this.assertSendOrdering(constructedMsg);
-    this.sendBuffer.push(constructedMsg);
-    const res = sendMessage(this.conn, this.codec, constructedMsg);
-    if (!res.ok) {
-      this.listeners.onMessageSendFailure(constructedMsg, res.reason);
-      return res;
+    const encodeResult = this.encodeMsg(msg);
+    if (!encodeResult.ok) {
+      return encodeResult;
+    }
+    const encodedMsg = encodeResult.value;
+    this.assertSendOrdering(encodedMsg);
+    this.sendBuffer.push(encodedMsg);
+    const sent = this.conn.send(encodedMsg.data);
+    if (!sent) {
+      const reason = "failed to send message";
+      this.listeners.onMessageSendFailure(
+        { ...encodedMsg.msg, seq: encodedMsg.seq },
+        reason
+      );
+      return { ok: false, reason };
     }
-    this.seqSent = constructedMsg.seq;
-    return res;
+    this.seqSent = encodedMsg.seq;
+    return { ok: true, value: encodedMsg.id };
   }
   constructor(props) {
     super(props);
@@ -929,10 +969,14 @@ var SessionConnected = class extends IdentifiedSession {
       );
       for (const msg of this.sendBuffer) {
         this.assertSendOrdering(msg);
-        const res = sendMessage(this.conn, this.codec, msg);
-        if (!res.ok) {
-          this.listeners.onMessageSendFailure(msg, res.reason);
-          return res;
+        const sent = this.conn.send(msg.data);
+        if (!sent) {
+          const reason = "failed to send buffered message";
+          this.listeners.onMessageSendFailure(
+            { ...msg.msg, seq: msg.seq },
+            reason
+          );
+          return { ok: false, reason };
         }
         this.seqSent = msg.seq;
       }
@@ -1593,6 +1637,17 @@ var Transport = class {
     const noConnectionSession = SessionStateGraph.transition.ConnectingToNoConnection(session, {
       onSessionGracePeriodElapsed: () => {
         this.onSessionGracePeriodElapsed(noConnectionSession);
+      },
+      onMessageSendFailure: (msg, reason) => {
+        this.log?.error(`failed to send message: ${reason}`, {
+          ...noConnectionSession.loggingMetadata,
+          transportMessage: msg
+        });
+        this.protocolError({
+          type: ProtocolError.MessageSendFailure,
+          message: reason
+        });
+        this.deleteSession(noConnectionSession, { unhealthy: true });
       }
     });
     this.updateSession(noConnectionSession);
@@ -1600,18 +1655,32 @@ var Transport = class {
   }
   onConnClosed(session) {
     let noConnectionSession;
+    const listeners = {
+      onSessionGracePeriodElapsed: () => {
+        this.onSessionGracePeriodElapsed(noConnectionSession);
+      },
+      onMessageSendFailure: (msg, reason) => {
+        this.log?.error(`failed to send message: ${reason}`, {
+          ...noConnectionSession.loggingMetadata,
+          transportMessage: msg
+        });
+        this.protocolError({
+          type: ProtocolError.MessageSendFailure,
+          message: reason
+        });
+        this.deleteSession(noConnectionSession, { unhealthy: true });
+      }
+    };
     if (session.state === "Handshaking" /* Handshaking */) {
-      noConnectionSession = SessionStateGraph.transition.HandshakingToNoConnection(session, {
-        onSessionGracePeriodElapsed: () => {
-          this.onSessionGracePeriodElapsed(noConnectionSession);
-        }
-      });
+      noConnectionSession = SessionStateGraph.transition.HandshakingToNoConnection(
+        session,
+        listeners
+      );
     } else {
-      noConnectionSession = SessionStateGraph.transition.ConnectedToNoConnection(session, {
-        onSessionGracePeriodElapsed: () => {
-          this.onSessionGracePeriodElapsed(noConnectionSession);
-        }
-      });
+      noConnectionSession = SessionStateGraph.transition.ConnectedToNoConnection(
+        session,
+        listeners
+      );
     }
     this.updateSession(noConnectionSession);
     return noConnectionSession;
@@ -1918,6 +1987,17 @@ var ServerTransport = class extends Transport {
           {
             onSessionGracePeriodElapsed: () => {
               this.onSessionGracePeriodElapsed(noConnectionSession);
+            },
+            onMessageSendFailure: (msg2, reason) => {
+              this.log?.error(`failed to send message: ${reason}`, {
+                ...noConnectionSession.loggingMetadata,
+                transportMessage: msg2
+              });
+              this.protocolError({
+                type: ProtocolError.MessageSendFailure,
+                message: reason
+              });
+              this.deleteSession(noConnectionSession, { unhealthy: true });
             }
           }
         );