@replit/river 0.216.1 → 0.217.2

package/dist/transport/impls/ws/server.cjs

@@ -1,2179 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// transport/impls/ws/server.ts
-var server_exports = {};
-__export(server_exports, {
-  WebSocketServerTransport: () => WebSocketServerTransport
-});
-module.exports = __toCommonJS(server_exports);
-
-// transport/id.ts
-var import_nanoid = require("nanoid");
-var alphabet = (0, import_nanoid.customAlphabet)(
-  "1234567890abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ"
-);
-var generateId = () => alphabet(12);
-
-// 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;
-  }
-  dataListener;
-  closeListener;
-  errorListener;
-  onData(msg) {
-    this.dataListener?.(msg);
-  }
-  onError(err) {
-    this.errorListener?.(err);
-  }
-  onClose() {
-    this.closeListener?.();
-    this.telemetry?.span.end();
-  }
-  /**
-   * Set the callback for when a message is received.
-   * @param cb The message handler callback.
-   */
-  setDataListener(cb) {
-    this.dataListener = cb;
-  }
-  removeDataListener() {
-    this.dataListener = void 0;
-  }
-  /**
-   * Set the callback for when the connection is closed.
-   * This should also be called if an error happens and after notifying the error listener.
-   * @param cb The callback to call when the connection is closed.
-   */
-  setCloseListener(cb) {
-    this.closeListener = cb;
-  }
-  removeCloseListener() {
-    this.closeListener = void 0;
-  }
-  /**
-   * Set the callback for when an error is received.
-   * This should only be used for logging errors, all cleanup
-   * should be delegated to setCloseListener.
-   *
-   * The implementer should take care such that the implemented
-   * connection will call both the close and error callbacks
-   * on an error.
-   *
-   * @param cb The callback to call when an error is received.
-   */
-  setErrorListener(cb) {
-    this.errorListener = cb;
-  }
-  removeErrorListener() {
-    this.errorListener = void 0;
-  }
-};
-
-// transport/impls/ws/connection.ts
-var WS_HEALTHY_CLOSE_CODE = 1e3;
-var WebSocketCloseError = class extends Error {
-  code;
-  reason;
-  constructor(code, reason) {
-    super(`websocket closed with code and reason: ${code} - ${reason}`);
-    this.code = code;
-    this.reason = reason;
-  }
-};
-var WebSocketConnection = class extends Connection {
-  ws;
-  extras;
-  get loggingMetadata() {
-    const metadata = super.loggingMetadata;
-    if (this.extras) {
-      metadata.extras = this.extras;
-    }
-    return metadata;
-  }
-  constructor(ws, extras) {
-    super();
-    this.ws = ws;
-    this.extras = extras;
-    this.ws.binaryType = "arraybuffer";
-    let didError = false;
-    this.ws.onerror = () => {
-      didError = true;
-    };
-    this.ws.onclose = ({ code, reason }) => {
-      if (didError) {
-        const err = new WebSocketCloseError(code, reason);
-        this.onError(err);
-      }
-      this.onClose();
-    };
-    this.ws.onmessage = (msg) => {
-      this.onData(msg.data);
-    };
-  }
-  send(payload) {
-    try {
-      this.ws.send(payload);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  close() {
-    this.ws.close(WS_HEALTHY_CLOSE_CODE);
-  }
-};
-
-// transport/server.ts
-var import_api4 = require("@opentelemetry/api");
-
-// transport/message.ts
-var import_typebox = require("@sinclair/typebox");
-var TransportMessageSchema = (t) => import_typebox.Type.Object({
-  id: import_typebox.Type.String(),
-  from: import_typebox.Type.String(),
-  to: import_typebox.Type.String(),
-  seq: import_typebox.Type.Integer(),
-  ack: import_typebox.Type.Integer(),
-  serviceName: import_typebox.Type.Optional(import_typebox.Type.String()),
-  procedureName: import_typebox.Type.Optional(import_typebox.Type.String()),
-  streamId: import_typebox.Type.String(),
-  controlFlags: import_typebox.Type.Integer(),
-  tracing: import_typebox.Type.Optional(
-    import_typebox.Type.Object({
-      traceparent: import_typebox.Type.String(),
-      tracestate: import_typebox.Type.String()
-    })
-  ),
-  payload: t
-});
-var ControlMessageAckSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("ACK")
-});
-var ControlMessageCloseSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("CLOSE")
-});
-var currentProtocolVersion = "v2.0";
-var acceptedProtocolVersions = ["v1.1", currentProtocolVersion];
-function isAcceptedProtocolVersion(version2) {
-  return acceptedProtocolVersions.includes(version2);
-}
-var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("HANDSHAKE_REQ"),
-  protocolVersion: import_typebox.Type.String(),
-  sessionId: import_typebox.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_typebox.Type.Object({
-    // what the client expects the server to send next
-    nextExpectedSeq: import_typebox.Type.Integer(),
-    nextSentSeq: import_typebox.Type.Integer()
-  }),
-  metadata: import_typebox.Type.Optional(import_typebox.Type.Unknown())
-});
-var HandshakeErrorRetriableResponseCodes = import_typebox.Type.Union([
-  import_typebox.Type.Literal("SESSION_STATE_MISMATCH")
-]);
-var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox.Type.Union([
-  // The custom validation handler rejected the handler because the client is unsupported.
-  import_typebox.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
-  // The custom validation handler rejected the handshake.
-  import_typebox.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
-]);
-var HandshakeErrorFatalResponseCodes = import_typebox.Type.Union([
-  HandshakeErrorCustomHandlerFatalResponseCodes,
-  // The ciient sent a handshake that doesn't comply with the extended handshake metadata.
-  import_typebox.Type.Literal("MALFORMED_HANDSHAKE_META"),
-  // The ciient sent a handshake that doesn't comply with ControlMessageHandshakeRequestSchema.
-  import_typebox.Type.Literal("MALFORMED_HANDSHAKE"),
-  // The client's protocol version does not match the server's.
-  import_typebox.Type.Literal("PROTOCOL_VERSION_MISMATCH")
-]);
-var HandshakeErrorResponseCodes = import_typebox.Type.Union([
-  HandshakeErrorRetriableResponseCodes,
-  HandshakeErrorFatalResponseCodes
-]);
-var ControlMessageHandshakeResponseSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("HANDSHAKE_RESP"),
-  status: import_typebox.Type.Union([
-    import_typebox.Type.Object({
-      ok: import_typebox.Type.Literal(true),
-      sessionId: import_typebox.Type.String()
-    }),
-    import_typebox.Type.Object({
-      ok: import_typebox.Type.Literal(false),
-      reason: import_typebox.Type.String(),
-      code: HandshakeErrorResponseCodes
-    })
-  ])
-});
-var ControlMessagePayloadSchema = import_typebox.Type.Union([
-  ControlMessageCloseSchema,
-  ControlMessageAckSchema,
-  ControlMessageHandshakeRequestSchema,
-  ControlMessageHandshakeResponseSchema
-]);
-var OpaqueTransportMessageSchema = TransportMessageSchema(
-  import_typebox.Type.Unknown()
-);
-function handshakeResponseMessage({
-  from,
-  to,
-  status
-}) {
-  return {
-    id: generateId(),
-    from,
-    to,
-    seq: 0,
-    ack: 0,
-    streamId: generateId(),
-    controlFlags: 0,
-    payload: {
-      type: "HANDSHAKE_RESP",
-      status
-    }
-  };
-}
-function isAck(controlFlag) {
-  return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
-}
-
-// codec/json.ts
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-function uint8ArrayToBase64(uint8Array) {
-  let binary = "";
-  uint8Array.forEach((byte) => {
-    binary += String.fromCharCode(byte);
-  });
-  return btoa(binary);
-}
-function base64ToUint8Array(base64) {
-  const binaryString = atob(base64);
-  const uint8Array = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
-    uint8Array[i] = binaryString.charCodeAt(i);
-  }
-  return uint8Array;
-}
-var NaiveJsonCodec = {
-  toBuffer: (obj) => {
-    return encoder.encode(
-      JSON.stringify(obj, function replacer(key) {
-        const val = this[key];
-        if (val instanceof Uint8Array) {
-          return { $t: uint8ArrayToBase64(val) };
-        } else if (typeof val === "bigint") {
-          return { $b: val.toString() };
-        } else {
-          return val;
-        }
-      })
-    );
-  },
-  fromBuffer: (buff) => {
-    const parsed = JSON.parse(
-      decoder.decode(buff),
-      function reviver(_key, val) {
-        if (val?.$t !== void 0) {
-          return base64ToUint8Array(val.$t);
-        } else if (val?.$b !== void 0) {
-          return BigInt(val.$b);
-        } else {
-          return val;
-        }
-      }
-    );
-    if (typeof parsed !== "object" || parsed === null) {
-      throw new Error("unpacked msg is not an object");
-    }
-    return parsed;
-  }
-};
-
-// transport/options.ts
-var defaultTransportOptions = {
-  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,
-  isFatalConnectionError: () => false
-};
-var defaultClientTransportOptions = {
-  ...defaultTransportOptions,
-  ...defaultConnectionRetryOptions
-};
-var defaultServerTransportOptions = {
-  ...defaultTransportOptions
-};
-
-// logging/log.ts
-var import_api = require("@opentelemetry/api");
-var LoggingLevels = {
-  debug: -1,
-  info: 0,
-  warn: 1,
-  error: 2
-};
-var cleanedLogFn = (log) => {
-  return (msg, metadata) => {
-    if (metadata && !metadata.telemetry) {
-      const span = import_api.trace.getSpan(import_api.context.active());
-      if (span) {
-        metadata.telemetry = {
-          traceId: span.spanContext().traceId,
-          spanId: span.spanContext().spanId
-        };
-      }
-    }
-    if (!metadata?.transportMessage) {
-      log(msg, metadata);
-      return;
-    }
-    const { payload, ...rest } = metadata.transportMessage;
-    metadata.transportMessage = rest;
-    log(msg, metadata);
-  };
-};
-var BaseLogger = class {
-  minLevel;
-  output;
-  constructor(output, minLevel = "info") {
-    this.minLevel = minLevel;
-    this.output = output;
-  }
-  debug(msg, metadata) {
-    if (LoggingLevels[this.minLevel] <= LoggingLevels.debug) {
-      this.output(msg, metadata ?? {}, "debug");
-    }
-  }
-  info(msg, metadata) {
-    if (LoggingLevels[this.minLevel] <= LoggingLevels.info) {
-      this.output(msg, metadata ?? {}, "info");
-    }
-  }
-  warn(msg, metadata) {
-    if (LoggingLevels[this.minLevel] <= LoggingLevels.warn) {
-      this.output(msg, metadata ?? {}, "warn");
-    }
-  }
-  error(msg, metadata) {
-    if (LoggingLevels[this.minLevel] <= LoggingLevels.error) {
-      this.output(msg, metadata ?? {}, "error");
-    }
-  }
-};
-var createLogProxy = (log) => ({
-  debug: cleanedLogFn(log.debug.bind(log)),
-  info: cleanedLogFn(log.info.bind(log)),
-  warn: cleanedLogFn(log.warn.bind(log)),
-  error: cleanedLogFn(log.error.bind(log))
-});
-
-// transport/events.ts
-var ProtocolError = {
-  RetriesExceeded: "conn_retry_exceeded",
-  HandshakeFailed: "handshake_failed",
-  MessageOrderingViolated: "message_ordering_violated",
-  InvalidMessage: "invalid_message",
-  MessageSendFailure: "message_send_failure"
-};
-var EventDispatcher = class {
-  eventListeners = {};
-  removeAllListeners() {
-    this.eventListeners = {};
-  }
-  numberOfListeners(eventType) {
-    return this.eventListeners[eventType]?.size ?? 0;
-  }
-  addEventListener(eventType, handler) {
-    if (!this.eventListeners[eventType]) {
-      this.eventListeners[eventType] = /* @__PURE__ */ new Set();
-    }
-    this.eventListeners[eventType]?.add(handler);
-  }
-  removeEventListener(eventType, handler) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      this.eventListeners[eventType]?.delete(handler);
-    }
-  }
-  dispatchEvent(eventType, event) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      const copy = [...handlers];
-      for (const handler of copy) {
-        handler(event);
-      }
-    }
-  }
-};
-
-// transport/sessionStateMachine/common.ts
-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;
-  codec;
-  tracer;
-  log;
-  constructor({ from, options, log, tracer, codec }) {
-    super();
-    this.from = from;
-    this.options = options;
-    this.log = log;
-    this.tracer = tracer;
-    this.codec = codec;
-  }
-};
-var IdentifiedSession = class extends CommonSession {
-  id;
-  telemetry;
-  to;
-  protocolVersion;
-  listeners;
-  /**
-   * 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,
-      listeners
-    } = 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;
-    this.listeners = listeners;
-  }
-  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;
-  }
-  encodeMsg(partialMsg) {
-    const msg = {
-      ...partialMsg,
-      id: generateId(),
-      to: this.to,
-      from: this.from,
-      seq: this.seq,
-      ack: this.ack
-    };
-    const encoded = this.codec.toBuffer(msg);
-    if (!encoded.ok) {
-      this.listeners.onMessageSendFailure(
-        { ...partialMsg, seq: this.seq },
-        encoded.reason
-      );
-      return encoded;
-    }
-    this.seq++;
-    return {
-      ok: true,
-      value: {
-        id: msg.id,
-        seq: msg.seq,
-        msg: partialMsg,
-        data: encoded.value
-      }
-    };
-  }
-  nextSeq() {
-    return this.sendBuffer.length > 0 ? this.sendBuffer[0].seq : this.seq;
-  }
-  send(msg) {
-    const encodeResult = this.encodeMsg(msg);
-    if (!encodeResult.ok) {
-      return encodeResult;
-    }
-    this.sendBuffer.push(encodeResult.value);
-    return {
-      ok: true,
-      value: encodeResult.value.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() {
-    super._handleClose();
-    this.bestEffortClose();
-  }
-};
-
-// transport/sessionStateMachine/SessionNoConnection.ts
-var SessionNoConnection = class extends IdentifiedSessionWithGracePeriod {
-  state = "NoConnection" /* NoConnection */;
-  _handleClose() {
-    super._handleClose();
-  }
-  _handleStateExit() {
-    super._handleStateExit();
-  }
-};
-
-// tracing/index.ts
-var import_api2 = require("@opentelemetry/api");
-
-// transport/stringifyError.ts
-function coerceErrorString(err) {
-  if (err instanceof Error) {
-    return err.message || "unknown reason";
-  }
-  return `[coerced to error] ${String(err)}`;
-}
-
-// package.json
-var version = "0.216.1";
-
-// tracing/index.ts
-function createSessionTelemetryInfo(tracer, sessionId, to, from, propagationCtx) {
-  const parentCtx = propagationCtx ? import_api2.propagation.extract(import_api2.context.active(), propagationCtx) : import_api2.context.active();
-  const span = tracer.startSpan(
-    `river.session`,
-    {
-      attributes: {
-        component: "river",
-        "river.session.id": sessionId,
-        "river.session.to": to,
-        "river.session.from": from
-      }
-    },
-    parentCtx
-  );
-  const ctx = import_api2.trace.setSpan(parentCtx, span);
-  return { span, ctx };
-}
-function createConnectionTelemetryInfo(tracer, connection, info) {
-  const span = tracer.startSpan(
-    `river.connection`,
-    {
-      attributes: {
-        component: "river",
-        "river.connection.id": connection.id
-      },
-      links: [{ context: info.span.spanContext() }]
-    },
-    info.ctx
-  );
-  const ctx = import_api2.trace.setSpan(info.ctx, span);
-  return { span, ctx };
-}
-function getTracer() {
-  return import_api2.trace.getTracer("river", version);
-}
-
-// 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.setDataListener(this.onHandshakeData);
-    this.conn.setErrorListener(this.listeners.onConnectionErrored);
-    this.conn.setCloseListener(this.listeners.onConnectionClosed);
-  }
-  get loggingMetadata() {
-    return {
-      clientId: this.from,
-      connId: this.conn.id,
-      ...this.conn.loggingMetadata
-    };
-  }
-  onHandshakeData = (msg) => {
-    const parsedMsgRes = this.codec.fromBuffer(msg);
-    if (!parsedMsgRes.ok) {
-      this.listeners.onInvalidHandshake(
-        `could not parse handshake message: ${parsedMsgRes.reason}`,
-        "MALFORMED_HANDSHAKE"
-      );
-      return;
-    }
-    this.listeners.onHandshake(parsedMsgRes.value);
-  };
-  sendHandshake(msg) {
-    const buff = this.codec.toBuffer(msg);
-    if (!buff.ok) {
-      return buff;
-    }
-    const sent = this.conn.send(buff.value);
-    if (!sent) {
-      return {
-        ok: false,
-        reason: "failed to send handshake"
-      };
-    }
-    return {
-      ok: true,
-      value: msg.id
-    };
-  }
-  _handleStateExit() {
-    this.conn.removeDataListener();
-    this.conn.removeErrorListener();
-    this.conn.removeCloseListener();
-    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.setDataListener(this.onHandshakeData);
-    this.conn.setErrorListener(this.listeners.onConnectionErrored);
-    this.conn.setCloseListener(this.listeners.onConnectionClosed);
-  }
-  get loggingMetadata() {
-    return {
-      ...super.loggingMetadata,
-      ...this.conn.loggingMetadata
-    };
-  }
-  onHandshakeData = (msg) => {
-    const parsedMsgRes = this.codec.fromBuffer(msg);
-    if (!parsedMsgRes.ok) {
-      this.listeners.onInvalidHandshake(
-        `could not parse handshake message: ${parsedMsgRes.reason}`,
-        "MALFORMED_HANDSHAKE"
-      );
-      return;
-    }
-    this.listeners.onHandshake(parsedMsgRes.value);
-  };
-  sendHandshake(msg) {
-    const buff = this.codec.toBuffer(msg);
-    if (!buff.ok) {
-      return buff;
-    }
-    const sent = this.conn.send(buff.value);
-    if (!sent) {
-      return {
-        ok: false,
-        reason: "failed to send handshake"
-      };
-    }
-    return {
-      ok: true,
-      value: msg.id
-    };
-  }
-  _handleStateExit() {
-    super._handleStateExit();
-    this.conn.removeDataListener();
-    this.conn.removeErrorListener();
-    this.conn.removeCloseListener();
-    if (this.handshakeTimeout) {
-      clearTimeout(this.handshakeTimeout);
-      this.handshakeTimeout = void 0;
-    }
-  }
-  _handleClose() {
-    super._handleClose();
-    this.conn.close();
-  }
-};
-
-// transport/sessionStateMachine/SessionConnected.ts
-var import_api3 = require("@opentelemetry/api");
-var SessionConnected = class extends IdentifiedSession {
-  state = "Connected" /* Connected */;
-  conn;
-  listeners;
-  heartbeatHandle;
-  heartbeatMissTimeout;
-  isActivelyHeartbeating = false;
-  updateBookkeeping(ack, seq) {
-    this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq >= ack);
-    this.ack = seq + 1;
-    if (this.heartbeatMissTimeout) {
-      clearTimeout(this.heartbeatMissTimeout);
-    }
-    this.startMissingHeartbeatTimeout();
-  }
-  assertSendOrdering(encodedMsg) {
-    if (encodedMsg.seq > this.seqSent + 1) {
-      const msg = `invariant violation: would have sent out of order msg (seq: ${encodedMsg.seq}, expected: ${this.seqSent} + 1)`;
-      this.log?.error(msg, {
-        ...this.loggingMetadata,
-        tags: ["invariant-violation"]
-      });
-      throw new Error(msg);
-    }
-  }
-  send(msg) {
-    const encodeResult = this.encodeMsg(msg);
-    if (!encodeResult.ok) {
-      return encodeResult;
-    }
-    const encodedMsg = encodeResult.value;
-    this.assertSendOrdering(encodedMsg);
-    this.sendBuffer.push(encodedMsg);
-    const sent = this.conn.send(encodedMsg.data);
-    if (!sent) {
-      const reason = "failed to send message";
-      this.listeners.onMessageSendFailure(
-        { ...encodedMsg.msg, seq: encodedMsg.seq },
-        reason
-      );
-      return { ok: false, reason };
-    }
-    this.seqSent = encodedMsg.seq;
-    return { ok: true, value: encodedMsg.id };
-  }
-  constructor(props) {
-    super(props);
-    this.conn = props.conn;
-    this.listeners = props.listeners;
-    this.conn.setDataListener(this.onMessageData);
-    this.conn.setCloseListener(this.listeners.onConnectionClosed);
-    this.conn.setErrorListener(this.listeners.onConnectionErrored);
-  }
-  sendBufferedMessages() {
-    if (this.sendBuffer.length > 0) {
-      this.log?.info(
-        `sending ${this.sendBuffer.length} buffered messages, starting at seq ${this.nextSeq()}`,
-        this.loggingMetadata
-      );
-      for (const msg of this.sendBuffer) {
-        this.assertSendOrdering(msg);
-        const sent = this.conn.send(msg.data);
-        if (!sent) {
-          const reason = "failed to send buffered message";
-          this.listeners.onMessageSendFailure(
-            { ...msg.msg, seq: msg.seq },
-            reason
-          );
-          return { ok: false, reason };
-        }
-        this.seqSent = msg.seq;
-      }
-    }
-    return { ok: true, value: void 0 };
-  }
-  get loggingMetadata() {
-    return {
-      ...super.loggingMetadata,
-      ...this.conn.loggingMetadata
-    };
-  }
-  startMissingHeartbeatTimeout() {
-    const maxMisses = this.options.heartbeatsUntilDead;
-    const missDuration = maxMisses * this.options.heartbeatIntervalMs;
-    this.heartbeatMissTimeout = setTimeout(() => {
-      this.log?.info(
-        `closing connection to ${this.to} due to inactivity (missed ${maxMisses} heartbeats which is ${missDuration}ms)`,
-        this.loggingMetadata
-      );
-      this.telemetry.span.addEvent(
-        "closing connection due to missing heartbeat"
-      );
-      this.conn.close();
-    }, missDuration);
-  }
-  startActiveHeartbeat() {
-    this.isActivelyHeartbeating = true;
-    this.heartbeatHandle = setInterval(() => {
-      this.sendHeartbeat();
-    }, this.options.heartbeatIntervalMs);
-  }
-  sendHeartbeat() {
-    this.log?.debug("sending heartbeat", this.loggingMetadata);
-    const heartbeat = {
-      streamId: "heartbeat",
-      controlFlags: 1 /* AckBit */,
-      payload: {
-        type: "ACK"
-      }
-    };
-    this.send(heartbeat);
-  }
-  onMessageData = (msg) => {
-    const parsedMsgRes = this.codec.fromBuffer(msg);
-    if (!parsedMsgRes.ok) {
-      this.listeners.onInvalidMessage(
-        `could not parse message: ${parsedMsgRes.reason}`
-      );
-      return;
-    }
-    const parsedMsg = parsedMsgRes.value;
-    if (parsedMsg.seq !== this.ack) {
-      if (parsedMsg.seq < this.ack) {
-        this.log?.debug(
-          `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: import_api3.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) {
-      this.sendHeartbeat();
-    }
-  };
-  _handleStateExit() {
-    super._handleStateExit();
-    this.conn.removeDataListener();
-    this.conn.removeCloseListener();
-    this.conn.removeErrorListener();
-    if (this.heartbeatHandle) {
-      clearInterval(this.heartbeatHandle);
-      this.heartbeatHandle = void 0;
-    }
-    if (this.heartbeatMissTimeout) {
-      clearTimeout(this.heartbeatMissTimeout);
-      this.heartbeatMissTimeout = void 0;
-    }
-  }
-  _handleClose() {
-    super._handleClose();
-    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;
-    }
-  }
-};
-
-// codec/adapter.ts
-var import_value = require("@sinclair/typebox/value");
-var CodecMessageAdapter = class {
-  constructor(codec) {
-    this.codec = codec;
-  }
-  toBuffer(msg) {
-    try {
-      return {
-        ok: true,
-        value: this.codec.toBuffer(msg)
-      };
-    } catch (e) {
-      return {
-        ok: false,
-        reason: coerceErrorString(e)
-      };
-    }
-  }
-  fromBuffer(buf) {
-    try {
-      const parsedMsg = this.codec.fromBuffer(buf);
-      if (!import_value.Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
-        return {
-          ok: false,
-          reason: "transport message schema mismatch"
-        };
-      }
-      return {
-        ok: true,
-        value: parsedMsg
-      };
-    } catch (e) {
-      return {
-        ok: false,
-        reason: coerceErrorString(e)
-      };
-    }
-  }
-};
-
-// transport/sessionStateMachine/transitions.ts
-function inheritSharedSession(session) {
-  return {
-    id: session.id,
-    from: session.from,
-    to: session.to,
-    seq: session.seq,
-    ack: session.ack,
-    seqSent: session.seqSent,
-    sendBuffer: session.sendBuffer,
-    telemetry: session.telemetry,
-    options: session.options,
-    log: session.log,
-    tracer: session.tracer,
-    protocolVersion: session.protocolVersion,
-    codec: session.codec
-  };
-}
-function inheritSharedSessionWithGrace(session) {
-  return {
-    ...inheritSharedSession(session),
-    graceExpiryTime: session.graceExpiryTime
-  };
-}
-var SessionStateGraph = {
-  entrypoints: {
-    NoConnection: (to, from, listeners, options, protocolVersion, tracer, log) => {
-      const id = `session-${generateId()}`;
-      const telemetry = createSessionTelemetryInfo(tracer, id, to, from);
-      const sendBuffer = [];
-      const session = new SessionNoConnection({
-        listeners,
-        id,
-        from,
-        to,
-        seq: 0,
-        ack: 0,
-        seqSent: 0,
-        graceExpiryTime: Date.now() + options.sessionDisconnectGraceMs,
-        sendBuffer,
-        telemetry,
-        options,
-        protocolVersion,
-        tracer,
-        log,
-        codec: new CodecMessageAdapter(options.codec)
-      });
-      session.log?.info(`session ${session.id} created in NoConnection state`, {
-        ...session.loggingMetadata,
-        tags: ["state-transition"]
-      });
-      return session;
-    },
-    WaitingForHandshake: (from, conn, listeners, options, tracer, log) => {
-      const session = new SessionWaitingForHandshake({
-        conn,
-        listeners,
-        from,
-        options,
-        tracer,
-        log,
-        codec: new CodecMessageAdapter(options.codec)
-      });
-      session.log?.info(`session created in WaitingForHandshake state`, {
-        ...session.loggingMetadata,
-        tags: ["state-transition"]
-      });
-      return session;
-    }
-  },
-  // All of the transitions 'move'/'consume' the old session and return a new one.
-  // After a session is transitioned, any usage of the old session will throw.
-  transition: {
-    // happy path transitions
-    NoConnectionToBackingOff: (oldSession, backoffMs, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession._handleStateExit();
-      const session = new SessionBackingOff({
-        backoffMs,
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from NoConnection to BackingOff`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    BackingOffToConnecting: (oldSession, connPromise, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession._handleStateExit();
-      const session = new SessionConnecting({
-        connPromise,
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from BackingOff to Connecting`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    ConnectingToHandshaking: (oldSession, conn, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession._handleStateExit();
-      const session = new SessionHandshaking({
-        conn,
-        listeners,
-        ...carriedState
-      });
-      conn.telemetry = createConnectionTelemetryInfo(
-        session.tracer,
-        conn,
-        session.telemetry
-      );
-      session.log?.info(
-        `session ${session.id} transition from Connecting to Handshaking`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    HandshakingToConnected: (oldSession, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
-      const conn = oldSession.conn;
-      oldSession._handleStateExit();
-      const session = new SessionConnected({
-        conn,
-        listeners,
-        ...carriedState
-      });
-      session.startMissingHeartbeatTimeout();
-      session.log?.info(
-        `session ${session.id} transition from Handshaking to Connected`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    WaitingForHandshakeToConnected: (pendingSession, oldSession, sessionId, to, propagationCtx, listeners, protocolVersion) => {
-      const conn = pendingSession.conn;
-      const { from, options } = pendingSession;
-      const carriedState = oldSession ? (
-        // old session exists, inherit state
-        inheritSharedSession(oldSession)
-      ) : (
-        // old session does not exist, create new state
-        {
-          id: sessionId,
-          from,
-          to,
-          seq: 0,
-          ack: 0,
-          seqSent: 0,
-          sendBuffer: [],
-          telemetry: createSessionTelemetryInfo(
-            pendingSession.tracer,
-            sessionId,
-            to,
-            from,
-            propagationCtx
-          ),
-          options,
-          tracer: pendingSession.tracer,
-          log: pendingSession.log,
-          protocolVersion,
-          codec: new CodecMessageAdapter(options.codec)
-        }
-      );
-      pendingSession._handleStateExit();
-      oldSession?._handleStateExit();
-      const session = new SessionConnected({
-        conn,
-        listeners,
-        ...carriedState
-      });
-      session.startMissingHeartbeatTimeout();
-      conn.telemetry = createConnectionTelemetryInfo(
-        session.tracer,
-        conn,
-        session.telemetry
-      );
-      session.log?.info(
-        `session ${session.id} transition from WaitingForHandshake to Connected`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    // disconnect paths
-    BackingOffToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection({
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from BackingOff to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    ConnectingToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession.bestEffortClose();
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection({
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from Connecting to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    HandshakingToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSessionWithGrace(oldSession);
-      oldSession.conn.close();
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection({
-        listeners,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from Handshaking to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    },
-    ConnectedToNoConnection: (oldSession, listeners) => {
-      const carriedState = inheritSharedSession(oldSession);
-      const graceExpiryTime = Date.now() + oldSession.options.sessionDisconnectGraceMs;
-      oldSession.conn.close();
-      oldSession._handleStateExit();
-      const session = new SessionNoConnection({
-        listeners,
-        graceExpiryTime,
-        ...carriedState
-      });
-      session.log?.info(
-        `session ${session.id} transition from Connected to NoConnection`,
-        {
-          ...session.loggingMetadata,
-          tags: ["state-transition"]
-        }
-      );
-      return session;
-    }
-  }
-};
-var transitions = SessionStateGraph.transition;
-var ClientSessionStateGraph = {
-  entrypoint: SessionStateGraph.entrypoints.NoConnection,
-  transition: {
-    // happy paths
-    // NoConnection -> BackingOff: attempt to connect
-    NoConnectionToBackingOff: transitions.NoConnectionToBackingOff,
-    // BackingOff -> Connecting: backoff period elapsed, start connection
-    BackingOffToConnecting: transitions.BackingOffToConnecting,
-    // Connecting -> Handshaking: connection established, start handshake
-    ConnectingToHandshaking: transitions.ConnectingToHandshaking,
-    // Handshaking -> Connected: handshake complete, session ready
-    HandshakingToConnected: transitions.HandshakingToConnected,
-    // disconnect paths
-    // BackingOff -> NoConnection: unused
-    BackingOffToNoConnection: transitions.BackingOffToNoConnection,
-    // Connecting -> NoConnection: connection failed or connection timeout
-    ConnectingToNoConnection: transitions.ConnectingToNoConnection,
-    // Handshaking -> NoConnection: connection closed or handshake timeout
-    HandshakingToNoConnection: transitions.HandshakingToNoConnection,
-    // Connected -> NoConnection: connection closed
-    ConnectedToNoConnection: transitions.ConnectedToNoConnection
-    // destroy/close paths
-    // NoConnection -> x: grace period elapsed
-    // BackingOff -> x: grace period elapsed
-    // Connecting -> x: grace period elapsed
-    // Handshaking -> x: grace period elapsed or invalid handshake message or handshake rejection
-    // Connected -> x: grace period elapsed or invalid message
-  }
-};
-var ServerSessionStateGraph = {
-  entrypoint: SessionStateGraph.entrypoints.WaitingForHandshake,
-  transition: {
-    // happy paths
-    // WaitingForHandshake -> Connected: handshake complete, session ready
-    WaitingForHandshakeToConnected: transitions.WaitingForHandshakeToConnected,
-    // disconnect paths
-    // Connected -> NoConnection: connection closed
-    ConnectedToNoConnection: transitions.ConnectedToNoConnection
-    // destroy/close paths
-    // WaitingForHandshake -> x: handshake timeout elapsed or invalid handshake message or handshake rejection or connection closed
-  }
-};
-
-// 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?.info(
-      `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);
-      },
-      onMessageSendFailure: (msg, reason) => {
-        this.log?.error(`failed to send message: ${reason}`, {
-          ...noConnectionSession.loggingMetadata,
-          transportMessage: msg
-        });
-        this.protocolError({
-          type: ProtocolError.MessageSendFailure,
-          message: reason
-        });
-        this.deleteSession(noConnectionSession, { unhealthy: true });
-      }
-    });
-    this.updateSession(noConnectionSession);
-    return noConnectionSession;
-  }
-  onConnClosed(session) {
-    let noConnectionSession;
-    const listeners = {
-      onSessionGracePeriodElapsed: () => {
-        this.onSessionGracePeriodElapsed(noConnectionSession);
-      },
-      onMessageSendFailure: (msg, reason) => {
-        this.log?.error(`failed to send message: ${reason}`, {
-          ...noConnectionSession.loggingMetadata,
-          transportMessage: msg
-        });
-        this.protocolError({
-          type: ProtocolError.MessageSendFailure,
-          message: reason
-        });
-        this.deleteSession(noConnectionSession, { unhealthy: true });
-      }
-    };
-    if (session.state === "Handshaking" /* Handshaking */) {
-      noConnectionSession = SessionStateGraph.transition.HandshakingToNoConnection(
-        session,
-        listeners
-      );
-    } else {
-      noConnectionSession = SessionStateGraph.transition.ConnectedToNoConnection(
-        session,
-        listeners
-      );
-    }
-    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 || session._isConsumed) {
-        throw new Error(
-          `session scope for ${sessionId} has ended (transition), can't send`
-        );
-      }
-      const res = session.send(msg);
-      if (!res.ok) {
-        throw new Error(res.reason);
-      }
-      return res.value;
-    };
-  }
-};
-
-// transport/server.ts
-var import_value2 = require("@sinclair/typebox/value");
-var ServerTransport = class extends Transport {
-  /**
-   * The options for this transport.
-   */
-  options;
-  /**
-   * Optional handshake options for the server.
-   */
-  handshakeExtensions;
-  /**
-   * A map of session handshake data for each session.
-   */
-  sessionHandshakeMetadata = /* @__PURE__ */ new Map();
-  sessions = /* @__PURE__ */ new Map();
-  pendingSessions = /* @__PURE__ */ new Set();
-  constructor(clientId, providedOptions) {
-    super(clientId, providedOptions);
-    this.sessions = /* @__PURE__ */ new Map();
-    this.options = {
-      ...defaultServerTransportOptions,
-      ...providedOptions
-    };
-    this.log?.info(`initiated server transport`, {
-      clientId: this.clientId,
-      protocolVersion: currentProtocolVersion
-    });
-  }
-  extendHandshake(options) {
-    this.handshakeExtensions = options;
-  }
-  deletePendingSession(pendingSession) {
-    pendingSession.close();
-    this.pendingSessions.delete(pendingSession);
-  }
-  deleteSession(session, options) {
-    this.sessionHandshakeMetadata.delete(session.to);
-    super.deleteSession(session, options);
-  }
-  handleConnection(conn) {
-    if (this.getStatus() !== "open") return;
-    this.log?.info(`new incoming connection`, {
-      ...conn.loggingMetadata,
-      clientId: this.clientId
-    });
-    let receivedHandshake = false;
-    const pendingSession = ServerSessionStateGraph.entrypoint(
-      this.clientId,
-      conn,
-      {
-        onConnectionClosed: () => {
-          this.log?.warn(
-            `connection from unknown closed before handshake finished`,
-            pendingSession.loggingMetadata
-          );
-          this.deletePendingSession(pendingSession);
-        },
-        onConnectionErrored: (err) => {
-          const errorString = coerceErrorString(err);
-          this.log?.warn(
-            `connection from unknown errored before handshake finished: ${errorString}`,
-            pendingSession.loggingMetadata
-          );
-          this.deletePendingSession(pendingSession);
-        },
-        onHandshakeTimeout: () => {
-          this.log?.warn(
-            `connection from unknown timed out before handshake finished`,
-            pendingSession.loggingMetadata
-          );
-          this.deletePendingSession(pendingSession);
-        },
-        onHandshake: (msg) => {
-          if (receivedHandshake) {
-            this.log?.error(
-              `received multiple handshake messages from pending session`,
-              {
-                ...pendingSession.loggingMetadata,
-                connectedTo: msg.from,
-                transportMessage: msg
-              }
-            );
-            this.deletePendingSession(pendingSession);
-            return;
-          }
-          receivedHandshake = true;
-          void this.onHandshakeRequest(pendingSession, msg);
-        },
-        onInvalidHandshake: (reason, code) => {
-          this.log?.error(
-            `invalid handshake: ${reason}`,
-            pendingSession.loggingMetadata
-          );
-          this.deletePendingSession(pendingSession);
-          this.protocolError({
-            type: ProtocolError.HandshakeFailed,
-            code,
-            message: reason
-          });
-        }
-      },
-      this.options,
-      this.tracer,
-      this.log
-    );
-    this.pendingSessions.add(pendingSession);
-  }
-  rejectHandshakeRequest(session, to, reason, code, metadata) {
-    session.conn.telemetry?.span.setStatus({
-      code: import_api4.SpanStatusCode.ERROR,
-      message: reason
-    });
-    this.log?.warn(reason, metadata);
-    const responseMsg = handshakeResponseMessage({
-      from: this.clientId,
-      to,
-      status: {
-        ok: false,
-        code,
-        reason
-      }
-    });
-    const res = session.sendHandshake(responseMsg);
-    if (!res.ok) {
-      this.log?.error(`failed to send handshake response: ${res.reason}`, {
-        ...session.loggingMetadata,
-        transportMessage: responseMsg
-      });
-      this.protocolError({
-        type: ProtocolError.MessageSendFailure,
-        message: res.reason
-      });
-      this.deletePendingSession(session);
-      return;
-    }
-    this.protocolError({
-      type: ProtocolError.HandshakeFailed,
-      code,
-      message: reason
-    });
-    this.deletePendingSession(session);
-  }
-  async onHandshakeRequest(session, msg) {
-    if (!import_value2.Value.Check(ControlMessageHandshakeRequestSchema, msg.payload)) {
-      this.rejectHandshakeRequest(
-        session,
-        msg.from,
-        "received invalid handshake request",
-        "MALFORMED_HANDSHAKE",
-        {
-          ...session.loggingMetadata,
-          transportMessage: msg,
-          connectedTo: msg.from,
-          validationErrors: [
-            ...import_value2.Value.Errors(ControlMessageHandshakeRequestSchema, msg.payload)
-          ]
-        }
-      );
-      return;
-    }
-    const gotVersion = msg.payload.protocolVersion;
-    if (!isAcceptedProtocolVersion(gotVersion)) {
-      this.rejectHandshakeRequest(
-        session,
-        msg.from,
-        `expected protocol version oneof [${acceptedProtocolVersions.toString()}], got ${gotVersion}`,
-        "PROTOCOL_VERSION_MISMATCH",
-        {
-          ...session.loggingMetadata,
-          connectedTo: msg.from,
-          transportMessage: msg
-        }
-      );
-      return;
-    }
-    let parsedMetadata = {};
-    if (this.handshakeExtensions) {
-      if (!import_value2.Value.Check(this.handshakeExtensions.schema, msg.payload.metadata)) {
-        this.rejectHandshakeRequest(
-          session,
-          msg.from,
-          "received malformed handshake metadata",
-          "MALFORMED_HANDSHAKE_META",
-          {
-            ...session.loggingMetadata,
-            connectedTo: msg.from,
-            validationErrors: [
-              ...import_value2.Value.Errors(
-                this.handshakeExtensions.schema,
-                msg.payload.metadata
-              )
-            ]
-          }
-        );
-        return;
-      }
-      const previousParsedMetadata = this.sessionHandshakeMetadata.get(
-        msg.from
-      );
-      let parsedMetadataOrFailureCode;
-      try {
-        parsedMetadataOrFailureCode = await this.handshakeExtensions.validate(
-          msg.payload.metadata,
-          previousParsedMetadata
-        );
-      } catch (err) {
-        this.rejectHandshakeRequest(
-          session,
-          msg.from,
-          `handshake validation threw: ${coerceErrorString(err)}`,
-          "REJECTED_BY_CUSTOM_HANDLER",
-          {
-            ...session.loggingMetadata,
-            connectedTo: msg.from,
-            clientId: this.clientId
-          }
-        );
-        return;
-      }
-      if (session._isConsumed) {
-        return;
-      }
-      if (import_value2.Value.Check(
-        HandshakeErrorCustomHandlerFatalResponseCodes,
-        parsedMetadataOrFailureCode
-      )) {
-        this.rejectHandshakeRequest(
-          session,
-          msg.from,
-          "rejected by handshake handler",
-          parsedMetadataOrFailureCode,
-          {
-            ...session.loggingMetadata,
-            connectedTo: msg.from,
-            clientId: this.clientId
-          }
-        );
-        return;
-      }
-      parsedMetadata = parsedMetadataOrFailureCode;
-    }
-    let connectCase = "new session";
-    const clientNextExpectedSeq = msg.payload.expectedSessionState.nextExpectedSeq;
-    const clientNextSentSeq = msg.payload.expectedSessionState.nextSentSeq;
-    let oldSession = this.sessions.get(msg.from);
-    if (this.options.enableTransparentSessionReconnects && oldSession && oldSession.id === msg.payload.sessionId) {
-      connectCase = "transparent reconnection";
-      const ourNextSeq = oldSession.nextSeq();
-      const ourAck = oldSession.ack;
-      if (clientNextSentSeq > ourAck) {
-        this.rejectHandshakeRequest(
-          session,
-          msg.from,
-          `client is in the future: server wanted next message to be ${ourAck} but client would have sent ${clientNextSentSeq}`,
-          "SESSION_STATE_MISMATCH",
-          {
-            ...session.loggingMetadata,
-            connectedTo: msg.from,
-            transportMessage: msg
-          }
-        );
-        return;
-      }
-      if (ourNextSeq > clientNextExpectedSeq) {
-        this.rejectHandshakeRequest(
-          session,
-          msg.from,
-          `server is in the future: client wanted next message to be ${clientNextExpectedSeq} but server would have sent ${ourNextSeq}`,
-          "SESSION_STATE_MISMATCH",
-          {
-            ...session.loggingMetadata,
-            connectedTo: msg.from,
-            transportMessage: msg
-          }
-        );
-        return;
-      }
-      if (oldSession.state !== "NoConnection" /* NoConnection */) {
-        const noConnectionSession = ServerSessionStateGraph.transition.ConnectedToNoConnection(
-          oldSession,
-          {
-            onSessionGracePeriodElapsed: () => {
-              this.onSessionGracePeriodElapsed(noConnectionSession);
-            },
-            onMessageSendFailure: (msg2, reason) => {
-              this.log?.error(`failed to send message: ${reason}`, {
-                ...noConnectionSession.loggingMetadata,
-                transportMessage: msg2
-              });
-              this.protocolError({
-                type: ProtocolError.MessageSendFailure,
-                message: reason
-              });
-              this.deleteSession(noConnectionSession, { unhealthy: true });
-            }
-          }
-        );
-        oldSession = noConnectionSession;
-        this.updateSession(oldSession);
-      }
-    } else if (oldSession) {
-      connectCase = "hard reconnection";
-      this.log?.info(
-        `client is reconnecting to a new session (${msg.payload.sessionId}) with an old session (${oldSession.id}) already existing, closing old session`,
-        {
-          ...session.loggingMetadata,
-          connectedTo: msg.from,
-          sessionId: msg.payload.sessionId
-        }
-      );
-      this.deleteSession(oldSession);
-      oldSession = void 0;
-    }
-    if (!oldSession && (clientNextSentSeq > 0 || clientNextExpectedSeq > 0)) {
-      connectCase = "unknown session";
-      const rejectionMessage = this.options.enableTransparentSessionReconnects ? `client is trying to reconnect to a session the server don't know about: ${msg.payload.sessionId}` : `client is attempting a transparent reconnect to a session but the server does not support it: ${msg.payload.sessionId}`;
-      this.rejectHandshakeRequest(
-        session,
-        msg.from,
-        rejectionMessage,
-        "SESSION_STATE_MISMATCH",
-        {
-          ...session.loggingMetadata,
-          connectedTo: msg.from,
-          transportMessage: msg
-        }
-      );
-      return;
-    }
-    const sessionId = msg.payload.sessionId;
-    this.log?.info(
-      `handshake from ${msg.from} ok (${connectCase}), responding with handshake success`,
-      {
-        ...session.loggingMetadata,
-        connectedTo: msg.from
-      }
-    );
-    const responseMsg = handshakeResponseMessage({
-      from: this.clientId,
-      to: msg.from,
-      status: {
-        ok: true,
-        sessionId
-      }
-    });
-    const res = session.sendHandshake(responseMsg);
-    if (!res.ok) {
-      this.log?.error(`failed to send handshake response: ${res.reason}`, {
-        ...session.loggingMetadata,
-        transportMessage: responseMsg
-      });
-      this.protocolError({
-        type: ProtocolError.MessageSendFailure,
-        message: res.reason
-      });
-      this.deletePendingSession(session);
-      return;
-    }
-    this.pendingSessions.delete(session);
-    const connectedSession = ServerSessionStateGraph.transition.WaitingForHandshakeToConnected(
-      session,
-      // by this point oldSession is either no connection or we dont have an old session
-      oldSession,
-      sessionId,
-      msg.from,
-      msg.tracing,
-      {
-        onConnectionErrored: (err) => {
-          const errStr = coerceErrorString(err);
-          this.log?.warn(
-            `connection to ${connectedSession.to} errored: ${errStr}`,
-            connectedSession.loggingMetadata
-          );
-        },
-        onConnectionClosed: () => {
-          this.log?.info(
-            `connection to ${connectedSession.to} closed`,
-            connectedSession.loggingMetadata
-          );
-          this.onConnClosed(connectedSession);
-        },
-        onMessage: (msg2) => {
-          this.handleMsg(msg2);
-        },
-        onInvalidMessage: (reason) => {
-          this.log?.error(`invalid message: ${reason}`, {
-            ...connectedSession.loggingMetadata,
-            transportMessage: msg
-          });
-          this.protocolError({
-            type: ProtocolError.InvalidMessage,
-            message: reason
-          });
-          this.deleteSession(connectedSession, { unhealthy: true });
-        },
-        onMessageSendFailure: (msg2, reason) => {
-          this.log?.error(`failed to send message: ${reason}`, {
-            ...connectedSession.loggingMetadata,
-            transportMessage: msg2
-          });
-          this.protocolError({
-            type: ProtocolError.MessageSendFailure,
-            message: reason
-          });
-          this.deleteSession(connectedSession, { unhealthy: true });
-        }
-      },
-      gotVersion
-    );
-    const bufferSendRes = connectedSession.sendBufferedMessages();
-    if (!bufferSendRes.ok) {
-      return;
-    }
-    this.sessionHandshakeMetadata.set(connectedSession.to, parsedMetadata);
-    if (oldSession) {
-      this.updateSession(connectedSession);
-    } else {
-      this.createSession(connectedSession);
-    }
-    connectedSession.startActiveHeartbeat();
-  }
-};
-
-// transport/impls/ws/server.ts
-function cleanHeaders(headers) {
-  const cleanedHeaders = {};
-  for (const [key, value] of Object.entries(headers)) {
-    if (!key.startsWith("sec-") && value) {
-      const cleanedValue = Array.isArray(value) ? value[0] : value;
-      cleanedHeaders[key] = cleanedValue;
-    }
-  }
-  return cleanedHeaders;
-}
-var WebSocketServerTransport = class extends ServerTransport {
-  wss;
-  constructor(wss, clientId, providedOptions) {
-    super(clientId, providedOptions);
-    this.wss = wss;
-    this.wss.on("connection", this.connectionHandler);
-  }
-  connectionHandler = (ws, req) => {
-    const conn = new WebSocketConnection(ws, {
-      headers: cleanHeaders(req.headersDistinct)
-    });
-    this.handleConnection(conn);
-  };
-  close() {
-    super.close();
-    this.wss.off("connection", this.connectionHandler);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WebSocketServerTransport
-});
-//# sourceMappingURL=server.cjs.map