@replit/river 0.207.2 → 0.208.0

package/dist/chunk-24EWYOGK.js

@@ -1,1287 +0,0 @@
-import {
-  OpaqueTransportMessageSchema,
-  createConnectionTelemetryInfo,
-  createSessionTelemetryInfo,
-  generateId,
-  getTracer,
-  isAck
-} from "./chunk-46IVOKJU.js";
-import {
-  BaseLogger,
-  createLogProxy
-} from "./chunk-CC7RN7GI.js";
-import {
-  NaiveJsonCodec
-} from "./chunk-AJGIY2UB.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;
-  /**
-   * Cleanup this state machine state and mark it as consumed.
-   * After calling close, it is an error to access any properties on the state.
-   * You should never need to call this as a consumer.
-   *
-   * If you're looking to close the session from the client,
-   * use `.hardDisconnect` on the client transport.
-   */
-  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;
-  tracer;
-  log;
-  constructor({ from, options, log, tracer }) {
-    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;
-  }
-};
-var IdentifiedSession = class extends CommonSession {
-  id;
-  telemetry;
-  to;
-  protocolVersion;
-  /**
-   * Index of the message we will send next (excluding handshake)
-   */
-  seq;
-  /**
-   * Last seq we sent over the wire this session (excluding handshake) and retransmissions
-   */
-  seqSent;
-  /**
-   * Number of unique messages we've received this session (excluding handshake)
-   */
-  ack;
-  sendBuffer;
-  constructor(props) {
-    const {
-      id,
-      to,
-      seq,
-      ack,
-      sendBuffer,
-      telemetry,
-      log,
-      protocolVersion,
-      seqSent: messagesSent
-    } = 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;
-    this.seqSent = messagesSent;
-  }
-  get loggingMetadata() {
-    const metadata = {
-      clientId: this.from,
-      connectedTo: this.to,
-      sessionId: this.id
-    };
-    if (this.telemetry.span.isRecording()) {
-      const spanContext = this.telemetry.span.spanContext();
-      metadata.telemetry = {
-        traceId: spanContext.traceId,
-        spanId: spanContext.spanId
-      };
-    }
-    return metadata;
-  }
-  constructMsg(partialMsg) {
-    if (this._isConsumed) {
-      throw new Error(ERR_CONSUMED);
-    }
-    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;
-  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();
-    }
-  };
-  updateBookkeeping(ack, seq) {
-    this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq >= ack);
-    this.ack = seq + 1;
-    this.heartbeatMisses = 0;
-  }
-  assertSendOrdering(constructedMsg) {
-    if (constructedMsg.seq > this.seqSent + 1) {
-      const msg = `invariant violation: would have sent out of order msg (seq: ${constructedMsg.seq}, expected: ${this.seqSent} + 1)`;
-      this.log?.error(msg, {
-        ...this.loggingMetadata,
-        transportMessage: constructedMsg,
-        tags: ["invariant-violation"],
-        extras: {
-          lastConstructedMsgs: this.lastConstructedMsgs
-        }
-      });
-      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));
-    this.seqSent = constructedMsg.seq;
-    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.assertSendOrdering(msg);
-        this.conn.send(this.options.codec.toBuffer(msg));
-        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);
-  }
-  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"
-      }
-    });
-  }
-  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?.error(reason, {
-          ...this.loggingMetadata,
-          transportMessage: parsedMsg,
-          tags: ["invariant-violation"]
-        });
-        this.telemetry.span.setStatus({
-          code: SpanStatusCode.ERROR,
-          message: reason
-        });
-        this.conn.close();
-      }
-      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) {
-      void Promise.resolve().then(() => {
-        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,
-    seqSent: session.seqSent,
-    sendBuffer: session.sendBuffer,
-    telemetry: session.telemetry,
-    options: session.options,
-    log: session.log,
-    tracer: session.tracer,
-    protocolVersion: session.protocolVersion
-  };
-}
-function inheritSharedSessionWithGrace(session) {
-  return {
-    ...inheritSharedSession(session),
-    graceExpiryTime: session.graceExpiryTime
-  };
-}
-var SessionStateGraph = {
-  entrypoints: {
-    NoConnection: (to, from, listeners, options, protocolVersion, tracer, log) => {
-      const id = `session-${generateId()}`;
-      const telemetry = createSessionTelemetryInfo(tracer, id, to, from);
-      const sendBuffer = [];
-      const session = new SessionNoConnection({
-        listeners,
-        id,
-        from,
-        to,
-        seq: 0,
-        ack: 0,
-        seqSent: 0,
-        graceExpiryTime: Date.now() + options.sessionDisconnectGraceMs,
-        sendBuffer,
-        telemetry,
-        options,
-        protocolVersion,
-        tracer,
-        log
-      });
-      session.log?.info(`session ${session.id} created in NoConnection state`, {
-        ...session.loggingMetadata,
-        tags: ["state-transition"]
-      });
-      return session;
-    },
-    WaitingForHandshake: (from, conn, listeners, options, tracer, log) => {
-      const session = new SessionWaitingForHandshake({
-        conn,
-        listeners,
-        from,
-        options,
-        tracer,
-        log
-      });
-      session.log?.info(`session created in WaitingForHandshake state`, {
-        ...session.loggingMetadata,
-        tags: ["state-transition"]
-      });
-      return session;
-    }
-  },
-  // All of the transitions 'move'/'consume' the old session and return a new one.
-  // After a session is transitioned, any usage of the old session will throw.
-  transition: {
-    // happy path transitions
-    NoConnectionToBackingOff: (oldSession, backoffMs, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession._handleStateExit();
-      const session = new SessionBackingOff({
-        backoffMs,
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from NoConnection to BackingOff`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    BackingOffToConnecting: (oldSession, connPromise, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession._handleStateExit();
-      const session = new SessionConnecting({
-        connPromise,
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from BackingOff to Connecting`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    ConnectingToHandshaking: (oldSession, conn, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession._handleStateExit();
-      const session = new SessionHandshaking({
-        conn,
-        listeners,
-        ...carriedState
-      });
-      conn.telemetry = createConnectionTelemetryInfo(
-        session.tracer,
-        conn,
-        session.telemetry
-      );
-      session.log?.info(
-        `session ${session.id} transition from Connecting to Handshaking`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    HandshakingToConnected: (oldSession, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
-      const conn = oldSession.conn;
-      oldSession._handleStateExit();
-      const session = new SessionConnected({
-        conn,
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from Handshaking to Connected`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    WaitingForHandshakeToConnected: (pendingSession, oldSession, sessionId, to, propagationCtx, listeners, protocolVersion) => {
-      const conn = pendingSession.conn;
-      const { from, options } = pendingSession;
-      const carriedState = oldSession ? (
-        // old session exists, inherit state
-        inheritSharedSession(oldSession)
-      ) : (
-        // old session does not exist, create new state
-        {
-          id: sessionId,
-          from,
-          to,
-          seq: 0,
-          ack: 0,
-          seqSent: 0,
-          sendBuffer: [],
-          telemetry: createSessionTelemetryInfo(
-            pendingSession.tracer,
-            sessionId,
-            to,
-            from,
-            propagationCtx
-          ),
-          options,
-          tracer: pendingSession.tracer,
-          log: pendingSession.log,
-          protocolVersion
-        }
-      );
-      pendingSession._handleStateExit();
-      oldSession?._handleStateExit();
-      const session = new SessionConnected({
-        conn,
-        listeners,
-        ...carriedState
-      });
-      conn.telemetry = createConnectionTelemetryInfo(
-        session.tracer,
-        conn,
-        session.telemetry
-      );
-      session.log?.info(
-        `session ${session.id} transition from WaitingForHandshake to Connected`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    // disconnect paths
-    BackingOffToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection({
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from BackingOff to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    ConnectingToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession.bestEffortClose();
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection({
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from Connecting to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    HandshakingToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession.conn.close();
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection({
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from Handshaking to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    ConnectedToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
-      const graceExpiryTime = Date.now() + oldSession.options.sessionDisconnectGraceMs;
-      oldSession.conn.close();
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection({
-        listeners,
-        graceExpiryTime,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from Connected to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    }
-  }
-};
-var transitions = SessionStateGraph.transition;
-var ClientSessionStateGraph = {
-  entrypoint: SessionStateGraph.entrypoints.NoConnection,
-  transition: {
-    // happy paths
-    // NoConnection -> BackingOff: attempt to connect
-    NoConnectionToBackingOff: transitions.NoConnectionToBackingOff,
-    // BackingOff -> Connecting: backoff period elapsed, start connection
-    BackingOffToConnecting: transitions.BackingOffToConnecting,
-    // Connecting -> Handshaking: connection established, start handshake
-    ConnectingToHandshaking: transitions.ConnectingToHandshaking,
-    // Handshaking -> Connected: handshake complete, session ready
-    HandshakingToConnected: transitions.HandshakingToConnected,
-    // disconnect paths
-    // BackingOff -> NoConnection: unused
-    BackingOffToNoConnection: transitions.BackingOffToNoConnection,
-    // Connecting -> NoConnection: connection failed or connection timeout
-    ConnectingToNoConnection: transitions.ConnectingToNoConnection,
-    // Handshaking -> NoConnection: connection closed or handshake timeout
-    HandshakingToNoConnection: transitions.HandshakingToNoConnection,
-    // Connected -> NoConnection: connection closed
-    ConnectedToNoConnection: transitions.ConnectedToNoConnection
-    // destroy/close paths
-    // NoConnection -> x: grace period elapsed
-    // BackingOff -> x: grace period elapsed
-    // Connecting -> x: grace period elapsed
-    // Handshaking -> x: grace period elapsed or invalid handshake message or handshake rejection
-    // Connected -> x: grace period elapsed or invalid message
-  }
-};
-var ServerSessionStateGraph = {
-  entrypoint: SessionStateGraph.entrypoints.WaitingForHandshake,
-  transition: {
-    // happy paths
-    // WaitingForHandshake -> Connected: handshake complete, session ready
-    WaitingForHandshakeToConnected: transitions.WaitingForHandshakeToConnected,
-    // disconnect paths
-    // Connected -> NoConnection: connection closed
-    ConnectedToNoConnection: transitions.ConnectedToNoConnection
-    // destroy/close paths
-    // WaitingForHandshake -> x: handshake timeout elapsed or invalid handshake message or handshake rejection or connection closed
-  }
-};
-
-// transport/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 {
-  /**
-   * The status of the transport.
-   */
-  status;
-  /**
-   * The client ID of this transport.
-   */
-  clientId;
-  /**
-   * The event dispatcher for handling events of type EventTypes.
-   */
-  eventDispatcher;
-  /**
-   * The options for this transport.
-   */
-  options;
-  log;
-  tracer;
-  sessions;
-  /**
-   * Creates a new Transport instance.
-   * @param codec The codec used to encode and decode messages.
-   * @param clientId The client ID of this transport.
-   */
-  constructor(clientId, providedOptions) {
-    this.options = { ...defaultTransportOptions, ...providedOptions };
-    this.eventDispatcher = new EventDispatcher();
-    this.clientId = clientId;
-    this.status = "open";
-    this.sessions = /* @__PURE__ */ new Map();
-    this.tracer = getTracer();
-  }
-  bindLogger(fn, level) {
-    if (typeof fn === "function") {
-      this.log = createLogProxy(new BaseLogger(fn, level));
-      return;
-    }
-    this.log = createLogProxy(fn);
-  }
-  /**
-   * Called when a message is received by this transport.
-   * You generally shouldn't need to override this in downstream transport implementations.
-   * @param message The received message.
-   */
-  handleMsg(message) {
-    if (this.getStatus() !== "open")
-      return;
-    this.eventDispatcher.dispatchEvent("message", message);
-  }
-  /**
-   * Adds a listener to this transport.
-   * @param the type of event to listen for
-   * @param handler The message handler to add.
-   */
-  addEventListener(type, handler) {
-    this.eventDispatcher.addEventListener(type, handler);
-  }
-  /**
-   * Removes a listener from this transport.
-   * @param the type of event to un-listen on
-   * @param handler The message handler to remove.
-   */
-  removeEventListener(type, handler) {
-    this.eventDispatcher.removeEventListener(type, handler);
-  }
-  protocolError(message) {
-    this.eventDispatcher.dispatchEvent("protocolError", message);
-  }
-  /**
-   * Default close implementation for transports. You should override this in the downstream
-   * implementation if you need to do any additional cleanup and call super.close() at the end.
-   * Closes the transport. Any messages sent while the transport is closed will be silently discarded.
-   */
-  close() {
-    this.status = "closed";
-    const sessions = Array.from(this.sessions.values());
-    for (const session of sessions) {
-      this.deleteSession(session);
-    }
-    this.eventDispatcher.dispatchEvent("transportStatus", {
-      status: this.status
-    });
-    this.eventDispatcher.removeAllListeners();
-    this.log?.info(`manually closed transport`, { clientId: this.clientId });
-  }
-  getStatus() {
-    return this.status;
-  }
-  // state transitions
-  createSession(session) {
-    const activeSession = this.sessions.get(session.to);
-    if (activeSession) {
-      const msg = `attempt to create session for ${session.to} but active session (${activeSession.id}) already exists`;
-      this.log?.error(msg, {
-        ...session.loggingMetadata,
-        tags: ["invariant-violation"]
-      });
-      throw new Error(msg);
-    }
-    this.sessions.set(session.to, session);
-    this.eventDispatcher.dispatchEvent("sessionStatus", {
-      status: "created",
-      session
-    });
-    this.eventDispatcher.dispatchEvent("sessionTransition", {
-      state: session.state,
-      id: session.id
-    });
-  }
-  updateSession(session) {
-    const activeSession = this.sessions.get(session.to);
-    if (!activeSession) {
-      const msg = `attempt to transition session for ${session.to} but no active session exists`;
-      this.log?.error(msg, {
-        ...session.loggingMetadata,
-        tags: ["invariant-violation"]
-      });
-      throw new Error(msg);
-    }
-    if (activeSession.id !== session.id) {
-      const msg = `attempt to transition active session for ${session.to} but active session (${activeSession.id}) is different from handle (${session.id})`;
-      this.log?.error(msg, {
-        ...session.loggingMetadata,
-        tags: ["invariant-violation"]
-      });
-      throw new Error(msg);
-    }
-    this.sessions.set(session.to, session);
-    this.eventDispatcher.dispatchEvent("sessionTransition", {
-      state: session.state,
-      id: session.id
-    });
-  }
-  deleteSession(session, options) {
-    if (session._isConsumed)
-      return;
-    const loggingMetadata = session.loggingMetadata;
-    if (loggingMetadata.tags && options?.unhealthy) {
-      loggingMetadata.tags.push("unhealthy-session");
-    }
-    session.log?.info(`closing session ${session.id}`, loggingMetadata);
-    this.eventDispatcher.dispatchEvent("sessionStatus", {
-      status: "closing",
-      session
-    });
-    const to = session.to;
-    session.close();
-    this.sessions.delete(to);
-    this.eventDispatcher.dispatchEvent("sessionStatus", {
-      status: "closed",
-      session: { id: session.id, to }
-    });
-  }
-  // common listeners
-  onSessionGracePeriodElapsed(session) {
-    this.log?.warn(
-      `session to ${session.to} grace period elapsed, closing`,
-      session.loggingMetadata
-    );
-    this.deleteSession(session);
-  }
-  onConnectingFailed(session) {
-    const noConnectionSession = SessionStateGraph.transition.ConnectingToNoConnection(session, {
-      onSessionGracePeriodElapsed: () => {
-        this.onSessionGracePeriodElapsed(noConnectionSession);
-      }
-    });
-    this.updateSession(noConnectionSession);
-    return noConnectionSession;
-  }
-  onConnClosed(session) {
-    let noConnectionSession;
-    if (session.state === "Handshaking" /* Handshaking */) {
-      noConnectionSession = SessionStateGraph.transition.HandshakingToNoConnection(session, {
-        onSessionGracePeriodElapsed: () => {
-          this.onSessionGracePeriodElapsed(noConnectionSession);
-        }
-      });
-    } else {
-      noConnectionSession = SessionStateGraph.transition.ConnectedToNoConnection(session, {
-        onSessionGracePeriodElapsed: () => {
-          this.onSessionGracePeriodElapsed(noConnectionSession);
-        }
-      });
-    }
-    this.updateSession(noConnectionSession);
-    return noConnectionSession;
-  }
-  /**
-   * Gets a send closure scoped to a specific session. Sending using the returned
-   * closure after the session has transitioned to a different state will be a noop.
-   *
-   * Session objects themselves can become stale as they transition between
-   * states. As stale sessions cannot be used again (and will throw), holding
-   * onto a session object is not recommended.
-   */
-  getSessionBoundSendFn(to, sessionId) {
-    if (this.getStatus() !== "open") {
-      throw new Error("cannot get a bound send function on a closed transport");
-    }
-    return (msg) => {
-      const session = this.sessions.get(to);
-      if (!session) {
-        throw new Error(
-          `session scope for ${sessionId} has ended (close), can't send`
-        );
-      }
-      const sameSession = session.id === sessionId;
-      if (!sameSession) {
-        throw new Error(
-          `session scope for ${sessionId} has ended (transition), can't send`
-        );
-      }
-      return session.send(msg);
-    };
-  }
-};
-
-// transport/connection.ts
-var Connection = class {
-  id;
-  telemetry;
-  constructor() {
-    this.id = `conn-${generateId()}`;
-  }
-  get loggingMetadata() {
-    const metadata = { connId: this.id };
-    if (this.telemetry?.span.isRecording()) {
-      const spanContext = this.telemetry.span.spanContext();
-      metadata.telemetry = {
-        traceId: spanContext.traceId,
-        spanId: spanContext.spanId
-      };
-    }
-    return metadata;
-  }
-  // can't use event emitter because we need this to work in both node + browser
-  _dataListeners = /* @__PURE__ */ new Set();
-  _closeListeners = /* @__PURE__ */ new Set();
-  _errorListeners = /* @__PURE__ */ new Set();
-  get dataListeners() {
-    return [...this._dataListeners];
-  }
-  get closeListeners() {
-    return [...this._closeListeners];
-  }
-  get errorListeners() {
-    return [...this._errorListeners];
-  }
-  onData(msg) {
-    for (const cb of this.dataListeners) {
-      cb(msg);
-    }
-  }
-  onError(err) {
-    for (const cb of this.errorListeners) {
-      cb(err);
-    }
-  }
-  onClose() {
-    for (const cb of this.closeListeners) {
-      cb();
-    }
-    this.telemetry?.span.end();
-  }
-  /**
-   * Handle adding a callback for when a message is received.
-   * @param msg The message that was received.
-   */
-  addDataListener(cb) {
-    this._dataListeners.add(cb);
-  }
-  removeDataListener(cb) {
-    this._dataListeners.delete(cb);
-  }
-  /**
-   * Handle adding a callback for when the connection is closed.
-   * This should also be called if an error happens and after notifying all the error listeners.
-   * @param cb The callback to call when the connection is closed.
-   */
-  addCloseListener(cb) {
-    this._closeListeners.add(cb);
-  }
-  removeCloseListener(cb) {
-    this._closeListeners.delete(cb);
-  }
-  /**
-   * Handle adding a callback for when an error is received.
-   * This should only be used for this.logging errors, all cleanup
-   * should be delegated to addCloseListener.
-   *
-   * The implementer should take care such that the implemented
-   * connection will call both the close and error callbacks
-   * on an error.
-   *
-   * @param cb The callback to call when an error is received.
-   */
-  addErrorListener(cb) {
-    this._errorListeners.add(cb);
-  }
-  removeErrorListener(cb) {
-    this._errorListeners.delete(cb);
-  }
-};
-
-export {
-  defaultTransportOptions,
-  defaultClientTransportOptions,
-  defaultServerTransportOptions,
-  SessionState,
-  SessionStateGraph,
-  ClientSessionStateGraph,
-  ServerSessionStateGraph,
-  ProtocolError,
-  Transport,
-  Connection
-};
-//# sourceMappingURL=chunk-24EWYOGK.js.map