@replit/river 0.23.3 → 0.23.4

package/dist/transport/index.d.cts

@@ -1,309 +1,6 @@
-import { C as Codec } from '../types-3e5768ec.js';
-import { O as OpaqueTransportMessage, C as Connection, b as Session, T as TransportClientId, m as PropagationContext, P as PartialTransportMessage, g as ClientHandshakeOptions, c as ServerHandshakeOptions, d as ParsedMetadata, S as SessionOptions } from '../index-a009d7f6.js';
-export { i as OpaqueTransportMessageSchema, j as TransportMessage, h as TransportMessageSchema, l as isStreamClose, k as isStreamOpen } from '../index-a009d7f6.js';
-import '@sinclair/typebox/value';
+export { c as ClientTransport, P as ClientTransportOptions, C as Connection, n as EventHandler, E as EventMap, m as EventTypes, o as ProtocolError, p as ProtocolErrorType, d as ServerTransport, e as ServerTransportOptions, b as Session, T as Transport, k as TransportOptions, l as TransportStatus } from '../transport-4a5e288a.js';
+export { O as OpaqueTransportMessage, e as OpaqueTransportMessageSchema, T as TransportClientId, c as TransportMessage, d as TransportMessageSchema, f as isStreamClose, i as isStreamOpen } from '../index-926aea33.js';
+import '../types-3e5768ec.js';
 import '@sinclair/typebox';
+import '@sinclair/typebox/value';
 import '@opentelemetry/api';
