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

package/dist/implementer-router.d.mts

@@ -1,78 +0,0 @@
-import type { ErrorMap, InferRouterContractErrorMap, RouterContract } from "@orpc/contract";
-import type { IntersectPick, Public } from "@orpc/shared";
-import type { Context, MergedContext, MergedInitialContext } from "./context.mjs";
-import type { AnyMiddleware, Middleware } from "./middleware.mjs";
-import type { DecoratedMiddleware } from "./middleware-decorated.mjs";
-import type { ProcedureConfig } from "./procedure.mjs";
-import type { ContractedRouter } from "./router.mjs";
-import type { AugmentedRouterWithMiddlewares } from "./router-utils.mjs";
-import { ProcedureContract } from "@orpc/contract";
-import { ProcedureImplementer } from "./implementer-procedure.mjs";
-import { Lazy } from "./lazy.mjs";
-export declare class SharedRouterImplementer<
-	TContract extends RouterContract,
-	TInitialContext extends Context
-> {
-	private readonly contract;
-	private readonly config;
-	private readonly middlewares;
-	private constructor();
-	static create<
-		TContract extends RouterContract,
-		TInitialContext extends Context
-	>(contract: TContract, config: ProcedureConfig): SharedRouterImplementer<TContract, TInitialContext>;
-	static create<
-		TContract extends RouterContract,
-		TInitialContext extends Context,
-		TInjectedContext extends Context
-	>(contract: TContract, config: ProcedureConfig, middlewares: AnyMiddleware[]): SharedRouterImplementerWithMiddlewares<TContract, TInitialContext, TInjectedContext>;
-	use<
-		$OutContext extends IntersectPick<TInitialContext, $OutContext>,
-		$InContext extends Context = TInitialContext,
-		$ErrorMap extends ErrorMap = InferRouterContractErrorMap<TContract>
-	>(middleware: Middleware<$InContext | TInitialContext, $OutContext, unknown, unknown, $ErrorMap>): RouterImplementerWithMiddlewares<TContract, MergedInitialContext<TInitialContext, object, $InContext>, $OutContext>;
-	middleware<
-		$OutContext extends IntersectPick<TInitialContext, $OutContext>,
-		$Input,
-		$InContext extends Context = TInitialContext,
-		$Output = any
-	>(middleware: Middleware<$InContext | TInitialContext, $OutContext, $Input, $Output, InferRouterContractErrorMap<TContract>>): DecoratedMiddleware<MergedInitialContext<TInitialContext, object, $InContext>, $OutContext, $Input, $Output, object>;
-	router<T extends ContractedRouter<TContract, any>>(router: T): T;
-	lazy<T extends ContractedRouter<TContract, any>>(loader: () => Promise<{
-		default: T;
-	}>): Lazy<T>;
-}
-export interface SharedRouterImplementerWithMiddlewares<
-	TContract extends RouterContract,
-	TInitialContext extends Context,
-	TInjectedContext extends Context
-> {
-	use<
-		$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>,
-		$InContext extends Context = MergedContext<TInitialContext, TInjectedContext>,
-		$ErrorMap extends ErrorMap = InferRouterContractErrorMap<TContract>
-	>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, unknown, unknown, $ErrorMap>): RouterImplementerWithMiddlewares<TContract, MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>>;
-	middleware<
-		$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>,
-		$Input,
-		$InContext extends Context = MergedContext<TInitialContext, TInjectedContext>,
-		$Output = any
-	>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, $Input, $Output, InferRouterContractErrorMap<TContract>>): DecoratedMiddleware<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, $Input, $Output, object>;
-	router<T extends ContractedRouter<TContract, MergedContext<TInitialContext, TInjectedContext>>>(router: T): AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, object>;
-	lazy<T extends ContractedRouter<TContract, any>>(loader: () => Promise<{
-		default: T;
-	}>): Lazy<AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, object>>;
-}
-export type RouterImplementer<
-	TContract extends RouterContract,
-	TInitialContext extends Context
-> = TContract extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureImplementer<TInitialContext, object, $InputSchema, $OutputSchema, $ErrorMap> : Public<SharedRouterImplementer<TContract, TInitialContext>> & { [K in keyof TContract]: TContract[K] extends RouterContract ? RouterImplementer<TContract[K], TInitialContext> : never };
-export type RouterImplementerWithMiddlewares<
-	TContract extends RouterContract,
-	TInitialContext extends Context,
-	TInjectedContext extends Context
-> = TContract extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureImplementer<TInitialContext, TInjectedContext, $InputSchema, $OutputSchema, $ErrorMap> : SharedRouterImplementerWithMiddlewares<TContract, TInitialContext, TInjectedContext> & { [K in keyof TContract]: TContract[K] extends RouterContract ? RouterImplementerWithMiddlewares<TContract[K], TInitialContext, TInjectedContext> : never };
-export declare function createRouterImplementer<
-	TContract extends RouterContract,
-	TInitialContext extends Context
->(contract: TContract, config: ProcedureConfig): RouterImplementer<TContract, TInitialContext>;

