@replit/river 0.207.2 → 0.208.0

package/dist/chunk-A7RGOVRV.js

@@ -1,438 +0,0 @@
-import {
-  ClientSessionStateGraph,
-  ProtocolError,
-  Transport,
-  defaultClientTransportOptions
-} from "./chunk-24EWYOGK.js";
-import {
-  ControlMessageHandshakeResponseSchema,
-  HandshakeErrorRetriableResponseCodes,
-  coerceErrorString,
-  currentProtocolVersion,
-  getPropagationContext,
-  handshakeRequestMessage
-} from "./chunk-46IVOKJU.js";
-
-// transport/client.ts
-import { SpanStatusCode } from "@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();
-  }
-};
-
-// transport/client.ts
-import { Value } from "@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.tracer,
-      this.log
-    );
-    this.createSession(session);
-    return session;
-  }
-  // listeners
-  onConnectingFailed(session) {
-    const noConnectionSession = super.onConnectingFailed(session);
-    this.tryReconnecting(noConnectionSession.to);
-    return noConnectionSession;
-  }
-  onConnClosed(session) {
-    const noConnectionSession = super.onConnClosed(session);
-    this.tryReconnecting(noConnectionSession.to);
-    return noConnectionSession;
-  }
-  onConnectionEstablished(session, conn) {
-    const handshakingSession = ClientSessionStateGraph.transition.ConnectingToHandshaking(
-      session,
-      conn,
-      {
-        onConnectionErrored: (err) => {
-          const errStr = coerceErrorString(err);
-          this.log?.error(
-            `connection to ${handshakingSession.to} errored during handshake: ${errStr}`,
-            handshakingSession.loggingMetadata
-          );
-        },
-        onConnectionClosed: () => {
-          this.log?.warn(
-            `connection to ${handshakingSession.to} closed during handshake`,
-            handshakingSession.loggingMetadata
-          );
-          this.onConnClosed(handshakingSession);
-        },
-        onHandshake: (msg) => {
-          this.onHandshakeResponse(handshakingSession, msg);
-        },
-        onInvalidHandshake: (reason, code) => {
-          this.log?.error(
-            `invalid handshake: ${reason}`,
-            handshakingSession.loggingMetadata
-          );
-          this.deleteSession(session, { unhealthy: true });
-          this.protocolError({
-            type: ProtocolError.HandshakeFailed,
-            code,
-            message: reason
-          });
-        },
-        onHandshakeTimeout: () => {
-          this.log?.error(
-            `connection to ${handshakingSession.to} timed out during handshake`,
-            handshakingSession.loggingMetadata
-          );
-          this.onConnClosed(handshakingSession);
-        },
-        onSessionGracePeriodElapsed: () => {
-          this.onSessionGracePeriodElapsed(handshakingSession);
-        }
-      }
-    );
-    this.updateSession(handshakingSession);
-    void this.sendHandshake(handshakingSession);
-    return handshakingSession;
-  }
-  rejectHandshakeResponse(session, reason, metadata) {
-    session.conn.telemetry?.span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: reason
-    });
-    this.log?.warn(reason, metadata);
-    this.deleteSession(session, { unhealthy: true });
-  }
-  onHandshakeResponse(session, msg) {
-    if (!Value.Check(ControlMessageHandshakeResponseSchema, msg.payload)) {
-      const reason = `received invalid handshake response`;
-      this.rejectHandshakeResponse(session, reason, {
-        ...session.loggingMetadata,
-        transportMessage: msg,
-        validationErrors: [
-          ...Value.Errors(ControlMessageHandshakeResponseSchema, msg.payload)
-        ]
-      });
-      return;
-    }
-    if (!msg.payload.status.ok) {
-      const retriable = 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);
-  }
-  /**
-   * Manually kills all sessions to the server (including all pending state).
-   * This is useful for when you want to close all connections to a server
-   * and don't want to wait for the grace period to elapse.
-   */
-  hardDisconnect() {
-    const sessions = Array.from(this.sessions.values());
-    for (const session of sessions) {
-      this.deleteSession(session);
-    }
-  }
-  onBackoffFinished(session) {
-    const connPromise = session.tracer.startActiveSpan(
-      "connect",
-      async (span) => {
-        try {
-          return await this.createNewOutgoingConnection(session.to);
-        } catch (err) {
-          const errStr = coerceErrorString(err);
-          span.recordException(errStr);
-          span.setStatus({ code: 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();
-  }
-};
-
-export {
-  ClientTransport
-};
-//# sourceMappingURL=chunk-A7RGOVRV.js.map

package/dist/chunk-A7RGOVRV.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../transport/client.ts","../transport/rateLimit.ts"],"sourcesContent":["import { SpanStatusCode } from '@opentelemetry/api';\nimport { ClientHandshakeOptions } from '../router/handshake';\nimport {\n  ControlMessageHandshakeResponseSchema,\n  HandshakeErrorRetriableResponseCodes,\n  OpaqueTransportMessage,\n  TransportClientId,\n  currentProtocolVersion,\n  handshakeRequestMessage,\n} from './message';\nimport {\n  ClientTransportOptions,\n  ProvidedClientTransportOptions,\n  defaultClientTransportOptions,\n} from './options';\nimport { LeakyBucketRateLimit } from './rateLimit';\nimport { Transport } from './transport';\nimport { coerceErrorString } from './stringifyError';\nimport { ProtocolError } from './events';\nimport { Value } from '@sinclair/typebox/value';\nimport { getPropagationContext } from '../tracing';\nimport { Connection } from './connection';\nimport { MessageMetadata } from '../logging';\nimport { SessionConnecting } from './sessionStateMachine/SessionConnecting';\nimport { SessionHandshaking } from './sessionStateMachine/SessionHandshaking';\nimport { SessionConnected } from './sessionStateMachine/SessionConnected';\nimport {\n  ClientSession,\n  ClientSessionStateGraph,\n} from './sessionStateMachine/transitions';\nimport { SessionState } from './sessionStateMachine/common';\nimport { SessionNoConnection } from './sessionStateMachine/SessionNoConnection';\nimport { SessionBackingOff } from './sessionStateMachine/SessionBackingOff';\n\nexport abstract class ClientTransport<\n  ConnType extends Connection,\n> extends Transport<ConnType> {\n  /**\n   * The options for this transport.\n   */\n  protected options: ClientTransportOptions;\n\n  retryBudget: LeakyBucketRateLimit;\n\n  /**\n   * A flag indicating whether the transport should automatically reconnect\n   * when a connection is dropped.\n   * Realistically, this should always be true for clients unless you are writing\n   * tests or a special case where you don't want to reconnect.\n   */\n  reconnectOnConnectionDrop = true;\n\n  /**\n   * Optional handshake options for this client.\n   */\n  handshakeExtensions?: ClientHandshakeOptions;\n\n  sessions: Map<TransportClientId, ClientSession<ConnType>>;\n\n  constructor(\n    clientId: TransportClientId,\n    providedOptions?: ProvidedClientTransportOptions,\n  ) {\n    super(clientId, providedOptions);\n    this.sessions = new Map();\n    this.options = {\n      ...defaultClientTransportOptions,\n      ...providedOptions,\n    };\n    this.retryBudget = new LeakyBucketRateLimit(this.options);\n  }\n\n  extendHandshake(options: ClientHandshakeOptions) {\n    this.handshakeExtensions = options;\n  }\n\n  /**\n   * Abstract method that creates a new {@link Connection} object.\n   *\n   * @param to The client ID of the node to connect to.\n   * @returns The new connection object.\n   */\n  protected abstract createNewOutgoingConnection(\n    to: TransportClientId,\n  ): Promise<ConnType>;\n\n  private tryReconnecting(to: TransportClientId) {\n    const oldSession = this.sessions.get(to);\n    if (!this.options.enableTransparentSessionReconnects && oldSession) {\n      this.deleteSession(oldSession);\n    }\n\n    if (this.reconnectOnConnectionDrop && this.getStatus() === 'open') {\n      this.connect(to);\n    }\n  }\n\n  /*\n   * Creates a raw unconnected session object.\n   * This is mostly a River internal, you shouldn't need to use this directly.\n   */\n  createUnconnectedSession(to: string): SessionNoConnection {\n    const session = ClientSessionStateGraph.entrypoint(\n      to,\n      this.clientId,\n      {\n        onSessionGracePeriodElapsed: () => {\n          this.onSessionGracePeriodElapsed(session);\n        },\n      },\n      this.options,\n      currentProtocolVersion,\n      this.tracer,\n      this.log,\n    );\n\n    this.createSession(session);\n\n    return session;\n  }\n\n  // listeners\n  protected onConnectingFailed(session: SessionConnecting<ConnType>) {\n    const noConnectionSession = super.onConnectingFailed(session);\n    this.tryReconnecting(noConnectionSession.to);\n\n    return noConnectionSession;\n  }\n\n  protected onConnClosed(\n    session: SessionHandshaking<ConnType> | SessionConnected<ConnType>,\n  ) {\n    const noConnectionSession = super.onConnClosed(session);\n    this.tryReconnecting(noConnectionSession.to);\n\n    return noConnectionSession;\n  }\n\n  protected onConnectionEstablished(\n    session: SessionConnecting<ConnType>,\n    conn: ConnType,\n  ): SessionHandshaking<ConnType> {\n    // transition to handshaking\n    const handshakingSession =\n      ClientSessionStateGraph.transition.ConnectingToHandshaking(\n        session,\n        conn,\n        {\n          onConnectionErrored: (err) => {\n            // just log, when we error we also emit close\n            const errStr = coerceErrorString(err);\n            this.log?.error(\n              `connection to ${handshakingSession.to} errored during handshake: ${errStr}`,\n              handshakingSession.loggingMetadata,\n            );\n          },\n          onConnectionClosed: () => {\n            this.log?.warn(\n              `connection to ${handshakingSession.to} closed during handshake`,\n              handshakingSession.loggingMetadata,\n            );\n            this.onConnClosed(handshakingSession);\n          },\n          onHandshake: (msg) => {\n            this.onHandshakeResponse(handshakingSession, msg);\n          },\n          onInvalidHandshake: (reason, code) => {\n            this.log?.error(\n              `invalid handshake: ${reason}`,\n              handshakingSession.loggingMetadata,\n            );\n            this.deleteSession(session, { unhealthy: true });\n            this.protocolError({\n              type: ProtocolError.HandshakeFailed,\n              code,\n              message: reason,\n            });\n          },\n          onHandshakeTimeout: () => {\n            this.log?.error(\n              `connection to ${handshakingSession.to} timed out during handshake`,\n              handshakingSession.loggingMetadata,\n            );\n            this.onConnClosed(handshakingSession);\n          },\n          onSessionGracePeriodElapsed: () => {\n            this.onSessionGracePeriodElapsed(handshakingSession);\n          },\n        },\n      );\n\n    this.updateSession(handshakingSession);\n    void this.sendHandshake(handshakingSession);\n\n    return handshakingSession;\n  }\n\n  private rejectHandshakeResponse(\n    session: SessionHandshaking<ConnType>,\n    reason: string,\n    metadata: MessageMetadata,\n  ) {\n    session.conn.telemetry?.span.setStatus({\n      code: SpanStatusCode.ERROR,\n      message: reason,\n    });\n\n    this.log?.warn(reason, metadata);\n    this.deleteSession(session, { unhealthy: true });\n  }\n\n  protected onHandshakeResponse(\n    session: SessionHandshaking<ConnType>,\n    msg: OpaqueTransportMessage,\n  ) {\n    // invariant: msg is a handshake response\n    if (!Value.Check(ControlMessageHandshakeResponseSchema, msg.payload)) {\n      const reason = `received invalid handshake response`;\n      this.rejectHandshakeResponse(session, reason, {\n        ...session.loggingMetadata,\n        transportMessage: msg,\n        validationErrors: [\n          ...Value.Errors(ControlMessageHandshakeResponseSchema, msg.payload),\n        ],\n      });\n\n      return;\n    }\n\n    // invariant: handshake response should be ok\n    if (!msg.payload.status.ok) {\n      const retriable = Value.Check(\n        HandshakeErrorRetriableResponseCodes,\n        msg.payload.status.code,\n      );\n\n      const reason = `handshake failed: ${msg.payload.status.reason}`;\n      const to = session.to;\n      this.rejectHandshakeResponse(session, reason, {\n        ...session.loggingMetadata,\n        transportMessage: msg,\n      });\n\n      if (retriable) {\n        this.tryReconnecting(to);\n      } else {\n        this.protocolError({\n          type: ProtocolError.HandshakeFailed,\n          code: msg.payload.status.code,\n          message: reason,\n        });\n      }\n\n      return;\n    }\n\n    // invariant: session id should match between client + server\n    if (msg.payload.status.sessionId !== session.id) {\n      const reason = `session id mismatch: expected ${session.id}, got ${msg.payload.status.sessionId}`;\n      this.rejectHandshakeResponse(session, reason, {\n        ...session.loggingMetadata,\n        transportMessage: msg,\n      });\n\n      return;\n    }\n\n    // transition to connected!\n    this.log?.info(`handshake from ${msg.from} ok`, {\n      ...session.loggingMetadata,\n      transportMessage: msg,\n    });\n\n    const connectedSession =\n      ClientSessionStateGraph.transition.HandshakingToConnected(session, {\n        onConnectionErrored: (err) => {\n          // just log, when we error we also emit close\n          const errStr = coerceErrorString(err);\n          this.log?.warn(\n            `connection to ${connectedSession.to} errored: ${errStr}`,\n            connectedSession.loggingMetadata,\n          );\n        },\n        onConnectionClosed: () => {\n          this.log?.info(\n            `connection to ${connectedSession.to} closed`,\n            connectedSession.loggingMetadata,\n          );\n          this.onConnClosed(connectedSession);\n        },\n        onMessage: (msg) => {\n          this.handleMsg(msg);\n        },\n        onInvalidMessage: (reason) => {\n          this.deleteSession(connectedSession, { unhealthy: true });\n          this.protocolError({\n            type: ProtocolError.InvalidMessage,\n            message: reason,\n          });\n        },\n      });\n\n    this.updateSession(connectedSession);\n    this.retryBudget.startRestoringBudget();\n  }\n\n  /**\n   * Manually attempts to connect to a client.\n   * @param to The client ID of the node to connect to.\n   */\n  connect(to: TransportClientId) {\n    if (this.getStatus() !== 'open') {\n      this.log?.info(\n        `transport state is no longer open, cancelling attempt to connect to ${to}`,\n      );\n\n      return;\n    }\n\n    const session = this.sessions.get(to) ?? this.createUnconnectedSession(to);\n    if (session.state !== SessionState.NoConnection) {\n      // already trying to connect\n      this.log?.debug(\n        `session to ${to} has state ${session.state}, skipping connect attempt`,\n        session.loggingMetadata,\n      );\n\n      return;\n    }\n\n    // check budget\n    if (!this.retryBudget.hasBudget()) {\n      const budgetConsumed = this.retryBudget.getBudgetConsumed();\n      const errMsg = `tried to connect to ${to} but retry budget exceeded (more than ${budgetConsumed} attempts in the last ${this.retryBudget.totalBudgetRestoreTime}ms)`;\n      this.log?.error(errMsg, session.loggingMetadata);\n      this.protocolError({\n        type: ProtocolError.RetriesExceeded,\n        message: errMsg,\n      });\n\n      return;\n    }\n\n    const backoffMs = this.retryBudget.getBackoffMs();\n\n    this.log?.info(\n      `attempting connection to ${to} (${backoffMs}ms backoff)`,\n      session.loggingMetadata,\n    );\n\n    this.retryBudget.consumeBudget();\n    const backingOffSession =\n      ClientSessionStateGraph.transition.NoConnectionToBackingOff(\n        session,\n        backoffMs,\n        {\n          onBackoffFinished: () => {\n            this.onBackoffFinished(backingOffSession);\n          },\n          onSessionGracePeriodElapsed: () => {\n            this.onSessionGracePeriodElapsed(backingOffSession);\n          },\n        },\n      );\n\n    this.updateSession(backingOffSession);\n  }\n\n  /**\n   * Manually kills all sessions to the server (including all pending state).\n   * This is useful for when you want to close all connections to a server\n   * and don't want to wait for the grace period to elapse.\n   */\n  hardDisconnect() {\n    // create a copy of the sessions to avoid modifying the map while iterating\n    const sessions = Array.from(this.sessions.values());\n    for (const session of sessions) {\n      this.deleteSession(session);\n    }\n  }\n\n  protected onBackoffFinished(session: SessionBackingOff) {\n    const connPromise = session.tracer.startActiveSpan(\n      'connect',\n      async (span) => {\n        try {\n          return await this.createNewOutgoingConnection(session.to);\n        } catch (err) {\n          // rethrow the error so that the promise is rejected\n          // as it was before we wrapped it in a span\n          const errStr = coerceErrorString(err);\n          span.recordException(errStr);\n          span.setStatus({ code: SpanStatusCode.ERROR });\n          throw err;\n        } finally {\n          span.end();\n        }\n      },\n    );\n\n    // transition to connecting\n    const connectingSession =\n      ClientSessionStateGraph.transition.BackingOffToConnecting(\n        session,\n        connPromise,\n        {\n          onConnectionEstablished: (conn) => {\n            this.log?.debug(\n              `connection to ${connectingSession.to} established`,\n              {\n                ...conn.loggingMetadata,\n                ...connectingSession.loggingMetadata,\n              },\n            );\n\n            // cast here because conn can't be narrowed to ConnType\n            // in the callback due to variance rules\n            this.onConnectionEstablished(connectingSession, conn as ConnType);\n          },\n          onConnectionFailed: (error: unknown) => {\n            const errStr = coerceErrorString(error);\n            this.log?.error(\n              `error connecting to ${connectingSession.to}: ${errStr}`,\n              connectingSession.loggingMetadata,\n            );\n            this.onConnectingFailed(connectingSession);\n          },\n          onConnectionTimeout: () => {\n            this.log?.error(\n              `connection to ${connectingSession.to} timed out`,\n              connectingSession.loggingMetadata,\n            );\n            this.onConnectingFailed(connectingSession);\n          },\n          onSessionGracePeriodElapsed: () => {\n            this.onSessionGracePeriodElapsed(connectingSession);\n          },\n        },\n      );\n\n    this.updateSession(connectingSession);\n  }\n\n  private async sendHandshake(session: SessionHandshaking<ConnType>) {\n    let metadata: unknown = undefined;\n\n    if (this.handshakeExtensions) {\n      metadata = await this.handshakeExtensions.construct();\n    }\n\n    // double-check to make sure we haven't transitioned the session yet\n    if (session._isConsumed) {\n      // bail out, don't need to do anything\n      return;\n    }\n\n    const requestMsg = handshakeRequestMessage({\n      from: this.clientId,\n      to: session.to,\n      sessionId: session.id,\n      expectedSessionState: {\n        nextExpectedSeq: session.ack,\n        nextSentSeq: session.nextSeq(),\n      },\n      metadata,\n      tracing: getPropagationContext(session.telemetry.ctx),\n    });\n\n    this.log?.debug(`sending handshake request to ${session.to}`, {\n      ...session.loggingMetadata,\n      transportMessage: requestMsg,\n    });\n\n    session.sendHandshake(requestMsg);\n  }\n\n  close() {\n    this.retryBudget.close();\n    super.close();\n  }\n}\n","/**\n * Options to control the backoff and retry behavior of the client transport's connection behaviour.\n *\n * River implements exponential backoff with jitter to prevent flooding the server\n * when there's an issue with connection establishment.\n *\n * The backoff is calculated via the following:\n *   backOff = min(jitter + {@link baseIntervalMs} * 2 ^ budget_consumed, {@link maxBackoffMs})\n *\n * We use a leaky bucket rate limit with a budget of {@link attemptBudgetCapacity} reconnection attempts.\n * Budget only starts to restore after a successful handshake at a rate of one budget per {@link budgetRestoreIntervalMs}.\n */\nexport interface ConnectionRetryOptions {\n  /**\n   * The base interval to wait before retrying a connection.\n   */\n  baseIntervalMs: number;\n\n  /**\n   * The maximum random jitter to add to the total backoff time.\n   */\n  maxJitterMs: number;\n\n  /**\n   * The maximum amount of time to wait before retrying a connection.\n   * This does not include the jitter.\n   */\n  maxBackoffMs: number;\n\n  /**\n   * The max number of times to attempt a connection before a successful handshake.\n   * This persists across connections but starts restoring budget after a successful handshake.\n   * The restoration interval depends on {@link budgetRestoreIntervalMs}\n   */\n  attemptBudgetCapacity: number;\n\n  /**\n   * After a successful connection attempt, how long to wait before we restore a single budget.\n   */\n  budgetRestoreIntervalMs: number;\n}\n\nexport class LeakyBucketRateLimit {\n  private budgetConsumed: number;\n  private intervalHandle?: ReturnType<typeof setInterval>;\n  private readonly options: ConnectionRetryOptions;\n\n  constructor(options: ConnectionRetryOptions) {\n    this.options = options;\n    this.budgetConsumed = 0;\n  }\n\n  getBackoffMs() {\n    if (this.getBudgetConsumed() === 0) {\n      return 0;\n    }\n\n    const exponent = Math.max(0, this.getBudgetConsumed() - 1);\n    const jitter = Math.floor(Math.random() * this.options.maxJitterMs);\n    const backoffMs = Math.min(\n      this.options.baseIntervalMs * 2 ** exponent,\n      this.options.maxBackoffMs,\n    );\n\n    return backoffMs + jitter;\n  }\n\n  get totalBudgetRestoreTime() {\n    return (\n      this.options.budgetRestoreIntervalMs * this.options.attemptBudgetCapacity\n    );\n  }\n\n  consumeBudget() {\n    // If we're consuming again, let's ensure that we're not leaking\n    this.stopLeak();\n    this.budgetConsumed = this.getBudgetConsumed() + 1;\n  }\n\n  getBudgetConsumed() {\n    return this.budgetConsumed;\n  }\n\n  hasBudget() {\n    return this.getBudgetConsumed() < this.options.attemptBudgetCapacity;\n  }\n\n  startRestoringBudget() {\n    if (this.intervalHandle) {\n      return;\n    }\n\n    const restoreBudgetForUser = () => {\n      const currentBudget = this.budgetConsumed;\n      if (!currentBudget) {\n        this.stopLeak();\n\n        return;\n      }\n\n      const newBudget = currentBudget - 1;\n      if (newBudget === 0) {\n        return;\n      }\n\n      this.budgetConsumed = newBudget;\n    };\n\n    this.intervalHandle = setInterval(\n      restoreBudgetForUser,\n      this.options.budgetRestoreIntervalMs,\n    );\n  }\n\n  private stopLeak() {\n    if (!this.intervalHandle) {\n      return;\n    }\n\n    clearInterval(this.intervalHandle);\n    this.intervalHandle = undefined;\n  }\n\n  close() {\n    this.stopLeak();\n  }\n}\n"],"mappings":"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","names":["msg"]}

package/dist/chunk-AJGIY2UB.js

@@ -1,56 +0,0 @@
-// 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;
-    }
-  }
-};
-
-export {
-  NaiveJsonCodec
-};
-//# sourceMappingURL=chunk-AJGIY2UB.js.map

package/dist/chunk-AJGIY2UB.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../codec/json.ts"],"sourcesContent":["import { Codec } from './types';\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\n// Convert Uint8Array to base64\nfunction uint8ArrayToBase64(uint8Array: Uint8Array) {\n  let binary = '';\n  uint8Array.forEach((byte) => {\n    binary += String.fromCharCode(byte);\n  });\n\n  return btoa(binary);\n}\n\n// Convert base64 to Uint8Array\nfunction base64ToUint8Array(base64: string) {\n  const binaryString = atob(base64);\n  const uint8Array = new Uint8Array(binaryString.length);\n  for (let i = 0; i < binaryString.length; i++) {\n    uint8Array[i] = binaryString.charCodeAt(i);\n  }\n\n  return uint8Array;\n}\n\ninterface Base64EncodedValue {\n  $t: string;\n}\n\n/**\n * Naive JSON codec implementation using JSON.stringify and JSON.parse.\n * @type {Codec}\n */\nexport const NaiveJsonCodec: Codec = {\n  toBuffer: (obj: object) => {\n    return encoder.encode(\n      JSON.stringify(obj, function replacer<\n        T extends object,\n      >(this: T, key: keyof T) {\n        const val = this[key];\n        if (val instanceof Uint8Array) {\n          return { $t: uint8ArrayToBase64(val) } satisfies Base64EncodedValue;\n        } else {\n          return val;\n        }\n      }),\n    );\n  },\n  fromBuffer: (buff: Uint8Array) => {\n    try {\n      const parsed = JSON.parse(\n        decoder.decode(buff),\n        function reviver(_key, val: unknown) {\n          if ((val as Base64EncodedValue | undefined)?.$t) {\n            return base64ToUint8Array((val as Base64EncodedValue).$t);\n          } else {\n            return val;\n          }\n        },\n      ) as unknown;\n\n      if (typeof parsed === 'object') return parsed;\n\n      return null;\n    } catch {\n      return null;\n    }\n  },\n};\n"],"mappings":";AAEA,IAAM,UAAU,IAAI,YAAY;AAChC,IAAM,UAAU,IAAI,YAAY;AAGhC,SAAS,mBAAmB,YAAwB;AAClD,MAAI,SAAS;AACb,aAAW,QAAQ,CAAC,SAAS;AAC3B,cAAU,OAAO,aAAa,IAAI;AAAA,EACpC,CAAC;AAED,SAAO,KAAK,MAAM;AACpB;AAGA,SAAS,mBAAmB,QAAgB;AAC1C,QAAM,eAAe,KAAK,MAAM;AAChC,QAAM,aAAa,IAAI,WAAW,aAAa,MAAM;AACrD,WAAS,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;AAC5C,eAAW,CAAC,IAAI,aAAa,WAAW,CAAC;AAAA,EAC3C;AAEA,SAAO;AACT;AAUO,IAAM,iBAAwB;AAAA,EACnC,UAAU,CAAC,QAAgB;AACzB,WAAO,QAAQ;AAAA,MACb,KAAK,UAAU,KAAK,SAAS,SAElB,KAAc;AACvB,cAAM,MAAM,KAAK,GAAG;AACpB,YAAI,eAAe,YAAY;AAC7B,iBAAO,EAAE,IAAI,mBAAmB,GAAG,EAAE;AAAA,QACvC,OAAO;AACL,iBAAO;AAAA,QACT;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EACA,YAAY,CAAC,SAAqB;AAChC,QAAI;AACF,YAAM,SAAS,KAAK;AAAA,QAClB,QAAQ,OAAO,IAAI;AAAA,QACnB,SAAS,QAAQ,MAAM,KAAc;AACnC,cAAK,KAAwC,IAAI;AAC/C,mBAAO,mBAAoB,IAA2B,EAAE;AAAA,UAC1D,OAAO;AACL,mBAAO;AAAA,UACT;AAAA,QACF;AAAA,MACF;AAEA,UAAI,OAAO,WAAW;AAAU,eAAO;AAEvC,aAAO;AAAA,IACT,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AACF;","names":[]}