@orpc/server 2.0.0-beta.5 → 2.0.0-beta.50

package/dist/plugins/request-limit.js

@@ -0,0 +1,61 @@
+import { toArray } from "@orpc/shared";
+import { ORPCError } from "@orpc/client";
+import { flattenStandardHeader } from "@standard-server/core";
+import { toFetchHeaders, toStandardBody } from "@standard-server/fetch";
+// src/plugins/request-limit.ts
+/**
+* Rejects requests whose body exceeds `maxBodySize`.
+*
+* When used with the request compression plugin, the limit applies to the
+* decompressed payload rather than the compressed wire size.
+*
+* @see {@link https://orpc.dev/docs/plugins/request-limit | Request Limit Plugin}
+*/
+var RequestLimitHandlerPlugin = class {
+	name = "~request-limit";
+	/**
+	* Should limit the original batch request body instead of sub-requests.
+	*/
+	after = ["~batch"];
+	/**
+	* Should limit the final body size instead of the compressed one.
+	*/
+	before = ["~request-compression"];
+	maxBodySize;
+	constructor(options) {
+		this.maxBodySize = options.maxBodySize;
+	}
+	init(options) {
+		const maxBodySize = this.maxBodySize;
+		const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+			return next({
+				...interceptorOptions,
+				request: {
+					...interceptorOptions.request,
+					async resolveBody(hint) {
+						const contentLength = Number(flattenStandardHeader(interceptorOptions.request.headers["content-length"]));
+						if (Number.isFinite(contentLength) && contentLength > maxBodySize) throw new ORPCError("PAYLOAD_TOO_LARGE");
+						const stream = await interceptorOptions.request.resolveBody("octet-stream");
+						if (!(stream instanceof ReadableStream)) return stream;
+						let currentBodySize = 0;
+						const limitedStream = stream.pipeThrough(new TransformStream({ transform(chunk, controller) {
+							currentBodySize += chunk.byteLength;
+							if (currentBodySize > maxBodySize) {
+								controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+								return;
+							}
+							controller.enqueue(chunk);
+						} }));
+						const response = new Response(limitedStream, { headers: toFetchHeaders(interceptorOptions.request.headers) });
+						return toStandardBody(response, { hint });
+					}
+				}
+			});
+		};
+		return {
+			...options,
+			routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)]
+		};
+	}
+};
+export { RequestLimitHandlerPlugin };

package/dist/plugins/response-compression.d.ts

@@ -0,0 +1,62 @@
+import "../adapters/standard/index.js";
+import { StandardHandlerPlugin } from "../adapters/standard/plugin.js";
+import { StandardHandlerOptions, StandardHandlerRoutingInterceptorOptions } from "../adapters/standard/handler.js";
+import { Context } from "../context.js";
+import { CompressionEncoding } from "@orpc/shared";
+import { StandardHeaders, StandardResponse } from "@standard-server/core";
+export interface ResponseCompressionHandlerPluginOptions<T extends Context> {
+  /**
+   * The compression schemes to use for response compression.
+   * Schemes are prioritized by their order in this array and
+   * only applied if the client supports them (via Accept-Encoding).
+   *
+   * @default ['gzip', 'deflate']
+   */
+  encodings?: readonly CompressionEncoding[] | undefined;
+  /**
+   * The minimum response size in bytes required to trigger compression.
+   * Responses smaller than this threshold will not be compressed to avoid overhead.
+   * If the response size cannot be determined, compression will still be applied.
+   *
+   * @default 1024 (1KB)
+   */
+  threshold?: number | undefined;
+  /**
+   * Determines whether a response with the given Content-Type should be compressed.
+   * Only consulted for binary transfers (streams, files, and file form-data parts).
+   * Also receives the routing interceptor options for per-request decisions.
+   *
+   * @default isCompressibleContentType (covers common text-based formats)
+   */
+  isCompressibleContentType?: ((contentType: string | null | undefined, options: StandardHandlerRoutingInterceptorOptions<T>) => boolean) | undefined;
+}
+/**
+ * Compresses response bodies based on the client's Accept-Encoding header.
+ * Works at the standard handler level, so it supports all adapters.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/response-compression | Response Compression Plugin}
+ */
+export declare class ResponseCompressionHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+  name: string;
+  /**
+   * Compression should be done after batching, to compress the final response.
+   * Compression should also be done after response headers are set, to access final headers like Content-Type and Cache-Control.
+   */
+  after: string[];
+  private readonly encodings;
+  private readonly threshold;
+  private readonly isCompressibleContentType;
+  constructor(options?: ResponseCompressionHandlerPluginOptions<T>);
+  init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+/**
+ * Picks the first of `encodings` the client accepts, or `undefined` when the response
+ * must be sent as is because it is already encoded, partial, or forbids transforms.
+ * Shared by the response compression plugins so they agree on when to compress.
+ */
+export declare function negotiateResponseCompressionEncoding<TEncoding extends string>(response: StandardResponse, requestHeaders: StandardHeaders, encodings: readonly TEncoding[]): TEncoding | undefined;
+/**
+ * The headers of a response whose body is compressed with `encoding`.
+ * Shared by the response compression plugins so compressed responses carry the same headers.
+ */
+export declare function toCompressedHeaders(headers: StandardHeaders, encoding: string): StandardHeaders;

