@orpc/server 0.43.0 → 0.45.0

package/dist/shared/server.Cn9ybJtE.d.mts

@@ -0,0 +1,152 @@
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, ClientContext, Client } from '@orpc/client';
+import { IsNever, MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
+import { ErrorMap, ErrorMapItem, SchemaInput, HTTPPath, Meta, Schema, ContractProcedureDef, SchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure, MergedErrorMap } from '@orpc/contract';
+
+type Context = Record<string, any>;
+type MergedContext<T extends Context, U extends Context> = T & U;
+declare function mergeContext<T extends Context, U extends Context>(context: T, other: U): MergedContext<T, U>;
+type ConflictContextGuard<T extends Context> = true extends IsNever<T> | {
+    [K in keyof T]: IsNever<T[K]>;
+}[keyof T] ? never : unknown;
+
+type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
+type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
+type ORPCErrorConstructorMap<T extends ErrorMap> = {
+    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, SchemaInput<UInputSchema>> : never : never;
+};
+
+declare const LAZY_LOADER_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_LOADER_SYMBOL](): Promise<{
+        default: T;
+    }>;
+}
+type Lazyable<T> = T | Lazy<T>;
+interface LazyOptions {
+    prefix?: HTTPPath;
+}
+declare function lazy<T>(loader: () => Promise<{
+    default: T;
+}>): Lazy<T>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never> extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+};
+interface MiddlewareNextFn<TInContext extends Context, TOutput> {
+    <U extends Context & Partial<TInContext> = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TInContext;
+    path: string[];
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    next: MiddlewareNextFn<TInContext, TOutput>;
+    errors: TErrorConstructorMap;
+}
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TCurrentContext;
+    input: TInput;
+    path: string[];
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    errors: TErrorConstructorMap;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    (opt: ProcedureHandlerOptions<TCurrentContext, TInput, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
+}
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    __initialContext?: (type: TInitialContext) => unknown;
+    middlewares: AnyMiddleware[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+    handler: ProcedureHandler<TCurrentContext, any, THandlerOutput, any, any>;
+}
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>;
+    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>);
+}
+type AnyProcedure = Procedure<any, any, any, any, any, any, any>;
+declare function isProcedure(item: unknown): item is AnyProcedure;
+
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    context: TInitialContext;
+    input: SchemaInput<TInputSchema>;
+    errors: ORPCErrorConstructorMap<TErrorMap>;
+    path: string[];
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+}
+/**
+ * Options for creating a procedure caller with comprehensive type safety
+ */
+type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+    /**
+     * This is helpful for logging and analytics.
+     */
+    path?: string[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TInputSchema, TErrorMap, TMeta>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>[];
+} & (Record<never, never> extends TInitialContext ? {
+    context?: Value<TInitialContext, [clientContext: TClientContext]>;
+} : {
+    context: Value<TInitialContext, [clientContext: TClientContext]>;
+});
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+
+type AccessibleLazyRouter<T extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : Lazy<T> & (T extends AnyProcedure | undefined ? unknown : {
+    [K in keyof T]: T[K] extends AnyRouter ? AccessibleLazyRouter<T[K]> : never;
+});
+declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
+
+type Router<TInitialContext extends Context, TContract extends AnyContractRouter> = Lazyable<TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, any, UErrorMap, UMeta> : {
+    [K in keyof TContract]: TContract[K] extends AnyContractRouter ? Router<TInitialContext, TContract[K]> : never;
+}>;
+type AnyRouter = Router<any, any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer UInitialContext, any> ? UInitialContext : never;
+type InferRouterInputs<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterInputs<U> : T extends Procedure<any, any, infer UInputSchema, any, any, any, any> ? SchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterInputs<T[K]> : never;
+};
+type InferRouterOutputs<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterOutputs<U> : T extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput, any, any> ? SchemaOutput<UOutputSchema, UFuncOutput> : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterOutputs<T[K]> : never;
+};
+type AdaptedRouter<TRouter extends AnyRouter, TInitialContext extends Context, TErrorMap extends ErrorMap> = TRouter extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<AdaptedRouter<U, TInitialContext, TErrorMap>> : TRouter extends Procedure<any, infer UCurrentContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, UCurrentContext, UInputSchema, UOutputSchema, UFuncOutput, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
+    [K in keyof TRouter]: TRouter[K] extends AnyRouter ? AdaptedRouter<TRouter[K], TInitialContext, TErrorMap> : never;
+};
+interface AdaptRouterOptions<TErrorMap extends ErrorMap> {
+    middlewares: AnyMiddleware[];
+    tags?: readonly string[];
+    prefix?: HTTPPath;
+    errorMap: TErrorMap;
+}
+declare function adaptRouter<TRouter extends AnyRouter, TInitialContext extends Context, TErrorMap extends ErrorMap>(router: TRouter, options: AdaptRouterOptions<TErrorMap>): AdaptedRouter<TRouter, TInitialContext, TErrorMap>;
+declare function getRouterChild<T extends AnyRouter | Lazy<undefined>>(router: T, ...path: string[]): T extends Lazy<any> ? Lazy<AnyProcedure> | Lazy<Record<string, AnyRouter>> | Lazy<undefined> : AnyRouter | Lazy<undefined> | undefined;
+
+export { type AnyProcedure as A, type ProcedureDef as B, type Context as C, isProcedure as D, createProcedureClient as E, type InferRouterInputs as F, type InferRouterOutputs as G, adaptRouter as H, type InferRouterInitialContext as I, getRouterChild as J, type AccessibleLazyRouter as K, type Lazy as L, type Middleware as M, createAccessibleLazyRouter as N, type ORPCErrorConstructorMap as O, type ProcedureClientInterceptorOptions as P, type Router as R, type AnyRouter as a, Procedure as b, type ConflictContextGuard as c, type MergedContext as d, type MapInputMiddleware as e, type CreateProcedureClientOptions as f, type ProcedureClient as g, type ProcedureHandler as h, type AdaptRouterOptions as i, type AdaptedRouter as j, type AnyMiddleware as k, type Lazyable as l, mergeContext as m, LAZY_LOADER_SYMBOL as n, type LazyMeta as o, type LazyOptions as p, lazy as q, isLazy as r, type MiddlewareResult as s, type MiddlewareNextFnOptions as t, unlazy as u, type MiddlewareNextFn as v, type MiddlewareOutputFn as w, type MiddlewareOptions as x, middlewareOutputFn as y, type ProcedureHandlerOptions as z };

