@replit/river 0.200.0-rc.2 → 0.200.0-rc.4

package/dist/util/testHelpers.cjs

@@ -34,13 +34,16 @@ __export(testHelpers_exports, {
   asClientStream: () => asClientStream,
   asClientSubscription: () => asClientSubscription,
   asClientUpload: () => asClientUpload,
+  closeAllConnections: () => closeAllConnections,
   createDummyTransportMessage: () => createDummyTransportMessage,
   createLocalWebSocketClient: () => createLocalWebSocketClient,
   createWebSocketServer: () => createWebSocketServer,
   dummySession: () => dummySession,
   getIteratorFromStream: () => getIteratorFromStream,
+  getTransportConnections: () => getTransportConnections,
   getUnixSocketPath: () => getUnixSocketPath,
   iterNext: () => iterNext,
+  numberOfConnections: () => numberOfConnections,
   onUdsServeReady: () => onUdsServeReady,
   onWsServerReady: () => onWsServerReady,
   payloadToTransportMessage: () => payloadToTransportMessage,
@@ -376,23 +379,120 @@ var InputReaderErrorSchema = import_typebox2.Type.Object({
   message: import_typebox2.Type.String()
 });
 
+// transport/message.ts
+var import_typebox3 = require("@sinclair/typebox");
+
+// transport/id.ts
+var import_nanoid = require("nanoid");
+var alphabet = (0, import_nanoid.customAlphabet)(
+  "1234567890abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ"
+);
+var generateId = () => alphabet(12);
+
+// transport/message.ts
+var TransportMessageSchema = (t) => import_typebox3.Type.Object({
+  id: import_typebox3.Type.String(),
+  from: import_typebox3.Type.String(),
+  to: import_typebox3.Type.String(),
+  seq: import_typebox3.Type.Integer(),
+  ack: import_typebox3.Type.Integer(),
+  serviceName: import_typebox3.Type.Optional(import_typebox3.Type.String()),
+  procedureName: import_typebox3.Type.Optional(import_typebox3.Type.String()),
+  streamId: import_typebox3.Type.String(),
+  controlFlags: import_typebox3.Type.Integer(),
+  tracing: import_typebox3.Type.Optional(
+    import_typebox3.Type.Object({
+      traceparent: import_typebox3.Type.String(),
+      tracestate: import_typebox3.Type.String()
+    })
+  ),
+  payload: t
+});
+var ControlMessageAckSchema = import_typebox3.Type.Object({
+  type: import_typebox3.Type.Literal("ACK")
+});
+var ControlMessageCloseSchema = import_typebox3.Type.Object({
+  type: import_typebox3.Type.Literal("CLOSE")
+});
+var currentProtocolVersion = "v2.0";
+var ControlMessageHandshakeRequestSchema = import_typebox3.Type.Object({
+  type: import_typebox3.Type.Literal("HANDSHAKE_REQ"),
+  protocolVersion: import_typebox3.Type.String(),
+  sessionId: import_typebox3.Type.String(),
+  /**
+   * Specifies what the server's expected session state (from the pov of the client). This can be
+   * used by the server to know whether this is a new or a reestablished connection, and whether it
+   * is compatible with what it already has.
+   */
+  expectedSessionState: import_typebox3.Type.Object({
+    // what the client expects the server to send next
+    nextExpectedSeq: import_typebox3.Type.Integer(),
+    // TODO: remove optional once we know all servers
+    // are nextSentSeq here
+    // what the server expects the client to send next
+    nextSentSeq: import_typebox3.Type.Optional(import_typebox3.Type.Integer())
+  }),
+  metadata: import_typebox3.Type.Optional(import_typebox3.Type.Unknown())
+});
+var HandshakeErrorRetriableResponseCodes = import_typebox3.Type.Union([
+  import_typebox3.Type.Literal("SESSION_STATE_MISMATCH")
+]);
+var HandshakeErrorFatalResponseCodes = import_typebox3.Type.Union([
+  import_typebox3.Type.Literal("MALFORMED_HANDSHAKE_META"),
+  import_typebox3.Type.Literal("MALFORMED_HANDSHAKE"),
+  import_typebox3.Type.Literal("PROTOCOL_VERSION_MISMATCH"),
+  import_typebox3.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
+]);
+var HandshakeErrorResponseCodes = import_typebox3.Type.Union([
+  HandshakeErrorRetriableResponseCodes,
+  HandshakeErrorFatalResponseCodes
+]);
+var ControlMessageHandshakeResponseSchema = import_typebox3.Type.Object({
+  type: import_typebox3.Type.Literal("HANDSHAKE_RESP"),
+  status: import_typebox3.Type.Union([
+    import_typebox3.Type.Object({
+      ok: import_typebox3.Type.Literal(true),
+      sessionId: import_typebox3.Type.String()
+    }),
+    import_typebox3.Type.Object({
+      ok: import_typebox3.Type.Literal(false),
+      reason: import_typebox3.Type.String(),
+      // TODO: remove optional once we know all servers
+      // are sending code here
+      code: import_typebox3.Type.Optional(HandshakeErrorResponseCodes)
+    })
+  ])
+});
+var ControlMessagePayloadSchema = import_typebox3.Type.Union([
+  ControlMessageCloseSchema,
+  ControlMessageAckSchema,
+  ControlMessageHandshakeRequestSchema,
+  ControlMessageHandshakeResponseSchema
+]);
+var OpaqueTransportMessageSchema = TransportMessageSchema(
+  import_typebox3.Type.Unknown()
+);
+function isAck(controlFlag) {
+  return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
+}
+
 // tracing/index.ts
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.200.0-rc.2";
+var version = "0.200.0-rc.4";
 
 // tracing/index.ts
-function createSessionTelemetryInfo(session, propagationCtx) {
+function createSessionTelemetryInfo(sessionId, to, from, propagationCtx) {
   const parentCtx = propagationCtx ? import_api.propagation.extract(import_api.context.active(), propagationCtx) : import_api.context.active();
   const span = tracer.startSpan(
-    `session ${session.id}`,
+    `session ${sessionId}`,
     {
       attributes: {
         component: "river",
-        "river.session.id": session.id,
-        "river.session.to": session.to,
-        "river.session.from": session.from
+        "river.session.id": sessionId,
+        "river.session.to": to,
+        "river.session.from": from
       }
     },
     parentCtx
@@ -413,298 +513,6 @@ function coerceErrorString(err) {
 // util/testHelpers.ts
 var import_nanoid2 = require("nanoid");
 
-// transport/session.ts
-var import_nanoid = require("nanoid");
-var import_api2 = require("@opentelemetry/api");
-var nanoid = (0, import_nanoid.customAlphabet)("1234567890abcdefghijklmnopqrstuvxyz", 6);
-var unsafeId = () => nanoid();
-var Session = class {
-  codec;
-  options;
-  telemetry;
-  /**
-   * The buffer of messages that have been sent but not yet acknowledged.
-   */
-  sendBuffer = [];
-  /**
-   * The active connection associated with this session
-   */
-  connection;
-  /**
-   * A connection that is currently undergoing handshaking. Used to distinguish between the active
-   * connection, but still be able to close it if needed.
-   */
-  handshakingConnection;
-  from;
-  to;
-  /**
-   * The unique ID of this session.
-   */
-  id;
-  /**
-   * What the other side advertised as their session ID
-   * for this session.
-   */
-  advertisedSessionId;
-  /**
-   * Number of messages we've sent along this session (excluding handshake and acks)
-   */
-  seq = 0;
-  /**
-   * Number of unique messages we've received this session (excluding handshake and acks)
-   */
-  ack = 0;
-  /**
-   * The grace period between when the inner connection is disconnected
-   * and when we should consider the entire session disconnected.
-   */
-  disconnectionGrace;
-  /**
-   * Number of heartbeats we've sent without a response.
-   */
-  heartbeatMisses;
-  /**
-   * The interval for sending heartbeats.
-   */
-  heartbeat;
-  log;
-  constructor(conn, from, to, options, propagationCtx) {
-    this.id = `session-${nanoid(12)}`;
-    this.options = options;
-    this.from = from;
-    this.to = to;
-    this.connection = conn;
-    this.codec = options.codec;
-    this.heartbeatMisses = 0;
-    this.heartbeat = setInterval(
-      () => this.sendHeartbeat(),
-      options.heartbeatIntervalMs
-    );
-    this.telemetry = createSessionTelemetryInfo(this, propagationCtx);
-  }
-  bindLogger(log) {
-    this.log = log;
-  }
-  get loggingMetadata() {
-    const spanContext = this.telemetry.span.spanContext();
-    return {
-      clientId: this.from,
-      connectedTo: this.to,
-      sessionId: this.id,
-      connId: this.connection?.id,
-      telemetry: {
-        traceId: spanContext.traceId,
-        spanId: spanContext.spanId
-      }
-    };
-  }
-  /**
-   * Sends a message over the session's connection.
-   * If the connection is not ready or the message fails to send, the message can be buffered for retry unless skipped.
-   *
-   * @param msg The partial message to be sent, which will be constructed into a full message.
-   * @param addToSendBuff Whether to add the message to the send buffer for retry.
-   * @returns The full transport ID of the message that was attempted to be sent.
-   */
-  send(msg) {
-    const fullMsg = this.constructMsg(msg);
-    this.log?.debug(`sending msg`, {
-      ...this.loggingMetadata,
-      transportMessage: fullMsg
-    });
-    if (this.connection) {
-      const ok = this.connection.send(this.codec.toBuffer(fullMsg));
-      if (ok)
-        return fullMsg.id;
-      this.log?.info(
-        `failed to send msg to ${fullMsg.to}, connection is probably dead`,
-        {
-          ...this.loggingMetadata,
-          transportMessage: fullMsg
-        }
-      );
-    } else {
-      this.log?.debug(
-        `buffering msg to ${fullMsg.to}, connection not ready yet`,
-        { ...this.loggingMetadata, transportMessage: fullMsg }
-      );
-    }
-    return fullMsg.id;
-  }
-  sendHeartbeat() {
-    const misses = this.heartbeatMisses;
-    const missDuration = misses * this.options.heartbeatIntervalMs;
-    if (misses > this.options.heartbeatsUntilDead) {
-      if (this.connection) {
-        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.closeStaleConnection();
-      }
-      return;
-    }
-    this.send({
-      streamId: "heartbeat",
-      controlFlags: 1 /* AckBit */,
-      payload: {
-        type: "ACK"
-      }
-    });
-    this.heartbeatMisses++;
-  }
-  resetBufferedMessages() {
-    this.sendBuffer = [];
-    this.seq = 0;
-    this.ack = 0;
-  }
-  sendBufferedMessages(conn) {
-    this.log?.info(`resending ${this.sendBuffer.length} buffered messages`, {
-      ...this.loggingMetadata,
-      connId: conn.id
-    });
-    for (const msg of this.sendBuffer) {
-      this.log?.debug(`resending msg`, {
-        ...this.loggingMetadata,
-        transportMessage: msg,
-        connId: conn.id
-      });
-      const ok = conn.send(this.codec.toBuffer(msg));
-      if (!ok) {
-        const errMsg = `failed to send buffered message to ${this.to} (sus, this is a fresh connection)`;
-        conn.telemetry?.span.setStatus({
-          code: import_api2.SpanStatusCode.ERROR,
-          message: errMsg
-        });
-        this.log?.error(errMsg, {
-          ...this.loggingMetadata,
-          transportMessage: msg,
-          connId: conn.id,
-          tags: ["invariant-violation"]
-        });
-        conn.close();
-        return;
-      }
-    }
-  }
-  updateBookkeeping(ack, seq) {
-    if (seq + 1 < this.ack) {
-      this.log?.error(`received stale seq ${seq} + 1 < ${this.ack}`, {
-        ...this.loggingMetadata,
-        tags: ["invariant-violation"]
-      });
-      return;
-    }
-    this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq >= ack);
-    this.ack = seq + 1;
-  }
-  closeStaleConnection(conn) {
-    if (this.connection === void 0 || this.connection === conn)
-      return;
-    this.log?.info(
-      `closing old inner connection from session to ${this.to}`,
-      this.loggingMetadata
-    );
-    this.connection.close();
-    this.connection = void 0;
-  }
-  replaceWithNewConnection(newConn, isTransparentReconnect) {
-    this.closeStaleConnection(newConn);
-    this.cancelGrace();
-    if (isTransparentReconnect) {
-      this.sendBufferedMessages(newConn);
-    }
-    this.connection = newConn;
-    this.handshakingConnection = void 0;
-  }
-  replaceWithNewHandshakingConnection(newConn) {
-    this.handshakingConnection = newConn;
-  }
-  beginGrace(cb) {
-    this.log?.info(
-      `starting ${this.options.sessionDisconnectGraceMs}ms grace period until session to ${this.to} is closed`,
-      this.loggingMetadata
-    );
-    this.cancelGrace();
-    this.disconnectionGrace = setTimeout(() => {
-      this.log?.info(
-        `grace period for ${this.to} elapsed`,
-        this.loggingMetadata
-      );
-      cb();
-    }, this.options.sessionDisconnectGraceMs);
-  }
-  // called on reconnect of the underlying session
-  cancelGrace() {
-    this.heartbeatMisses = 0;
-    clearTimeout(this.disconnectionGrace);
-    this.disconnectionGrace = void 0;
-  }
-  /**
-   * Used to close the handshaking connection, if set.
-   */
-  closeHandshakingConnection(expectedHandshakingConn) {
-    if (this.handshakingConnection === void 0)
-      return;
-    if (expectedHandshakingConn !== void 0 && this.handshakingConnection === expectedHandshakingConn) {
-      return;
-    }
-    this.handshakingConnection.close();
-    this.handshakingConnection = void 0;
-  }
-  // closed when we want to discard the whole session
-  // (i.e. shutdown or session disconnect)
-  close() {
-    this.closeStaleConnection();
-    this.cancelGrace();
-    this.resetBufferedMessages();
-    clearInterval(this.heartbeat);
-  }
-  get connected() {
-    return this.connection !== void 0;
-  }
-  get nextExpectedAck() {
-    return this.seq;
-  }
-  get nextExpectedSeq() {
-    return this.ack;
-  }
-  /**
-   * Check that the peer's next expected seq number matches something that is in our send buffer
-   * _or_ matches our actual next seq.
-   */
-  nextExpectedSeqInRange(nextExpectedSeq) {
-    for (const msg of this.sendBuffer) {
-      if (nextExpectedSeq === msg.seq) {
-        return true;
-      }
-    }
-    return nextExpectedSeq === this.seq;
-  }
-  // This is only used in tests to make the session misbehave.
-  /* @internal */
-  advanceAckForTesting(by) {
-    this.ack += by;
-  }
-  constructMsg(partialMsg) {
-    const msg = {
-      ...partialMsg,
-      id: unsafeId(),
-      to: this.to,
-      from: this.from,
-      seq: this.seq,
-      ack: this.ack
-    };
-    this.seq++;
-    this.sendBuffer.push(msg);
-    return msg;
-  }
-  inspectSendBuffer() {
-    return this.sendBuffer;
-  }
-};
-
 // codec/json.ts
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
@@ -762,6 +570,8 @@ var defaultTransportOptions = {
   heartbeatIntervalMs: 1e3,
   heartbeatsUntilDead: 2,
   sessionDisconnectGraceMs: 5e3,
+  connectionTimeoutMs: 2e3,
+  handshakeTimeoutMs: 1e3,
   codec: NaiveJsonCodec
 };
 var defaultConnectionRetryOptions = {
@@ -779,6 +589,614 @@ var defaultServerTransportOptions = {
   ...defaultTransportOptions
 };
 
+// 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 {
+  /*
+   * Whether this state has been consumed
+   * and we've moved on to another state
+   */
+  _isConsumed;
+  close() {
+    this._handleClose();
+  }
+  constructor() {
+    this._isConsumed = false;
+    return new Proxy(this, {
+      get(target, prop) {
+        if (prop === "_isConsumed" || prop === "id" || prop === "state") {
+          return Reflect.get(target, prop);
+        }
+        if (prop === "_handleStateExit") {
+          return () => {
+            target._isConsumed = true;
+            target._handleStateExit();
+          };
+        }
+        if (prop === "_handleClose") {
+          return () => {
+            target._handleStateExit();
+            target._handleClose();
+          };
+        }
+        if (target._isConsumed) {
+          throw new Error(
+            `${ERR_CONSUMED}: getting ${prop.toString()} on consumed state`
+          );
+        }
+        return Reflect.get(target, prop);
+      },
+      set(target, prop, value) {
+        if (target._isConsumed) {
+          throw new Error(
+            `${ERR_CONSUMED}: setting ${prop.toString()} on consumed state`
+          );
+        }
+        return Reflect.set(target, prop, value);
+      }
+    });
+  }
+};
+var CommonSession = class extends StateMachineState {
+  from;
+  options;
+  log;
+  constructor(from, options, log) {
+    super();
+    this.from = from;
+    this.options = options;
+    this.log = log;
+  }
+  parseMsg(msg) {
+    const parsedMsg = this.options.codec.fromBuffer(msg);
+    if (parsedMsg === null) {
+      const decodedBuffer = new TextDecoder().decode(Buffer.from(msg));
+      this.log?.error(
+        `received malformed msg: ${decodedBuffer}`,
+        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;
+  }
+};
+var IdentifiedSession = class extends CommonSession {
+  id;
+  telemetry;
+  to;
+  protocolVersion;
+  /**
+   * Index of the message we will send next (excluding handshake)
+   */
+  seq;
+  /**
+   * Number of unique messages we've received this session (excluding handshake)
+   */
+  ack;
+  sendBuffer;
+  constructor(id, from, to, seq, ack, sendBuffer, telemetry, options, protocolVersion, log) {
+    super(from, options, log);
+    this.id = id;
+    this.to = to;
+    this.seq = seq;
+    this.ack = ack;
+    this.sendBuffer = sendBuffer;
+    this.telemetry = telemetry;
+    this.log = log;
+    this.protocolVersion = protocolVersion;
+  }
+  get loggingMetadata() {
+    const spanContext = this.telemetry.span.spanContext();
+    return {
+      clientId: this.from,
+      connectedTo: this.to,
+      sessionId: this.id,
+      telemetry: {
+        traceId: spanContext.traceId,
+        spanId: spanContext.spanId
+      }
+    };
+  }
+  constructMsg(partialMsg) {
+    const msg = {
+      ...partialMsg,
+      id: generateId(),
+      to: this.to,
+      from: this.from,
+      seq: this.seq,
+      ack: this.ack
+    };
+    this.seq++;
+    return msg;
+  }
+  nextSeq() {
+    return this.sendBuffer.length > 0 ? this.sendBuffer[0].seq : this.seq;
+  }
+  send(msg) {
+    const constructedMsg = this.constructMsg(msg);
+    this.sendBuffer.push(constructedMsg);
+    return constructedMsg.id;
+  }
+  _handleStateExit() {
+  }
+  _handleClose() {
+    this.sendBuffer.length = 0;
+    this.telemetry.span.end();
+  }
+};
+
+// transport/sessionStateMachine/SessionConnecting.ts
+var SessionConnecting = class extends IdentifiedSession {
+  state = "Connecting" /* Connecting */;
+  connPromise;
+  listeners;
+  connectionTimeout;
+  constructor(connPromise, listeners, ...args) {
+    super(...args);
+    this.connPromise = connPromise;
+    this.listeners = listeners;
+    this.connectionTimeout = setTimeout(() => {
+      listeners.onConnectionTimeout();
+    }, this.options.connectionTimeoutMs);
+    connPromise.then(
+      (conn) => {
+        if (this._isConsumed)
+          return;
+        listeners.onConnectionEstablished(conn);
+      },
+      (err) => {
+        if (this._isConsumed)
+          return;
+        listeners.onConnectionFailed(err);
+      }
+    );
+  }
+  // close a pending connection if it resolves, ignore errors if the promise
+  // ends up rejected anyways
+  bestEffortClose() {
+    void this.connPromise.then((conn) => conn.close()).catch(() => {
+    });
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+    clearTimeout(this.connectionTimeout);
+    this.connectionTimeout = void 0;
+  }
+  _handleClose() {
+    this.bestEffortClose();
+    super._handleClose();
+  }
+};
+
+// transport/sessionStateMachine/SessionNoConnection.ts
+var SessionNoConnection = class extends IdentifiedSession {
+  state = "NoConnection" /* NoConnection */;
+  listeners;
+  gracePeriodTimeout;
+  constructor(listeners, ...args) {
+    super(...args);
+    this.listeners = listeners;
+    this.gracePeriodTimeout = setTimeout(() => {
+      this.listeners.onSessionGracePeriodElapsed();
+    }, this.options.sessionDisconnectGraceMs);
+  }
+  _handleClose() {
+    super._handleClose();
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+    if (this.gracePeriodTimeout) {
+      clearTimeout(this.gracePeriodTimeout);
+      this.gracePeriodTimeout = void 0;
+    }
+  }
+};
+
+// transport/sessionStateMachine/SessionWaitingForHandshake.ts
+var SessionWaitingForHandshake = class extends CommonSession {
+  state = "WaitingForHandshake" /* WaitingForHandshake */;
+  conn;
+  listeners;
+  handshakeTimeout;
+  constructor(conn, listeners, ...args) {
+    super(...args);
+    this.conn = conn;
+    this.listeners = listeners;
+    this.handshakeTimeout = setTimeout(() => {
+      listeners.onHandshakeTimeout();
+    }, this.options.handshakeTimeoutMs);
+    this.conn.addDataListener(this.onHandshakeData);
+    this.conn.addErrorListener(listeners.onConnectionErrored);
+    this.conn.addCloseListener(listeners.onConnectionClosed);
+  }
+  onHandshakeData = (msg) => {
+    const parsedMsg = this.parseMsg(msg);
+    if (parsedMsg === null) {
+      this.listeners.onInvalidHandshake("could not parse message");
+      return;
+    }
+    this.listeners.onHandshake(parsedMsg);
+  };
+  get loggingMetadata() {
+    return {
+      clientId: this.from,
+      connId: this.conn.id
+    };
+  }
+  sendHandshake(msg) {
+    return this.conn.send(this.options.codec.toBuffer(msg));
+  }
+  _handleStateExit() {
+    this.conn.removeDataListener(this.onHandshakeData);
+    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
+    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
+    clearTimeout(this.handshakeTimeout);
+    this.handshakeTimeout = void 0;
+  }
+  _handleClose() {
+    this.conn.close();
+  }
+};
+
+// transport/sessionStateMachine/SessionHandshaking.ts
+var SessionHandshaking = class extends IdentifiedSession {
+  state = "Handshaking" /* Handshaking */;
+  conn;
+  listeners;
+  handshakeTimeout;
+  constructor(conn, listeners, ...args) {
+    super(...args);
+    this.conn = conn;
+    this.listeners = listeners;
+    this.handshakeTimeout = setTimeout(() => {
+      listeners.onHandshakeTimeout();
+    }, this.options.handshakeTimeoutMs);
+    this.conn.addDataListener(this.onHandshakeData);
+    this.conn.addErrorListener(listeners.onConnectionErrored);
+    this.conn.addCloseListener(listeners.onConnectionClosed);
+  }
+  onHandshakeData = (msg) => {
+    const parsedMsg = this.parseMsg(msg);
+    if (parsedMsg === null) {
+      this.listeners.onInvalidHandshake("could not parse message");
+      return;
+    }
+    this.listeners.onHandshake(parsedMsg);
+  };
+  sendHandshake(msg) {
+    return this.conn.send(this.options.codec.toBuffer(msg));
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+    this.conn.removeDataListener(this.onHandshakeData);
+    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
+    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
+    clearTimeout(this.handshakeTimeout);
+  }
+  _handleClose() {
+    super._handleClose();
+    this.conn.close();
+  }
+};
+
+// transport/sessionStateMachine/SessionConnected.ts
+var import_api2 = require("@opentelemetry/api");
+var SessionConnected = class extends IdentifiedSession {
+  state = "Connected" /* Connected */;
+  conn;
+  listeners;
+  heartbeatHandle;
+  heartbeatMisses = 0;
+  get isActivelyHeartbeating() {
+    return this.heartbeatHandle !== void 0;
+  }
+  updateBookkeeping(ack, seq) {
+    this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq >= ack);
+    this.ack = seq + 1;
+    this.heartbeatMisses = 0;
+  }
+  send(msg) {
+    const constructedMsg = this.constructMsg(msg);
+    this.sendBuffer.push(constructedMsg);
+    this.conn.send(this.options.codec.toBuffer(constructedMsg));
+    return constructedMsg.id;
+  }
+  constructor(conn, listeners, ...args) {
+    super(...args);
+    this.conn = conn;
+    this.listeners = listeners;
+    this.conn.addDataListener(this.onMessageData);
+    this.conn.addCloseListener(listeners.onConnectionClosed);
+    this.conn.addErrorListener(listeners.onConnectionErrored);
+    if (this.sendBuffer.length > 0) {
+      this.log?.debug(
+        `sending ${this.sendBuffer.length} buffered messages`,
+        this.loggingMetadata
+      );
+    }
+    for (const msg of this.sendBuffer) {
+      conn.send(this.options.codec.toBuffer(msg));
+    }
+  }
+  startActiveHeartbeat() {
+    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;
+      }
+      this.sendHeartbeat();
+      this.heartbeatMisses++;
+    }, this.options.heartbeatIntervalMs);
+  }
+  sendHeartbeat() {
+    this.send({
+      streamId: "heartbeat",
+      controlFlags: 1 /* AckBit */,
+      payload: {
+        type: "ACK"
+      }
+    });
+  }
+  onMessageData = (msg) => {
+    const parsedMsg = this.parseMsg(msg);
+    if (parsedMsg === null)
+      return;
+    if (parsedMsg.seq !== this.ack) {
+      if (parsedMsg.seq < this.ack) {
+        this.log?.debug(
+          `received duplicate msg (got seq: ${parsedMsg.seq}, wanted seq: ${this.ack}), discarding`,
+          {
+            ...this.loggingMetadata,
+            transportMessage: parsedMsg
+          }
+        );
+      } else {
+        const reason = `received out-of-order msg (got seq: ${parsedMsg.seq}, wanted seq: ${this.ack})`;
+        this.log?.error(reason, {
+          ...this.loggingMetadata,
+          transportMessage: parsedMsg,
+          tags: ["invariant-violation"]
+        });
+        this.telemetry.span.setStatus({
+          code: import_api2.SpanStatusCode.ERROR,
+          message: reason
+        });
+        this.listeners.onInvalidMessage(reason);
+      }
+      return;
+    }
+    this.log?.debug(`received msg`, {
+      ...this.loggingMetadata,
+      transportMessage: parsedMsg
+    });
+    this.updateBookkeeping(parsedMsg.ack, parsedMsg.seq);
+    if (!isAck(parsedMsg.controlFlags)) {
+      this.listeners.onMessage(parsedMsg);
+      return;
+    }
+    this.log?.debug(`discarding msg (ack bit set)`, {
+      ...this.loggingMetadata,
+      transportMessage: parsedMsg
+    });
+    if (!this.isActivelyHeartbeating) {
+      this.sendHeartbeat();
+    }
+  };
+  _handleStateExit() {
+    super._handleStateExit();
+    this.conn.removeDataListener(this.onMessageData);
+    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
+    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
+    clearInterval(this.heartbeatHandle);
+    this.heartbeatHandle = void 0;
+  }
+  _handleClose() {
+    super._handleClose();
+    this.conn.close();
+  }
+};
+
+// transport/sessionStateMachine/transitions.ts
+function inheritSharedSession(session) {
+  return [
+    session.id,
+    session.from,
+    session.to,
+    session.seq,
+    session.ack,
+    session.sendBuffer,
+    session.telemetry,
+    session.options,
+    session.protocolVersion,
+    session.log
+  ];
+}
+var SessionStateGraph = {
+  entrypoints: {
+    NoConnection(to, from, listeners, options, protocolVersion, log) {
+      const id = `session-${generateId()}`;
+      const telemetry = createSessionTelemetryInfo(id, to, from);
+      const sendBuffer = [];
+      const session = new SessionNoConnection(
+        listeners,
+        id,
+        from,
+        to,
+        0,
+        0,
+        sendBuffer,
+        telemetry,
+        options,
+        protocolVersion,
+        log
+      );
+      session.log?.info(`session ${session.id} created in NoConnection state`, {
+        ...session.loggingMetadata,
+        tags: ["state-transition"]
+      });
+      return session;
+    },
+    WaitingForHandshake(from, conn, listeners, options, log) {
+      const session = new SessionWaitingForHandshake(
+        conn,
+        listeners,
+        from,
+        options,
+        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
+    NoConnectionToConnecting(oldSession, connPromise, listeners) {
+      const carriedState = inheritSharedSession(oldSession);
+      oldSession._handleStateExit();
+      const session = new SessionConnecting(
+        connPromise,
+        listeners,
+        ...carriedState
+      );
+      session.log?.info(
+        `session ${session.id} transition from NoConnection to Connecting`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    ConnectingToHandshaking(oldSession, conn, listeners) {
+      const carriedState = inheritSharedSession(oldSession);
+      oldSession._handleStateExit();
+      const session = new SessionHandshaking(conn, listeners, ...carriedState);
+      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
+        [
+          sessionId,
+          from,
+          to,
+          0,
+          0,
+          [],
+          createSessionTelemetryInfo(sessionId, to, from, propagationCtx),
+          options,
+          protocolVersion,
+          pendingSession.log
+        ]
+      );
+      pendingSession._handleStateExit();
+      oldSession?._handleStateExit();
+      const session = new SessionConnected(conn, listeners, ...carriedState);
+      session.log?.info(
+        `session ${session.id} transition from WaitingForHandshake to Connected`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    // disconnect paths
+    ConnectingToNoConnection(oldSession, listeners) {
+      const carriedState = inheritSharedSession(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 = inheritSharedSession(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);
+      oldSession.conn.close();
+      oldSession._handleStateExit();
+      const session = new SessionNoConnection(listeners, ...carriedState);
+      session.log?.info(
+        `session ${session.id} transition from Connected to NoConnection`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    }
+  }
+};
+
 // util/testHelpers.ts
 function createLocalWebSocketClient(port) {
   const sock = new import_ws.default(`ws://localhost:${port}`);
@@ -847,18 +1265,23 @@ function catchProcError(err) {
 }
 var testingSessionOptions = defaultTransportOptions;
 function dummySession() {
-  return new Session(
-    void 0,
+  return SessionStateGraph.entrypoints.NoConnection(
     "client",
     "server",
-    testingSessionOptions
+    {
+      onSessionGracePeriodElapsed: () => {
+      }
+    },
+    testingSessionOptions,
+    currentProtocolVersion
   );
 }
 function dummyCtx(state, session, extendedContext) {
   return {
     ...extendedContext,
-    from: session.from,
     state,
+    sessionId: session.id,
+    from: session.from,
     metadata: {},
     abortController: new AbortController(),
     clientAbortSignal: new AbortController().signal,
@@ -936,21 +1359,41 @@ function asClientUpload(state, proc, init, extendedContext, session = dummySessi
   return [inputPipe.writer, () => result];
 }
 var getUnixSocketPath = () => {
-  return process.platform === "win32" ? `\\\\?\\pipe\\${(0, import_nanoid2.nanoid)()}` : `/tmp/${(0, import_nanoid2.nanoid)()}.sock`;
+  return `/tmp/${(0, import_nanoid2.nanoid)()}.sock`;
 };
+function getTransportConnections(transport) {
+  const connections = [];
+  for (const session of transport.sessions.values()) {
+    if (session.state === "Connected" /* Connected */) {
+      connections.push(session.conn);
+    }
+  }
+  return connections;
+}
+function numberOfConnections(transport) {
+  return getTransportConnections(transport).length;
+}
+function closeAllConnections(transport) {
+  for (const conn of getTransportConnections(transport)) {
+    conn.close();
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   asClientRpc,
   asClientStream,
   asClientSubscription,
   asClientUpload,
+  closeAllConnections,
   createDummyTransportMessage,
   createLocalWebSocketClient,
   createWebSocketServer,
   dummySession,
   getIteratorFromStream,
+  getTransportConnections,
   getUnixSocketPath,
   iterNext,
+  numberOfConnections,
   onUdsServeReady,
   onWsServerReady,
   payloadToTransportMessage,