@replit/river 0.200.5 → 0.201.0

package/dist/testUtil/index.cjs

@@ -0,0 +1,2616 @@
+"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,
+  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 {
+          return val;
+        }
+      })
+    );
+  },
+  fromBuffer: (buff) => {
+    try {
+      const parsed = JSON.parse(
+        decoder.decode(buff),
+        function reviver(_key, val) {
+          if (val?.$t) {
+            return base64ToUint8Array(val.$t);
+          } else {
+            return val;
+          }
+        }
+      );
+      if (typeof parsed === "object")
+        return parsed;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// transport/options.ts
+var defaultTransportOptions = {
+  heartbeatIntervalMs: 1e3,
+  heartbeatsUntilDead: 2,
+  sessionDisconnectGraceMs: 5e3,
+  connectionTimeoutMs: 2e3,
+  handshakeTimeoutMs: 1e3,
+  enableTransparentSessionReconnects: true,
+  codec: NaiveJsonCodec
+};
+var defaultConnectionRetryOptions = {
+  baseIntervalMs: 150,
+  maxJitterMs: 200,
+  maxBackoffMs: 32e3,
+  attemptBudgetCapacity: 5,
+  budgetRestoreIntervalMs: 200
+};
+var defaultClientTransportOptions = {
+  ...defaultTransportOptions,
+  ...defaultConnectionRetryOptions
+};
+var defaultServerTransportOptions = {
+  ...defaultTransportOptions
+};
+
+// transport/sessionStateMachine/common.ts
+var import_value = require("@sinclair/typebox/value");
+var ERR_CONSUMED = `session state has been consumed and is no longer valid`;
+var StateMachineState = class {
+  /*
+   * Whether this state has been consumed
+   * and we've moved on to another state
+   */
+  _isConsumed;
+  close() {
+    this._handleClose();
+  }
+  constructor() {
+    this._isConsumed = false;
+    return new Proxy(this, {
+      get(target, prop) {
+        if (prop === "_isConsumed" || prop === "id" || prop === "state") {
+          return Reflect.get(target, prop);
+        }
+        if (prop === "_handleStateExit") {
+          return () => {
+            target._isConsumed = true;
+            target._handleStateExit();
+          };
+        }
+        if (prop === "_handleClose") {
+          return () => {
+            target._isConsumed = true;
+            target._handleStateExit();
+            target._handleClose();
+          };
+        }
+        if (target._isConsumed) {
+          throw new Error(
+            `${ERR_CONSUMED}: getting ${prop.toString()} on consumed state`
+          );
+        }
+        return Reflect.get(target, prop);
+      },
+      set(target, prop, value) {
+        if (target._isConsumed) {
+          throw new Error(
+            `${ERR_CONSUMED}: setting ${prop.toString()} on consumed state`
+          );
+        }
+        return Reflect.set(target, prop, value);
+      }
+    });
+  }
+};
+var CommonSession = class extends StateMachineState {
+  from;
+  options;
+  log;
+  constructor({ from, options, log }) {
+    super();
+    this.from = from;
+    this.options = options;
+    this.log = log;
+  }
+  parseMsg(msg) {
+    const parsedMsg = this.options.codec.fromBuffer(msg);
+    if (parsedMsg === null) {
+      const decodedBuffer = new TextDecoder().decode(Buffer.from(msg));
+      this.log?.error(
+        `received malformed msg: ${decodedBuffer}`,
+        this.loggingMetadata
+      );
+      return null;
+    }
+    if (!import_value.Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
+      this.log?.error(`received invalid msg: ${JSON.stringify(parsedMsg)}`, {
+        ...this.loggingMetadata,
+        validationErrors: [
+          ...import_value.Value.Errors(OpaqueTransportMessageSchema, parsedMsg)
+        ]
+      });
+      return null;
+    }
+    return parsedMsg;
+  }
+};
+var IdentifiedSession = class extends CommonSession {
+  id;
+  telemetry;
+  to;
+  protocolVersion;
+  /**
+   * Index of the message we will send next (excluding handshake)
+   */
+  seq;
+  /**
+   * Number of unique messages we've received this session (excluding handshake)
+   */
+  ack;
+  sendBuffer;
+  constructor(props) {
+    const { id, to, seq, ack, sendBuffer, telemetry, log, protocolVersion } = props;
+    super(props);
+    this.id = id;
+    this.to = to;
+    this.seq = seq;
+    this.ack = ack;
+    this.sendBuffer = sendBuffer;
+    this.telemetry = telemetry;
+    this.log = log;
+    this.protocolVersion = protocolVersion;
+  }
+  get loggingMetadata() {
+    const spanContext = this.telemetry.span.spanContext();
+    const metadata = {
+      clientId: this.from,
+      connectedTo: this.to,
+      sessionId: this.id
+    };
+    if (this.telemetry.span.isRecording()) {
+      metadata.telemetry = {
+        traceId: spanContext.traceId,
+        spanId: spanContext.spanId
+      };
+    }
+    return metadata;
+  }
+  constructMsg(partialMsg) {
+    const msg = {
+      ...partialMsg,
+      id: generateId(),
+      to: this.to,
+      from: this.from,
+      seq: this.seq,
+      ack: this.ack
+    };
+    this.seq++;
+    return msg;
+  }
+  nextSeq() {
+    return this.sendBuffer.length > 0 ? this.sendBuffer[0].seq : this.seq;
+  }
+  send(msg) {
+    const constructedMsg = this.constructMsg(msg);
+    this.sendBuffer.push(constructedMsg);
+    return constructedMsg.id;
+  }
+  _handleStateExit() {
+  }
+  _handleClose() {
+    this.sendBuffer.length = 0;
+    this.telemetry.span.end();
+  }
+};
+var IdentifiedSessionWithGracePeriod = class extends IdentifiedSession {
+  graceExpiryTime;
+  gracePeriodTimeout;
+  listeners;
+  constructor(props) {
+    super(props);
+    this.listeners = props.listeners;
+    this.graceExpiryTime = props.graceExpiryTime;
+    this.gracePeriodTimeout = setTimeout(() => {
+      this.listeners.onSessionGracePeriodElapsed();
+    }, this.graceExpiryTime - Date.now());
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+    if (this.gracePeriodTimeout) {
+      clearTimeout(this.gracePeriodTimeout);
+      this.gracePeriodTimeout = void 0;
+    }
+  }
+  _handleClose() {
+    super._handleClose();
+  }
+};
+
+// transport/sessionStateMachine/SessionConnecting.ts
+var SessionConnecting = class extends IdentifiedSessionWithGracePeriod {
+  state = "Connecting" /* Connecting */;
+  connPromise;
+  listeners;
+  connectionTimeout;
+  constructor(props) {
+    super(props);
+    this.connPromise = props.connPromise;
+    this.listeners = props.listeners;
+    this.connPromise.then(
+      (conn) => {
+        if (this._isConsumed)
+          return;
+        this.listeners.onConnectionEstablished(conn);
+      },
+      (err) => {
+        if (this._isConsumed)
+          return;
+        this.listeners.onConnectionFailed(err);
+      }
+    );
+    this.connectionTimeout = setTimeout(() => {
+      this.listeners.onConnectionTimeout();
+    }, this.options.connectionTimeoutMs);
+  }
+  // close a pending connection if it resolves, ignore errors if the promise
+  // ends up rejected anyways
+  bestEffortClose() {
+    const logger = this.log;
+    const metadata = this.loggingMetadata;
+    this.connPromise.then((conn) => {
+      conn.close();
+      logger?.info(
+        "connection eventually resolved but session has transitioned, closed connection",
+        {
+          ...metadata,
+          ...conn.loggingMetadata
+        }
+      );
+    }).catch(() => {
+    });
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+    if (this.connectionTimeout) {
+      clearTimeout(this.connectionTimeout);
+      this.connectionTimeout = void 0;
+    }
+  }
+  _handleClose() {
+    this.bestEffortClose();
+    super._handleClose();
+  }
+};
+
+// transport/sessionStateMachine/SessionNoConnection.ts
+var SessionNoConnection = class extends IdentifiedSessionWithGracePeriod {
+  state = "NoConnection" /* NoConnection */;
+  _handleClose() {
+    super._handleClose();
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+  }
+};
+
+// tracing/index.ts
+var import_api = require("@opentelemetry/api");
+
+// package.json
+var version = "0.201.0";
+
+// tracing/index.ts
+function getPropagationContext(ctx) {
+  const tracing = {
+    traceparent: "",
+    tracestate: ""
+  };
+  import_api.propagation.inject(ctx, tracing);
+  return tracing;
+}
+function createSessionTelemetryInfo(sessionId, to, from, propagationCtx) {
+  const parentCtx = propagationCtx ? import_api.propagation.extract(import_api.context.active(), propagationCtx) : import_api.context.active();
+  const span = tracer.startSpan(
+    `session ${sessionId}`,
+    {
+      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 };
+}
+var tracer = import_api.trace.getTracer("river", version);
+var tracing_default = tracer;
+
+// transport/sessionStateMachine/SessionWaitingForHandshake.ts
+var SessionWaitingForHandshake = class extends CommonSession {
+  state = "WaitingForHandshake" /* WaitingForHandshake */;
+  conn;
+  listeners;
+  handshakeTimeout;
+  constructor(props) {
+    super(props);
+    this.conn = props.conn;
+    this.listeners = props.listeners;
+    this.handshakeTimeout = setTimeout(() => {
+      this.listeners.onHandshakeTimeout();
+    }, this.options.handshakeTimeoutMs);
+    this.conn.addDataListener(this.onHandshakeData);
+    this.conn.addErrorListener(this.listeners.onConnectionErrored);
+    this.conn.addCloseListener(this.listeners.onConnectionClosed);
+  }
+  get loggingMetadata() {
+    return {
+      clientId: this.from,
+      connId: this.conn.id,
+      ...this.conn.loggingMetadata
+    };
+  }
+  onHandshakeData = (msg) => {
+    const parsedMsg = this.parseMsg(msg);
+    if (parsedMsg === null) {
+      this.listeners.onInvalidHandshake(
+        "could not parse message",
+        "MALFORMED_HANDSHAKE"
+      );
+      return;
+    }
+    this.listeners.onHandshake(parsedMsg);
+  };
+  sendHandshake(msg) {
+    return this.conn.send(this.options.codec.toBuffer(msg));
+  }
+  _handleStateExit() {
+    this.conn.removeDataListener(this.onHandshakeData);
+    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
+    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
+    clearTimeout(this.handshakeTimeout);
+    this.handshakeTimeout = void 0;
+  }
+  _handleClose() {
+    this.conn.close();
+  }
+};
+
+// transport/sessionStateMachine/SessionHandshaking.ts
+var SessionHandshaking = class extends IdentifiedSessionWithGracePeriod {
+  state = "Handshaking" /* Handshaking */;
+  conn;
+  listeners;
+  handshakeTimeout;
+  constructor(props) {
+    super(props);
+    this.conn = props.conn;
+    this.listeners = props.listeners;
+    this.handshakeTimeout = setTimeout(() => {
+      this.listeners.onHandshakeTimeout();
+    }, this.options.handshakeTimeoutMs);
+    this.conn.addDataListener(this.onHandshakeData);
+    this.conn.addErrorListener(this.listeners.onConnectionErrored);
+    this.conn.addCloseListener(this.listeners.onConnectionClosed);
+  }
+  get loggingMetadata() {
+    return {
+      ...super.loggingMetadata,
+      ...this.conn.loggingMetadata
+    };
+  }
+  onHandshakeData = (msg) => {
+    const parsedMsg = this.parseMsg(msg);
+    if (parsedMsg === null) {
+      this.listeners.onInvalidHandshake(
+        "could not parse message",
+        "MALFORMED_HANDSHAKE"
+      );
+      return;
+    }
+    this.listeners.onHandshake(parsedMsg);
+  };
+  sendHandshake(msg) {
+    return this.conn.send(this.options.codec.toBuffer(msg));
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+    this.conn.removeDataListener(this.onHandshakeData);
+    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
+    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
+    if (this.handshakeTimeout) {
+      clearTimeout(this.handshakeTimeout);
+      this.handshakeTimeout = void 0;
+    }
+  }
+  _handleClose() {
+    super._handleClose();
+    this.conn.close();
+  }
+};
+
+// transport/sessionStateMachine/SessionConnected.ts
+var import_api2 = require("@opentelemetry/api");
+var SessionConnected = class extends IdentifiedSession {
+  state = "Connected" /* Connected */;
+  conn;
+  listeners;
+  heartbeatHandle;
+  heartbeatMisses = 0;
+  isActivelyHeartbeating;
+  updateBookkeeping(ack, seq) {
+    this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq >= ack);
+    this.ack = seq + 1;
+    this.heartbeatMisses = 0;
+  }
+  send(msg) {
+    const constructedMsg = this.constructMsg(msg);
+    this.sendBuffer.push(constructedMsg);
+    this.conn.send(this.options.codec.toBuffer(constructedMsg));
+    return constructedMsg.id;
+  }
+  constructor(props) {
+    super(props);
+    this.conn = props.conn;
+    this.listeners = props.listeners;
+    this.conn.addDataListener(this.onMessageData);
+    this.conn.addCloseListener(this.listeners.onConnectionClosed);
+    this.conn.addErrorListener(this.listeners.onConnectionErrored);
+    if (this.sendBuffer.length > 0) {
+      this.log?.info(
+        `sending ${this.sendBuffer.length} buffered messages, starting at seq ${this.nextSeq()}`,
+        this.loggingMetadata
+      );
+      for (const msg of this.sendBuffer) {
+        this.conn.send(this.options.codec.toBuffer(msg));
+      }
+    }
+    this.isActivelyHeartbeating = false;
+    this.heartbeatHandle = setInterval(() => {
+      const misses = this.heartbeatMisses;
+      const missDuration = misses * this.options.heartbeatIntervalMs;
+      if (misses >= this.options.heartbeatsUntilDead) {
+        this.log?.info(
+          `closing connection to ${this.to} due to inactivity (missed ${misses} heartbeats which is ${missDuration}ms)`,
+          this.loggingMetadata
+        );
+        this.telemetry.span.addEvent("closing connection due to inactivity");
+        this.conn.close();
+        clearInterval(this.heartbeatHandle);
+        this.heartbeatHandle = void 0;
+        return;
+      }
+      if (this.isActivelyHeartbeating) {
+        this.sendHeartbeat();
+      }
+      this.heartbeatMisses++;
+    }, this.options.heartbeatIntervalMs);
+  }
+  get loggingMetadata() {
+    return {
+      ...super.loggingMetadata,
+      ...this.conn.loggingMetadata
+    };
+  }
+  startActiveHeartbeat() {
+    this.isActivelyHeartbeating = true;
+  }
+  sendHeartbeat() {
+    this.log?.debug("sending heartbeat", this.loggingMetadata);
+    this.send({
+      streamId: "heartbeat",
+      controlFlags: 1 /* AckBit */,
+      payload: {
+        type: "ACK"
+      }
+    });
+  }
+  closeConnection() {
+    this.conn.removeDataListener(this.onMessageData);
+    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
+    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
+    this.conn.close();
+  }
+  onMessageData = (msg) => {
+    const parsedMsg = this.parseMsg(msg);
+    if (parsedMsg === null) {
+      this.listeners.onInvalidMessage("could not parse message");
+      return;
+    }
+    if (parsedMsg.seq !== this.ack) {
+      if (parsedMsg.seq < this.ack) {
+        this.log?.debug(
+          `received duplicate msg (got seq: ${parsedMsg.seq}, wanted seq: ${this.ack}), discarding`,
+          {
+            ...this.loggingMetadata,
+            transportMessage: parsedMsg
+          }
+        );
+      } else {
+        const reason = `received out-of-order msg, closing connection (got seq: ${parsedMsg.seq}, wanted seq: ${this.ack})`;
+        this.log?.warn(reason, {
+          ...this.loggingMetadata,
+          transportMessage: parsedMsg,
+          tags: ["invariant-violation"]
+        });
+        this.telemetry.span.setStatus({
+          code: import_api2.SpanStatusCode.ERROR,
+          message: reason
+        });
+        this.closeConnection();
+      }
+      return;
+    }
+    this.log?.debug(`received msg`, {
+      ...this.loggingMetadata,
+      transportMessage: parsedMsg
+    });
+    this.updateBookkeeping(parsedMsg.ack, parsedMsg.seq);
+    if (!isAck(parsedMsg.controlFlags)) {
+      this.listeners.onMessage(parsedMsg);
+      return;
+    }
+    this.log?.debug(`discarding msg (ack bit set)`, {
+      ...this.loggingMetadata,
+      transportMessage: parsedMsg
+    });
+    if (!this.isActivelyHeartbeating) {
+      this.sendHeartbeat();
+    }
+  };
+  _handleStateExit() {
+    super._handleStateExit();
+    this.conn.removeDataListener(this.onMessageData);
+    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
+    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
+    if (this.heartbeatHandle) {
+      clearInterval(this.heartbeatHandle);
+      this.heartbeatHandle = void 0;
+    }
+  }
+  _handleClose() {
+    super._handleClose();
+    this.conn.close();
+  }
+};
+
+// transport/sessionStateMachine/SessionBackingOff.ts
+var SessionBackingOff = class extends IdentifiedSessionWithGracePeriod {
+  state = "BackingOff" /* BackingOff */;
+  listeners;
+  backoffTimeout;
+  constructor(props) {
+    super(props);
+    this.listeners = props.listeners;
+    this.backoffTimeout = setTimeout(() => {
+      this.listeners.onBackoffFinished();
+    }, props.backoffMs);
+  }
+  _handleClose() {
+    super._handleClose();
+  }
+  _handleStateExit() {
+    super._handleStateExit();
+    if (this.backoffTimeout) {
+      clearTimeout(this.backoffTimeout);
+      this.backoffTimeout = void 0;
+    }
+  }
+};
+
+// transport/sessionStateMachine/transitions.ts
+function inheritSharedSession(session) {
+  return {
+    id: session.id,
+    from: session.from,
+    to: session.to,
+    seq: session.seq,
+    ack: session.ack,
+    sendBuffer: session.sendBuffer,
+    telemetry: session.telemetry,
+    options: session.options,
+    log: session.log,
+    protocolVersion: session.protocolVersion
+  };
+}
+function inheritSharedSessionWithGrace(session) {
+  return {
+    ...inheritSharedSession(session),
+    graceExpiryTime: session.graceExpiryTime
+  };
+}
+var SessionStateGraph = {
+  entrypoints: {
+    NoConnection: (to, from, listeners, options, protocolVersion, log) => {
+      const id = `session-${generateId()}`;
+      const telemetry = createSessionTelemetryInfo(id, to, from);
+      const sendBuffer = [];
+      const session = new SessionNoConnection({
+        listeners,
+        id,
+        from,
+        to,
+        seq: 0,
+        ack: 0,
+        graceExpiryTime: Date.now() + options.sessionDisconnectGraceMs,
+        sendBuffer,
+        telemetry,
+        options,
+        protocolVersion,
+        log
+      });
+      session.log?.info(`session ${session.id} created in NoConnection state`, {
+        ...session.loggingMetadata,
+        tags: ["state-transition"]
+      });
+      return session;
+    },
+    WaitingForHandshake: (from, conn, listeners, options, log) => {
+      const session = new SessionWaitingForHandshake({
+        conn,
+        listeners,
+        from,
+        options,
+        log
+      });
+      session.log?.info(`session created in WaitingForHandshake state`, {
+        ...session.loggingMetadata,
+        tags: ["state-transition"]
+      });
+      return session;
+    }
+  },
+  // All of the transitions 'move'/'consume' the old session and return a new one.
+  // After a session is transitioned, any usage of the old session will throw.
+  transition: {
+    // happy path transitions
+    NoConnectionToBackingOff: (oldSession, backoffMs, listeners) => {
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
+      oldSession._handleStateExit();
+      const session = new SessionBackingOff({
+        backoffMs,
+        listeners,
+        ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from NoConnection to BackingOff`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    BackingOffToConnecting: (oldSession, connPromise, listeners) => {
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
+      oldSession._handleStateExit();
+      const session = new SessionConnecting({
+        connPromise,
+        listeners,
+        ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from BackingOff to Connecting`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    ConnectingToHandshaking: (oldSession, conn, listeners) => {
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
+      oldSession._handleStateExit();
+      const session = new SessionHandshaking({
+        conn,
+        listeners,
+        ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from Connecting to Handshaking`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    HandshakingToConnected: (oldSession, listeners) => {
+      const carriedState = inheritSharedSession(oldSession);
+      const conn = oldSession.conn;
+      oldSession._handleStateExit();
+      const session = new SessionConnected({
+        conn,
+        listeners,
+        ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from Handshaking to Connected`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    WaitingForHandshakeToConnected: (pendingSession, oldSession, sessionId, to, propagationCtx, listeners, protocolVersion) => {
+      const conn = pendingSession.conn;
+      const { from, options } = pendingSession;
+      const carriedState = oldSession ? (
+        // old session exists, inherit state
+        inheritSharedSession(oldSession)
+      ) : (
+        // old session does not exist, create new state
+        {
+          id: sessionId,
+          from,
+          to,
+          seq: 0,
+          ack: 0,
+          sendBuffer: [],
+          telemetry: createSessionTelemetryInfo(
+            sessionId,
+            to,
+            from,
+            propagationCtx
+          ),
+          options,
+          log: pendingSession.log,
+          protocolVersion
+        }
+      );
+      pendingSession._handleStateExit();
+      oldSession?._handleStateExit();
+      const session = new SessionConnected({
+        conn,
+        listeners,
+        ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from WaitingForHandshake to Connected`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    // disconnect paths
+    BackingOffToNoConnection: (oldSession, listeners) => {
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
+      oldSession._handleStateExit();
+      const session = new SessionNoConnection({
+        listeners,
+        ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from BackingOff to NoConnection`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    ConnectingToNoConnection: (oldSession, listeners) => {
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
+      oldSession.bestEffortClose();
+      oldSession._handleStateExit();
+      const session = new SessionNoConnection({
+        listeners,
+        ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from Connecting to NoConnection`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    HandshakingToNoConnection: (oldSession, listeners) => {
+      const carriedState = inheritSharedSessionWithGrace(oldSession);
+      oldSession.conn.close();
+      oldSession._handleStateExit();
+      const session = new SessionNoConnection({
+        listeners,
+        ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from Handshaking to NoConnection`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    },
+    ConnectedToNoConnection: (oldSession, listeners) => {
+      const carriedState = inheritSharedSession(oldSession);
+      const graceExpiryTime = Date.now() + oldSession.options.sessionDisconnectGraceMs;
+      oldSession.conn.close();
+      oldSession._handleStateExit();
+      const session = new SessionNoConnection({
+        listeners,
+        graceExpiryTime,
+        ...carriedState
+      });
+      session.log?.info(
+        `session ${session.id} transition from Connected to NoConnection`,
+        {
+          ...session.loggingMetadata,
+          tags: ["state-transition"]
+        }
+      );
+      return session;
+    }
+  }
+};
+var transitions = SessionStateGraph.transition;
+var ClientSessionStateGraph = {
+  entrypoint: SessionStateGraph.entrypoints.NoConnection,
+  transition: {
+    // happy paths
+    // NoConnection -> BackingOff: attempt to connect
+    NoConnectionToBackingOff: transitions.NoConnectionToBackingOff,
+    // BackingOff -> Connecting: backoff period elapsed, start connection
+    BackingOffToConnecting: transitions.BackingOffToConnecting,
+    // Connecting -> Handshaking: connection established, start handshake
+    ConnectingToHandshaking: transitions.ConnectingToHandshaking,
+    // Handshaking -> Connected: handshake complete, session ready
+    HandshakingToConnected: transitions.HandshakingToConnected,
+    // disconnect paths
+    // BackingOff -> NoConnection: unused
+    BackingOffToNoConnection: transitions.BackingOffToNoConnection,
+    // Connecting -> NoConnection: connection failed or connection timeout
+    ConnectingToNoConnection: transitions.ConnectingToNoConnection,
+    // Handshaking -> NoConnection: connection closed or handshake timeout
+    HandshakingToNoConnection: transitions.HandshakingToNoConnection,
+    // Connected -> NoConnection: connection closed
+    ConnectedToNoConnection: transitions.ConnectedToNoConnection
+    // destroy/close paths
+    // NoConnection -> x: grace period elapsed
+    // BackingOff -> x: grace period elapsed
+    // Connecting -> x: grace period elapsed
+    // Handshaking -> x: grace period elapsed or invalid handshake message or handshake rejection
+    // Connected -> x: grace period elapsed or invalid message
+  }
+};
+var ServerSessionStateGraph = {
+  entrypoint: SessionStateGraph.entrypoints.WaitingForHandshake,
+  transition: {
+    // happy paths
+    // WaitingForHandshake -> Connected: handshake complete, session ready
+    WaitingForHandshakeToConnected: transitions.WaitingForHandshakeToConnected,
+    // disconnect paths
+    // Connected -> NoConnection: connection closed
+    ConnectedToNoConnection: transitions.ConnectedToNoConnection
+    // destroy/close paths
+    // WaitingForHandshake -> x: handshake timeout elapsed or invalid handshake message or handshake rejection or connection closed
+  }
+};
+
+// transport/client.ts
+var import_api3 = 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;
+  }
+  close() {
+    this.stopLeak();
+  }
+};
+
+// logging/log.ts
+var LoggingLevels = {
+  debug: -1,
+  info: 0,
+  warn: 1,
+  error: 2
+};
+var cleanedLogFn = (log) => {
+  return (msg, metadata) => {
+    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"
+};
+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;
+  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();
+  }
+  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";
+    for (const session of this.sessions.values()) {
+      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: "connect",
+      session
+    });
+    this.eventDispatcher.dispatchEvent("sessionTransition", {
+      state: session.state,
+      session
+    });
+  }
+  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,
+      session
+    });
+  }
+  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: "disconnect",
+      session
+    });
+    const to = session.to;
+    session.close();
+    this.sessions.delete(to);
+  }
+  // common listeners
+  onSessionGracePeriodElapsed(session) {
+    this.log?.warn(
+      `session to ${session.to} grace period elapsed, closing`,
+      session.loggingMetadata
+    );
+    this.deleteSession(session);
+  }
+  onConnectingFailed(session) {
+    const noConnectionSession = SessionStateGraph.transition.ConnectingToNoConnection(session, {
+      onSessionGracePeriodElapsed: () => {
+        this.onSessionGracePeriodElapsed(noConnectionSession);
+      }
+    });
+    this.updateSession(noConnectionSession);
+    return noConnectionSession;
+  }
+  onConnClosed(session) {
+    let noConnectionSession;
+    if (session.state === "Handshaking" /* Handshaking */) {
+      noConnectionSession = SessionStateGraph.transition.HandshakingToNoConnection(session, {
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(noConnectionSession);
+        }
+      });
+    } else {
+      noConnectionSession = SessionStateGraph.transition.ConnectedToNoConnection(session, {
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(noConnectionSession);
+        }
+      });
+    }
+    this.updateSession(noConnectionSession);
+    return noConnectionSession;
+  }
+  /**
+   * Gets a send closure scoped to a specific session. Sending using the returned
+   * closure after the session has transitioned to a different state will be a noop.
+   *
+   * Session objects themselves can become stale as they transition between
+   * states. As stale sessions cannot be used again (and will throw), holding
+   * onto a session object is not recommended.
+   */
+  getSessionBoundSendFn(to, sessionId) {
+    if (this.getStatus() !== "open") {
+      throw new Error("cannot get a bound send function on a closed transport");
+    }
+    return (msg) => {
+      const session = this.sessions.get(to);
+      if (!session) {
+        throw new Error(
+          `session scope for ${sessionId} has ended (close), can't send`
+        );
+      }
+      const sameSession = session.id === sessionId;
+      if (!sameSession) {
+        throw new Error(
+          `session scope for ${sessionId} has ended (transition), can't send`
+        );
+      }
+      return session.send(msg);
+    };
+  }
+};
+
+// transport/stringifyError.ts
+function coerceErrorString(err) {
+  if (err instanceof Error) {
+    return err.message || "unknown reason";
+  }
+  return `[coerced to error] ${String(err)}`;
+}
+
+// transport/client.ts
+var import_value2 = 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);
+        }
+      },
+      this.options,
+      currentProtocolVersion,
+      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);
+        }
+      }
+    );
+    this.updateSession(handshakingSession);
+    void this.sendHandshake(handshakingSession);
+    return handshakingSession;
+  }
+  rejectHandshakeResponse(session, reason, metadata) {
+    session.conn.telemetry?.span.setStatus({
+      code: import_api3.SpanStatusCode.ERROR,
+      message: reason
+    });
+    this.log?.warn(reason, metadata);
+    this.deleteSession(session, { unhealthy: true });
+  }
+  onHandshakeResponse(session, msg) {
+    if (!import_value2.Value.Check(ControlMessageHandshakeResponseSchema, msg.payload)) {
+      const reason = `received invalid handshake response`;
+      this.rejectHandshakeResponse(session, reason, {
+        ...session.loggingMetadata,
+        transportMessage: msg,
+        validationErrors: [
+          ...import_value2.Value.Errors(ControlMessageHandshakeResponseSchema, msg.payload)
+        ]
+      });
+      return;
+    }
+    if (!msg.payload.status.ok) {
+      const retriable = import_value2.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);
+        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.deleteSession(connectedSession, { unhealthy: true });
+        this.protocolError({
+          type: ProtocolError.InvalidMessage,
+          message: reason
+        });
+      }
+    });
+    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);
+        }
+      }
+    );
+    this.updateSession(backingOffSession);
+  }
+  onBackoffFinished(session) {
+    const connPromise = tracing_default.startActiveSpan("connect", async (span) => {
+      try {
+        return await this.createNewOutgoingConnection(session.to);
+      } catch (err) {
+        const errStr = coerceErrorString(err);
+        span.recordException(errStr);
+        span.setStatus({ code: import_api3.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);
+        }
+      }
+    );
+    this.updateSession(connectingSession);
+  }
+  async sendHandshake(session) {
+    let metadata = void 0;
+    if (this.handshakeExtensions) {
+      metadata = await this.handshakeExtensions.construct();
+    }
+    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
+    });
+    session.sendHandshake(requestMsg);
+  }
+  close() {
+    this.retryBudget.close();
+    super.close();
+  }
+};
+
+// transport/connection.ts
+var Connection = class {
+  id;
+  telemetry;
+  constructor() {
+    this.id = `conn-${generateId()}`;
+  }
+  get loggingMetadata() {
+    const metadata = { connId: this.id };
+    const spanContext = this.telemetry?.span.spanContext();
+    if (this.telemetry?.span.isRecording() && spanContext) {
+      metadata.telemetry = {
+        traceId: spanContext.traceId,
+        spanId: spanContext.spanId
+      };
+    }
+    return metadata;
+  }
+  // can't use event emitter because we need this to work in both node + browser
+  _dataListeners = /* @__PURE__ */ new Set();
+  _closeListeners = /* @__PURE__ */ new Set();
+  _errorListeners = /* @__PURE__ */ new Set();
+  get dataListeners() {
+    return [...this._dataListeners];
+  }
+  get closeListeners() {
+    return [...this._closeListeners];
+  }
+  get errorListeners() {
+    return [...this._errorListeners];
+  }
+  /**
+   * Handle adding a callback for when a message is received.
+   * @param msg The message that was received.
+   */
+  addDataListener(cb) {
+    this._dataListeners.add(cb);
+  }
+  removeDataListener(cb) {
+    this._dataListeners.delete(cb);
+  }
+  /**
+   * Handle adding a callback for when the connection is closed.
+   * This should also be called if an error happens and after notifying all the error listeners.
+   * @param cb The callback to call when the connection is closed.
+   */
+  addCloseListener(cb) {
+    this._closeListeners.add(cb);
+  }
+  removeCloseListener(cb) {
+    this._closeListeners.delete(cb);
+  }
+  /**
+   * Handle adding a callback for when an error is received.
+   * This should only be used for this.logging errors, all cleanup
+   * should be delegated to addCloseListener.
+   *
+   * The implementer should take care such that the implemented
+   * connection will call both the close and error callbacks
+   * on an error.
+   *
+   * @param cb The callback to call when an error is received.
+   */
+  addErrorListener(cb) {
+    this._errorListeners.add(cb);
+  }
+  removeErrorListener(cb) {
+    this._errorListeners.delete(cb);
+  }
+};
+
+// transport/server.ts
+var import_api4 = require("@opentelemetry/api");
+var import_value3 = 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.log
+    );
+    this.pendingSessions.add(pendingSession);
+  }
+  rejectHandshakeRequest(session, to, reason, code, metadata) {
+    session.conn.telemetry?.span.setStatus({
+      code: import_api4.SpanStatusCode.ERROR,
+      message: reason
+    });
+    this.log?.warn(reason, metadata);
+    session.sendHandshake(
+      handshakeResponseMessage({
+        from: this.clientId,
+        to,
+        status: {
+          ok: false,
+          code,
+          reason
+        }
+      })
+    );
+    this.protocolError({
+      type: ProtocolError.HandshakeFailed,
+      code,
+      message: reason
+    });
+    this.deletePendingSession(session);
+  }
+  async onHandshakeRequest(session, msg) {
+    if (!import_value3.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_value3.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_value3.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_value3.Value.Errors(
+                this.handshakeExtensions.schema,
+                msg.payload.metadata
+              )
+            ]
+          }
+        );
+        return;
+      }
+      const previousParsedMetadata = this.sessionHandshakeMetadata.get(
+        msg.from
+      );
+      const parsedMetadataOrFailureCode = await this.handshakeExtensions.validate(
+        msg.payload.metadata,
+        previousParsedMetadata
+      );
+      if (session._isConsumed) {
+        return;
+      }
+      if (import_value3.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);
+            }
+          }
+        );
+        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
+      }
+    });
+    session.sendHandshake(responseMsg);
+    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.protocolError({
+            type: ProtocolError.InvalidMessage,
+            message: reason
+          });
+          this.deleteSession(connectedSession, { unhealthy: true });
+        }
+      },
+      gotVersion
+    );
+    this.sessionHandshakeMetadata.set(connectedSession.to, parsedMetadata);
+    if (oldSession) {
+      this.updateSession(connectedSession);
+    } else {
+      this.createSession(connectedSession);
+    }
+    this.pendingSessions.delete(session);
+    connectedSession.startActiveHeartbeat();
+  }
+};
+
+// 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);
+  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.on("data", (data) => {
+      for (const cb of this.dataListeners) {
+        cb(data);
+      }
+    });
+    this.conn.on("end", () => {
+      for (const cb of this.closeListeners) {
+        cb();
+      }
+    });
+    this.conn.on("error", (err) => {
+      for (const cb of this.errorListeners) {
+        cb(err);
+      }
+    });
+  }
+  send(payload) {
+    setImmediate(() => {
+      this.conn.write(payload);
+    });
+    return true;
+  }
+  close() {
+    setImmediate(() => {
+      this.conn.end();
+    });
+  }
+};
+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();
+      }
+    },
+    async restartServer() {
+      for (const transport of transports) {
+        if (transport.clientId !== "SERVER")
+          continue;
+        transport.close();
+      }
+      for (const conn of Object.values(connections.get())) {
+        conn.serverToClient.end();
+        conn.clientToServer.end();
+      }
+    },
+    cleanup() {
+      for (const conn of Object.values(connections.get())) {
+        conn.serverToClient.end();
+        conn.clientToServer.end();
+      }
+    }
+  };
+}
+
+// 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: () => {
+      }
+    },
+    testingSessionOptions,
+    currentProtocolVersion
+  );
+}
+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();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemoryConnection,
+  closeAllConnections,
+  createDummyTransportMessage,
+  createLocalWebSocketClient,
+  createMockTransportNetwork,
+  createWebSocketServer,
+  dummySession,
+  getClientSendFn,
+  getReadableIterator,
+  getServerSendFn,
+  getTransportConnections,
+  isReadableDone,
+  numberOfConnections,
+  onWsServerReady,
+  payloadToTransportMessage,
+  readNextResult,
+  testingClientSessionOptions,
+  testingSessionOptions,
+  waitForMessage
+});
+//# sourceMappingURL=index.cjs.map