@replit/river 0.200.0-rc.9 → 0.200.2

package/dist/{services-1b5ac5bc.d.ts → services-259f39a3.d.ts}

@@ -1,159 +1,193 @@
-import * as _sinclair_typebox from '@sinclair/typebox';
-import { Static, TObject, TUnion, TString, TSchema, TLiteral, TNever } from '@sinclair/typebox';
-import { C as Connection, p as ClientHandshakeOptions, u as ProcedureHandlerContext, o as ServiceContext } from './context-b4aff18f.js';
-import { c as TransportClientId } from './message-7d135e38.js';
-import { C as ClientTransport } from './client-22a47343.js';
+import { TObject, TString, TSchema, TUnion, TLiteral, TNever, Static } from '@sinclair/typebox';
+import { C as Connection, q as ClientHandshakeOptions, v as ProcedureHandlerContext, p as ServiceContext } from './context-69f37ac1.js';
+import { c as TransportClientId } from './message-57bb8187.js';
+import { C as ClientTransport } from './client-9292552a.js';
 
-declare const StreamDrainedError: {
-    readonly code: "STREAM_DRAINED";
-    readonly message: "Stream was drained";
-};
-type ReadStreamResult<T, E extends Static<BaseErrorSchemaType>> = Result<T, E | typeof StreamDrainedError>;
 /**
- * Using simple iterator here to lock down the iteration and disallow
- * `return` and `throw` to be called from the outside.
+ * {@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.
  */
-interface SimpleIterator<T> {
+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;
+}>;
+/**
+ * {@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;
+}>, 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: Static<BaseErrorSchemaType>;
+/**
+ * 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: T;
+        value: ReadableResult<T, E>;
     } | {
         done: true;
         value: undefined;
     }>;
 }
 /**
- * A `ReadStream` represents a stream of data.
+ * A {@link Readable} is an abstraction from which data is consumed from {@link Writable} source.
  *
- * This stream is not closable by the reader, the reader must wait for
- * the writer to close it.
+ * - 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.
  *
- * The stream can only be locked (aka consumed) once and will remain
- * locked, trying to lock the stream again will throw an TypeError.
+ * 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 ReadStream<T, E extends Static<BaseErrorSchemaType>> {
-    /**
-     * Stream implements AsyncIterator API and can be consumed via
-     * for-await-of loops. Iteration locks the stream
-     *
-     */
-    [Symbol.asyncIterator](): SimpleIterator<ReadStreamResult<T, E>>;
-    /**
-     * `unwrappedIter` returns an AsyncIterator that will unwrap the results coming
-     * into the stream, yielding the payload if successful, otherwise throwing.
-     * We generally recommend using the normal iterator instead of this method,
-     * and handling errors explicitly.
-     */
-    unwrappedIter(): {
-        [Symbol.asyncIterator](): SimpleIterator<T>;
-    };
-    /**
-     * `asArray` locks the stream and returns a promise that resolves
-     * with an array of the stream's content when the stream is closed.
-     *
-     */
-    asArray(): Promise<Array<ReadStreamResult<T, E>>>;
-    /**
-     * `drain` locks the stream and discards any existing or future data.
-     *
-     * If there is an existing Promise waiting for the next value,
-     * `drain` causes it to resolve with a {@link StreamDrainedError} error.
-     */
-    drain(): undefined;
-    /**
-     * `isLocked` returns true if the stream is locked.
-     */
-    isLocked(): boolean;
+interface Readable<T, E extends Static<BaseErrorSchemaType>> {
     /**
-     * `onClose` registers a callback that will be called when the stream
-     * is closed. Returns a function that can be used to unregister the
-     * listener.
+     * {@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}.
      */
-    onClose(cb: () => void): () => void;
+    [Symbol.asyncIterator](): ReadableIterator<T, E>;
     /**
-     * `isClosed` returns true if the stream was closed by the writer.
-     *
-     * Note that the stream can still have queued data and can still be
-     * consumed.
+     * {@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.
      */
-    isClosed(): boolean;
+    collect(): Promise<Array<ReadableResult<T, E>>>;
     /**
-     * `requestClose` sends a request to the writer to close the stream,
-     * and resolves the writer closes its end of the stream..
+     * {@link break} locks the {@link Readable} and discards any existing or future incoming data.
      *
-     * The stream can still receive more data after the request is sent. If you
-     * no longer wish to use the stream, make sure to call `drain`.
+     * If there is an existing reader waiting for the next value, {@link break} causes it to
+     * resolve with a {@link ReadableBrokenError} error.
      */
-    requestClose(): Promise<undefined>;
+    break(): undefined;
     /**
-     * `isCloseRequested` checks if the reader has requested to close the stream.
+     * {@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}.
      */
-    isCloseRequested(): boolean;
+    isReadable(): boolean;
 }
 /**
- * A `WriteStream` is a streams that can be written to.
+ * 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 WriteStream<T> {
+interface Writable<T> {
     /**
-     * `write` writes a value to the stream. An error is thrown if writing to a closed stream.
+     * {@link write} writes a value to the pipe. An error is thrown if writing to a closed {@link Writable}.
      */
     write(value: T): undefined;
     /**
-     * `close` signals the closure of the write stream, informing the reader that the stream is complete.
-     * Calling close multiple times has no effect.
+     * {@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;
     /**
-     * `isCloseRequested` checks if the reader has requested to close the stream.
-     */
-    isCloseRequested(): boolean;
-    /**
-     * `onCloseRequest` registers a callback that will be called when the stream's
-     * reader requests a close. Returns a function that can be used to unregister the
-     * listener.
+     * {@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.
      */