package/dist/implementer-router.mjs

@@ -1,77 +0,0 @@
-import { ProcedureContract } from "@orpc/contract";
-import { bindMethods } from "@orpc/shared";
-import { ProcedureImplementer } from "./implementer-procedure.mjs";
-import { Lazy } from "./lazy.mjs";
-import { decorateMiddleware } from "./middleware-decorated.mjs";
-import { withHiddenRouterContract } from "./router-hidden.mjs";
-import { augmentImplementedRouter } from "./router-utils.mjs";
-export class SharedRouterImplementer {
-	contract;
-	config;
-	middlewares;
-	constructor(contract, config, middlewares) {
-		this.contract = contract;
-		this.config = config;
-		this.middlewares = middlewares;
-	}
-	static create(contract, config, middlewares = []) {
-		return new SharedRouterImplementer(contract, config, middlewares);
-	}
-	use(middleware) {
-		return createRouterImplementerInternal(this.contract, this.config, [...this.middlewares, middleware]);
-	}
-	middleware(middleware) {
-		const allMiddlewares = [...this.middlewares, middleware];
-		let current = decorateMiddleware(allMiddlewares.shift());
-		for (const mid of allMiddlewares) {
-			current = current.use(mid);
-		}
-		return current;
-	}
-	router(router) {
-		if (this.middlewares.length) {
-			router = augmentImplementedRouter(router, {
-				...this.config,
-				middlewares: this.middlewares
-			});
-		}
-		return withHiddenRouterContract(router, this.contract);
-	}
-	lazy(loader) {
-		return new Lazy({
-			loader: async () => {
-				const { default: router } = await loader();
-				return { default: this.router(router) };
-			},
-			meta: {}
-		});
-	}
-}
-export function createRouterImplementer(contract, config) {
-	return createRouterImplementerInternal(contract, config, []);
-}
-function createRouterImplementerInternal(contract, config, middlewares) {
-	if (contract instanceof ProcedureContract) {
-		return new ProcedureImplementer({
-			...config,
-			...contract["~orpc"],
-			orderedMiddlewares: middlewares.map((middleware) => ({ middleware }))
-		});
-	}
-	const implementer = {};
-	for (const [key, child] of Object.entries(contract)) {
-		implementer[key] = createRouterImplementerInternal(child, config, middlewares);
-	}
-	const shared = bindMethods(SharedRouterImplementer.create(contract, config, middlewares));
-	for (const [key, method] of Object.entries(shared)) {
-		if (key in implementer) {
-			const child = implementer[key];
-			implementer[key] = new Proxy(method, { get(_, p) {
-				return Reflect.get(child, p);
-			} });
-		} else {
-			implementer[key] = method;
-		}
-	}
-	return implementer;
-}

package/dist/implementer.d.mts

@@ -1,22 +0,0 @@
-import type { RouterContract } from "@orpc/contract";
-import type { DefaultInitialContext } from "./builder.mjs";
-import type { Context } from "./context.mjs";
-import type { RouterImplementer } from "./implementer-router.mjs";
-import type { ProcedureConfig } from "./procedure.mjs";
-export type Implementer<
-	TContract extends RouterContract,
-	TInitialContext extends Context
-> = {
-	$context<T extends Context = DefaultInitialContext>(): Implementer<TContract, T & object>;
-	$config(config: ProcedureConfig): Implementer<TContract, TInitialContext>;
-} & RouterImplementer<TContract, TInitialContext>;
-/**
-* Turns a contract into an implementer, used to implement the contract's
-* procedures, routers, and middleware with full type safety.
-*
-* @see {@link https://orpc.dev/docs/contract/implementation#implementer | Contract Implementation - Implementer}
-*/
-export declare function implement<
-	TContract extends RouterContract,
-	TInitialContext extends Context = DefaultInitialContext
->(contract: TContract, config?: ProcedureConfig): Implementer<TContract, TInitialContext & object>;

