@orpc/server 0.0.0-next.c6c659d → 0.0.0-next.cba521d

package/dist/{chunk-MB74GD7C.js → chunk-3EVCPLVI.js}

@@ -4,7 +4,7 @@ import {
   getRouterChild,
   isProcedure,
   unlazy
-} from "./chunk-ZBJYYEII.js";
+} from "./chunk-OUPZ7QGV.js";
 
 // src/adapters/fetch/super-json.ts
 var super_json_exports = {};
@@ -298,4 +298,4 @@ export {
   ORPCProcedureMatcher,
   RPCHandler
 };
-//# sourceMappingURL=chunk-MB74GD7C.js.map
+//# sourceMappingURL=chunk-3EVCPLVI.js.map

package/dist/{chunk-ZBJYYEII.js → chunk-OUPZ7QGV.js}

@@ -86,6 +86,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 +99,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 +157,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 +238,8 @@ export {
   isLazy,
   unlazy,
   flatLazy,
+  middlewareOutputFn,
   createProcedureClient,
   getRouterChild
 };
-//# sourceMappingURL=chunk-ZBJYYEII.js.map
+//# sourceMappingURL=chunk-OUPZ7QGV.js.map

package/dist/fetch.js

@@ -4,8 +4,8 @@ import {
   ORPCProcedureMatcher,
   RPCHandler,
   super_json_exports
-} from "./chunk-MB74GD7C.js";
-import "./chunk-ZBJYYEII.js";
+} from "./chunk-3EVCPLVI.js";
+import "./chunk-OUPZ7QGV.js";
 export {
   ORPCPayloadCodec,
   ORPCProcedureMatcher,

package/dist/hono.js

@@ -4,8 +4,8 @@ import {
   ORPCProcedureMatcher,
   RPCHandler,
   super_json_exports
-} from "./chunk-MB74GD7C.js";
-import "./chunk-ZBJYYEII.js";
+} from "./chunk-3EVCPLVI.js";
+import "./chunk-OUPZ7QGV.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-ZBJYYEII.js";
+} from "./chunk-OUPZ7QGV.js";
 
 // src/builder.ts
 import { ContractProcedure } from "@orpc/contract";
@@ -68,7 +69,7 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
     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 +80,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 +93,7 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
     }
     return new _DecoratedProcedure({
       ...this["~orpc"],
-      middlewares: castedMiddlewares
+      preMiddlewares: castedMiddlewares
     });
   }
   /**
@@ -122,12 +123,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
     });
@@ -211,7 +213,7 @@ var RouterBuilder = class _RouterBuilder {
   use(middleware) {
     return new _RouterBuilder({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
+      middlewares: [...this["~orpc"].middlewares, middleware]
     });
   }
   router(router) {
@@ -283,11 +285,12 @@ var RouterImplementer = class _RouterImplementer {
 };
 
 // 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 +353,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
     });
@@ -375,12 +381,14 @@ var Builder = class _Builder {
     this["~orpc"] = def;
   }
   context() {
-    return new _Builder({});
+    return new _Builder({
+      middlewares: []
+    });
   }
   use(middleware) {
     return new _Builder({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
+      middlewares: [...this["~orpc"].middlewares, middleware]
     });
   }
   middleware(middleware) {
@@ -431,7 +439,8 @@ var Builder = class _Builder {
   }
   handler(handler) {
     return new DecoratedProcedure({
-      middlewares: this["~orpc"].middlewares,
+      preMiddlewares: this["~orpc"].middlewares,
+      postMiddlewares: [],
       contract: new ContractProcedure({
         InputSchema: void 0,
         OutputSchema: void 0,
@@ -512,7 +521,9 @@ 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: []
+});
 export {
   Builder,
   DecoratedProcedure,
@@ -542,6 +553,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-MB74GD7C.js";
-import "./chunk-ZBJYYEII.js";
+} from "./chunk-3EVCPLVI.js";
+import "./chunk-OUPZ7QGV.js";
 
 // src/adapters/next/serve.ts
 import { value } from "@orpc/shared";

package/dist/node.js

@@ -1,7 +1,7 @@
 import {
   RPCHandler
-} from "./chunk-MB74GD7C.js";
-import "./chunk-ZBJYYEII.js";
+} from "./chunk-3EVCPLVI.js";
+import "./chunk-OUPZ7QGV.js";
 
 // src/adapters/node/request-listener.ts
 function createRequest(req, res) {

package/dist/src/builder.d.ts

@@ -11,7 +11,7 @@ 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>>[];
+    middlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[];
 }
 export declare class Builder<TContext extends Context, TExtraContext extends Context> {
     '~type': "Builder";

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

@@ -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<string, unknown>>[];
 }
 export declare class ProcedureBuilder<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> {
     '~type': "ProcedureBuilder";

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

@@ -3,7 +3,7 @@ import type { Hooks, Value } from '@orpc/shared';
 import type { Lazyable } from './lazy';
 import type { Procedure } from './procedure';
 import type { Context, Meta } from './types';
-export type ProcedureClient<TClientContext, TInput, TOutput, TError extends Error> = Client<TClientContext, TInput, TOutput, TError>;
+export type ProcedureClient<TClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
 /**
  * Options for creating a procedure caller with comprehensive type safety
  */