package/dist/plugins/response-compression.js

@@ -0,0 +1,157 @@
+import { estimateCompressibleFormDataSize, estimateUtf8ByteLength, isAcceptableEncoding, isAsyncIteratorObject, isCompressibleContentType, isNoTransformCacheControl, parseAcceptEncodingQualities, toArray, varyByAcceptEncoding } from "@orpc/shared";
+import { flattenStandardHeader, generateContentDisposition } from "@standard-server/core";
+import { toFetchBody } from "@standard-server/fetch";
+// src/plugins/response-compression.ts
+/**
+* Compresses response bodies based on the client's Accept-Encoding header.
+* Works at the standard handler level, so it supports all adapters.
+*
+* @see {@link https://orpc.dev/docs/plugins/response-compression | Response Compression Plugin}
+*/
+var ResponseCompressionHandlerPlugin = class {
+	name = "~response-compression";
+	/**
+	* Compression should be done after batching, to compress the final response.
+	* Compression should also be done after response headers are set, to access final headers like Content-Type and Cache-Control.
+	*/
+	after = ["~batch", "~response-headers"];
+	encodings;
+	threshold;
+	isCompressibleContentType;
+	constructor(options = {}) {
+		this.encodings = options.encodings ?? ["gzip", "deflate"];
+		this.threshold = options.threshold ?? 1024;
+		this.isCompressibleContentType = options.isCompressibleContentType ?? isCompressibleContentType;
+	}
+	init(options) {
+		const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+			const result = await next();
+			if (!result.matched) return result;
+			const response = result.response;
+			const encoding = negotiateResponseCompressionEncoding(response, interceptorOptions.request.headers, this.encodings);
+			if (encoding === void 0) return result;
+			const body = response.body;
+			const headers = response.headers;
+			if (body instanceof ReadableStream) {
+				const contentLength = Number(flattenStandardHeader(headers["content-length"]));
+				if ((!Number.isFinite(contentLength) || contentLength >= this.threshold) && this.isCompressibleContentType(flattenStandardHeader(headers["content-type"]), interceptorOptions)) return {
+					...result,
+					response: {
+						...response,
+						body: body.pipeThrough(new CompressionStream(encoding)),
+						headers: toCompressedHeaders(headers, encoding)
+					}
+				};
+			} else if (body instanceof Blob) {
+				const contentType = headers["content-type"] ?? body.type;
+				if ((!Number.isFinite(body.size) || body.size >= this.threshold) && this.isCompressibleContentType(flattenStandardHeader(contentType), interceptorOptions)) {
+					const contentDisposition = headers["content-disposition"] ?? generateContentDisposition(body instanceof File ? body.name : "blob");
+					return {
+						...result,
+						response: {
+							...response,
+							body: body.stream().pipeThrough(new CompressionStream(encoding)),
+							headers: {
+								...toCompressedHeaders(headers, encoding),
+								"standard-server": headers["standard-server"] ?? "file",
+								"content-type": contentType,
+								"content-disposition": contentDisposition
+							}
+						}
+					};
+				}
+			} else if (body instanceof FormData) {
+				if (estimateCompressibleFormDataSize(body, (contentType) => this.isCompressibleContentType(contentType, interceptorOptions)) >= this.threshold) {
+					const res = new Response(body);
+					const compressedStream = res.body.pipeThrough(new CompressionStream(encoding));
+					return {
+						...result,
+						response: {
+							...response,
+							body: compressedStream,
+							headers: {
+								...toCompressedHeaders(headers, encoding),
+								"standard-server": [],
+								"content-type": res.headers.get("content-type")
+							}
+						}
+					};
+				}
+			} else if (body instanceof URLSearchParams) {
+				const string = body.toString();
+				if (estimateUtf8ByteLength(string) >= this.threshold) {
+					const [, bodyHeaders] = toFetchBody(body, headers);
+					return {
+						...result,
+						response: {
+							...response,
+							body: new Blob([string]).stream().pipeThrough(new CompressionStream(encoding)),
+							headers: {
+								...toCompressedHeaders(bodyHeaders, encoding),
+								"standard-server": bodyHeaders["standard-server"] ?? []
+							}
+						}
+					};
+				}
+			} else if (body !== void 0 && !isAsyncIteratorObject(body)) {
+				const [string, bodyHeaders] = toFetchBody(body, headers);
+				if (estimateUtf8ByteLength(string) >= this.threshold) return {
+					...result,
+					response: {
+						...response,
+						body: new Blob([string]).stream().pipeThrough(new CompressionStream(encoding)),
+						headers: {
+							...toCompressedHeaders(bodyHeaders, encoding),
+							"standard-server": bodyHeaders["standard-server"] ?? []
+						}
+					}
+				};
+			}
+			return result;
+		};
+		return {
+			...options,
+			routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)]
+		};
+	}
+};
+/**
+* Picks the first of `encodings` the client accepts, or `undefined` when the response
+* must be sent as is because it is already encoded, partial, or forbids transforms.
+* Shared by the response compression plugins so they agree on when to compress.
+*/
+function negotiateResponseCompressionEncoding(response, requestHeaders, encodings) {
+	if (flattenStandardHeader(response.headers["content-encoding"]) !== void 0) return;
+	/**
+	* A partial response body is a byte range of the identity representation, so compressing it
+	* would leave `Content-Range` describing offsets the client never receives.
+	*/
+	if (response.status === 206 || flattenStandardHeader(response.headers["content-range"]) !== void 0) return;
+	if (isNoTransformCacheControl(flattenStandardHeader(response.headers["cache-control"]))) return;
+	const acceptEncodings = parseAcceptEncodingQualities(flattenStandardHeader(requestHeaders["accept-encoding"]));
+	return encodings.find((encoding) => isAcceptableEncoding(acceptEncodings, encoding));
+}
+/**
+* The headers of a response whose body is compressed with `encoding`.
+* Shared by the response compression plugins so compressed responses carry the same headers.
+*/
+function toCompressedHeaders(headers, encoding) {
+	return {
+		...headers,
+		"content-length": [],
+		"content-encoding": encoding,
+		"vary": varyByAcceptEncoding(flattenStandardHeader(headers.vary)),
+		/**
+		* A strong tag shared with the identity bytes would let `If-Range` splice them after compressed ones.
+		* A weak tag still revalidates through `If-None-Match`, and the compressed body serves no ranges.
+		*
+		* @see https://www.rfc-editor.org/rfc/rfc9110.html#name-etag
+		*/
+		"etag": weakenEtag(flattenStandardHeader(headers.etag)),
+		"accept-ranges": []
+	};
+}
+function weakenEtag(etag) {
+	return etag === void 0 || etag.startsWith("W/") ? etag : `W/${etag}`;
+}
+export { ResponseCompressionHandlerPlugin, negotiateResponseCompressionEncoding, toCompressedHeaders };

