@orpc/server 2.0.0-beta.47 → 2.0.0-beta.49

package/dist/plugins/method-override.js

@@ -0,0 +1,50 @@
+import { toArray } from '@orpc/shared';
+import { parseStandardUrl } from '@standard-server/core';
+/**
+ * Overrides the HTTP method of a POST request based on a query parameter,
+ * so HTML forms (which only support GET and POST) can invoke procedures
+ * routed as PUT, PATCH, or DELETE.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/method-override | Method Override Plugin}
+ */
+export class MethodOverrideHandlerPlugin {
+    name = '~method-override';
+    /**
+     * Should override batch sub-request methods, not the original batch request.
+     */
+    before = ['~batch'];
+    param;
+    methods;
+    constructor(options = {}) {
+        this.param = options.param ?? 'method';
+        this.methods = new Set((options.methods ?? ['PUT', 'PATCH', 'DELETE']).map((method) => method.toUpperCase()));
+    }
+    init(options) {
+        const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+            const { request } = interceptorOptions;
+            if (request.method !== 'POST') {
+                return next();
+            }
+            const [pathname, search, hash] = parseStandardUrl(request.url);
+            const params = new URLSearchParams(search);
+            const raw = params.getAll(this.param).at(-1);
+            if (raw === undefined) {
+                return next();
+            }
+            const method = raw.toUpperCase();
+            if (!this.methods.has(method)) {
+                return next();
+            }
+            params.delete(this.param);
+            const url = `${pathname}${params.size ? `?${params}` : ''}${hash ?? ''}`;
+            return next({
+                ...interceptorOptions,
+                request: { ...request, method, url },
+            });
+        };
+        return {
+            ...options,
+            routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)],
+        };
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { StandardHandlerOptions, StandardHandlerPlugin } from '../adapters/standard/index.ts';
+import type { Context } from '../context.ts';
+/**
+ * Decompresses incoming request bodies based on the Content-Encoding header,
+ * supporting gzip, deflate, and deflate-raw.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/request-compression | Request Compression Plugin}
+ */
+export declare class RequestCompressionHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    /**
+     * Should decompress the original batch request body instead of sub-requests.
+     */
+    after: string[];
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/request-compression.js

@@ -0,0 +1,82 @@
+import { ORPCError } from '@orpc/client';
+import { toArray } from '@orpc/shared';
+import { flattenStandardHeader } from '@standard-server/core';
+import { toFetchHeaders, toStandardBody } from '@standard-server/fetch';
+/**
+ * Each coding adds a decompressor to the chain, so an unbounded list lets a tiny
+ * request cost unbounded CPU and memory. Same limit as undici and curl.
+ */
+const MAX_CONTENT_ENCODINGS = 5;
+/**
+ * Decompresses incoming request bodies based on the Content-Encoding header,
+ * supporting gzip, deflate, and deflate-raw.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/request-compression | Request Compression Plugin}
+ */
+export class RequestCompressionHandlerPlugin {
+    name = '~request-compression';
+    /**
+     * Should decompress the original batch request body instead of sub-requests.
+     */
+    after = ['~batch'];
+    init(options) {
+        // oxlint-disable-next-line unicorn/consistent-function-scoping
+        const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+            const encodings = parseContentEncodings(flattenStandardHeader(interceptorOptions.request.headers['content-encoding']));
+            if (encodings.length === 0 || !encodings.every(isSupportedEncoding)) {
+                return next();
+            }
+            const decompressedHeaders = {
+                ...interceptorOptions.request.headers,
+                'content-length': undefined,
+                'content-encoding': undefined,
+            };
+            return next({
+                ...interceptorOptions,
+                request: {
+                    ...interceptorOptions.request,
+                    headers: decompressedHeaders,
+                    async resolveBody(hint) {
+                        const stream = await interceptorOptions.request.resolveBody('octet-stream');
+                        // adapter might not support hint (e.g peer adapter)
+                        if (!(stream instanceof ReadableStream)) {
+                            return stream;
+                        }
+                        if (encodings.length > MAX_CONTENT_ENCODINGS) {
+                            throw new ORPCError('UNSUPPORTED_MEDIA_TYPE', {
+                                message: 'Too many content encodings.',
+                            });
+                        }
+                        let decompressedStream = stream;
+                        for (let i = encodings.length - 1; i >= 0; i--) {
+                            decompressedStream = decompressedStream.pipeThrough(new DecompressionStream(encodings[i]));
+                        }
+                        const response = new Response(decompressedStream, {
+                            headers: toFetchHeaders(decompressedHeaders),
+                        });
+                        return toStandardBody(response, { hint });
+                    },
+                },
+            });
+        };
+        return {
+            ...options,
+            routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)],
+        };
+    }
+}
+const SUPPORTED_ENCODINGS = ['gzip', 'deflate', 'deflate-raw'];
+function isSupportedEncoding(encoding) {
+    return SUPPORTED_ENCODINGS.includes(encoding);
+}
+/**
+ * Parse Content-Encoding into ordered codings (order applied).
+ *
+ * @see https://www.rfc-editor.org/rfc/rfc9110.html#name-content-encoding
+ */
+function parseContentEncodings(header) {
+    if (header === undefined) {
+        return [];
+    }
+    return header.split(',').map((part) => part.trim().toLowerCase());
+}

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