package/dist/shared/server.Cn9ybJtE.d.ts

@@ -0,0 +1,152 @@
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, ClientContext, Client } from '@orpc/client';
+import { IsNever, MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
+import { ErrorMap, ErrorMapItem, SchemaInput, HTTPPath, Meta, Schema, ContractProcedureDef, SchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure, MergedErrorMap } from '@orpc/contract';
+
+type Context = Record<string, any>;
+type MergedContext<T extends Context, U extends Context> = T & U;
+declare function mergeContext<T extends Context, U extends Context>(context: T, other: U): MergedContext<T, U>;
+type ConflictContextGuard<T extends Context> = true extends IsNever<T> | {
+    [K in keyof T]: IsNever<T[K]>;
+}[keyof T] ? never : unknown;
+
+type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
+type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
+type ORPCErrorConstructorMap<T extends ErrorMap> = {
+    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, SchemaInput<UInputSchema>> : never : never;
+};
+
+declare const LAZY_LOADER_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_LOADER_SYMBOL](): Promise<{
+        default: T;
+    }>;
+}
+type Lazyable<T> = T | Lazy<T>;
+interface LazyOptions {
+    prefix?: HTTPPath;
+}
+declare function lazy<T>(loader: () => Promise<{
+    default: T;
+}>): Lazy<T>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never> extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+};
+interface MiddlewareNextFn<TInContext extends Context, TOutput> {
+    <U extends Context & Partial<TInContext> = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TInContext;
+    path: string[];
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    next: MiddlewareNextFn<TInContext, TOutput>;
+    errors: TErrorConstructorMap;
+}
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TCurrentContext;
+    input: TInput;
+    path: string[];
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    errors: TErrorConstructorMap;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    (opt: ProcedureHandlerOptions<TCurrentContext, TInput, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
+}
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    __initialContext?: (type: TInitialContext) => unknown;
+    middlewares: AnyMiddleware[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+    handler: ProcedureHandler<TCurrentContext, any, THandlerOutput, any, any>;
+}
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>;
+    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>);
+}
+type AnyProcedure = Procedure<any, any, any, any, any, any, any>;
+declare function isProcedure(item: unknown): item is AnyProcedure;
+
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    context: TInitialContext;
+    input: SchemaInput<TInputSchema>;
+    errors: ORPCErrorConstructorMap<TErrorMap>;
+    path: string[];
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+}
+/**
+ * Options for creating a procedure caller with comprehensive type safety
+ */
+type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+    /**
+     * This is helpful for logging and analytics.
+     */
+    path?: string[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TInputSchema, TErrorMap, TMeta>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>[];
+} & (Record<never, never> extends TInitialContext ? {
+    context?: Value<TInitialContext, [clientContext: TClientContext]>;
+} : {
+    context: Value<TInitialContext, [clientContext: TClientContext]>;
+});
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+
+type AccessibleLazyRouter<T extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : Lazy<T> & (T extends AnyProcedure | undefined ? unknown : {
+    [K in keyof T]: T[K] extends AnyRouter ? AccessibleLazyRouter<T[K]> : never;
+});
+declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
+
+type Router<TInitialContext extends Context, TContract extends AnyContractRouter> = Lazyable<TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, any, UErrorMap, UMeta> : {
+    [K in keyof TContract]: TContract[K] extends AnyContractRouter ? Router<TInitialContext, TContract[K]> : never;
+}>;
+type AnyRouter = Router<any, any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer UInitialContext, any> ? UInitialContext : never;
+type InferRouterInputs<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterInputs<U> : T extends Procedure<any, any, infer UInputSchema, any, any, any, any> ? SchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterInputs<T[K]> : never;
+};
+type InferRouterOutputs<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterOutputs<U> : T extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput, any, any> ? SchemaOutput<UOutputSchema, UFuncOutput> : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterOutputs<T[K]> : never;
+};
+type AdaptedRouter<TRouter extends AnyRouter, TInitialContext extends Context, TErrorMap extends ErrorMap> = TRouter extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<AdaptedRouter<U, TInitialContext, TErrorMap>> : TRouter extends Procedure<any, infer UCurrentContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, UCurrentContext, UInputSchema, UOutputSchema, UFuncOutput, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
+    [K in keyof TRouter]: TRouter[K] extends AnyRouter ? AdaptedRouter<TRouter[K], TInitialContext, TErrorMap> : never;
+};
+interface AdaptRouterOptions<TErrorMap extends ErrorMap> {
+    middlewares: AnyMiddleware[];
+    tags?: readonly string[];
+    prefix?: HTTPPath;
+    errorMap: TErrorMap;
+}
+declare function adaptRouter<TRouter extends AnyRouter, TInitialContext extends Context, TErrorMap extends ErrorMap>(router: TRouter, options: AdaptRouterOptions<TErrorMap>): AdaptedRouter<TRouter, TInitialContext, TErrorMap>;
+declare function getRouterChild<T extends AnyRouter | Lazy<undefined>>(router: T, ...path: string[]): T extends Lazy<any> ? Lazy<AnyProcedure> | Lazy<Record<string, AnyRouter>> | Lazy<undefined> : AnyRouter | Lazy<undefined> | undefined;
+
+export { type AnyProcedure as A, type ProcedureDef as B, type Context as C, isProcedure as D, createProcedureClient as E, type InferRouterInputs as F, type InferRouterOutputs as G, adaptRouter as H, type InferRouterInitialContext as I, getRouterChild as J, type AccessibleLazyRouter as K, type Lazy as L, type Middleware as M, createAccessibleLazyRouter as N, type ORPCErrorConstructorMap as O, type ProcedureClientInterceptorOptions as P, type Router as R, type AnyRouter as a, Procedure as b, type ConflictContextGuard as c, type MergedContext as d, type MapInputMiddleware as e, type CreateProcedureClientOptions as f, type ProcedureClient as g, type ProcedureHandler as h, type AdaptRouterOptions as i, type AdaptedRouter as j, type AnyMiddleware as k, type Lazyable as l, mergeContext as m, LAZY_LOADER_SYMBOL as n, type LazyMeta as o, type LazyOptions as p, lazy as q, isLazy as r, type MiddlewareResult as s, type MiddlewareNextFnOptions as t, unlazy as u, type MiddlewareNextFn as v, type MiddlewareOutputFn as w, type MiddlewareOptions as x, middlewareOutputFn as y, type ProcedureHandlerOptions as z };

