@replit/river 0.25.2 → 0.26.1

package/dist/chunk-XRI2BXMM.js.map

@@ -0,0 +1 @@
+{"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  PartialTransportMessage,\n  TransportClientId,\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 '../util/stringify';\nimport { ProtocolError } from './events';\nimport { Value } from '@sinclair/typebox/value';\nimport tracer, { 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   * This should call {@link handleConnection} when the connection is created.\n   * The downstream client implementation needs to implement this.\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: string) {\n    if (this.reconnectOnConnectionDrop && this.getStatus() === 'open') {\n      this.connect(to);\n    }\n  }\n\n  send(to: string, msg: PartialTransportMessage): string {\n    if (this.getStatus() === 'closed') {\n      const err = 'transport is closed, cant send';\n      this.log?.error(err, {\n        clientId: this.clientId,\n        transportMessage: msg,\n        tags: ['invariant-violation'],\n      });\n\n      throw new Error(err);\n    }\n\n    let session = this.sessions.get(to);\n    if (!session) {\n      session = this.createUnconnectedSession(to);\n    }\n\n    return session.send(msg);\n  }\n\n  private 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      this.log,\n    );\n\n    this.updateSession(session);\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    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    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);\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        },\n      );\n\n    this.updateSession(handshakingSession);\n    void this.sendHandshake(handshakingSession);\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);\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      return;\n    }\n\n    // invariant: handshake response should be ok\n    if (!msg.payload.status.ok) {\n      // TODO: remove conditional check after we know code is always present\n      const retriable = msg.payload.status.code\n        ? Value.Check(\n            HandshakeErrorRetriableResponseCodes,\n            msg.payload.status.code,\n          )\n        : false;\n\n      const reason = `handshake failed: ${msg.payload.status.reason}`;\n      this.rejectHandshakeResponse(session, reason, {\n        ...session.loggingMetadata,\n        transportMessage: msg,\n      });\n\n      if (retriable) {\n        this.tryReconnecting(session.to);\n      } else {\n        this.deleteSession(session);\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      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) => this.handleMsg(msg),\n        onInvalidMessage: (reason) => {\n          this.deleteSession(connectedSession);\n          this.protocolError({\n            type: ProtocolError.MessageOrderingViolated,\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    // create a new session if one does not exist\n    let session = this.sessions.get(to);\n    session ??= this.createUnconnectedSession(to);\n\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      return;\n    }\n\n    if (this.getStatus() !== 'open') {\n      this.log?.info(\n        `transport state is no longer open, cancelling attempt to connect to ${to}`,\n        session.loggingMetadata,\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      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            const reconnectPromise = tracer.startActiveSpan(\n              'connect',\n              async (span) => {\n                try {\n                  return await this.createNewOutgoingConnection(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            this.onBackoffFinished(backingOffSession, reconnectPromise);\n          },\n        },\n      );\n\n    this.updateSession(backingOffSession);\n  }\n\n  protected onBackoffFinished(\n    session: SessionBackingOff,\n    connPromise: Promise<ConnType>,\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              connectingSession.loggingMetadata,\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        },\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    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        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/{client-edc8e2de.d.ts → client-0f636b3a.d.ts}

@@ -1,5 +1,5 @@
-import { C as Connection, T as Transport, n as ClientTransportOptions, L as LeakyBucketRateLimit, p as ClientHandshakeOptions, q as ClientSession, b as ProvidedClientTransportOptions, f as SessionConnecting, e as SessionNoConnection, g as SessionHandshaking, h as SessionConnected, r as SessionBackingOff } from './handshake-12d57161.js';
-import { c as TransportClientId, P as PartialTransportMessage, b as OpaqueTransportMessage } from './message-e6c560fd.js';
+import { C as Connection, T as Transport, n as ClientTransportOptions, L as LeakyBucketRateLimit, p as ClientHandshakeOptions, q as ClientSession, b as ProvidedClientTransportOptions, f as SessionConnecting, e as SessionNoConnection, g as SessionHandshaking, h as SessionConnected, r as SessionBackingOff } from './handshake-8752f79e.js';
+import { c as TransportClientId, P as PartialTransportMessage, b as OpaqueTransportMessage } from './message-57296605.js';
 
 declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {
     /**

package/dist/{connection-ef50ac3a.d.ts → connection-07e97a79.d.ts}

@@ -1,4 +1,4 @@
-import { C as Connection } from './handshake-12d57161.js';
+import { C as Connection } from './handshake-8752f79e.js';
 import { W as WsLike } from './wslike-e0b32dd5.js';
 
 declare class WebSocketConnection extends Connection {

package/dist/{handshake-12d57161.d.ts → handshake-8752f79e.d.ts}

@@ -1,5 +1,5 @@
-import { e as TelemetryInfo, M as MessageMetadata, c as TransportClientId, L as Logger, b as OpaqueTransportMessage, P as PartialTransportMessage, a as TransportMessage, f as LogFn, g as LoggingLevel } from './message-e6c560fd.js';
-import { TSchema, Static } from '@sinclair/typebox';
+import { e as TelemetryInfo, M as MessageMetadata, c as TransportClientId, L as Logger, b as OpaqueTransportMessage, P as PartialTransportMessage, a as TransportMessage, H as HandshakeErrorResponseCodes, f as LogFn, g as LoggingLevel, h as HandshakeErrorCustomHandlerFatalResponseCodes } from './message-57296605.js';
+import { Static, TSchema } from '@sinclair/typebox';
 import { C as Codec } from './types-3e5768ec.js';
 
 /**
@@ -148,7 +148,7 @@ interface SessionHandshakingListeners {
     onConnectionErrored: (err: unknown) => void;
     onConnectionClosed: () => void;
     onHandshake: (msg: OpaqueTransportMessage) => void;
-    onInvalidHandshake: (reason: string) => void;
+    onInvalidHandshake: (reason: string, code: Static<typeof HandshakeErrorResponseCodes>) => void;
     onHandshakeTimeout: () => void;
 }
 interface SessionHandshakingProps<ConnType extends Connection> extends IdentifiedSessionProps {
@@ -273,7 +273,11 @@ interface EventMap {
         state: SessionState.NoConnection;
     };
     protocolError: {
-        type: ProtocolErrorType;
+        type: (typeof ProtocolError)['HandshakeFailed'];
+        code: Static<typeof HandshakeErrorResponseCodes>;
+        message: string;
+    } | {
+        type: Omit<ProtocolErrorType, (typeof ProtocolError)['HandshakeFailed']>;
         message: string;
     };
     transportStatus: {
@@ -428,7 +432,7 @@ declare abstract class Transport<ConnType extends Connection> {
      * @returns The ID of the sent message or undefined if it wasn't sent
      */
     abstract send(to: TransportClientId, msg: PartialTransportMessage): string;
-    protected protocolError(type: ProtocolErrorType, message: string): void;
+    protected protocolError(message: EventMap['protocolError']): void;
     /**
      * 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.
@@ -499,7 +503,7 @@ type ServiceContextWithTransportInfo<State> = ServiceContext & {
 };
 
 type ConstructHandshake<T extends TSchema> = () => Static<T> | Promise<Static<T>>;
-type ValidateHandshake<T extends TSchema> = (metadata: Static<T>, previousParsedMetadata?: ParsedMetadata) => false | ParsedMetadata | Promise<false | ParsedMetadata>;
+type ValidateHandshake<T extends TSchema> = (metadata: Static<T>, previousParsedMetadata?: ParsedMetadata) => Static<typeof HandshakeErrorCustomHandlerFatalResponseCodes> | ParsedMetadata | Promise<Static<typeof HandshakeErrorCustomHandlerFatalResponseCodes> | ParsedMetadata>;
 interface ClientHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
     /**
      * Schema for the metadata that the client sends to the server

package/dist/logging/index.d.cts

@@ -1,4 +1,4 @@
-export { f as LogFn, L as Logger, M as MessageMetadata, h as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../message-e6c560fd.js';
+export { f as LogFn, L as Logger, M as MessageMetadata, j as coloredStringLogger, k as jsonLogger, s as stringLogger } from '../message-57296605.js';
 import '@sinclair/typebox/value';
 import '@sinclair/typebox';
 import '@opentelemetry/api';

package/dist/logging/index.d.ts

@@ -1,4 +1,4 @@
-export { f as LogFn, L as Logger, M as MessageMetadata, h as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../message-e6c560fd.js';
+export { f as LogFn, L as Logger, M as MessageMetadata, j as coloredStringLogger, k as jsonLogger, s as stringLogger } from '../message-57296605.js';
 import '@sinclair/typebox/value';
 import '@sinclair/typebox';
 import '@opentelemetry/api';

package/dist/{message-e6c560fd.d.ts → message-57296605.d.ts}

@@ -64,6 +64,8 @@ declare const TransportMessageSchema: <T extends TSchema>(t: T) => _sinclair_typ
     }>>;
     payload: T;
 }>;
+declare const HandshakeErrorCustomHandlerFatalResponseCodes: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"REJECTED_UNSUPPORTED_CLIENT">, _sinclair_typebox.TLiteral<"REJECTED_BY_CUSTOM_HANDLER">]>;
+declare const HandshakeErrorResponseCodes: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"SESSION_STATE_MISMATCH">, _sinclair_typebox.TUnion<[_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"REJECTED_UNSUPPORTED_CLIENT">, _sinclair_typebox.TLiteral<"REJECTED_BY_CUSTOM_HANDLER">]>, _sinclair_typebox.TLiteral<"MALFORMED_HANDSHAKE_META">, _sinclair_typebox.TLiteral<"MALFORMED_HANDSHAKE">, _sinclair_typebox.TLiteral<"PROTOCOL_VERSION_MISMATCH">]>]>;
 /**
  * Defines the schema for an opaque transport message that is agnostic to any
  * procedure/service.
@@ -133,4 +135,4 @@ declare function isStreamOpen(controlFlag: number): boolean;
  */
 declare function isStreamClose(controlFlag: number): boolean;
 
-export { Logger as L, MessageMetadata as M, OpaqueTransportMessageSchema as O, PartialTransportMessage as P, TransportMessageSchema as T, TransportMessage as a, OpaqueTransportMessage as b, TransportClientId as c, isStreamClose as d, TelemetryInfo as e, LogFn as f, LoggingLevel as g, coloredStringLogger as h, isStreamOpen as i, jsonLogger as j, stringLogger as s };
+export { HandshakeErrorResponseCodes as H, Logger as L, MessageMetadata as M, OpaqueTransportMessageSchema as O, PartialTransportMessage as P, TransportMessageSchema as T, TransportMessage as a, OpaqueTransportMessage as b, TransportClientId as c, isStreamClose as d, TelemetryInfo as e, LogFn as f, LoggingLevel as g, HandshakeErrorCustomHandlerFatalResponseCodes as h, isStreamOpen as i, coloredStringLogger as j, jsonLogger as k, stringLogger as s };

package/dist/router/index.cjs

@@ -667,11 +667,20 @@ var ControlMessageHandshakeRequestSchema = import_typebox3.Type.Object({
 var HandshakeErrorRetriableResponseCodes = import_typebox3.Type.Union([
   import_typebox3.Type.Literal("SESSION_STATE_MISMATCH")
 ]);
+var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox3.Type.Union([
+  // The custom validation handler rejected the handler because the client is unsupported.
+  import_typebox3.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
+  // The custom validation handler rejected the handshake.
+  import_typebox3.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
+]);
 var HandshakeErrorFatalResponseCodes = import_typebox3.Type.Union([
+  HandshakeErrorCustomHandlerFatalResponseCodes,
+  // The ciient sent a handshake that doesn't comply with the extended handshake metadata.
   import_typebox3.Type.Literal("MALFORMED_HANDSHAKE_META"),
+  // The ciient sent a handshake that doesn't comply with ControlMessageHandshakeRequestSchema.
   import_typebox3.Type.Literal("MALFORMED_HANDSHAKE"),
-  import_typebox3.Type.Literal("PROTOCOL_VERSION_MISMATCH"),
-  import_typebox3.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
+  // The client's protocol version does not match the server's.
+  import_typebox3.Type.Literal("PROTOCOL_VERSION_MISMATCH")
 ]);
 var HandshakeErrorResponseCodes = import_typebox3.Type.Union([
   HandshakeErrorRetriableResponseCodes,
@@ -752,7 +761,7 @@ function Err(error) {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.25.2";
+var version = "0.26.1";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {