@replit/river 0.208.0 → 0.208.1

package/dist/router/index.d.cts

@@ -1,11 +1,11 @@
-import { A as AnyServiceSchemaMap, b as Connection, S as ServerHandshakeOptions, c as ServiceContext, d as ProcedureHandlerContext, e as PayloadType, I as InstantiatedServiceSchemaMap, f as ParsedMetadata, g as AnyProcedure } from '../transport-CCaWx1Rb.cjs';
-export { N as BaseErrorSchemaType, L as CANCEL_CODE, Q as Client, X as Err, Z as ErrResult, K as INVALID_REQUEST_CODE, T as Ok, _ as OkResult, n as ProcErrors, j as ProcHandler, k as ProcInit, l as ProcRequest, m as ProcResponse, o as ProcType, E as Procedure, F as ProcedureErrorSchemaType, y as ProcedureMap, R as RPCProcedure, D as Readable, M as ReaderErrorSchema, a1 as ResponseData, Y as Result, a0 as ResultUnwrapErr, $ as ResultUnwrapOk, t as SerializedProcedureSchema, x as SerializedProcedureSchemaProtocolv1, q as SerializedServerSchema, v as SerializedServerSchemaProtocolv1, r as SerializedServiceSchema, w as SerializedServiceSchemaProtocolv1, h as Service, i as ServiceConfiguration, p as ServiceSchema, B as StreamProcedure, z as SubscriptionProcedure, H as UNCAUGHT_ERROR_CODE, J as UNEXPECTED_DISCONNECT_CODE, U as UploadProcedure, V as ValidProcType, W as Writable, O as createClient, a2 as createClientHandshakeOptions, a3 as createServerHandshakeOptions, G as flattenErrorType, s as serializeSchema, u as serializeSchemaV1Compat } from '../transport-CCaWx1Rb.cjs';
+import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, c as ParsedMetadata, d as AnyProcedure, e as ProcedureHandlerContext, f as PayloadType, b as Connection, S as ServerHandshakeOptions, g as ServiceContext } from '../services-44be1b6b.js';
+export { N as BaseErrorSchemaType, L as CANCEL_CODE, Q as Client, X as Err, Z as ErrResult, K as INVALID_REQUEST_CODE, T as Ok, _ as OkResult, n as ProcErrors, j as ProcHandler, k as ProcInit, l as ProcRequest, m as ProcResponse, o as ProcType, E as Procedure, F as ProcedureErrorSchemaType, y as ProcedureMap, R as RPCProcedure, D as Readable, M as ReaderErrorSchema, a1 as ResponseData, Y as Result, a0 as ResultUnwrapErr, $ as ResultUnwrapOk, t as SerializedProcedureSchema, x as SerializedProcedureSchemaProtocolv1, q as SerializedServerSchema, v as SerializedServerSchemaProtocolv1, r as SerializedServiceSchema, w as SerializedServiceSchemaProtocolv1, h as Service, i as ServiceConfiguration, p as ServiceSchema, B as StreamProcedure, z as SubscriptionProcedure, H as UNCAUGHT_ERROR_CODE, J as UNEXPECTED_DISCONNECT_CODE, U as UploadProcedure, V as ValidProcType, W as Writable, O as createClient, a2 as createClientHandshakeOptions, a3 as createServerHandshakeOptions, G as flattenErrorType, s as serializeSchema, u as serializeSchemaV1Compat } from '../services-44be1b6b.js';
 import { Static } from '@sinclair/typebox';
-import { T as TransportClientId, O as OpaqueTransportMessage } from '../message-Di94OL80.cjs';
+import { T as TransportClientId, O as OpaqueTransportMessage } from '../message-01c3e85a.js';
 import { ServerTransport } from '../transport/index.cjs';
 import '@opentelemetry/api';
-import '../index-C9tpZjBN.cjs';
-import '../adapter-Cuc4JtfV.cjs';
+import '../index-02554794.js';
+import '../adapter-f2b6e211.js';
 
 type StreamId = string;
 /**
@@ -71,6 +71,6 @@ declare function createServer<Services extends AnyServiceSchemaMap>(transport: S
     middlewares?: Array<Middleware>;
 }>): Server<Services>;
 
-var version = "0.208.0";
+var version = "0.208.1";
 
-export { type Middleware, type MiddlewareContext, type MiddlewareParam, ParsedMetadata, PayloadType, ProcedureHandlerContext, version as RIVER_VERSION, type Server, ServiceContext, createServer };
+export { Middleware, MiddlewareContext, MiddlewareParam, ParsedMetadata, PayloadType, ProcedureHandlerContext, version as RIVER_VERSION, Server, ServiceContext, createServer };

package/dist/router/index.d.ts

@@ -1,11 +1,11 @@
-import { A as AnyServiceSchemaMap, b as Connection, S as ServerHandshakeOptions, c as ServiceContext, d as ProcedureHandlerContext, e as PayloadType, I as InstantiatedServiceSchemaMap, f as ParsedMetadata, g as AnyProcedure } from '../transport-CZb3vdB4.js';
-export { N as BaseErrorSchemaType, L as CANCEL_CODE, Q as Client, X as Err, Z as ErrResult, K as INVALID_REQUEST_CODE, T as Ok, _ as OkResult, n as ProcErrors, j as ProcHandler, k as ProcInit, l as ProcRequest, m as ProcResponse, o as ProcType, E as Procedure, F as ProcedureErrorSchemaType, y as ProcedureMap, R as RPCProcedure, D as Readable, M as ReaderErrorSchema, a1 as ResponseData, Y as Result, a0 as ResultUnwrapErr, $ as ResultUnwrapOk, t as SerializedProcedureSchema, x as SerializedProcedureSchemaProtocolv1, q as SerializedServerSchema, v as SerializedServerSchemaProtocolv1, r as SerializedServiceSchema, w as SerializedServiceSchemaProtocolv1, h as Service, i as ServiceConfiguration, p as ServiceSchema, B as StreamProcedure, z as SubscriptionProcedure, H as UNCAUGHT_ERROR_CODE, J as UNEXPECTED_DISCONNECT_CODE, U as UploadProcedure, V as ValidProcType, W as Writable, O as createClient, a2 as createClientHandshakeOptions, a3 as createServerHandshakeOptions, G as flattenErrorType, s as serializeSchema, u as serializeSchemaV1Compat } from '../transport-CZb3vdB4.js';
+import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, c as ParsedMetadata, d as AnyProcedure, e as ProcedureHandlerContext, f as PayloadType, b as Connection, S as ServerHandshakeOptions, g as ServiceContext } from '../services-44be1b6b.js';
+export { N as BaseErrorSchemaType, L as CANCEL_CODE, Q as Client, X as Err, Z as ErrResult, K as INVALID_REQUEST_CODE, T as Ok, _ as OkResult, n as ProcErrors, j as ProcHandler, k as ProcInit, l as ProcRequest, m as ProcResponse, o as ProcType, E as Procedure, F as ProcedureErrorSchemaType, y as ProcedureMap, R as RPCProcedure, D as Readable, M as ReaderErrorSchema, a1 as ResponseData, Y as Result, a0 as ResultUnwrapErr, $ as ResultUnwrapOk, t as SerializedProcedureSchema, x as SerializedProcedureSchemaProtocolv1, q as SerializedServerSchema, v as SerializedServerSchemaProtocolv1, r as SerializedServiceSchema, w as SerializedServiceSchemaProtocolv1, h as Service, i as ServiceConfiguration, p as ServiceSchema, B as StreamProcedure, z as SubscriptionProcedure, H as UNCAUGHT_ERROR_CODE, J as UNEXPECTED_DISCONNECT_CODE, U as UploadProcedure, V as ValidProcType, W as Writable, O as createClient, a2 as createClientHandshakeOptions, a3 as createServerHandshakeOptions, G as flattenErrorType, s as serializeSchema, u as serializeSchemaV1Compat } from '../services-44be1b6b.js';
 import { Static } from '@sinclair/typebox';
-import { T as TransportClientId, O as OpaqueTransportMessage } from '../message-Di94OL80.js';
+import { T as TransportClientId, O as OpaqueTransportMessage } from '../message-01c3e85a.js';
 import { ServerTransport } from '../transport/index.js';
 import '@opentelemetry/api';
-import '../index-D8IOd3LG.js';
-import '../adapter-ChksXKVN.js';
+import '../index-02554794.js';
+import '../adapter-f2b6e211.js';
 
 type StreamId = string;
 /**
@@ -71,6 +71,6 @@ declare function createServer<Services extends AnyServiceSchemaMap>(transport: S
     middlewares?: Array<Middleware>;
 }>): Server<Services>;
 
-var version = "0.208.0";
+var version = "0.208.1";
 
-export { type Middleware, type MiddlewareContext, type MiddlewareParam, ParsedMetadata, PayloadType, ProcedureHandlerContext, version as RIVER_VERSION, type Server, ServiceContext, createServer };
+export { Middleware, MiddlewareContext, MiddlewareParam, ParsedMetadata, PayloadType, ProcedureHandlerContext, version as RIVER_VERSION, Server, ServiceContext, createServer };

package/dist/router/index.js

@@ -16,7 +16,7 @@ import {
   serializeSchema,
   serializeSchemaV1Compat,
   version
-} from "../chunk-ETZAHFGQ.js";
+} from "../chunk-EVAQ2QMB.js";
 export {
   CANCEL_CODE,
   Err,

package/dist/{transport-CZb3vdB4.d.ts → services-44be1b6b.d.ts}

@@ -1,9 +1,9 @@
 import * as _sinclair_typebox from '@sinclair/typebox';
-import { TSchema, Static, TNever, TObject, TLiteral, TString, TUnion } from '@sinclair/typebox';
+import { Static, TSchema, TObject, TString, TUnion, TLiteral, TNever } from '@sinclair/typebox';
 import { Tracer, Span } from '@opentelemetry/api';
-import { b as TelemetryInfo, T as TransportClientId, P as ProtocolVersion, O as OpaqueTransportMessage, a as PartialTransportMessage, c as TransportMessage, H as HandshakeErrorCustomHandlerFatalResponseCodes, d as HandshakeErrorResponseCodes } from './message-Di94OL80.js';
-import { M as MessageMetadata, L as Logger, T as Tags, a as LogFn, b as LoggingLevel } from './index-D8IOd3LG.js';
-import { C as Codec, a as CodecMessageAdapter, S as SendResult, b as SendBufferResult } from './adapter-ChksXKVN.js';
+import { b as TelemetryInfo, T as TransportClientId, P as ProtocolVersion, O as OpaqueTransportMessage, a as PartialTransportMessage, c as TransportMessage, H as HandshakeErrorResponseCodes, d as HandshakeErrorCustomHandlerFatalResponseCodes } from './message-01c3e85a.js';
+import { M as MessageMetadata, L as Logger, T as Tags, a as LogFn, b as LoggingLevel } from './index-02554794.js';
+import { C as Codec, a as CodecMessageAdapter, S as SendResult, b as SendBufferResult } from './adapter-f2b6e211.js';
 
 /**
  * A connection is the actual raw underlying transport connection.
@@ -188,100 +188,6 @@ declare abstract class IdentifiedSessionWithGracePeriod extends IdentifiedSessio
     _handleClose(): void;
 }
 
-type ConstructHandshake<T extends TSchema> = () => Static<T> | Promise<Static<T>>;
-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
-     * during the handshake.
-     */
-    schema: MetadataSchema;
-    /**
-     * Gets the {@link HandshakeRequestMetadata} to send to the server.
-     */
-    construct: ConstructHandshake<MetadataSchema>;
-}
-interface ServerHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
-    /**
-     * Schema for the metadata that the server receives from the client
-     * during the handshake.
-     */
-    schema: MetadataSchema;
-    /**
-     * Parses the {@link HandshakeRequestMetadata} sent by the client, transforming
-     * it into {@link ParsedHandshakeMetadata}.
-     *
-     * May return `false` if the client should be rejected.
-     *
-     * @param metadata - The metadata sent by the client.
-     * @param session - The session that the client would be associated with.
-     * @param isReconnect - Whether the client is reconnecting to the session,
-     *                      or if this is a new session.
-     */
-    validate: ValidateHandshake<MetadataSchema>;
-}
-declare function createClientHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, construct: ConstructHandshake<MetadataSchema>): ClientHandshakeOptions;
-declare function createServerHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, validate: ValidateHandshake<MetadataSchema>): ServerHandshakeOptions;
-
-/**
- * Options to control the backoff and retry behavior of the client transport's connection behaviour.
- *
- * River implements exponential backoff with jitter to prevent flooding the server
- * when there's an issue with connection establishment.
- *
- * The backoff is calculated via the following:
- *   backOff = min(jitter + {@link baseIntervalMs} * 2 ^ budget_consumed, {@link maxBackoffMs})
- *
- * We use a leaky bucket rate limit with a budget of {@link attemptBudgetCapacity} reconnection attempts.
- * Budget only starts to restore after a successful handshake at a rate of one budget per {@link budgetRestoreIntervalMs}.
- */
-interface ConnectionRetryOptions {
-    /**
-     * The base interval to wait before retrying a connection.
-     */
-    baseIntervalMs: number;
-    /**
-     * The maximum random jitter to add to the total backoff time.
-     */
-    maxJitterMs: number;
-    /**
-     * The maximum amount of time to wait before retrying a connection.
-     * This does not include the jitter.
-     */
-    maxBackoffMs: number;
-    /**
-     * The max number of times to attempt a connection before a successful handshake.
-     * This persists across connections but starts restoring budget after a successful handshake.
-     * The restoration interval depends on {@link budgetRestoreIntervalMs}
-     */
-    attemptBudgetCapacity: number;
-    /**
-     * After a successful connection attempt, how long to wait before we restore a single budget.
-     */
-    budgetRestoreIntervalMs: number;
-}
-declare class LeakyBucketRateLimit {
-    private budgetConsumed;
-    private intervalHandle?;
-    private readonly options;
-    constructor(options: ConnectionRetryOptions);
-    getBackoffMs(): number;
-    get totalBudgetRestoreTime(): number;
-    consumeBudget(): void;
-    getBudgetConsumed(): number;
-    hasBudget(): boolean;
-    startRestoringBudget(): void;
-    private stopLeak;
-    close(): void;
-}
-
-type TransportOptions = SessionOptions;
-type ProvidedTransportOptions = Partial<TransportOptions>;
-type ClientTransportOptions = TransportOptions & ConnectionRetryOptions;
-type ProvidedClientTransportOptions = Partial<ClientTransportOptions>;
-type ServerTransportOptions = TransportOptions;
-type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
-
 interface SessionConnectingListeners extends IdentifiedSessionWithGracePeriodListeners {
     onConnectionEstablished: (conn: Connection) => void;
     onConnectionFailed: (err: unknown) => void;
@@ -302,6 +208,12 @@ declare class SessionConnecting<ConnType extends Connection> extends IdentifiedS
     _handleClose(): void;
 }
 
