@orpc/server 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/shared/{server.BsNNjG5J.d.mts → server.DD1roZl9.d.mts}

@@ -1,10 +1,10 @@
 import { RouterContract, ProcedureContract, ORPCErrorFromErrorMap, ThrowableError, InferSchemaInput, InferSchemaOutput } from '@orpc/contract';
-import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.BL22TloH.mjs';
+import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.BEdOJs6S.mjs';
 
-type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any, any> | {
+type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any> | {
     [k: string]: Lazyable<Router<TInitialContext>>;
 };
-type ContractedRouter<T extends RouterContract, TInitialContext extends Context> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap, never> : {
+type ContractedRouter<T extends RouterContract, TInitialContext extends Context> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap> : {
     [K in keyof T]: T[K] extends RouterContract ? Lazyable<ContractedRouter<T[K], TInitialContext>> : never;
 };
 type AnyRouter = Router<any>;
@@ -12,50 +12,62 @@ type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer $>
 /**
  * Infer all initial context of the router.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-initial-contexts | Router - Infer Router Initial Contexts}
  */
-type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any, any> ? UInitialContext : {
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any> ? UInitialContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
 };
 /**
  * Infer all current context of the router.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-final-contexts | Router - Infer Router Final Contexts}
  */
-type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : {
+type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterFinalContexts<U> : never;
 };
 /**
- * Infer all router inputs
+ * Infer all router inputs.
+ *
+ * @remarks
+ * **Note**: A procedure is a router too.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @see {@link https://orpc.dev/docs/router#infer-router-inputs | Router - Infer Router Inputs}
  */
-type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any> ? InferSchemaInput<UInputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
 };
 /**
- * Infer all router outputs
+ * Infer all router outputs.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-outputs | Router - Infer Router Outputs}
  */
-type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any> ? InferSchemaOutput<UOutputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 /**
  * Infer the union of throwable errors for entire router.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-error | Router - Infer Router Error}
  */
-type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
+type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterError<U> : never;
 }[keyof T];
 /**
  * Infer throwable errors for each procedure, preserving the router shape.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-errors | Router - Infer Router Errors}
  */
-type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
+type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterErrors<U> : never;
 };
 
-export type { AnyRouter as A, ContractedRouter as C, InferRouterInitialContext as I, Router as R, InferRouterError as a, InferRouterErrors as b, InferRouterFinalContexts as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };
+export type { AnyRouter as A, ContractedRouter as C, InferRouterInitialContext as I, Router as R, InferRouterFinalContexts as a, InferRouterError as b, InferRouterErrors as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };

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

@@ -0,0 +1,14 @@
+import { Value, Promisable } from '@orpc/shared';
+import { StandardLazyRequest } from '@standard-server/core';
+import { C as Context } from './server.BEdOJs6S.js';
+import { a as StandardHandlerHandleOptions } from './server.DJNkZPfD.js';
+
+type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
+    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
+} : {
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+});
+declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
+
+export { resolveFriendlyStandardHandlerHandleOptions as r };
+export type { FriendlyStandardHandlerHandleOptions as F };

package/dist/shared/{server.DJIkub_t.d.mts → server.DJNkZPfD.d.ts}

@@ -1,7 +1,7 @@
 import { AnyORPCError } from '@orpc/client';
-import { OrderablePlugin, Interceptor, Promisable } from '@orpc/shared';
-import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.BL22TloH.mjs';
+import { OrderablePlugin, Value, Promisable, Interceptor } from '@orpc/shared';
+import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
+import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.BEdOJs6S.js';
 import { Schema, ErrorMap } from '@orpc/contract';
 
 interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
