@replit/river 0.200.5 → 0.201.0

package/dist/util/testHelpers.cjs

@@ -1,1563 +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);
-
-// util/testHelpers.ts
-var testHelpers_exports = {};
-__export(testHelpers_exports, {
-  asClientRpc: () => asClientRpc,
-  asClientStream: () => asClientStream,
-  asClientSubscription: () => asClientSubscription,
-  asClientUpload: () => asClientUpload,
-  closeAllConnections: () => closeAllConnections,
-  createDummyTransportMessage: () => createDummyTransportMessage,
-  createLocalWebSocketClient: () => createLocalWebSocketClient,
-  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(testHelpers_exports);
-var import_ws = __toESM(require("ws"), 1);
-
-// router/result.ts
-var import_typebox = require("@sinclair/typebox");
-var AnyResultSchema = import_typebox.Type.Union([
-  import_typebox.Type.Object({
-    ok: import_typebox.Type.Literal(false),
-    payload: import_typebox.Type.Object({
-      code: import_typebox.Type.String(),
-      message: import_typebox.Type.String(),
-      extras: import_typebox.Type.Optional(import_typebox.Type.Unknown())
-    })
-  }),
-  import_typebox.Type.Object({
-    ok: import_typebox.Type.Literal(true),
-    payload: import_typebox.Type.Unknown()
-  })
-]);
-function Ok(payload) {
-  return {
-    ok: true,
-    payload
-  };
-}
-function Err(error) {
-  return {
-    ok: false,
-    payload: error
-  };
-}
-
-// transport/message.ts
-var import_typebox2 = 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_typebox2.Type.Object({
-  id: import_typebox2.Type.String(),
-  from: import_typebox2.Type.String(),
-  to: import_typebox2.Type.String(),
-  seq: import_typebox2.Type.Integer(),
-  ack: import_typebox2.Type.Integer(),
-  serviceName: import_typebox2.Type.Optional(import_typebox2.Type.String()),
-  procedureName: import_typebox2.Type.Optional(import_typebox2.Type.String()),
-  streamId: import_typebox2.Type.String(),
-  controlFlags: import_typebox2.Type.Integer(),
-  tracing: import_typebox2.Type.Optional(
-    import_typebox2.Type.Object({
-      traceparent: import_typebox2.Type.String(),
-      tracestate: import_typebox2.Type.String()
-    })
-  ),
-  payload: t
-});
-var ControlMessageAckSchema = import_typebox2.Type.Object({
-  type: import_typebox2.Type.Literal("ACK")
-});
-var ControlMessageCloseSchema = import_typebox2.Type.Object({
-  type: import_typebox2.Type.Literal("CLOSE")
-});
-var currentProtocolVersion = "v2.0";
-var ControlMessageHandshakeRequestSchema = import_typebox2.Type.Object({
-  type: import_typebox2.Type.Literal("HANDSHAKE_REQ"),
-  protocolVersion: import_typebox2.Type.String(),
-  sessionId: import_typebox2.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_typebox2.Type.Object({
-    // what the client expects the server to send next
-    nextExpectedSeq: import_typebox2.Type.Integer(),
-    nextSentSeq: import_typebox2.Type.Integer()
-  }),
-  metadata: import_typebox2.Type.Optional(import_typebox2.Type.Unknown())
-});
-var HandshakeErrorRetriableResponseCodes = import_typebox2.Type.Union([
-  import_typebox2.Type.Literal("SESSION_STATE_MISMATCH")
-]);
-var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox2.Type.Union([
-  // The custom validation handler rejected the handler because the client is unsupported.
-  import_typebox2.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
-  // The custom validation handler rejected the handshake.
-  import_typebox2.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
-]);
-var HandshakeErrorFatalResponseCodes = import_typebox2.Type.Union([
-  HandshakeErrorCustomHandlerFatalResponseCodes,
-  // The ciient sent a handshake that doesn't comply with the extended handshake metadata.
-  import_typebox2.Type.Literal("MALFORMED_HANDSHAKE_META"),
-  // The ciient sent a handshake that doesn't comply with ControlMessageHandshakeRequestSchema.
-  import_typebox2.Type.Literal("MALFORMED_HANDSHAKE"),
-  // The client's protocol version does not match the server's.
-  import_typebox2.Type.Literal("PROTOCOL_VERSION_MISMATCH")
-]);
-var HandshakeErrorResponseCodes = import_typebox2.Type.Union([
-  HandshakeErrorRetriableResponseCodes,
-  HandshakeErrorFatalResponseCodes
-]);
-var ControlMessageHandshakeResponseSchema = import_typebox2.Type.Object({
-  type: import_typebox2.Type.Literal("HANDSHAKE_RESP"),
-  status: import_typebox2.Type.Union([
-    import_typebox2.Type.Object({
-      ok: import_typebox2.Type.Literal(true),
-      sessionId: import_typebox2.Type.String()
-    }),
-    import_typebox2.Type.Object({
-      ok: import_typebox2.Type.Literal(false),
-      reason: import_typebox2.Type.String(),
-      code: HandshakeErrorResponseCodes
-    })
-  ])
-});
-var ControlMessagePayloadSchema = import_typebox2.Type.Union([
-  ControlMessageCloseSchema,
-  ControlMessageAckSchema,
-  ControlMessageHandshakeRequestSchema,
-  ControlMessageHandshakeResponseSchema
-]);
-var OpaqueTransportMessageSchema = TransportMessageSchema(
-  import_typebox2.Type.Unknown()
-);
-function isAck(controlFlag) {
-  return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
-}
-
-// util/stringify.ts
-function coerceErrorString(err) {
-  if (err instanceof Error) {
-    return err.message || "unknown reason";
-  }
-  return `[coerced to error] ${String(err)}`;
-}
-
-// router/streams.ts
-var ReadableBrokenError = {
-  code: "READABLE_BROKEN",
-  message: "Readable was broken before it is fully consumed"
-};
-function createPromiseWithResolvers() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return {
-    promise,
-    // @ts-expect-error promise callbacks are sync
-    resolve,
-    // @ts-expect-error promise callbacks are sync
-    reject
-  };
-}
-var ReadableImpl = class {
-  /**
-   * Whether the {@link Readable} is closed.
-   *
-   * Closed {@link Readable}s are done receiving values, but that doesn't affect
-   * any other aspect of the {@link Readable} such as it's consumability.
-   */
-  closed = false;
-  /**
-   * Whether the {@link Readable} is locked.
-   *
-   * @see {@link Readable}'s typedoc to understand locking
-   */
-  locked = false;
-  /**
-   * Whether {@link break} was called.
-   *
-   * @see {@link break} for more information
-   */
-  broken = false;
-  /**
-   * This flag allows us to avoid emitting a {@link ReadableBrokenError} after {@link break} was called
-   * in cases where the {@link queue} is fully consumed and {@link ReadableImpl} is {@link closed}. This is just an
-   * ergonomic feature to avoid emitting an error in our iteration when we don't have to.
-   */
-  brokenWithValuesLeftToRead = false;
-  /**
-   * A list of values that have been pushed to the {@link ReadableImpl} but not yet emitted to the user.
-   */
-  queue = [];
-  /**
-   * Used by methods in the class to signal to the iterator that it
-   * should check for the next value.
-   */
-  next = null;
-  [Symbol.asyncIterator]() {
-    if (this.locked) {
-      throw new TypeError("Readable is already locked");
-    }
-    this.locked = true;
-    let didSignalBreak = false;
-    return {
-      next: async () => {
-        if (didSignalBreak) {
-          return {
-            done: true,
-            value: void 0
-          };
-        }
-        while (this.queue.length === 0) {
-          if (this.closed && !this.brokenWithValuesLeftToRead) {
-            return {
-              done: true,
-              value: void 0
-            };
-          }
-          if (this.broken) {
-            didSignalBreak = true;
-            return {
-              done: false,
-              value: Err(ReadableBrokenError)
-            };
-          }
-          if (!this.next) {
-            this.next = createPromiseWithResolvers();
-          }
-          await this.next.promise;
-          this.next = null;
-        }
-        const value = this.queue.shift();
-        return { done: false, value };
-      },
-      return: () => {
-        this.break();
-        return { done: true, value: void 0 };
-      }
-    };
-  }
-  async collect() {
-    const array = [];
-    for await (const value of this) {
-      array.push(value);
-    }
-    return array;
-  }
-  break() {
-    if (this.broken) {
-      return;
-    }
-    this.locked = true;
-    this.broken = true;
-    this.brokenWithValuesLeftToRead = this.queue.length > 0;
-    this.queue.length = 0;
-    this.next?.resolve();
-  }
-  isReadable() {
-    return !this.locked && !this.broken;
-  }
-  /**
-   * @internal meant for use within river, not exposed as a public API
-   *
-   * Pushes a value to be read.
-   */
-  _pushValue(value) {
-    if (this.broken) {
-      return;
-    }
-    if (this.closed) {
-      throw new Error("Cannot push to closed Readable");
-    }
-    this.queue.push(value);
-    this.next?.resolve();
-  }
-  /**
-   * @internal meant for use within river, not exposed as a public API
-   *
-   * Triggers the close of the {@link Readable}. Make sure to push all remaining
-   * values before calling this method.
-   */
-  _triggerClose() {
-    if (this.closed) {
-      throw new Error("Unexpected closing multiple times");
-    }
-    this.closed = true;
-    this.next?.resolve();
-  }
-  /**
-   * @internal meant for use within river, not exposed as a public API
-   */
-  _hasValuesInQueue() {
-    return this.queue.length > 0;
-  }
-  /**
-   * @internal meant for use within river, not exposed as a public API
-   */
-  isClosed() {
-    return this.closed;
-  }
-};
-var WritableImpl = class {
-  /**
-   * Passed via constructor to pass on calls to {@link write}
-   */
-  writeCb;
-  /**
-   * Passed via constructor to pass on calls to {@link close}
-   */
-  closeCb;
-  /**
-   * Whether {@link close} was called, and {@link Writable} is not writable anymore.
-   */
-  closed = false;
-  constructor(callbacks) {
-    this.writeCb = callbacks.writeCb;
-    this.closeCb = callbacks.closeCb;
-  }
-  write(value) {
-    if (this.closed) {
-      throw new Error("Cannot write to closed Writable");
-    }
-    this.writeCb(value);
-  }
-  isWritable() {
-    return !this.closed;
-  }
-  close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    this.writeCb = () => void 0;
-    this.closeCb();
-    this.closeCb = () => void 0;
-  }
-  /**
-   * @internal meant for use within river, not exposed as a public API
-   */
-  isClosed() {
-    return this.closed;
-  }
-};
-
-// 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.200.5";
-
-// tracing/index.ts
-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);
-
-// 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
-  }
-};
-
-// router/errors.ts
-var import_typebox3 = require("@sinclair/typebox");
-var UNCAUGHT_ERROR_CODE = "UNCAUGHT_ERROR";
-var UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
-var INVALID_REQUEST_CODE = "INVALID_REQUEST";
-var CANCEL_CODE = "CANCEL";
-var ReaderErrorSchema = import_typebox3.Type.Union([
-  import_typebox3.Type.Object({
-    code: import_typebox3.Type.Literal(UNCAUGHT_ERROR_CODE),
-    message: import_typebox3.Type.String()
-  }),
-  import_typebox3.Type.Object({
-    code: import_typebox3.Type.Literal(UNEXPECTED_DISCONNECT_CODE),
-    message: import_typebox3.Type.String()
-  }),
-  import_typebox3.Type.Object({
-    code: import_typebox3.Type.Literal(INVALID_REQUEST_CODE),
-    message: import_typebox3.Type.String()
-  }),
-  import_typebox3.Type.Object({
-    code: import_typebox3.Type.Literal(CANCEL_CODE),
-    message: import_typebox3.Type.String()
-  })
-]);
-
-// util/testHelpers.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);
-  });
-}
-function catchProcError(err) {
-  const errorMsg = coerceErrorString(err);
-  return Err({ code: UNCAUGHT_ERROR_CODE, message: errorMsg });
-}
-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 dummyCtx(state, session, extendedContext) {
-  return {
-    ...extendedContext,
-    state,
-    sessionId: session.id,
-    from: session.from,
-    metadata: {},
-    // TODO might wanna hook these up!
-    cancel: () => void 0,
-    signal: new AbortController().signal
-  };
-}
-function asClientRpc(state, proc, extendedContext, session = dummySession()) {
-  return async (msg) => {
-    return proc.handler({
-      ctx: dummyCtx(state, session, extendedContext),
-      reqInit: msg
-    }).catch(catchProcError);
-  };
-}
-function createResponsePipe() {
-  const readable = new ReadableImpl();
-  const writable = new WritableImpl({
-    writeCb: (v) => {
-      readable._pushValue(v);
-    },
-    closeCb: () => {
-      void Promise.resolve().then(() => {
-        readable._triggerClose();
-      });
-    }
-  });
-  return { readable, writable };
-}
-function createRequestPipe() {
-  const readable = new ReadableImpl();
-  const writable = new WritableImpl({
-    writeCb: (v) => {
-      readable._pushValue(Ok(v));
-    },
-    closeCb: () => {
-      void Promise.resolve().then(() => {
-        readable._triggerClose();
-      });
-    }
-  });
-  return { readable, writable };
-}
-function asClientStream(state, proc, reqInit, extendedContext, session = dummySession()) {
-  const requestPipe = createRequestPipe();
-  const responsePipe = createResponsePipe();
-  void proc.handler({
-    ctx: dummyCtx(state, session, extendedContext),
-    reqInit: reqInit ?? {},
-    reqReadable: requestPipe.readable,
-    resWritable: responsePipe.writable
-  }).catch((err) => responsePipe.writable.write(catchProcError(err)));
-  return {
-    reqWritable: requestPipe.writable,
-    resReadable: responsePipe.readable
-  };
-}
-function asClientSubscription(state, proc, extendedContext, session = dummySession()) {
-  const responsePipe = createResponsePipe();
-  return (msg) => {
-    void proc.handler({
-      ctx: dummyCtx(state, session, extendedContext),
-      reqInit: msg,
-      resWritable: responsePipe.writable
-    }).catch(
-      (err) => responsePipe.writable.write(catchProcError(err))
-    );
-    return { resReadable: responsePipe.readable };
-  };
-}
-function asClientUpload(state, proc, reqInit, extendedContext, session = dummySession()) {
-  const requestPipe = createRequestPipe();
-  const result = proc.handler({
-    ctx: dummyCtx(state, session, extendedContext),
-    reqInit: reqInit ?? {},
-    reqReadable: requestPipe.readable
-  }).catch(catchProcError);
-  return { reqWritable: requestPipe.writable, finalize: () => result };
-}
-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 = {
-  asClientRpc,
-  asClientStream,
-  asClientSubscription,
-  asClientUpload,
-  closeAllConnections,
-  createDummyTransportMessage,
-  createLocalWebSocketClient,
-  createWebSocketServer,
-  dummySession,
-  getClientSendFn,
-  getReadableIterator,
-  getServerSendFn,
-  getTransportConnections,
-  isReadableDone,
-  numberOfConnections,
-  onWsServerReady,
-  payloadToTransportMessage,
-  readNextResult,
-  testingClientSessionOptions,
-  testingSessionOptions,
-  waitForMessage
-});
-//# sourceMappingURL=testHelpers.cjs.map