+declare class SessionNoConnection extends IdentifiedSessionWithGracePeriod {
+    readonly state: SessionState.NoConnection;
+    _handleClose(): void;
+    _handleStateExit(): void;
+}
+
 interface SessionHandshakingListeners extends IdentifiedSessionWithGracePeriodListeners {
     onConnectionErrored: (err: unknown) => void;
     onConnectionClosed: () => void;
@@ -392,31 +304,276 @@ declare class SessionConnected<ConnType extends Connection> extends IdentifiedSe
     _handleClose(): void;
 }
 
-declare class SessionNoConnection extends IdentifiedSessionWithGracePeriod {
-    readonly state: SessionState.NoConnection;
+interface SessionBackingOffListeners extends IdentifiedSessionWithGracePeriodListeners {
+    onBackoffFinished: () => void;
+}
+interface SessionBackingOffProps extends IdentifiedSessionWithGracePeriodProps {
+    backoffMs: number;
+    listeners: SessionBackingOffListeners;
+}
+declare class SessionBackingOff extends IdentifiedSessionWithGracePeriod {
+    readonly state: SessionState.BackingOff;
+    listeners: SessionBackingOffListeners;
+    backoffTimeout?: ReturnType<typeof setTimeout>;
+    constructor(props: SessionBackingOffProps);
     _handleClose(): void;
     _handleStateExit(): void;
 }
 
-interface SessionBackingOffListeners extends IdentifiedSessionWithGracePeriodListeners {
-    onBackoffFinished: () => void;
-}
-interface SessionBackingOffProps extends IdentifiedSessionWithGracePeriodProps {
-    backoffMs: number;
-    listeners: SessionBackingOffListeners;
+type ClientSession<ConnType extends Connection> = SessionNoConnection | SessionBackingOff | SessionConnecting<ConnType> | SessionHandshaking<ConnType> | SessionConnected<ConnType>;
+type ServerSession<ConnType extends Connection> = SessionConnected<ConnType> | SessionNoConnection;
+type Session<ConnType extends Connection> = ClientSession<ConnType> | ServerSession<ConnType>;
+
+declare const ProtocolError: {
+    readonly RetriesExceeded: "conn_retry_exceeded";
+    readonly HandshakeFailed: "handshake_failed";
+    readonly MessageOrderingViolated: "message_ordering_violated";
+    readonly InvalidMessage: "invalid_message";
+    readonly MessageSendFailure: "message_send_failure";
+};
+type ProtocolErrorType = (typeof ProtocolError)[keyof typeof ProtocolError];
+interface EventMap {
+    message: OpaqueTransportMessage;
+    sessionStatus: {
+        status: 'created' | 'closing';
+        session: Session<Connection>;
+    } | {
+        status: 'closed';
+        session: Pick<Session<Connection>, 'id' | 'to'>;
+    };
+    sessionTransition: {
+        state: SessionState.Connected;
+        id: SessionId;
+    } | {
+        state: SessionState.Handshaking;
+        id: SessionId;
+    } | {
+        state: SessionState.Connecting;
+        id: SessionId;
+    } | {
+        state: SessionState.BackingOff;
+        id: SessionId;
+    } | {
+        state: SessionState.NoConnection;
+        id: SessionId;
+    };
+    protocolError: {
+        type: (typeof ProtocolError)['HandshakeFailed'];
+        code: Static<typeof HandshakeErrorResponseCodes>;
+        message: string;
+    } | {
+        type: Omit<ProtocolErrorType, (typeof ProtocolError)['HandshakeFailed']>;
+        message: string;
+    };
+    transportStatus: {
+        status: TransportStatus;
+    };
+}
+type EventTypes = keyof EventMap;
+type EventHandler<K extends EventTypes> = (event: EventMap[K]) => unknown;
+declare class EventDispatcher<T extends EventTypes> {
+    private eventListeners;
+    removeAllListeners(): void;
+    numberOfListeners<K extends T>(eventType: K): number;
+    addEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
+    removeEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
+    dispatchEvent<K extends T>(eventType: K, event: EventMap[K]): void;
+}
+
+/**
+ * Options to control the backoff and retry behavior of the client transport's connection behaviour.
+ *
+ * River implements exponential backoff with jitter to prevent flooding the server
+ * when there's an issue with connection establishment.
+ *
+ * The backoff is calculated via the following:
+ *   backOff = min(jitter + {@link baseIntervalMs} * 2 ^ budget_consumed, {@link maxBackoffMs})
+ *
+ * We use a leaky bucket rate limit with a budget of {@link attemptBudgetCapacity} reconnection attempts.
+ * Budget only starts to restore after a successful handshake at a rate of one budget per {@link budgetRestoreIntervalMs}.
+ */
+interface ConnectionRetryOptions {
+    /**
+     * The base interval to wait before retrying a connection.
+     */
+    baseIntervalMs: number;
+    /**
+     * The maximum random jitter to add to the total backoff time.
+     */
+    maxJitterMs: number;
+    /**
+     * The maximum amount of time to wait before retrying a connection.
+     * This does not include the jitter.
+     */
+    maxBackoffMs: number;
+    /**
+     * The max number of times to attempt a connection before a successful handshake.
+     * This persists across connections but starts restoring budget after a successful handshake.
+     * The restoration interval depends on {@link budgetRestoreIntervalMs}
+     */
+    attemptBudgetCapacity: number;
+    /**
+     * After a successful connection attempt, how long to wait before we restore a single budget.
+     */
+    budgetRestoreIntervalMs: number;
+}
+declare class LeakyBucketRateLimit {
+    private budgetConsumed;
+    private intervalHandle?;
+    private readonly options;
+    constructor(options: ConnectionRetryOptions);
+    getBackoffMs(): number;
+    get totalBudgetRestoreTime(): number;
+    consumeBudget(): void;
+    getBudgetConsumed(): number;
+    hasBudget(): boolean;
+    startRestoringBudget(): void;
+    private stopLeak;
+    close(): void;
+}
+
+type TransportOptions = SessionOptions;
+type ProvidedTransportOptions = Partial<TransportOptions>;
+type ClientTransportOptions = TransportOptions & ConnectionRetryOptions;
+type ProvidedClientTransportOptions = Partial<ClientTransportOptions>;
+type ServerTransportOptions = TransportOptions;
+type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
+
+/**
+ * Represents the possible states of a transport.
+ * @property {'open'} open - The transport is open and operational (note that this doesn't mean it is actively connected)
+ * @property {'closed'} closed - The transport is permanently closed and cannot be reopened.
+ */
+type TransportStatus = 'open' | 'closed';
+interface DeleteSessionOptions {
+    unhealthy: boolean;
+}
+type SessionBoundSendFn = (msg: PartialTransportMessage) => string;
+/**
+ * Transports manage the lifecycle (creation/deletion) of sessions
+ *
+ * ```plaintext
+ *            ▲
+ *  incoming  │
+ *  messages  │
+ *            ▼
+ *      ┌─────────────┐   1:N   ┌───────────┐   1:1*  ┌────────────┐
+ *      │  Transport  │ ◄─────► │  Session  │ ◄─────► │ Connection │
+ *      └─────────────┘         └───────────┘         └────────────┘
+ *            ▲                               * (may or may not be initialized yet)
+ *            │
+ *            ▼
+ *      ┌───────────┐
+ *      │ Message   │
+ *      │ Listeners │
+ *      └───────────┘
+ * ```
+ * @abstract
+ */
+declare abstract class Transport<ConnType extends Connection> {
+    /**
+     * The status of the transport.
+     */
+    private status;
+    /**
+     * The client ID of this transport.
+     */
+    clientId: TransportClientId;
+    /**
+     * The event dispatcher for handling events of type EventTypes.
+     */
+    eventDispatcher: EventDispatcher<EventTypes>;
+    /**
+     * The options for this transport.
+     */
+    protected options: TransportOptions;
+    log?: Logger;
+    tracer: Tracer;
+    sessions: Map<TransportClientId, Session<ConnType>>;
+    /**
+     * Creates a new Transport instance.
+     * @param codec The codec used to encode and decode messages.
+     * @param clientId The client ID of this transport.
+     */
+    constructor(clientId: TransportClientId, providedOptions?: ProvidedTransportOptions);
+    bindLogger(fn: LogFn | Logger, level?: LoggingLevel): void;
+    /**
+     * Called when a message is received by this transport.
+     * You generally shouldn't need to override this in downstream transport implementations.
+     * @param message The received message.
+     */
+    protected handleMsg(message: OpaqueTransportMessage): void;
+    /**
+     * Adds a listener to this transport.
+     * @param the type of event to listen for
+     * @param handler The message handler to add.
+     */
+    addEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
+    /**
+     * Removes a listener from this transport.
+     * @param the type of event to un-listen on
+     * @param handler The message handler to remove.
+     */
+    removeEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): 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.
+     * Closes the transport. Any messages sent while the transport is closed will be silently discarded.
+     */
+    close(): void;
+    getStatus(): TransportStatus;
+    protected createSession<S extends Session<ConnType>>(session: S): void;
+    protected updateSession<S extends Session<ConnType>>(session: S): void;
+    protected deleteSession(session: Session<ConnType>, options?: DeleteSessionOptions): void;
+    protected onSessionGracePeriodElapsed(session: Session<ConnType>): void;
+    protected onConnectingFailed(session: SessionConnecting<ConnType>): SessionNoConnection;
+    protected onConnClosed(session: SessionHandshaking<ConnType> | SessionConnected<ConnType>): SessionNoConnection;
+    /**
+     * Gets a send closure scoped to a specific session. Sending using the returned
+     * closure after the session has transitioned to a different state will be a noop.
+     *
+     * Session objects themselves can become stale as they transition between
+     * states. As stale sessions cannot be used again (and will throw), holding
+     * onto a session object is not recommended.
+     */
+    getSessionBoundSendFn(to: TransportClientId, sessionId: SessionId): SessionBoundSendFn;
+}
+
+type ConstructHandshake<T extends TSchema> = () => Static<T> | Promise<Static<T>>;
+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
+     * during the handshake.
+     */
+    schema: MetadataSchema;
+    /**
+     * Gets the {@link HandshakeRequestMetadata} to send to the server.
+     */
+    construct: ConstructHandshake<MetadataSchema>;
 }
