@replit/river 0.207.2 → 0.208.0

package/dist/testUtil/index.cjs

@@ -235,23 +235,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;
   }
 };
 
@@ -281,7 +278,6 @@ var defaultServerTransportOptions = {
 };
 
 // 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 {
   /*
@@ -341,34 +337,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 {
@@ -428,9 +406,6 @@ var IdentifiedSession = class extends CommonSession {
     return metadata;
   }
   constructMsg(partialMsg) {
-    if (this._isConsumed) {
-      throw new Error(ERR_CONSUMED);
-    }
     const msg = {
       ...partialMsg,
       id: generateId(),
@@ -448,7 +423,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() {
   }
@@ -480,6 +458,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 {
@@ -493,13 +488,11 @@ var SessionConnecting = class extends IdentifiedSessionWithGracePeriod {
     this.listeners = props.listeners;
     this.connPromise.then(
       (conn) => {
-        if (this._isConsumed)
-          return;
+        if (this._isConsumed) return;
         this.listeners.onConnectionEstablished(conn);
       },
       (err) => {
-        if (this._isConsumed)
-          return;
+        if (this._isConsumed) return;
         this.listeners.onConnectionFailed(err);
       }
     );
@@ -532,8 +525,8 @@ var SessionConnecting = class extends IdentifiedSessionWithGracePeriod {
     }
   }
   _handleClose() {
-    this.bestEffortClose();
     super._handleClose();
+    this.bestEffortClose();
   }
 };
 
@@ -560,7 +553,7 @@ function coerceErrorString(err) {
 }
 
 // package.json
-var version = "0.207.2";
+var version = "0.208.0";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {
@@ -574,7 +567,7 @@ function getPropagationContext(ctx) {
 function createSessionTelemetryInfo(tracer, sessionId, to, from, propagationCtx) {
   const parentCtx = propagationCtx ? import_api.propagation.extract(import_api.context.active(), propagationCtx) : import_api.context.active();
   const span = tracer.startSpan(
-    `river.session.${sessionId}`,
+    `river.session`,
     {
       attributes: {
         component: "river",
@@ -590,7 +583,7 @@ function createSessionTelemetryInfo(tracer, sessionId, to, from, propagationCtx)
 }
 function createConnectionTelemetryInfo(tracer, connection, info) {
   const span = tracer.startSpan(
-    `connection ${connection.id}`,
+    `river.connection`,
     {
       attributes: {
         component: "river",
@@ -620,9 +613,9 @@ var SessionWaitingForHandshake = class extends CommonSession {
     this.handshakeTimeout = setTimeout(() => {
       this.listeners.onHandshakeTimeout();
     }, this.options.handshakeTimeoutMs);
-    this.conn.addDataListener(this.onHandshakeData);
-    this.conn.addErrorListener(this.listeners.onConnectionErrored);
-    this.conn.addCloseListener(this.listeners.onConnectionClosed);
+    this.conn.setDataListener(this.onHandshakeData);
+    this.conn.setErrorListener(this.listeners.onConnectionErrored);
+    this.conn.setCloseListener(this.listeners.onConnectionClosed);
   }
   get loggingMetadata() {
     return {
@@ -632,23 +625,23 @@ 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);
-    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
-    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
+    this.conn.removeDataListener();
+    this.conn.removeErrorListener();
+    this.conn.removeCloseListener();
     clearTimeout(this.handshakeTimeout);
     this.handshakeTimeout = void 0;
   }
@@ -670,9 +663,9 @@ var SessionHandshaking = class extends IdentifiedSessionWithGracePeriod {
     this.handshakeTimeout = setTimeout(() => {
       this.listeners.onHandshakeTimeout();
     }, this.options.handshakeTimeoutMs);
-    this.conn.addDataListener(this.onHandshakeData);
-    this.conn.addErrorListener(this.listeners.onConnectionErrored);
-    this.conn.addCloseListener(this.listeners.onConnectionClosed);
+    this.conn.setDataListener(this.onHandshakeData);
+    this.conn.setErrorListener(this.listeners.onConnectionErrored);
+    this.conn.setCloseListener(this.listeners.onConnectionClosed);
   }
   get loggingMetadata() {
     return {
@@ -681,24 +674,24 @@ 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();
-    this.conn.removeDataListener(this.onHandshakeData);
-    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
-    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
+    this.conn.removeDataListener();
+    this.conn.removeErrorListener();
+    this.conn.removeCloseListener();
     if (this.handshakeTimeout) {
       clearTimeout(this.handshakeTimeout);
       this.handshakeTimeout = void 0;
@@ -717,25 +710,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) {
@@ -743,30 +726,32 @@ 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);
     this.conn = props.conn;
     this.listeners = props.listeners;
-    this.conn.addDataListener(this.onMessageData);
-    this.conn.addCloseListener(this.listeners.onConnectionClosed);
-    this.conn.addErrorListener(this.listeners.onConnectionErrored);
+    this.conn.setDataListener(this.onMessageData);
+    this.conn.setCloseListener(this.listeners.onConnectionClosed);
+    this.conn.setErrorListener(this.listeners.onConnectionErrored);
+  }
+  sendBufferedMessages() {
     if (this.sendBuffer.length > 0) {
       this.log?.info(
         `sending ${this.sendBuffer.length} buffered messages, starting at seq ${this.nextSeq()}`,
@@ -774,30 +759,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 {
@@ -805,25 +775,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(
@@ -862,20 +853,22 @@ var SessionConnected = class extends IdentifiedSession {
       transportMessage: parsedMsg
     });
     if (!this.isActivelyHeartbeating) {
-      void Promise.resolve().then(() => {
-        this.sendHeartbeat();
-      });
+      this.sendHeartbeat();
     }
   };
   _handleStateExit() {
     super._handleStateExit();
-    this.conn.removeDataListener(this.onMessageData);
-    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
-    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
+    this.conn.removeDataListener();
+    this.conn.removeCloseListener();
+    this.conn.removeErrorListener();
     if (this.heartbeatHandle) {
       clearInterval(this.heartbeatHandle);
       this.heartbeatHandle = void 0;
     }
+    if (this.heartbeatMissTimeout) {
+      clearTimeout(this.heartbeatMissTimeout);
+      this.heartbeatMissTimeout = void 0;
+    }
   }
   _handleClose() {
     super._handleClose();
@@ -907,425 +900,47 @@ var SessionBackingOff = class extends IdentifiedSessionWithGracePeriod {
   }
 };
 
-// transport/sessionStateMachine/transitions.ts
-function inheritSharedSession(session) {
-  return {
-    id: session.id,
-    from: session.from,
-    to: session.to,
-    seq: session.seq,
-    ack: session.ack,
-    seqSent: session.seqSent,
-    sendBuffer: session.sendBuffer,
-    telemetry: session.telemetry,
-    options: session.options,
-    log: session.log,
-    tracer: session.tracer,
-    protocolVersion: session.protocolVersion
-  };
-}
-function inheritSharedSessionWithGrace(session) {
-  return {
-    ...inheritSharedSession(session),
-    graceExpiryTime: session.graceExpiryTime
+// codec/adapter.ts
+var import_value3 = require("@sinclair/typebox/value");
+
+// logging/log.ts
+var import_api3 = require("@opentelemetry/api");
+var LoggingLevels = {
+  debug: -1,
+  info: 0,
+  warn: 1,
+  error: 2
+};
+var cleanedLogFn = (log) => {
+  return (msg, metadata) => {
+    if (metadata && !metadata.telemetry) {
+      const span = import_api3.trace.getSpan(import_api3.context.active());
+      if (span) {
+        metadata.telemetry = {
+          traceId: span.spanContext().traceId,
+          spanId: span.spanContext().spanId
+        };
+      }
+    }
+    if (!metadata?.transportMessage) {
+      log(msg, metadata);
+      return;
+    }
+    const { payload, ...rest } = metadata.transportMessage;
+    metadata.transportMessage = rest;
+    log(msg, metadata);
   };
-}
-var SessionStateGraph = {
-  entrypoints: {
-    NoConnection: (to, from, listeners, options, protocolVersion, tracer, log) => {
-      const id = `session-${generateId()}`;
-      const telemetry = createSessionTelemetryInfo(tracer, id, to, from);
-      const sendBuffer = [];
-      const session = new SessionNoConnection({
-        listeners,
-        id,
-        from,
-        to,
-        seq: 0,
-        ack: 0,
-        seqSent: 0,
-        graceExpiryTime: Date.now() + options.sessionDisconnectGraceMs,
-        sendBuffer,
-        telemetry,
-        options,
-        protocolVersion,
-        tracer,
-        log
-      });
-      session.log?.info(`session ${session.id} created in NoConnection state`, {
-        ...session.loggingMetadata,
-        tags: ["state-transition"]
-      });
-      return session;
-    },
-    WaitingForHandshake: (from, conn, listeners, options, tracer, log) => {
-      const session = new SessionWaitingForHandshake({
-        conn,
-        listeners,
-        from,
-        options,
-        tracer,
-        log
-      });
-      session.log?.info(`session created in WaitingForHandshake state`, {
-        ...session.loggingMetadata,
-        tags: ["state-transition"]
-      });
-      return session;
-    }
-  },
-  // All of the transitions 'move'/'consume' the old session and return a new one.
-  // After a session is transitioned, any usage of the old session will throw.
-  transition: {
-    // happy path transitions
-    NoConnectionToBackingOff: (oldSession, backoffMs, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession._handleStateExit();
-      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 = inheritSharedSessionWithGrace(oldSession);
-      oldSession._handleStateExit();
-      const session = new SessionConnecting({
-        connPromise,
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from BackingOff to Connecting`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    ConnectingToHandshaking: (oldSession, conn, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession._handleStateExit();
-      const session = new SessionHandshaking({
-        conn,
-        listeners,
-        ...carriedState
-      });
-      conn.telemetry = createConnectionTelemetryInfo(
-        session.tracer,
-        conn,
-        session.telemetry
-      );
-      session.log?.info(
-        `session ${session.id} transition from Connecting to Handshaking`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    HandshakingToConnected: (oldSession, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
-      const conn = oldSession.conn;
-      oldSession._handleStateExit();
-      const session = new SessionConnected({
-        conn,
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from Handshaking to Connected`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    WaitingForHandshakeToConnected: (pendingSession, oldSession, sessionId, to, propagationCtx, listeners, protocolVersion) => {
-      const conn = pendingSession.conn;
-      const { from, options } = pendingSession;
-      const carriedState = oldSession ? (
-        // old session exists, inherit state
-        inheritSharedSession(oldSession)
-      ) : (
-        // old session does not exist, create new state
-        {
-          id: sessionId,
-          from,
-          to,
-          seq: 0,
-          ack: 0,
-          seqSent: 0,
-          sendBuffer: [],
-          telemetry: createSessionTelemetryInfo(
-            pendingSession.tracer,
-            sessionId,
-            to,
-            from,
-            propagationCtx
-          ),
-          options,
-          tracer: pendingSession.tracer,
-          log: pendingSession.log,
-          protocolVersion
-        }
-      );
-      pendingSession._handleStateExit();
-      oldSession?._handleStateExit();
-      const session = new SessionConnected({
-        conn,
-        listeners,
-        ...carriedState
-      });
-      conn.telemetry = createConnectionTelemetryInfo(
-        session.tracer,
-        conn,
-        session.telemetry
-      );
-      session.log?.info(
-        `session ${session.id} transition from WaitingForHandshake to Connected`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    // disconnect paths
-    BackingOffToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(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 = inheritSharedSessionWithGrace(oldSession);
-      oldSession.bestEffortClose();
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection({
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from Connecting to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    HandshakingToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession.conn.close();
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection({
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from Handshaking to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    ConnectedToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
-      const graceExpiryTime = Date.now() + oldSession.options.sessionDisconnectGraceMs;
-      oldSession.conn.close();
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection({
-        listeners,
-        graceExpiryTime,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from Connected to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    }
-  }
-};
-var transitions = SessionStateGraph.transition;
-var ClientSessionStateGraph = {
-  entrypoint: SessionStateGraph.entrypoints.NoConnection,
-  transition: {
-    // happy paths
-    // NoConnection -> BackingOff: attempt to connect
-    NoConnectionToBackingOff: transitions.NoConnectionToBackingOff,
-    // BackingOff -> Connecting: backoff period elapsed, start connection
-    BackingOffToConnecting: transitions.BackingOffToConnecting,
-    // Connecting -> Handshaking: connection established, start handshake
-    ConnectingToHandshaking: transitions.ConnectingToHandshaking,
-    // Handshaking -> Connected: handshake complete, session ready
-    HandshakingToConnected: transitions.HandshakingToConnected,
-    // disconnect paths
-    // BackingOff -> NoConnection: unused
-    BackingOffToNoConnection: transitions.BackingOffToNoConnection,
-    // Connecting -> NoConnection: connection failed or connection timeout
-    ConnectingToNoConnection: transitions.ConnectingToNoConnection,
-    // Handshaking -> NoConnection: connection closed or handshake timeout
-    HandshakingToNoConnection: transitions.HandshakingToNoConnection,
-    // Connected -> NoConnection: connection closed
-    ConnectedToNoConnection: transitions.ConnectedToNoConnection
-    // destroy/close paths
-    // NoConnection -> x: grace period elapsed
-    // BackingOff -> x: grace period elapsed
-    // Connecting -> x: grace period elapsed
-    // Handshaking -> x: grace period elapsed or invalid handshake message or handshake rejection
-    // Connected -> x: grace period elapsed or invalid message
-  }
-};
-var ServerSessionStateGraph = {
-  entrypoint: SessionStateGraph.entrypoints.WaitingForHandshake,
-  transition: {
-    // happy paths
-    // WaitingForHandshake -> Connected: handshake complete, session ready
-    WaitingForHandshakeToConnected: transitions.WaitingForHandshakeToConnected,
-    // disconnect paths
-    // Connected -> NoConnection: connection closed
-    ConnectedToNoConnection: transitions.ConnectedToNoConnection
-    // destroy/close paths
-    // WaitingForHandshake -> x: handshake timeout elapsed or invalid handshake message or handshake rejection or connection closed
-  }
-};
-
-// transport/client.ts
-var import_api4 = require("@opentelemetry/api");
-
-// transport/rateLimit.ts
-var LeakyBucketRateLimit = class {
-  budgetConsumed;
-  intervalHandle;
-  options;
-  constructor(options) {
-    this.options = options;
-    this.budgetConsumed = 0;
-  }
-  getBackoffMs() {
-    if (this.getBudgetConsumed() === 0) {
-      return 0;
-    }
-    const exponent = Math.max(0, this.getBudgetConsumed() - 1);
-    const jitter = Math.floor(Math.random() * this.options.maxJitterMs);
-    const backoffMs = Math.min(
-      this.options.baseIntervalMs * 2 ** exponent,
-      this.options.maxBackoffMs
-    );
-    return backoffMs + jitter;
-  }
-  get totalBudgetRestoreTime() {
-    return this.options.budgetRestoreIntervalMs * this.options.attemptBudgetCapacity;
-  }
-  consumeBudget() {
-    this.stopLeak();
-    this.budgetConsumed = this.getBudgetConsumed() + 1;
-  }
-  getBudgetConsumed() {
-    return this.budgetConsumed;
-  }
-  hasBudget() {
-    return this.getBudgetConsumed() < this.options.attemptBudgetCapacity;
-  }
-  startRestoringBudget() {
-    if (this.intervalHandle) {
-      return;
-    }
-    const restoreBudgetForUser = () => {
-      const currentBudget = this.budgetConsumed;
-      if (!currentBudget) {
-        this.stopLeak();
-        return;
-      }
-      const newBudget = currentBudget - 1;
-      if (newBudget === 0) {
-        return;
-      }
-      this.budgetConsumed = newBudget;
-    };
-    this.intervalHandle = setInterval(
-      restoreBudgetForUser,
-      this.options.budgetRestoreIntervalMs
-    );
-  }
-  stopLeak() {
-    if (!this.intervalHandle) {
-      return;
-    }
-    clearInterval(this.intervalHandle);
-    this.intervalHandle = void 0;
-  }
-  close() {
-    this.stopLeak();
-  }
-};
-
-// logging/log.ts
-var import_api3 = require("@opentelemetry/api");
-var LoggingLevels = {
-  debug: -1,
-  info: 0,
-  warn: 1,
-  error: 2
-};
-var cleanedLogFn = (log) => {
-  return (msg, metadata) => {
-    if (metadata && !metadata.telemetry) {
-      const span = import_api3.trace.getSpan(import_api3.context.active());
-      if (span) {
-        metadata.telemetry = {
-          traceId: span.spanContext().traceId,
-          spanId: span.spanContext().spanId
-        };
-      }
-    }
-    if (!metadata?.transportMessage) {
-      log(msg, metadata);
-      return;
-    }
-    const { payload, ...rest } = metadata.transportMessage;
-    metadata.transportMessage = rest;
-    log(msg, metadata);
-  };
-};
-var BaseLogger = class {
-  minLevel;
-  output;
-  constructor(output, minLevel = "info") {
-    this.minLevel = minLevel;
-    this.output = output;
-  }
-  debug(msg, metadata) {
-    if (LoggingLevels[this.minLevel] <= LoggingLevels.debug) {
-      this.output(msg, metadata ?? {}, "debug");
+};
+var BaseLogger = class {
+  minLevel;
+  output;
+  constructor(output, minLevel = "info") {
+    this.minLevel = minLevel;
+    this.output = output;
+  }
+  debug(msg, metadata) {
+    if (LoggingLevels[this.minLevel] <= LoggingLevels.debug) {
+      this.output(msg, metadata ?? {}, "debug");
     }
   }
   info(msg, metadata) {
@@ -1356,7 +971,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 = {};
@@ -1436,8 +1052,7 @@ var Transport = class {
    * @param message The received message.
    */
   handleMsg(message) {
-    if (this.getStatus() !== "open")
-      return;
+    if (this.getStatus() !== "open") return;
     this.eventDispatcher.dispatchEvent("message", message);
   }
   /**
@@ -1525,8 +1140,7 @@ var Transport = class {
     });
   }
   deleteSession(session, options) {
-    if (session._isConsumed)
-      return;
+    if (session._isConsumed) return;
     const loggingMetadata = session.loggingMetadata;
     if (loggingMetadata.tags && options?.unhealthy) {
       loggingMetadata.tags.push("unhealthy-session");
@@ -1546,7 +1160,7 @@ var Transport = class {
   }
   // common listeners
   onSessionGracePeriodElapsed(session) {
-    this.log?.warn(
+    this.log?.info(
       `session to ${session.to} grace period elapsed, closing`,
       session.loggingMetadata
     );
@@ -1599,18 +1213,92 @@ 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;
     };
   }
 };
 
 // transport/client.ts
-var import_value2 = require("@sinclair/typebox/value");
+var import_api4 = require("@opentelemetry/api");
+
+// transport/rateLimit.ts
+var LeakyBucketRateLimit = class {
+  budgetConsumed;
+  intervalHandle;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.budgetConsumed = 0;
+  }
+  getBackoffMs() {
+    if (this.getBudgetConsumed() === 0) {
+      return 0;
+    }
+    const exponent = Math.max(0, this.getBudgetConsumed() - 1);
+    const jitter = Math.floor(Math.random() * this.options.maxJitterMs);
+    const backoffMs = Math.min(
+      this.options.baseIntervalMs * 2 ** exponent,
+      this.options.maxBackoffMs
+    );
+    return backoffMs + jitter;
+  }
+  get totalBudgetRestoreTime() {
+    return this.options.budgetRestoreIntervalMs * this.options.attemptBudgetCapacity;
+  }
+  consumeBudget() {
+    this.stopLeak();
+    this.budgetConsumed = this.getBudgetConsumed() + 1;
+  }
+  getBudgetConsumed() {
+    return this.budgetConsumed;
+  }
+  hasBudget() {
+    return this.getBudgetConsumed() < this.options.attemptBudgetCapacity;
+  }
+  startRestoringBudget() {
+    if (this.intervalHandle) {
+      return;
+    }
+    const restoreBudgetForUser = () => {
+      const currentBudget = this.budgetConsumed;
+      if (!currentBudget) {
+        this.stopLeak();
+        return;
+      }
+      const newBudget = currentBudget - 1;
+      if (newBudget === 0) {
+        return;
+      }
+      this.budgetConsumed = newBudget;
+    };
+    this.intervalHandle = setInterval(
+      restoreBudgetForUser,
+      this.options.budgetRestoreIntervalMs
+    );
+  }
+  stopLeak() {
+    if (!this.intervalHandle) {
+      return;
+    }
+    clearInterval(this.intervalHandle);
+    this.intervalHandle = void 0;
+  }
+  close() {
+    this.stopLeak();
+  }
+};
+
+// transport/client.ts
+var import_value = require("@sinclair/typebox/value");
 var ClientTransport = class extends Transport {
   /**
    * The options for this transport.
@@ -1741,19 +1429,19 @@ var ClientTransport = class extends Transport {
     this.deleteSession(session, { unhealthy: true });
   }
   onHandshakeResponse(session, msg) {
-    if (!import_value2.Value.Check(ControlMessageHandshakeResponseSchema, msg.payload)) {
+    if (!import_value.Value.Check(ControlMessageHandshakeResponseSchema, msg.payload)) {
       const reason = `received invalid handshake response`;
       this.rejectHandshakeResponse(session, reason, {
         ...session.loggingMetadata,
         transportMessage: msg,
         validationErrors: [
-          ...import_value2.Value.Errors(ControlMessageHandshakeResponseSchema, msg.payload)
+          ...import_value.Value.Errors(ControlMessageHandshakeResponseSchema, msg.payload)
         ]
       });
       return;
     }
     if (!msg.payload.status.ok) {
-      const retriable = import_value2.Value.Check(
+      const retriable = import_value.Value.Check(
         HandshakeErrorRetriableResponseCodes,
         msg.payload.status.code
       );
@@ -1805,13 +1493,32 @@ 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) {
+      return;
+    }
     this.updateSession(connectedSession);
     this.retryBudget.startRestoringBudget();
   }
@@ -1950,7 +1657,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();
@@ -1958,96 +1676,9 @@ var ClientTransport = class extends Transport {
   }
 };
 
-// transport/connection.ts
-var Connection = class {
-  id;
-  telemetry;
-  constructor() {
-    this.id = `conn-${generateId()}`;
-  }
-  get loggingMetadata() {
-    const metadata = { connId: this.id };
-    if (this.telemetry?.span.isRecording()) {
-      const spanContext = this.telemetry.span.spanContext();
-      metadata.telemetry = {
-        traceId: spanContext.traceId,
-        spanId: spanContext.spanId
-      };
-    }
-    return metadata;
-  }
-  // can't use event emitter because we need this to work in both node + browser
-  _dataListeners = /* @__PURE__ */ new Set();
-  _closeListeners = /* @__PURE__ */ new Set();
-  _errorListeners = /* @__PURE__ */ new Set();
-  get dataListeners() {
-    return [...this._dataListeners];
-  }
-  get closeListeners() {
-    return [...this._closeListeners];
-  }
-  get errorListeners() {
-    return [...this._errorListeners];
-  }
-  onData(msg) {
-    for (const cb of this.dataListeners) {
-      cb(msg);
-    }
-  }
-  onError(err) {
-    for (const cb of this.errorListeners) {
-      cb(err);
-    }
-  }
-  onClose() {
-    for (const cb of this.closeListeners) {
-      cb();
-    }
-    this.telemetry?.span.end();
-  }
-  /**
-   * Handle adding a callback for when a message is received.
-   * @param msg The message that was received.
-   */
-  addDataListener(cb) {
-    this._dataListeners.add(cb);
-  }
-  removeDataListener(cb) {
-    this._dataListeners.delete(cb);
-  }
-  /**
-   * Handle adding a callback for when the connection is closed.
-   * This should also be called if an error happens and after notifying all the error listeners.
-   * @param cb The callback to call when the connection is closed.
-   */
-  addCloseListener(cb) {
-    this._closeListeners.add(cb);
-  }
-  removeCloseListener(cb) {
-    this._closeListeners.delete(cb);
-  }
-  /**
-   * Handle adding a callback for when an error is received.
-   * This should only be used for this.logging errors, all cleanup
-   * should be delegated to addCloseListener.
-   *
-   * The implementer should take care such that the implemented
-   * connection will call both the close and error callbacks
-   * on an error.
-   *
-   * @param cb The callback to call when an error is received.
-   */
-  addErrorListener(cb) {
-    this._errorListeners.add(cb);
-  }
-  removeErrorListener(cb) {
-    this._errorListeners.delete(cb);
-  }
-};
-
 // transport/server.ts
 var import_api5 = require("@opentelemetry/api");