-    onCloseRequest(cb: () => void): () => void;
-    /**
-     * `isClosed` returns true if the stream was closed by the writer.
-     */
-    isClosed(): boolean;
-    /**
-     * `onClose` registers a callback that will be called when the stream
-     * is closed. Returns a function that can be used to unregister the
-     * listener.
-     */
-    onClose(cb: () => void): () => void;
+    isWritable(): boolean;
 }
 
 interface CallOptions {
     signal?: AbortSignal;
 }
-type RpcFn<Router extends AnyService, ProcName extends keyof Router['procedures']> = (reqInit: ProcInit<Router, ProcName>, options?: CallOptions) => Promise<Result<ProcOutput<Router, ProcName>, ProcErrors<Router, ProcName>>>;
-type UploadFn<Router extends AnyService, ProcName extends keyof Router['procedures']> = (reqInit: ProcInit<Router, ProcName>, options?: CallOptions) => {
-    reqWriter: WriteStream<ProcInput<Router, ProcName>>;
-    finalize: () => Promise<Result<ProcOutput<Router, ProcName>, ProcErrors<Router, ProcName>>>;
+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<Router extends AnyService, ProcName extends keyof Router['procedures']> = (reqInit: ProcInit<Router, ProcName>, options?: CallOptions) => {
-    reqWriter: WriteStream<ProcInput<Router, ProcName>>;
-    resReader: ReadStream<ProcOutput<Router, ProcName>, ProcErrors<Router, 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<Router extends AnyService, ProcName extends keyof Router['procedures']> = (reqInit: ProcInit<Router, ProcName>, options?: CallOptions) => {
-    resReader: ReadStream<ProcOutput<Router, ProcName>, ProcErrors<Router, 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 Router - The type of the Router.
- */
-type ServiceClient<Router extends AnyService> = {
-    [ProcName in keyof Router['procedures']]: ProcType<Router, ProcName> extends 'rpc' ? {
-        rpc: RpcFn<Router, ProcName>;
-    } : ProcType<Router, ProcName> extends 'upload' ? {
-        upload: UploadFn<Router, ProcName>;
-    } : ProcType<Router, ProcName> extends 'stream' ? {
-        stream: StreamFn<Router, ProcName>;
-    } : ProcType<Router, ProcName> extends 'subscription' ? {
-        subscribe: SubscriptionFn<Router, ProcName>;
+ * @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;
 };
 /**
@@ -186,15 +220,6 @@ declare function createClient<ServiceSchemaMap extends AnyServiceSchemaMap>(tran
     handshakeOptions: ClientHandshakeOptions;
 }>): Client<ServiceSchemaMap>;
 
-type TLiteralString = TLiteral<string>;
-type BaseErrorSchemaType = TObject<{
-    code: TLiteralString | TUnion<Array<TLiteralString>>;
-    message: TLiteralString | TString;
-}> | TObject<{
-    code: TLiteralString | TUnion<Array<TLiteralString>>;
-    message: TLiteralString | TString;
-    extras: TSchema;
-}>;
 interface OkResult<T> {
     ok: true;
     payload: T;
@@ -212,19 +237,26 @@ declare function Err<const Err extends Static<BaseErrorSchemaType>>(error: Err):
  * Refine a {@link Result} type to its returned payload.
  */
 type ResultUnwrapOk<R> = R extends Result<infer T, infer __E> ? T : never;
+/**
+ * Unwrap a {@link Result} type and return the payload if successful,
+ * otherwise throws an error.
+ * @param result - The result to unwrap.
+ * @throws Will throw an error if the result is not ok.
+ */
+declare function unwrapOrThrow<T, Err extends Static<BaseErrorSchemaType>>(result: Result<T, Err>): T;
 /**
  * Refine a {@link Result} type to its error payload.
  */
 type ResultUnwrapErr<R> = R extends Result<infer __T, infer Err> ? Err : never;
 /**
- * Retrieve the output type for a procedure, represented as a {@link Result}
+ * Retrieve the response type for a procedure, represented as a {@link Result}
  * type.
  * Example:
  * ```
- * type Message = Output<typeof client, 'serviceName', 'procedureName'>
+ * type Message = ResponseData<typeof client, 'serviceName', 'procedureName'>
  * ```
  */
-type Output<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 & {
+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;
@@ -233,11 +265,11 @@ type Output<RiverClient, ServiceName extends keyof RiverClient, ProcedureName ex
 } ? UploadOutputMessage : never : Procedure extends object & {
     stream: infer StreamFn extends Fn;
 } ? ReturnType<StreamFn> extends {
-    resReader: ReadStream<infer StreamOutputMessage, Static<BaseErrorSchemaType>>;
+    resReadable: Readable<infer StreamOutputMessage, Static<BaseErrorSchemaType>>;
 } ? StreamOutputMessage : never : Procedure extends object & {
     subscribe: infer SubscriptionFn extends Fn;
 } ? Awaited<ReturnType<SubscriptionFn>> extends {
-    resReader: ReadStream<infer SubscriptionOutputMessage, Static<BaseErrorSchemaType>>;
+    resReadable: Readable<infer SubscriptionOutputMessage, Static<BaseErrorSchemaType>>;
 } ? SubscriptionOutputMessage : never : never : never : never;
 
 /**
@@ -260,57 +292,12 @@ type ValidProcType = 'rpc' | 'upload' | 'subscription' | 'stream';
  * Represents the payload type for {@link Procedure}s.
  */
 type PayloadType = TSchema;
-/**
- * INTERNAL_RIVER_ERROR_CODE is the code that is used when an internal error occurs,
- * this means that some invariants expected by the river server implementation have
- * been violated. When encountering this error please report this to river maintainers.
- */
-declare const INTERNAL_RIVER_ERROR_CODE: "INTERNAL_RIVER_ERROR";
-/**
- * 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";
-/**
- * UNEXPECTED_DISCONNECT_CODE is the code used the stream's session
- * disconnect unexpetedly.
- */
-declare const UNEXPECTED_DISCONNECT_CODE: "UNEXPECTED_DISCONNECT";
-/**
- * INVALID_REQUEST_CODE is the code used when a client's request is invalid.
- */
-declare const INVALID_REQUEST_CODE: "INVALID_REQUEST";
-/**
- * ABORT_CODE is the code used when either server or client aborts the stream.
- */
-declare const ABORT_CODE: "ABORT";
-/**
- * ResponseReaderErrorSchema is the schema for all the errors that can be
- * emitted in the ResponseData ReadStream on the client.
- */
-declare const ResponseReaderErrorSchema: _sinclair_typebox.TObject<{
-    code: TUnion<[_sinclair_typebox.TLiteral<"INTERNAL_RIVER_ERROR">, _sinclair_typebox.TLiteral<"UNCAUGHT_ERROR">, _sinclair_typebox.TLiteral<"UNEXPECTED_DISCONNECT">, _sinclair_typebox.TLiteral<"INVALID_REQUEST">, _sinclair_typebox.TLiteral<"ABORT">]>;
-    message: _sinclair_typebox.TString;
-}>;
-/**
- * RequestReaderErrorSchema is the schema for all the errors that can be
- * emitted in the RequestData ReadStream on the server.
- */
-declare const RequestReaderErrorSchema: _sinclair_typebox.TObject<{
-    code: TUnion<[_sinclair_typebox.TLiteral<"UNCAUGHT_ERROR">, _sinclair_typebox.TLiteral<"UNEXPECTED_DISCONNECT">, _sinclair_typebox.TLiteral<"INVALID_REQUEST">, _sinclair_typebox.TLiteral<"ABORT">]>;
-    message: _sinclair_typebox.TString;
-}>;
-/**
- * Represents an acceptable schema to pass to a procedure.
- * Just a type of a schema, not an actual schema.
- */
-type ProcedureErrorSchemaType = TUnion<Array<BaseErrorSchemaType>> | BaseErrorSchemaType | TNever;
 /**
  * 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 output 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> {
@@ -319,7 +306,7 @@ interface RpcProcedure<State, RequestInit extends PayloadType, ResponseData exte
     responseData: ResponseData;
     responseError: ResponseErr;
     description?: string;
-    handler({ ctx, reqInit, }: {
+    handler(param: {
         ctx: ProcedureHandlerContext<State>;
         reqInit: Static<RequestInit>;
     }): Promise<Result<Static<ResponseData>, Static<ResponseErr>>>;
@@ -330,8 +317,8 @@ interface RpcProcedure<State, RequestInit extends PayloadType, ResponseData exte
  *
  * @template State - The context state object.
  * @template RequestInit - The TypeBox schema of the initialization object.
- * @template RequestData - The TypeBox schema of the input object.
- * @template ResponseData - The TypeBox schema of the output 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> {
@@ -341,10 +328,10 @@ interface UploadProcedure<State, RequestInit extends PayloadType, RequestData ex
     responseData: ResponseData;
     responseError: ResponseErr;
     description?: string;
-    handler({ ctx, reqInit, reqReader, }: {
+    handler(param: {
         ctx: ProcedureHandlerContext<State>;
         reqInit: Static<RequestInit>;
-        reqReader: ReadStream<Static<RequestData>, Static<typeof RequestReaderErrorSchema>>;
+        reqReadable: Readable<Static<RequestData>, Static<typeof ReaderErrorSchema>>;
     }): Promise<Result<Static<ResponseData>, Static<ResponseErr>>>;
 }
 /**
@@ -352,7 +339,7 @@ interface UploadProcedure<State, RequestInit extends PayloadType, RequestData ex
  *
  * @template State - The context state object.
  * @template RequestInit - The TypeBox schema of the initialization object.
- * @template ResponseData - The TypeBox schema of the output 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> {
@@ -361,10 +348,10 @@ interface SubscriptionProcedure<State, RequestInit extends PayloadType, Response
     responseData: ResponseData;
     responseError: ResponseErr;
     description?: string;
-    handler({ ctx, reqInit, resWriter, }: {
+    handler(param: {
         ctx: ProcedureHandlerContext<State>;
         reqInit: Static<RequestInit>;
-        resWriter: WriteStream<Result<Static<ResponseData>, Static<ResponseErr>>>;
+        resWritable: Writable<Result<Static<ResponseData>, Static<ResponseErr>>>;
     }): Promise<void | undefined>;
 }
 /**
@@ -373,8 +360,8 @@ interface SubscriptionProcedure<State, RequestInit extends PayloadType, Response
  *
  * @template State - The context state object.
  * @template RequestInit - The TypeBox schema of the initialization object.
- * @template RequestData - The TypeBox schema of the input object.
- * @template ResponseData - The TypeBox schema of the output 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> {
@@ -384,11 +371,11 @@ interface StreamProcedure<State, RequestInit extends PayloadType, RequestData ex
     responseData: ResponseData;
     responseError: ResponseErr;
     description?: string;
-    handler({ ctx, reqInit, reqReader, resWriter, }: {
+    handler(param: {
         ctx: ProcedureHandlerContext<State>;
         reqInit: Static<RequestInit>;
-        reqReader: ReadStream<Static<RequestData>, Static<typeof RequestReaderErrorSchema>>;
-        resWriter: WriteStream<Result<Static<ResponseData>, Static<ResponseErr>>>;
+        reqReadable: Readable<Static<RequestData>, Static<typeof ReaderErrorSchema>>;
+        resWritable: Writable<Result<Static<ResponseData>, Static<ResponseErr>>>;
     }): Promise<void | undefined>;
 }
 /**
@@ -488,9 +475,9 @@ declare function stream<State, RequestInit extends PayloadType, RequestData exte
  *
  * @template State - The TypeBox schema of the state object.
  * @template Ty - The type of the procedure.
- * @template RequestData - The TypeBox schema of the input object.
- * @template RequestInit - The TypeBox schema of the input initialization object, if any.
- * @template ResponseData - The TypeBox schema of the output object.
+ * @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;
@@ -547,25 +534,25 @@ type ProcHandler<S extends AnyService, ProcName extends keyof S['procedures']> =
  */
 type ProcInit<S extends AnyService, ProcName extends keyof S['procedures']> = Static<S['procedures'][ProcName]['requestInit']>;
 /**
- * Helper to get the type definition for the procedure input of a service.
+ * 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 ProcInput<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName] extends {
+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 output of a service.
+ * 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 ProcOutput<S extends AnyService, ProcName extends keyof S['procedures']> = Static<S['procedures'][ProcName]['responseData']>;
+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 ResponseReaderErrorSchema>;
+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.
@@ -596,6 +583,16 @@ interface SerializedProcedureSchemaProtocolv1 {
 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;
@@ -766,7 +763,7 @@ declare class ServiceSchema<State extends object, Procedures extends ProcedureMa
      * protocol v1. This is useful to be able to continue to generate schemas for older
      * clients as they are still supported.
      */
-    serializeBackwardsCompatible(): SerializedServiceSchemaProtocolv1;
+    serializeV1Compat(): SerializedServiceSchemaProtocolv1;
     /**
      * Instantiates this schema into a {@link Service} object.
      *
@@ -833,4 +830,4 @@ declare class ServiceScaffold<State extends object> {
     }>;
 }
 
-export { AnyServiceSchemaMap as A, BaseErrorSchemaType as B, RequestReaderErrorSchema as C, createClient as D, ErrResult as E, Client as F, Ok as G, Err as H, InstantiatedServiceSchemaMap as I, ResultUnwrapOk as J, ResultUnwrapErr as K, Output as L, OkResult as O, PayloadType as P, ReadStream as R, SimpleIterator as S, UploadProcedure as U, ValidProcType as V, WriteStream as W, ProcedureErrorSchemaType as a, Procedure as b, Result as c, ResponseReaderErrorSchema as d, Service as e, ServiceConfiguration as f, ProcHandler as g, ProcInit as h, ProcInput as i, ProcOutput as j, ProcErrors as k, ProcType as l, ServiceSchema as m, SerializedServerSchema as n, SerializedServiceSchema as o, SerializedProcedureSchema as p, ProcedureMap as q, RpcProcedure as r, serializeSchema as s, SubscriptionProcedure as t, StreamProcedure as u, INTERNAL_RIVER_ERROR_CODE as v, UNCAUGHT_ERROR_CODE as w, UNEXPECTED_DISCONNECT_CODE as x, INVALID_REQUEST_CODE as y, ABORT_CODE as z };
+export { AnyServiceSchemaMap as A, BaseErrorSchemaType as B, StreamProcedure as C, flattenErrorType as D, UNCAUGHT_ERROR_CODE as E, UNEXPECTED_DISCONNECT_CODE as F, INVALID_REQUEST_CODE as G, CANCEL_CODE as H, InstantiatedServiceSchemaMap as I, createClient as J, Client as K, Err as L, unwrapOrThrow as M, ErrResult as N, Ok as O, PayloadType as P, OkResult as Q, Readable as R, Service as S, ResultUnwrapOk as T, UploadProcedure as U, ValidProcType as V, Writable as W, ResultUnwrapErr as X, ResponseData as Y, ReadableIterator as a, ReadableResult as b, ProcedureErrorSchemaType as c, Procedure as d, Result as e, ReaderErrorSchema as f, AnyProcedure as g, ServiceConfiguration as h, ProcHandler as i, ProcInit as j, ProcRequest as k, ProcResponse as l, ProcErrors as m, ProcType as n, ServiceSchema as o, SerializedServerSchema as p, SerializedServiceSchema as q, SerializedProcedureSchema as r, serializeSchema as s, serializeSchemaV1Compat as t, SerializedServerSchemaProtocolv1 as u, SerializedServiceSchemaProtocolv1 as v, SerializedProcedureSchemaProtocolv1 as w, ProcedureMap as x, RpcProcedure as y, SubscriptionProcedure as z };