@replit/river 0.207.3 → 0.208.0

package/dist/transport-CCaWx1Rb.d.cts

@@ -0,0 +1,1566 @@
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { TSchema, Static, TNever, TObject, TLiteral, TString, TUnion } 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.cjs';
+import { M as MessageMetadata, L as Logger, T as Tags, a as LogFn, b as LoggingLevel } from './index-C9tpZjBN.cjs';
+import { C as Codec, a as CodecMessageAdapter, S as SendResult, b as SendBufferResult } from './adapter-Cuc4JtfV.cjs';
+
+/**
+ * A connection is the actual raw underlying transport connection.
+ * It's responsible for dispatching to/from the actual connection itself
+ * This should be instantiated as soon as the client/server has a connection
+ * It's tied to the lifecycle of the underlying transport connection (i.e. if the WS drops, this connection should be deleted)
+ */
+declare abstract class Connection {
+    id: string;
+    telemetry?: TelemetryInfo;
+    constructor();
+    get loggingMetadata(): MessageMetadata;
+    dataListener?: (msg: Uint8Array) => void;
+    closeListener?: () => void;
+    errorListener?: (err: Error) => void;
+    onData(msg: Uint8Array): void;
+    onError(err: Error): void;
+    onClose(): void;
+    /**
+     * Set the callback for when a message is received.
+     * @param cb The message handler callback.
+     */
+    setDataListener(cb: (msg: Uint8Array) => void): void;
+    removeDataListener(): void;
+    /**
+     * Set the callback for when the connection is closed.
+     * This should also be called if an error happens and after notifying the error listener.
+     * @param cb The callback to call when the connection is closed.
+     */
+    setCloseListener(cb: () => void): void;
+    removeCloseListener(): void;
+    /**
+     * Set the callback for when an error is received.
+     * This should only be used for logging errors, all cleanup
+     * should be delegated to setCloseListener.
+     *
+     * The implementer should take care such that the implemented
+     * connection will call both the close and error callbacks
+     * on an error.
+     *
+     * @param cb The callback to call when an error is received.
+     */
+    setErrorListener(cb: (err: Error) => void): void;
+    removeErrorListener(): void;
+    /**
+     * Sends a message over the connection.
+     * @param msg The message to send.
+     * @returns true if the message was sent, false otherwise.
+     */
+    abstract send(msg: Uint8Array): boolean;
+    /**
+     * Closes the connection.
+     */
+    abstract close(): void;
+}
+
+declare const enum SessionState {
+    NoConnection = "NoConnection",
+    BackingOff = "BackingOff",
+    Connecting = "Connecting",
+    Handshaking = "Handshaking",
+    Connected = "Connected",
+    WaitingForHandshake = "WaitingForHandshake"
+}
+declare abstract class StateMachineState {
+    abstract readonly state: SessionState;
+    _isConsumed: boolean;
+    abstract _handleStateExit(): void;
+    abstract _handleClose(): void;
+    /**
+     * Cleanup this state machine state and mark it as consumed.
+     * After calling close, it is an error to access any properties on the state.
+     * You should never need to call this as a consumer.
+     *
+     * If you're looking to close the session from the client,
+     * use `.hardDisconnect` on the client transport.
+     */
+    close(): void;
+    constructor();
+}
+interface SessionOptions {
+    /**
+     * Frequency at which to send heartbeat acknowledgements
+     */
+    heartbeatIntervalMs: number;
+    /**
+     * Number of elapsed heartbeats without a response message before we consider
+     * the connection dead.
+     */
+    heartbeatsUntilDead: number;
+    /**
+     * Max duration that a session can be without a connection before we consider
+     * it dead. This deadline is carried between states and is used to determine
+     * when to consider the session a lost cause and delete it entirely.
+     * Generally, this should be strictly greater than the sum of
+     * {@link connectionTimeoutMs} and {@link handshakeTimeoutMs}.
+     */
+    sessionDisconnectGraceMs: number;
+    /**
+     * Connection timeout in milliseconds
+     */
+    connectionTimeoutMs: number;
+    /**
+     * Handshake timeout in milliseconds
+     */
+    handshakeTimeoutMs: number;
+    /**
+     * Whether to enable transparent session reconnects
+     */
+    enableTransparentSessionReconnects: boolean;
+    /**
+     * The codec to use for encoding/decoding messages over the wire
+     */
+    codec: Codec;
+}
+interface CommonSessionProps {
+    from: TransportClientId;
+    options: SessionOptions;
+    codec: CodecMessageAdapter;
+    tracer: Tracer;
+    log: Logger | undefined;
+}
+declare abstract class CommonSession extends StateMachineState {
+    readonly from: TransportClientId;
+    readonly options: SessionOptions;
+    readonly codec: CodecMessageAdapter;
+    tracer: Tracer;
+    log?: Logger;
+    abstract get loggingMetadata(): MessageMetadata;
+    constructor({ from, options, log, tracer, codec }: CommonSessionProps);
+}
+type SessionId = string;
+interface IdentifiedSessionProps extends CommonSessionProps {
+    id: SessionId;
+    to: TransportClientId;
+    seq: number;
+    ack: number;
+    seqSent: number;
+    sendBuffer: Array<OpaqueTransportMessage>;
+    telemetry: TelemetryInfo;
+    protocolVersion: ProtocolVersion;
+}
+declare abstract class IdentifiedSession extends CommonSession {
+    readonly id: SessionId;
+    readonly telemetry: TelemetryInfo;
+    readonly to: TransportClientId;
+    readonly protocolVersion: ProtocolVersion;
+    /**
+     * Index of the message we will send next (excluding handshake)
+     */
+    seq: number;
+    /**
+     * Last seq we sent over the wire this session (excluding handshake) and retransmissions
+     */
+    seqSent: number;
+    /**
+     * Number of unique messages we've received this session (excluding handshake)
+     */
+    ack: number;
+    sendBuffer: Array<OpaqueTransportMessage>;
+    constructor(props: IdentifiedSessionProps);
+    get loggingMetadata(): MessageMetadata;
+    constructMsg<Payload>(partialMsg: PartialTransportMessage<Payload>): TransportMessage<Payload>;
+    nextSeq(): number;
+    send(msg: PartialTransportMessage): SendResult;
+    _handleStateExit(): void;
+    _handleClose(): void;
+}
+interface IdentifiedSessionWithGracePeriodListeners {
+    onSessionGracePeriodElapsed: () => void;
+}
+interface IdentifiedSessionWithGracePeriodProps extends IdentifiedSessionProps {
+    graceExpiryTime: number;
+    listeners: IdentifiedSessionWithGracePeriodListeners;
+}
+declare abstract class IdentifiedSessionWithGracePeriod extends IdentifiedSession {
+    graceExpiryTime: number;
+    protected gracePeriodTimeout?: ReturnType<typeof setTimeout>;
+    listeners: IdentifiedSessionWithGracePeriodListeners;
+    constructor(props: IdentifiedSessionWithGracePeriodProps);
+    _handleStateExit(): void;
+    _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;
+    onConnectionTimeout: () => void;
+}
+interface SessionConnectingProps<ConnType extends Connection> extends IdentifiedSessionWithGracePeriodProps {
+    connPromise: Promise<ConnType>;
+    listeners: SessionConnectingListeners;
+}
+declare class SessionConnecting<ConnType extends Connection> extends IdentifiedSessionWithGracePeriod {
+    readonly state: SessionState.Connecting;
+    connPromise: Promise<ConnType>;
+    listeners: SessionConnectingListeners;
+    connectionTimeout?: ReturnType<typeof setTimeout>;
+    constructor(props: SessionConnectingProps<ConnType>);
+    bestEffortClose(): void;
+    _handleStateExit(): void;
+    _handleClose(): void;
+}
+
+interface SessionHandshakingListeners extends IdentifiedSessionWithGracePeriodListeners {
+    onConnectionErrored: (err: unknown) => void;
+    onConnectionClosed: () => void;
+    onHandshake: (msg: OpaqueTransportMessage) => void;
+    onInvalidHandshake: (reason: string, code: Static<typeof HandshakeErrorResponseCodes>) => void;
+    onHandshakeTimeout: () => void;
+}
+interface SessionHandshakingProps<ConnType extends Connection> extends IdentifiedSessionWithGracePeriodProps {
+    conn: ConnType;
+    listeners: SessionHandshakingListeners;
+}
+declare class SessionHandshaking<ConnType extends Connection> extends IdentifiedSessionWithGracePeriod {
+    readonly state: SessionState.Handshaking;
+    conn: ConnType;
+    listeners: SessionHandshakingListeners;
+    handshakeTimeout?: ReturnType<typeof setTimeout>;
+    constructor(props: SessionHandshakingProps<ConnType>);
+    get loggingMetadata(): {
+        protocolVersion?: ProtocolVersion | undefined;
+        clientId?: string | undefined;
+        connectedTo?: string | undefined;
+        sessionId?: string | undefined;
+        connId?: string | undefined;
+        transportMessage?: Partial<OpaqueTransportMessage> | undefined;
+        validationErrors?: {
+            path: string;
+            message: string;
+        }[] | undefined;
+        tags?: Tags[] | undefined;
+        telemetry?: {
+            traceId: string;
+            spanId: string;
+        } | undefined;
+        extras?: Record<string, unknown> | undefined;
+    };
+    onHandshakeData: (msg: Uint8Array) => void;
+    sendHandshake(msg: TransportMessage): SendResult;
+    _handleStateExit(): void;
+    _handleClose(): void;
+}
+
+interface SessionConnectedListeners {
+    onConnectionErrored: (err: unknown) => void;
+    onConnectionClosed: () => void;
+    onMessage: (msg: OpaqueTransportMessage) => void;
+    onMessageSendFailure: (msg: PartialTransportMessage, reason: string) => void;
+    onInvalidMessage: (reason: string) => void;
+}
+interface SessionConnectedProps<ConnType extends Connection> extends IdentifiedSessionProps {
+    conn: ConnType;
+    listeners: SessionConnectedListeners;
+}
+declare class SessionConnected<ConnType extends Connection> extends IdentifiedSession {
+    readonly state: SessionState.Connected;
+    conn: ConnType;
+    listeners: SessionConnectedListeners;
+    private heartbeatHandle?;
+    private heartbeatMissTimeout?;
+    private isActivelyHeartbeating;
+    updateBookkeeping(ack: number, seq: number): void;
+    private assertSendOrdering;
+    send(msg: PartialTransportMessage): SendResult;
+    constructor(props: SessionConnectedProps<ConnType>);
+    sendBufferedMessages(): SendBufferResult;
+    get loggingMetadata(): {
+        protocolVersion?: ProtocolVersion | undefined;
+        clientId?: string | undefined;
+        connectedTo?: string | undefined;
+        sessionId?: string | undefined;
+        connId?: string | undefined;
+        transportMessage?: Partial<OpaqueTransportMessage> | undefined;
+        validationErrors?: {
+            path: string;
+            message: string;
+        }[] | undefined;
+        tags?: Tags[] | undefined;
+        telemetry?: {
+            traceId: string;
+            spanId: string;
+        } | undefined;
+        extras?: Record<string, unknown> | undefined;
+    };
+    startMissingHeartbeatTimeout(): void;
+    startActiveHeartbeat(): void;
+    private sendHeartbeat;
+    onMessageData: (msg: Uint8Array) => void;
+    _handleStateExit(): void;
+    _handleClose(): void;
+}
+
+declare class SessionNoConnection extends IdentifiedSessionWithGracePeriod {
+    readonly state: SessionState.NoConnection;
+    _handleClose(): void;
+    _handleStateExit(): void;
+}
+
+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;
+}
+
+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 abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {
+    /**
+     * The options for this transport.
+     */
+    protected options: ClientTransportOptions;
+    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;
+    sessions: Map<TransportClientId, ClientSession<ConnType>>;
+    constructor(clientId: TransportClientId, providedOptions?: ProvidedClientTransportOptions);
+    extendHandshake(options: ClientHandshakeOptions): void;
+    /**
+     * Abstract method that creates a new {@link Connection} object.
+     *
+     * @param to The client ID of the node to connect to.
+     * @returns The new connection object.
+     */
+    protected abstract createNewOutgoingConnection(to: TransportClientId): Promise<ConnType>;
+    private tryReconnecting;
+    createUnconnectedSession(to: string): SessionNoConnection;
+    protected onConnectingFailed(session: SessionConnecting<ConnType>): SessionNoConnection;
+    protected onConnClosed(session: SessionHandshaking<ConnType> | SessionConnected<ConnType>): SessionNoConnection;
+    protected onConnectionEstablished(session: SessionConnecting<ConnType>, conn: ConnType): SessionHandshaking<ConnType>;
+    private rejectHandshakeResponse;
+    protected onHandshakeResponse(session: SessionHandshaking<ConnType>, msg: OpaqueTransportMessage): void;
+    /**
+     * Manually attempts to connect to a client.
+     * @param to The client ID of the node to connect to.
+     */
+    connect(to: TransportClientId): void;
+    /**
+     * Manually kills all sessions to the server (including all pending state).
+     * This is useful for when you want to close all connections to a server
+     * and don't want to wait for the grace period to elapse.
+     */
+    hardDisconnect(): void;
+    protected onBackoffFinished(session: SessionBackingOff): void;
+    private sendHandshake;
+    close(): void;
+}
+
+/**
+ * {@link UNCAUGHT_ERROR_CODE} is the code that is used when an error is thrown
+ * inside a procedure handler that's not required.
+ */
+declare const UNCAUGHT_ERROR_CODE = "UNCAUGHT_ERROR";
+/**
+ * {@link UNEXPECTED_DISCONNECT_CODE} is the code used the stream's session
+ * disconnect unexpetedly.
+ */
+declare const UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
+/**
+ * {@link INVALID_REQUEST_CODE} is the code used when a client's request is invalid.
+ */
+declare const INVALID_REQUEST_CODE = "INVALID_REQUEST";
+/**
+ * {@link CANCEL_CODE} is the code used when either server or client cancels the stream.
+ */
+declare const CANCEL_CODE = "CANCEL";
+type TLiteralString = TLiteral<string>;
+type BaseErrorSchemaType = TObject<{
+    code: TLiteralString;
+    message: TLiteralString | TString;
+}> | TObject<{
+    code: TLiteralString;
+    message: TLiteralString | TString;
+    extras: TSchema;
+}>;
+/**
+ * A schema for cancel payloads sent from the client
+ */
+declare const CancelErrorSchema: TObject<{
+    code: TLiteral<"CANCEL">;
+    message: TString;
+}>;
+/**
+ * {@link ReaderErrorSchema} is the schema for all the built-in river errors that
+ * can be emitted to a reader (request reader on the server, and response reader
+ * on the client).
+ */
+declare const ReaderErrorSchema: TUnion<[TObject<{
+    code: TLiteral<"UNCAUGHT_ERROR">;
+    message: TString;
+}>, TObject<{
+    code: TLiteral<"UNEXPECTED_DISCONNECT">;
+    message: TString;
+}>, TObject<{
+    code: TLiteral<"INVALID_REQUEST">;
+    message: TString;
+    extras: _sinclair_typebox.TOptional<TObject<{
+        firstValidationErrors: _sinclair_typebox.TArray<TObject<{
+            path: TString;
+            message: TString;
+        }>>;
+        totalErrors: _sinclair_typebox.TNumber;
+    }>>;
+}>, TObject<{
+    code: TLiteral<"CANCEL">;
+    message: TString;
+}>]>;
+/**
+ * Represents an acceptable schema to pass to a procedure.
+ * Just a type of a schema, not an actual schema.
+ *
+ */
+type ProcedureErrorSchemaType = TNever | BaseErrorSchemaType | TUnion<Array<BaseErrorSchemaType>>;
+type NestableProcedureErrorSchemaType = BaseErrorSchemaType | TUnion<NestableProcedureErrorSchemaTypeArray>;
+interface NestableProcedureErrorSchemaTypeArray extends Array<NestableProcedureErrorSchemaType> {
+}
+type Flatten<T> = T extends BaseErrorSchemaType ? T : T extends TUnion<Array<infer U extends TSchema>> ? Flatten<U> : unknown;
+/**
+ * In the case where API consumers for some god-forsaken reason want to use
+ * arbitrarily nested unions, this helper flattens them to a single level.
+ *
+ * Note that loses some metadata information on the nested unions like
+ * nested description fields, etc.
+ *
+ * @param errType - An arbitrarily union-nested error schema.
+ * @returns The flattened error schema.
+ */
+declare function flattenErrorType<T extends NestableProcedureErrorSchemaType>(errType: T): Flatten<T>;
+
+declare const ReadableBrokenError: {
+    readonly code: "READABLE_BROKEN";
+    readonly message: "Readable was broken before it is fully consumed";
+};
+/**
+ * Similar to {@link Result} but with an extra error to handle cases where {@link Readable.break} is called
+ */
+type ReadableResult<T, E extends Static<BaseErrorSchemaType>> = Result<T, E | typeof ReadableBrokenError>;
+/**
+ * A simple {@link AsyncIterator} used in {@link Readable}
+ * that doesn't have a the extra "return" and "throw" methods, and
+ * the doesn't have a "done value" (TReturn).
+ */
+interface ReadableIterator<T, E extends Static<BaseErrorSchemaType>> {
+    next(): Promise<{
+        done: false;
+        value: ReadableResult<T, E>;
+    } | {
+        done: true;
+        value: undefined;
+    }>;
+}
+/**
+ * A {@link Readable} is an abstraction from which data is consumed from {@link Writable} source.
+ *
+ * - On the server the argument passed the procedure handler for `upload` and `stream` implements a {@link Readable} interface
+ *   so you can read client's request data.
+ * - On the client the returned value of `subscription` or `stream` invocation implements a {@link Readable} interface
+ *   so you can read server's response data.
+ *
+ * A {@link Readable} can only have one consumer (iterator or {@link collect}) for the {@link Readable}'s
+ * lifetime, in essense, reading from a {@link Readable} locks it forever.
+ */
+interface Readable<T, E extends Static<BaseErrorSchemaType>> {
+    /**
+     * {@link Readable} implements AsyncIterator API and can be consumed via
+     * for-await-of loops. Iteration locks the Readable. Exiting the loop
+     * will **not** release the lock and it'll be equivalent of calling
+     * {@link break}.
+     */
+    [Symbol.asyncIterator](): ReadableIterator<T, E>;
+    /**
+     * {@link collect} locks the {@link Readable} and returns a promise that resolves
+     * with an array of the content when the {@link Readable} is fully done. This could
+     * be due to the {@link Writable} end of the pipe closing cleanly, the procedure invocation
+     * is cancelled, or {@link break} is called.
+     */
+    collect(): Promise<Array<ReadableResult<T, E>>>;
+    /**
+     * {@link break} locks the {@link Readable} and discards any existing or future incoming data.
+     *
+     * If there is an existing reader waiting for the next value, {@link break} causes it to
+     * resolve with a {@link ReadableBrokenError} error.
+     */
+    break(): undefined;
+    /**
+     * {@link isReadable} returns true if it's safe to read from the {@link Readable}, either
+     * via iteration or {@link collect}. It returns false if the {@link Readable} is locked
+     * by a consumer (iterator or {@link collect}) or readable was broken via {@link break}.
+     */
+    isReadable(): boolean;
+}
+/**
+ * A {@link Writeable} is a an abstraction for a {@link Readable} destination to which data is written to.
+ *
+ * - On the server the argument passed the procedure handler for `subscription` and `stream` implements a {@link Writeable}
+ *   so you can write server's response data.
+ * - On the client the returned value of `upload` or `stream` invocation implements a {@link Writeable}
+ *   so you can write client's request data.
+ *
+ * Once closed, a {@link Writeable} can't be re-opened.`  `
+ */
+interface Writable<T> {
+    /**
+     * {@link write} writes a value to the pipe. An error is thrown if writing to a closed {@link Writable}.
+     */
+    write(value: T): undefined;
+    /**
+     * {@link close} signals the closure of the {@link Writeable}, informing the {@link Readable} end that
+     * all data has been transmitted and we've cleanly closed.
+     *
+     * Calling {@link close} multiple times is a no-op.
+     */
+    close(): undefined;
+    /**
+     * {@link isWritable} returns true if it's safe to call {@link write}, which
+     * means that the {@link Writable} hasn't been closed due to {@link close} being called
+     * on this {@link Writable} or the procedure invocation ending for any reason.
+     */
+    isWritable(): boolean;
+}
+
+interface CallOptions {
+    signal?: AbortSignal;
+}
+type RpcFn<Service extends AnyService, ProcName extends keyof Service['procedures']> = (reqInit: ProcInit<Service, ProcName>, options?: CallOptions) => Promise<Result<ProcResponse<Service, ProcName>, ProcErrors<Service, ProcName>>>;
+type UploadFn<Service extends AnyService, ProcName extends keyof Service['procedures']> = (reqInit: ProcInit<Service, ProcName>, options?: CallOptions) => {
+    reqWritable: Writable<ProcRequest<Service, ProcName>>;
+    finalize: () => Promise<Result<ProcResponse<Service, ProcName>, ProcErrors<Service, ProcName>>>;
+};
+type StreamFn<Service extends AnyService, ProcName extends keyof Service['procedures']> = (reqInit: ProcInit<Service, ProcName>, options?: CallOptions) => {
+    reqWritable: Writable<ProcRequest<Service, ProcName>>;
+    resReadable: Readable<ProcResponse<Service, ProcName>, ProcErrors<Service, ProcName>>;
+};
+type SubscriptionFn<Service extends AnyService, ProcName extends keyof Service['procedures']> = (reqInit: ProcInit<Service, ProcName>, options?: CallOptions) => {
+    resReadable: Readable<ProcResponse<Service, ProcName>, ProcErrors<Service, ProcName>>;
+};
+/**
+ * A helper type to transform an actual service type into a type
+ * we can case to in the proxy.
+ * @template Service - The type of the Service.
+ */
+type ServiceClient<Service extends AnyService> = {
+    [ProcName in keyof Service['procedures']]: ProcType<Service, ProcName> extends 'rpc' ? {
+        rpc: RpcFn<Service, ProcName>;
+    } : ProcType<Service, ProcName> extends 'upload' ? {
+        upload: UploadFn<Service, ProcName>;
+    } : ProcType<Service, ProcName> extends 'stream' ? {
+        stream: StreamFn<Service, ProcName>;
+    } : ProcType<Service, ProcName> extends 'subscription' ? {
+        subscribe: SubscriptionFn<Service, ProcName>;
+    } : never;
+};
+/**
+ * Defines a type that represents a client for a server with a set of services.
+ * @template Srv - The type of the server.
+ */
+type Client<Services extends AnyServiceSchemaMap, IS extends InstantiatedServiceSchemaMap<Services> = InstantiatedServiceSchemaMap<Services>> = {
+    [SvcName in keyof IS]: ServiceClient<IS[SvcName]>;
+};
+interface ClientOptions {
+    connectOnInvoke: boolean;
+    eagerlyConnect: boolean;
+}
+/**
+ * Creates a client for a given server using the provided transport.
+ * Note that the client only needs the type of the server, not the actual
+ * server definition itself.
+ *
+ * This relies on a proxy to dynamically create the client, so the client
+ * will be typed as if it were the actual server with the appropriate services
+ * and procedures.
+ *
+ * @template Srv - The type of the server.
+ * @param {Transport} transport - The transport to use for communication.
+ * @param {TransportClientId} serverId - The ID of the server to connect to.
+ * @param {Partial<ClientOptions>} providedClientOptions - The options for the client.
+ * @returns The client for the server.
+ */
+declare function createClient<ServiceSchemaMap extends AnyServiceSchemaMap>(transport: ClientTransport<Connection>, serverId: TransportClientId, providedClientOptions?: Partial<ClientOptions & {
+    handshakeOptions: ClientHandshakeOptions;
+}>): Client<ServiceSchemaMap>;
+
+interface OkResult<T> {
+    ok: true;
+    payload: T;
+}
+interface ErrResult<Err extends Static<BaseErrorSchemaType>> {
+    ok: false;
+    payload: Err;
+}
+type Result<T, Err extends Static<BaseErrorSchemaType>> = OkResult<T> | ErrResult<Err>;
+declare function Ok<const T extends Array<unknown>>(p: T): OkResult<T>;
+declare function Ok<const T extends ReadonlyArray<unknown>>(p: T): OkResult<T>;
+declare function Ok<const T>(payload: T): OkResult<T>;
+declare function Err<const Err extends Static<BaseErrorSchemaType>>(error: Err): ErrResult<Err>;
+/**
+ * Refine a {@link Result} type to its returned payload.
+ */
+type ResultUnwrapOk<R> = R extends Result<infer T, infer __E> ? T : never;
+/**
+ * Refine a {@link Result} type to its error payload.
+ */
+type ResultUnwrapErr<R> = R extends Result<infer __T, infer Err> ? Err : never;
+/**
+ * Retrieve the response type for a procedure, represented as a {@link Result}
+ * type.
+ * Example:
+ * ```
+ * type Message = ResponseData<typeof client, 'serviceName', 'procedureName'>
+ * ```
+ */
+type ResponseData<RiverClient, ServiceName extends keyof RiverClient, ProcedureName extends keyof RiverClient[ServiceName], Procedure = RiverClient[ServiceName][ProcedureName], Fn extends (...args: never) => unknown = (...args: never) => unknown> = RiverClient extends Client<infer __ServiceSchemaMap> ? Procedure extends object ? Procedure extends object & {
+    rpc: infer RpcFn extends Fn;
+} ? Awaited<ReturnType<RpcFn>> : Procedure extends object & {
+    upload: infer UploadFn extends Fn;
+} ? ReturnType<UploadFn> extends {
+    finalize: (...args: never) => Promise<infer UploadOutputMessage>;
+} ? UploadOutputMessage : never : Procedure extends object & {
+    stream: infer StreamFn extends Fn;
+} ? ReturnType<StreamFn> extends {
+    resReadable: Readable<infer StreamOutputMessage, Static<BaseErrorSchemaType>>;
+} ? StreamOutputMessage : never : Procedure extends object & {
+    subscribe: infer SubscriptionFn extends Fn;
+} ? Awaited<ReturnType<SubscriptionFn>> extends {
+    resReadable: Readable<infer SubscriptionOutputMessage, Static<BaseErrorSchemaType>>;
+} ? SubscriptionOutputMessage : never : never : never : never;
+
+/**
+ * ServiceContext exist for the purpose of declaration merging
+ * to extend the context with additional properties.
+ *
+ * For example:
+ *
+ * ```ts
+ * declare module '@replit/river' {
+ *   interface ServiceContext {
+ *     db: Database;
+ *   }
+ * }
+ *
+ * createServer(someTransport, myServices, { extendedContext: { db: myDb } });
+ * ```
+ *
+ * Once you do this, your {@link ProcedureHandlerContext} will have `db` property on it.
+ */
+interface ServiceContext {
+}
+/**
+ * The parsed metadata schema for a service. This is the
+ * return value of the {@link ServerHandshakeOptions.validate}
+ * if the handshake extension is used.
+ *
+ * You should use declaration merging to extend this interface
+ * with the sanitized metadata.
+ *
+ * ```ts
+ * declare module '@replit/river' {
+ *   interface ParsedMetadata {
+ *     userId: number;
+ *   }
+ * }
+ * ```
+ */
+interface ParsedMetadata extends Record<string, unknown> {
+}
+/**
+ * This is passed to every procedure handler and contains various context-level
+ * information and utilities. This may be extended, see {@link ServiceContext}
+ */
+type ProcedureHandlerContext<State> = ServiceContext & {
+    /**
+     * State for this service as defined by the service definition.
+     */
+    state: State;
+    /**
+     * The span for this procedure call. You can use this to add attributes, events, and
+     * links to the span.
+     */
+    span: Span;
+    /**
+     * Metadata parsed on the server. See {@link ParsedMetadata}
+     */
+    metadata: ParsedMetadata;
+    /**
+     * The ID of the session that sent this request.
+     */
+    sessionId: SessionId;
+    /**
+     * The ID of the client that sent this request. There may be multiple sessions per client.
+     */
+    from: TransportClientId;
+    /**
+     * This is used to cancel the procedure call from the handler and notify the client that the
+     * call was cancelled.
+     *
+     * Cancelling is not the same as closing procedure calls gracefully, please refer to
+     * the river documentation to understand the difference between the two concepts.
+     */
+    cancel: (message?: string) => ErrResult<Static<typeof CancelErrorSchema>>;
+    /**
+     * This signal is a standard [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal)
+     * triggered when the procedure invocation is done. This signal tracks the invocation/request finishing
+     * for _any_ reason, for example:
+     * - client explicit cancellation
+     * - procedure handler explicit cancellation via {@link cancel}
+     * - client session disconnect
+     * - server cancellation due to client invalid payload
+     * - invocation finishes cleanly, this depends on the type of the procedure (i.e. rpc handler return, or in a stream after the client-side has closed the request writable and the server-side has closed the response writable)
+     *
+     * You can use this to pass it on to asynchronous operations (such as fetch).
+     *
+     * You may also want to explicitly register callbacks on the
+     * ['abort' event](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/abort_event)
+     * as a way to cleanup after the request is finished.
+     *
+     * Note that (per standard AbortSignals) callbacks registered _after_ the procedure invocation
+     * is done are not triggered. In such cases, you can check the "aborted" property and cleanup
+     * immediately if needed.
+     */
+    signal: AbortSignal;
+};
+
+/**
+ * Brands a type to prevent it from being directly constructed.
+ */
+type Branded<T> = T & {
+    readonly __BRAND_DO_NOT_USE: unique symbol;
+};
+/**
+ * Unbrands a {@link Branded} type.
+ */
+type Unbranded<T> = T extends Branded<infer U> ? U : never;
+/**
+ * The valid {@link Procedure} types. The `stream` and `upload` types can optionally have a
+ * different type for the very first initialization message. The suffixless types correspond to
+ * gRPC's four combinations of stream / non-stream in each direction.
+ */
+type ValidProcType = 'rpc' | 'upload' | 'subscription' | 'stream';
+/**
+ * Represents the payload type for {@link Procedure}s.
+ */
+type PayloadType = TSchema;
+type Cancellable<T> = T | Static<typeof CancelErrorSchema>;
+/**
+ * Procedure for a single message in both directions (1:1).
+ *
+ * @template State - The context state object.
+ * @template RequestInit - The TypeBox schema of the initialization object.
+ * @template ResponseData - The TypeBox schema of the response object.
+ * @template ResponseErr - The TypeBox schema of the error object.
+ */
+interface RpcProcedure<State, RequestInit extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType> {
+    type: 'rpc';
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler(param: {
+        ctx: ProcedureHandlerContext<State>;
+        reqInit: Static<RequestInit>;
+    }): Promise<Result<Static<ResponseData>, Cancellable<Static<ResponseErr>>>>;
+}
+/**
+ * Procedure for a client-stream (potentially preceded by an initialization message),
+ * single message from server (n:1).
+ *
+ * @template State - The context state object.
+ * @template RequestInit - The TypeBox schema of the initialization object.
+ * @template RequestData - The TypeBox schema of the request object.
+ * @template ResponseData - The TypeBox schema of the response object.
+ * @template ResponseErr - The TypeBox schema of the error object.
+ */
+interface UploadProcedure<State, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType> {
+    type: 'upload';
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler(param: {
+        ctx: ProcedureHandlerContext<State>;
+        reqInit: Static<RequestInit>;
+        reqReadable: Readable<Static<RequestData>, Static<typeof ReaderErrorSchema>>;
+    }): Promise<Result<Static<ResponseData>, Cancellable<Static<ResponseErr>>>>;
+}
+/**
+ * Procedure for a single message from client, stream from server (1:n).
+ *
+ * @template State - The context state object.
+ * @template RequestInit - The TypeBox schema of the initialization object.
+ * @template ResponseData - The TypeBox schema of the response object.
+ * @template ResponseErr - The TypeBox schema of the error object.
+ */
+interface SubscriptionProcedure<State, RequestInit extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType> {
+    type: 'subscription';
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler(param: {
+        ctx: ProcedureHandlerContext<State>;
+        reqInit: Static<RequestInit>;
+        resWritable: Writable<Result<Static<ResponseData>, Cancellable<Static<ResponseErr>>>>;
+    }): Promise<void | undefined>;
+}
+/**
+ * Procedure for a bidirectional stream (potentially preceded by an initialization message),
+ * (n:n).
+ *
+ * @template State - The context state object.
+ * @template RequestInit - The TypeBox schema of the initialization object.
+ * @template RequestData - The TypeBox schema of the request object.
+ * @template ResponseData - The TypeBox schema of the response object.
+ * @template ResponseErr - The TypeBox schema of the error object.
+ */
+interface StreamProcedure<State, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType> {
+    type: 'stream';
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler(param: {
+        ctx: ProcedureHandlerContext<State>;
+        reqInit: Static<RequestInit>;
+        reqReadable: Readable<Static<RequestData>, Static<typeof ReaderErrorSchema>>;
+        resWritable: Writable<Result<Static<ResponseData>, Cancellable<Static<ResponseErr>>>>;
+    }): Promise<void | undefined>;
+}
+/**
+ * Represents any {@link Procedure} type.
+ *
+ * @template State - The context state object. You can provide this to constrain
+ *                   the type of procedures.
+ */
+type AnyProcedure<State = object> = Procedure<State, ValidProcType, PayloadType, PayloadType | null, PayloadType, ProcedureErrorSchemaType>;
+/**
+ * Represents a map of {@link Procedure}s.
+ *
+ * @template State - The context state object. You can provide this to constrain
+ *                   the type of procedures.
+ */
+type ProcedureMap<State = object> = Record<string, AnyProcedure<State>>;
+/**
+ * Creates an {@link RpcProcedure}.
+ */
+declare function rpc<State, RequestInit extends PayloadType, ResponseData extends PayloadType>(def: {
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError?: never;
+    description?: string;
+    handler: RpcProcedure<State, RequestInit, ResponseData, TNever>['handler'];
+}): Branded<RpcProcedure<State, RequestInit, ResponseData, TNever>>;
+declare function rpc<State, RequestInit extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType>(def: {
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler: RpcProcedure<State, RequestInit, ResponseData, ResponseErr>['handler'];
+}): Branded<RpcProcedure<State, RequestInit, ResponseData, ResponseErr>>;
+/**
+ * Creates an {@link UploadProcedure}, optionally with an initialization message.
+ */
+declare function upload<State, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType>(def: {
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError?: never;
+    description?: string;
+    handler: UploadProcedure<State, RequestInit, RequestData, ResponseData, TNever>['handler'];
+}): Branded<UploadProcedure<State, RequestInit, RequestData, ResponseData, TNever>>;
+declare function upload<State, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType>(def: {
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler: UploadProcedure<State, RequestInit, RequestData, ResponseData, ResponseErr>['handler'];
+}): Branded<UploadProcedure<State, RequestInit, RequestData, ResponseData, ResponseErr>>;
+/**
+ * Creates a {@link SubscriptionProcedure}.
+ */
+declare function subscription<State, RequestInit extends PayloadType, ResponseData extends PayloadType>(def: {
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError?: never;
+    description?: string;
+    handler: SubscriptionProcedure<State, RequestInit, ResponseData, TNever>['handler'];
+}): Branded<SubscriptionProcedure<State, RequestInit, ResponseData, TNever>>;
+declare function subscription<State, RequestInit extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType>(def: {
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler: SubscriptionProcedure<State, RequestInit, ResponseData, ResponseErr>['handler'];
+}): Branded<SubscriptionProcedure<State, RequestInit, ResponseData, ResponseErr>>;
+/**
+ * Creates a {@link StreamProcedure}, optionally with an initialization message.
+ */
+declare function stream<State, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType>(def: {
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError?: never;
+    description?: string;
+    handler: StreamProcedure<State, RequestInit, RequestData, ResponseData, TNever>['handler'];
+}): Branded<StreamProcedure<State, RequestInit, RequestData, ResponseData, TNever>>;
+declare function stream<State, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType>(def: {
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler: StreamProcedure<State, RequestInit, RequestData, ResponseData, ResponseErr>['handler'];
+}): Branded<StreamProcedure<State, RequestInit, RequestData, ResponseData, ResponseErr>>;
+/**
+ * Defines a Procedure type that can be a:
+ * - {@link RpcProcedure} for a single message in both directions (1:1)
+ * - {@link UploadProcedure} for a client-stream (potentially preceded by an
+ *   initialization message)
+ * - {@link SubscriptionProcedure} for a single message from client, stream from server (1:n)
+ * - {@link StreamProcedure} for a bidirectional stream (potentially preceded by an
+ *    initialization message)
+ *
+ * @template State - The TypeBox schema of the state object.
+ * @template Ty - The type of the procedure.
+ * @template RequestData - The TypeBox schema of the request object.
+ * @template RequestInit - The TypeBox schema of the request initialization object, if any.
+ * @template ResponseData - The TypeBox schema of the response object.
+ */
+type Procedure<State, Ty extends ValidProcType, RequestInit extends PayloadType, RequestData extends PayloadType | null, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType> = {
+    type: Ty;
+} & (RequestData extends PayloadType ? Ty extends 'upload' ? UploadProcedure<State, RequestInit, RequestData, ResponseData, ResponseErr> : Ty extends 'stream' ? StreamProcedure<State, RequestInit, RequestData, ResponseData, ResponseErr> : never : Ty extends 'rpc' ? RpcProcedure<State, RequestInit, ResponseData, ResponseErr> : Ty extends 'subscription' ? SubscriptionProcedure<State, RequestInit, ResponseData, ResponseErr> : never);
+/**
+ * Holds the {@link Procedure} creation functions. Use these to create
+ * procedures for services. You aren't allowed to create procedures directly.
+ */
+declare const Procedure: {
+    rpc: typeof rpc;
+    upload: typeof upload;
+    subscription: typeof subscription;
+    stream: typeof stream;
+};
+
+/**
+ * An instantiated service, probably from a {@link ServiceSchema}.
+ *
+ * You shouldn't construct these directly, use {@link ServiceSchema} instead.
+ */
+interface Service<State extends object, Procs extends ProcedureMap<State>> {
+    readonly state: State;
+    readonly procedures: Procs;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}
+/**
+ * Represents any {@link Service} object.
+ */
+type AnyService = Service<object, ProcedureMap>;
+/**
+ * Represents any {@link ServiceSchema} object.
+ */
+type AnyServiceSchema = ServiceSchema<object, ProcedureMap>;
+/**
+ * A dictionary of {@link ServiceSchema}s, where the key is the service name.
+ */
+type AnyServiceSchemaMap = Record<string, AnyServiceSchema>;
+/**
+ * Takes a {@link AnyServiceSchemaMap} and returns a dictionary of instantiated
+ * services.
+ */
+type InstantiatedServiceSchemaMap<T extends AnyServiceSchemaMap> = {
+    [K in keyof T]: T[K] extends ServiceSchema<infer S, infer P> ? Service<S, P> : never;
+};
+/**
+ * Helper to get the type definition for a specific handler of a procedure in a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcHandler<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['handler'];
+/**
+ * Helper to get the type definition for the procedure init type of a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcInit<S extends AnyService, ProcName extends keyof S['procedures']> = Static<S['procedures'][ProcName]['requestInit']>;
+/**
+ * Helper to get the type definition for the procedure request of a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcRequest<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName] extends {
+    requestData: PayloadType;
+} ? Static<S['procedures'][ProcName]['requestData']> : never;
+/**
+ * Helper to get the type definition for the procedure response of a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcResponse<S extends AnyService, ProcName extends keyof S['procedures']> = Static<S['procedures'][ProcName]['responseData']>;
+/**
+ * Helper to get the type definition for the procedure errors of a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcErrors<S extends AnyService, ProcName extends keyof S['procedures']> = Static<S['procedures'][ProcName]['responseError']> | Static<typeof ReaderErrorSchema>;
+/**
+ * Helper to get the type of procedure in a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcType<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['type'];
+/**
+ * A list of procedures where every procedure is "branded", as-in the procedure
+ * was created via the {@link Procedure} constructors.
+ */
+type BrandedProcedureMap<State> = Record<string, Branded<AnyProcedure<State>>>;
+type MaybeDisposable<State extends object> = State & {
+    [Symbol.asyncDispose]?: () => Promise<void>;
+    [Symbol.dispose]?: () => void;
+};
+/**
+ * The configuration for a service.
+ */
+interface ServiceConfiguration<State extends object> {
+    /**
+     * A factory function for creating a fresh state.
+     */
+    initializeState: (extendedContext: ServiceContext) => MaybeDisposable<State>;
+}
+interface SerializedProcedureSchemaProtocolv1 {
+    init?: PayloadType;
+    input: PayloadType;
+    output: PayloadType;
+    errors?: ProcedureErrorSchemaType;
+    type: 'rpc' | 'subscription' | 'upload' | 'stream';
+}
+interface SerializedServiceSchemaProtocolv1 {
+    procedures: Record<string, SerializedProcedureSchemaProtocolv1>;
+}
+interface SerializedServerSchemaProtocolv1 {
+    handshakeSchema?: TSchema;
+    services: Record<string, SerializedServiceSchemaProtocolv1>;
+}
+/**
+ * Same as {@link serializeSchema} but with a format that is compatible with
+ * protocolv1. This is useful to be able to continue to generate schemas for older
+ * clients as they are still supported.
+ */
+declare function serializeSchemaV1Compat(services: AnyServiceSchemaMap, handshakeSchema?: TSchema): SerializedServerSchemaProtocolv1;
+interface SerializedProcedureSchema {
+    init: PayloadType;
+    input?: PayloadType;
+    output: PayloadType;
+    errors?: ProcedureErrorSchemaType;
+    type: 'rpc' | 'subscription' | 'upload' | 'stream';
+}
+interface SerializedServiceSchema {
+    procedures: Record<string, SerializedProcedureSchema>;
+}
+interface SerializedServerSchema {
+    handshakeSchema?: TSchema;
+    services: Record<string, SerializedServiceSchema>;
+}
+/**
+ * Serializes a server schema into a plain object that is JSON compatible.
+ */
+declare function serializeSchema(services: AnyServiceSchemaMap, handshakeSchema?: TSchema): SerializedServerSchema;
+/**
+ * The schema for a {@link Service}. This is used to define a service, specifically
+ * its initial state and procedures.
+ *
+ * There are two ways to define a service:
+ * 1. the {@link ServiceSchema.define} static method, which takes a configuration and
+ *    a list of procedures directly. Use this to ergonomically define a service schema
+ *    in one go. Good for smaller services, especially if they're stateless.
+ * 2. the {@link ServiceSchema.scaffold} static method, which creates a scaffold that
+ *    can be used to define procedures separately from the configuration. Use this to
+ *    better organize your service's definition, especially if it's a large service.
+ *    You can also use it in a builder pattern to define the service in a more
+ *    fluent way.
+ *
+ * See the static methods for more information and examples.
+ *
+ * When defining procedures, use the {@link Procedure} constructors to create them.
+ */
+declare class ServiceSchema<State extends object, Procedures extends ProcedureMap<State>> {
+    /**
+     * Factory function for creating a fresh state.
+     */
+    protected readonly initializeState: (extendedContext: ServiceContext) => MaybeDisposable<State>;
+    /**
+     * The procedures for this service.
+     */
+    readonly procedures: Procedures;
+    /**
+     * @param config - The configuration for this service.
+     * @param procedures - The procedures for this service.
+     */
+    protected constructor(config: ServiceConfiguration<State>, procedures: Procedures);
+    /**
+     * Creates a {@link ServiceScaffold}, which can be used to define procedures
+     * that can then be merged into a {@link ServiceSchema}, via the scaffold's
+     * `finalize` method.
+     *
+     * There are two patterns that work well with this method. The first is using
+     * it to separate the definition of procedures from the definition of the
+     * service's configuration:
+     * ```ts
+     * const MyServiceScaffold = ServiceSchema.scaffold({
+     *   initializeState: () => ({ count: 0 }),
+     * });
+     *
+     * const incrementProcedures = MyServiceScaffold.procedures({
+     *   increment: Procedure.rpc({
+     *     requestInit: Type.Object({ amount: Type.Number() }),
+     *     responseData: Type.Object({ current: Type.Number() }),
+     *     async handler(ctx, init) {
+     *       ctx.state.count += init.amount;
+     *       return Ok({ current: ctx.state.count });
+     *     }
+     *   }),
+     * })
+     *
+     * const MyService = MyServiceScaffold.finalize({
+     *   ...incrementProcedures,
+     *   // you can also directly define procedures here
+     * });
+     * ```
+     * This might be really handy if you have a very large service and you're
+     * wanting to split it over multiple files. You can define the scaffold
+     * in one file, and then import that scaffold in other files where you
+     * define procedures - and then finally import the scaffolds and your
+     * procedure objects in a final file where you finalize the scaffold into
+     * a service schema.
+     *
+     * The other way is to use it like in a builder pattern:
+     * ```ts
+     * const MyService = ServiceSchema
+     *   .scaffold({ initializeState: () => ({ count: 0 }) })
+     *   .finalize({
+     *     increment: Procedure.rpc({
+     *       requestInit: Type.Object({ amount: Type.Number() }),
+     *       responseData: Type.Object({ current: Type.Number() }),
+     *       async handler(ctx, init) {
+     *         ctx.state.count += init.amount;
+     *         return Ok({ current: ctx.state.count });
+     *       }
+     *     }),
+     *   })
+     * ```
+     * Depending on your preferences, this may be a more appealing way to define
+     * a schema versus using the {@link ServiceSchema.define} method.
+     */
+    static scaffold<State extends object>(config: ServiceConfiguration<State>): ServiceScaffold<State>;
+    /**
+     * Creates a new {@link ServiceSchema} with the given configuration and procedures.
+     *
+     * All procedures must be created with the {@link Procedure} constructors.
+     *
+     * NOTE: There is an overload that lets you just provide the procedures alone if your
+     * service has no state.
+     *
+     * @param config - The configuration for this service.
+     * @param procedures - The procedures for this service.
+     *
+     * @example
+     * ```
+     * const service = ServiceSchema.define(
+     *   { initializeState: () => ({ count: 0 }) },
+     *   {
+     *     increment: Procedure.rpc({
+     *       requestInit: Type.Object({ amount: Type.Number() }),
+     *       responseData: Type.Object({ current: Type.Number() }),
+     *       async handler(ctx, init) {
+     *         ctx.state.count += init.amount;
+     *         return Ok({ current: ctx.state.count });
+     *       }
+     *     }),
+     *   },
+     * );
+     * ```
+     */
+    static define<State extends object, Procedures extends BrandedProcedureMap<State>>(config: ServiceConfiguration<State>, procedures: Procedures): ServiceSchema<State, {
+        [K in keyof Procedures]: Unbranded<Procedures[K]>;
+    }>;
+    /**
+     * Creates a new {@link ServiceSchema} with the given procedures.
+     *
+     * All procedures must be created with the {@link Procedure} constructors.
+     *
+     * NOTE: There is an overload that lets you provide configuration as well,
+     * if your service has extra configuration like a state.
+     *
+     * @param procedures - The procedures for this service.
+     *
+     * @example
+     * ```
+     * const service = ServiceSchema.define({
+     *   add: Procedure.rpc({
+     *     requestInit: Type.Object({ a: Type.Number(), b: Type.Number() }),
+     *     responseData: Type.Object({ result: Type.Number() }),
+     *     async handler(ctx, init) {
+     *       return Ok({ result: init.a + init.b });
+     *     }
+     *   }),
+     * });
+     */
+    static define<Procedures extends BrandedProcedureMap<Record<string, never>>>(procedures: Procedures): ServiceSchema<Record<string, never>, {
+        [K in keyof Procedures]: Unbranded<Procedures[K]>;
+    }>;
+    /**
+     * Serializes this schema's procedures into a plain object that is JSON compatible.
+     */
+    serialize(): SerializedServiceSchema;
+    /**
+     * Same as {@link ServiceSchema.serialize}, but with a format that is compatible with
+     * protocol v1. This is useful to be able to continue to generate schemas for older
+     * clients as they are still supported.
+     */
+    serializeV1Compat(): SerializedServiceSchemaProtocolv1;
+    /**
+     * Instantiates this schema into a {@link Service} object.
+     *
+     * You probably don't need this, usually the River server will handle this
+     * for you.
+     */
+    instantiate(extendedContext: ServiceContext): Service<State, Procedures>;
+}
+/**
+ * A scaffold for defining a service's procedures.
+ *
+ * @see {@link ServiceSchema.scaffold}
+ */
+declare class ServiceScaffold<State extends object> {
+    /**
+     * The configuration for this service.
+     */
+    protected readonly config: ServiceConfiguration<State>;
+    /**
+     * @param config - The configuration for this service.
+     */
+    constructor(config: ServiceConfiguration<State>);
+    /**
+     * Define procedures for this service. Use the {@link Procedure} constructors
+     * to create them. This returns the procedures object, which can then be
+     * passed to {@link ServiceSchema.finalize} to create a {@link ServiceSchema}.
+     *
+     * @example
+     * ```
+     * const myProcedures = MyServiceScaffold.procedures({
+     *   myRPC: Procedure.rpc({
+     *     // ...
+     *   }),
+     * });
+     *
+     * const MyService = MyServiceScaffold.finalize({
+     *   ...myProcedures,
+     * });
+     * ```
+     *
+     * @param procedures - The procedures for this service.
+     */
+    procedures<T extends BrandedProcedureMap<State>>(procedures: T): T;
+    /**
+     * Finalizes the scaffold into a {@link ServiceSchema}. This is where you
+     * provide the service's procedures and get a {@link ServiceSchema} in return.
+     *
+     * You can directly define procedures here, or you can define them separately
+     * with the {@link ServiceScaffold.procedures} method, and then pass them here.
+     *
+     * @example
+     * ```
+     * const MyService = MyServiceScaffold.finalize({
+     *  myRPC: Procedure.rpc({
+     *   // ...
+     *  }),
+     *  // e.g. from the procedures method
+     *  ...myOtherProcedures,
+     * });
+     * ```
+     */
+    finalize<T extends BrandedProcedureMap<State>>(procedures: T): ServiceSchema<State, {
+        [K in keyof T]: Unbranded<T[K]>;
+    }>;
+}
+
+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 };