@replit/river 0.12.6 → 0.13.0

package/dist/transport/impls/stdio/client.cjs

@@ -1,904 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// transport/impls/stdio/client.ts
-var client_exports = {};
-__export(client_exports, {
-  StdioClientTransport: () => StdioClientTransport
-});
-module.exports = __toCommonJS(client_exports);
-
-// logging/index.ts
-var log;
-
-// transport/transport.ts
-var import_value = require("@sinclair/typebox/value");
-
-// transport/message.ts
-var import_typebox = require("@sinclair/typebox");
-var import_nanoid = require("nanoid");
-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.Union([import_typebox.Type.String(), import_typebox.Type.Null()])),
-  procedureName: import_typebox.Type.Optional(import_typebox.Type.Union([import_typebox.Type.String(), import_typebox.Type.Null()])),
-  streamId: import_typebox.Type.String(),
-  controlFlags: import_typebox.Type.Integer(),
-  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 PROTOCOL_VERSION = "v1";
-var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("HANDSHAKE_REQ"),
-  protocolVersion: import_typebox.Type.Literal(PROTOCOL_VERSION),
-  instanceId: import_typebox.Type.String()
-});
-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),
-      instanceId: import_typebox.Type.String()
-    }),
-    import_typebox.Type.Object({
-      ok: import_typebox.Type.Literal(false),
-      reason: import_typebox.Type.Union([import_typebox.Type.Literal("VERSION_MISMATCH")])
-    })
-  ])
-});
-var ControlMessagePayloadSchema = import_typebox.Type.Union([
-  ControlMessageCloseSchema,
-  ControlMessageAckSchema,
-  ControlMessageHandshakeRequestSchema,
-  ControlMessageHandshakeResponseSchema
-]);
-var OpaqueTransportMessageSchema = TransportMessageSchema(
-  import_typebox.Type.Unknown()
-);
-function bootRequestMessage(from, to, instanceId) {
-  return {
-    id: (0, import_nanoid.nanoid)(),
-    from,
-    to,
-    seq: 0,
-    ack: 0,
-    streamId: (0, import_nanoid.nanoid)(),
-    controlFlags: 0,
-    payload: {
-      type: "HANDSHAKE_REQ",
-      protocolVersion: PROTOCOL_VERSION,
-      instanceId
-    }
-  };
-}
-function isAck(controlFlag) {
-  return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
-}
-
-// transport/events.ts
-var EventDispatcher = class {
-  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) {
-      for (const handler of handlers) {
-        handler(event);
-      }
-    }
-  }
-};
-
-// transport/session.ts
-var import_nanoid2 = require("nanoid");
-var nanoid2 = (0, import_nanoid2.customAlphabet)("1234567890abcdefghijklmnopqrstuvxyz", 6);
-var unsafeId = () => nanoid2();
-var Connection = class {
-  debugId;
-  constructor() {
-    this.debugId = `conn-${unsafeId()}`;
-  }
-};
-var HEARTBEAT_INTERVAL_MS = 1e3;
-var HEARTBEATS_TILL_DEAD = 2;
-var SESSION_DISCONNECT_GRACE_MS = 5e3;
-var Session = class {
-  codec;
-  /**
-   * The buffer of messages that have been sent but not yet acknowledged.
-   */
-  sendBuffer = [];
-  /**
-   * The active connection associated with this session
-   */
-  connection;
-  from;
-  to;
-  /**
-   * The unique ID of this session.
-   */
-  debugId;
-  /**
-   * Number of messages we've sent along this session (excluding handshake)
-   */
-  seq = 0;
-  /**
-   * Number of unique messages we've received this session (excluding handshake)
-   */
-  ack = 0;
-  /**
-   * The grace period between when the inner connection is disconnected
-   * and when we should consider the entire session disconnected.
-   */
-  disconnectionGrace;
-  /**
-   * Number of heartbeats we've sent without a response.
-   */
-  heartbeatMisses;
-  /**
-   * The interval for sending heartbeats.
-   */
-  heartbeat;
-  constructor(codec, from, connectedTo, conn) {
-    this.debugId = `sess-${unsafeId()}`;
-    this.from = from;
-    this.to = connectedTo;
-    this.connection = conn;
-    this.codec = codec;
-    this.heartbeatMisses = 0;
-    this.heartbeat = setInterval(
-      () => this.sendHeartbeat(),
-      HEARTBEAT_INTERVAL_MS
-    );
-  }
-  /**
-   * Sends a message over the session's connection.
-   * If the connection is not ready or the message fails to send, the message can be buffered for retry unless skipped.
-   *
-   * @param msg The partial message to be sent, which will be constructed into a full message.
-   * @param skipRetry Optional. If true, the message will not be buffered for retry on failure. This should only be used for
-   * ack hearbeats, which contain information that can already be found in the other buffered messages.
-   * @returns The full transport ID of the message that was attempted to be sent.
-   */
-  send(msg, skipRetry) {
-    const fullMsg = this.constructMsg(msg);
-    log?.debug(`${this.from} -- sending ${JSON.stringify(fullMsg)}`);
-    if (this.connection) {
-      const ok = this.connection.send(this.codec.toBuffer(fullMsg));
-      if (ok)
-        return fullMsg.id;
-      log?.info(
-        `${this.from} -- failed to send ${fullMsg.id} to ${fullMsg.to}, connection (id: ${this.connection.debugId}) is probably dead`
-      );
-    } else {
-      log?.info(
-        `${this.from} -- failed to send ${fullMsg.id} to ${fullMsg.to}, connection not ready yet`
-      );
-    }
-    if (skipRetry)
-      return fullMsg.id;
-    this.addToSendBuff(fullMsg);
-    log?.info(
-      `${this.from} -- buffering msg ${fullMsg.id} until connection is healthy again`
-    );
-    return fullMsg.id;
-  }
-  sendHeartbeat() {
-    if (this.heartbeatMisses >= HEARTBEATS_TILL_DEAD) {
-      if (this.connection) {
-        log?.info(
-          `${this.from} -- closing connection (id: ${this.connection.debugId}) to ${this.to} due to inactivity`
-        );
-        this.closeStaleConnection(this.connection);
-      }
-      return;
-    }
-    this.send(
-      {
-        streamId: "heartbeat",
-        controlFlags: 1 /* AckBit */,
-        payload: {
-          type: "ACK"
-        }
-      },
-      true
-    );
-    this.heartbeatMisses++;
-  }
-  resetBufferedMessages() {
-    this.sendBuffer = [];
-    this.seq = 0;
-    this.ack = 0;
-  }
-  sendBufferedMessages() {
-    if (!this.connection) {
-      const msg = `${this.from} -- tried sending buffered messages without a connection (if you hit this code path something is seriously wrong)`;
-      log?.error(msg);
-      throw new Error(msg);
-    }
-    for (const msg of this.sendBuffer) {
-      log?.debug(`${this.from} -- resending ${JSON.stringify(msg)}`);
-      const ok = this.connection.send(this.codec.toBuffer(msg));
-      if (!ok) {
-        const msg2 = `${this.from} -- failed to send buffered message to ${this.to} in session (id: ${this.debugId}) (if you hit this code path something is seriously wrong)`;
-        log?.error(msg2);
-        throw new Error(msg2);
-      }
-    }
-  }
-  updateBookkeeping(ack, seq) {
-    this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq > ack);
-    this.ack = seq + 1;
-  }
-  addToSendBuff(msg) {
-    this.sendBuffer.push(msg);
-    log?.debug(
-      `${this.from} -- send buff to ${this.to} now tracking ${this.sendBuffer.length} messages`
-    );
-  }
-  closeStaleConnection(conn) {
-    if (!this.connection || this.connection !== conn)
-      return;
-    log?.info(
-      `${this.from} -- closing old inner connection (id: ${this.connection.debugId}) from session (id: ${this.debugId}) to ${this.to}`
-    );
-    this.connection.close();
-    this.connection = void 0;
-  }
-  replaceWithNewConnection(newConn) {
-    this.closeStaleConnection(this.connection);
-    this.cancelGrace();
-    this.connection = newConn;
-  }
-  beginGrace(cb) {
-    this.disconnectionGrace = setTimeout(() => {
-      this.close();
-      cb();
-    }, SESSION_DISCONNECT_GRACE_MS);
-  }
-  // called on reconnect of the underlying session
-  cancelGrace() {
-    this.heartbeatMisses = 0;
-    clearTimeout(this.disconnectionGrace);
-  }
-  // closed when we want to discard the whole session
-  // (i.e. shutdown or session disconnect)
-  close() {
-    this.closeStaleConnection(this.connection);
-    this.cancelGrace();
-    this.resetBufferedMessages();
-    clearInterval(this.heartbeat);
-  }
-  get connected() {
-    return this.connection !== void 0;
-  }
-  get nextExpectedSeq() {
-    return this.ack;
-  }
-  constructMsg(partialMsg) {
-    const msg = {
-      ...partialMsg,
-      id: unsafeId(),
-      to: this.to,
-      from: this.from,
-      seq: this.seq,
-      ack: this.ack
-    };
-    this.seq++;
-    return msg;
-  }
-  inspectSendBuffer() {
-    return this.sendBuffer;
-  }
-};
-
-// 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/transport.ts
-var import_nanoid3 = require("nanoid");
-
-// util/stringify.ts
-function coerceErrorString(err) {
-  if (err instanceof Error) {
-    return err.message;
-  }
-  return `[coerced to error] ${String(err)}`;
-}
-
-// transport/transport.ts
-var DEFAULT_RECONNECT_JITTER_MAX_MS = 500;
-var DEFAULT_RECONNECT_INTERVAL_MS = 250;
-var defaultTransportOptions = {
-  retryIntervalMs: DEFAULT_RECONNECT_INTERVAL_MS,
-  retryJitterMs: DEFAULT_RECONNECT_JITTER_MAX_MS,
-  retryAttemptsMax: 5,
-  codec: NaiveJsonCodec
-};
-var Transport = class {
-  /**
-   * Unique per instance of the transport.
-   * This allows us to distinguish reconnects to different
-   * transports.
-   */
-  instanceId = (0, import_nanoid3.nanoid)();
-  connectedInstanceIds = /* @__PURE__ */ new Map();
-  /**
-   * A flag indicating whether the transport has been destroyed.
-   * A destroyed transport will not attempt to reconnect and cannot be used again.
-   */
-  state;
-  /**
-   * The {@link Codec} used to encode and decode messages.
-   */
-  codec;
-  /**
-   * The client ID of this transport.
-   */
-  clientId;
-  /**
-   * The map of {@link Session}s managed by this transport.
-   */
-  sessions;
-  /**
-   * The map of {@link Connection}s managed by this transport.
-   */
-  get connections() {
-    return new Map(
-      [...this.sessions].map(([client, session]) => [client, session.connection]).filter((entry) => entry[1] !== void 0)
-    );
-  }
-  /**
-   * The event dispatcher for handling events of type EventTypes.
-   */
-  eventDispatcher;
-  /**
-   * The options for this transport.
-   */
-  options;
-  /**
-   * Creates a new Transport instance.
-   * This should also set up {@link onConnect}, and {@link onDisconnect} listeners.
-   * @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.sessions = /* @__PURE__ */ new Map();
-    this.codec = this.options.codec;
-    this.clientId = clientId;
-    this.state = "open";
-  }
-  /**
-   * Called when a new connection is established
-   * and we know the identity of the connected client.
-   * @param conn The connection object.
-   */
-  onConnect(conn, connectedTo, instanceId) {
-    this.eventDispatcher.dispatchEvent("connectionStatus", {
-      status: "connect",
-      conn
-    });
-    let oldSession = this.sessions.get(connectedTo);
-    const lastInstanceId = this.connectedInstanceIds.get(connectedTo);
-    if (oldSession && lastInstanceId !== void 0 && lastInstanceId !== instanceId) {
-      log?.warn(
-        `${this.clientId} -- handshake from ${connectedTo} is a different instance (got: ${instanceId}, last connected to: ${lastInstanceId}), starting a new session`
-      );
-      oldSession.close();
-      this.deleteSession(oldSession);
-      oldSession = void 0;
-    }
-    this.connectedInstanceIds.set(connectedTo, instanceId);
-    if (oldSession === void 0) {
-      const newSession = this.createSession(connectedTo, conn);
-      log?.info(
-        `${this.clientId} -- new connection (id: ${conn.debugId}) for new session (id: ${newSession.debugId}) to ${connectedTo}`
-      );
-      return newSession;
-    }
-    log?.info(
-      `${this.clientId} -- new connection (id: ${conn.debugId}) for existing session (id: ${oldSession.debugId}) to ${connectedTo}`
-    );
-    oldSession.replaceWithNewConnection(conn);
-    oldSession.sendBufferedMessages();
-    return oldSession;
-  }
-  createSession(connectedTo, conn) {
-    const session = new Session(
-      this.codec,
-      this.clientId,
-      connectedTo,
-      conn
-    );
-    this.sessions.set(session.to, session);
-    this.eventDispatcher.dispatchEvent("sessionStatus", {
-      status: "connect",
-      session
-    });
-    return session;
-  }
-  deleteSession(session) {
-    this.sessions.delete(session.to);
-    log?.info(
-      `${this.clientId} -- session ${session.debugId} disconnect from ${session.to}`
-    );
-    this.eventDispatcher.dispatchEvent("sessionStatus", {
-      status: "disconnect",
-      session
-    });
-  }
-  /**
-   * The downstream implementation needs to call this when a connection is closed.
-   * @param conn The connection object.
-   * @param connectedTo The peer we are connected to.
-   */
-  onDisconnect(conn, connectedTo) {
-    this.eventDispatcher.dispatchEvent("connectionStatus", {
-      status: "disconnect",
-      conn
-    });
-    const session = this.sessions.get(connectedTo);
-    if (!session)
-      return;
-    session.connection = void 0;
-    session.beginGrace(() => this.deleteSession(session));
-  }
-  /**
-   * Parses a message from a Uint8Array into a {@link OpaqueTransportMessage}.
-   * @param msg The message to parse.
-   * @returns The parsed message, or null if the message is malformed or invalid.
-   */
-  parseMsg(msg) {
-    const parsedMsg = this.codec.fromBuffer(msg);
-    if (parsedMsg === null) {
-      const decodedBuffer = new TextDecoder().decode(msg);
-      log?.error(
-        `${this.clientId} -- received malformed msg, killing conn: ${decodedBuffer}`
-      );
-      return null;
-    }
-    if (!import_value.Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
-      log?.error(
-        `${this.clientId} -- received invalid msg: ${JSON.stringify(
-          parsedMsg
-        )}`
-      );
-      return null;
-    }
-    return {
-      ...parsedMsg,
-      serviceName: parsedMsg.serviceName === null ? void 0 : parsedMsg.serviceName,
-      procedureName: parsedMsg.procedureName === null ? void 0 : parsedMsg.procedureName
-    };
-  }
-  /**
-   * Called when a message is received by this transport.
-   * You generally shouldn't need to override this in downstream transport implementations.
-   * @param msg The received message.
-   */
-  handleMsg(msg) {
-    if (this.state !== "open")
-      return;
-    const session = this.sessions.get(msg.from);
-    if (!session) {
-      const err = `${this.clientId} -- (invariant violation) no existing session for ${msg.from}`;
-      log?.error(err);
-      return;
-    }
-    session.cancelGrace();
-    log?.debug(`${this.clientId} -- received msg: ${JSON.stringify(msg)}`);
-    if (msg.seq !== session.nextExpectedSeq) {
-      log?.warn(
-        `${this.clientId} -- received out-of-order msg (got: ${msg.seq}, wanted: ${session.nextExpectedSeq}), discarding: ${JSON.stringify(
-          msg
-        )}`
-      );
-      return;
-    }
-    if (!isAck(msg.controlFlags)) {
-      this.eventDispatcher.dispatchEvent("message", msg);
-    }
-    session.updateBookkeeping(msg.ack, msg.seq);
-  }
-  /**
-   * 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 unlisten on
-   * @param handler The message handler to remove.
-   */
-  removeEventListener(type, handler) {
-    this.eventDispatcher.removeEventListener(type, handler);
-  }
-  /**
-   * Sends a message over this transport, delegating to the appropriate connection to actually
-   * send the message.
-   * @param msg The message to send.
-   * @returns The ID of the sent message or undefined if it wasn't sent
-   */
-  send(to, msg) {
-    if (this.state === "destroyed") {
-      const err = "transport is destroyed, cant send";
-      log?.error(`${this.clientId} -- ` + err + `: ${JSON.stringify(msg)}`);
-      throw new Error(err);
-    } else if (this.state === "closed") {
-      log?.info(
-        `${this.clientId} -- transport closed when sending, discarding : ${JSON.stringify(
-          msg
-        )}`
-      );
-      return void 0;
-    }
-    let session = this.sessions.get(to);
-    if (!session) {
-      session = this.createSession(to, void 0);
-      log?.info(
-        `${this.clientId} -- no session for ${to}, created a new one (id: ${session.debugId})`
-      );
-    }
-    return session.send(msg);
-  }
-  // control helpers
-  sendCloseStream(to, streamId) {
-    return this.send(to, {
-      streamId,
-      controlFlags: 4 /* StreamClosedBit */,
-      payload: {
-        type: "CLOSE"
-      }
-    });
-  }
-  /**
-   * 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.state = "closed";
-    for (const session of this.sessions.values()) {
-      session.close();
-      this.deleteSession(session);
-    }
-    log?.info(`${this.clientId} -- manually closed transport`);
-  }
-  /**
-   * Default destroy implementation for transports. You should override this in the downstream
-   * implementation if you need to do any additional cleanup and call super.destroy() at the end.
-   * Destroys the transport. Any messages sent while the transport is destroyed will throw an error.
-   */
-  destroy() {
-    this.state = "destroyed";
-    for (const session of this.sessions.values()) {
-      session.close();
-      this.deleteSession(session);
-    }
-    log?.info(`${this.clientId} -- manually destroyed transport`);
-  }
-};
-var ClientTransport = class extends Transport {
-  /**
-   * The map of reconnect promises for each client ID.
-   */
-  inflightConnectionPromises;
-  tryReconnecting = true;
-  constructor(clientId, providedOptions) {
-    super(clientId, providedOptions);
-    this.inflightConnectionPromises = /* @__PURE__ */ new Map();
-  }
-  handleConnection(conn, to) {
-    const bootHandler = this.receiveWithBootSequence(conn, () => {
-      conn.removeDataListener(bootHandler);
-      conn.addDataListener((data) => {
-        const parsed = this.parseMsg(data);
-        if (!parsed) {
-          conn.close();
-          return;
-        }
-        this.handleMsg(parsed);
-      });
-    });
-    conn.addDataListener(bootHandler);
-    conn.addCloseListener(() => {
-      this.onDisconnect(conn, to);
-      void this.connect(to);
-    });
-    conn.addErrorListener((err) => {
-      log?.warn(
-        `${this.clientId} -- error in connection (id: ${conn.debugId}) to ${to}: ${coerceErrorString(err)}`
-      );
-    });
-  }
-  /**
-   * Manually attempts to connect to a client.
-   * @param to The client ID of the node to connect to.
-   */
-  async connect(to, attempt = 0) {
-    if (this.state !== "open" || !this.tryReconnecting) {
-      log?.info(
-        `${this.clientId} -- transport state is no longer open, not attempting connection`
-      );
-      return;
-    }
-    let reconnectPromise = this.inflightConnectionPromises.get(to);
-    if (!reconnectPromise) {
-      reconnectPromise = this.createNewOutgoingConnection(to);
-      this.inflightConnectionPromises.set(to, reconnectPromise);
-    }
-    try {
-      const conn = await reconnectPromise;
-      this.state = "open";
-      const requestMsg = bootRequestMessage(this.clientId, to, this.instanceId);
-      log?.debug(`${this.clientId} -- sending boot handshake to ${to}`);
-      conn.send(this.codec.toBuffer(requestMsg));
-    } catch (error) {
-      const errStr = coerceErrorString(error);
-      this.inflightConnectionPromises.delete(to);
-      if (attempt >= this.options.retryAttemptsMax) {
-        const errMsg = `connection to ${to} failed after ${attempt} attempts (${errStr}), giving up`;
-        log?.error(`${this.clientId} -- ${errMsg}`);
-        throw new Error(errMsg);
-      } else {
-        const jitter = Math.floor(Math.random() * this.options.retryJitterMs);
-        const backoffMs = this.options.retryIntervalMs * 2 ** attempt + jitter;
-        log?.warn(
-          `${this.clientId} -- connection to ${to} failed (${errStr}), trying again in ${backoffMs}ms`
-        );
-        setTimeout(() => void this.connect(to, attempt + 1), backoffMs);
-      }
-    }
-  }
-  receiveWithBootSequence(conn, sessionCb) {
-    const bootHandler = (data) => {
-      const parsed = this.parseMsg(data);
-      if (!parsed) {
-        conn.close();
-        return;
-      }
-      if (!import_value.Value.Check(ControlMessageHandshakeResponseSchema, parsed.payload)) {
-        log?.warn(
-          `${this.clientId} -- received invalid handshake resp: ${JSON.stringify(parsed)}`
-        );
-        return;
-      }
-      if (!parsed.payload.status.ok) {
-        log?.warn(
-          `${this.clientId} -- received failed handshake resp: ${JSON.stringify(
-            parsed
-          )}`
-        );
-        return;
-      }
-      const serverInstanceId = parsed.payload.status.instanceId;
-      log?.debug(
-        `${this.clientId} -- handshake from ${parsed.from} ok (server instance: ${serverInstanceId})`
-      );
-      sessionCb(this.onConnect(conn, parsed.from, serverInstanceId));
-    };
-    return bootHandler;
-  }
-  onDisconnect(conn, connectedTo) {
-    this.inflightConnectionPromises.delete(connectedTo);
-    super.onDisconnect(conn, connectedTo);
-  }
-};
-
-// transport/transforms/messageFraming.ts
-var import_node_stream = require("stream");
-var Uint32LengthPrefixFraming = class extends import_node_stream.Transform {
-  receivedBuffer;
-  maxBufferSizeBytes;
-  constructor({ maxBufferSizeBytes, ...options }) {
-    super(options);
-    this.maxBufferSizeBytes = maxBufferSizeBytes;
-    this.receivedBuffer = Buffer.alloc(0);
-  }
-  _transform(chunk, _encoding, cb) {
-    if (this.receivedBuffer.byteLength + chunk.byteLength > this.maxBufferSizeBytes) {
-      const err = new Error(
-        `buffer overflow: ${this.receivedBuffer.byteLength}B > ${this.maxBufferSizeBytes}B`
-      );
-      this.emit("error", err);
-      cb(err);
-      return;
-    }
-    this.receivedBuffer = Buffer.concat([this.receivedBuffer, chunk]);
-    while (this.receivedBuffer.length > 4) {
-      const claimedMessageLength = this.receivedBuffer.readUInt32BE(0) + 4;
-      if (this.receivedBuffer.length >= claimedMessageLength) {
-        const message = this.receivedBuffer.subarray(4, claimedMessageLength);
-        this.push(message);
-        this.receivedBuffer = this.receivedBuffer.subarray(claimedMessageLength);
-      } else {
-        break;
-      }
-    }
-    cb();
-  }
-  _flush(cb) {
-    if (this.receivedBuffer.length) {
-      this.emit("error", new Error("got incomplete message while flushing"));
-    }
-    this.receivedBuffer = Buffer.alloc(0);
-    cb();
-  }
-  _destroy(error, callback) {
-    this.receivedBuffer = Buffer.alloc(0);
-    super._destroy(error, callback);
-  }
-};
-function createLengthEncodedStream(options) {
-  return new Uint32LengthPrefixFraming({
-    maxBufferSizeBytes: options?.maxBufferSizeBytes ?? 16 * 1024 * 1024
-    // 16MB
-  });
-}
-var MessageFramer = {
-  createFramedStream: createLengthEncodedStream,
-  write: (buf) => {
-    const lengthPrefix = Buffer.alloc(4);
-    lengthPrefix.writeUInt32BE(buf.length, 0);
-    return Buffer.concat([lengthPrefix, buf]);
-  }
-};
-
-// transport/impls/stdio/connection.ts
-var StreamConnection = class extends Connection {
-  input;
-  output;
-  framer;
-  constructor(input, output) {
-    super();
-    this.framer = MessageFramer.createFramedStream();
-    this.input = input.pipe(this.framer);
-    this.output = output;
-  }
-  addDataListener(cb) {
-    this.input.on("data", cb);
-  }
-  removeDataListener(cb) {
-    this.input.off("data", cb);
-  }
-  addCloseListener(cb) {
-    this.input.on("close", cb);
-    this.output.on("close", cb);
-  }
-  addErrorListener(cb) {
-    this.input.on("error", cb);
-    this.output.on("error", cb);
-  }
-  send(payload) {
-    if (!this.output.writable)
-      return false;
-    return this.output.write(MessageFramer.write(payload));
-  }
-  close() {
-    this.output.end();
-    this.input.unpipe(this.framer);
-    this.framer.destroy();
-  }
-};
-
-// transport/impls/stdio/client.ts
-var StdioClientTransport = class extends ClientTransport {
-  input = process.stdin;
-  output = process.stdout;
-  serverId;
-  /**
-   * Constructs a new StdioClientTransport instance.
-   * @param clientId - The ID of the client associated with this transport.
-   * @param input - The readable stream to use as input. Defaults to process.stdin.
-   * @param output - The writable stream to use as output. Defaults to process.stdout.
-   */
-  constructor(clientId, input = process.stdin, output = process.stdout, serverId, providedOptions) {
-    super(clientId, providedOptions);
-    this.input = input;
-    this.output = output;
-    this.serverId = serverId;
-    void this.connect(serverId);
-  }
-  async createNewOutgoingConnection(to) {
-    log?.info(`${this.clientId} -- establishing a new stream to ${to}`);
-    const conn = new StreamConnection(this.input, this.output);
-    this.handleConnection(conn, to);
-    return Promise.resolve(conn);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  StdioClientTransport
-});