-declare class SessionBackingOff extends IdentifiedSessionWithGracePeriod {
-    readonly state: SessionState.BackingOff;
-    listeners: SessionBackingOffListeners;
-    backoffTimeout?: ReturnType<typeof setTimeout>;
-    constructor(props: SessionBackingOffProps);
-    _handleClose(): void;
-    _handleStateExit(): void;
+interface ServerHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
+    /**
+     * Schema for the metadata that the server receives from the client
+     * during the handshake.
+     */
+    schema: MetadataSchema;
+    /**
+     * Parses the {@link HandshakeRequestMetadata} sent by the client, transforming
+     * it into {@link ParsedHandshakeMetadata}.
+     *
+     * May return `false` if the client should be rejected.
+     *
+     * @param metadata - The metadata sent by the client.
+     * @param session - The session that the client would be associated with.
+     * @param isReconnect - Whether the client is reconnecting to the session,
+     *                      or if this is a new session.
+     */
+    validate: ValidateHandshake<MetadataSchema>;
 }
-
-type ClientSession<ConnType extends Connection> = SessionNoConnection | SessionBackingOff | SessionConnecting<ConnType> | SessionHandshaking<ConnType> | SessionConnected<ConnType>;
-type ServerSession<ConnType extends Connection> = SessionConnected<ConnType> | SessionNoConnection;
-type Session<ConnType extends Connection> = ClientSession<ConnType> | ServerSession<ConnType>;
+declare function createClientHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, construct: ConstructHandshake<MetadataSchema>): ClientHandshakeOptions;
+declare function createServerHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, validate: ValidateHandshake<MetadataSchema>): ServerHandshakeOptions;
 
 declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {
     /**
@@ -1406,161 +1563,4 @@ declare class ServiceScaffold<State extends object> {
     }>;
 }
 
-declare const ProtocolError: {
-    readonly RetriesExceeded: "conn_retry_exceeded";
-    readonly HandshakeFailed: "handshake_failed";
-    readonly MessageOrderingViolated: "message_ordering_violated";
-    readonly InvalidMessage: "invalid_message";
-    readonly MessageSendFailure: "message_send_failure";
-};
-type ProtocolErrorType = (typeof ProtocolError)[keyof typeof ProtocolError];
-interface EventMap {
-    message: OpaqueTransportMessage;
-    sessionStatus: {
-        status: 'created' | 'closing';
-        session: Session<Connection>;
-    } | {
-        status: 'closed';
-        session: Pick<Session<Connection>, 'id' | 'to'>;
-    };
-    sessionTransition: {
-        state: SessionState.Connected;
-        id: SessionId;
-    } | {
-        state: SessionState.Handshaking;
-        id: SessionId;
-    } | {
-        state: SessionState.Connecting;
-        id: SessionId;
-    } | {
-        state: SessionState.BackingOff;
-        id: SessionId;
-    } | {
-        state: SessionState.NoConnection;
-        id: SessionId;
-    };
-    protocolError: {
-        type: (typeof ProtocolError)['HandshakeFailed'];
-        code: Static<typeof HandshakeErrorResponseCodes>;
-        message: string;
-    } | {
-        type: Omit<ProtocolErrorType, (typeof ProtocolError)['HandshakeFailed']>;
-        message: string;
-    };
-    transportStatus: {
-        status: TransportStatus;
-    };
-}
-type EventTypes = keyof EventMap;
-type EventHandler<K extends EventTypes> = (event: EventMap[K]) => unknown;
-declare class EventDispatcher<T extends EventTypes> {
-    private eventListeners;
-    removeAllListeners(): void;
-    numberOfListeners<K extends T>(eventType: K): number;
-    addEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
-    removeEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
-    dispatchEvent<K extends T>(eventType: K, event: EventMap[K]): void;
-}
-
-/**
- * Represents the possible states of a transport.
- * @property {'open'} open - The transport is open and operational (note that this doesn't mean it is actively connected)
- * @property {'closed'} closed - The transport is permanently closed and cannot be reopened.
- */
-type TransportStatus = 'open' | 'closed';
-interface DeleteSessionOptions {
-    unhealthy: boolean;
-}
-type SessionBoundSendFn = (msg: PartialTransportMessage) => string;
-/**
- * Transports manage the lifecycle (creation/deletion) of sessions
- *
- * ```plaintext
- *            ▲
- *  incoming  │
- *  messages  │
- *            ▼
- *      ┌─────────────┐   1:N   ┌───────────┐   1:1*  ┌────────────┐
- *      │  Transport  │ ◄─────► │  Session  │ ◄─────► │ Connection │
- *      └─────────────┘         └───────────┘         └────────────┘
- *            ▲                               * (may or may not be initialized yet)
- *            │
- *            ▼
- *      ┌───────────┐
- *      │ Message   │
- *      │ Listeners │
- *      └───────────┘
- * ```
- * @abstract
- */
-declare abstract class Transport<ConnType extends Connection> {
-    /**
-     * The status of the transport.
-     */
-    private status;
-    /**
-     * The client ID of this transport.
-     */
-    clientId: TransportClientId;
-    /**
-     * The event dispatcher for handling events of type EventTypes.
-     */
-    eventDispatcher: EventDispatcher<EventTypes>;
-    /**
-     * The options for this transport.
-     */
-    protected options: TransportOptions;
-    log?: Logger;
-    tracer: Tracer;
-    sessions: Map<TransportClientId, Session<ConnType>>;
-    /**
-     * Creates a new Transport instance.
-     * @param codec The codec used to encode and decode messages.
-     * @param clientId The client ID of this transport.
-     */
-    constructor(clientId: TransportClientId, providedOptions?: ProvidedTransportOptions);
-    bindLogger(fn: LogFn | Logger, level?: LoggingLevel): void;
-    /**
-     * Called when a message is received by this transport.
-     * You generally shouldn't need to override this in downstream transport implementations.
-     * @param message The received message.
-     */
-    protected handleMsg(message: OpaqueTransportMessage): void;
-    /**
-     * Adds a listener to this transport.
-     * @param the type of event to listen for
-     * @param handler The message handler to add.
-     */
-    addEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
-    /**
-     * Removes a listener from this transport.
-     * @param the type of event to un-listen on
-     * @param handler The message handler to remove.
-     */
-    removeEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): 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.
-     * Closes the transport. Any messages sent while the transport is closed will be silently discarded.
-     */
-    close(): void;
-    getStatus(): TransportStatus;
-    protected createSession<S extends Session<ConnType>>(session: S): void;
-    protected updateSession<S extends Session<ConnType>>(session: S): void;
-    protected deleteSession(session: Session<ConnType>, options?: DeleteSessionOptions): void;
-    protected onSessionGracePeriodElapsed(session: Session<ConnType>): void;
-    protected onConnectingFailed(session: SessionConnecting<ConnType>): SessionNoConnection;
-    protected onConnClosed(session: SessionHandshaking<ConnType> | SessionConnected<ConnType>): SessionNoConnection;
-    /**
-     * Gets a send closure scoped to a specific session. Sending using the returned
-     * closure after the session has transitioned to a different state will be a noop.
-     *
-     * Session objects themselves can become stale as they transition between
-     * states. As stale sessions cannot be used again (and will throw), holding
-     * onto a session object is not recommended.
-     */
-    getSessionBoundSendFn(to: TransportClientId, sessionId: SessionId): SessionBoundSendFn;
-}
-
-export { type ResultUnwrapOk as $, type AnyServiceSchemaMap as A, type StreamProcedure as B, ClientTransport as C, type Readable as D, Procedure as E, type ProcedureErrorSchemaType as F, flattenErrorType as G, UNCAUGHT_ERROR_CODE as H, type InstantiatedServiceSchemaMap as I, UNEXPECTED_DISCONNECT_CODE as J, INVALID_REQUEST_CODE as K, CANCEL_CODE as L, ReaderErrorSchema as M, type BaseErrorSchemaType as N, createClient as O, type ProvidedClientTransportOptions as P, type Client as Q, type RpcProcedure as R, type ServerHandshakeOptions as S, Ok as T, type UploadProcedure as U, type ValidProcType as V, type Writable as W, Err as X, type Result as Y, type ErrResult as Z, type OkResult as _, type ProvidedServerTransportOptions as a, type ResultUnwrapErr as a0, type ResponseData as a1, createClientHandshakeOptions as a2, createServerHandshakeOptions as a3, type ClientHandshakeOptions as a4, type ReadableIterator as a5, type ReadableResult as a6, Transport as a7, type SessionOptions as a8, type ClientTransportOptions as a9, SessionNoConnection as aa, type SessionBoundSendFn as ab, CommonSession as ac, SessionState as ad, type CommonSessionProps as ae, type ServerTransportOptions as af, type ServerSession as ag, type DeleteSessionOptions as ah, type TransportStatus as ai, type ProvidedTransportOptions as aj, type Session as ak, SessionConnecting as al, SessionHandshaking as am, SessionConnected as an, type EventMap as ao, type EventTypes as ap, type EventHandler as aq, ProtocolError as ar, type ProtocolErrorType as as, Connection as b, type ServiceContext as c, type ProcedureHandlerContext as d, type PayloadType as e, type ParsedMetadata as f, type AnyProcedure as g, type Service as h, type ServiceConfiguration as i, type ProcHandler as j, type ProcInit as k, type ProcRequest as l, type ProcResponse as m, type ProcErrors as n, type ProcType as o, ServiceSchema as p, type SerializedServerSchema as q, type SerializedServiceSchema as r, serializeSchema as s, type SerializedProcedureSchema as t, serializeSchemaV1Compat as u, type SerializedServerSchemaProtocolv1 as v, type SerializedServiceSchemaProtocolv1 as w, type SerializedProcedureSchemaProtocolv1 as x, type ProcedureMap as y, type SubscriptionProcedure as z };
+export { ResultUnwrapOk as $, AnyServiceSchemaMap as A, StreamProcedure as B, ClientTransport as C, Readable as D, Procedure as E, ProcedureErrorSchemaType as F, flattenErrorType as G, UNCAUGHT_ERROR_CODE as H, InstantiatedServiceSchemaMap as I, UNEXPECTED_DISCONNECT_CODE as J, INVALID_REQUEST_CODE as K, CANCEL_CODE as L, ReaderErrorSchema as M, BaseErrorSchemaType as N, createClient as O, ProvidedClientTransportOptions as P, Client as Q, RpcProcedure as R, ServerHandshakeOptions as S, Ok as T, UploadProcedure as U, ValidProcType as V, Writable as W, Err as X, Result as Y, ErrResult as Z, OkResult as _, ProvidedServerTransportOptions as a, ResultUnwrapErr as a0, ResponseData as a1, createClientHandshakeOptions as a2, createServerHandshakeOptions as a3, ClientHandshakeOptions as a4, ReadableIterator as a5, ReadableResult as a6, Transport as a7, SessionOptions as a8, ClientTransportOptions as a9, SessionNoConnection as aa, SessionBoundSendFn as ab, CommonSession as ac, SessionState as ad, CommonSessionProps as ae, ServerTransportOptions as af, ServerSession as ag, DeleteSessionOptions as ah, TransportStatus as ai, ProvidedTransportOptions as aj, Session as ak, SessionConnecting as al, SessionHandshaking as am, SessionConnected as an, EventMap as ao, EventTypes as ap, EventHandler as aq, ProtocolError as ar, ProtocolErrorType as as, Connection as b, ParsedMetadata as c, AnyProcedure as d, ProcedureHandlerContext as e, PayloadType as f, ServiceContext as g, Service as h, ServiceConfiguration as i, ProcHandler as j, ProcInit as k, ProcRequest as l, ProcResponse as m, ProcErrors as n, ProcType as o, ServiceSchema as p, SerializedServerSchema as q, SerializedServiceSchema as r, serializeSchema as s, SerializedProcedureSchema as t, serializeSchemaV1Compat as u, SerializedServerSchemaProtocolv1 as v, SerializedServiceSchemaProtocolv1 as w, SerializedProcedureSchemaProtocolv1 as x, ProcedureMap as y, SubscriptionProcedure as z };