package/dist/implementer.mjs

@@ -1,30 +0,0 @@
-import { isTypescriptObject } from "@orpc/shared";
-import { createRouterImplementer } from "./implementer-router.mjs";
-
-export function implement(contract, config = {}) {
-	
-	
-	const routerImplementer = createRouterImplementer(contract, config);
-	const implementer = new Proxy(routerImplementer, { get(_, p) {
-		let method;
-		if (p === "$context") {
-			method = () => implementer;
-		} else if (p === "$config") {
-			method = (incoming) => implement(contract, {
-				...config,
-				...incoming
-			});
-		}
-		const value = Reflect.get(routerImplementer, p);
-		if (method) {
-			if (!isTypescriptObject(value)) {
-				return method;
-			}
-			return new Proxy(method, { get(_, p) {
-				return Reflect.get(value, p);
-			} });
-		}
-		return value;
-	} });
-	return implementer;
-}

package/dist/index.d.mts

@@ -1,57 +0,0 @@
-export * from "./builder.mjs";
-export * from "./builder-variants.mjs";
-export * from "./constants.mjs";
-export * from "./context.mjs";
-export * from "./implementer.mjs";
-export * from "./implementer-procedure.mjs";
-export { SharedRouterImplementer } from "./implementer-router.mjs";
-export type { RouterImplementer, RouterImplementerWithMiddlewares, SharedRouterImplementerWithMiddlewares } from "./implementer-router.mjs";
-export * from "./lazy.mjs";
-export * from "./middleware.mjs";
-export type { DecoratedMiddleware } from "./middleware-decorated.mjs";
-export * from "./procedure.mjs";
-export * from "./procedure-client.mjs";
-export * from "./procedure-decorated.mjs";
-export { call } from "./procedure-utils.mjs";
-export type { CallOptions, CallRest } from "./procedure-utils.mjs";
-export * from "./router.mjs";
-export type { 
-/**
-* @deprecated Use `InferRouterFinalContexts` instead.
-*/
- InferRouterFinalContexts as InferRouterCurrentContexts } from "./router.mjs";
-export * from "./router-client.mjs";
-export { getRouter, resolveContractProcedure, unlazyRouter, walkProcedureContractsAsync, walkProcedureContractsSync } from "./router-utils.mjs";
-export type { AugmentedRouter, AugmentedRouterWithMiddlewares, UnlaziedRouter, WalkProcedureContractsLazyResult } from "./router-utils.mjs";
-export type { AnyORPCError, AnyORPCErrorJSON, Client, ClientContext, ClientOptions, ClientRest, FriendlyClientOptions, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, RPCJsonSerialization, RPCJsonSerializationMeta, RPCJsonSerializerHandler, RPCJsonSerializerOptions, RPCSerializerOptions, RPCSerializerSerializeOptions, SafeResult } from "@orpc/client";
-export { COMMON_ERROR_STATUS_MAP, isDefinedError, ORPCError, RPCJsonSerializer, RPCSerializer, safe, toORPCError } from "@orpc/client";
-export type { AnyMetaPlugin, AnySchema, ErrorMap, ErrorMapItem, InferSchemaInput, InferSchemaOutput, InitialInputSchema, InitialOutputSchema, MergedErrorMap, MergedSchema, Meta, MetaPlugin, MetaPluginDefinition, ORPCErrorConstructorMap, ORPCErrorConstructorMapItem, ORPCErrorConstructorMapItemOptions, ORPCErrorFactory, ORPCErrorFactoryOptions, ORPCErrorFromErrorMap, ProcedureContract, ProcedureContractDefinition, RouterContract, Schema } from "@orpc/contract";
-export { asyncIteratorObject, defineMeta, error, eventIterator, type, ValidationError } from "@orpc/contract";
-export type { AsyncCleanupFn, AsyncIteratorClassNextFn, DistributiveOmit, IntersectPick, MaybeOptionalOptions, PromiseWithError, Public, Registry, ThrowableError } from "@orpc/shared";
-export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, 
-/**
-* @deprecated Use `asyncIteratorToStream` instead.
-*/
- asyncIteratorToStream as eventIteratorToStream, 
-/**
-* @deprecated Use `asyncIteratorToUnproxiedDataStream` instead.
-*/
- asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, 
-/**
-* @deprecated Use `streamToAsyncIteratorObject` instead.
-*/
- streamToAsyncIteratorObject as streamToEventIterator } from "@orpc/shared";
-export type { EventMeta, StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from "@standard-server/core";
-export { ErrorEvent, 
-/**
-* Retrieves metadata attached to a single iterator event value.
-*
-* @see {@link https://orpc.dev/docs/helpers/publisher | Publisher Helpers}
-*/
- getEventMeta, unwrapEvent, 
-/**
-* Returns a new iterator event value with attached, validated metadata.
-*
-* @see {@link https://orpc.dev/docs/async-iterator-object#last-event-id--event-metadata | AsyncIteratorObject (SSE) - Last Event ID & Event Metadata}
-*/
- withEventMeta } from "@standard-server/core";

package/dist/index.mjs

@@ -1,30 +0,0 @@
-export * from "./builder.mjs";
-export * from "./builder-variants.mjs";
-export * from "./constants.mjs";
-export * from "./context.mjs";
-export * from "./implementer.mjs";
-export * from "./implementer-procedure.mjs";
-export { SharedRouterImplementer } from "./implementer-router.mjs";
-export * from "./lazy.mjs";
-export * from "./middleware.mjs";
-export * from "./procedure.mjs";
-export * from "./procedure-client.mjs";
-export * from "./procedure-decorated.mjs";
-export { call } from "./procedure-utils.mjs";
-export * from "./router.mjs";
-export * from "./router-client.mjs";
-export { getRouter, resolveContractProcedure, unlazyRouter, walkProcedureContractsAsync, walkProcedureContractsSync } from "./router-utils.mjs";
-export { COMMON_ERROR_STATUS_MAP, isDefinedError, ORPCError, RPCJsonSerializer, RPCSerializer, safe, toORPCError } from "@orpc/client";
-export { asyncIteratorObject, defineMeta, error, eventIterator, type, ValidationError } from "@orpc/contract";
-export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, 
-
- asyncIteratorToStream as eventIteratorToStream, 
-
- asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, 
-
- streamToAsyncIteratorObject as streamToEventIterator } from "@orpc/shared";
-export { ErrorEvent, 
-
- getEventMeta, unwrapEvent, 
-
- withEventMeta } from "@standard-server/core";