package/dist/plugins/response-headers.d.ts

@@ -0,0 +1,32 @@
+import { StandardHandlerPlugin } from "../adapters/standard/plugin.js";
+import { StandardHandlerOptions } from "../adapters/standard/handler.js";
+import "../adapters/standard/index.js";
+/**
+ * The context shape into which the Response Headers Plugin injects `resHeaders`.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/response-headers | Response Headers Plugin}
+ */
+export interface ResponseHeadersHandlerPluginContext {
+  /**
+   * Response headers as a Headers instance. This is injected by the Response Headers Plugin.
+   * When set before the response is sent, these headers will be included in the response. If not set, no additional headers will be added.
+   */
+  resHeaders?: Headers | undefined;
+}
+/**
+ * The Response Headers Plugin allows you to set response headers in oRPC.
+ * It injects a resHeaders instance into the context, enabling you to modify response headers easily.
+ *
+ * @remarks
+ * **Warning**: In a `streaming` batch, only the cookies of the first procedure to respond reach the client.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/response-headers | Response Headers Plugin}
+ */
+export declare class ResponseHeadersHandlerPlugin<T extends ResponseHeadersHandlerPluginContext> implements StandardHandlerPlugin<T> {
+  name: string;
+  /**
+   * Interceptors should run after batch interceptors so headers are applied to each sub-response.
+   */
+  before: string[];
+  init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/response-headers.js

@@ -0,0 +1,44 @@
+import { toArray } from "@orpc/shared";
+import { mergeStandardHeaders } from "@standard-server/core";
+import { toStandardHeaders } from "@standard-server/fetch";
+// src/plugins/response-headers.ts
+/**
+* The Response Headers Plugin allows you to set response headers in oRPC.
+* It injects a resHeaders instance into the context, enabling you to modify response headers easily.
+*
+* @remarks
+* **Warning**: In a `streaming` batch, only the cookies of the first procedure to respond reach the client.
+*
+* @see {@link https://orpc.dev/docs/plugins/response-headers | Response Headers Plugin}
+*/
+var ResponseHeadersHandlerPlugin = class {
+	name = "~response-headers";
+	/**
+	* Interceptors should run after batch interceptors so headers are applied to each sub-response.
+	*/
+	before = ["~batch"];
+	init(options) {
+		return {
+			...options,
+			routingInterceptors: [async (interceptorOptions) => {
+				const resHeaders = new Headers(interceptorOptions.context.resHeaders);
+				const result = await interceptorOptions.next({
+					...interceptorOptions,
+					context: {
+						...interceptorOptions.context,
+						resHeaders
+					}
+				});
+				if (!result.response) return result;
+				return {
+					...result,
+					response: {
+						...result.response,
+						headers: mergeStandardHeaders(result.response.headers, toStandardHeaders(resHeaders))
+					}
+				};
+			}, ...toArray(options.routingInterceptors)]
+		};
+	}
+};
+export { ResponseHeadersHandlerPlugin };

package/dist/plugins/rethrow.d.ts

@@ -0,0 +1,35 @@
+import "../adapters/standard/index.js";
+import { StandardHandlerPlugin } from "../adapters/standard/plugin.js";
+import { StandardHandlerInterceptorOptions, StandardHandlerOptions } from "../adapters/standard/handler.js";
+import { Context } from "../context.js";
+import { ThrowableError } from "@orpc/shared";
+export interface RethrowHandlerPluginOptions<T extends Context> {
+  /**
+   * Decide which errors should be rethrown.
+   *
+   * @example
+   * ```ts
+   * const rethrowPlugin = new RethrowHandlerPlugin({
+   *   filter: (error) => {
+   *     // Rethrow all non-ORPCError errors
+   *     return !(error instanceof ORPCError)
+   *   }
+   * })
+   * ```
+   */
+  filter: (error: ThrowableError, options: StandardHandlerInterceptorOptions<T>) => boolean;
+}
+/**
+ * The plugin can bypass oRPC's built-in error handling
+ * and rethrow matching errors directly to your framework's error handling mechanism
+ * (e.g., NestJS exception filters, Express error middleware).
+ *
+ * @see {@link https://orpc.dev/docs/plugins/rethrow | Rethrow Handler Plugin}
+ */
+export declare class RethrowHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+  name: string;
+  private readonly filter;
+  private readonly CONTEXT_SYMBOL;
+  constructor(options: RethrowHandlerPluginOptions<T>);
+  init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/rethrow.js

@@ -0,0 +1,47 @@
+import { toArray } from "@orpc/shared";
+// src/plugins/rethrow.ts
+/**
+* The plugin can bypass oRPC's built-in error handling
+* and rethrow matching errors directly to your framework's error handling mechanism
+* (e.g., NestJS exception filters, Express error middleware).
+*
+* @see {@link https://orpc.dev/docs/plugins/rethrow | Rethrow Handler Plugin}
+*/
+var RethrowHandlerPlugin = class {
+	name = "~rethrow";
+	filter;
+	CONTEXT_SYMBOL = Symbol("ORPC_RETHROW_HANDLER_PLUGIN_CONTEXT");
+	constructor(options) {
+		this.filter = options.filter;
+	}
+	init(options) {
+		const routingInterceptor = async (options) => {
+			const pluginContext = {};
+			const result = await options.next({
+				...options,
+				context: {
+					...options.context,
+					[this.CONTEXT_SYMBOL]: pluginContext
+				}
+			});
+			if (pluginContext.error) throw pluginContext.error.value;
+			return result;
+		};
+		const interceptor = async (options) => {
+			const pluginContext = options.context[this.CONTEXT_SYMBOL];
+			if (!pluginContext) throw new TypeError("[RethrowHandlerPlugin] Rethrow handler context has been corrupted or modified by another plugin or interceptor");
+			try {
+				return await options.next();
+			} catch (error) {
+				if (this.filter(error, options)) pluginContext.error = { value: error };
+				throw error;
+			}
+		};
+		return {
+			...options,
+			routingInterceptors: [...toArray(options.routingInterceptors), routingInterceptor],
+			interceptors: [interceptor, ...toArray(options.interceptors)]
+		};
+	}
+};
+export { RethrowHandlerPlugin };

package/dist/plugins/signal-sync.d.ts

@@ -0,0 +1,15 @@
+import "../adapters/standard/index.js";
+import { StandardHandlerPlugin } from "../adapters/standard/plugin.js";
+import { StandardHandlerOptions } from "../adapters/standard/handler.js";
+import { Context } from "../context.js";
+/**
+ * Keeps the request signal and a streaming output (async iterator object or readable stream) in sync:
+ * cancelling the output aborts the signal with an `AbortError`,
+ * and aborting the signal ends the output with the abort reason and cancels it.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/signal-sync | Signal Sync Plugin}
+ */
+export declare class SignalSyncHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+  name: string;
+  init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/signal-sync.js

@@ -0,0 +1,76 @@
+import { AbortError, AsyncIteratorClass, anyAbortSignal, isAsyncIteratorObject, listenAbort, override, runWithSignal, toArray } from "@orpc/shared";
+// src/plugins/signal-sync.ts
+/**
+* Keeps the request signal and a streaming output (async iterator object or readable stream) in sync:
+* cancelling the output aborts the signal with an `AbortError`,
+* and aborting the signal ends the output with the abort reason and cancels it.
+*
+* @see {@link https://orpc.dev/docs/plugins/signal-sync | Signal Sync Plugin}
+*/
+var SignalSyncHandlerPlugin = class {
+	name = "~signal-sync";
+	init(options) {
+		const clientInterceptor = async (interceptorOptions) => {
+			const controller = new AbortController();
+			const signal = anyAbortSignal([interceptorOptions.signal, controller.signal]);
+			const cancel = () => controller.abort(new AbortError("The response body was cancelled"));
+			const output = await interceptorOptions.next({
+				...interceptorOptions,
+				signal
+			});
+			if (isAsyncIteratorObject(output)) return override(output, syncAsyncIterator(output, signal, cancel));
+			if (output instanceof ReadableStream) return override(output, syncReadableStream(output, signal, cancel));
+			return output;
+		};
+		return {
+			...options,
+			clientInterceptors: [clientInterceptor, ...toArray(options.clientInterceptors)]
+		};
+	}
+};
+function syncAsyncIterator(iterator, signal, cancel) {
+	let cancelling;
+	const unlisten = listenAbort(signal, () => {
+		cancelling = (async () => iterator.return?.())();
+		cancelling.catch(() => {});
+	});
+	return new AsyncIteratorClass(() => runWithSignal(signal, () => iterator.next()), async ({ kind }) => {
+		if (kind === "cancelled") {
+			cancel();
+			await cancelling;
+		}
+		unlisten();
+	});
+}
+function syncReadableStream(stream, signal, cancel) {
+	const reader = stream.getReader();
+	let cancelling;
+	let unlisten;
+	return new ReadableStream({
+		start(controller) {
+			unlisten = listenAbort(signal, (reason) => {
+				controller.error(reason);
+				cancelling = reader.cancel(reason);
+				cancelling.catch(() => {});
+			});
+		},
+		async pull(controller) {
+			try {
+				const { done, value } = await reader.read();
+				if (signal.aborted) return;
+				if (done) {
+					unlisten();
+					controller.close();
+				} else controller.enqueue(value);
+			} catch (error) {
+				unlisten();
+				throw error;
+			}
+		},
+		async cancel() {
+			cancel();
+			await cancelling;
+		}
+	}, { highWaterMark: 0 });
+}
+export { SignalSyncHandlerPlugin };

package/dist/plugins/timeout.d.ts

@@ -0,0 +1,39 @@
+import "../adapters/standard/index.js";
+import { StandardHandlerPlugin } from "../adapters/standard/plugin.js";
+import { StandardHandlerInterceptorOptions, StandardHandlerOptions } from "../adapters/standard/handler.js";
+import { Context } from "../context.js";
+import { Value } from "@orpc/shared";
+export interface TimeoutHandlerPluginOptions<T extends Context> {
+  /**
+   * Timeout in milliseconds before the request signal is aborted.
+   * This only covers producing the response, use `streamingTimeout`
+   * to limit streaming response bodies.
+   * Use `null` or `undefined` to disable the timeout.
+   */
+  timeout: Value<number | null | undefined, [options: StandardHandlerInterceptorOptions<T>]>;
+  /**
+   * Timeout in milliseconds for the full duration of a streaming response body
+   * (async iterator object or readable stream), measured from when the response is produced.
+   * When exceeded, the request signal is aborted and the body ends
+   * once its producer honors the signal.
+   * Usually higher than `timeout`.
+   * Use `null` or `undefined` to disable the timeout.
+   *
+   * @default undefined (streaming responses run without limit)
+   */
+  streamingTimeout?: Value<number | null | undefined, [options: StandardHandlerInterceptorOptions<T>]> | undefined;
+}
+/**
+ * The Timeout Handler Plugin aborts the request signal with an `AbortError`
+ * when handling exceeds a configured timeout. It only aborts the signal,
+ * the procedure must honor it to stop early and produce the response.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/timeout | Timeout Plugin}
+ */
+export declare class TimeoutHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+  private readonly timeout;
+  private readonly streamingTimeout;
+  name: string;
+  constructor(options: NoInfer<TimeoutHandlerPluginOptions<T>>);
+  init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/timeout.js

@@ -0,0 +1,62 @@
+import { AbortError, anyAbortSignal, isAsyncIteratorObject, override, toArray, value, wrapAsyncIterator, wrapReadableStream } from "@orpc/shared";
+// src/plugins/timeout.ts
+/**
+* The Timeout Handler Plugin aborts the request signal with an `AbortError`
+* when handling exceeds a configured timeout. It only aborts the signal,
+* the procedure must honor it to stop early and produce the response.
+*
+* @see {@link https://orpc.dev/docs/plugins/timeout | Timeout Plugin}
+*/
+var TimeoutHandlerPlugin = class {
+	timeout;
+	streamingTimeout;
+	name = "~timeout";
+	constructor(options) {
+		this.timeout = options.timeout;
+		this.streamingTimeout = options.streamingTimeout;
+	}
+	init(options) {
+		const interceptor = async (interceptorOptions) => {
+			const timeoutMs = value(this.timeout, interceptorOptions);
+			const streamingTimeoutMs = value(this.streamingTimeout, interceptorOptions);
+			const hasTimeout = timeoutMs !== null && timeoutMs !== void 0;
+			const hasStreamingTimeout = streamingTimeoutMs !== null && streamingTimeoutMs !== void 0;
+			if (!hasTimeout && !hasStreamingTimeout) return interceptorOptions.next();
+			const controller = new AbortController();
+			const abortWithTimeout = (ms) => {
+				controller.abort(new AbortError(`Request timed out after ${ms}ms`));
+			};
+			const timeoutId = hasTimeout ? setTimeout(abortWithTimeout, timeoutMs, timeoutMs) : void 0;
+			const signal = anyAbortSignal([interceptorOptions.request.signal, controller.signal]);
+			try {
+				const response = await interceptorOptions.next({
+					...interceptorOptions,
+					request: {
+						...interceptorOptions.request,
+						signal
+					}
+				});
+				if (hasStreamingTimeout) {
+					const body = response.body;
+					const isIterator = isAsyncIteratorObject(body);
+					if (isIterator || body instanceof ReadableStream) {
+						const streamingTimeoutId = setTimeout(abortWithTimeout, streamingTimeoutMs, streamingTimeoutMs);
+						const onFinish = () => clearTimeout(streamingTimeoutId);
+						return {
+							...response,
+							body: isIterator ? override(body, wrapAsyncIterator(body, { onFinish })) : override(body, wrapReadableStream(body, { onFinish }))
+						};
+					}
+				}
+				return response;
+			} finally {
+				clearTimeout(timeoutId);
+			}
+		};
+		return {
+			...options,
+			interceptors: [interceptor, ...toArray(options.interceptors)]
+		};
+	}
+};
+export { TimeoutHandlerPlugin };

package/dist/procedure-client.d.ts

@@ -0,0 +1,18 @@
+import { Context } from "./context.js";
+import { Lazyable } from "./lazy.js";
+import { Procedure, ProcedureHandlerOptions } from "./procedure.js";
+import { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ORPCErrorConstructorMap, ORPCErrorFromErrorMap } from "@orpc/contract";
+import { Interceptor, MaybeOptionalOptions, Promisable, PromiseWithError, ThrowableError as ThrowableError$1, Value } from "@orpc/shared";
+import { Client, ClientContext } from "@orpc/client";
+export type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError$1>;
+export interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap> extends ProcedureHandlerOptions<TInitialContext, unknown, ORPCErrorConstructorMap<TErrorMap>> {}
+export type ProcedureClientInterceptor<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError$1>>;
+export type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TClientContext extends ClientContext> = {
+  path?: string[] | undefined;
+  interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap>[] | undefined;
+} & (object extends TInitialContext ? {
+  context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]> | undefined;
+} : {
+  context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+});
+export declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TClientContext extends ClientContext = object>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;