package/dist/shared/server.CynXWJja.d.ts

@@ -0,0 +1,9 @@
+import { C as Context } from './server.Cn9ybJtE.js';
+import { a as StandardHandlerOptions, b as StandardMatcher, c as StandardCodec } from './server.dPmfqnQI.js';
+
+interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T> {
+    matcher?: StandardMatcher;
+    codec?: StandardCodec;
+}
+
+export type { RPCHandlerOptions as R };

package/dist/shared/server.D86dtDX_.d.mts

@@ -0,0 +1,77 @@
+import { HTTPPath, Schema, Meta, SchemaOutput, ErrorFromErrorMap } from '@orpc/contract';
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { StandardResponse, StandardRequest } from '@orpc/standard-server';
+import { a as AnyRouter, A as AnyProcedure, C as Context, P as ProcedureClientInterceptorOptions, R as Router } from './server.Cn9ybJtE.mjs';
+import { ORPCError } from '@orpc/client';
+
+type StandardParams = Record<string, string>;
+type StandardMatchResult = {
+    path: string[];
+    procedure: AnyProcedure;
+    params?: StandardParams;
+} | undefined;
+interface StandardMatcher {
+    init(router: AnyRouter): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+}
+
+type StandardHandleOptions<T extends Context> = {
+    prefix?: HTTPPath;
+} & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+type WellStandardHandleOptions<T extends Context> = StandardHandleOptions<T> & {
+    context: T;
+};
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+type StandardHandlerInterceptorOptions<TContext extends Context> = WellStandardHandleOptions<TContext> & {
+    request: StandardRequest;
+};
+interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: Plugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Schema, Record<never, never>, Meta>, SchemaOutput<Schema, unknown>, ErrorFromErrorMap<Record<never, never>>>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly options;
+    private readonly plugin;
+    constructor(router: Router<T, any>, matcher: StandardMatcher, codec: StandardCodec, options?: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: StandardRequest, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<StandardHandleResult>;
+}
+
+interface Plugin<TContext extends Context> {
+    init?(options: StandardHandlerOptions<TContext>): void;
+}
+declare class CompositePlugin<TContext extends Context> implements Plugin<TContext> {
+    private readonly plugins;
+    constructor(plugins?: Plugin<TContext>[]);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { CompositePlugin as C, type Plugin as P, type StandardHandleOptions as S, type WellStandardHandleOptions as W, type StandardHandlerOptions as a, type StandardMatcher as b, type StandardCodec as c, type StandardHandlerInterceptorOptions as d, type StandardParams as e, type StandardMatchResult as f, type StandardHandleResult as g, StandardHandler as h };

package/dist/shared/server.Q6ZmnTgO.mjs

@@ -0,0 +1,12 @@
+class CompositePlugin {
+  constructor(plugins = []) {
+    this.plugins = plugins;
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options);
+    }
+  }
+}
+
+export { CompositePlugin as C };

