@orpc/server 2.0.0-beta.46 → 2.0.0-beta.48

package/dist/plugins/get-method-csrf-protection.mjs

@@ -0,0 +1,45 @@
+import { ORPCError } from "@orpc/client";
+import { toArray } from "@orpc/shared";
+import { flattenStandardHeader } from "@standard-server/core";
+
+export class GetMethodCsrfProtectionHandlerPlugin {
+	name = "~get-method-csrf-protection";
+	init(options) {
+		
+		const interceptor = (interceptorOptions) => {
+			if (this.isAllowed(interceptorOptions)) {
+				return interceptorOptions.next();
+			}
+			throw new ORPCError("FORBIDDEN", { message: "Request blocked by CSRF protection." });
+		};
+		return {
+			...options,
+			interceptors: [interceptor, ...toArray(options.interceptors)]
+		};
+	}
+	isAllowed({ request }) {
+		
+		
+		if (request.method !== "GET") {
+			return true;
+		}
+		const site = flattenStandardHeader(request.headers["sec-fetch-site"])?.toLowerCase();
+		
+		
+		
+		
+		if (site === undefined || site === "same-origin" || site === "same-site") {
+			return true;
+		}
+		
+		
+		
+		
+		const mode = flattenStandardHeader(request.headers["sec-fetch-mode"])?.toLowerCase();
+		const dest = flattenStandardHeader(request.headers["sec-fetch-dest"])?.toLowerCase();
+		if (mode === undefined || dest === undefined) {
+			return false;
+		}
+		return mode !== "navigate" || dest !== "document";
+	}
+}

package/dist/plugins/head-method.d.mts

@@ -0,0 +1,23 @@
+import type { StandardHandlerOptions, StandardHandlerPlugin } from "../adapters/standard/index.mjs";
+import type { Context } from "../context.mjs";
+/**
+* Answers `HEAD` requests with the headers of the matching `GET` procedure, like Fastify's
+* `exposeHeadRoutes`, so clients can check a resource's existence, type, and size without
+* downloading it. A procedure routed as `HEAD` itself takes precedence over the `GET` one.
+*
+* @remarks
+* - `HEAD` responses never carry a body: the plugin discards it, cancelling streams and
+*   event iterators, and keeps the headers it implies, such as `Content-Type`, and
+*   `Content-Length` when its size is known up front.
+* - `GET` procedures still need to be reachable, so with `RPCHandler`, `GET` must be in `allowMethods`.
+*
+* @see {@link https://orpc.dev/docs/plugins/head-method | HEAD Method Plugin}
+*/
+export declare class HeadMethodHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+	name: string;
+	/**
+	* Discard the body after response compression, so `HEAD` reports the same `Content-Encoding` as `GET`.
+	*/
+	after: string[];
+	init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/head-method.mjs

@@ -0,0 +1,95 @@
+import { isAsyncIteratorObject, toArray } from "@orpc/shared";
+import { cancelStandardBody, getRequiredStandardBodyHint } from "@standard-server/core";
+import { toFetchBody } from "@standard-server/fetch";
+const textEncoder = /* @__PURE__ */ new TextEncoder();
+
+export class HeadMethodHandlerPlugin {
+	name = "~head-method";
+	
+	after = ["~response-compression"];
+	init(options) {
+		const bodyInterceptor = async ({ next, request }) => {
+			if (request.method !== "HEAD") {
+				return next();
+			}
+			const result = await next();
+			if (!result.matched) {
+				return result;
+			}
+			return {
+				...result,
+				response: toHeadResponse(result.response)
+			};
+		};
+		
+		const fallbackInterceptor = async (interceptorOptions) => {
+			const { next, request } = interceptorOptions;
+			if (request.method !== "HEAD") {
+				return next();
+			}
+			const result = await next();
+			if (result.matched) {
+				return result;
+			}
+			return next({
+				...interceptorOptions,
+				request: {
+					...request,
+					method: "GET"
+				}
+			});
+		};
+		return {
+			...options,
+			routingInterceptors: [
+				bodyInterceptor,
+				...toArray(options.routingInterceptors),
+				fallbackInterceptor
+			]
+		};
+	}
+}
+
+function toHeadResponse(response) {
+	const { body } = response;
+	if (body === undefined) {
+		return response;
+	}
+	if (isAsyncIteratorObject(body)) {
+		discardBody(body);
+		const headers = {
+			...response.headers,
+			"content-length": undefined
+		};
+		headers["content-type"] ??= "text/event-stream";
+		headers["standard-server"] = getRequiredStandardBodyHint("event-stream", headers) ?? [];
+		return {
+			...response,
+			headers,
+			body: createEmptyStream()
+		};
+	}
+	const [encoded, headers] = toFetchBody(body, response.headers);
+	if (encoded instanceof ReadableStream) {
+		discardBody(encoded);
+	} else if (encoded instanceof FormData) {
+		
+		headers["standard-server"] = [];
+		headers["content-type"] = new Response(encoded).headers.get("content-type");
+	} else if (typeof encoded === "string" || encoded instanceof URLSearchParams) {
+		headers["standard-server"] ??= [];
+		headers["content-length"] = textEncoder.encode(encoded.toString()).byteLength.toString();
+	}
+	return {
+		...response,
+		headers,
+		body: createEmptyStream()
+	};
+}
+function createEmptyStream() {
+	return new ReadableStream({ start: (controller) => controller.close() });
+}
+
+function discardBody(body) {
+	cancelStandardBody(body).catch(() => {});
+}

