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

package/dist/chunk-OLWVR5AB.js

@@ -0,0 +1,860 @@
+import {
+  OpaqueTransportMessageSchema,
+  createSessionTelemetryInfo,
+  generateId,
+  isAck
+} from "./chunk-BYCR4VEM.js";
+import {
+  NaiveJsonCodec
+} from "./chunk-4PVU7J25.js";
+
+// transport/options.ts
+var defaultTransportOptions = {
+  heartbeatIntervalMs: 1e3,
+  heartbeatsUntilDead: 2,
+  sessionDisconnectGraceMs: 5e3,
+  connectionTimeoutMs: 2e3,
+  handshakeTimeoutMs: 1e3,
+  enableTransparentSessionReconnects: true,
+  codec: NaiveJsonCodec
+};
+var defaultConnectionRetryOptions = {
+  baseIntervalMs: 150,
+  maxJitterMs: 200,
+  maxBackoffMs: 32e3,
+  attemptBudgetCapacity: 5,
+  budgetRestoreIntervalMs: 200
+};
+var defaultClientTransportOptions = {
+  ...defaultTransportOptions,
+  ...defaultConnectionRetryOptions
+};
+var defaultServerTransportOptions = {
+  ...defaultTransportOptions
+};
+
+// transport/sessionStateMachine/common.ts
+import { Value } from "@sinclair/typebox/value";
+var SessionState = /* @__PURE__ */ ((SessionState2) => {
+  SessionState2["NoConnection"] = "NoConnection";
+  SessionState2["BackingOff"] = "BackingOff";
+  SessionState2["Connecting"] = "Connecting";
+  SessionState2["Handshaking"] = "Handshaking";
+  SessionState2["Connected"] = "Connected";
+  SessionState2["WaitingForHandshake"] = "WaitingForHandshake";
+  return SessionState2;
+})(SessionState || {});
+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._isConsumed = true;
+            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 (!Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
+      this.log?.error(`received invalid msg: ${JSON.stringify(parsedMsg)}`, {
+        ...this.loggingMetadata,
+        validationErrors: [
+          ...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(props) {
+    const { id, to, seq, ack, sendBuffer, telemetry, log, protocolVersion } = props;
+    super(props);
+    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();
+    const metadata = {
+      clientId: this.from,
+      connectedTo: this.to,
+      sessionId: this.id
+    };
+    if (this.telemetry.span.isRecording()) {
+      metadata.telemetry = {
+        traceId: spanContext.traceId,
+        spanId: spanContext.spanId
+      };
+    }
+    return metadata;
+  }
+  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();
+  }
+};
+var IdentifiedSessionWithGracePeriod = class extends IdentifiedSession {
+  graceExpiryTime;
+  gracePeriodTimeout;
+  listeners;
+  constructor(props) {
+    super(props);
+    this.listeners = props.listeners;
+    this.graceExpiryTime = props.graceExpiryTime;
+    this.gracePeriodTimeout = setTimeout(() => {
+      this.listeners.onSessionGracePeriodElapsed();
+    }, this.graceExpiryTime - Date.now());
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+    if (this.gracePeriodTimeout) {
+      clearTimeout(this.gracePeriodTimeout);
+      this.gracePeriodTimeout = void 0;
+    }
+  }
+  _handleClose() {
+    super._handleClose();
+  }
+};
+
+// transport/sessionStateMachine/SessionConnecting.ts
+var SessionConnecting = class extends IdentifiedSessionWithGracePeriod {
+  state = "Connecting" /* Connecting */;
+  connPromise;
+  listeners;
+  connectionTimeout;
+  constructor(props) {
+    super(props);
+    this.connPromise = props.connPromise;
+    this.listeners = props.listeners;
+    this.connPromise.then(
+      (conn) => {
+        if (this._isConsumed)
+          return;
+        this.listeners.onConnectionEstablished(conn);
+      },
+      (err) => {
+        if (this._isConsumed)
+          return;
+        this.listeners.onConnectionFailed(err);
+      }
+    );
+    this.connectionTimeout = setTimeout(() => {
+      this.listeners.onConnectionTimeout();
+    }, this.options.connectionTimeoutMs);
+  }
+  // close a pending connection if it resolves, ignore errors if the promise
+  // ends up rejected anyways
+  bestEffortClose() {
+    const logger = this.log;
+    const metadata = this.loggingMetadata;
+    this.connPromise.then((conn) => {
+      conn.close();
+      logger?.info(
+        "connection eventually resolved but session has transitioned, closed connection",
+        {
+          ...metadata,
+          ...conn.loggingMetadata
+        }
+      );
+    }).catch(() => {
+    });
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+    if (this.connectionTimeout) {
+      clearTimeout(this.connectionTimeout);
+      this.connectionTimeout = void 0;
+    }
+  }
+  _handleClose() {
+    this.bestEffortClose();
+    super._handleClose();
+  }
+};
+
+// transport/sessionStateMachine/SessionNoConnection.ts
+var SessionNoConnection = class extends IdentifiedSessionWithGracePeriod {
+  state = "NoConnection" /* NoConnection */;
+  _handleClose() {
+    super._handleClose();
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+  }
+};
+
+// transport/sessionStateMachine/SessionWaitingForHandshake.ts
+var SessionWaitingForHandshake = class extends CommonSession {
+  state = "WaitingForHandshake" /* WaitingForHandshake */;
+  conn;
+  listeners;
+  handshakeTimeout;
+  constructor(props) {
+    super(props);
+    this.conn = props.conn;
+    this.listeners = props.listeners;
+    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);
+  }
+  get loggingMetadata() {
+    return {
+      clientId: this.from,
+      connId: this.conn.id,
+      ...this.conn.loggingMetadata
+    };
+  }
+  onHandshakeData = (msg) => {
+    const parsedMsg = this.parseMsg(msg);
+    if (parsedMsg === null) {
+      this.listeners.onInvalidHandshake(
+        "could not parse message",
+        "MALFORMED_HANDSHAKE"
+      );
+      return;
+    }
+    this.listeners.onHandshake(parsedMsg);
+  };
+  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 IdentifiedSessionWithGracePeriod {
+  state = "Handshaking" /* Handshaking */;
+  conn;
+  listeners;
+  handshakeTimeout;
+  constructor(props) {
+    super(props);
+    this.conn = props.conn;
+    this.listeners = props.listeners;
+    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);
+  }
+  get loggingMetadata() {
+    return {
+      ...super.loggingMetadata,
+      ...this.conn.loggingMetadata
+    };
+  }
+  onHandshakeData = (msg) => {
+    const parsedMsg = this.parseMsg(msg);
+    if (parsedMsg === null) {
+      this.listeners.onInvalidHandshake(
+        "could not parse message",
+        "MALFORMED_HANDSHAKE"
+      );
+      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);
+    if (this.handshakeTimeout) {
+      clearTimeout(this.handshakeTimeout);
+      this.handshakeTimeout = void 0;
+    }
+  }
+  _handleClose() {
+    super._handleClose();
+    this.conn.close();
+  }
+};
+
+// transport/sessionStateMachine/SessionConnected.ts
+import { SpanStatusCode } from "@opentelemetry/api";
+var SessionConnected = class extends IdentifiedSession {
+  state = "Connected" /* Connected */;
+  conn;
+  listeners;
+  heartbeatHandle;
+  heartbeatMisses = 0;
+  isActivelyHeartbeating;
+  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(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);
+    if (this.sendBuffer.length > 0) {
+      this.log?.info(
+        `sending ${this.sendBuffer.length} buffered messages, starting at seq ${this.nextSeq()}`,
+        this.loggingMetadata
+      );
+      for (const msg of this.sendBuffer) {
+        this.conn.send(this.options.codec.toBuffer(msg));
+      }
+    }
+    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);
+  }
+  get loggingMetadata() {
+    return {
+      ...super.loggingMetadata,
+      ...this.conn.loggingMetadata
+    };
+  }
+  startActiveHeartbeat() {
+    this.isActivelyHeartbeating = true;
+  }
+  sendHeartbeat() {
+    this.log?.debug("sending heartbeat", this.loggingMetadata);
+    this.send({
+      streamId: "heartbeat",
+      controlFlags: 1 /* AckBit */,
+      payload: {
+        type: "ACK"
+      }
+    });
+  }
+  closeConnection() {
+    this.conn.removeDataListener(this.onMessageData);
+    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
+    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
+    this.conn.close();
+  }
+  onMessageData = (msg) => {
+    const parsedMsg = this.parseMsg(msg);
+    if (parsedMsg === null) {
+      this.listeners.onInvalidMessage("could not parse message");
+      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, closing connection (got seq: ${parsedMsg.seq}, wanted seq: ${this.ack})`;
+        this.log?.warn(reason, {
+          ...this.loggingMetadata,
+          transportMessage: parsedMsg,
+          tags: ["invariant-violation"]
+        });
+        this.telemetry.span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: reason
+        });
+        this.closeConnection();
+      }
+      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);
+    if (this.heartbeatHandle) {
+      clearInterval(this.heartbeatHandle);
+      this.heartbeatHandle = void 0;
+    }
+  }
+  _handleClose() {
+    super._handleClose();
+    this.conn.close();
+  }
+};
+
+// transport/sessionStateMachine/SessionBackingOff.ts
+var SessionBackingOff = class extends IdentifiedSessionWithGracePeriod {
+  state = "BackingOff" /* BackingOff */;
+  listeners;
+  backoffTimeout;
+  constructor(props) {
+    super(props);
+    this.listeners = props.listeners;
+    this.backoffTimeout = setTimeout(() => {
+      this.listeners.onBackoffFinished();
+    }, props.backoffMs);
+  }
+  _handleClose() {
+    super._handleClose();
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+    if (this.backoffTimeout) {
+      clearTimeout(this.backoffTimeout);
+      this.backoffTimeout = void 0;
+    }
+  }
+};
+
+// transport/sessionStateMachine/transitions.ts
+function inheritSharedSession(session) {
+  return {
+    id: session.id,
+    from: session.from,
+    to: session.to,
+    seq: session.seq,
+    ack: session.ack,
+    sendBuffer: session.sendBuffer,
+    telemetry: session.telemetry,
+    options: session.options,
+    log: session.log,
+    protocolVersion: session.protocolVersion
+  };
+}
+function inheritSharedSessionWithGrace(session) {
+  return {
+    ...inheritSharedSession(session),
+    graceExpiryTime: session.graceExpiryTime
+  };
+}
+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,
+        seq: 0,
+        ack: 0,
+        graceExpiryTime: Date.now() + options.sessionDisconnectGraceMs,
+        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
+    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
+      });
+      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,
+          sendBuffer: [],
+          telemetry: createSessionTelemetryInfo(
+            sessionId,
+            to,
+            from,
+            propagationCtx
+          ),
+          options,
+          log: pendingSession.log,
+          protocolVersion
+        }
+      );
+      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
+    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
+  }
+};
+
+export {
+  defaultTransportOptions,
+  defaultClientTransportOptions,
+  defaultServerTransportOptions,
+  SessionState,
+  SessionStateGraph,
+  ClientSessionStateGraph,
+  ServerSessionStateGraph
+};
+//# sourceMappingURL=chunk-OLWVR5AB.js.map