package/dist/{chunk-MHVECKBC.js → shared/server.V6zT5iYQ.mjs}

@@ -1,5 +1,8 @@
-// src/lazy.ts
-var LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
+import { fallbackORPCErrorStatus, ORPCError } from '@orpc/client';
+import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, adaptRoute } from '@orpc/contract';
+import { value, intercept, toError } from '@orpc/shared';
+
+const LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
 function lazy(loader) {
   return {
     [LAZY_LOADER_SYMBOL]: loader
@@ -12,14 +15,12 @@ function unlazy(lazied) {
   return isLazy(lazied) ? lazied[LAZY_LOADER_SYMBOL]() : Promise.resolve({ default: lazied });
 }
 
-// src/procedure.ts
-import { isContractProcedure } from "@orpc/contract";
-var Procedure = class {
+class Procedure {
   "~orpc";
   constructor(def) {
     this["~orpc"] = def;
   }
-};
+}
 function isProcedure(item) {
   if (item instanceof Procedure) {
     return true;
@@ -27,7 +28,6 @@ function isProcedure(item) {
   return isContractProcedure(item) && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
 }
 
-// src/lazy-utils.ts
 function flatLazy(lazied) {
   const flattenLoader = async () => {
     let current = await unlazy(lazied);
@@ -56,18 +56,24 @@ function createLazyProcedureFormAnyLazy(lazied) {
   return lazyProcedure;
 }
 
-// src/middleware.ts
-function middlewareOutputFn(output) {
-  return { output, context: {} };
+function dedupeMiddlewares(compare, middlewares) {
+  let min = 0;
+  for (let i = 0; i < middlewares.length; i++) {
+    const index = compare.indexOf(middlewares[i], min);
+    if (index === -1) {
+      return middlewares.slice(i);
+    }
+    min = index + 1;
+  }
+  return [];
+}
+function mergeMiddlewares(first, second) {
+  return [...first, ...dedupeMiddlewares(first, second)];
+}
+function addMiddleware(middlewares, addition) {
+  return [...middlewares, addition];
 }
 
-// src/procedure-client.ts
-import { ORPCError as ORPCError2 } from "@orpc/client";
-import { ValidationError } from "@orpc/contract";
-import { intercept, toError, value } from "@orpc/shared";
-
-// src/error.ts
-import { fallbackORPCErrorStatus, ORPCError } from "@orpc/client";
 function createORPCErrorConstructorMap(errors) {
   const proxy = new Proxy(errors, {
     get(target, code) {
@@ -105,7 +111,10 @@ async function validateORPCError(map, error) {
   return new ORPCError(code, { defined: true, status, message, data: validated.value, cause });
 }
 
-// src/procedure-client.ts
+function middlewareOutputFn(output) {
+  return { output, context: {} };
+}
+
 function createProcedureClient(lazyableProcedure, ...[options]) {
   return async (...[input, callerOptions]) => {
     const path = options?.path ?? [];
@@ -129,7 +138,7 @@ function createProcedureClient(lazyableProcedure, ...[options]) {
         (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
       );
     } catch (e) {
-      if (!(e instanceof ORPCError2)) {
+      if (!(e instanceof ORPCError)) {
         throw toError(e);
       }
       const validated = await validateORPCError(procedure["~orpc"].errorMap, e);
@@ -144,7 +153,7 @@ async function validateInput(procedure, input) {
   }
   const result = await schema["~standard"].validate(input);
   if (result.issues) {
-    throw new ORPCError2("BAD_REQUEST", {
+    throw new ORPCError("BAD_REQUEST", {
       message: "Input validation failed",
       data: {
         issues: result.issues
@@ -161,7 +170,7 @@ async function validateOutput(procedure, output) {
   }
   const result = await schema["~standard"].validate(output);
   if (result.issues) {
-    throw new ORPCError2("INTERNAL_SERVER_ERROR", {
+    throw new ORPCError("INTERNAL_SERVER_ERROR", {
       message: "Output validation failed",
       cause: new ValidationError({ message: "Output validation failed", issues: result.issues })
     });
@@ -196,8 +205,7 @@ async function executeProcedureInternal(procedure, options) {
   return (await next({})).output;
 }
 
-// src/hidden.ts
-var ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_ROUTER_CONTRACT");
+const ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_ROUTER_CONTRACT");
 function setRouterContract(obj, contract) {
   return new Proxy(obj, {
     get(target, key) {
@@ -211,7 +219,7 @@ function setRouterContract(obj, contract) {
 function getRouterContract(obj) {
   return obj[ROUTER_CONTRACT_SYMBOL];
 }
-var LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
+const LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
 function deepSetLazyRouterPrefix(router, prefix) {
   return new Proxy(router, {
     get(target, key) {
@@ -230,29 +238,20 @@ function getLazyRouterPrefix(obj) {
   return obj[LAZY_ROUTER_PREFIX_SYMBOL];
 }
 
-// src/router.ts
-import { adaptRoute, mergeErrorMap, mergePrefix } from "@orpc/contract";
-
-// src/middleware-utils.ts
-function dedupeMiddlewares(compare, middlewares) {
-  let min = 0;
-  for (let i = 0; i < middlewares.length; i++) {
-    const index = compare.indexOf(middlewares[i], min);
-    if (index === -1) {
-      return middlewares.slice(i);
+function createAccessibleLazyRouter(lazied) {
+  const flattenLazy = flatLazy(lazied);
+  const recursive = new Proxy(flattenLazy, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      const next = getRouterChild(flattenLazy, key);
+      return createAccessibleLazyRouter(next);
     }
-    min = index + 1;
-  }
-  return [];
-}
-function mergeMiddlewares(first, second) {
-  return [...first, ...dedupeMiddlewares(first, second)];
-}
-function addMiddleware(middlewares, addition) {
-  return [...middlewares, addition];
+  });
+  return recursive;
 }
 
-// src/router.ts
 function adaptRouter(router, options) {
   if (isLazy(router)) {
     const adapted2 = lazy(async () => {
@@ -316,23 +315,6 @@ function getRouterChild(router, ...path) {
   return current;
 }
 
-// src/router-accessible-lazy.ts
-function createAccessibleLazyRouter(lazied) {
-  const flattenLazy = flatLazy(lazied);
-  const recursive = new Proxy(flattenLazy, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      const next = getRouterChild(flattenLazy, key);
-      return createAccessibleLazyRouter(next);
-    }
-  });
-  return recursive;
-}
-
-// src/utils.ts
-import { isContractProcedure as isContractProcedure2 } from "@orpc/contract";
 function eachContractProcedure(options, callback, laziedOptions = []) {
   const hiddenContract = getRouterContract(options.router);
   if (hiddenContract) {
@@ -350,7 +332,7 @@ function eachContractProcedure(options, callback, laziedOptions = []) {
       lazied: options.router,
       path: options.path
     });
-  } else if (isContractProcedure2(options.router)) {
+  } else if (isContractProcedure(options.router)) {
     callback({
       contract: options.router,
       path: options.path
@@ -373,10 +355,10 @@ async function eachAllContractProcedure(options, callback) {
   const pending = [options];
   for (const item of pending) {
     const lazies = eachContractProcedure(item, callback);
-    for (const lazy2 of lazies) {
-      const { default: router } = await unlazy(lazy2.lazied);
+    for (const lazy of lazies) {
+      const { default: router } = await unlazy(lazy.lazied);
       pending.push({
-        path: lazy2.path,
+        path: lazy.path,
         router
       });
     }
@@ -394,28 +376,4 @@ function createContractedProcedure(contract, procedure) {
   });
 }
 
-export {
-  LAZY_LOADER_SYMBOL,
-  lazy,
-  isLazy,
-  unlazy,
-  Procedure,
-  isProcedure,
-  flatLazy,
-  createLazyProcedureFormAnyLazy,
-  addMiddleware,
-  middlewareOutputFn,
-  createProcedureClient,
-  setRouterContract,
-  getRouterContract,
-  deepSetLazyRouterPrefix,
-  getLazyRouterPrefix,
-  createAccessibleLazyRouter,
-  adaptRouter,
-  getRouterChild,
-  eachContractProcedure,
-  eachAllContractProcedure,
-  convertPathToHttpPath,
-  createContractedProcedure
-};
-//# sourceMappingURL=chunk-MHVECKBC.js.map
+export { LAZY_LOADER_SYMBOL as L, Procedure as P, convertPathToHttpPath as a, createContractedProcedure as b, createProcedureClient as c, addMiddleware as d, eachContractProcedure as e, adaptRouter as f, getRouterChild as g, flatLazy as h, isProcedure as i, isLazy as j, createLazyProcedureFormAnyLazy as k, lazy as l, getRouterContract as m, deepSetLazyRouterPrefix as n, getLazyRouterPrefix as o, middlewareOutputFn as p, createAccessibleLazyRouter as q, eachAllContractProcedure as r, setRouterContract as s, unlazy as u };