package/dist/lazy.d.mts

@@ -1,20 +0,0 @@
-import type { AnyMetaPlugin, Meta } from "@orpc/contract";
-export interface LazyDefinition<T> {
-	meta: Meta;
-	metaPlugins?: AnyMetaPlugin[] | undefined;
-	loader: () => Promise<{
-		default: T;
-	}>;
-}
-export declare class Lazy<T> {
-	"~orpc": LazyDefinition<T>;
-	constructor(def: LazyDefinition<T>);
-	/**
-	* Checks if the given instance satisfies the {@link Lazy} class/interface.
-	*/
-	static [Symbol.hasInstance](instance: unknown): boolean;
-}
-export type Lazyable<T> = T | Lazy<T>;
-export declare function unlazy<T extends Lazyable<any>>(maybeLazy: T): Promise<{
-	default: T extends Lazy<infer U> ? U : T;
-}>;

package/dist/lazy.mjs

@@ -1,22 +0,0 @@
-import { getConstructor, isTypescriptObject } from "@orpc/shared";
-export class Lazy {
-	"~orpc";
-	constructor(def) {
-		this["~orpc"] = def;
-	}
-	
-	static [Symbol.hasInstance](instance) {
-		if (this !== Lazy) {
-			
-			return Function.prototype[Symbol.hasInstance].call(this, instance);
-		}
-		const constructor = getConstructor(instance);
-		if (constructor === Lazy) {
-			return true;
-		}
-		return isTypescriptObject(instance) && isTypescriptObject(instance["~orpc"]) && isTypescriptObject(instance["~orpc"].meta) && (instance["~orpc"].metaPlugins === undefined || Array.isArray(instance["~orpc"].metaPlugins)) && typeof instance["~orpc"].loader === "function";
-	}
-}
-export function unlazy(maybeLazy) {
-	return maybeLazy instanceof Lazy ? maybeLazy["~orpc"].loader() : Promise.resolve({ default: maybeLazy });
-}

