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

package/dist/shared/server.1ExWFMze.mjs

@@ -0,0 +1,69 @@
+import { ORPCError } from '@orpc/client';
+import { toArray } from '@orpc/shared';
+import { flattenStandardHeader } from '@standard-server/core';
+import { toFetchHeaders, toStandardBody } from '@standard-server/fetch';
+
+class RequestLimitHandlerPlugin {
+  name = "~request-limit";
+  /**
+   * Should limit the original batch request body instead of sub-requests.
+   */
+  after = ["~batch"];
+  /**
+   * Should limit the final body size instead of the compressed one.
+   */
+  before = ["~request-compression"];
+  maxBodySize;
+  constructor(options) {
+    this.maxBodySize = options.maxBodySize;
+  }
+  init(options) {
+    const maxBodySize = this.maxBodySize;
+    const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+      return next({
+        ...interceptorOptions,
+        request: {
+          ...interceptorOptions.request,
+          async resolveBody(hint) {
+            const contentLength = Number(
+              flattenStandardHeader(interceptorOptions.request.headers["content-length"])
+            );
+            if (Number.isFinite(contentLength) && contentLength > maxBodySize) {
+              throw new ORPCError("PAYLOAD_TOO_LARGE");
+            }
+            const stream = await interceptorOptions.request.resolveBody("octet-stream");
+            if (!(stream instanceof ReadableStream)) {
+              return stream;
+            }
+            let currentBodySize = 0;
+            const limitedStream = stream.pipeThrough(
+              new TransformStream({
+                transform(chunk, controller) {
+                  currentBodySize += chunk.byteLength;
+                  if (currentBodySize > maxBodySize) {
+                    controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+                    return;
+                  }
+                  controller.enqueue(chunk);
+                }
+              })
+            );
+            const response = new Response(limitedStream, {
+              headers: toFetchHeaders(interceptorOptions.request.headers)
+            });
+            return toStandardBody(response, { hint });
+          }
+        }
+      });
+    };
+    return {
+      ...options,
+      routingInterceptors: [
+        routingInterceptor,
+        ...toArray(options.routingInterceptors)
+      ]
+    };
+  }
+}
+
+export { RequestLimitHandlerPlugin as R };

package/dist/shared/{server.CjOb6ItT.mjs → server.24nXyhbl.mjs}

@@ -1,5 +1,5 @@
 import { resolveMetaPlugins, mergeErrorMap, getHiddenMetaPlugins } from '@orpc/contract';