@@ -18,5 +18,5 @@ export type CreateProcedureClientOptions<TContext extends Context, TOutputSchema
     context?: Value<TContext, [clientContext: TClientContext]>;
 } : never)) & Hooks<unknown, SchemaOutput<TOutputSchema, THandlerOutput>, TContext, Meta>;
 export type CreateProcedureClientRest<TContext extends Context, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TClientContext> = [options: CreateProcedureClientOptions<TContext, TOutputSchema, THandlerOutput, TClientContext>] | (undefined extends TContext ? [] : never);
-export declare function createProcedureClient<TContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TClientContext>(lazyableProcedure: Lazyable<Procedure<TContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>>, ...[options]: CreateProcedureClientRest<TContext, TOutputSchema, THandlerOutput, TClientContext>): ProcedureClient<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
+export declare function createProcedureClient<TContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TClientContext>(lazyableProcedure: Lazyable<Procedure<TContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>>, ...[options]: CreateProcedureClientRest<TContext, TOutputSchema, THandlerOutput, TClientContext>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
 //# sourceMappingURL=procedure-client.d.ts.map

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

@@ -1,22 +1,22 @@
-import type { Client, ClientRest, ErrorFromErrorMap, ErrorMap, HTTPPath, RouteOptions, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ClientRest, ErrorMap, HTTPPath, RouteOptions, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { ORPCErrorConstructorMap } from './error';
 import type { MapInputMiddleware, Middleware } from './middleware';
-import type { CreateProcedureClientRest } from './procedure-client';
+import type { CreateProcedureClientRest, ProcedureClient } from './procedure-client';
 import type { Context, MergeContext } from './types';
 import { Procedure } from './procedure';
 export declare class DecoratedProcedure<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap> extends Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap> {
     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>;
+    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.
      */
-    callable<TClientContext>(...rest: CreateProcedureClientRest<TContext, TOutputSchema, THandlerOutput, TClientContext>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap> & (Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>);
+    callable<TClientContext>(...rest: CreateProcedureClientRest<TContext, TOutputSchema, THandlerOutput, TClientContext>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
     /**
      * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
      * **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<string, unknown>>[];
+    postMiddlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>, Record<string, unknown>>[];
 };
 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<string, unknown>`?
  * 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<string, unknown>>[];
+    postMiddlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>, Record<string, unknown>>[];
     contract: ContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;
     handler: ProcedureHandler<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, any>;
 }

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

@@ -12,7 +12,7 @@ export type AdaptedRouter<TContext extends Context, TRouter extends ANY_ROUTER>
 export type RouterBuilderDef<TContext extends Context, TExtraContext extends Context> = {
     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<string, unknown>>[];
 };
 export declare class RouterBuilder<TContext extends Context, TExtraContext extends Context> {
     '~type': "RouterBuilder";

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

@@ -1,4 +1,3 @@
-import type { ContractProcedure, ContractRouter, ErrorFromErrorMap, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { Hooks, Value } from '@orpc/shared';
 import type { Lazy } from './lazy';
 import type { Procedure } from './procedure';
@@ -8,8 +7,8 @@ import { type ANY_ROUTER, type Router } from './router';
 /**
  * FIXME: separate RouterClient and ContractRouterClient, don't mix them
  */
-export type RouterClient<TRouter extends ANY_ROUTER | ContractRouter, TClientContext> = TRouter extends Lazy<infer U extends ANY_ROUTER | ContractRouter> ? RouterClient<U, TClientContext> : TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap> | Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap> ? ProcedureClient<TClientContext, SchemaInput<UInputSchema>, SchemaOutput<UOutputSchema, UFuncOutput>, ErrorFromErrorMap<UErrorMap>> : {
-    [K in keyof TRouter]: TRouter[K] extends ANY_ROUTER | ContractRouter ? RouterClient<TRouter[K], TClientContext> : never;
+export type RouterClient<TRouter extends ANY_ROUTER, TClientContext> = TRouter extends Lazy<infer U extends ANY_ROUTER> ? RouterClient<U, TClientContext> : TRouter extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap> ? ProcedureClient<TClientContext, UInputSchema, UOutputSchema, UFuncOutput, UErrorMap> : {
+    [K in keyof TRouter]: TRouter[K] extends ANY_ROUTER ? RouterClient<TRouter[K], TClientContext> : never;
 };
 export type CreateRouterClientOptions<TRouter extends ANY_ROUTER> = {
     /**

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

@@ -5,7 +5,7 @@ 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>>[];
+    middlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[];
     contract: TContract;
 }
 export declare class RouterImplementer<TContext extends Context, TExtraContext extends Context, TContract extends ContractRouter> {

package/package.json

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