@replit/river 0.207.2 → 0.207.3

package/dist/transport/index.cjs

@@ -99,7 +99,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 = {};
@@ -164,23 +165,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;
   }
 };
 
@@ -209,9 +207,6 @@ var defaultServerTransportOptions = {
   ...defaultTransportOptions
 };
 
-// transport/message.ts
-var import_typebox = require("@sinclair/typebox");
-
 // transport/id.ts
 var import_nanoid = require("nanoid");
 var alphabet = (0, import_nanoid.customAlphabet)(
@@ -219,148 +214,7 @@ var alphabet = (0, import_nanoid.customAlphabet)(
 );
 var generateId = () => alphabet(12);
 
-// transport/message.ts
-var TransportMessageSchema = (t) => import_typebox.Type.Object({
-  id: import_typebox.Type.String(),
-  from: import_typebox.Type.String(),
-  to: import_typebox.Type.String(),
-  seq: import_typebox.Type.Integer(),
-  ack: import_typebox.Type.Integer(),
-  serviceName: import_typebox.Type.Optional(import_typebox.Type.String()),
-  procedureName: import_typebox.Type.Optional(import_typebox.Type.String()),
-  streamId: import_typebox.Type.String(),
-  controlFlags: import_typebox.Type.Integer(),
-  tracing: import_typebox.Type.Optional(
-    import_typebox.Type.Object({
-      traceparent: import_typebox.Type.String(),
-      tracestate: import_typebox.Type.String()
-    })
-  ),
-  payload: t
-});
-var ControlMessageAckSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("ACK")
-});
-var ControlMessageCloseSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("CLOSE")
-});
-var currentProtocolVersion = "v2.0";
-var acceptedProtocolVersions = ["v1.1", currentProtocolVersion];
-function isAcceptedProtocolVersion(version2) {
-  return acceptedProtocolVersions.includes(version2);
-}
-var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("HANDSHAKE_REQ"),
-  protocolVersion: import_typebox.Type.String(),
-  sessionId: import_typebox.Type.String(),
-  /**
-   * Specifies what the server's expected session state (from the pov of the client). This can be
-   * used by the server to know whether this is a new or a reestablished connection, and whether it
-   * is compatible with what it already has.
-   */
-  expectedSessionState: import_typebox.Type.Object({
-    // what the client expects the server to send next
-    nextExpectedSeq: import_typebox.Type.Integer(),
-    nextSentSeq: import_typebox.Type.Integer()
-  }),
-  metadata: import_typebox.Type.Optional(import_typebox.Type.Unknown())
-});
-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"),
-  // 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,
-  HandshakeErrorFatalResponseCodes
-]);
-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),
-      sessionId: import_typebox.Type.String()
-    }),
-    import_typebox.Type.Object({
-      ok: import_typebox.Type.Literal(false),
-      reason: import_typebox.Type.String(),
-      code: HandshakeErrorResponseCodes
-    })
-  ])
-});
-var ControlMessagePayloadSchema = import_typebox.Type.Union([
-  ControlMessageCloseSchema,
-  ControlMessageAckSchema,
-  ControlMessageHandshakeRequestSchema,
-  ControlMessageHandshakeResponseSchema
-]);
-var OpaqueTransportMessageSchema = TransportMessageSchema(
-  import_typebox.Type.Unknown()
-);
-function handshakeRequestMessage({
-  from,
-  to,
-  sessionId,
-  expectedSessionState,
-  metadata,
-  tracing
-}) {
-  return {
-    id: generateId(),
-    from,
-    to,
-    seq: 0,
-    ack: 0,
-    streamId: generateId(),
-    controlFlags: 0,
-    tracing,
-    payload: {
-      type: "HANDSHAKE_REQ",
-      protocolVersion: currentProtocolVersion,
-      sessionId,
-      expectedSessionState,
-      metadata
-    }
-  };
-}
-function handshakeResponseMessage({
-  from,
-  to,
-  status
-}) {
-  return {
-    id: generateId(),
-    from,
-    to,
-    seq: 0,
-    ack: 0,
-    streamId: generateId(),
-    controlFlags: 0,
-    payload: {
-      type: "HANDSHAKE_RESP",
-      status
-    }
-  };
-}
-function isAck(controlFlag) {
-  return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
-}
-
 // transport/sessionStateMachine/common.ts