-
-type ConnectionStatus = 'connect' | 'disconnect';
-declare const ProtocolError: {
-    readonly RetriesExceeded: "conn_retry_exceeded";
-    readonly HandshakeFailed: "handshake_failed";
-    readonly UseAfterDestroy: "use_after_destroy";
-    readonly MessageOrderingViolated: "message_ordering_violated";
-};
-type ProtocolErrorType = (typeof ProtocolError)[keyof typeof ProtocolError];
-interface EventMap {
-    message: OpaqueTransportMessage;
-    connectionStatus: {
-        status: ConnectionStatus;
-        conn: Connection;
-    };
-    sessionStatus: {
-        status: ConnectionStatus;
-        session: Session<Connection>;
-    };
-    protocolError: {
-        type: ProtocolErrorType;
-        message: string;
-    };
-}
-type EventTypes = keyof EventMap;
-type EventHandler<K extends EventTypes> = (event: EventMap[K]) => unknown;
-declare class EventDispatcher<T extends EventTypes> {
-    private eventListeners;
-    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 intervalHandles;
-    private readonly options;
-    constructor(options: ConnectionRetryOptions);
-    getBackoffMs(user: TransportClientId): number;
-    get totalBudgetRestoreTime(): number;
-    consumeBudget(user: TransportClientId): void;
-    getBudgetConsumed(user: TransportClientId): number;
-    hasBudget(user: TransportClientId): boolean;
-    startRestoringBudget(user: TransportClientId): void;
-    private stopLeak;
-    close(): 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 closed and not operational, but can be reopened.
- * @property {'destroyed'} destroyed - The transport is permanently destroyed and cannot be reopened.
- */
-type TransportStatus = 'open' | 'closed' | 'destroyed';
-type TransportOptions = SessionOptions;
-type ProvidedTransportOptions = Partial<TransportOptions>;
-type ClientTransportOptions = TransportOptions & ConnectionRetryOptions;
-type ProvidedClientTransportOptions = Partial<ClientTransportOptions>;
-type ServerTransportOptions = TransportOptions;
-type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
-/**
- * Transports manage the lifecycle (creation/deletion) of sessions and connections. Its responsibilities include:
- *
- *  1) Constructing a new {@link Session} and {@link Connection} on {@link TransportMessage}s from new clients.
- *     After constructing the {@link Connection}, {@link onConnect} is called which adds it to the connection map.
- *  2) Delegating message listening of the connection to the newly created {@link Connection}.
- *     From this point on, the {@link Connection} is responsible for *reading* and *writing*
- *     messages from the connection.
- *  3) When a connection is closed, the {@link Transport} calls {@link onDisconnect} which closes the
- *     connection via {@link Connection.close} and removes it from the {@link connections} map.
-
- *
- * ```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> {
-    /**
-     * A flag indicating whether the transport has been destroyed.
-     * A destroyed transport will not attempt to reconnect and cannot be used again.
-     */
-    state: TransportStatus;
-    /**
-     * The {@link Codec} used to encode and decode messages.
-     */
-    codec: Codec;
-    /**
-     * The client ID of this transport.
-     */
-    clientId: TransportClientId;
-    /**
-     * The map of {@link Session}s managed by this transport.
-     */
-    sessions: Map<TransportClientId, Session<ConnType>>;
-    /**
-     * The map of {@link Connection}s managed by this transport.
-     */
-    get connections(): Map<string, ConnType>;
-    /**
-     * The event dispatcher for handling events of type EventTypes.
-     */
-    eventDispatcher: EventDispatcher<EventTypes>;
-    /**
-     * The options for this transport.
-     */
-    protected options: TransportOptions;
-    /**
-     * Creates a new Transport instance.
-     * This should also set up {@link onConnect}, and {@link onDisconnect} listeners.
-     * @param codec The codec used to encode and decode messages.
-     * @param clientId The client ID of this transport.
-     */
-    constructor(clientId: TransportClientId, providedOptions?: ProvidedTransportOptions);
-    /**
-     * This is called immediately after a new connection is established and we
-     * may or may not know the identity of the connected client.
-     * It should attach all the necessary listeners to the connection for lifecycle
-     * events (i.e. data, close, error)
-     *
-     * This method is implemented by {@link ClientTransport} and {@link ServerTransport}.
-     */
-    protected abstract handleConnection(conn: ConnType, to: TransportClientId): void;
-    /**
-     * Called when a new connection is established
-     * and we know the identity of the connected client.
-     * @param conn The connection object.
-     */
-    protected onConnect(conn: ConnType, connectedTo: TransportClientId, session: Session<ConnType>, isReconnect: boolean): void;
-    protected createSession(to: TransportClientId, conn?: ConnType, propagationCtx?: PropagationContext): Session<ConnType>;
-    protected getOrCreateSession(to: TransportClientId, conn?: ConnType, sessionId?: string, propagationCtx?: PropagationContext): {
-        session: Session<ConnType>;
-        isReconnect: boolean;
-    };
-    protected deleteSession(session: Session<ConnType>): void;
-    /**
-     * The downstream implementation needs to call this when a connection is closed.
-     * @param conn The connection object.
-     * @param connectedTo The peer we are connected to.
-     */
-    protected onDisconnect(conn: ConnType, session: Session<ConnType>): void;
-    /**
-     * Parses a message from a Uint8Array into a {@link OpaqueTransportMessage}.
-     * @param msg The message to parse.
-     * @returns The parsed message, or null if the message is malformed or invalid.
-     */
-    protected parseMsg(msg: Uint8Array): OpaqueTransportMessage | null;
-    /**
-     * Called when a message is received by this transport.
-     * You generally shouldn't need to override this in downstream transport implementations.
-     * @param msg The received message.
-     */
-    protected handleMsg(msg: 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;
-    /**
-     * Sends a message over this transport, delegating to the appropriate connection to actually
-     * send the message.
-     * @param msg The message to send.
-     * @returns The ID of the sent message or undefined if it wasn't sent
-     */
-    send(to: TransportClientId, msg: PartialTransportMessage): string | undefined;
-    sendCloseStream(to: TransportClientId, streamId: string): string | undefined;
-    protected protocolError(type: ProtocolErrorType, message: string): 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;
-    /**
-     * Default destroy implementation for transports. You should override this in the downstream
-     * implementation if you need to do any additional cleanup and call super.destroy() at the end.
-     * Destroys the transport. Any messages sent while the transport is destroyed will throw an error.
-     */
-    destroy(): void;
-}
-declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {
-    /**
-     * The options for this transport.
-     */
-    protected options: ClientTransportOptions;
-    /**
-     * The map of reconnect promises for each client ID.
-     */
-    inflightConnectionPromises: Map<TransportClientId, Promise<ConnType>>;
-    retryBudget: LeakyBucketRateLimit;
-    /**
-     * 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: boolean;
-    /**
-     * Optional handshake options for this client.
-     */
-    handshakeExtensions?: ClientHandshakeOptions;
-    constructor(clientId: TransportClientId, providedOptions?: ProvidedClientTransportOptions);
-    extendHandshake(options: ClientHandshakeOptions): void;
-    protected handleConnection(conn: ConnType, to: TransportClientId): void;
-    receiveHandshakeResponseMessage(data: Uint8Array, conn: ConnType): Session<ConnType> | false;
-    /**
-     * Abstract method that creates a new {@link Connection} object.
-     * This should call {@link handleConnection} when the connection is created.
-     * The downstream client implementation needs to implement this.
-     *
-     * @param to The client ID of the node to connect to.
-     * @returns The new connection object.
-     */
-    protected abstract createNewOutgoingConnection(to: TransportClientId): Promise<ConnType>;
-    /**
-     * Manually attempts to connect to a client.
-     * @param to The client ID of the node to connect to.
-     */
-    connect(to: TransportClientId): Promise<void>;
-    protected deleteSession(session: Session<ConnType>): void;
-    protected sendHandshake(to: TransportClientId, conn: ConnType): Promise<boolean>;
-    close(): void;
-}
-declare abstract class ServerTransport<ConnType extends Connection> extends Transport<ConnType> {
-    /**
-     * The options for this transport.
-     */
-    protected options: ServerTransportOptions;
-    /**
-     * Optional handshake options for the server.
-     */
-    handshakeExtensions?: ServerHandshakeOptions;
-    /**
-     * A map of session handshake data for each session.
-     */
-    sessionHandshakeMetadata: WeakMap<Session<ConnType>, ParsedMetadata>;
-    constructor(clientId: TransportClientId, providedOptions?: ProvidedServerTransportOptions);
-    extendHandshake(options: ServerHandshakeOptions): void;
-    protected handleConnection(conn: ConnType): void;
-    private validateHandshakeMetadata;
-    receiveHandshakeRequestMessage(data: Uint8Array, conn: ConnType): Promise<Session<ConnType> | false>;
-}
-
-export { ClientHandshakeOptions, ClientTransport, ProvidedClientTransportOptions as ClientTransportOptions, Connection, EventHandler, EventMap, EventTypes, OpaqueTransportMessage, ProtocolError, ProtocolErrorType, ServerHandshakeOptions, ServerTransport, ProvidedServerTransportOptions as ServerTransportOptions, Session, Transport, TransportClientId, ProvidedTransportOptions as TransportOptions, TransportStatus };

package/dist/transport/index.d.ts

@@ -1,309 +1,6 @@
-import { C as Codec } from '../types-3e5768ec.js';
-import { O as OpaqueTransportMessage, C as Connection, b as Session, T as TransportClientId, m as PropagationContext, P as PartialTransportMessage, g as ClientHandshakeOptions, c as ServerHandshakeOptions, d as ParsedMetadata, S as SessionOptions } from '../index-a009d7f6.js';
-export { i as OpaqueTransportMessageSchema, j as TransportMessage, h as TransportMessageSchema, l as isStreamClose, k as isStreamOpen } from '../index-a009d7f6.js';
-import '@sinclair/typebox/value';
+export { c as ClientTransport, P as ClientTransportOptions, C as Connection, n as EventHandler, E as EventMap, m as EventTypes, o as ProtocolError, p as ProtocolErrorType, d as ServerTransport, e as ServerTransportOptions, b as Session, T as Transport, k as TransportOptions, l as TransportStatus } from '../transport-4a5e288a.js';
+export { O as OpaqueTransportMessage, e as OpaqueTransportMessageSchema, T as TransportClientId, c as TransportMessage, d as TransportMessageSchema, f as isStreamClose, i as isStreamOpen } from '../index-926aea33.js';
+import '../types-3e5768ec.js';
 import '@sinclair/typebox';
+import '@sinclair/typebox/value';
 import '@opentelemetry/api';
-
-type ConnectionStatus = 'connect' | 'disconnect';
-declare const ProtocolError: {
-    readonly RetriesExceeded: "conn_retry_exceeded";
-    readonly HandshakeFailed: "handshake_failed";
-    readonly UseAfterDestroy: "use_after_destroy";
-    readonly MessageOrderingViolated: "message_ordering_violated";
-};
-type ProtocolErrorType = (typeof ProtocolError)[keyof typeof ProtocolError];
-interface EventMap {
-    message: OpaqueTransportMessage;
-    connectionStatus: {
-        status: ConnectionStatus;
-        conn: Connection;
-    };
-    sessionStatus: {
-        status: ConnectionStatus;
-        session: Session<Connection>;
-    };
-    protocolError: {
-        type: ProtocolErrorType;
-        message: string;
-    };
-}
-type EventTypes = keyof EventMap;
-type EventHandler<K extends EventTypes> = (event: EventMap[K]) => unknown;
-declare class EventDispatcher<T extends EventTypes> {
-    private eventListeners;
-    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 intervalHandles;
-    private readonly options;
-    constructor(options: ConnectionRetryOptions);
-    getBackoffMs(user: TransportClientId): number;
-    get totalBudgetRestoreTime(): number;
-    consumeBudget(user: TransportClientId): void;
-    getBudgetConsumed(user: TransportClientId): number;
-    hasBudget(user: TransportClientId): boolean;
-    startRestoringBudget(user: TransportClientId): void;
-    private stopLeak;
-    close(): 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 closed and not operational, but can be reopened.
- * @property {'destroyed'} destroyed - The transport is permanently destroyed and cannot be reopened.
- */
-type TransportStatus = 'open' | 'closed' | 'destroyed';
-type TransportOptions = SessionOptions;
-type ProvidedTransportOptions = Partial<TransportOptions>;
-type ClientTransportOptions = TransportOptions & ConnectionRetryOptions;
-type ProvidedClientTransportOptions = Partial<ClientTransportOptions>;
-type ServerTransportOptions = TransportOptions;
-type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
-/**
- * Transports manage the lifecycle (creation/deletion) of sessions and connections. Its responsibilities include:
- *
- *  1) Constructing a new {@link Session} and {@link Connection} on {@link TransportMessage}s from new clients.
- *     After constructing the {@link Connection}, {@link onConnect} is called which adds it to the connection map.
- *  2) Delegating message listening of the connection to the newly created {@link Connection}.
- *     From this point on, the {@link Connection} is responsible for *reading* and *writing*
- *     messages from the connection.
- *  3) When a connection is closed, the {@link Transport} calls {@link onDisconnect} which closes the
- *     connection via {@link Connection.close} and removes it from the {@link connections} map.
-
- *
- * ```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> {
-    /**
-     * A flag indicating whether the transport has been destroyed.
-     * A destroyed transport will not attempt to reconnect and cannot be used again.
-     */
-    state: TransportStatus;
-    /**
-     * The {@link Codec} used to encode and decode messages.
-     */
-    codec: Codec;
-    /**
-     * The client ID of this transport.
-     */
-    clientId: TransportClientId;
-    /**
-     * The map of {@link Session}s managed by this transport.
-     */
-    sessions: Map<TransportClientId, Session<ConnType>>;
-    /**
-     * The map of {@link Connection}s managed by this transport.
-     */
-    get connections(): Map<string, ConnType>;
-    /**
-     * The event dispatcher for handling events of type EventTypes.
-     */
-    eventDispatcher: EventDispatcher<EventTypes>;
-    /**
-     * The options for this transport.
-     */
-    protected options: TransportOptions;
-    /**
-     * Creates a new Transport instance.
-     * This should also set up {@link onConnect}, and {@link onDisconnect} listeners.
-     * @param codec The codec used to encode and decode messages.
-     * @param clientId The client ID of this transport.
-     */
-    constructor(clientId: TransportClientId, providedOptions?: ProvidedTransportOptions);
-    /**
-     * This is called immediately after a new connection is established and we
-     * may or may not know the identity of the connected client.
-     * It should attach all the necessary listeners to the connection for lifecycle
-     * events (i.e. data, close, error)
-     *
-     * This method is implemented by {@link ClientTransport} and {@link ServerTransport}.
-     */
-    protected abstract handleConnection(conn: ConnType, to: TransportClientId): void;
-    /**
-     * Called when a new connection is established
-     * and we know the identity of the connected client.
-     * @param conn The connection object.
-     */
-    protected onConnect(conn: ConnType, connectedTo: TransportClientId, session: Session<ConnType>, isReconnect: boolean): void;
-    protected createSession(to: TransportClientId, conn?: ConnType, propagationCtx?: PropagationContext): Session<ConnType>;
-    protected getOrCreateSession(to: TransportClientId, conn?: ConnType, sessionId?: string, propagationCtx?: PropagationContext): {
-        session: Session<ConnType>;
-        isReconnect: boolean;
-    };
-    protected deleteSession(session: Session<ConnType>): void;
-    /**
-     * The downstream implementation needs to call this when a connection is closed.
-     * @param conn The connection object.
-     * @param connectedTo The peer we are connected to.
-     */
-    protected onDisconnect(conn: ConnType, session: Session<ConnType>): void;
-    /**
-     * Parses a message from a Uint8Array into a {@link OpaqueTransportMessage}.
-     * @param msg The message to parse.
-     * @returns The parsed message, or null if the message is malformed or invalid.
-     */
-    protected parseMsg(msg: Uint8Array): OpaqueTransportMessage | null;
-    /**
-     * Called when a message is received by this transport.
-     * You generally shouldn't need to override this in downstream transport implementations.
-     * @param msg The received message.
-     */
-    protected handleMsg(msg: 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;
-    /**
-     * Sends a message over this transport, delegating to the appropriate connection to actually
-     * send the message.
-     * @param msg The message to send.
-     * @returns The ID of the sent message or undefined if it wasn't sent
-     */
-    send(to: TransportClientId, msg: PartialTransportMessage): string | undefined;
-    sendCloseStream(to: TransportClientId, streamId: string): string | undefined;
-    protected protocolError(type: ProtocolErrorType, message: string): 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;
-    /**
-     * Default destroy implementation for transports. You should override this in the downstream
-     * implementation if you need to do any additional cleanup and call super.destroy() at the end.
-     * Destroys the transport. Any messages sent while the transport is destroyed will throw an error.
-     */
-    destroy(): void;
-}
-declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {
-    /**
-     * The options for this transport.
-     */
-    protected options: ClientTransportOptions;
-    /**
-     * The map of reconnect promises for each client ID.
-     */
-    inflightConnectionPromises: Map<TransportClientId, Promise<ConnType>>;
-    retryBudget: LeakyBucketRateLimit;
-    /**
-     * 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: boolean;
-    /**
-     * Optional handshake options for this client.
-     */
-    handshakeExtensions?: ClientHandshakeOptions;
-    constructor(clientId: TransportClientId, providedOptions?: ProvidedClientTransportOptions);
-    extendHandshake(options: ClientHandshakeOptions): void;
-    protected handleConnection(conn: ConnType, to: TransportClientId): void;
-    receiveHandshakeResponseMessage(data: Uint8Array, conn: ConnType): Session<ConnType> | false;
-    /**
-     * Abstract method that creates a new {@link Connection} object.
-     * This should call {@link handleConnection} when the connection is created.
-     * The downstream client implementation needs to implement this.
-     *
-     * @param to The client ID of the node to connect to.
-     * @returns The new connection object.
-     */
-    protected abstract createNewOutgoingConnection(to: TransportClientId): Promise<ConnType>;
-    /**
-     * Manually attempts to connect to a client.
-     * @param to The client ID of the node to connect to.
-     */
-    connect(to: TransportClientId): Promise<void>;
-    protected deleteSession(session: Session<ConnType>): void;
-    protected sendHandshake(to: TransportClientId, conn: ConnType): Promise<boolean>;
-    close(): void;
-}
-declare abstract class ServerTransport<ConnType extends Connection> extends Transport<ConnType> {
-    /**
-     * The options for this transport.
-     */
-    protected options: ServerTransportOptions;
-    /**
-     * Optional handshake options for the server.
-     */
-    handshakeExtensions?: ServerHandshakeOptions;
-    /**
-     * A map of session handshake data for each session.
-     */
-    sessionHandshakeMetadata: WeakMap<Session<ConnType>, ParsedMetadata>;
-    constructor(clientId: TransportClientId, providedOptions?: ProvidedServerTransportOptions);
-    extendHandshake(options: ServerHandshakeOptions): void;
-    protected handleConnection(conn: ConnType): void;
-    private validateHandshakeMetadata;
-    receiveHandshakeRequestMessage(data: Uint8Array, conn: ConnType): Promise<Session<ConnType> | false>;
-}
-
-export { ClientHandshakeOptions, ClientTransport, ProvidedClientTransportOptions as ClientTransportOptions, Connection, EventHandler, EventMap, EventTypes, OpaqueTransportMessage, ProtocolError, ProtocolErrorType, ServerHandshakeOptions, ServerTransport, ProvidedServerTransportOptions as ServerTransportOptions, Session, Transport, TransportClientId, ProvidedTransportOptions as TransportOptions, TransportStatus };

package/dist/transport/index.js

@@ -5,11 +5,11 @@ import {
   ServerTransport,
   Session,
   Transport
-} from "../chunk-IKT6A32W.js";
+} from "../chunk-BHNINW7F.js";
 import {
   OpaqueTransportMessageSchema,
   TransportMessageSchema
-} from "../chunk-XZV3HOQW.js";
+} from "../chunk-CHOAXTQF.js";
 import "../chunk-SPP7ACQN.js";
 import "../chunk-3AW3IXVD.js";
 export {