package/dist/plugins/index.d.mts

@@ -1,432 +1,39 @@
-import { Value, Promisable, ThrowableError } from '@orpc/shared';
-import { StandardLazyRequest, StandardResponse, StandardHeaders, StandardMethod } from '@standard-server/core';
-import { Context } from '../index.mjs';
-import { StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions, StandardHandlerOptions, StandardHandlerInterceptorOptions } from '../adapters/standard/index.mjs';
-export { R as RequestLimitHandlerPlugin, a as RequestLimitHandlerPluginOptions } from '../shared/server.CTV_mC2P.mjs';
-export { BATCH_HEADER, DEFAULT_BATCH_MAX_SIZE } from '@orpc/client/plugins';
-import '@orpc/client';
-import '@orpc/contract';
-
-/**
- * Content type for batch responses that use the length-prefixed binary framing,
- * which they do when any sub-response contains binary or is a stream.
- *
- * Decoding is driven by the `standard-server` body hint, not this header,
- * so it only serves to describe the payload to logs, proxies, and dev tools.
- */
-declare const BATCH_CONTENT_TYPE = "application/vnd.orpc.batch";
-interface BatchHandlerPluginOptions<T extends Context> {
-    /**
-     * The max size of the batch allowed. Larger batches are rejected with a `413`,
-     * so keep the client Batch Link Plugin's `maxSize` at or below it.
-     *
-     * @default DEFAULT_BATCH_MAX_SIZE (10)
-     * @see {@link https://orpc.dev/docs/plugins/batch#max-size | Batch Plugin - Max Size}
-     */
-    maxSize?: Value<Promisable<number>, [options: StandardHandlerRoutingInterceptorOptions<T>]> | undefined;
-    /**
-     * Map each subrequest in the batch before it is processed.
-     *
-     * @default merges the batch request headers into the subrequest, giving them priority over
-     * the subrequest headers, and removes the `orpc-batch` header to prevent nested batching
-     */
-    mapSubrequest?: ((subrequest: StandardLazyRequest, batchOptions: StandardHandlerRoutingInterceptorOptions<T>) => StandardLazyRequest) | undefined;
-    /**
-     * Map each sub-response in the batch before it is sent.
-     *
-     * @default removes the headers the batch response already has with the same value, which the client
-     * merges back, and `set-cookie`, which the browser ignores there and JavaScript could read
-     */
-    mapSubresponse?: ((subresponse: StandardResponse, partialBatchResponse: Pick<StandardResponse, 'status' | 'headers'>, batchOptions: StandardHandlerRoutingInterceptorOptions<T>) => StandardResponse) | undefined;
-    /**
-     * Success batch response status code.
-     *
-     * @default 207
-     */
-    successStatus?: Value<Promisable<number>, [batchOptions: StandardHandlerRoutingInterceptorOptions<T>]> | undefined;
-    /**
-     * Success batch response headers.
-     *
-     * The batch response also gets the cookies its sub-responses set, and the headers they all share.
-     * Headers set here win, and setting one to `undefined` keeps it off, except `set-cookie` and `vary`, which merge.
-     *
-     * @default {}
-     */
-    headers?: Value<Promisable<StandardHeaders>, [batchOptions: StandardHandlerRoutingInterceptorOptions<T>]> | undefined;
-    /**
-     * Keep-alive settings for batch responses that stream.
-     *
-     * When enabled, a zero-length length-prefixed frame is sent periodically while the
-     * stream is idle (no message sent for `interval` ms). Clients ignore these frames.
-     *
-     * @default { enabled: true, interval: 15000 }
-     */
-    keepAlive?: {
-        /**
-         * If true, a keep-alive frame is sent periodically while the stream is idle.
-         *
-         * @default true
-         */
-        enabled: boolean;
-        /**
-         * Interval (in milliseconds) between keep-alive frames after the last message.
-         *
-         * @default 15000
-         */
-        interval?: number | undefined;
-    } | undefined;
-}
-/**
- * Handles batch requests sent by the client Batch Link Plugin, splitting each
- * batch into sub-requests and sending their responses back together.
- *
- * @remarks
- * The batch starts the response once every sub-response is ready, so it carries the cookies sub-requests
- * set and the headers every sub-response shares. It streams when a sub-response is a stream.
- *
- * **Note**: HTTP/2 and later already multiplex requests over a single connection, which often makes this plugin unnecessary.
- *
- * @see {@link https://orpc.dev/docs/plugins/batch | Batch Plugin}
- */
-declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    name: string;
-    /**
-     * Run batch interceptors inside the tracing interceptors
-     * so each subrequest gets its own span instead of sharing one batch-level span.
-     */
-    after: string[];
-    private readonly maxSize;
-    private readonly mapSubrequest;
-    private readonly mapSubresponse;
-    private readonly successStatus;
-    private readonly headers;
-    private readonly keepAliveEnabled;
-    private readonly keepAliveInterval;
-    constructor(options?: BatchHandlerPluginOptions<T>);
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-interface CORSHandlerPluginOptions<T extends Context> {
-    /**
-     * Configures the `Access-Control-Allow-Origin` header.
-     * Can be a string, an array of allowed origins, or a function (optionally async) that returns the allowed origin(s).
-     *
-     * A function must only return origins it has validated: returning the incoming origin
-     * unchecked allows every origin.
-     *
-     * @default '*'
-     */
-    origin?: Value<Promisable<string | readonly string[] | null | undefined>, [origin: string, options: StandardHandlerRoutingInterceptorOptions<T>]> | undefined;
-    /**
-     * Configures the `Timing-Allow-Origin` header.
-     * Can be a string, an array of allowed origins, or a function (optionally async) that returns the allowed origin(s).
-     */
-    timingOrigin?: Value<Promisable<string | readonly string[] | null | undefined>, [origin: string, options: StandardHandlerRoutingInterceptorOptions<T>]> | undefined;
-    /**
-     * Configures the `Access-Control-Allow-Methods` header for preflight requests.
-     *
-     * @default ['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH', 'QUERY']
-     */
-    allowMethods?: readonly string[] | undefined;
-    /**
-     * Configures the `Access-Control-Allow-Headers` header for preflight requests.
-     * Falls back to the request's `Access-Control-Request-Headers` if not set.
-     * When set, it replaces that fallback, so include every non-safelisted header
-     * clients send, such as `Content-Type`.
-     */
-    allowHeaders?: readonly string[] | undefined;
-    /**
-     * Configures the `Access-Control-Max-Age` header (in seconds) for preflight requests.
-     */
-    maxAge?: number | undefined;
-    /**
-     * Configures the `Access-Control-Allow-Credentials` header.
-     *
-     * When enabled, `origin` must allow trusted origins only: every allowed origin can send
-     * authenticated requests as your users and read the responses.
-     */
-    credentials?: boolean | undefined;
-    /**
-     * Configures the `Access-Control-Expose-Headers` header.
-     */
-    exposeHeaders?: readonly string[] | undefined;
-}
-/**
- * Configures the [CORS Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS)
- * for your API, including preflight requests.
- *
- * @see {@link https://orpc.dev/docs/plugins/cors | CORS Handler Plugin}
- */
-declare class CORSHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    private readonly options;
-    name: string;
-    /**
-     * - Do not create spans for CORS preflight requests.
-     * - Run CORS interceptors before batch interceptors so headers are applied to
-     *  the actual response rather than sub-responses.
-     */
-    after: string[];
-    constructor(options?: CORSHandlerPluginOptions<T>);
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-    private resolveOrigin;
-}
-
-/**
- * Adds Cross-Site Request Forgery (CSRF) protection that makes the safe `GET` method as
- * secure as unsafe ones such as `POST`. It rejects `GET` requests arriving as top-level
- * navigations initiated cross-site or from outside the browser, the only context where
- * another site can make a browser attach `SameSite=Lax` cookies to a safe-method request.
- * Requests matching no procedure stay unmatched, so they can fall through to whatever
- * serves the rest of the site.
- *
- * @remarks
- * **Note**: Requests browsers send without `SameSite=Lax` cookies, such as cross-site `fetch`
- * and `<img>`, pass through, so procedures stay reachable from other sites. This safeguard
- * requires authentication cookies explicitly marked `SameSite=Lax` or `SameSite=Strict`,
- * since browsers may attach other cookies to the requests that pass.
- *
- * @see {@link https://orpc.dev/docs/plugins/get-method-csrf-protection | GET Method CSRF Protection Plugin}
- */
-declare class GetMethodCsrfProtectionHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    name: string;
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-    private isAllowed;
-}
-
-interface MethodOverrideHandlerPluginOptions {
-    /**
-     * The query parameter carrying the override method.
-     *
-     * @default 'method'
-     */
-    param?: string | undefined;
-    /**
-     * The methods a POST request may be overridden to.
-     *
-     * GET and HEAD are excluded by default because they switch input decoding
-     * from the request body to the query string and widen the CSRF surface.
-     *
-     * @default ['PUT', 'PATCH', 'DELETE']
-     */
-    methods?: readonly StandardMethod[] | undefined;
-}
-/**
- * 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}
- */
-declare class MethodOverrideHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    name: string;
-    /**
-     * Should override batch sub-request methods, not the original batch request.
-     */
-    before: string[];
-    private readonly param;
-    private readonly methods;
-    constructor(options?: MethodOverrideHandlerPluginOptions);
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-/**
- * 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}
- */
-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>;
-}
-
-/**
- * The context shape into which the Request Headers Plugin injects `reqHeaders`.
- *
- * @see {@link https://orpc.dev/docs/plugins/request-headers | Request Headers Plugin}
- */
-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}
- */
-declare class RequestHeadersHandlerPlugin<T extends RequestHeadersHandlerPluginContext> implements StandardHandlerPlugin<T> {
-    name: string;
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-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}
- */
-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.
- */
-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.
- */
-declare function toCompressedHeaders(headers: StandardHeaders, encoding: string): StandardHeaders;
-
-/**
- * The context shape into which the Response Headers Plugin injects `resHeaders`.
- *
- * @see {@link https://orpc.dev/docs/plugins/response-headers | Response Headers Plugin}
- */
-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.
- *
- * @see {@link https://orpc.dev/docs/plugins/response-headers | Response Headers Plugin}
- */
-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>;
-}
-
-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}
- */
-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>;
-}
-
-/**
- * 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}
- */
-declare class SignalSyncHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    name: string;
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-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}
- */
-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>;
-}
-
-export { BATCH_CONTENT_TYPE, BatchHandlerPlugin, CORSHandlerPlugin, CORSHandlerPlugin as CORSPlugin, GetMethodCsrfProtectionHandlerPlugin, MethodOverrideHandlerPlugin, RequestCompressionHandlerPlugin, RequestHeadersHandlerPlugin, RequestHeadersHandlerPlugin as RequestHeadersPlugin, ResponseCompressionHandlerPlugin, ResponseHeadersHandlerPlugin, ResponseHeadersHandlerPlugin as ResponseHeadersPlugin, RethrowHandlerPlugin, SignalSyncHandlerPlugin, TimeoutHandlerPlugin, negotiateResponseCompressionEncoding, toCompressedHeaders };
-export type { BatchHandlerPluginOptions, CORSHandlerPluginOptions, MethodOverrideHandlerPluginOptions, RequestHeadersHandlerPluginContext, RequestHeadersHandlerPluginContext as RequestHeadersPluginContext, ResponseCompressionHandlerPluginOptions, ResponseHeadersHandlerPluginContext, ResponseHeadersHandlerPluginContext as ResponseHeadersPluginContext, RethrowHandlerPluginOptions, TimeoutHandlerPluginOptions };
+export * from "./batch.mjs";
+export * from "./cors.mjs";
+export { 
+/**
+* @deprecated Use `CORSHandlerPlugin` instead.
+*/
+ CORSHandlerPlugin as CORSPlugin } from "./cors.mjs";
+export * from "./get-method-csrf-protection.mjs";
+export * from "./head-method.mjs";
+export * from "./method-override.mjs";
+export * from "./request-compression.mjs";
+export * from "./request-headers.mjs";
+export { 
+/**
+* @deprecated Use `RequestHeadersHandlerPlugin` instead.
+*/
+ RequestHeadersHandlerPlugin as RequestHeadersPlugin } from "./request-headers.mjs";
+export type { 
+/**
+* @deprecated Use `RequestHeadersHandlerPluginContext` instead.
+*/
+ RequestHeadersHandlerPluginContext as RequestHeadersPluginContext } from "./request-headers.mjs";
+export * from "./request-limit.mjs";
+export * from "./response-compression.mjs";
+export * from "./response-headers.mjs";
+export { 
+/**
+* @deprecated Use `ResponseHeadersHandlerPlugin` instead.
+*/
+ ResponseHeadersHandlerPlugin as ResponseHeadersPlugin } from "./response-headers.mjs";
+export type { 
+/**
+* @deprecated Use `ResponseHeadersHandlerPluginContext` instead.
+*/
+ ResponseHeadersHandlerPluginContext as ResponseHeadersPluginContext } from "./response-headers.mjs";
+export * from "./rethrow.mjs";
+export * from "./signal-sync.mjs";
+export * from "./timeout.mjs";
+export { BATCH_HEADER, DEFAULT_BATCH_MAX_SIZE } from "@orpc/client/plugins";