-import { P as Procedure } from './server.CrlKQucM.mjs';
+import { P as Procedure } from './server.Djb_ebJT.mjs';
 
 class DecoratedProcedure extends Procedure {
   meta(...plugins) {

package/dist/shared/{server.DBANIheG.d.ts → server.B5K1CViq.d.mts}

@@ -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.js';
+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.BsujoJoF.mjs';
 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.BsNNjG5J.d.mts → server.BpmUhems.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.BsujoJoF.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.BL22TloH.d.mts → server.BsujoJoF.d.mts}

@@ -1,5 +1,5 @@
-import { ORPCErrorCode, ORPCErrorOptions, ORPCError, AnyORPCError, ClientContext, Client } from '@orpc/client';
-import { ErrorMap, ErrorMapItem, InferSchemaInput, AnyMetaPlugin, AnySchema, ProcedureContractDefinition, Meta, InferSchemaOutput, ORPCErrorFromErrorMap } from '@orpc/contract';
+import { ClientContext, Client } from '@orpc/client';
+import { ErrorMap, AnyMetaPlugin, ORPCErrorConstructorMap, AnySchema, ProcedureContractDefinition, Meta, InferSchemaOutput, ORPCErrorFromErrorMap, InferSchemaInput } from '@orpc/contract';
 import { MaybeOptionalOptions, Promisable, Interceptor, PromiseWithError, ThrowableError, Value } from '@orpc/shared';
 
 interface Context {
@@ -8,40 +8,6 @@ interface Context {
 type MergedInitialContext<TInitial extends Context, TOutContext extends Context, TInContext extends Context> = Exclude<keyof TInContext, keyof TInitial | keyof TOutContext> extends never ? TInitial : TInitial & Omit<TInContext, keyof TInitial | keyof TOutContext>;
 type MergedContext<TCurrent extends Context, TOutContext extends Context> = keyof TOutContext extends never ? TCurrent : Omit<TCurrent, keyof TOutContext> & TOutContext;
 
-type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'status'>;
-interface ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> {
-    (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>): ORPCError<TCode, TInData>;
-}
-type ORPCErrorConstructorMap<T extends ErrorMap> = {
-    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, InferSchemaInput<UInputSchema>> : never : never;
-};
-/**
- * Creates a map of ORPC error constructors.
- *
- * The returned object is a `Proxy` that allows access to arbitrary error codes:
- * - If the code exists in the provided `errorMap`, the corresponding constructor
- *   will create a **defined** `ORPCError`.
- * - If the code does not exist, a fallback `ORPCError` constructor is returned.
- *
- * The `in` operator can be used to check whether an error code is explicitly
- * defined in the map.
- *
- * @example
- * ```ts
- * const errorMap = createORPCErrorConstructorMap({
- *   NOT_FOUND: {
- *     status: 404,
- *     message: 'Not Found',
- *   },
- * })
- *
- * if ('NOT_FOUND' in errorMap) {
- *   const error = errorMap.NOT_FOUND()
- * }
- * ```
- */
-declare function createORPCErrorConstructorMap<T extends ErrorMap>(errorMap: T): ORPCErrorConstructorMap<T>;
-
 type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
     output: TOutput;
     context: TOutContext;
@@ -94,7 +60,7 @@ interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErro
     context: TCurrentContext;
     input: TInput;
     path: string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, any>;
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap>;
     signal?: AbortSignal | undefined;
     lastEventId?: string | undefined;
     errors: TErrorConstructorMap;
@@ -119,32 +85,45 @@ interface OrderedMiddleware {
     outputSchemasLengthAtUse?: number | undefined;
     middleware: AnyMiddleware;
 }
-interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap> {
-    __TInitialContext?: (type: TInitialContext) => unknown;
-    __TInjectedContext?: (type: TInjectedContext) => unknown;
-    __TReturnedError?: () => TReturnedError;
+interface ProcedureConfig {
+    /**
+     * When enabled, input schemas are not validated at runtime.
+     * Schemas are still used for type inference and OpenAPI generation.
+     *
+     * @remarks
+     * **Warning**: Do not disable validation for schemas that transform values.
+     *
+     * @default false
+     */
+    disableInputValidation?: boolean | undefined;
     /**
-     * When enabled, errors returned (not thrown) by the handler are passed through as-is,
-     * rather than being transformed into inferrable errors.
+     * When enabled, output schemas are not validated at runtime.
+     * Schemas are still used for type inference and OpenAPI generation.
+     *
+     * Useful when output schemas exist only for specification generation.
      *
-     * This is intended for the contract-first approach, where the procedure adheres to an
-     * external contract and returned errors should not affect the inferred contract types.
+     * @remarks
+     * **Warning**: Do not disable validation for schemas that transform values.
      *
      * @default false
      */
-    opaqueReturnedErrors?: boolean | undefined;
+    disableOutputValidation?: boolean | undefined;
+}
+interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>, ProcedureConfig {
+    __TInitialContext?: (type: TInitialContext) => unknown;
+    __TInjectedContext?: (type: TInjectedContext) => unknown;
     orderedMiddlewares: OrderedMiddleware[];
     handler: ProcedureHandler<any, any, any, any>;
 }
-declare class Procedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
-    '~orpc': ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
-    constructor(def: ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>);
+declare class Procedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    '~orpc': ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+    constructor(def: ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>);
     /**
-     * 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: unknown): boolean;
 }
-type AnyProcedure = Procedure<any, any, any, any, any, any>;
+type AnyProcedure = Procedure<any, any, any, any, any>;
 
 interface LazyDefinition<T> {
     meta: Meta;
@@ -157,7 +136,7 @@ declare class Lazy<T> {
     '~orpc': LazyDefinition<T>;
     constructor(def: LazyDefinition<T>);
     /**
-     * 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: unknown): boolean;
 }
@@ -166,19 +145,19 @@ declare function unlazy<T extends Lazyable<any>>(maybeLazy: T): Promise<{
     default: T extends Lazy<infer U> ? U : T;
 }>;
 
-type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedORPCError extends AnyORPCError> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | TReturnedORPCError | ThrowableError>;
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>;
 interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap> extends ProcedureHandlerOptions<TInitialContext, unknown, ORPCErrorConstructorMap<TErrorMap>> {
 }
-type ProcedureClientInterceptor<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> = Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | TReturnedError | ThrowableError>>;
-type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError, TClientContext extends ClientContext> = {
+type ProcedureClientInterceptor<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>>;
+type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TClientContext extends ClientContext> = {
     path?: string[];
-    interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap, TReturnedError>[];
+    interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap>[];
 } & (object extends TInitialContext ? {
     context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
 } : {
     context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
 });
-declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError, TClientContext extends ClientContext = object>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TClientContext extends ClientContext = object>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
 
-export { Procedure as a, Lazy as g, createORPCErrorConstructorMap as w, createProcedureClient as x, unlazy as y };
-export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, ORPCErrorConstructorMap as O, ProcedureClientOptions as P, ProcedureClient as b, ProcedureClientInterceptor as c, Middleware as d, MergedInitialContext as e, AnyMiddleware as f, ProcedureHandler as h, OrderedMiddleware as i, LazyDefinition as j, MiddlewareDefinition as k, MiddlewareDone as l, MiddlewareDoneOptions as m, MiddlewareNext as n, MiddlewareNextOptions as o, MiddlewareOptions as p, MiddlewareResult as q, ORPCErrorConstructorMapItem as r, ORPCErrorConstructorMapItemOptions as s, ProcedureClientInterceptorOptions as t, ProcedureDefinition as u, ProcedureHandlerOptions as v };
+export { Procedure as a, Lazy as h, createProcedureClient as u, unlazy as v };
+export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, OrderedMiddleware as O, ProcedureClientOptions as P, ProcedureClient as b, ProcedureClientInterceptor as c, Middleware as d, MergedInitialContext as e, ProcedureConfig as f, AnyMiddleware as g, ProcedureHandler as i, LazyDefinition as j, MiddlewareDefinition as k, MiddlewareDone as l, MiddlewareDoneOptions as m, MiddlewareNext as n, MiddlewareNextOptions as o, MiddlewareOptions as p, MiddlewareResult as q, ProcedureClientInterceptorOptions as r, ProcedureDefinition as s, ProcedureHandlerOptions as t };

package/dist/shared/{server.BL22TloH.d.ts → server.BsujoJoF.d.ts}

@@ -1,5 +1,5 @@
-import { ORPCErrorCode, ORPCErrorOptions, ORPCError, AnyORPCError, ClientContext, Client } from '@orpc/client';
-import { ErrorMap, ErrorMapItem, InferSchemaInput, AnyMetaPlugin, AnySchema, ProcedureContractDefinition, Meta, InferSchemaOutput, ORPCErrorFromErrorMap } from '@orpc/contract';
+import { ClientContext, Client } from '@orpc/client';
+import { ErrorMap, AnyMetaPlugin, ORPCErrorConstructorMap, AnySchema, ProcedureContractDefinition, Meta, InferSchemaOutput, ORPCErrorFromErrorMap, InferSchemaInput } from '@orpc/contract';
 import { MaybeOptionalOptions, Promisable, Interceptor, PromiseWithError, ThrowableError, Value } from '@orpc/shared';
 
 interface Context {
@@ -8,40 +8,6 @@ interface Context {
 type MergedInitialContext<TInitial extends Context, TOutContext extends Context, TInContext extends Context> = Exclude<keyof TInContext, keyof TInitial | keyof TOutContext> extends never ? TInitial : TInitial & Omit<TInContext, keyof TInitial | keyof TOutContext>;
 type MergedContext<TCurrent extends Context, TOutContext extends Context> = keyof TOutContext extends never ? TCurrent : Omit<TCurrent, keyof TOutContext> & TOutContext;
 
-type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'status'>;
-interface ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> {
-    (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>): ORPCError<TCode, TInData>;
-}
-type ORPCErrorConstructorMap<T extends ErrorMap> = {
-    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, InferSchemaInput<UInputSchema>> : never : never;
-};
-/**
- * Creates a map of ORPC error constructors.
- *
- * The returned object is a `Proxy` that allows access to arbitrary error codes:
- * - If the code exists in the provided `errorMap`, the corresponding constructor
- *   will create a **defined** `ORPCError`.
- * - If the code does not exist, a fallback `ORPCError` constructor is returned.
- *
- * The `in` operator can be used to check whether an error code is explicitly
- * defined in the map.
- *
- * @example
- * ```ts
- * const errorMap = createORPCErrorConstructorMap({
- *   NOT_FOUND: {
- *     status: 404,
- *     message: 'Not Found',
- *   },
- * })
- *
- * if ('NOT_FOUND' in errorMap) {
- *   const error = errorMap.NOT_FOUND()
- * }
- * ```
- */
-declare function createORPCErrorConstructorMap<T extends ErrorMap>(errorMap: T): ORPCErrorConstructorMap<T>;
-
 type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
     output: TOutput;
     context: TOutContext;
@@ -94,7 +60,7 @@ interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErro
     context: TCurrentContext;
     input: TInput;
     path: string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, any>;
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap>;
     signal?: AbortSignal | undefined;
     lastEventId?: string | undefined;
     errors: TErrorConstructorMap;
@@ -119,32 +85,45 @@ interface OrderedMiddleware {
     outputSchemasLengthAtUse?: number | undefined;
     middleware: AnyMiddleware;
 }
-interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap> {
-    __TInitialContext?: (type: TInitialContext) => unknown;
-    __TInjectedContext?: (type: TInjectedContext) => unknown;
-    __TReturnedError?: () => TReturnedError;
+interface ProcedureConfig {
+    /**
+     * When enabled, input schemas are not validated at runtime.
+     * Schemas are still used for type inference and OpenAPI generation.
+     *
+     * @remarks
+     * **Warning**: Do not disable validation for schemas that transform values.
+     *
+     * @default false
+     */
+    disableInputValidation?: boolean | undefined;
     /**
-     * When enabled, errors returned (not thrown) by the handler are passed through as-is,
-     * rather than being transformed into inferrable errors.
+     * When enabled, output schemas are not validated at runtime.
+     * Schemas are still used for type inference and OpenAPI generation.
+     *
+     * Useful when output schemas exist only for specification generation.
      *
-     * This is intended for the contract-first approach, where the procedure adheres to an
-     * external contract and returned errors should not affect the inferred contract types.
+     * @remarks
+     * **Warning**: Do not disable validation for schemas that transform values.
      *
      * @default false
      */
-    opaqueReturnedErrors?: boolean | undefined;
+    disableOutputValidation?: boolean | undefined;
+}
+interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>, ProcedureConfig {
+    __TInitialContext?: (type: TInitialContext) => unknown;
+    __TInjectedContext?: (type: TInjectedContext) => unknown;
     orderedMiddlewares: OrderedMiddleware[];
     handler: ProcedureHandler<any, any, any, any>;
 }
-declare class Procedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
-    '~orpc': ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
-    constructor(def: ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>);
+declare class Procedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    '~orpc': ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+    constructor(def: ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>);
     /**
-     * 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: unknown): boolean;
 }
-type AnyProcedure = Procedure<any, any, any, any, any, any>;
+type AnyProcedure = Procedure<any, any, any, any, any>;
 
 interface LazyDefinition<T> {
     meta: Meta;
@@ -157,7 +136,7 @@ declare class Lazy<T> {
     '~orpc': LazyDefinition<T>;
     constructor(def: LazyDefinition<T>);
     /**
-     * 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: unknown): boolean;
 }
@@ -166,19 +145,19 @@ declare function unlazy<T extends Lazyable<any>>(maybeLazy: T): Promise<{
     default: T extends Lazy<infer U> ? U : T;
 }>;
 
-type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedORPCError extends AnyORPCError> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | TReturnedORPCError | ThrowableError>;
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>;
 interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap> extends ProcedureHandlerOptions<TInitialContext, unknown, ORPCErrorConstructorMap<TErrorMap>> {
 }
-type ProcedureClientInterceptor<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> = Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | TReturnedError | ThrowableError>>;
-type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError, TClientContext extends ClientContext> = {
+type ProcedureClientInterceptor<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>>;
+type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TClientContext extends ClientContext> = {
     path?: string[];
-    interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap, TReturnedError>[];
+    interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap>[];
 } & (object extends TInitialContext ? {
     context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
 } : {
     context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
 });
-declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError, TClientContext extends ClientContext = object>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TClientContext extends ClientContext = object>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
 
-export { Procedure as a, Lazy as g, createORPCErrorConstructorMap as w, createProcedureClient as x, unlazy as y };
-export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, ORPCErrorConstructorMap as O, ProcedureClientOptions as P, ProcedureClient as b, ProcedureClientInterceptor as c, Middleware as d, MergedInitialContext as e, AnyMiddleware as f, ProcedureHandler as h, OrderedMiddleware as i, LazyDefinition as j, MiddlewareDefinition as k, MiddlewareDone as l, MiddlewareDoneOptions as m, MiddlewareNext as n, MiddlewareNextOptions as o, MiddlewareOptions as p, MiddlewareResult as q, ORPCErrorConstructorMapItem as r, ORPCErrorConstructorMapItemOptions as s, ProcedureClientInterceptorOptions as t, ProcedureDefinition as u, ProcedureHandlerOptions as v };
+export { Procedure as a, Lazy as h, createProcedureClient as u, unlazy as v };
+export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, OrderedMiddleware as O, ProcedureClientOptions as P, ProcedureClient as b, ProcedureClientInterceptor as c, Middleware as d, MergedInitialContext as e, ProcedureConfig as f, AnyMiddleware as g, ProcedureHandler as i, LazyDefinition as j, MiddlewareDefinition as k, MiddlewareDone as l, MiddlewareDoneOptions as m, MiddlewareNext as n, MiddlewareNextOptions as o, MiddlewareOptions as p, MiddlewareResult as q, ProcedureClientInterceptorOptions as r, ProcedureDefinition as s, ProcedureHandlerOptions as t };