@@ -36,6 +36,17 @@ declare class CompositeStandardHandlerPlugin<T extends Context> implements Stand
 
 interface StandardHandlerHandleOptions<T extends Context> {
     prefix?: `/${string}` | undefined;
+    /**
+     * The initial context, or a function (sync or async) that receives the request and returns it.
+     * The function only runs once the request passes the prefix check.
+     */
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+}
+/**
+ * `StandardHandlerHandleOptions` after the context has been resolved,
+ * this is what interceptors and codecs receive.
+ */
+interface ResolvedStandardHandlerHandleOptions<T extends Context> extends Omit<StandardHandlerHandleOptions<T>, 'context'> {
     context: T;
 }
 type StandardHandlerHandleResult = {
@@ -45,11 +56,11 @@ type StandardHandlerHandleResult = {
     matched: false;
     response?: undefined;
 };
-interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, StandardHandlerHandleOptions<T> {
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, ResolvedStandardHandlerHandleOptions<T> {
     request: StandardLazyRequest;
 }
 type StandardHandlerInterceptor<T extends Context> = Interceptor<StandardHandlerInterceptorOptions<T>, Promise<StandardResponse>>;
-interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends ResolvedStandardHandlerHandleOptions<T> {
     request: StandardLazyRequest;
 }
 type StandardHandlerRoutingInterceptor<T extends Context> = Interceptor<StandardHandlerRoutingInterceptorOptions<T>, Promise<StandardHandlerHandleResult>>;
@@ -73,7 +84,7 @@ interface StandardHandlerOptions<TContext extends Context> {
      * ClientInterceptor equivalent with createRouterClient.interceptors / createProcedure.interceptors
      * useful for error handling, logging, metrics, etc. (not counting encoding/decoding)
      */
-    clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap, any>[];
+    clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap>[];
     plugins?: StandardHandlerPlugin<TContext>[];
 }
 declare class StandardHandler<T extends Context> {
@@ -82,9 +93,9 @@ declare class StandardHandler<T extends Context> {
     private readonly interceptors;
     private readonly clientInterceptors;
     constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
-    handle(request: StandardLazyRequest, { context, prefix }: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
+    handle(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
 }
-declare class OtelHandlerPlugin implements StandardHandlerPlugin<any> {
+declare class TracingHandlerPlugin implements StandardHandlerPlugin<any> {
     name: string;
     init(options: StandardHandlerOptions<any>): StandardHandlerOptions<any>;
 }
@@ -95,10 +106,10 @@ interface StandardHandlerCodecResolvedProcedure {
     decodeInput: () => Promise<unknown>;
 }
 interface StandardHandlerCodec<T extends Context> {
-    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
-    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
 }
 
-export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, StandardHandler as S };
-export type { StandardHandlerOptions as a, StandardHandlerHandleOptions as b, StandardHandlerCodec as c, StandardHandlerCodecResolvedProcedure as d, StandardHandlerPlugin as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerInterceptorOptions as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };
+export { CompositeStandardHandlerPlugin as C, StandardHandler as S, TracingHandlerPlugin as T };
+export type { ResolvedStandardHandlerHandleOptions as R, StandardHandlerHandleOptions as a, StandardHandlerPlugin as b, StandardHandlerOptions as c, StandardHandlerRoutingInterceptorOptions as d, StandardHandlerInterceptorOptions as e, StandardHandlerCodec as f, StandardHandlerCodecResolvedProcedure as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };

package/dist/shared/{server.Pa0F03f_.d.ts → server.DZeVx8K9.d.ts}

@@ -1,10 +1,10 @@
 import { RouterContract, ProcedureContract, ORPCErrorFromErrorMap, ThrowableError, InferSchemaInput, InferSchemaOutput } from '@orpc/contract';
-import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.BL22TloH.js';
+import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.BEdOJs6S.js';
 
-type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any, any> | {
+type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any> | {
     [k: string]: Lazyable<Router<TInitialContext>>;
 };
-type ContractedRouter<T extends RouterContract, TInitialContext extends Context> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap, never> : {
+type ContractedRouter<T extends RouterContract, TInitialContext extends Context> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap> : {
     [K in keyof T]: T[K] extends RouterContract ? Lazyable<ContractedRouter<T[K], TInitialContext>> : never;
 };
 type AnyRouter = Router<any>;
@@ -12,50 +12,62 @@ type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer $>
 /**
  * Infer all initial context of the router.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-initial-contexts | Router - Infer Router Initial Contexts}
  */
-type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any, any> ? UInitialContext : {
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any> ? UInitialContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
 };
 /**
  * Infer all current context of the router.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-final-contexts | Router - Infer Router Final Contexts}
  */
-type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : {
+type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterFinalContexts<U> : never;
 };
 /**
- * Infer all router inputs
+ * Infer all router inputs.
+ *
+ * @remarks
+ * **Note**: A procedure is a router too.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @see {@link https://orpc.dev/docs/router#infer-router-inputs | Router - Infer Router Inputs}
  */
-type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any> ? InferSchemaInput<UInputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
 };
 /**
- * Infer all router outputs
+ * Infer all router outputs.
  *
- * @info A procedure is a router too.
- * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-outputs | Router - Infer Router Outputs}
  */
-type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any> ? InferSchemaOutput<UOutputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 /**
  * Infer the union of throwable errors for entire router.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-error | Router - Infer Router Error}
  */
-type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
+type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterError<U> : never;
 }[keyof T];
 /**
  * Infer throwable errors for each procedure, preserving the router shape.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-errors | Router - Infer Router Errors}
  */
-type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
+type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterErrors<U> : never;
 };
 
-export type { AnyRouter as A, ContractedRouter as C, InferRouterInitialContext as I, Router as R, InferRouterError as a, InferRouterErrors as b, InferRouterFinalContexts as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };
+export type { AnyRouter as A, ContractedRouter as C, InferRouterInitialContext as I, Router as R, InferRouterFinalContexts as a, InferRouterError as b, InferRouterErrors as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };

package/dist/shared/{server.CrlKQucM.mjs → server.FEqy7Hrj.mjs}

@@ -1,32 +1,6 @@
-import { ORPCError, wrapEventIteratorPreservingMeta, cloneORPCError } from '@orpc/client';
-import { reconcileORPCError, ValidationError, ProcedureContract } from '@orpc/contract';
-import { getOrBind, resolveMaybeOptionalOptions, getConstructor, isTypescriptObject, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream } from '@orpc/shared';
-
-function createORPCErrorConstructorMap(errorMap) {
-  const proxy = new Proxy(errorMap, {
-    get(target, code) {
-      if (typeof code !== "string") {
-        return getOrBind(target, code);
-      }
-      const item = (...rest) => {
-        const options = resolveMaybeOptionalOptions(rest);
-        const config = errorMap[code];
-        const error = new ORPCError(code, {
-          message: options.message ?? config?.message,
-          data: options.data,
-          cause: options.cause
-        });
-        if (config) {
-          error.defined = true;
-          error.inferable = true;
-        }
-        return error;
-      };
-      return item;
-    }
-  });
-  return proxy;
-}
+import { wrapAsyncIteratorPreservingEventMeta, ORPCError } from '@orpc/client';
+import { createORPCErrorConstructorMap, reconcileORPCError, ValidationError, ProcedureContract } from '@orpc/contract';
+import { getConstructor, isTypescriptObject, resolveMaybeOptionalOptions, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, override, getTracer, traceAsyncIterator, traceReadableStream, mergeTwoLevels } from '@orpc/shared';
 
 class Lazy {
   "~orpc";
@@ -34,7 +8,7 @@ class Lazy {
     this["~orpc"] = def;
   }
   /**
-   * Checks if the given instance satisfies the {@see Lazy} class/interface.
+   * Checks if the given instance satisfies the {@link Lazy} class/interface.
    */
   static [Symbol.hasInstance](instance) {
     if (this !== Lazy) {
@@ -84,12 +58,11 @@ function createProcedureClient(lazyableProcedure, ...rest) {
         );
       });
       if (isAsyncIteratorObject(output)) {
-        return override(output, wrapEventIteratorPreservingMeta(
-          traceAsyncIterator("consume_event_iterator_output", output),
+        return override(output, wrapAsyncIteratorPreservingEventMeta(
+          getTracer() ? traceAsyncIterator("consume_async_iterator_object_output", output) : output,
           { mapError: reconcileError }
         ));
-      }
-      if (output instanceof ReadableStream) {
+      } else if (getTracer() && output instanceof ReadableStream) {
         return override(output, traceReadableStream("consume_octet_stream_output", output));
       }
       return output;
@@ -149,10 +122,19 @@ async function executeProcedureInternal(procedure, options) {
   const orderedMiddlewares = procedure["~orpc"].orderedMiddlewares;
   const next = async (midIndex, context, input) => {
     let currentInput = input;
+    let middlewareInput = input;
     const startInputIndex = midIndex === 0 ? 0 : orderedMiddlewares[midIndex - 1].inputSchemasLengthAtUse ?? 0;
     const endInputIndex = midIndex === orderedMiddlewares.length ? inputSchemas.length : orderedMiddlewares[midIndex].inputSchemasLengthAtUse ?? 0;
-    for (let i = startInputIndex; i < endInputIndex; i++) {
-      currentInput = await validateInput(i, inputSchemas[i], currentInput);
+    if (!procedure["~orpc"].disableInputValidation) {
+      for (let i = startInputIndex; i < endInputIndex; i++) {
+        const validated = await validateInput(
+          i,
+          inputSchemas[i],
+          i !== 0 ? mergeTwoLevels(options.input, currentInput) : currentInput
+        );
+        currentInput = i !== 0 ? mergeTwoLevels(currentInput, validated) : validated;
+      }
+      middlewareInput = endInputIndex > 0 && endInputIndex < inputSchemas.length ? mergeTwoLevels(options.input, currentInput) : currentInput;
     }
     let currentOutput;
     let currentContext = context;
@@ -175,7 +157,7 @@ async function executeProcedureInternal(procedure, options) {
             },
             lastEventId: options.lastEventId
           },
-          currentInput,
+          middlewareInput,
           middlewareDone
         );
       });
@@ -186,23 +168,13 @@ async function executeProcedureInternal(procedure, options) {
         "handler",
         () => procedure["~orpc"].handler({ ...options, context, input: currentInput }, currentInput)
       );
-      if (currentOutput instanceof ORPCError) {
-        if (procedure["~orpc"].opaqueReturnedErrors) {
-          throw currentOutput;
-        }
-        if (currentOutput.inferable && !currentOutput.defined) {
-          throw currentOutput;
-        }
-        const error = cloneORPCError(currentOutput);
-        error.defined = false;
-        error.inferable = true;
-        throw error;
-      }
     }
     const startOutputIndex = midIndex === 0 ? 0 : orderedMiddlewares[midIndex - 1].outputSchemasLengthAtUse ?? 0;
     const endOutputIndex = midIndex === orderedMiddlewares.length ? outputSchemas.length : orderedMiddlewares[midIndex].outputSchemasLengthAtUse ?? 0;
-    for (let i = endOutputIndex - 1; i >= startOutputIndex; i--) {
-      currentOutput = await validateOutput(i, outputSchemas[i], currentOutput);
+    if (!procedure["~orpc"].disableOutputValidation) {
+      for (let i = endOutputIndex - 1; i >= startOutputIndex; i--) {
+        currentOutput = await validateOutput(i, outputSchemas[i], currentOutput);
+      }
     }
     return { output: currentOutput, context: currentContext };
   };
@@ -216,7 +188,7 @@ class Procedure {
     this["~orpc"] = def;
   }
   /**
-   * Checks if the given instance satisfies the {@see Procedure} class/interface.
+   * Checks if the given instance satisfies the {@link Procedure} class/interface.
    */
   static [Symbol.hasInstance](instance) {
     if (this !== Procedure) {
@@ -230,4 +202,4 @@ class Procedure {
   }
 }
 
-export { Lazy as L, Procedure as P, createORPCErrorConstructorMap as a, createProcedureClient as c, unlazy as u };
+export { Lazy as L, Procedure as P, createProcedureClient as c, unlazy as u };

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

@@ -0,0 +1,14 @@
+import { Value, Promisable } from '@orpc/shared';
+import { StandardLazyRequest } from '@standard-server/core';
+import { C as Context } from './server.BEdOJs6S.mjs';
+import { a as StandardHandlerHandleOptions } from './server.CVO0hWyj.mjs';
+
+type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
+    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
+} : {
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+});
+declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
+
+export { resolveFriendlyStandardHandlerHandleOptions as r };
+export type { FriendlyStandardHandlerHandleOptions as F };

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.41",
+  "description": "Build typesafe APIs with oRPC: RPC and OpenAPI support, middleware, and adapters for Node.js, Bun, Deno, Fetch, Fastify, WebSocket, AWS Lambda, and more",
   "license": "MIT",
+  "funding": [
+    "https://github.com/sponsors/dinwwwh",
+    "https://opencollective.com/middleapi"
+  ],
   "homepage": "https://orpc.dev",
   "repository": {
     "type": "git",
@@ -10,7 +15,20 @@
     "directory": "packages/server"
   },
   "keywords": [
-    "orpc"
+    "orpc",
+    "rpc",
+    "api",
+    "typescript",
+    "typesafe",
+    "server",
+    "openapi",
+    "middleware",
+    "nodejs",
+    "bun",
+    "deno",
+    "fastify",
+    "websocket",
+    "aws-lambda"
   ],
   "sideEffects": [
     "./dist/extensions/callable.mjs"
@@ -52,6 +70,16 @@
       "import": "./dist/adapters/node/index.mjs",
       "default": "./dist/adapters/node/index.mjs"
     },
+    "./aws-lambda": {
+      "types": "./dist/adapters/aws-lambda/index.d.mts",
+      "import": "./dist/adapters/aws-lambda/index.mjs",
+      "default": "./dist/adapters/aws-lambda/index.mjs"
+    },
+    "./fastify": {
+      "types": "./dist/adapters/fastify/index.d.mts",
+      "import": "./dist/adapters/fastify/index.mjs",
+      "default": "./dist/adapters/fastify/index.mjs"
+    },
     "./websocket": {
       "types": "./dist/adapters/websocket/index.d.mts",
       "import": "./dist/adapters/websocket/index.mjs",
@@ -77,31 +105,37 @@
     "dist"
   ],
   "peerDependencies": {
-    "crossws": ">=0.3.4"
+    "crossws": ">=0.3.4",
+    "fastify": ">=5.6.1"
   },
   "peerDependenciesMeta": {
     "crossws": {
       "optional": true
+    },
+    "fastify": {
+      "optional": true
     }
   },
   "dependencies": {
-    "@standardserver/core": "^0.0.25",
-    "@standardserver/fetch": "^0.0.25",
-    "@standardserver/node": "^0.0.25",
-    "@standardserver/peer": "^0.0.25",
-    "cookie": "^1.1.1",
-    "@orpc/client": "2.0.0-beta.4",
-    "@orpc/interop": "2.0.0-beta.4",
-    "@orpc/contract": "2.0.0-beta.4",
-    "@orpc/shared": "2.0.0-beta.4"
+    "@orpc/client": "2.0.0-beta.41",
+    "@orpc/contract": "2.0.0-beta.41",
+    "@orpc/shared": "2.0.0-beta.41",
+    "@standard-server/aws-lambda": "~0.10.0",
+    "@standard-server/core": "~0.10.0",
+    "@standard-server/fastify": "~0.10.0",
+    "@standard-server/fetch": "~0.10.0",
+    "@standard-server/node": "~0.10.0",
+    "@standard-server/peer": "~0.10.0",
+    "cookie": "^2.0.1"
   },
   "devDependencies": {
     "crossws": "^0.4.6",
+    "fastify": "^5.12.1",
     "supertest": "^7.2.2",
-    "zod": "^4.4.3"
+    "ws": "^8.21.3",
+    "zod": "^4.5.4"
   },
   "scripts": {
-    "build": "unbuild",
     "type:check": "tsc -b"
   }
 }

package/dist/shared/server.CX4vUnDk.mjs

@@ -1,11 +0,0 @@
-import { value } from '@orpc/shared';
-
-function createStandardPeerRequestHandler(handler, options) {
-  return async (request) => {
-    const context = await value(options.context ?? {}, request);
-    const { response } = await handler.handle(request, { ...options, context });
-    return response ?? { status: 404, headers: {}, body: "No procedure matched" };
-  };
-}
-
-export { createStandardPeerRequestHandler as c };

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

@@ -1,66 +0,0 @@
-import { RPCSerializer, AnyORPCError } from '@orpc/client';
-import { Value, Promisable } from '@orpc/shared';
-import { StandardMethod, StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { A as AnyProcedure, C as Context } from './server.BL22TloH.mjs';
-import { A as AnyRouter } from './server.BsNNjG5J.mjs';
-import { AnyProcedureContract } from '@orpc/contract';
-import { b as StandardHandlerHandleOptions, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure } from './server.DJIkub_t.mjs';
-
-interface RPCMatcherOptions {
-    /**
-     * Filter which procedures are exposed for matching. Return `false` to exclude.
-     *
-     * @default true
-     */
-    filter?: Value<boolean, [procedure: AnyProcedureContract | AnyProcedure, path: string[]]>;
-}
-declare class RPCMatcher {
-    private readonly filter;
-    private readonly rootRouter;
-    private readonly tree;
-    private pendingLazyRouters;
-    constructor(router: AnyRouter, options?: RPCMatcherOptions);
-    private index;
-    match(_method: StandardMethod, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
-        path: string[];
-        procedure: AnyProcedure;
-    } | undefined>;
-    private matchPathname;
-    private resolvePendingLazyRouters;
-    private resolveProcedure;
-}
-
-interface RPCHandlerCodecOptions<T extends Context> extends RPCMatcherOptions {
-    /**
-     * Override the default RPC serializer.
-     */
-    serializer?: Pick<RPCSerializer, keyof RPCSerializer>;
-    /**
-     * Resolve HTTP status for encoded successful outputs.
-     *
-     * Value should be in range `200-299`
-     * Return `undefined` or `null` to fallback to default
-     *
-     * @default DEFAULT_ERROR_STATUS, DEFAULT_ERROR_STATUS
-     */
-    outputStatus?: Value<number | undefined | null, [output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>]>;
-    /**
-     * Mapping ORPCError Code -> HTTP Status Code
-     *
-     * @default COMMON_ERROR_STATUS_MAP
-     */
-    errorStatusMap?: Record<string, number> | undefined;
-}
-declare class RPCHandlerCodec<T extends Context> implements StandardHandlerCodec<T> {
-    private readonly matcher;
-    private readonly serializer;
-    private readonly errorStatusMap;
-    private readonly outputStatus;
-    constructor(router: AnyRouter, options?: RPCHandlerCodecOptions<T>);
-    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
-    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-    encodeError(error: AnyORPCError, _procedure: AnyProcedure, _path: string[], _options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-}
-
-export { RPCHandlerCodec as a, RPCMatcher as b };
-export type { RPCHandlerCodecOptions as R, RPCMatcherOptions as c };