package/dist/middleware-decorated.d.mts

@@ -1,27 +0,0 @@
-import type { ErrorMap, MergedErrorMap } from "@orpc/contract";
-import type { IntersectPick } from "@orpc/shared";
-import type { Context, MergedContext, MergedInitialContext } from "./context.mjs";
-import type { Middleware } from "./middleware.mjs";
-export interface DecoratedMiddleware<
-	TInContext extends Context,
-	TOutContext extends Context,
-	TInput,
-	TOutput,
-	TErrorMap extends ErrorMap
-> extends Middleware<TInContext, TOutContext, TInput, TOutput, TErrorMap> {
-	adaptInput<T>(adapt: (input: T) => TInput): DecoratedMiddleware<TInContext, TOutContext, T, TOutput, TErrorMap>;
-	errors<T extends ErrorMap>(errors: T): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, MergedErrorMap<TErrorMap, T>>;
-	use<
-		$OutContext extends IntersectPick<MergedContext<TInContext, TOutContext>, $OutContext>,
-		$Input extends TInput,
-		$InContext extends Context = MergedContext<TInContext, TOutContext>,
-		$ErrorMap extends ErrorMap = TErrorMap
-	>(middleware: Middleware<$InContext | MergedContext<TInContext, TOutContext>, $OutContext, $Input, TOutput, $ErrorMap>): DecoratedMiddleware<MergedInitialContext<TInContext, TOutContext, $InContext>, MergedContext<TOutContext, $OutContext>, $Input, TOutput, MergedErrorMap<$ErrorMap, TErrorMap>>;
-}
-export declare function decorateMiddleware<
-	TInContext extends Context,
-	TOutContext extends Context,
-	TInput,
-	TOutput,
-	TErrorMap extends ErrorMap
->(middleware: Middleware<TInContext, TOutContext, TInput, TOutput, TErrorMap>): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, TErrorMap>;

package/dist/middleware-decorated.mjs

@@ -1,65 +0,0 @@
-import { mergeErrorMap } from "@orpc/contract";
-import { toArray } from "@orpc/shared";
-export function decorateMiddleware(middleware) {
-	const decorated = ((...args) => middleware(...args));
-	decorated["~orpc"] = middleware["~orpc"];
-	Object.defineProperty(decorated, "name", { value: middleware.name });
-	decorated.adaptInput = (adapt) => {
-		const mapped = decorateMiddleware((opts, input, ...args) => {
-			return middleware(opts, adapt(input), ...args);
-		});
-		mapped["~orpc"] = decorated["~orpc"];
-		Object.defineProperty(mapped, "name", { value: decorated.name });
-		return mapped;
-	};
-	decorated.errors = (errors) => {
-		const newMiddleware = decorateMiddleware(decorated);
-		newMiddleware["~orpc"] = {
-			...decorated["~orpc"],
-			errorMap: mergeErrorMap(decorated["~orpc"]?.errorMap, errors)
-		};
-		return newMiddleware;
-	};
-	decorated.use = (usedMiddleware) => {
-		const merged = decorateMiddleware((opts, ...args) => {
-			return middleware({
-				...opts,
-				async next(nextOpts1) {
-					const signal = nextOpts1?.signal ?? opts.signal;
-					const result = await usedMiddleware({
-						...opts,
-						context: {
-							...opts.context,
-							...nextOpts1?.context
-						},
-						signal,
-						next(nextOpts2, ...args) {
-							return opts.next({
-								context: {
-									...nextOpts1?.context,
-									...nextOpts2?.context
-								},
-								signal: nextOpts2?.signal ?? signal
-							}, ...args);
-						}
-					}, ...args);
-					return {
-						...result,
-						context: {
-							...nextOpts1?.context,
-							...result.context
-						}
-					};
-				}
-			}, ...args);
-		});
-		merged["~orpc"] = {
-			...decorated["~orpc"],
-			errorMap: mergeErrorMap(usedMiddleware["~orpc"]?.errorMap, decorated["~orpc"]?.errorMap),
-			metaPlugins: [...toArray(decorated["~orpc"]?.metaPlugins), ...toArray(usedMiddleware["~orpc"]?.metaPlugins)]
-		};
-		Object.defineProperty(merged, "name", { value: `${decorated.name} + ${usedMiddleware.name}` });
-		return merged;
-	};
-	return decorated;
-}

