@replit/river 0.207.2 → 0.207.3

package/dist/{chunk-24EWYOGK.js → chunk-BO7MFCO6.js}

@@ -1,18 +1,114 @@
 import {
+  ControlMessageHandshakeRequestSchema,
+  ControlMessageHandshakeResponseSchema,
+  HandshakeErrorCustomHandlerFatalResponseCodes,
+  HandshakeErrorRetriableResponseCodes,
   OpaqueTransportMessageSchema,
+  acceptedProtocolVersions,
+  coerceErrorString,
   createConnectionTelemetryInfo,
   createSessionTelemetryInfo,
+  currentProtocolVersion,
   generateId,
+  getPropagationContext,
   getTracer,
+  handshakeRequestMessage,
+  handshakeResponseMessage,
+  isAcceptedProtocolVersion,
   isAck
-} from "./chunk-46IVOKJU.js";
+} from "./chunk-QGPYCXV4.js";
 import {
   BaseLogger,
   createLogProxy
 } from "./chunk-CC7RN7GI.js";
-import {
-  NaiveJsonCodec
-} from "./chunk-AJGIY2UB.js";
+
+// transport/events.ts
+var ProtocolError = {
+  RetriesExceeded: "conn_retry_exceeded",
+  HandshakeFailed: "handshake_failed",
+  MessageOrderingViolated: "message_ordering_violated",
+  InvalidMessage: "invalid_message",
+  MessageSendFailure: "message_send_failure"
+};
+var EventDispatcher = class {
+  eventListeners = {};
+  removeAllListeners() {
+    this.eventListeners = {};
+  }
+  numberOfListeners(eventType) {
+    return this.eventListeners[eventType]?.size ?? 0;
+  }
+  addEventListener(eventType, handler) {
+    if (!this.eventListeners[eventType]) {
+      this.eventListeners[eventType] = /* @__PURE__ */ new Set();
+    }
+    this.eventListeners[eventType]?.add(handler);
+  }
+  removeEventListener(eventType, handler) {
+    const handlers = this.eventListeners[eventType];
+    if (handlers) {
+      this.eventListeners[eventType]?.delete(handler);
+    }
+  }
+  dispatchEvent(eventType, event) {
+    const handlers = this.eventListeners[eventType];
+    if (handlers) {
+      const copy = [...handlers];
+      for (const handler of copy) {
+        handler(event);
+      }
+    }
+  }
+};
+
+// codec/json.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function uint8ArrayToBase64(uint8Array) {
+  let binary = "";
+  uint8Array.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary);
+}
+function base64ToUint8Array(base64) {
+  const binaryString = atob(base64);
+  const uint8Array = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    uint8Array[i] = binaryString.charCodeAt(i);
+  }
+  return uint8Array;
+}
+var NaiveJsonCodec = {
+  toBuffer: (obj) => {
+    return encoder.encode(
+      JSON.stringify(obj, function replacer(key) {
+        const val = this[key];
+        if (val instanceof Uint8Array) {
+          return { $t: uint8ArrayToBase64(val) };
+        } else {
+          return val;
+        }
+      })
+    );
+  },
+  fromBuffer: (buff) => {
+    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" || parsed === null) {
+      throw new Error("unpacked msg is not an object");
+    }
+    return parsed;
+  }
+};
 
 // transport/options.ts
 var defaultTransportOptions = {
@@ -40,7 +136,6 @@ var defaultServerTransportOptions = {
 };
 
 // transport/sessionStateMachine/common.ts
-import { Value } from "@sinclair/typebox/value";
 var SessionState = /* @__PURE__ */ ((SessionState2) => {
   SessionState2["NoConnection"] = "NoConnection";
   SessionState2["BackingOff"] = "BackingOff";
@@ -109,34 +204,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 (!Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
-      this.log?.error(`received invalid msg: ${JSON.stringify(parsedMsg)}`, {
-        ...this.loggingMetadata,
-        validationErrors: [
-          ...Value.Errors(OpaqueTransportMessageSchema, parsedMsg)
-        ]
-      });
-      return null;
-    }
-    return parsedMsg;
+    this.codec = codec;
   }
 };
 var IdentifiedSession = class extends CommonSession {
@@ -196,9 +273,6 @@ var IdentifiedSession = class extends CommonSession {
     return metadata;
   }
   constructMsg(partialMsg) {
-    if (this._isConsumed) {
-      throw new Error(ERR_CONSUMED);
-    }
     const msg = {
       ...partialMsg,
       id: generateId(),
@@ -216,7 +290,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() {
   }
@@ -248,6 +325,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 {
@@ -300,8 +394,8 @@ var SessionConnecting = class extends IdentifiedSessionWithGracePeriod {
     }
   }
   _handleClose() {
-    this.bestEffortClose();
     super._handleClose();
+    this.bestEffortClose();
   }
 };
 
@@ -341,18 +435,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);
@@ -390,18 +484,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();
@@ -426,25 +520,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) {
@@ -452,22 +536,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);
@@ -476,6 +560,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()}`,
@@ -483,30 +569,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 {
@@ -514,25 +585,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(
@@ -571,9 +663,7 @@ var SessionConnected = class extends IdentifiedSession {
       transportMessage: parsedMsg
     });
     if (!this.isActivelyHeartbeating) {
-      void Promise.resolve().then(() => {
-        this.sendHeartbeat();
-      });
+      this.sendHeartbeat();
     }
   };
   _handleStateExit() {
@@ -585,6 +675,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();
@@ -616,6 +710,62 @@ var SessionBackingOff = class extends IdentifiedSessionWithGracePeriod {
   }
 };
 
+// codec/binary.ts
+import { decode, encode } from "@msgpack/msgpack";
+var BinaryCodec = {
+  toBuffer(obj) {
+    return encode(obj, { ignoreUndefined: true });
+  },
+  fromBuffer: (buff) => {
+    const res = decode(buff);
+    if (typeof res !== "object" || res === null) {
+      throw new Error("unpacked msg is not an object");
+    }
+    return res;
+  }
+};
+
+// codec/adapter.ts
+import { Value } from "@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 (!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 {
@@ -630,7 +780,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) {
@@ -659,7 +810,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,
@@ -674,7 +826,8 @@ var SessionStateGraph = {
         from,
         options,
         tracer,
-        log
+        log,
+        codec: new CodecMessageAdapter(options.codec)
       });
       session.log?.info(`session created in WaitingForHandshake state`, {
         ...session.loggingMetadata,
@@ -752,6 +905,7 @@ var SessionStateGraph = {
         listeners,
         ...carriedState
       });
+      session.startMissingHeartbeatTimeout();
       session.log?.info(
         `session ${session.id} transition from Handshaking to Connected`,
         {
@@ -787,7 +941,8 @@ var SessionStateGraph = {
           options,
           tracer: pendingSession.tracer,
           log: pendingSession.log,
-          protocolVersion
+          protocolVersion,
+          codec: new CodecMessageAdapter(options.codec)
         }
       );
       pendingSession._handleStateExit();
@@ -797,6 +952,7 @@ var SessionStateGraph = {
         listeners,
         ...carriedState
       });
+      session.startMissingHeartbeatTimeout();
       conn.telemetry = createConnectionTelemetryInfo(
         session.tracer,
         conn,
@@ -927,44 +1083,6 @@ var ServerSessionStateGraph = {
   }
 };
 
-// transport/events.ts
-var ProtocolError = {
-  RetriesExceeded: "conn_retry_exceeded",
-  HandshakeFailed: "handshake_failed",
-  MessageOrderingViolated: "message_ordering_violated",
-  InvalidMessage: "invalid_message"
-};
-var EventDispatcher = class {
-  eventListeners = {};
-  removeAllListeners() {
-    this.eventListeners = {};
-  }
-  numberOfListeners(eventType) {
-    return this.eventListeners[eventType]?.size ?? 0;
-  }
-  addEventListener(eventType, handler) {
-    if (!this.eventListeners[eventType]) {
-      this.eventListeners[eventType] = /* @__PURE__ */ new Set();
-    }
-    this.eventListeners[eventType]?.add(handler);
-  }
-  removeEventListener(eventType, handler) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      this.eventListeners[eventType]?.delete(handler);
-    }
-  }
-  dispatchEvent(eventType, event) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      const copy = [...handlers];
-      for (const handler of copy) {
-        handler(event);
-      }
-    }
-  }
-};
-
 // transport/transport.ts
 var Transport = class {
   /**
@@ -1175,13 +1293,886 @@ 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
+import { SpanStatusCode as SpanStatusCode2 } from "@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
+import { Value as Value2 } from "@sinclair/typebox/value";
+var ClientTransport = class extends Transport {
+  /**
+   * The options for this transport.
+   */
+  options;
+  retryBudget;
+  /**
+   * A flag indicating whether the transport should automatically reconnect
+   * when a connection is dropped.
+   * Realistically, this should always be true for clients unless you are writing
+   * tests or a special case where you don't want to reconnect.
+   */
+  reconnectOnConnectionDrop = true;
+  /**
+   * Optional handshake options for this client.
+   */
+  handshakeExtensions;
+  sessions;
+  constructor(clientId, providedOptions) {
+    super(clientId, providedOptions);
+    this.sessions = /* @__PURE__ */ new Map();
+    this.options = {
+      ...defaultClientTransportOptions,
+      ...providedOptions
+    };
+    this.retryBudget = new LeakyBucketRateLimit(this.options);
+  }
+  extendHandshake(options) {
+    this.handshakeExtensions = options;
+  }
+  tryReconnecting(to) {
+    const oldSession = this.sessions.get(to);
+    if (!this.options.enableTransparentSessionReconnects && oldSession) {
+      this.deleteSession(oldSession);
+    }
+    if (this.reconnectOnConnectionDrop && this.getStatus() === "open") {
+      this.connect(to);
+    }
+  }
+  /*
+   * Creates a raw unconnected session object.
+   * This is mostly a River internal, you shouldn't need to use this directly.
+   */
+  createUnconnectedSession(to) {
+    const session = ClientSessionStateGraph.entrypoint(
+      to,
+      this.clientId,
+      {
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(session);
+        }
+      },
+      this.options,
+      currentProtocolVersion,
+      this.tracer,
+      this.log
+    );
+    this.createSession(session);
+    return session;
+  }
+  // listeners
+  onConnectingFailed(session) {
+    const noConnectionSession = super.onConnectingFailed(session);
+    this.tryReconnecting(noConnectionSession.to);
+    return noConnectionSession;
+  }
+  onConnClosed(session) {
+    const noConnectionSession = super.onConnClosed(session);
+    this.tryReconnecting(noConnectionSession.to);
+    return noConnectionSession;
+  }
+  onConnectionEstablished(session, conn) {
+    const handshakingSession = ClientSessionStateGraph.transition.ConnectingToHandshaking(
+      session,
+      conn,
+      {
+        onConnectionErrored: (err) => {
+          const errStr = coerceErrorString(err);
+          this.log?.error(
+            `connection to ${handshakingSession.to} errored during handshake: ${errStr}`,
+            handshakingSession.loggingMetadata
+          );
+        },
+        onConnectionClosed: () => {
+          this.log?.warn(
+            `connection to ${handshakingSession.to} closed during handshake`,
+            handshakingSession.loggingMetadata
+          );
+          this.onConnClosed(handshakingSession);
+        },
+        onHandshake: (msg) => {
+          this.onHandshakeResponse(handshakingSession, msg);
+        },
+        onInvalidHandshake: (reason, code) => {
+          this.log?.error(
+            `invalid handshake: ${reason}`,
+            handshakingSession.loggingMetadata
+          );
+          this.deleteSession(session, { unhealthy: true });
+          this.protocolError({
+            type: ProtocolError.HandshakeFailed,
+            code,
+            message: reason
+          });
+        },
+        onHandshakeTimeout: () => {
+          this.log?.error(
+            `connection to ${handshakingSession.to} timed out during handshake`,
+            handshakingSession.loggingMetadata
+          );
+          this.onConnClosed(handshakingSession);
+        },
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(handshakingSession);
+        }
+      }
+    );
+    this.updateSession(handshakingSession);
+    void this.sendHandshake(handshakingSession);
+    return handshakingSession;
+  }
+  rejectHandshakeResponse(session, reason, metadata) {
+    session.conn.telemetry?.span.setStatus({
+      code: SpanStatusCode2.ERROR,
+      message: reason
+    });
+    this.log?.warn(reason, metadata);
+    this.deleteSession(session, { unhealthy: true });
+  }
+  onHandshakeResponse(session, msg) {
+    if (!Value2.Check(ControlMessageHandshakeResponseSchema, msg.payload)) {
+      const reason = `received invalid handshake response`;
+      this.rejectHandshakeResponse(session, reason, {
+        ...session.loggingMetadata,
+        transportMessage: msg,
+        validationErrors: [
+          ...Value2.Errors(ControlMessageHandshakeResponseSchema, msg.payload)
+        ]
+      });
+      return;
+    }
+    if (!msg.payload.status.ok) {
+      const retriable = Value2.Check(
+        HandshakeErrorRetriableResponseCodes,
+        msg.payload.status.code
+      );
+      const reason = `handshake failed: ${msg.payload.status.reason}`;
+      const to = session.to;
+      this.rejectHandshakeResponse(session, reason, {
+        ...session.loggingMetadata,
+        transportMessage: msg
+      });
+      if (retriable) {
+        this.tryReconnecting(to);
+      } else {
+        this.protocolError({
+          type: ProtocolError.HandshakeFailed,
+          code: msg.payload.status.code,
+          message: reason
+        });
+      }
+      return;
+    }
+    if (msg.payload.status.sessionId !== session.id) {
+      const reason = `session id mismatch: expected ${session.id}, got ${msg.payload.status.sessionId}`;
+      this.rejectHandshakeResponse(session, reason, {
+        ...session.loggingMetadata,
+        transportMessage: msg
+      });
+      return;
+    }
+    this.log?.info(`handshake from ${msg.from} ok`, {
+      ...session.loggingMetadata,
+      transportMessage: msg
+    });
+    const connectedSession = ClientSessionStateGraph.transition.HandshakingToConnected(session, {
+      onConnectionErrored: (err) => {
+        const errStr = coerceErrorString(err);
+        this.log?.warn(
+          `connection to ${connectedSession.to} errored: ${errStr}`,
+          connectedSession.loggingMetadata
+        );
+      },
+      onConnectionClosed: () => {
+        this.log?.info(
+          `connection to ${connectedSession.to} closed`,
+          connectedSession.loggingMetadata
+        );
+        this.onConnClosed(connectedSession);
+      },
+      onMessage: (msg2) => {
+        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 });
+      }
+    });
+    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();
+  }
+  /**
+   * Manually attempts to connect to a client.
+   * @param to The client ID of the node to connect to.
+   */
+  connect(to) {
+    if (this.getStatus() !== "open") {
+      this.log?.info(
+        `transport state is no longer open, cancelling attempt to connect to ${to}`
+      );
+      return;
+    }
+    const session = this.sessions.get(to) ?? this.createUnconnectedSession(to);
+    if (session.state !== "NoConnection" /* NoConnection */) {
+      this.log?.debug(
+        `session to ${to} has state ${session.state}, skipping connect attempt`,
+        session.loggingMetadata
+      );
+      return;
+    }
+    if (!this.retryBudget.hasBudget()) {
+      const budgetConsumed = this.retryBudget.getBudgetConsumed();
+      const errMsg = `tried to connect to ${to} but retry budget exceeded (more than ${budgetConsumed} attempts in the last ${this.retryBudget.totalBudgetRestoreTime}ms)`;
+      this.log?.error(errMsg, session.loggingMetadata);
+      this.protocolError({
+        type: ProtocolError.RetriesExceeded,
+        message: errMsg
+      });
+      return;
+    }
+    const backoffMs = this.retryBudget.getBackoffMs();
+    this.log?.info(
+      `attempting connection to ${to} (${backoffMs}ms backoff)`,
+      session.loggingMetadata
+    );
+    this.retryBudget.consumeBudget();
+    const backingOffSession = ClientSessionStateGraph.transition.NoConnectionToBackingOff(
+      session,
+      backoffMs,
+      {
+        onBackoffFinished: () => {
+          this.onBackoffFinished(backingOffSession);
+        },
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(backingOffSession);
+        }
+      }
+    );
+    this.updateSession(backingOffSession);
+  }
+  /**
+   * Manually kills all sessions to the server (including all pending state).
+   * This is useful for when you want to close all connections to a server
+   * and don't want to wait for the grace period to elapse.
+   */
+  hardDisconnect() {
+    const sessions = Array.from(this.sessions.values());
+    for (const session of sessions) {
+      this.deleteSession(session);
+    }
+  }
+  onBackoffFinished(session) {
+    const connPromise = session.tracer.startActiveSpan(
+      "connect",
+      async (span) => {
+        try {
+          return await this.createNewOutgoingConnection(session.to);
+        } catch (err) {
+          const errStr = coerceErrorString(err);
+          span.recordException(errStr);
+          span.setStatus({ code: SpanStatusCode2.ERROR });
+          throw err;
+        } finally {
+          span.end();
+        }
+      }
+    );
+    const connectingSession = ClientSessionStateGraph.transition.BackingOffToConnecting(
+      session,
+      connPromise,
+      {
+        onConnectionEstablished: (conn) => {
+          this.log?.debug(
+            `connection to ${connectingSession.to} established`,
+            {
+              ...conn.loggingMetadata,
+              ...connectingSession.loggingMetadata
+            }
+          );
+          this.onConnectionEstablished(connectingSession, conn);
+        },
+        onConnectionFailed: (error) => {
+          const errStr = coerceErrorString(error);
+          this.log?.error(
+            `error connecting to ${connectingSession.to}: ${errStr}`,
+            connectingSession.loggingMetadata
+          );
+          this.onConnectingFailed(connectingSession);
+        },
+        onConnectionTimeout: () => {
+          this.log?.error(
+            `connection to ${connectingSession.to} timed out`,
+            connectingSession.loggingMetadata
+          );
+          this.onConnectingFailed(connectingSession);
+        },
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(connectingSession);
+        }
+      }
+    );
+    this.updateSession(connectingSession);
+  }
+  async sendHandshake(session) {
+    let metadata = void 0;
+    if (this.handshakeExtensions) {
+      metadata = await this.handshakeExtensions.construct();
+    }
+    if (session._isConsumed) {
+      return;
+    }
+    const requestMsg = handshakeRequestMessage({
+      from: this.clientId,
+      to: session.to,
+      sessionId: session.id,
+      expectedSessionState: {
+        nextExpectedSeq: session.ack,
+        nextSentSeq: session.nextSeq()
+      },
+      metadata,
+      tracing: getPropagationContext(session.telemetry.ctx)
+    });
+    this.log?.debug(`sending handshake request to ${session.to}`, {
+      ...session.loggingMetadata,
+      transportMessage: 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();
+    super.close();
+  }
+};
+
+// transport/server.ts
+import { SpanStatusCode as SpanStatusCode3 } from "@opentelemetry/api";
+import { Value as Value3 } from "@sinclair/typebox/value";
+var ServerTransport = class extends Transport {
+  /**
+   * The options for this transport.
+   */
+  options;
+  /**
+   * Optional handshake options for the server.
+   */
+  handshakeExtensions;
+  /**
+   * A map of session handshake data for each session.
+   */
+  sessionHandshakeMetadata = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  pendingSessions = /* @__PURE__ */ new Set();
+  constructor(clientId, providedOptions) {
+    super(clientId, providedOptions);
+    this.sessions = /* @__PURE__ */ new Map();
+    this.options = {
+      ...defaultServerTransportOptions,
+      ...providedOptions
     };
+    this.log?.info(`initiated server transport`, {
+      clientId: this.clientId,
+      protocolVersion: currentProtocolVersion
+    });
+  }
+  extendHandshake(options) {
+    this.handshakeExtensions = options;
+  }
+  deletePendingSession(pendingSession) {
+    pendingSession.close();
+    this.pendingSessions.delete(pendingSession);
+  }
+  deleteSession(session, options) {
+    this.sessionHandshakeMetadata.delete(session.to);
+    super.deleteSession(session, options);
+  }
+  handleConnection(conn) {
+    if (this.getStatus() !== "open")
+      return;
+    this.log?.info(`new incoming connection`, {
+      ...conn.loggingMetadata,
+      clientId: this.clientId
+    });
+    let receivedHandshake = false;
+    const pendingSession = ServerSessionStateGraph.entrypoint(
+      this.clientId,
+      conn,
+      {
+        onConnectionClosed: () => {
+          this.log?.warn(
+            `connection from unknown closed before handshake finished`,
+            pendingSession.loggingMetadata
+          );
+          this.deletePendingSession(pendingSession);
+        },
+        onConnectionErrored: (err) => {
+          const errorString = coerceErrorString(err);
+          this.log?.warn(
+            `connection from unknown errored before handshake finished: ${errorString}`,
+            pendingSession.loggingMetadata
+          );
+          this.deletePendingSession(pendingSession);
+        },
+        onHandshakeTimeout: () => {
+          this.log?.warn(
+            `connection from unknown timed out before handshake finished`,
+            pendingSession.loggingMetadata
+          );
+          this.deletePendingSession(pendingSession);
+        },
+        onHandshake: (msg) => {
+          if (receivedHandshake) {
+            this.log?.error(
+              `received multiple handshake messages from pending session`,
+              {
+                ...pendingSession.loggingMetadata,
+                connectedTo: msg.from,
+                transportMessage: msg
+              }
+            );
+            this.deletePendingSession(pendingSession);
+            return;
+          }
+          receivedHandshake = true;
+          void this.onHandshakeRequest(pendingSession, msg);
+        },
+        onInvalidHandshake: (reason, code) => {
+          this.log?.error(
+            `invalid handshake: ${reason}`,
+            pendingSession.loggingMetadata
+          );
+          this.deletePendingSession(pendingSession);
+          this.protocolError({
+            type: ProtocolError.HandshakeFailed,
+            code,
+            message: reason
+          });
+        }
+      },
+      this.options,
+      this.tracer,
+      this.log
+    );
+    this.pendingSessions.add(pendingSession);
+  }
+  rejectHandshakeRequest(session, to, reason, code, metadata) {
+    session.conn.telemetry?.span.setStatus({
+      code: SpanStatusCode3.ERROR,
+      message: reason
+    });
+    this.log?.warn(reason, metadata);
+    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,
+      message: reason
+    });
+    this.deletePendingSession(session);
+  }
+  async onHandshakeRequest(session, msg) {
+    if (!Value3.Check(ControlMessageHandshakeRequestSchema, msg.payload)) {
+      this.rejectHandshakeRequest(
+        session,
+        msg.from,
+        "received invalid handshake request",
+        "MALFORMED_HANDSHAKE",
+        {
+          ...session.loggingMetadata,
+          transportMessage: msg,
+          connectedTo: msg.from,
+          validationErrors: [
+            ...Value3.Errors(ControlMessageHandshakeRequestSchema, msg.payload)
+          ]
+        }
+      );
+      return;
+    }
+    const gotVersion = msg.payload.protocolVersion;
+    if (!isAcceptedProtocolVersion(gotVersion)) {
+      this.rejectHandshakeRequest(
+        session,
+        msg.from,
+        `expected protocol version oneof [${acceptedProtocolVersions.toString()}], got ${gotVersion}`,
+        "PROTOCOL_VERSION_MISMATCH",
+        {
+          ...session.loggingMetadata,
+          connectedTo: msg.from,
+          transportMessage: msg
+        }
+      );
+      return;
+    }
+    let parsedMetadata = {};
+    if (this.handshakeExtensions) {
+      if (!Value3.Check(this.handshakeExtensions.schema, msg.payload.metadata)) {
+        this.rejectHandshakeRequest(
+          session,
+          msg.from,
+          "received malformed handshake metadata",
+          "MALFORMED_HANDSHAKE_META",
+          {
+            ...session.loggingMetadata,
+            connectedTo: msg.from,
+            validationErrors: [
+              ...Value3.Errors(
+                this.handshakeExtensions.schema,
+                msg.payload.metadata
+              )
+            ]
+          }
+        );
+        return;
+      }
+      const previousParsedMetadata = this.sessionHandshakeMetadata.get(
+        msg.from
+      );
+      const parsedMetadataOrFailureCode = await this.handshakeExtensions.validate(
+        msg.payload.metadata,
+        previousParsedMetadata
+      );
+      if (session._isConsumed) {
+        return;
+      }
+      if (Value3.Check(
+        HandshakeErrorCustomHandlerFatalResponseCodes,
+        parsedMetadataOrFailureCode
+      )) {
+        this.rejectHandshakeRequest(
+          session,
+          msg.from,
+          "rejected by handshake handler",
+          parsedMetadataOrFailureCode,
+          {
+            ...session.loggingMetadata,
+            connectedTo: msg.from,
+            clientId: this.clientId
+          }
+        );
+        return;
+      }
+      parsedMetadata = parsedMetadataOrFailureCode;
+    }
+    let connectCase = "new session";
+    const clientNextExpectedSeq = msg.payload.expectedSessionState.nextExpectedSeq;
+    const clientNextSentSeq = msg.payload.expectedSessionState.nextSentSeq;
+    let oldSession = this.sessions.get(msg.from);
+    if (this.options.enableTransparentSessionReconnects && oldSession && oldSession.id === msg.payload.sessionId) {
+      connectCase = "transparent reconnection";
+      const ourNextSeq = oldSession.nextSeq();
+      const ourAck = oldSession.ack;
+      if (clientNextSentSeq > ourAck) {
+        this.rejectHandshakeRequest(
+          session,
+          msg.from,
+          `client is in the future: server wanted next message to be ${ourAck} but client would have sent ${clientNextSentSeq}`,
+          "SESSION_STATE_MISMATCH",
+          {
+            ...session.loggingMetadata,
+            connectedTo: msg.from,
+            transportMessage: msg
+          }
+        );
+        return;
+      }
+      if (ourNextSeq > clientNextExpectedSeq) {
+        this.rejectHandshakeRequest(
+          session,
+          msg.from,
+          `server is in the future: client wanted next message to be ${clientNextExpectedSeq} but server would have sent ${ourNextSeq}`,
+          "SESSION_STATE_MISMATCH",
+          {
+            ...session.loggingMetadata,
+            connectedTo: msg.from,
+            transportMessage: msg
+          }
+        );
+        return;
+      }
+      if (oldSession.state !== "NoConnection" /* NoConnection */) {
+        const noConnectionSession = ServerSessionStateGraph.transition.ConnectedToNoConnection(
+          oldSession,
+          {
+            onSessionGracePeriodElapsed: () => {
+              this.onSessionGracePeriodElapsed(noConnectionSession);
+            }
+          }
+        );
+        oldSession = noConnectionSession;
+        this.updateSession(oldSession);
+      }
+    } else if (oldSession) {
+      connectCase = "hard reconnection";
+      this.log?.info(
+        `client is reconnecting to a new session (${msg.payload.sessionId}) with an old session (${oldSession.id}) already existing, closing old session`,
+        {
+          ...session.loggingMetadata,
+          connectedTo: msg.from,
+          sessionId: msg.payload.sessionId
+        }
+      );
+      this.deleteSession(oldSession);
+      oldSession = void 0;
+    }
+    if (!oldSession && (clientNextSentSeq > 0 || clientNextExpectedSeq > 0)) {
+      connectCase = "unknown session";
+      const rejectionMessage = this.options.enableTransparentSessionReconnects ? `client is trying to reconnect to a session the server don't know about: ${msg.payload.sessionId}` : `client is attempting a transparent reconnect to a session but the server does not support it: ${msg.payload.sessionId}`;
+      this.rejectHandshakeRequest(
+        session,
+        msg.from,
+        rejectionMessage,
+        "SESSION_STATE_MISMATCH",
+        {
+          ...session.loggingMetadata,
+          connectedTo: msg.from,
+          transportMessage: msg
+        }
+      );
+      return;
+    }
+    const sessionId = msg.payload.sessionId;
+    this.log?.info(
+      `handshake from ${msg.from} ok (${connectCase}), responding with handshake success`,
+      {
+        ...session.loggingMetadata,
+        connectedTo: msg.from
+      }
+    );
+    const responseMsg = handshakeResponseMessage({
+      from: this.clientId,
+      to: msg.from,
+      status: {
+        ok: true,
+        sessionId
+      }
+    });
+    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
+      oldSession,
+      sessionId,
+      msg.from,
+      msg.tracing,
+      {
+        onConnectionErrored: (err) => {
+          const errStr = coerceErrorString(err);
+          this.log?.warn(
+            `connection to ${connectedSession.to} errored: ${errStr}`,
+            connectedSession.loggingMetadata
+          );
+        },
+        onConnectionClosed: () => {
+          this.log?.info(
+            `connection to ${connectedSession.to} closed`,
+            connectedSession.loggingMetadata
+          );
+          this.onConnClosed(connectedSession);
+        },
+        onMessage: (msg2) => {
+          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);
+    }
+    connectedSession.startActiveHeartbeat();
   }
 };
 
@@ -1273,15 +2264,17 @@ var Connection = class {
 };
 
 export {
+  BinaryCodec,
+  NaiveJsonCodec,
+  ProtocolError,
   defaultTransportOptions,
   defaultClientTransportOptions,
-  defaultServerTransportOptions,
   SessionState,
   SessionStateGraph,
-  ClientSessionStateGraph,
-  ServerSessionStateGraph,
-  ProtocolError,
   Transport,
-  Connection
+  ClientTransport,
+  ServerTransport,
+  Connection,
+  CodecMessageAdapter
 };
-//# sourceMappingURL=chunk-24EWYOGK.js.map
+//# sourceMappingURL=chunk-BO7MFCO6.js.map