-var import_value = require("@sinclair/typebox/value");
 var SessionState = /* @__PURE__ */ ((SessionState2) => {
   SessionState2["NoConnection"] = "NoConnection";
   SessionState2["BackingOff"] = "BackingOff";
@@ -429,34 +283,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 {
@@ -516,9 +352,6 @@ var IdentifiedSession = class extends CommonSession {
     return metadata;
   }
   constructMsg(partialMsg) {
-    if (this._isConsumed) {
-      throw new Error(ERR_CONSUMED);
-    }
     const msg = {
       ...partialMsg,
       id: generateId(),
@@ -536,7 +369,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() {
   }
@@ -568,6 +404,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 {
@@ -620,8 +473,8 @@ var SessionConnecting = class extends IdentifiedSessionWithGracePeriod {
     }
   }
   _handleClose() {
-    this.bestEffortClose();
     super._handleClose();
+    this.bestEffortClose();
   }
 };
 
@@ -639,6 +492,147 @@ var SessionNoConnection = class extends IdentifiedSessionWithGracePeriod {
 // tracing/index.ts
 var import_api2 = require("@opentelemetry/api");
 
+// transport/message.ts
+var import_typebox = require("@sinclair/typebox");
+var TransportMessageSchema = (t) => import_typebox.Type.Object({
+  id: import_typebox.Type.String(),
+  from: import_typebox.Type.String(),
+  to: import_typebox.Type.String(),
+  seq: import_typebox.Type.Integer(),
+  ack: import_typebox.Type.Integer(),
+  serviceName: import_typebox.Type.Optional(import_typebox.Type.String()),
+  procedureName: import_typebox.Type.Optional(import_typebox.Type.String()),
+  streamId: import_typebox.Type.String(),
+  controlFlags: import_typebox.Type.Integer(),
+  tracing: import_typebox.Type.Optional(
+    import_typebox.Type.Object({
+      traceparent: import_typebox.Type.String(),
+      tracestate: import_typebox.Type.String()
+    })
+  ),
+  payload: t
+});
+var ControlMessageAckSchema = import_typebox.Type.Object({
+  type: import_typebox.Type.Literal("ACK")
+});
+var ControlMessageCloseSchema = import_typebox.Type.Object({
+  type: import_typebox.Type.Literal("CLOSE")
+});
+var currentProtocolVersion = "v2.0";
+var acceptedProtocolVersions = ["v1.1", currentProtocolVersion];
+function isAcceptedProtocolVersion(version2) {
+  return acceptedProtocolVersions.includes(version2);
+}
+var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
+  type: import_typebox.Type.Literal("HANDSHAKE_REQ"),
+  protocolVersion: import_typebox.Type.String(),
+  sessionId: import_typebox.Type.String(),
+  /**
+   * Specifies what the server's expected session state (from the pov of the client). This can be
+   * used by the server to know whether this is a new or a reestablished connection, and whether it
+   * is compatible with what it already has.
+   */
+  expectedSessionState: import_typebox.Type.Object({
+    // what the client expects the server to send next
+    nextExpectedSeq: import_typebox.Type.Integer(),
+    nextSentSeq: import_typebox.Type.Integer()
+  }),
+  metadata: import_typebox.Type.Optional(import_typebox.Type.Unknown())
+});
+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"),
+  // 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,
+  HandshakeErrorFatalResponseCodes
+]);
+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),
+      sessionId: import_typebox.Type.String()
+    }),
+    import_typebox.Type.Object({
+      ok: import_typebox.Type.Literal(false),
+      reason: import_typebox.Type.String(),
+      code: HandshakeErrorResponseCodes
+    })
+  ])
+});
+var ControlMessagePayloadSchema = import_typebox.Type.Union([
+  ControlMessageCloseSchema,
+  ControlMessageAckSchema,
+  ControlMessageHandshakeRequestSchema,
+  ControlMessageHandshakeResponseSchema
+]);
+var OpaqueTransportMessageSchema = TransportMessageSchema(
+  import_typebox.Type.Unknown()
+);
+function handshakeRequestMessage({
+  from,
+  to,
+  sessionId,
+  expectedSessionState,
+  metadata,
+  tracing
+}) {
+  return {
+    id: generateId(),
+    from,
+    to,
+    seq: 0,
+    ack: 0,
+    streamId: generateId(),
+    controlFlags: 0,
+    tracing,
+    payload: {
+      type: "HANDSHAKE_REQ",
+      protocolVersion: currentProtocolVersion,
+      sessionId,
+      expectedSessionState,
+      metadata
+    }
+  };
+}
+function handshakeResponseMessage({
+  from,
+  to,
+  status
+}) {
+  return {
+    id: generateId(),
+    from,
+    to,
+    seq: 0,
+    ack: 0,
+    streamId: generateId(),
+    controlFlags: 0,
+    payload: {
+      type: "HANDSHAKE_RESP",
+      status
+    }
+  };
+}
+function isAck(controlFlag) {
+  return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
+}
+
 // transport/stringifyError.ts
 function coerceErrorString(err) {
   if (err instanceof Error) {
@@ -648,7 +642,7 @@ function coerceErrorString(err) {
 }
 
 // package.json
-var version = "0.207.2";
+var version = "0.207.3";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {
@@ -720,18 +714,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);
@@ -769,18 +763,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();
@@ -805,25 +799,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) {
@@ -831,22 +815,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);
@@ -855,6 +839,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()}`,
@@ -862,30 +848,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 {
@@ -893,25 +864,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(
@@ -950,9 +942,7 @@ var SessionConnected = class extends IdentifiedSession {
       transportMessage: parsedMsg
     });
     if (!this.isActivelyHeartbeating) {
-      void Promise.resolve().then(() => {
-        this.sendHeartbeat();
-      });
+      this.sendHeartbeat();
     }
   };
   _handleStateExit() {
@@ -964,6 +954,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();
@@ -995,6 +989,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 {
@@ -1009,7 +1044,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) {
@@ -1038,7 +1074,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,
@@ -1053,7 +1090,8 @@ var SessionStateGraph = {
         from,
         options,
         tracer,
-        log
+        log,
+        codec: new CodecMessageAdapter(options.codec)
       });
       session.log?.info(`session created in WaitingForHandshake state`, {
         ...session.loggingMetadata,
@@ -1131,6 +1169,7 @@ var SessionStateGraph = {
         listeners,
         ...carriedState
       });
+      session.startMissingHeartbeatTimeout();
       session.log?.info(
         `session ${session.id} transition from Handshaking to Connected`,
         {
@@ -1166,7 +1205,8 @@ var SessionStateGraph = {
           options,
           tracer: pendingSession.tracer,
           log: pendingSession.log,
-          protocolVersion
+          protocolVersion,
+          codec: new CodecMessageAdapter(options.codec)
         }
       );
       pendingSession._handleStateExit();
@@ -1176,6 +1216,7 @@ var SessionStateGraph = {
         listeners,
         ...carriedState
       });
+      session.startMissingHeartbeatTimeout();
       conn.telemetry = createConnectionTelemetryInfo(
         session.tracer,
         conn,
@@ -1516,12 +1557,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;
     };
   }
 };
@@ -1792,13 +1837,41 @@ var ClientTransport = class extends Transport {
         this.handleMsg(msg2);
       },
       onInvalidMessage: (reason) => {
-        this.deleteSession(connectedSession, { unhealthy: true });
+        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 });
       }
     });
+    const res = connectedSession.sendBufferedMessages();
+    if (!res.ok) {
+      this.log?.error(`failed to send buffered messages: ${res.reason}`, {
+        ...connectedSession.loggingMetadata,
+        transportMessage: msg
+      });
+      this.protocolError({
+        type: ProtocolError.MessageSendFailure,
+        message: res.reason
+      });
+      this.deleteSession(connectedSession, { unhealthy: true });
+      return;
+    }
     this.updateSession(connectedSession);
     this.retryBudget.startRestoringBudget();
   }
@@ -1937,7 +2010,18 @@ var ClientTransport = class extends Transport {
       ...session.loggingMetadata,
       transportMessage: requestMsg
     });
-    session.sendHandshake(requestMsg);
+    const res = session.sendHandshake(requestMsg);
+    if (!res.ok) {
+      this.log?.error(`failed to send handshake request: ${res.reason}`, {
+        ...session.loggingMetadata,
+        transportMessage: requestMsg
+      });
+      this.protocolError({
+        type: ProtocolError.MessageSendFailure,
+        message: res.reason
+      });
+      this.deleteSession(session, { unhealthy: true });
+    }
   }
   close() {
     this.retryBudget.close();
@@ -2061,17 +2145,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,
@@ -2255,7 +2350,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
@@ -2282,22 +2390,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();
   }
 };