-var import_value3 = require("@sinclair/typebox/value");
+var import_value2 = require("@sinclair/typebox/value");
 var ServerTransport = class extends Transport {
   /**
    * The options for this transport.
@@ -2087,8 +1718,7 @@ var ServerTransport = class extends Transport {
     super.deleteSession(session, options);
   }
   handleConnection(conn) {
-    if (this.getStatus() !== "open")
-      return;
+    if (this.getStatus() !== "open") return;
     this.log?.info(`new incoming connection`, {
       ...conn.loggingMetadata,
       clientId: this.clientId
@@ -2161,17 +1791,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,
@@ -2180,7 +1821,7 @@ var ServerTransport = class extends Transport {
     this.deletePendingSession(session);
   }
   async onHandshakeRequest(session, msg) {
-    if (!import_value3.Value.Check(ControlMessageHandshakeRequestSchema, msg.payload)) {
+    if (!import_value2.Value.Check(ControlMessageHandshakeRequestSchema, msg.payload)) {
       this.rejectHandshakeRequest(
         session,
         msg.from,
@@ -2191,7 +1832,7 @@ var ServerTransport = class extends Transport {
           transportMessage: msg,
           connectedTo: msg.from,
           validationErrors: [
-            ...import_value3.Value.Errors(ControlMessageHandshakeRequestSchema, msg.payload)
+            ...import_value2.Value.Errors(ControlMessageHandshakeRequestSchema, msg.payload)
           ]
         }
       );
@@ -2214,7 +1855,7 @@ var ServerTransport = class extends Transport {
     }
     let parsedMetadata = {};
     if (this.handshakeExtensions) {
-      if (!import_value3.Value.Check(this.handshakeExtensions.schema, msg.payload.metadata)) {
+      if (!import_value2.Value.Check(this.handshakeExtensions.schema, msg.payload.metadata)) {
         this.rejectHandshakeRequest(
           session,
           msg.from,
@@ -2224,7 +1865,7 @@ var ServerTransport = class extends Transport {
             ...session.loggingMetadata,
             connectedTo: msg.from,
             validationErrors: [
-              ...import_value3.Value.Errors(
+              ...import_value2.Value.Errors(
                 this.handshakeExtensions.schema,
                 msg.payload.metadata
               )
@@ -2243,7 +1884,7 @@ var ServerTransport = class extends Transport {
       if (session._isConsumed) {
         return;
       }
-      if (import_value3.Value.Check(
+      if (import_value2.Value.Check(
         HandshakeErrorCustomHandlerFatalResponseCodes,
         parsedMetadataOrFailureCode
       )) {
@@ -2355,7 +1996,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
@@ -2382,81 +2036,527 @@ 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) {
+      return;
+    }
     this.sessionHandshakeMetadata.set(connectedSession.to, parsedMetadata);
     if (oldSession) {
       this.updateSession(connectedSession);
     } else {
       this.createSession(connectedSession);
     }
-    this.pendingSessions.delete(session);
     connectedSession.startActiveHeartbeat();
   }
 };
 
-// testUtil/observable/observable.ts
-var Observable = class {
-  value;
-  listeners;
-  constructor(initialValue) {
-    this.value = initialValue;
-    this.listeners = /* @__PURE__ */ new Set();
+// transport/connection.ts
+var Connection = class {
+  id;
+  telemetry;
+  constructor() {
+    this.id = `conn-${generateId()}`;
   }
-  /**
-   * Gets the current value of the observable.
-   */
-  get() {
-    return this.value;
+  get loggingMetadata() {
+    const metadata = { connId: this.id };
+    if (this.telemetry?.span.isRecording()) {
+      const spanContext = this.telemetry.span.spanContext();
+      metadata.telemetry = {
+        traceId: spanContext.traceId,
+        spanId: spanContext.spanId
+      };
+    }
+    return metadata;
+  }
+  dataListener;
+  closeListener;
+  errorListener;
+  onData(msg) {
+    this.dataListener?.(msg);
+  }
+  onError(err) {
+    this.errorListener?.(err);
+  }
+  onClose() {
+    this.closeListener?.();
+    this.telemetry?.span.end();
   }
   /**
-   * Sets the current value of the observable. All listeners will get an update with this value.
-   * @param newValue - The new value to set.
+   * Set the callback for when a message is received.
+   * @param cb The message handler callback.
    */
-  set(tx) {
-    const newValue = tx(this.value);
-    this.value = newValue;
-    this.listeners.forEach((listener) => listener(newValue));
+  setDataListener(cb) {
+    this.dataListener = cb;
+  }
+  removeDataListener() {
+    this.dataListener = void 0;
   }
   /**
-   * Subscribes to changes in the observable value.
-   * @param listener - A callback function that will be called when the value changes.
-   * @returns A function that can be called to unsubscribe from further notifications.
+   * Set the callback for when the connection is closed.
+   * This should also be called if an error happens and after notifying the error listener.
+   * @param cb The callback to call when the connection is closed.
    */
-  observe(listener) {
-    this.listeners.add(listener);
-    listener(this.get());
-    return () => this.listeners.delete(listener);
+  setCloseListener(cb) {
+    this.closeListener = cb;
+  }
+  removeCloseListener() {
+    this.closeListener = void 0;
   }
   /**
-   * Returns the number of listeners currently observing the observable
+   * Set the callback for when an error is received.
+   * This should only be used for logging errors, all cleanup
+   * should be delegated to setCloseListener.
+   *
+   * The implementer should take care such that the implemented
+   * connection will call both the close and error callbacks
+   * on an error.
+   *
+   * @param cb The callback to call when an error is received.
    */
-  get listenerCount() {
-    return this.listeners.size;
+  setErrorListener(cb) {
+    this.errorListener = cb;
+  }
+  removeErrorListener() {
+    this.errorListener = void 0;
   }
 };
 
-// testUtil/duplex/duplexPair.ts
-var import_node_stream = require("stream");
-var import_assert = __toESM(require("assert"), 1);
-var kCallback = Symbol("Callback");
-var kInitOtherSide = Symbol("InitOtherSide");
-var DuplexSide = class extends import_node_stream.Duplex {
-  otherSide;
-  [kCallback];
-  constructor() {
-    super();
-    this[kCallback] = null;
-    this.otherSide = null;
+// codec/adapter.ts
+var CodecMessageAdapter = class {
+  constructor(codec) {
+    this.codec = codec;
   }
-  [kInitOtherSide](otherSide) {
+  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_value3.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 {
+    id: session.id,
+    from: session.from,
+    to: session.to,
+    seq: session.seq,
+    ack: session.ack,
+    seqSent: session.seqSent,
+    sendBuffer: session.sendBuffer,
+    telemetry: session.telemetry,
+    options: session.options,
+    log: session.log,
+    tracer: session.tracer,
+    protocolVersion: session.protocolVersion,
+    codec: session.codec
+  };
+}
+function inheritSharedSessionWithGrace(session) {
+  return {
+    ...inheritSharedSession(session),
+    graceExpiryTime: session.graceExpiryTime
+  };
+}
+var SessionStateGraph = {
+  entrypoints: {
+    NoConnection: (to, from, listeners, options, protocolVersion, tracer, log) => {
+      const id = `session-${generateId()}`;
+      const telemetry = createSessionTelemetryInfo(tracer, id, to, from);
+      const sendBuffer = [];
+      const session = new SessionNoConnection({
+        listeners,
+        id,
+        from,
+        to,
+        seq: 0,
+        ack: 0,
+        seqSent: 0,
+        graceExpiryTime: Date.now() + options.sessionDisconnectGraceMs,
+        sendBuffer,
+        telemetry,
+        options,
+        protocolVersion,
+        tracer,
+        log,
+        codec: new CodecMessageAdapter(options.codec)
+      });
+      session.log?.info(`session ${session.id} created in NoConnection state`, {
+        ...session.loggingMetadata,
+        tags: ["state-transition"]
+      });
+      return session;
+    },
+    WaitingForHandshake: (from, conn, listeners, options, tracer, log) => {
+      const session = new SessionWaitingForHandshake({
+        conn,
+        listeners,
+        from,
+        options,
+        tracer,
+        log,
+        codec: new CodecMessageAdapter(options.codec)
+      });
+      session.log?.info(`session created in WaitingForHandshake state`, {
+        ...session.loggingMetadata,
+        tags: ["state-transition"]
+      });
+      return session;
+    }
+  },
+  // All of the transitions 'move'/'consume' the old session and return a new one.
+  // After a session is transitioned, any usage of the old session will throw.
+  transition: {
+    // happy path transitions
+    NoConnectionToBackingOff: (oldSession, backoffMs, listeners) => {
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
+      oldSession._handleStateExit();
+      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 = inheritSharedSessionWithGrace(oldSession);
+      oldSession._handleStateExit();
+      const session = new SessionConnecting({
+        connPromise,
+        listeners,
+        ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from BackingOff to Connecting`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    ConnectingToHandshaking: (oldSession, conn, listeners) => {
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
+      oldSession._handleStateExit();
+      const session = new SessionHandshaking({
+        conn,
+        listeners,
+        ...carriedState
+      });
+      conn.telemetry = createConnectionTelemetryInfo(
+        session.tracer,
+        conn,
+        session.telemetry
+      );
+      session.log?.info(
+        `session ${session.id} transition from Connecting to Handshaking`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    HandshakingToConnected: (oldSession, listeners) => {
+      const carriedState = inheritSharedSession(oldSession);
+      const conn = oldSession.conn;
+      oldSession._handleStateExit();
+      const session = new SessionConnected({
+        conn,
+        listeners,
+        ...carriedState
+      });
+      session.startMissingHeartbeatTimeout();
+      session.log?.info(
+        `session ${session.id} transition from Handshaking to Connected`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    WaitingForHandshakeToConnected: (pendingSession, oldSession, sessionId, to, propagationCtx, listeners, protocolVersion) => {
+      const conn = pendingSession.conn;
+      const { from, options } = pendingSession;
+      const carriedState = oldSession ? (
+        // old session exists, inherit state
+        inheritSharedSession(oldSession)
+      ) : (
+        // old session does not exist, create new state
+        {
+          id: sessionId,
+          from,
+          to,
+          seq: 0,
+          ack: 0,
+          seqSent: 0,
+          sendBuffer: [],
+          telemetry: createSessionTelemetryInfo(
+            pendingSession.tracer,
+            sessionId,
+            to,
+            from,
+            propagationCtx
+          ),
+          options,
+          tracer: pendingSession.tracer,
+          log: pendingSession.log,
+          protocolVersion,
+          codec: new CodecMessageAdapter(options.codec)
+        }
+      );
+      pendingSession._handleStateExit();
+      oldSession?._handleStateExit();
+      const session = new SessionConnected({
+        conn,
+        listeners,
+        ...carriedState
+      });
+      session.startMissingHeartbeatTimeout();
+      conn.telemetry = createConnectionTelemetryInfo(
+        session.tracer,
+        conn,
+        session.telemetry
+      );
+      session.log?.info(
+        `session ${session.id} transition from WaitingForHandshake to Connected`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    // disconnect paths
+    BackingOffToNoConnection: (oldSession, listeners) => {
+      const carriedState = inheritSharedSessionWithGrace(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 = inheritSharedSessionWithGrace(oldSession);
+      oldSession.bestEffortClose();
+      oldSession._handleStateExit();
+      const session = new SessionNoConnection({
+        listeners,
+        ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from Connecting to NoConnection`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    HandshakingToNoConnection: (oldSession, listeners) => {
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
+      oldSession.conn.close();
+      oldSession._handleStateExit();
+      const session = new SessionNoConnection({
+        listeners,
+        ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from Handshaking to NoConnection`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    ConnectedToNoConnection: (oldSession, listeners) => {
+      const carriedState = inheritSharedSession(oldSession);
+      const graceExpiryTime = Date.now() + oldSession.options.sessionDisconnectGraceMs;
+      oldSession.conn.close();
+      oldSession._handleStateExit();
+      const session = new SessionNoConnection({
+        listeners,
+        graceExpiryTime,
+        ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from Connected to NoConnection`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    }
+  }
+};
+var transitions = SessionStateGraph.transition;
+var ClientSessionStateGraph = {
+  entrypoint: SessionStateGraph.entrypoints.NoConnection,
+  transition: {
+    // happy paths
+    // NoConnection -> BackingOff: attempt to connect
+    NoConnectionToBackingOff: transitions.NoConnectionToBackingOff,
+    // BackingOff -> Connecting: backoff period elapsed, start connection
+    BackingOffToConnecting: transitions.BackingOffToConnecting,
+    // Connecting -> Handshaking: connection established, start handshake
+    ConnectingToHandshaking: transitions.ConnectingToHandshaking,
+    // Handshaking -> Connected: handshake complete, session ready
+    HandshakingToConnected: transitions.HandshakingToConnected,
+    // disconnect paths
+    // BackingOff -> NoConnection: unused
+    BackingOffToNoConnection: transitions.BackingOffToNoConnection,
+    // Connecting -> NoConnection: connection failed or connection timeout
+    ConnectingToNoConnection: transitions.ConnectingToNoConnection,
+    // Handshaking -> NoConnection: connection closed or handshake timeout
+    HandshakingToNoConnection: transitions.HandshakingToNoConnection,
+    // Connected -> NoConnection: connection closed
+    ConnectedToNoConnection: transitions.ConnectedToNoConnection
+    // destroy/close paths
+    // NoConnection -> x: grace period elapsed
+    // BackingOff -> x: grace period elapsed
+    // Connecting -> x: grace period elapsed
+    // Handshaking -> x: grace period elapsed or invalid handshake message or handshake rejection
+    // Connected -> x: grace period elapsed or invalid message
+  }
+};
+var ServerSessionStateGraph = {
+  entrypoint: SessionStateGraph.entrypoints.WaitingForHandshake,
+  transition: {
+    // happy paths
+    // WaitingForHandshake -> Connected: handshake complete, session ready
+    WaitingForHandshakeToConnected: transitions.WaitingForHandshakeToConnected,
+    // disconnect paths
+    // Connected -> NoConnection: connection closed
+    ConnectedToNoConnection: transitions.ConnectedToNoConnection
+    // destroy/close paths
+    // WaitingForHandshake -> x: handshake timeout elapsed or invalid handshake message or handshake rejection or connection closed
+  }
+};
+
+// testUtil/observable/observable.ts
+var Observable = class {
+  value;
+  listeners;
+  constructor(initialValue) {
+    this.value = initialValue;
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Gets the current value of the observable.
+   */
+  get() {
+    return this.value;
+  }
+  /**
+   * Sets the current value of the observable. All listeners will get an update with this value.
+   * @param newValue - The new value to set.
+   */
+  set(tx) {
+    const newValue = tx(this.value);
+    this.value = newValue;
+    this.listeners.forEach((listener) => listener(newValue));
+  }
+  /**
+   * Subscribes to changes in the observable value.
+   * @param listener - A callback function that will be called when the value changes.
+   * @returns A function that can be called to unsubscribe from further notifications.
+   */
+  observe(listener) {
+    this.listeners.add(listener);
+    listener(this.get());
+    return () => this.listeners.delete(listener);
+  }
+  /**
+   * Returns the number of listeners currently observing the observable
+   */
+  get listenerCount() {
+    return this.listeners.size;
+  }
+};
+
+// testUtil/duplex/duplexPair.ts
+var import_node_stream = require("stream");
+var import_assert = __toESM(require("assert"), 1);
+var kCallback = Symbol("Callback");
+var kInitOtherSide = Symbol("InitOtherSide");
+var DuplexSide = class extends import_node_stream.Duplex {
+  otherSide;
+  [kCallback];
+  constructor() {
+    super();
+    this[kCallback] = null;
+    this.otherSide = null;
+  }
+  [kInitOtherSide](otherSide) {
     if (this.otherSide === null) {
       this.otherSide = otherSide;
     }
@@ -2488,6 +2588,16 @@ function duplexPair() {
   const side1 = new DuplexSide();
   side0[kInitOtherSide](side1);
   side1[kInitOtherSide](side0);
+  side0.on("close", () => {
+    setImmediate(() => {
+      side1.destroy();
+    });
+  });
+  side1.on("close", () => {
+    setImmediate(() => {
+      side0.destroy();
+    });
+  });
   return [side0, side1];
 }
 
@@ -2500,19 +2610,13 @@ var InMemoryConnection = class extends Connection {
     this.conn = pipe;
     this.conn.allowHalfOpen = false;
     this.conn.on("data", (data) => {
-      for (const cb of this.dataListeners) {
-        cb(data);
-      }
+      this.dataListener?.(data);
     });
     this.conn.on("close", () => {
-      for (const cb of this.closeListeners) {
-        cb();
-      }
+      this.closeListener?.();
     });
     this.conn.on("error", (err) => {
-      for (const cb of this.errorListeners) {
-        cb(err);
-      }
+      this.errorListener?.(err);
     });
   }
   send(payload) {
@@ -2595,19 +2699,18 @@ function createMockTransportNetwork(opts) {
     },
     async restartServer() {
       for (const transport of transports) {
-        if (transport.clientId !== "SERVER")
-          continue;
+        if (transport.clientId !== "SERVER") continue;
         transport.close();
       }
       for (const conn of Object.values(connections.get())) {
-        conn.serverToClient.end();
-        conn.clientToServer.end();
+        conn.serverToClient.destroy();
+        conn.clientToServer.destroy();
       }
     },
     cleanup() {
       for (const conn of Object.values(connections.get())) {
-        conn.serverToClient.end();
-        conn.clientToServer.end();
+        conn.serverToClient.destroy();
+        conn.clientToServer.destroy();
       }
     }
   };