@replit/river 0.216.0 → 0.217.1

package/dist/testUtil/index.cjs

@@ -1,3051 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// testUtil/index.ts
-var testUtil_exports = {};
-__export(testUtil_exports, {
-  InMemoryConnection: () => InMemoryConnection,
-  closeAllConnections: () => closeAllConnections,
-  createDummyTransportMessage: () => createDummyTransportMessage,
-  createLocalWebSocketClient: () => createLocalWebSocketClient,
-  createMockTransportNetwork: () => createMockTransportNetwork,
-  createPartialContext: () => createPartialContext,
-  createWebSocketServer: () => createWebSocketServer,
-  dummySession: () => dummySession,
-  getClientSendFn: () => getClientSendFn,
-  getReadableIterator: () => getReadableIterator,
-  getServerSendFn: () => getServerSendFn,
-  getTransportConnections: () => getTransportConnections,
-  isReadableDone: () => isReadableDone,
-  numberOfConnections: () => numberOfConnections,
-  onWsServerReady: () => onWsServerReady,
-  payloadToTransportMessage: () => payloadToTransportMessage,
-  readNextResult: () => readNextResult,
-  testingClientSessionOptions: () => testingClientSessionOptions,
-  testingSessionOptions: () => testingSessionOptions,
-  waitForMessage: () => waitForMessage
-});
-module.exports = __toCommonJS(testUtil_exports);
-var import_ws = __toESM(require("ws"), 1);
-
-// transport/message.ts
-var import_typebox = require("@sinclair/typebox");
-
-// transport/id.ts
-var import_nanoid = require("nanoid");
-var alphabet = (0, import_nanoid.customAlphabet)(
-  "1234567890abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ"
-);
-var generateId = () => alphabet(12);
-
-// transport/message.ts
-var TransportMessageSchema = (t) => import_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 handshakeRequestMessage({
-  from,
-  to,
-  sessionId,
-  expectedSessionState,
-  metadata,
-  tracing
-}) {
-  return {
-    id: generateId(),
-    from,
-    to,
-    seq: 0,
-    ack: 0,
-    streamId: generateId(),
-    controlFlags: 0,
-    tracing,
-    payload: {
-      type: "HANDSHAKE_REQ",
-      protocolVersion: currentProtocolVersion,
-      sessionId,
-      expectedSessionState,
-      metadata
-    }
-  };
-}
-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
-};
-
-// 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_api = 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.0";
-
-// tracing/index.ts
-function getPropagationContext(ctx) {
-  const tracing = {
-    traceparent: "",
-    tracestate: ""
-  };
-  import_api.propagation.inject(ctx, tracing);
-  return tracing;
-}
-function createSessionTelemetryInfo(tracer, sessionId, to, from, propagationCtx) {
-  const parentCtx = propagationCtx ? import_api.propagation.extract(import_api.context.active(), propagationCtx) : import_api.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_api.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_api.trace.setSpan(info.ctx, span);
-  return { span, ctx };
-}
-function getTracer() {
-  return import_api.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_api2 = 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_api2.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_value3 = require("@sinclair/typebox/value");
-
-// logging/log.ts
-var import_api3 = 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_api3.trace.getSpan(import_api3.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/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/client.ts
-var import_api4 = require("@opentelemetry/api");
-
-// transport/rateLimit.ts
-var LeakyBucketRateLimit = class {
-  budgetConsumed;
-  intervalHandle;
-  options;
-  constructor(options) {
-    this.options = options;
-    this.budgetConsumed = 0;
-  }
-  getBackoffMs() {
-    if (this.getBudgetConsumed() === 0) {
-      return 0;
-    }
-    const exponent = Math.max(0, this.getBudgetConsumed() - 1);
-    const jitter = Math.floor(Math.random() * this.options.maxJitterMs);
-    const backoffMs = Math.min(
-      this.options.baseIntervalMs * 2 ** exponent,
-      this.options.maxBackoffMs
-    );
-    return backoffMs + jitter;
-  }
-  get totalBudgetRestoreTime() {
-    return this.options.budgetRestoreIntervalMs * this.options.attemptBudgetCapacity;
-  }
-  consumeBudget() {
-    this.stopLeak();
-    this.budgetConsumed = this.getBudgetConsumed() + 1;
-  }
-  getBudgetConsumed() {
-    return this.budgetConsumed;
-  }
-  hasBudget() {
-    return this.getBudgetConsumed() < this.options.attemptBudgetCapacity;
-  }
-  startRestoringBudget() {
-    if (this.intervalHandle) {
-      return;
-    }
-    const restoreBudgetForUser = () => {
-      const currentBudget = this.budgetConsumed;
-      if (!currentBudget) {
-        this.stopLeak();
-        return;
-      }
-      const newBudget = currentBudget - 1;
-      if (newBudget === 0) {
-        return;
-      }
-      this.budgetConsumed = newBudget;
-    };
-    this.intervalHandle = setInterval(
-      restoreBudgetForUser,
-      this.options.budgetRestoreIntervalMs
-    );
-  }
-  stopLeak() {
-    if (!this.intervalHandle) {
-      return;
-    }
-    clearInterval(this.intervalHandle);
-    this.intervalHandle = void 0;
-  }
-  resetBudget() {
-    this.stopLeak();
-    this.budgetConsumed = 0;
-  }
-  close() {
-    this.stopLeak();
-  }
-};
-
-// transport/client.ts
-var import_value = require("@sinclair/typebox/value");
-var ClientTransport = class extends Transport {
-  /**
-   * The options for this transport.
-   */
-  options;
-  retryBudget;
-  /**
-   * A flag indicating whether the transport should automatically reconnect
-   * when a connection is dropped.
-   * Realistically, this should always be true for clients unless you are writing
-   * tests or a special case where you don't want to reconnect.
-   */
-  reconnectOnConnectionDrop = true;
-  /**
-   * Optional handshake options for this client.
-   */
-  handshakeExtensions;
-  sessions;
-  constructor(clientId, providedOptions) {
-    super(clientId, providedOptions);
-    this.sessions = /* @__PURE__ */ new Map();
-    this.options = {
-      ...defaultClientTransportOptions,
-      ...providedOptions
-    };
-    this.retryBudget = new LeakyBucketRateLimit(this.options);
-  }
-  extendHandshake(options) {
-    this.handshakeExtensions = options;
-  }
-  tryReconnecting(to) {
-    const oldSession = this.sessions.get(to);
-    if (!this.options.enableTransparentSessionReconnects && oldSession) {
-      this.deleteSession(oldSession);
-    }
-    if (this.reconnectOnConnectionDrop && this.getStatus() === "open") {
-      this.connect(to);
-    }
-  }
-  /*
-   * Creates a raw unconnected session object.
-   * This is mostly a River internal, you shouldn't need to use this directly.
-   */
-  createUnconnectedSession(to) {
-    const session = ClientSessionStateGraph.entrypoint(
-      to,
-      this.clientId,
-      {
-        onSessionGracePeriodElapsed: () => {
-          this.onSessionGracePeriodElapsed(session);
-        },
-        onMessageSendFailure: (msg, reason) => {
-          this.log?.error(`failed to send message: ${reason}`, {
-            ...session.loggingMetadata,
-            transportMessage: msg
-          });
-          this.protocolError({
-            type: ProtocolError.MessageSendFailure,
-            message: reason
-          });
-          this.deleteSession(session, { unhealthy: true });
-        }
-      },
-      this.options,
-      currentProtocolVersion,
-      this.tracer,
-      this.log
-    );
-    this.createSession(session);
-    return session;
-  }
-  // listeners
-  onConnectingFailed(session) {
-    const noConnectionSession = super.onConnectingFailed(session);
-    this.tryReconnecting(noConnectionSession.to);
-    return noConnectionSession;
-  }
-  onConnClosed(session) {
-    const noConnectionSession = super.onConnClosed(session);
-    this.tryReconnecting(noConnectionSession.to);
-    return noConnectionSession;
-  }
-  onConnectionEstablished(session, conn) {
-    const handshakingSession = ClientSessionStateGraph.transition.ConnectingToHandshaking(
-      session,
-      conn,
-      {
-        onConnectionErrored: (err) => {
-          const errStr = coerceErrorString(err);
-          this.log?.error(
-            `connection to ${handshakingSession.to} errored during handshake: ${errStr}`,
-            handshakingSession.loggingMetadata
-          );
-        },
-        onConnectionClosed: () => {
-          this.log?.warn(
-            `connection to ${handshakingSession.to} closed during handshake`,
-            handshakingSession.loggingMetadata
-          );
-          this.onConnClosed(handshakingSession);
-        },
-        onHandshake: (msg) => {
-          this.onHandshakeResponse(handshakingSession, msg);
-        },
-        onInvalidHandshake: (reason, code) => {
-          this.log?.error(
-            `invalid handshake: ${reason}`,
-            handshakingSession.loggingMetadata
-          );
-          this.deleteSession(session, { unhealthy: true });
-          this.protocolError({
-            type: ProtocolError.HandshakeFailed,
-            code,
-            message: reason
-          });
-        },
-        onHandshakeTimeout: () => {
-          this.log?.error(
-            `connection to ${handshakingSession.to} timed out during handshake`,
-            handshakingSession.loggingMetadata
-          );
-          this.onConnClosed(handshakingSession);
-        },
-        onSessionGracePeriodElapsed: () => {
-          this.onSessionGracePeriodElapsed(handshakingSession);
-        },
-        onMessageSendFailure: (msg, reason) => {
-          this.log?.error(`failed to send message: ${reason}`, {
-            ...handshakingSession.loggingMetadata,
-            transportMessage: msg
-          });
-          this.protocolError({
-            type: ProtocolError.MessageSendFailure,
-            message: reason
-          });
-          this.deleteSession(handshakingSession, { unhealthy: true });
-        }
-      }
-    );
-    this.updateSession(handshakingSession);
-    void this.sendHandshake(handshakingSession);
-    return handshakingSession;
-  }
-  rejectHandshakeResponse(session, reason, metadata) {
-    session.conn.telemetry?.span.setStatus({
-      code: import_api4.SpanStatusCode.ERROR,
-      message: reason
-    });
-    this.log?.warn(reason, metadata);
-    this.deleteSession(session, { unhealthy: true });
-  }
-  onHandshakeResponse(session, msg) {
-    if (!import_value.Value.Check(ControlMessageHandshakeResponseSchema, msg.payload)) {
-      const reason = `received invalid handshake response`;
-      this.rejectHandshakeResponse(session, reason, {
-        ...session.loggingMetadata,
-        transportMessage: msg,
-        validationErrors: [
-          ...import_value.Value.Errors(ControlMessageHandshakeResponseSchema, msg.payload)
-        ]
-      });
-      return;
-    }
-    if (!msg.payload.status.ok) {
-      const retriable = import_value.Value.Check(
-        HandshakeErrorRetriableResponseCodes,
-        msg.payload.status.code
-      );
-      const reason = `handshake failed: ${msg.payload.status.reason}`;
-      const to = session.to;
-      this.rejectHandshakeResponse(session, reason, {
-        ...session.loggingMetadata,
-        transportMessage: msg
-      });
-      if (retriable) {
-        this.tryReconnecting(to);
-      } else {
-        this.protocolError({
-          type: ProtocolError.HandshakeFailed,
-          code: msg.payload.status.code,
-          message: reason
-        });
-      }
-      return;
-    }
-    if (msg.payload.status.sessionId !== session.id) {
-      const reason = `session id mismatch: expected ${session.id}, got ${msg.payload.status.sessionId}`;
-      this.rejectHandshakeResponse(session, reason, {
-        ...session.loggingMetadata,
-        transportMessage: msg
-      });
-      return;
-    }
-    this.log?.info(`handshake from ${msg.from} ok`, {
-      ...session.loggingMetadata,
-      transportMessage: msg
-    });
-    const connectedSession = ClientSessionStateGraph.transition.HandshakingToConnected(session, {
-      onConnectionErrored: (err) => {
-        const errStr = coerceErrorString(err);
-        if (err instanceof Error && this.options.isFatalConnectionError(err)) {
-          this.log?.warn(
-            `connection to ${connectedSession.to} fatally errored: ${errStr}`,
-            connectedSession.loggingMetadata
-          );
-          this.reconnectOnConnectionDrop = false;
-        } else {
-          this.log?.warn(
-            `connection to ${connectedSession.to} errored: ${errStr}`,
-            connectedSession.loggingMetadata
-          );
-        }
-      },
-      onConnectionClosed: () => {
-        this.log?.info(
-          `connection to ${connectedSession.to} closed`,
-          connectedSession.loggingMetadata
-        );
-        this.onConnClosed(connectedSession);
-      },
-      onMessage: (msg2) => {
-        this.handleMsg(msg2);
-      },
-      onInvalidMessage: (reason) => {
-        this.log?.error(`invalid message: ${reason}`, {
-          ...connectedSession.loggingMetadata,
-          transportMessage: msg
-        });
-        this.protocolError({
-          type: ProtocolError.InvalidMessage,
-          message: reason
-        });
-        this.deleteSession(connectedSession, { unhealthy: true });
-      },
-      onMessageSendFailure: (msg2, reason) => {
-        this.log?.error(`failed to send message: ${reason}`, {
-          ...connectedSession.loggingMetadata,
-          transportMessage: msg2
-        });
-        this.protocolError({
-          type: ProtocolError.MessageSendFailure,
-          message: reason
-        });
-        this.deleteSession(connectedSession, { unhealthy: true });
-      }
-    });
-    const res = connectedSession.sendBufferedMessages();
-    if (!res.ok) {
-      return;
-    }
-    this.updateSession(connectedSession);
-    this.retryBudget.startRestoringBudget();
-  }
-  /**
-   * Manually attempts to connect to a client.
-   * @param to The client ID of the node to connect to.
-   */
-  connect(to) {
-    if (this.getStatus() !== "open") {
-      this.log?.info(
-        `transport state is no longer open, cancelling attempt to connect to ${to}`
-      );
-      return;
-    }
-    const session = this.sessions.get(to) ?? this.createUnconnectedSession(to);
-    if (session.state !== "NoConnection" /* NoConnection */) {
-      this.log?.debug(
-        `session to ${to} has state ${session.state}, skipping connect attempt`,
-        session.loggingMetadata
-      );
-      return;
-    }
-    if (!this.retryBudget.hasBudget()) {
-      const budgetConsumed = this.retryBudget.getBudgetConsumed();
-      const errMsg = `tried to connect to ${to} but retry budget exceeded (more than ${budgetConsumed} attempts in the last ${this.retryBudget.totalBudgetRestoreTime}ms)`;
-      this.log?.error(errMsg, session.loggingMetadata);
-      this.protocolError({
-        type: ProtocolError.RetriesExceeded,
-        message: errMsg
-      });
-      return;
-    }
-    const backoffMs = this.retryBudget.getBackoffMs();
-    this.log?.info(
-      `attempting connection to ${to} (${backoffMs}ms backoff)`,
-      session.loggingMetadata
-    );
-    this.retryBudget.consumeBudget();
-    const backingOffSession = ClientSessionStateGraph.transition.NoConnectionToBackingOff(
-      session,
-      backoffMs,
-      {
-        onBackoffFinished: () => {
-          this.onBackoffFinished(backingOffSession);
-        },
-        onSessionGracePeriodElapsed: () => {
-          this.onSessionGracePeriodElapsed(backingOffSession);
-        },
-        onMessageSendFailure: (msg, reason) => {
-          this.log?.error(`failed to send message: ${reason}`, {
-            ...backingOffSession.loggingMetadata,
-            transportMessage: msg
-          });
-          this.protocolError({
-            type: ProtocolError.MessageSendFailure,
-            message: reason
-          });
-          this.deleteSession(backingOffSession, { unhealthy: true });
-        }
-      }
-    );
-    this.updateSession(backingOffSession);
-  }
-  /**
-   * Manually kills all sessions to the server (including all pending state).
-   * This is useful for when you want to close all connections to a server
-   * and don't want to wait for the grace period to elapse.
-   */
-  hardDisconnect() {
-    const sessions = Array.from(this.sessions.values());
-    for (const session of sessions) {
-      this.deleteSession(session);
-    }
-  }
-  onBackoffFinished(session) {
-    const connPromise = session.tracer.startActiveSpan(
-      "connect",
-      async (span) => {
-        try {
-          return await this.createNewOutgoingConnection(session.to);
-        } catch (err) {
-          const errStr = coerceErrorString(err);
-          span.recordException(errStr);
-          span.setStatus({ code: import_api4.SpanStatusCode.ERROR });
-          throw err;
-        } finally {
-          span.end();
-        }
-      }
-    );
-    const connectingSession = ClientSessionStateGraph.transition.BackingOffToConnecting(
-      session,
-      connPromise,
-      {
-        onConnectionEstablished: (conn) => {
-          this.log?.debug(
-            `connection to ${connectingSession.to} established`,
-            {
-              ...conn.loggingMetadata,
-              ...connectingSession.loggingMetadata
-            }
-          );
-          this.onConnectionEstablished(connectingSession, conn);
-        },
-        onConnectionFailed: (error) => {
-          const errStr = coerceErrorString(error);
-          this.log?.error(
-            `error connecting to ${connectingSession.to}: ${errStr}`,
-            connectingSession.loggingMetadata
-          );
-          this.onConnectingFailed(connectingSession);
-        },
-        onConnectionTimeout: () => {
-          this.log?.error(
-            `connection to ${connectingSession.to} timed out`,
-            connectingSession.loggingMetadata
-          );
-          this.onConnectingFailed(connectingSession);
-        },
-        onSessionGracePeriodElapsed: () => {
-          this.onSessionGracePeriodElapsed(connectingSession);
-        },
-        onMessageSendFailure: (msg, reason) => {
-          this.log?.error(`failed to send message: ${reason}`, {
-            ...connectingSession.loggingMetadata,
-            transportMessage: msg
-          });
-          this.protocolError({
-            type: ProtocolError.MessageSendFailure,
-            message: reason
-          });
-          this.deleteSession(connectingSession, { unhealthy: true });
-        }
-      }
-    );
-    this.updateSession(connectingSession);
-  }
-  async sendHandshake(session) {
-    let metadata = void 0;
-    if (this.handshakeExtensions) {
-      try {
-        metadata = await this.handshakeExtensions.construct();
-      } catch (err) {
-        const errStr = coerceErrorString(err);
-        this.log?.error(
-          `failed to construct handshake metadata for session to ${session.to}: ${errStr}`,
-          session.loggingMetadata
-        );
-        this.protocolError({
-          type: ProtocolError.HandshakeFailed,
-          message: `failed to construct handshake metadata: ${errStr}`
-        });
-        this.deleteSession(session, { unhealthy: true });
-        return;
-      }
-    }
-    if (session._isConsumed) {
-      return;
-    }
-    const requestMsg = handshakeRequestMessage({
-      from: this.clientId,
-      to: session.to,
-      sessionId: session.id,
-      expectedSessionState: {
-        nextExpectedSeq: session.ack,
-        nextSentSeq: session.nextSeq()
-      },
-      metadata,
-      tracing: getPropagationContext(session.telemetry.ctx)
-    });
-    this.log?.debug(`sending handshake request to ${session.to}`, {
-      ...session.loggingMetadata,
-      transportMessage: requestMsg
-    });
-    const res = session.sendHandshake(requestMsg);
-    if (!res.ok) {
-      this.log?.error(`failed to send handshake request: ${res.reason}`, {
-        ...session.loggingMetadata,
-        transportMessage: requestMsg
-      });
-      this.protocolError({
-        type: ProtocolError.MessageSendFailure,
-        message: res.reason
-      });
-      this.deleteSession(session, { unhealthy: true });
-    }
-  }
-  close() {
-    this.retryBudget.close();
-    super.close();
-  }
-};
-
-// transport/server.ts
-var import_api5 = require("@opentelemetry/api");
-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_api5.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/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;
-  }
-};
-
-// codec/adapter.ts
-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_value3.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
-  }
-};
-
-// testUtil/observable/observable.ts
-var Observable = class {
-  value;
-  listeners;
-  constructor(initialValue) {
-    this.value = initialValue;
-    this.listeners = /* @__PURE__ */ new Set();
-  }
-  /**
-   * Gets the current value of the observable.
-   */
-  get() {
-    return this.value;
-  }
-  /**
-   * Sets the current value of the observable. All listeners will get an update with this value.
-   * @param newValue - The new value to set.
-   */
-  set(tx) {
-    const newValue = tx(this.value);
-    this.value = newValue;
-    this.listeners.forEach((listener) => listener(newValue));
-  }
-  /**
-   * Subscribes to changes in the observable value.
-   * @param listener - A callback function that will be called when the value changes.
-   * @returns A function that can be called to unsubscribe from further notifications.
-   */
-  observe(listener) {
-    this.listeners.add(listener);
-    listener(this.get());
-    return () => this.listeners.delete(listener);
-  }
-  /**
-   * Returns the number of listeners currently observing the observable
-   */
-  get listenerCount() {
-    return this.listeners.size;
-  }
-};
-
-// testUtil/duplex/duplexPair.ts
-var import_node_stream = require("stream");
-var import_assert = __toESM(require("assert"), 1);
-var kCallback = Symbol("Callback");
-var kInitOtherSide = Symbol("InitOtherSide");
-var DuplexSide = class extends import_node_stream.Duplex {
-  otherSide;
-  [kCallback];
-  constructor() {
-    super();
-    this[kCallback] = null;
-    this.otherSide = null;
-  }
-  [kInitOtherSide](otherSide) {
-    if (this.otherSide === null) {
-      this.otherSide = otherSide;
-    }
-  }
-  _read() {
-    const callback = this[kCallback];
-    if (callback) {
-      this[kCallback] = null;
-      callback();
-    }
-  }
-  _write(chunk, _encoding, callback) {
-    (0, import_assert.default)(this.otherSide !== null);
-    (0, import_assert.default)(this.otherSide[kCallback] === null);
-    if (chunk.length === 0) {
-      process.nextTick(callback);
-    } else {
-      this.otherSide.push(chunk);
-      this.otherSide[kCallback] = callback;
-    }
-  }
-  _final(callback) {
-    this.otherSide?.on("end", callback);
-    this.otherSide?.push(null);
-  }
-};
-function duplexPair() {
-  const side0 = new DuplexSide();
-  const side1 = new DuplexSide();
-  side0[kInitOtherSide](side1);
-  side1[kInitOtherSide](side0);
-  side0.on("close", () => {
-    setImmediate(() => {
-      side1.destroy();
-    });
-  });
-  side1.on("close", () => {
-    setImmediate(() => {
-      side0.destroy();
-    });
-  });
-  return [side0, side1];
-}
-
-// testUtil/fixtures/mockTransport.ts
-var import_nanoid2 = require("nanoid");
-var InMemoryConnection = class extends Connection {
-  conn;
-  constructor(pipe) {
-    super();
-    this.conn = pipe;
-    this.conn.allowHalfOpen = false;
-    this.conn.on("data", (data) => {
-      this.dataListener?.(data);
-    });
-    this.conn.on("close", () => {
-      this.closeListener?.();
-    });
-    this.conn.on("error", (err) => {
-      this.errorListener?.(err);
-    });
-  }
-  send(payload) {
-    setImmediate(() => {
-      this.conn.write(payload);
-    });
-    return true;
-  }
-  close() {
-    setImmediate(() => {
-      this.conn.end();
-      this.conn.emit("close");
-    });
-  }
-};
-function createMockTransportNetwork(opts) {
-  const connections = new Observable({});
-  const transports = [];
-  class MockClientTransport extends ClientTransport {
-    async createNewOutgoingConnection(to) {
-      const [clientToServer, serverToClient] = duplexPair();
-      await new Promise((resolve) => setImmediate(resolve));
-      const connId = (0, import_nanoid2.nanoid)();
-      connections.set((prev) => ({
-        ...prev,
-        [connId]: {
-          id: connId,
-          clientToServer,
-          serverToClient,
-          clientId: this.clientId,
-          serverId: to,
-          handled: false
-        }
-      }));
-      return new InMemoryConnection(clientToServer);
-    }
-  }
-  class MockServerTransport extends ServerTransport {
-    subscribeCleanup;
-    constructor(clientId, options) {
-      super(clientId, options);
-      this.subscribeCleanup = connections.observe((conns) => {
-        for (const conn of Object.values(conns)) {
-          if (conn.handled || conn.serverId !== this.clientId) {
-            continue;
-          }
-          conn.handled = true;
-          const connection = new InMemoryConnection(conn.serverToClient);
-          this.handleConnection(connection);
-        }
-      });
-    }
-    close() {
-      this.subscribeCleanup();
-      super.close();
-    }
-  }
-  return {
-    getClientTransport: (id, handshakeOptions) => {
-      const clientTransport = new MockClientTransport(id, opts?.client);
-      if (handshakeOptions) {
-        clientTransport.extendHandshake(handshakeOptions);
-      }
-      transports.push(clientTransport);
-      return clientTransport;
-    },
-    getServerTransport: (id = "SERVER", handshakeOptions) => {
-      const serverTransport = new MockServerTransport(id, opts?.server);
-      if (handshakeOptions) {
-        serverTransport.extendHandshake(handshakeOptions);
-      }
-      transports.push(serverTransport);
-      return serverTransport;
-    },
-    simulatePhantomDisconnect() {
-      for (const conn of Object.values(connections.get())) {
-        conn.serverToClient.pause();
-        conn.clientToServer.pause();
-      }
-    },
-    async restartServer() {
-      for (const transport of transports) {
-        if (transport.clientId !== "SERVER") continue;
-        transport.close();
-      }
-      for (const conn of Object.values(connections.get())) {
-        conn.serverToClient.destroy();
-        conn.clientToServer.destroy();
-      }
-    },
-    cleanup() {
-      for (const conn of Object.values(connections.get())) {
-        conn.serverToClient.destroy();
-        conn.clientToServer.destroy();
-      }
-    }
-  };
-}
-
-// testUtil/index.ts
-function createLocalWebSocketClient(port) {
-  const sock = new import_ws.default(`ws://localhost:${port}`);
-  sock.binaryType = "arraybuffer";
-  return sock;
-}
-function createWebSocketServer(server) {
-  return new import_ws.WebSocketServer({ server });
-}
-function onWsServerReady(server) {
-  return new Promise((resolve, reject) => {
-    server.listen(() => {
-      const addr = server.address();
-      if (typeof addr === "object" && addr) {
-        resolve(addr.port);
-      } else {
-        reject(new Error("couldn't find a port to allocate"));
-      }
-    });
-  });
-}
-var readableIterators = /* @__PURE__ */ new WeakMap();
-function getReadableIterator(readable) {
-  let iter = readableIterators.get(readable);
-  if (!iter) {
-    iter = readable[Symbol.asyncIterator]();
-    readableIterators.set(readable, iter);
-  }
-  return iter;
-}
-async function readNextResult(readable) {
-  const res = await getReadableIterator(readable).next();
-  if (res.done) {
-    throw new Error("readNext from a done Readable");
-  }
-  return res.value;
-}
-async function isReadableDone(readable) {
-  const res = await getReadableIterator(readable).next();
-  return res.done;
-}
-function payloadToTransportMessage(payload) {
-  return {
-    streamId: "stream",
-    controlFlags: 0,
-    payload
-  };
-}
-function createDummyTransportMessage() {
-  return payloadToTransportMessage({
-    msg: "cool",
-    test: Math.random()
-  });
-}
-async function waitForMessage(t, filter, rejectMismatch) {
-  return new Promise((resolve, reject) => {
-    function cleanup() {
-      t.removeEventListener("message", onMessage);
-    }
-    function onMessage(msg) {
-      if (!filter || filter(msg)) {
-        cleanup();
-        resolve(msg.payload);
-      } else if (rejectMismatch) {
-        cleanup();
-        reject(new Error("message didnt match the filter"));
-      }
-    }
-    t.addEventListener("message", onMessage);
-  });
-}
-var testingSessionOptions = defaultTransportOptions;
-var testingClientSessionOptions = defaultClientTransportOptions;
-function dummySession() {
-  return SessionStateGraph.entrypoints.NoConnection(
-    "client",
-    "server",
-    {
-      onSessionGracePeriodElapsed: () => {
-      },
-      onMessageSendFailure: () => {
-      }
-    },
-    testingSessionOptions,
-    currentProtocolVersion,
-    getTracer()
-  );
-}
-function getClientSendFn(clientTransport, serverTransport) {
-  const session = clientTransport.sessions.get(serverTransport.clientId) ?? clientTransport.createUnconnectedSession(serverTransport.clientId);
-  return clientTransport.getSessionBoundSendFn(
-    serverTransport.clientId,
-    session.id
-  );
-}
-function getServerSendFn(serverTransport, clientTransport) {
-  const session = serverTransport.sessions.get(clientTransport.clientId);
-  if (!session) {
-    throw new Error("session not found");
-  }
-  return serverTransport.getSessionBoundSendFn(
-    clientTransport.clientId,
-    session.id
-  );
-}
-function getTransportConnections(transport) {
-  const connections = [];
-  for (const session of transport.sessions.values()) {
-    if (session.state === "Connected" /* Connected */) {
-      connections.push(session.conn);
-    }
-  }
-  return connections;
-}
-function numberOfConnections(transport) {
-  return getTransportConnections(transport).length;
-}
-function closeAllConnections(transport) {
-  for (const conn of getTransportConnections(transport)) {
-    conn.close();
-  }
-}
-function createPartialContext(partial) {
-  return new Proxy(partial, {
-    get(target, prop, receiver) {
-      if (prop in target) {
-        return Reflect.get(target, prop, receiver);
-      }
-      if (typeof prop === "string" && prop !== "then") {
-        throw new Error(
-          `${prop} is not mocked in the test context. Provide it via createPartialContext if your test needs it.`
-        );
-      }
-      return void 0;
-    }
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  InMemoryConnection,
-  closeAllConnections,
-  createDummyTransportMessage,
-  createLocalWebSocketClient,
-  createMockTransportNetwork,
-  createPartialContext,
-  createWebSocketServer,
-  dummySession,
-  getClientSendFn,
-  getReadableIterator,
-  getServerSendFn,
-  getTransportConnections,
-  isReadableDone,
-  numberOfConnections,
-  onWsServerReady,
-  payloadToTransportMessage,
-  readNextResult,
-  testingClientSessionOptions,
-  testingSessionOptions,
-  waitForMessage
-});
-//# sourceMappingURL=index.cjs.map