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

package/dist/plugins/batch.js

@@ -1,405 +1,371 @@
-import { ORPCError } from '@orpc/client';
-import { BATCH_HEADER, DEFAULT_BATCH_MAX_SIZE } from '@orpc/client/plugins';
-import { isAsyncIteratorObject, promiseWithResolvers, toArray, value } from '@orpc/shared';
-import { flattenStandardHeader, parseStandardUrl } from '@standard-server/core';
-import { encodePeerMessage, isClientPeerSendMessage, isPeerMessage, ServerPeer, } from '@standard-server/peer';
+import { isAsyncIteratorObject, listenAbort, promiseWithResolvers, toArray, value } from "@orpc/shared";
+import { ORPCError } from "@orpc/client";
+import { flattenStandardHeader, parseStandardUrl } from "@standard-server/core";
+import { BATCH_HEADER, DEFAULT_BATCH_MAX_SIZE } from "@orpc/client/plugins";
+import { ServerPeer, encodePeerMessage, isClientPeerSendMessage, isPeerMessage } from "@standard-server/peer";
+// src/plugins/batch.ts
 /**
- * Content type for batch responses that use the length-prefixed binary framing,
- * which they do in `streaming` mode, or 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.
- */
-export const BATCH_CONTENT_TYPE = 'application/vnd.orpc.batch';
+* Content type for batch responses that use the length-prefixed binary framing,
+* which they do in `streaming` mode, or 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.
+*/
+const BATCH_CONTENT_TYPE = "application/vnd.orpc.batch";
 const textEncoder = /* @__PURE__ */ new TextEncoder();
 function encodeLengthPrefix(length) {
-    const prefix = new Uint8Array(4);
-    new DataView(prefix.buffer).setUint32(0, length, false);
-    return prefix;
+	const prefix = /* @__PURE__ */ new Uint8Array(4);
+	new DataView(prefix.buffer).setUint32(0, length, false);
+	return prefix;
 }
 /**
- * Encodes a message as a length-prefixed frame: its 4-byte big-endian length, then its bytes.
- */
+* Encodes a message as a length-prefixed frame: its 4-byte big-endian length, then its bytes.
+*/
 async function encodeFrame(message) {
-    const encoded = await encodePeerMessage(message);
-    const bytes = typeof encoded === 'string' ? textEncoder.encode(encoded) : encoded;
-    return [encodeLengthPrefix(bytes.byteLength), bytes];
+	const encoded = await encodePeerMessage(message);
+	const bytes = typeof encoded === "string" ? textEncoder.encode(encoded) : encoded;
+	return [encodeLengthPrefix(bytes.byteLength), bytes];
 }
 /**
- * Whether a header describes a subresponse's own body, which the batch response does not share.
- */
+* Whether a header describes a subresponse's own body, which the batch response does not share.
+*/
 function isBodyHeader(name) {
-    return name.startsWith('content-') || name === 'standard-server';
+	return name.startsWith("content-") || name === "standard-server";
 }
 /**
- * Whether untrusted batch JSON is a list of client peer messages.
- * `isPeerMessage` must run first, since `isClientPeerSendMessage` does not check `id` or `binary`.
- */
+* Whether untrusted batch JSON is a list of client peer messages.
+* `isPeerMessage` must run first, since `isClientPeerSendMessage` does not check `id` or `binary`.
+*/
 function isClientPeerSendMessages(maybe) {
-    return (Array.isArray(maybe) &&
-        maybe.every((m) => isPeerMessage(m) && isClientPeerSendMessage(m)));
+	return Array.isArray(maybe) && maybe.every((m) => isPeerMessage(m) && isClientPeerSendMessage(m));
 }
 /**
- * Errors should not occur at the routing interceptor level.
- * Reject the promise so it can be handled by the unhandledRejection handler
- * for global logging or error handling.
- */
+* Errors should not occur at the routing interceptor level.
+* Reject the promise so it can be handled by the unhandledRejection handler
+* for global logging or error handling.
+*/
 function internalError(err) {
-    void Promise.reject(err);
-    return { status: 500, headers: {}, body: 'Internal server error' };
+	Promise.reject(err);
+	return {
+		status: 500,
+		headers: {},
+		body: "Internal server error"
+	};
 }
 /**
- * Resolves with the first subresponse head, or `undefined` if none has one.
- */
+* Resolves with the first subresponse head, or `undefined` if none has one.
+*/
 function firstSubresponseHead(heads) {
-    return new Promise((resolve) => {
-        for (const promise of heads) {
-            void promise.then((head) => head && resolve(head));
-        }
-        void Promise.all(heads).then(() => resolve(undefined));
-    });
+	return new Promise((resolve) => {
+		for (const promise of heads) promise.then((head) => head && resolve(head));
+		Promise.all(heads).then(() => resolve(void 0));
+	});
 }
 /**
- * Sets the distinct cookies of every source on the headers.
- */
+* Sets the distinct cookies of every source on the headers.
+*/
 function liftCookies(headers, sources) {
-    const cookies = new Set(sources.flatMap((source) => toArray(source['set-cookie'])));
-    return cookies.size > 0 ? { ...headers, 'set-cookie': [...cookies] } : headers;
+	const cookies = new Set(sources.flatMap((source) => toArray(source["set-cookie"])));
+	return cookies.size > 0 ? {
+		...headers,
+		"set-cookie": [...cookies]
+	} : headers;
 }
 /**
- * Builds the batch response headers: the headers the subresponses all have with the same value, as
- * the client does with the headers every subrequest shares, then the batch headers, which win, and
- * the distinct cookies and `vary` fields of both. A cache must vary on whatever any subresponse varies on.
- */
+* Builds the batch response headers: the headers the subresponses all have with the same value, as
+* the client does with the headers every subrequest shares, then the batch headers, which win, and
+* the distinct cookies and `vary` fields of both. A cache must vary on whatever any subresponse varies on.
+*/
 function liftSubresponseHeaders(batchHeaders, subresponseHeaders) {
-    const [first = {}, ...rest] = subresponseHeaders;
-    const shared = {};
-    for (const [name, value] of Object.entries(first)) {
-        if (value === undefined || isBodyHeader(name)) {
-            continue;
-        }
-        const flattened = flattenStandardHeader(value);
-        if (rest.every((other) => flattenStandardHeader(other[name]) === flattened)) {
-            shared[name] = value;
-        }
-    }
-    const headers = liftCookies({ ...shared, ...batchHeaders }, [batchHeaders, ...subresponseHeaders]);
-    const varies = new Map();
-    for (const value of [batchHeaders, ...subresponseHeaders].flatMap((other) => toArray(other.vary))) {
-        for (const field of value.split(',')) {
-            const name = field.trim();
-            const key = name.toLowerCase();
-            if (name && !varies.has(key)) {
-                varies.set(key, name);
-            }
-        }
-    }
-    if (varies.size > 0) {
-        headers.vary = varies.has('*') ? '*' : [...varies.values()].join(', ');
-    }
-    return headers;
+	const [first = {}, ...rest] = subresponseHeaders;
+	const shared = {};
+	for (const [name, value] of Object.entries(first)) {
+		if (value === void 0 || isBodyHeader(name)) continue;
+		const flattened = flattenStandardHeader(value);
+		if (rest.every((other) => flattenStandardHeader(other[name]) === flattened)) shared[name] = value;
+	}
+	const headers = liftCookies({
+		...shared,
+		...batchHeaders
+	}, [batchHeaders, ...subresponseHeaders]);
+	const varies = /* @__PURE__ */ new Map();
+	for (const value of [batchHeaders, ...subresponseHeaders].flatMap((other) => toArray(other.vary))) for (const field of value.split(",")) {
+		const name = field.trim();
+		const key = name.toLowerCase();
+		if (name && !varies.has(key)) varies.set(key, name);
+	}
+	if (varies.size > 0) headers.vary = varies.has("*") ? "*" : [...varies.values()].join(", ");
+	return headers;
 }
 /**
- * Handles batch requests sent by the client Batch Link Plugin, splitting each
- * batch into sub-requests and sending their responses back together.
- *
- * @remarks
- * The client Batch Link Plugin's `mode` picks how each batch responds: `buffered` (default) waits for every
- * sub-response and carries their cookies and shared headers; `streaming` starts once the first is ready and
- * carries only its cookies.
- *
- * **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}
- */
-export class BatchHandlerPlugin {
-    name = '~batch';
-    /**
-     * Run batch interceptors inside the tracing interceptors
-     * so each subrequest gets its own span instead of sharing one batch-level span.
-     */
-    after = ['~tracing'];
-    maxSize;
-    mapSubrequest;
-    mapSubresponse;
-    successStatus;
-    headers;
-    keepAliveEnabled;
-    keepAliveInterval;
-    constructor(options = {}) {
-        this.maxSize = options.maxSize ?? DEFAULT_BATCH_MAX_SIZE;
-        this.mapSubrequest =
-            options.mapSubrequest ??
-                ((subRequest, { request: batchRequest }) => ({
-                    ...subRequest,
-                    headers: {
-                        ...subRequest.headers,
-                        /**
-                         * The batch request headers win over the subrequest ones. They are the only ones the
-                         * transport actually saw, so headers the browser injects on its own, such as `cookie`
-                         * or `origin`, cannot be overridden by a subrequest, which is just request payload.
-                         */
-                        ...batchRequest.headers,
-                        [BATCH_HEADER]: undefined, // useful in case batch plugin is used multiple times
-                    },
-                }));
-        this.mapSubresponse =
-            options.mapSubresponse ??
-                ((subresponse, { headers: batchHeaders }) => {
-                    const headers = {};
-                    for (const [name, value] of Object.entries(subresponse.headers)) {
-                        if (name !== 'set-cookie' &&
-                            flattenStandardHeader(value) !== flattenStandardHeader(batchHeaders[name])) {
-                            headers[name] = value;
-                        }
-                    }
-                    return { ...subresponse, headers };
-                });
-        this.successStatus = options.successStatus ?? 207;
-        this.headers = options.headers ?? {};
-        this.keepAliveEnabled = options.keepAlive !== false;
-        this.keepAliveInterval =
-            (typeof options.keepAlive === 'object' ? options.keepAlive.interval : undefined) ?? 15_000;
-    }
-    init(options) {
-        const routingInterceptor = async (interceptorOptions) => {
-            const batchHeader = flattenStandardHeader(interceptorOptions.request.headers[BATCH_HEADER]);
-            if (batchHeader === undefined) {
-                return interceptorOptions.next();
-            }
-            const streaming = batchHeader === 'streaming';
-            let messages;
-            try {
-                if (interceptorOptions.request.method === 'GET') {
-                    const [, search] = parseStandardUrl(interceptorOptions.request.url);
-                    const params = new URLSearchParams(search);
-                    const data = params.getAll('data').at(-1);
-                    if (!data) {
-                        return {
-                            matched: true,
-                            response: {
-                                status: 400,
-                                headers: {},
-                                body: 'Missing data parameter for batch request',
-                            },
-                        };
-                    }
-                    const mightBeMessages = JSON.parse(data);
-                    if (!isClientPeerSendMessages(mightBeMessages)) {
-                        return {
-                            matched: true,
-                            response: { status: 400, headers: {}, body: 'Invalid batch request data parameter' },
-                        };
-                    }
-                    messages = mightBeMessages;
-                }
-                else {
-                    const mightBeMessages = await interceptorOptions.request.resolveBody();
-                    if (!isClientPeerSendMessages(mightBeMessages)) {
-                        return {
-                            matched: true,
-                            response: { status: 400, headers: {}, body: 'Invalid batch request body' },
-                        };
-                    }
-                    messages = mightBeMessages;
-                }
-            }
-            catch (error) {
-                return {
-                    matched: true,
-                    response: {
-                        status: 400,
-                        headers: {},
-                        body: error instanceof ORPCError ? error.message : 'Invalid batch request',
-                    },
-                };
-            }
-            const outerMethod = interceptorOptions.request.method;
-            if ((outerMethod === 'GET' || outerMethod === 'QUERY') &&
-                messages.some((message) => message.kind === 'request' && message.json.method !== outerMethod)) {
-                return {
-                    matched: true,
-                    response: {
-                        status: 400,
-                        headers: {},
-                        body: `${outerMethod} batch requests only accept ${outerMethod} sub-requests`,
-                    },
-                };
-            }
-            const maxSize = await value(this.maxSize, interceptorOptions);
-            if (messages.length > maxSize) {
-                return {
-                    matched: true,
-                    response: {
-                        status: 413,
-                        headers: {},
-                        body: 'Batch request size exceeds the maximum allowed size',
-                    },
-                };
-            }
-            const status = await value(this.successStatus, interceptorOptions);
-            const headers = await value(this.headers, interceptorOptions);
-            // Messages the peer sends before the response streams, or the whole body when it does not
-            const bufferedMessages = [];
-            let streamController;
-            let keepAliveTimer;
-            // Subresponses wait here for the batch headers: lifted from all of them, or only the first in streaming mode
-            const ready = messages.map(() => promiseWithResolvers());
-            const heads = ready.map(({ promise }) => promise);
-            const lifting = streaming
-                ? firstSubresponseHead(heads).then((head) => ({
-                    batchHeaders: liftCookies(headers, [headers, head?.headers ?? {}]),
-                    streams: true,
-                }))
-                : Promise.all(heads).then((all) => {
-                    const present = all.filter((head) => head !== undefined);
-                    return {
-                        batchHeaders: liftSubresponseHeaders(headers, present.map((head) => head.headers)),
-                        streams: present.some((head) => head.stream),
-                    };
-                });
-            const clearKeepAlive = () => {
-                if (keepAliveTimer !== undefined) {
-                    clearInterval(keepAliveTimer);
-                    keepAliveTimer = undefined;
-                }
-            };
-            const scheduleKeepAlive = () => {
-                if (!this.keepAliveEnabled) {
-                    return;
-                }
-                clearKeepAlive();
-                keepAliveTimer = setInterval(() => {
-                    try {
-                        // Zero-length length-prefixed frame = keep-alive (ignored by clients)
-                        streamController.enqueue(encodeLengthPrefix(0));
-                    }
-                    catch {
-                        // Stream may already be closed or errored.
-                        clearKeepAlive();
-                    }
-                }, this.keepAliveInterval);
-            };
-            const enqueueMessage = async (message) => {
-                for (const chunk of await encodeFrame(message)) {
-                    streamController.enqueue(chunk);
-                }
-                scheduleKeepAlive(); // reset idle timer
-            };
-            const peer = new ServerPeer(async (message) => {
-                if (streamController === undefined) {
-                    bufferedMessages.push(message);
-                }
-                else {
-                    await enqueueMessage(message);
-                }
-            });
-            const handleIndividualRequest = async (request, markReady) => {
-                let response;
-                try {
-                    request = this.mapSubrequest(request, interceptorOptions);
-                    const result = await interceptorOptions.next({ ...interceptorOptions, request });
-                    response = result.matched
-                        ? result.response
-                        : { status: 404, headers: {}, body: 'No procedure matched' };
-                }
-                catch (err) {
-                    response = internalError(err);
-                }
-                markReady({
-                    headers: response.headers,
-                    stream: response.body instanceof ReadableStream || isAsyncIteratorObject(response.body),
-                });
-                const { batchHeaders } = await lifting;
-                try {
-                    return this.mapSubresponse(response, { status, headers: batchHeaders }, interceptorOptions);
-                }
-                catch (err) {
-                    return internalError(err);
-                }
-            };
-            const runSubrequests = async () => {
-                const promise = Promise.all(messages.map((msg, i) => {
-                    const { resolve } = ready[i];
-                    // Not every message reaches the handler, such as a cancel or a repeated id
-                    return peer
-                        .message(msg, (request) => handleIndividualRequest(request, resolve))
-                        .finally(() => resolve(undefined));
-                }));
-                const signal = interceptorOptions.request.signal;
-                const closePeer = () => peer.close(signal?.reason);
-                if (signal?.aborted) {
-                    void closePeer();
-                }
-                signal?.addEventListener('abort', closePeer);
-                try {
-                    await promise;
-                }
-                finally {
-                    signal?.removeEventListener('abort', closePeer);
-                }
-            };
-            const subrequests = runSubrequests();
-            const { batchHeaders, streams } = await lifting;
-            const framedHeaders = {
-                ...batchHeaders,
-                'content-type': batchHeaders['content-type'] ?? BATCH_CONTENT_TYPE,
-            };
-            if (!streams) {
-                await subrequests;
-                await peer.close();
-                if (bufferedMessages.some((msg) => msg.binary !== undefined)) {
-                    const chunks = (await Promise.all(bufferedMessages.map(encodeFrame))).flat();
-                    return {
-                        matched: true,
-                        response: {
-                            status,
-                            headers: framedHeaders,
-                            body: new Blob(chunks),
-                        },
-                    };
-                }
-                return {
-                    matched: true,
-                    response: { status, headers: batchHeaders, body: bufferedMessages },
-                };
-            }
-            // Answer with a length-prefixed stream of every message, starting with those buffered so far
-            const body = new ReadableStream({
-                start(controller) {
-                    streamController = controller;
-                    scheduleKeepAlive();
-                },
-                async cancel(reason) {
-                    clearKeepAlive();
-                    await peer.close(reason);
-                },
-            });
-            const flushed = Promise.all(bufferedMessages.splice(0).map(enqueueMessage));
-            // DO NOT await here to block streaming response
-            Promise.all([flushed, subrequests])
-                .then(async () => {
-                clearKeepAlive();
-                streamController.close();
-                await peer.close();
-            })
-                .catch(async (error) => {
-                clearKeepAlive();
-                streamController.error(error);
-                await peer.close(error);
-            });
-            return {
-                matched: true,
-                response: {
-                    status,
-                    headers: framedHeaders,
-                    body,
-                },
-            };
-        };
-        return {
-            ...options,
-            routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)],
-        };
-    }
-}
+* Handles batch requests sent by the client Batch Link Plugin, splitting each
+* batch into sub-requests and sending their responses back together.
+*
+* @remarks
+* The client Batch Link Plugin's `mode` picks how each batch responds: `buffered` (default) waits for every
+* sub-response and carries their cookies and shared headers; `streaming` starts once the first is ready and
+* carries only its cookies.
+*
+* **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}
+*/
+var BatchHandlerPlugin = class {
+	name = "~batch";
+	/**
+	* Run batch interceptors inside the tracing interceptors
+	* so each subrequest gets its own span instead of sharing one batch-level span.
+	*/
+	after = ["~tracing"];
+	maxSize;
+	mapSubrequest;
+	mapSubresponse;
+	successStatus;
+	headers;
+	keepAliveEnabled;
+	keepAliveInterval;
+	constructor(options = {}) {
+		this.maxSize = options.maxSize ?? DEFAULT_BATCH_MAX_SIZE;
+		this.mapSubrequest = options.mapSubrequest ?? ((subRequest, { request: batchRequest }) => ({
+			...subRequest,
+			headers: {
+				...subRequest.headers,
+				/**
+				* The batch request headers win over the subrequest ones. They are the only ones the
+				* transport actually saw, so headers the browser injects on its own, such as `cookie`
+				* or `origin`, cannot be overridden by a subrequest, which is just request payload.
+				*/
+				...batchRequest.headers,
+				[BATCH_HEADER]: void 0
+			}
+		}));
+		this.mapSubresponse = options.mapSubresponse ?? ((subresponse, { headers: batchHeaders }) => {
+			const headers = {};
+			for (const [name, value] of Object.entries(subresponse.headers)) if (name !== "set-cookie" && flattenStandardHeader(value) !== flattenStandardHeader(batchHeaders[name])) headers[name] = value;
+			return {
+				...subresponse,
+				headers
+			};
+		});
+		this.successStatus = options.successStatus ?? 207;
+		this.headers = options.headers ?? {};
+		this.keepAliveEnabled = options.keepAlive !== false;
+		this.keepAliveInterval = (typeof options.keepAlive === "object" ? options.keepAlive.interval : void 0) ?? 15e3;
+	}
+	init(options) {
+		const routingInterceptor = async (interceptorOptions) => {
+			const batchHeader = flattenStandardHeader(interceptorOptions.request.headers[BATCH_HEADER]);
+			if (batchHeader === void 0) return interceptorOptions.next();
+			const streaming = batchHeader === "streaming";
+			let messages;
+			try {
+				if (interceptorOptions.request.method === "GET") {
+					const [, search] = parseStandardUrl(interceptorOptions.request.url);
+					const data = new URLSearchParams(search).getAll("data").at(-1);
+					if (!data) return {
+						matched: true,
+						response: {
+							status: 400,
+							headers: {},
+							body: "Missing data parameter for batch request"
+						}
+					};
+					const mightBeMessages = JSON.parse(data);
+					if (!isClientPeerSendMessages(mightBeMessages)) return {
+						matched: true,
+						response: {
+							status: 400,
+							headers: {},
+							body: "Invalid batch request data parameter"
+						}
+					};
+					messages = mightBeMessages;
+				} else {
+					const mightBeMessages = await interceptorOptions.request.resolveBody();
+					if (!isClientPeerSendMessages(mightBeMessages)) return {
+						matched: true,
+						response: {
+							status: 400,
+							headers: {},
+							body: "Invalid batch request body"
+						}
+					};
+					messages = mightBeMessages;
+				}
+			} catch (error) {
+				return {
+					matched: true,
+					response: {
+						status: 400,
+						headers: {},
+						body: error instanceof ORPCError ? error.message : "Invalid batch request"
+					}
+				};
+			}
+			const outerMethod = interceptorOptions.request.method;
+			if ((outerMethod === "GET" || outerMethod === "QUERY") && messages.some((message) => message.kind === "request" && message.json.method !== outerMethod)) return {
+				matched: true,
+				response: {
+					status: 400,
+					headers: {},
+					body: `${outerMethod} batch requests only accept ${outerMethod} sub-requests`
+				}
+			};
+			const maxSize = await value(this.maxSize, interceptorOptions);
+			if (messages.length > maxSize) return {
+				matched: true,
+				response: {
+					status: 413,
+					headers: {},
+					body: "Batch request size exceeds the maximum allowed size"
+				}
+			};
+			const status = await value(this.successStatus, interceptorOptions);
+			const headers = await value(this.headers, interceptorOptions);
+			const bufferedMessages = [];
+			let streamController;
+			let keepAliveTimer;
+			const ready = messages.map(() => promiseWithResolvers());
+			const heads = ready.map(({ promise }) => promise);
+			const lifting = streaming ? firstSubresponseHead(heads).then((head) => ({
+				batchHeaders: liftCookies(headers, [headers, head?.headers ?? {}]),
+				streams: true
+			})) : Promise.all(heads).then((all) => {
+				const present = all.filter((head) => head !== void 0);
+				return {
+					batchHeaders: liftSubresponseHeaders(headers, present.map((head) => head.headers)),
+					streams: present.some((head) => head.stream)
+				};
+			});
+			const clearKeepAlive = () => {
+				if (keepAliveTimer !== void 0) {
+					clearInterval(keepAliveTimer);
+					keepAliveTimer = void 0;
+				}
+			};
+			const scheduleKeepAlive = () => {
+				if (!this.keepAliveEnabled) return;
+				clearKeepAlive();
+				keepAliveTimer = setInterval(() => {
+					try {
+						streamController.enqueue(encodeLengthPrefix(0));
+					} catch {
+						clearKeepAlive();
+					}
+				}, this.keepAliveInterval);
+			};
+			const enqueueMessage = async (message) => {
+				for (const chunk of await encodeFrame(message)) streamController.enqueue(chunk);
+				scheduleKeepAlive();
+			};
+			const peer = new ServerPeer(async (message) => {
+				if (streamController === void 0) bufferedMessages.push(message);
+				else await enqueueMessage(message);
+			});
+			const handleIndividualRequest = async (request, markReady) => {
+				let response;
+				try {
+					request = this.mapSubrequest(request, interceptorOptions);
+					const result = await interceptorOptions.next({
+						...interceptorOptions,
+						request
+					});
+					response = result.matched ? result.response : {
+						status: 404,
+						headers: {},
+						body: "No procedure matched"
+					};
+				} catch (err) {
+					response = internalError(err);
+				}
+				markReady({
+					headers: response.headers,
+					stream: response.body instanceof ReadableStream || isAsyncIteratorObject(response.body)
+				});
+				const { batchHeaders } = await lifting;
+				try {
+					return this.mapSubresponse(response, {
+						status,
+						headers: batchHeaders
+					}, interceptorOptions);
+				} catch (err) {
+					return internalError(err);
+				}
+			};
+			const runSubrequests = async () => {
+				const promise = Promise.all(messages.map((msg, i) => {
+					const { resolve } = ready[i];
+					return peer.message(msg, (request) => handleIndividualRequest(request, resolve)).finally(() => resolve(void 0));
+				}));
+				const unlisten = listenAbort(interceptorOptions.request.signal, (reason) => void peer.close(reason));
+				try {
+					await promise;
+				} finally {
+					unlisten();
+				}
+			};
+			const subrequests = runSubrequests();
+			const { batchHeaders, streams } = await lifting;
+			const framedHeaders = {
+				...batchHeaders,
+				"content-type": batchHeaders["content-type"] ?? "application/vnd.orpc.batch"
+			};
+			if (!streams) {
+				await subrequests;
+				await peer.close();
+				if (bufferedMessages.some((msg) => msg.binary !== void 0)) {
+					const chunks = (await Promise.all(bufferedMessages.map(encodeFrame))).flat();
+					return {
+						matched: true,
+						response: {
+							status,
+							headers: framedHeaders,
+							body: new Blob(chunks)
+						}
+					};
+				}
+				return {
+					matched: true,
+					response: {
+						status,
+						headers: batchHeaders,
+						body: bufferedMessages
+					}
+				};
+			}
+			const body = new ReadableStream({
+				start(controller) {
+					streamController = controller;
+					scheduleKeepAlive();
+				},
+				async cancel(reason) {
+					clearKeepAlive();
+					await peer.close(reason);
+				}
+			});
+			const flushed = Promise.all(bufferedMessages.splice(0).map(enqueueMessage));
+			Promise.all([flushed, subrequests]).then(async () => {
+				clearKeepAlive();
+				streamController.close();
+				await peer.close();
+			}).catch(async (error) => {
+				clearKeepAlive();
+				streamController.error(error);
+				await peer.close(error);
+			});
+			return {
+				matched: true,
+				response: {
+					status,
+					headers: framedHeaders,
+					body
+				}
+			};
+		};
+		return {
+			...options,
+			routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)]
+		};
+	}
+};
+export { BATCH_CONTENT_TYPE, BatchHandlerPlugin };