package/dist/middleware.d.mts

@@ -1,70 +0,0 @@
-import type { AnyMetaPlugin, ErrorMap, ORPCErrorConstructorMap } from "@orpc/contract";
-import type { MaybeOptionalOptions, Promisable } from "@orpc/shared";
-import type { Context } from "./context.mjs";
-import type { AnyProcedure } from "./procedure.mjs";
-export type MiddlewareResult<
-	TOutContext extends Context,
-	TOutput
-> = Promisable<{
-	output: TOutput;
-	context: TOutContext;
-}>;
-export type MiddlewareNextOptions<TOutContext extends Context> = (object extends TOutContext ? {
-	context?: TOutContext | undefined;
-} : {
-	context: TOutContext;
-}) & {
-	/** Overrides the signal for the rest of the chain. */
-	signal?: AbortSignal | undefined;
-};
-export interface MiddlewareNext<TOutput> {
-	<T extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareNextOptions<T>>): MiddlewareResult<T, TOutput>;
-}
-export type MiddlewareDoneOptions<
-	TOutContext,
-	TOutput
-> = (object extends TOutContext ? {
-	context?: TOutContext | undefined;
-} : {
-	context: TOutContext;
-}) & {
-	output: TOutput;
-};
-export interface MiddlewareDone<TOutput> {
-	/**
-	* Create a successful result and terminate the middleware chain early.
-	*/
-	<TOutContext extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareDoneOptions<TOutContext, TOutput>>): MiddlewareResult<TOutContext, TOutput>;
-}
-export interface MiddlewareOptions<
-	TInContext extends Context,
-	TOutput,
-	TErrorConstructorMap extends ORPCErrorConstructorMap<any>
-> {
-	context: TInContext;
-	path: string[];
-	procedure: AnyProcedure;
-	signal?: AbortSignal | undefined;
-	lastEventId: string | undefined;
-	/**
-	* Invoke to continue the middleware chain.
-	*/
-	next: MiddlewareNext<TOutput>;
-	errors: TErrorConstructorMap;
-}
-export interface MiddlewareDefinition<TErrorMap extends ErrorMap> {
-	errorMap?: TErrorMap | undefined;
-	metaPlugins?: AnyMetaPlugin[] | undefined;
-}
-export interface Middleware<
-	TInContext extends Context,
-	TOutContext extends Context,
-	TInput,
-	TOutput,
-	TErrorMap extends ErrorMap
-> {
-	/** this property should be optional to support inline middleware */
-	"~orpc"?: MiddlewareDefinition<TErrorMap> | undefined;
-	(opts: MiddlewareOptions<TInContext, TOutput, ORPCErrorConstructorMap<TErrorMap>>, input: TInput, done: MiddlewareDone<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
-}
-export type AnyMiddleware = Middleware<any, any, any, any, any>;

package/dist/plugins/batch.d.mts

@@ -1,104 +0,0 @@
-import type { Promisable, Value } from "@orpc/shared";
-import type { StandardHeaders, StandardLazyRequest, StandardResponse } from "@standard-server/core";
-import type { StandardHandlerOptions, StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions } from "../adapters/standard/index.mjs";
-import type { Context } from "../context.mjs";
-/**
-* 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 declare const BATCH_CONTENT_TYPE = "application/vnd.orpc.batch";
-export 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.
-	*
-	* In `buffered` mode, the batch response also gets the cookies its sub-responses set, and the headers they all share.
-	* In `streaming` mode, it gets only the cookies of the first sub-response to be ready.
-	* 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 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 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>;
-}