@@ -0,0 +1,22 @@
+import type { StandardHandlerOptions, StandardHandlerPlugin } from '../adapters/standard/index.ts';
+/**
+ * The context shape into which the Request Headers Plugin injects `reqHeaders`.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/request-headers | Request Headers Plugin}
+ */
+export interface RequestHeadersHandlerPluginContext {
+    /**
+     * Request headers as a Headers instance. This is injected by the Request Headers Plugin.
+     */
+    reqHeaders?: Headers | undefined;
+}
+/**
+ * The Request Headers Plugin injects a `reqHeaders` instance into the context,
+ * allowing access to request headers in oRPC.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/request-headers | Request Headers Plugin}
+ */
+export declare class RequestHeadersHandlerPlugin<T extends RequestHeadersHandlerPluginContext> implements StandardHandlerPlugin<T> {
+    name: string;
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/request-headers.js

@@ -0,0 +1,30 @@
+import { toArray } from '@orpc/shared';
+import { toFetchHeaders } from '@standard-server/fetch';
+/**
+ * The Request Headers Plugin injects a `reqHeaders` instance into the context,
+ * allowing access to request headers in oRPC.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/request-headers | Request Headers Plugin}
+ */
+export class RequestHeadersHandlerPlugin {
+    name = '~request-headers';
+    init(options) {
+        return {
+            ...options,
+            interceptors: [
+                (interceptorOptions) => {
+                    const reqHeaders = interceptorOptions.context.reqHeaders ??
+                        toFetchHeaders(interceptorOptions.request.headers);
+                    return interceptorOptions.next({
+                        ...interceptorOptions,
+                        context: {
+                            ...interceptorOptions.context,
+                            reqHeaders,
+                        },
+                    });
+                },
+                ...toArray(options.interceptors),
+            ],
+        };
+    }
+}

package/dist/{shared/server.CgBF3Vj1.d.ts → plugins/request-limit.d.ts}

@@ -1,7 +1,6 @@
-import { C as Context } from './server.DFPxP2v3.js';
-import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.DOg7ke6y.js';
-
-interface RequestLimitHandlerPluginOptions {
+import type { StandardHandlerOptions, StandardHandlerPlugin } from '../adapters/standard/index.ts';
+import type { Context } from '../context.ts';
+export interface RequestLimitHandlerPluginOptions {
     /**
      * The maximum allowed request body size in bytes.
      */
@@ -15,7 +14,7 @@ interface RequestLimitHandlerPluginOptions {
  *
  * @see {@link https://orpc.dev/docs/plugins/request-limit | Request Limit Plugin}
  */
-declare class RequestLimitHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+export declare class RequestLimitHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
     name: string;
     /**
      * Should limit the original batch request body instead of sub-requests.
@@ -29,6 +28,3 @@ declare class RequestLimitHandlerPlugin<T extends Context> implements StandardHa
     constructor(options: RequestLimitHandlerPluginOptions);
     init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
 }
-
-export { RequestLimitHandlerPlugin as R };
-export type { RequestLimitHandlerPluginOptions as a };

package/dist/plugins/request-limit.js

@@ -0,0 +1,68 @@
+import { ORPCError } from '@orpc/client';
+import { toArray } from '@orpc/shared';
+import { flattenStandardHeader } from '@standard-server/core';
+import { toFetchHeaders, toStandardBody } from '@standard-server/fetch';
+/**
+ * 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}
+ */
+export class RequestLimitHandlerPlugin {
+    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');
+                        // adapter might not support hint (e.g. peer adapter)
+                        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)],
+        };
+    }
+}

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

@@ -0,0 +1,59 @@
+import type { StandardHeaders, StandardResponse } from '@standard-server/core';
+import type { StandardHandlerOptions, StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions } from '../adapters/standard/index.ts';
+import type { Context } from '../context.ts';
+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 ('gzip' | 'deflate' | 'deflate-raw')[] | 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,209 @@
+import { isAcceptableEncoding, isAsyncIteratorObject, isCompressibleContentType, isNoTransformCacheControl, parseAcceptEncodingQualities, toArray, varyByAcceptEncoding, } from '@orpc/shared';
+import { flattenStandardHeader, generateContentDisposition } from '@standard-server/core';
+import { toFetchBody } from '@standard-server/fetch';
+// Rough UTF-8 estimate. Mostly ASCII text stays close to 1 byte/char;
+// occasional multi-byte characters increase the average.
+const AVG_BYTES_PER_CHAR = 1.2;
+/**
+ * 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 class ResponseCompressionHandlerPlugin {
+    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 === undefined) {
+                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) {
+                // Adapters only fall back to the blob type when no Content-Type header is set
+                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) {
+                const PART_OVERHEAD = 64; // approx bytes for boundary + Content-Disposition/Content-Type headers per part
+                let contentLength = 0;
+                for (const [key, value] of body) {
+                    contentLength += PART_OVERHEAD + key.length;
+                    if (value instanceof Blob) {
+                        if (!Number.isFinite(value.size)) {
+                            // Bun-s3 can use NaN for size
+                            if (!this.isCompressibleContentType(value.type, interceptorOptions)) {
+                                // Unknown non-compressible part size makes the estimate unreliable
+                                contentLength = -Infinity;
+                                break;
+                            }
+                            // Unknown size for compressible content - still apply compression
+                            contentLength = Infinity;
+                        }
+                        else {
+                            contentLength += this.isCompressibleContentType(value.type, interceptorOptions)
+                                ? value.size
+                                : -value.size;
+                        }
+                    }
+                    else {
+                        contentLength += value.length * AVG_BYTES_PER_CHAR;
+                    }
+                }
+                if (contentLength >= 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 (string.length * AVG_BYTES_PER_CHAR >= this.threshold) {
+                    const [, bodyHeaders] = toFetchBody(body, headers);
+                    return {
+                        ...result,
+                        response: {
+                            ...response,
+                            body: new Blob([string]).stream().pipeThrough(new CompressionStream(encoding)),
+                            headers: {
+                                ...toCompressedHeaders(bodyHeaders, encoding),
+                                // An empty hint rather than none, so the adapter does not hint the compressed stream as `octet-stream`
+                                'standard-server': bodyHeaders['standard-server'] ?? [],
+                            },
+                        },
+                    };
+                }
+            }
+            else if (body !== undefined && !isAsyncIteratorObject(body)) {
+                const [string, bodyHeaders] = toFetchBody(body, headers);
+                if (string.length * AVG_BYTES_PER_CHAR >= 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.
+ */
+export function negotiateResponseCompressionEncoding(response, requestHeaders, encodings) {
+    if (flattenStandardHeader(response.headers['content-encoding']) !== undefined) {
+        // already compressed, do not compress again
+        return undefined;
+    }
+    /**
+     * 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']) !== undefined) {
+        return undefined;
+    }
+    // Cache-Control: no-transform forbids intermediaries (and these plugins) from transforming the body
+    if (isNoTransformCacheControl(flattenStandardHeader(response.headers['cache-control']))) {
+        return undefined;
+    }
+    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.
+ */
+export 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 === undefined || etag.startsWith('W/') ? etag : `W/${etag}`;
+}

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

@@ -0,0 +1,30 @@
+import type { StandardHandlerOptions, StandardHandlerPlugin } from '../adapters/standard/index.ts';
+/**
+ * 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,47 @@
+import { toArray } from '@orpc/shared';
+import { mergeStandardHeaders } from '@standard-server/core';
+import { toStandardHeaders } from '@standard-server/fetch';
+/**
+ * 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 class ResponseHeadersHandlerPlugin {
+    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),
+            ],
+        };
+    }
+}