@orpc/server 0.29.0 → 0.30.0

package/dist/{chunk-VY6NXNQT.js → chunk-2HRHHZJD.js}

@@ -4,7 +4,7 @@ import {
   getRouterChild,
   isProcedure,
   unlazy
-} from "./chunk-XDC42C3C.js";
+} from "./chunk-SA7HGGVY.js";
 
 // src/adapters/fetch/super-json.ts
 var super_json_exports = {};
@@ -298,4 +298,4 @@ export {
   ORPCProcedureMatcher,
   RPCHandler
 };
-//# sourceMappingURL=chunk-VY6NXNQT.js.map
+//# sourceMappingURL=chunk-2HRHHZJD.js.map

package/dist/{chunk-XDC42C3C.js → chunk-SA7HGGVY.js}

@@ -36,9 +36,6 @@ function isProcedure(item) {
 import { ORPCError } from "@orpc/contract";
 function createORPCErrorConstructorMap(errors) {
   const constructors = {};
-  if (!errors) {
-    return constructors;
-  }
   for (const code in errors) {
     const config = errors[code];
     if (!config) {
@@ -86,6 +83,11 @@ function flatLazy(lazied) {
   return lazy(flattenLoader);
 }
 
+// src/middleware.ts
+function middlewareOutputFn(output) {
+  return { output, context: void 0 };
+}
+
 // src/procedure-client.ts
 import { ORPCError as ORPCError2, validateORPCError, ValidationError } from "@orpc/contract";
 import { executeWithHooks, toError, value } from "@orpc/shared";
@@ -94,30 +96,22 @@ function createProcedureClient(lazyableProcedure, ...[options]) {
     const path = options?.path ?? [];
     const { default: procedure } = await unlazy(lazyableProcedure);
     const context = await value(options?.context, callerOptions?.context);
-    const meta = {
+    const errors = createORPCErrorConstructorMap(procedure["~orpc"].contract["~orpc"].errorMap);
+    const executeOptions = {
+      input,
+      context,
+      errors,
       path,
       procedure,
       signal: callerOptions?.signal
     };
-    const executeWithValidation = async () => {
-      const validInput = await validateInput(procedure, input);
-      const output = await executeMiddlewareChain({
-        context,
-        input: validInput,
-        path,
-        procedure,
-        signal: callerOptions?.signal,
-        errors: createORPCErrorConstructorMap(procedure["~orpc"].contract["~orpc"].errorMap)
-      });
-      return validateOutput(procedure, output);
-    };
     try {
       const output = await executeWithHooks({
         hooks: options,
         input,
         context,
-        meta,
-        execute: executeWithValidation
+        meta: executeOptions,
+        execute: () => executeProcedureInternal(procedure, executeOptions)
       });
       return output;
     } catch (e) {
@@ -160,24 +154,44 @@ async function validateOutput(procedure, output) {
   }
   return result.value;
 }
-async function executeMiddlewareChain(opt) {
-  const middlewares = opt.procedure["~orpc"].middlewares ?? [];
-  let currentMidIndex = 0;
+function executeMiddlewareChain(middlewares, opt, input) {
+  let currentIndex = 0;
   let currentContext = opt.context;
-  const next = async (nextOptions) => {
-    const mid = middlewares[currentMidIndex];
-    currentMidIndex += 1;
+  const executeMiddlewareChain2 = async (nextOptions) => {
+    const mid = middlewares[currentIndex];
+    currentIndex += 1;
     currentContext = mergeContext(currentContext, nextOptions.context);
     if (mid) {
-      return await mid({ ...opt, context: currentContext, next }, opt.input, (output) => ({ output, context: void 0 }));
+      return await mid({ ...opt, context: currentContext, next: executeMiddlewareChain2 }, input, middlewareOutputFn);
     }
-    const result = {
-      output: await opt.procedure["~orpc"].handler({ ...opt, context: currentContext }),
-      context: currentContext
-    };
-    return result;
+    return opt.next({ context: currentContext });
+  };
+  return executeMiddlewareChain2({});
+}
+async function executeProcedureInternal(procedure, options) {
+  const executeHandler = async (context, input) => {
+    return await procedure["~orpc"].handler({ ...options, context, input });
+  };
+  const executePostMiddlewares = async (context, input) => {
+    const validatedInput = await validateInput(procedure, input);
+    const result2 = await executeMiddlewareChain(procedure["~orpc"].postMiddlewares, {
+      ...options,
+      context,
+      next: async ({ context: context2 }) => {
+        return middlewareOutputFn(
+          await executeHandler(context2, validatedInput)
+        );
+      }
+    }, validatedInput);
+    const validatedOutput = await validateOutput(procedure, result2.output);
+    return { ...result2, output: validatedOutput };
   };
-  return (await next({})).output;
+  const result = await executeMiddlewareChain(procedure["~orpc"].preMiddlewares, {
+    ...options,
+    context: options.context,
+    next: ({ context }) => executePostMiddlewares(context, options.input)
+  }, options.input);
+  return result.output;
 }
 
 // src/router.ts
@@ -221,7 +235,8 @@ export {
   isLazy,
   unlazy,
   flatLazy,
+  middlewareOutputFn,
   createProcedureClient,
   getRouterChild
 };
-//# sourceMappingURL=chunk-XDC42C3C.js.map
+//# sourceMappingURL=chunk-SA7HGGVY.js.map

package/dist/fetch.js

@@ -4,8 +4,8 @@ import {
   ORPCProcedureMatcher,
   RPCHandler,
   super_json_exports
-} from "./chunk-VY6NXNQT.js";
-import "./chunk-XDC42C3C.js";
+} from "./chunk-2HRHHZJD.js";
+import "./chunk-SA7HGGVY.js";
 export {
   ORPCPayloadCodec,
   ORPCProcedureMatcher,

package/dist/hono.js

@@ -4,8 +4,8 @@ import {
   ORPCProcedureMatcher,
   RPCHandler,
   super_json_exports
-} from "./chunk-VY6NXNQT.js";
-import "./chunk-XDC42C3C.js";
+} from "./chunk-2HRHHZJD.js";
+import "./chunk-SA7HGGVY.js";
 
 // src/adapters/hono/middleware.ts
 import { value } from "@orpc/shared";

package/dist/index.js

@@ -9,8 +9,9 @@ import {
   isProcedure,
   lazy,
   mergeContext,
+  middlewareOutputFn,
   unlazy
-} from "./chunk-XDC42C3C.js";
+} from "./chunk-SA7HGGVY.js";
 
 // src/builder.ts
 import { ContractProcedure } from "@orpc/contract";
@@ -64,11 +65,17 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
       contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).route(route)
     });
   }
+  errors(errors) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).errors(errors)
+    });
+  }
   use(middleware, mapInput) {
     const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
     return new _DecoratedProcedure({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware_]
+      postMiddlewares: [...this["~orpc"].postMiddlewares, middleware_]
     });
   }
   unshiftTag(...tags) {
@@ -79,12 +86,12 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
   }
   unshiftMiddleware(...middlewares) {
     const castedMiddlewares = middlewares;
-    if (this["~orpc"].middlewares?.length) {
+    if (this["~orpc"].preMiddlewares.length) {
       let min = 0;
-      for (let i = 0; i < this["~orpc"].middlewares.length; i++) {
-        const index = castedMiddlewares.indexOf(this["~orpc"].middlewares[i], min);
+      for (let i = 0; i < this["~orpc"].preMiddlewares.length; i++) {
+        const index = castedMiddlewares.indexOf(this["~orpc"].preMiddlewares[i], min);
         if (index === -1) {
-          castedMiddlewares.push(...this["~orpc"].middlewares.slice(i));
+          castedMiddlewares.push(...this["~orpc"].preMiddlewares.slice(i));
           break;
         }
         min = index + 1;
@@ -92,7 +99,7 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
     }
     return new _DecoratedProcedure({
       ...this["~orpc"],
-      middlewares: castedMiddlewares
+      preMiddlewares: castedMiddlewares
     });
   }
   /**
@@ -122,12 +129,13 @@ var ProcedureImplementer = class _ProcedureImplementer {
     const mappedMiddleware = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
     return new _ProcedureImplementer({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], mappedMiddleware]
+      postMiddlewares: [...this["~orpc"].postMiddlewares, mappedMiddleware]
     });
   }
   handler(handler) {
     return new DecoratedProcedure({
-      middlewares: this["~orpc"].middlewares,
+      postMiddlewares: this["~orpc"].postMiddlewares,
+      preMiddlewares: this["~orpc"].preMiddlewares,
       contract: this["~orpc"].contract,
       handler
     });
@@ -208,10 +216,19 @@ var RouterBuilder = class _RouterBuilder {
       tags: [...this["~orpc"].tags ?? [], ...tags]
     });
   }
+  errors(errors) {
+    return new _RouterBuilder({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
   use(middleware) {
     return new _RouterBuilder({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
+      middlewares: [...this["~orpc"].middlewares, middleware]
     });
   }
   router(router) {
@@ -248,6 +265,9 @@ function adapt(item, options) {
     if (options.middlewares?.length) {
       decorated = decorated.unshiftMiddleware(...options.middlewares);
     }
+    if (Object.keys(options.errorMap).length) {
+      decorated = decorated.errors(options.errorMap);
+    }
     return decorated;
   }
   const adapted = {};
@@ -271,23 +291,30 @@ var RouterImplementer = class _RouterImplementer {
     });
   }
   router(router) {
-    const adapted = new RouterBuilder(this["~orpc"]).router(router);
+    const adapted = new RouterBuilder({
+      ...this["~orpc"],
+      errorMap: {}
+    }).router(router);
     const contracted = setRouterContract(adapted, this["~orpc"].contract);
     return contracted;
   }
   lazy(loader) {
-    const adapted = new RouterBuilder(this["~orpc"]).lazy(loader);
+    const adapted = new RouterBuilder({
+      ...this["~orpc"],
+      errorMap: {}
+    }).lazy(loader);
     const contracted = setRouterContract(adapted, this["~orpc"].contract);
     return contracted;
   }
 };
 
 // src/implementer-chainable.ts
-function createChainableImplementer(contract, middlewares) {
+function createChainableImplementer(contract, middlewares = []) {
   if (isContractProcedure(contract)) {
     const implementer = new ProcedureImplementer({
       contract,
-      middlewares
+      preMiddlewares: middlewares,
+      postMiddlewares: []
     });
     return implementer;
   }
@@ -350,17 +377,20 @@ var ProcedureBuilder = class _ProcedureBuilder {
     if (!mapInput) {
       return new ProcedureImplementer({
         contract: this["~orpc"].contract,
-        middlewares: this["~orpc"].middlewares
+        preMiddlewares: this["~orpc"].middlewares,
+        postMiddlewares: []
       }).use(middleware);
     }
     return new ProcedureImplementer({
       contract: this["~orpc"].contract,
-      middlewares: this["~orpc"].middlewares
+      preMiddlewares: this["~orpc"].middlewares,
+      postMiddlewares: []
     }).use(middleware, mapInput);
   }
   handler(handler) {
     return new DecoratedProcedure({
-      middlewares: this["~orpc"].middlewares,
+      preMiddlewares: this["~orpc"].middlewares,
+      postMiddlewares: [],
       contract: this["~orpc"].contract,
       handler
     });
@@ -374,15 +404,29 @@ var Builder = class _Builder {
   constructor(def) {
     this["~orpc"] = def;
   }
+  // TODO: separate it
   context() {
-    return new _Builder({});
+    return new _Builder({
+      middlewares: [],
+      errorMap: {}
+    });
   }
   use(middleware) {
     return new _Builder({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
+      middlewares: [...this["~orpc"].middlewares, middleware]
     });
   }
+  errors(errors) {
+    return new _Builder({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
+  // TODO: not allow define middleware after has context, or anything else
   middleware(middleware) {
     return decorateMiddleware(middleware);
   }
@@ -393,7 +437,7 @@ var Builder = class _Builder {
         route,
         InputSchema: void 0,
         OutputSchema: void 0,
-        errorMap: void 0
+        errorMap: this["~orpc"].errorMap
       })
     });
   }
@@ -404,7 +448,7 @@ var Builder = class _Builder {
         OutputSchema: void 0,
         InputSchema: schema,
         inputExample: example,
-        errorMap: void 0
+        errorMap: this["~orpc"].errorMap
       })
     });
   }
@@ -415,27 +459,18 @@ var Builder = class _Builder {
         InputSchema: void 0,
         OutputSchema: schema,
         outputExample: example,
-        errorMap: void 0
-      })
-    });
-  }
-  errors(errors) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: errors
+        errorMap: this["~orpc"].errorMap
       })
     });
   }
   handler(handler) {
     return new DecoratedProcedure({
-      middlewares: this["~orpc"].middlewares,
+      preMiddlewares: this["~orpc"].middlewares,
+      postMiddlewares: [],
       contract: new ContractProcedure({
         InputSchema: void 0,
         OutputSchema: void 0,
-        errorMap: void 0
+        errorMap: this["~orpc"].errorMap
       }),
       handler
     });
@@ -443,12 +478,14 @@ var Builder = class _Builder {
   prefix(prefix) {
     return new RouterBuilder({
       middlewares: this["~orpc"].middlewares,
+      errorMap: this["~orpc"].errorMap,
       prefix
     });
   }
   tag(...tags) {
     return new RouterBuilder({
       middlewares: this["~orpc"].middlewares,
+      errorMap: this["~orpc"].errorMap,
       tags
     });
   }
@@ -512,7 +549,10 @@ function createRouterClient(router, ...rest) {
 
 // src/index.ts
 import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe } from "@orpc/contract";
-var os = new Builder({});
+var os = new Builder({
+  middlewares: [],
+  errorMap: {}
+});
 export {
   Builder,
   DecoratedProcedure,
@@ -542,6 +582,7 @@ export {
   isProcedure,
   lazy,
   mergeContext,
+  middlewareOutputFn,
   os,
   safe,
   setRouterContract,

package/dist/next.js

@@ -4,8 +4,8 @@ import {
   ORPCProcedureMatcher,
   RPCHandler,
   super_json_exports
-} from "./chunk-VY6NXNQT.js";
-import "./chunk-XDC42C3C.js";
+} from "./chunk-2HRHHZJD.js";
+import "./chunk-SA7HGGVY.js";
 
 // src/adapters/next/serve.ts
 import { value } from "@orpc/shared";

package/dist/node.js

@@ -1,7 +1,7 @@
 import {
   RPCHandler
-} from "./chunk-VY6NXNQT.js";
-import "./chunk-XDC42C3C.js";
+} from "./chunk-2HRHHZJD.js";
+import "./chunk-SA7HGGVY.js";
 
 // src/adapters/node/request-listener.ts
 function createRequest(req, res) {

package/dist/src/builder.d.ts

@@ -1,4 +1,5 @@
-import type { ANY_CONTRACT_PROCEDURE, ContractRouter, ErrorMap, HTTPPath, RouteOptions, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ContractRouter, ErrorMap, ErrorMapGuard, ErrorMapSuggestions, HTTPPath, RouteOptions, Schema, SchemaInput, SchemaOutput, StrictErrorMap } from '@orpc/contract';
+import type { ORPCErrorConstructorMap } from './error';
 import type { FlattenLazy } from './lazy';
 import type { Middleware } from './middleware';
 import type { DecoratedMiddleware } from './middleware-decorated';
@@ -10,27 +11,28 @@ import { type ChainableImplementer } from './implementer-chainable';
 import { ProcedureBuilder } from './procedure-builder';
 import { DecoratedProcedure } from './procedure-decorated';
 import { RouterBuilder } from './router-builder';
-export interface BuilderDef<TContext extends Context, TExtraContext extends Context> {
-    middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[];
+export interface BuilderDef<TContext extends Context, TExtraContext extends Context, TErrorMap extends ErrorMap> {
+    middlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<never, never>>[];
+    errorMap: TErrorMap;
 }
-export declare class Builder<TContext extends Context, TExtraContext extends Context> {
+export declare class Builder<TContext extends Context, TExtraContext extends Context, TErrorMap extends ErrorMap> {
     '~type': "Builder";
-    '~orpc': BuilderDef<TContext, TExtraContext>;
-    constructor(def: BuilderDef<TContext, TExtraContext>);
-    context<UContext extends Context = WELL_CONTEXT>(): Builder<UContext, undefined>;
-    use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, unknown, unknown, Record<string, unknown>>): Builder<TContext, MergeContext<TExtraContext, U>>;
-    middleware<UExtraContext extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined, TInput = unknown, TOutput = any>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, TInput, TOutput, Record<string, unknown>>): DecoratedMiddleware<MergeContext<TContext, TExtraContext>, UExtraContext, TInput, TOutput, Record<string, unknown>>;
-    route(route: RouteOptions): ProcedureBuilder<TContext, TExtraContext, undefined, undefined, undefined>;
-    input<USchema extends Schema>(schema: USchema, example?: SchemaInput<USchema>): ProcedureBuilder<TContext, TExtraContext, USchema, undefined, undefined>;
-    output<USchema extends Schema>(schema: USchema, example?: SchemaOutput<USchema>): ProcedureBuilder<TContext, TExtraContext, undefined, USchema, undefined>;
-    errors<UErrorMap extends ErrorMap>(errors: UErrorMap): ProcedureBuilder<TContext, TExtraContext, undefined, undefined, UErrorMap>;
-    handler<UFuncOutput = undefined>(handler: ProcedureHandler<TContext, TExtraContext, undefined, undefined, UFuncOutput, undefined>): DecoratedProcedure<TContext, TExtraContext, undefined, undefined, UFuncOutput, undefined>;
-    prefix(prefix: HTTPPath): RouterBuilder<TContext, TExtraContext>;
-    tag(...tags: string[]): RouterBuilder<TContext, TExtraContext>;
-    router<U extends Router<MergeContext<TContext, TExtraContext>, any>>(router: U): AdaptedRouter<TContext, U>;
-    lazy<U extends Router<MergeContext<TContext, TExtraContext>, any>>(loader: () => Promise<{
+    '~orpc': BuilderDef<TContext, TExtraContext, TErrorMap>;
+    constructor(def: BuilderDef<TContext, TExtraContext, TErrorMap>);
+    context<UContext extends Context = WELL_CONTEXT>(): Builder<UContext, undefined, Record<never, never>>;
+    use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, unknown, unknown, ORPCErrorConstructorMap<TErrorMap>>): Builder<TContext, MergeContext<TExtraContext, U>, TErrorMap>;
+    errors<U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): Builder<TContext, TExtraContext, TErrorMap & U>;
+    middleware<UExtraContext extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined, TInput = unknown, TOutput = any>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, TInput, TOutput, Record<never, never>>): DecoratedMiddleware<MergeContext<TContext, TExtraContext>, UExtraContext, TInput, TOutput, Record<never, never>>;
+    route(route: RouteOptions): ProcedureBuilder<TContext, TExtraContext, undefined, undefined, TErrorMap>;
+    input<USchema extends Schema>(schema: USchema, example?: SchemaInput<USchema>): ProcedureBuilder<TContext, TExtraContext, USchema, undefined, TErrorMap>;
+    output<USchema extends Schema>(schema: USchema, example?: SchemaOutput<USchema>): ProcedureBuilder<TContext, TExtraContext, undefined, USchema, TErrorMap>;
+    handler<UFuncOutput = undefined>(handler: ProcedureHandler<TContext, TExtraContext, undefined, undefined, UFuncOutput, TErrorMap>): DecoratedProcedure<TContext, TExtraContext, undefined, undefined, UFuncOutput, TErrorMap>;
+    prefix(prefix: HTTPPath): RouterBuilder<TContext, TExtraContext, TErrorMap>;
+    tag(...tags: string[]): RouterBuilder<TContext, TExtraContext, TErrorMap>;
+    router<U extends Router<MergeContext<TContext, TExtraContext>, ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>>(router: U): AdaptedRouter<TContext, U, TErrorMap>;
+    lazy<U extends Router<MergeContext<TContext, TExtraContext>, ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>>(loader: () => Promise<{
         default: U;
-    }>): AdaptedRouter<TContext, FlattenLazy<U>>;
-    contract<U extends ANY_CONTRACT_PROCEDURE | ContractRouter>(contract: U): ChainableImplementer<TContext, TExtraContext, U>;
+    }>): AdaptedRouter<TContext, FlattenLazy<U>, TErrorMap>;
+    contract<U extends ContractRouter<any>>(contract: U): ChainableImplementer<TContext, TExtraContext, U>;
 }
 //# sourceMappingURL=builder.d.ts.map

package/dist/src/error.d.ts

@@ -3,7 +3,7 @@ import { ORPCError } from '@orpc/contract';
 export type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<any, TData>, 'defined' | 'code' | 'status'>;
 export type ORPCErrorConstructorMapItemRest<TData> = [options: ORPCErrorConstructorMapItemOptions<TData>] | (undefined extends TData ? [] : never);
 export type ORPCErrorConstructorMapItem<TCode extends string, TDataSchema extends Schema> = (...rest: ORPCErrorConstructorMapItemRest<SchemaInput<TDataSchema>>) => ORPCError<TCode, SchemaOutput<TDataSchema>>;
-export type ORPCErrorConstructorMap<T extends ErrorMap> = T extends undefined ? Record<string, unknown> : {
+export type ORPCErrorConstructorMap<T extends ErrorMap> = {
     [K in keyof T]: K extends string ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, UInputSchema> : never : never;
 };
 export declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;

package/dist/src/hidden.d.ts

@@ -1,6 +1,6 @@
 import type { ContractRouter, HTTPPath } from '@orpc/contract';
-export declare function setRouterContract<T extends object>(obj: T, contract: ContractRouter): T;
-export declare function getRouterContract(obj: object): ContractRouter | undefined;
+export declare function setRouterContract<T extends object>(obj: T, contract: ContractRouter<any>): T;
+export declare function getRouterContract(obj: object): ContractRouter<any> | undefined;
 export declare function deepSetLazyRouterPrefix<T extends object>(router: T, prefix: HTTPPath): T;
 export declare function getLazyRouterPrefix(obj: object): HTTPPath | undefined;
 //# sourceMappingURL=hidden.d.ts.map

package/dist/src/implementer-chainable.d.ts

@@ -3,8 +3,8 @@ import type { Context, MergeContext, WELL_CONTEXT } from './types';
 import { type ContractProcedure, type ContractRouter } from '@orpc/contract';
 import { ProcedureImplementer } from './procedure-implementer';
 import { RouterImplementer } from './router-implementer';
-export type ChainableImplementer<TContext extends Context, TExtraContext extends Context, TContract extends ContractRouter> = TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap> ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema, UErrorMap> : {
-    [K in keyof TContract]: TContract[K] extends ContractRouter ? ChainableImplementer<TContext, TExtraContext, TContract[K]> : never;
+export type ChainableImplementer<TContext extends Context, TExtraContext extends Context, TContract extends ContractRouter<any>> = TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap> ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema, UErrorMap> : {
+    [K in keyof TContract]: TContract[K] extends ContractRouter<any> ? ChainableImplementer<TContext, TExtraContext, TContract[K]> : never;
 } & Omit<RouterImplementer<TContext, TExtraContext, TContract>, '~type' | '~orpc'>;
-export declare function createChainableImplementer<TContext extends Context = WELL_CONTEXT, TExtraContext extends Context = undefined, TContract extends ContractRouter = any>(contract: TContract, middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[]): ChainableImplementer<TContext, TExtraContext, TContract>;
+export declare function createChainableImplementer<TContext extends Context = WELL_CONTEXT, TExtraContext extends Context = undefined, TContract extends ContractRouter<any> = any>(contract: TContract, middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<never, never>>[]): ChainableImplementer<TContext, TExtraContext, TContract>;
 //# sourceMappingURL=implementer-chainable.d.ts.map

package/dist/src/index.d.ts

@@ -21,5 +21,5 @@ export * from './router-implementer';
 export * from './types';
 export * from './utils';
 export { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe } from '@orpc/contract';
-export declare const os: Builder<WELL_CONTEXT, undefined>;
+export declare const os: Builder<WELL_CONTEXT, undefined, Record<never, never>>;
 //# sourceMappingURL=index.d.ts.map

package/dist/src/middleware.d.ts

@@ -32,4 +32,5 @@ export interface MapInputMiddleware<TInput, TMappedInput> {
     (input: TInput): TMappedInput;
 }
 export type ANY_MAP_INPUT_MIDDLEWARE = MapInputMiddleware<any, any>;
+export declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<undefined, TOutput>;
 //# sourceMappingURL=middleware.d.ts.map

package/dist/src/procedure-builder.d.ts

@@ -1,4 +1,4 @@
-import type { ContractProcedure, ErrorMap, RouteOptions, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ContractProcedure, ErrorMap, ErrorMapGuard, ErrorMapSuggestions, RouteOptions, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { ORPCErrorConstructorMap } from './error';
 import type { MapInputMiddleware, Middleware } from './middleware';
 import type { ProcedureHandler } from './procedure';
@@ -7,7 +7,7 @@ import { DecoratedProcedure } from './procedure-decorated';
 import { ProcedureImplementer } from './procedure-implementer';
 export interface ProcedureBuilderDef<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> {
     contract: ContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;
-    middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[];
+    middlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<never, never>>[];
 }
 export declare class ProcedureBuilder<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> {
     '~type': "ProcedureBuilder";
@@ -16,7 +16,7 @@ export declare class ProcedureBuilder<TContext extends Context, TExtraContext ex
     route(route: RouteOptions): ProcedureBuilder<TContext, TExtraContext, TInputSchema, TOutputSchema, TErrorMap>;
     input<U extends Schema>(schema: U, example?: SchemaInput<U>): ProcedureBuilder<TContext, TExtraContext, U, TOutputSchema, TErrorMap>;
     output<U extends Schema>(schema: U, example?: SchemaOutput<U>): ProcedureBuilder<TContext, TExtraContext, TInputSchema, U, TErrorMap>;
-    errors<UErrorMap extends ErrorMap>(errors: UErrorMap): ProcedureBuilder<TContext, TExtraContext, TInputSchema, TOutputSchema, UErrorMap>;
+    errors<U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ProcedureBuilder<TContext, TExtraContext, TInputSchema, TOutputSchema, TErrorMap & U>;
     use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>>): ProcedureImplementer<TContext, MergeContext<TExtraContext, U>, TInputSchema, TOutputSchema, TErrorMap>;
     use<UExtra extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined, UInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtra, UInput, SchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema>, UInput>): ProcedureImplementer<TContext, MergeContext<TExtraContext, UExtra>, TInputSchema, TOutputSchema, TErrorMap>;
     handler<UFuncOutput extends SchemaInput<TOutputSchema>>(handler: ProcedureHandler<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap>;

package/dist/src/procedure-decorated.d.ts

@@ -1,4 +1,4 @@
-import type { ClientRest, ErrorMap, HTTPPath, RouteOptions, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ClientRest, ErrorMap, ErrorMapGuard, ErrorMapSuggestions, HTTPPath, RouteOptions, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { ORPCErrorConstructorMap } from './error';
 import type { MapInputMiddleware, Middleware } from './middleware';
 import type { CreateProcedureClientRest, ProcedureClient } from './procedure-client';
@@ -8,10 +8,11 @@ export declare class DecoratedProcedure<TContext extends Context, TExtraContext
     static decorate<UContext extends Context, UExtraContext extends Context, UInputSchema extends Schema, UOutputSchema extends Schema, UHandlerOutput extends SchemaInput<UOutputSchema>, UErrorMap extends ErrorMap>(procedure: Procedure<UContext, UExtraContext, UInputSchema, UOutputSchema, UHandlerOutput, UErrorMap>): DecoratedProcedure<any, any, any, any, any, any> | DecoratedProcedure<UContext, UExtraContext, UInputSchema, UOutputSchema, UHandlerOutput, UErrorMap>;
     prefix(prefix: HTTPPath): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
     route(route: RouteOptions): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
-    use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema, THandlerOutput>, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TContext, MergeContext<TExtraContext, U>, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
-    use<UExtra extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined, UInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtra, UInput, SchemaInput<TOutputSchema, THandlerOutput>, ORPCErrorConstructorMap<TErrorMap>>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema, THandlerOutput>, UInput>): DecoratedProcedure<TContext, MergeContext<TExtraContext, UExtra>, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    errors<U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap & U>;
+    use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, SchemaOutput<TInputSchema>, THandlerOutput, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TContext, MergeContext<TExtraContext, U>, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    use<UExtra extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined, UInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtra, UInput, THandlerOutput, ORPCErrorConstructorMap<TErrorMap>>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema, THandlerOutput>, UInput>): DecoratedProcedure<TContext, MergeContext<TExtraContext, UExtra>, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
     unshiftTag(...tags: string[]): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
-    unshiftMiddleware<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(...middlewares: Middleware<TContext, U, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema, THandlerOutput>, ORPCErrorConstructorMap<TErrorMap>>[]): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    unshiftMiddleware(...middlewares: Middleware<TContext, Context & Partial<MergeContext<TContext, TExtraContext>> | undefined, unknown, SchemaOutput<TOutputSchema, THandlerOutput>, ORPCErrorConstructorMap<TErrorMap>>[]): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
     /**
      * Make this procedure callable (works like a function while still being a procedure).
      * **Note**: this only takes effect when this method is called at the end of the chain.

package/dist/src/procedure-implementer.d.ts

@@ -6,7 +6,8 @@ import type { Context, MergeContext } from './types';
 import { DecoratedProcedure } from './procedure-decorated';
 export type ProcedureImplementerDef<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> = {
     contract: ContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;
-    middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>>[];
+    preMiddlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<never, never>>[];
+    postMiddlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>, Record<never, never>>[];
 };
 export declare class ProcedureImplementer<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> {
     '~type': "ProcedureImplementer";

package/dist/src/procedure.d.ts

@@ -16,7 +16,7 @@ export interface ProcedureHandler<TContext extends Context, TExtraContext extend
     (opt: ProcedureHandlerOptions<TContext, TExtraContext, SchemaOutput<TInputSchema>, ORPCErrorConstructorMap<TErrorMap>>): Promisable<SchemaInput<TOutputSchema, THandlerOutput>>;
 }
 /**
- * Why is `ErrorConstructorMap` passed to `Middleware` as `any`?
+ * Why is `ErrorConstructorMap` passed to `postMiddlewares` as `Record<never, never>`?
  * Why is `ErrorMap` passed to `ProcedureHandler` as `any`?
  *
  * Passing `ErrorMap/ErrorConstructorMap` directly to `Middleware/ProcedureHandler`
@@ -27,7 +27,8 @@ export interface ProcedureHandler<TContext extends Context, TExtraContext extend
  * The only downside is that direct access to them requires careful type checking to ensure safety.
  */
 export interface ProcedureDef<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap> {
-    middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, SchemaOutput<TInputSchema>, any, any>[];
+    preMiddlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<never, never>>[];
+    postMiddlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>, Record<never, never>>[];
     contract: ContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;
     handler: ProcedureHandler<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, any>;
 }

package/dist/src/router-builder.d.ts

@@ -1,4 +1,4 @@
-import type { HTTPPath } from '@orpc/contract';
+import type { ContractRouter, ErrorMap, ErrorMapGuard, ErrorMapSuggestions, HTTPPath, StrictErrorMap } from '@orpc/contract';
 import type { FlattenLazy, Lazy } from './lazy';
 import type { Middleware } from './middleware';
 import type { Procedure } from './procedure';
@@ -6,24 +6,26 @@ import type { ANY_ROUTER, Router } from './router';
 import type { Context, MergeContext } from './types';
 import { type DecoratedLazy } from './lazy-decorated';
 import { DecoratedProcedure } from './procedure-decorated';
-export type AdaptedRouter<TContext extends Context, TRouter extends ANY_ROUTER> = TRouter extends Lazy<infer U extends ANY_ROUTER> ? DecoratedLazy<AdaptedRouter<TContext, U>> : TRouter extends Procedure<any, infer UExtraContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap> ? DecoratedProcedure<TContext, UExtraContext, UInputSchema, UOutputSchema, UFuncOutput, UErrorMap> : {
-    [K in keyof TRouter]: TRouter[K] extends ANY_ROUTER ? AdaptedRouter<TContext, TRouter[K]> : never;
+export type AdaptedRouter<TContext extends Context, TRouter extends ANY_ROUTER, TErrorMapExtra extends ErrorMap> = TRouter extends Lazy<infer U extends ANY_ROUTER> ? DecoratedLazy<AdaptedRouter<TContext, U, TErrorMapExtra>> : TRouter extends Procedure<any, infer UExtraContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap> ? DecoratedProcedure<TContext, UExtraContext, UInputSchema, UOutputSchema, UFuncOutput, UErrorMap & TErrorMapExtra> : {
+    [K in keyof TRouter]: TRouter[K] extends ANY_ROUTER ? AdaptedRouter<TContext, TRouter[K], TErrorMapExtra> : never;
 };
-export type RouterBuilderDef<TContext extends Context, TExtraContext extends Context> = {
+export type RouterBuilderDef<TContext extends Context, TExtraContext extends Context, TErrorMap extends ErrorMap> = {
     prefix?: HTTPPath;
     tags?: readonly string[];
-    middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[];
+    middlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<never, never>>[];
+    errorMap: TErrorMap;
 };
-export declare class RouterBuilder<TContext extends Context, TExtraContext extends Context> {
+export declare class RouterBuilder<TContext extends Context, TExtraContext extends Context, TErrorMap extends ErrorMap> {
     '~type': "RouterBuilder";
-    '~orpc': RouterBuilderDef<TContext, TExtraContext>;
-    constructor(def: RouterBuilderDef<TContext, TExtraContext>);
-    prefix(prefix: HTTPPath): RouterBuilder<TContext, TExtraContext>;
-    tag(...tags: string[]): RouterBuilder<TContext, TExtraContext>;
-    use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, unknown, unknown, Record<string, unknown>>): RouterBuilder<TContext, MergeContext<TExtraContext, U>>;
-    router<U extends Router<MergeContext<TContext, TExtraContext>, any>>(router: U): AdaptedRouter<TContext, U>;
-    lazy<U extends Router<MergeContext<TContext, TExtraContext>, any>>(loader: () => Promise<{
+    '~orpc': RouterBuilderDef<TContext, TExtraContext, TErrorMap>;
+    constructor(def: RouterBuilderDef<TContext, TExtraContext, TErrorMap>);
+    prefix(prefix: HTTPPath): RouterBuilder<TContext, TExtraContext, TErrorMap>;
+    tag(...tags: string[]): RouterBuilder<TContext, TExtraContext, TErrorMap>;
+    errors<U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): RouterBuilder<TContext, TExtraContext, TErrorMap & U>;
+    use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, unknown, unknown, Record<never, never>>): RouterBuilder<TContext, MergeContext<TExtraContext, U>, TErrorMap>;
+    router<U extends Router<MergeContext<TContext, TExtraContext>, ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>>(router: U): AdaptedRouter<TContext, U, TErrorMap>;
+    lazy<U extends Router<MergeContext<TContext, TExtraContext>, ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>>(loader: () => Promise<{
         default: U;
-    }>): AdaptedRouter<TContext, FlattenLazy<U>>;
+    }>): AdaptedRouter<TContext, FlattenLazy<U>, TErrorMap>;
 }
 //# sourceMappingURL=router-builder.d.ts.map

package/dist/src/router-implementer.d.ts

@@ -4,18 +4,18 @@ import type { Middleware } from './middleware';
 import type { Router } from './router';
 import type { AdaptedRouter } from './router-builder';
 import type { Context, MergeContext } from './types';
-export interface RouterImplementerDef<TContext extends Context, TExtraContext extends Context, TContract extends ContractRouter> {
-    middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[];
+export interface RouterImplementerDef<TContext extends Context, TExtraContext extends Context, TContract extends ContractRouter<any>> {
+    middlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<never, never>>[];
     contract: TContract;
 }
-export declare class RouterImplementer<TContext extends Context, TExtraContext extends Context, TContract extends ContractRouter> {
+export declare class RouterImplementer<TContext extends Context, TExtraContext extends Context, TContract extends ContractRouter<any>> {
     '~type': "RouterImplementer";
     '~orpc': RouterImplementerDef<TContext, TExtraContext, TContract>;
     constructor(def: RouterImplementerDef<TContext, TExtraContext, TContract>);
-    use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, unknown, unknown, Record<string, unknown>>): RouterImplementer<TContext, MergeContext<TExtraContext, U>, TContract>;
-    router<U extends Router<MergeContext<TContext, TExtraContext>, TContract>>(router: U): AdaptedRouter<TContext, U>;
+    use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, unknown, unknown, Record<never, never>>): RouterImplementer<TContext, MergeContext<TExtraContext, U>, TContract>;
+    router<U extends Router<MergeContext<TContext, TExtraContext>, TContract>>(router: U): AdaptedRouter<TContext, U, Record<never, never>>;
     lazy<U extends Router<MergeContext<TContext, TExtraContext>, TContract>>(loader: () => Promise<{
         default: U;
-    }>): AdaptedRouter<TContext, FlattenLazy<U>>;
+    }>): AdaptedRouter<TContext, FlattenLazy<U>, Record<never, never>>;
 }
 //# sourceMappingURL=router-implementer.d.ts.map

package/dist/src/router.d.ts

@@ -2,8 +2,8 @@ import type { ContractProcedure, ContractRouter, SchemaInput, SchemaOutput } fro
 import type { ANY_LAZY, Lazy, Lazyable } from './lazy';
 import type { ANY_PROCEDURE, Procedure } from './procedure';
 import type { Context } from './types';
-export type Router<TContext extends Context, TContract extends ContractRouter> = Lazyable<TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap> ? Procedure<TContext, any, UInputSchema, UOutputSchema, any, UErrorMap> : {
-    [K in keyof TContract]: TContract[K] extends ContractRouter ? Router<TContext, TContract[K]> : never;
+export type Router<TContext extends Context, TContract extends ContractRouter<any>> = Lazyable<TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap> ? Procedure<TContext, any, UInputSchema, UOutputSchema, any, UErrorMap> : {
+    [K in keyof TContract]: TContract[K] extends ContractRouter<any> ? Router<TContext, TContract[K]> : never;
 }>;
 export type ANY_ROUTER = Router<any, any>;
 export type InferRouterInputs<T extends ANY_ROUTER> = T extends Lazy<infer U extends ANY_ROUTER> ? InferRouterInputs<U> : T extends Procedure<any, any, infer UInputSchema, any, any, any> ? SchemaInput<UInputSchema> : {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -53,8 +53,8 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "@orpc/contract": "0.29.0",
-    "@orpc/shared": "0.29.0"
+    "@orpc/contract": "0.30.0",
+    "@orpc/shared": "0.30.0"
   },
   "scripts": {
     "build": "tsup --onSuccess='tsc -b --noCheck'",