@orpc/server 0.0.0-next.9b9ade5 → 0.0.0-next.9d7bfaa

package/dist/shared/{server.CMrS28Go.mjs → server.DG7Tamti.mjs}

@@ -1,6 +1,6 @@
 import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
 import { fallbackORPCErrorStatus, ORPCError } from '@orpc/client';
-import { value, intercept, toError } from '@orpc/shared';
+import { value, intercept } from '@orpc/shared';
 
 const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
 function lazy(loader, meta = {}) {
@@ -21,7 +21,24 @@ function unlazy(lazied) {
   return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
 }
 
-function mergeMiddlewares(first, second) {
+function isStartWithMiddlewares(middlewares, compare) {
+  if (compare.length > middlewares.length) {
+    return false;
+  }
+  for (let i = 0; i < middlewares.length; i++) {
+    if (compare[i] === void 0) {
+      return true;
+    }
+    if (middlewares[i] !== compare[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function mergeMiddlewares(first, second, options) {
+  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
+    return second;
+  }
   return [...first, ...second];
 }
 function addMiddleware(middlewares, addition) {
@@ -29,6 +46,9 @@ function addMiddleware(middlewares, addition) {
 }
 
 class Procedure {
+  /**
+   * This property holds the defined options.
+   */
   "~orpc";
   constructor(def) {
     this["~orpc"] = def;
@@ -41,6 +61,10 @@ function isProcedure(item) {
   return isContractProcedure(item) && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
 }
 
+function mergeCurrentContext(context, other) {
+  return { ...context, ...other };
+}
+
 function createORPCErrorConstructorMap(errors) {
   const proxy = new Proxy(errors, {
     get(target, code) {
@@ -106,7 +130,7 @@ function createProcedureClient(lazyableProcedure, ...[options]) {
       );
     } catch (e) {
       if (!(e instanceof ORPCError)) {
-        throw toError(e);
+        throw e;
       }
       const validated = await validateORPCError(procedure["~orpc"].errorMap, e);
       throw validated;
@@ -148,28 +172,29 @@ async function executeProcedureInternal(procedure, options) {
   const middlewares = procedure["~orpc"].middlewares;
   const inputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].inputValidationIndex), middlewares.length);
   const outputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].outputValidationIndex), middlewares.length);
-  let currentIndex = 0;
-  let currentContext = options.context;
-  let currentInput = options.input;
-  const next = async (...[nextOptions]) => {
-    const index = currentIndex;
-    currentIndex += 1;
-    currentContext = { ...currentContext, ...nextOptions?.context };
+  const next = async (index, context, input) => {
+    let currentInput = input;
     if (index === inputValidationIndex) {
       currentInput = await validateInput(procedure, currentInput);
     }
     const mid = middlewares[index];
-    const result = mid ? await mid({ ...options, context: currentContext, next }, currentInput, middlewareOutputFn) : { output: await procedure["~orpc"].handler({ ...options, context: currentContext, input: currentInput }), context: currentContext };
+    const output = mid ? (await mid({
+      ...options,
+      context,
+      next: async (...[nextOptions]) => {
+        const nextContext = nextOptions?.context ?? {};
+        return {
+          output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
+          context: nextContext
+        };
+      }
+    }, currentInput, middlewareOutputFn)).output : await procedure["~orpc"].handler({ ...options, context, input: currentInput });
     if (index === outputValidationIndex) {
-      const validatedOutput = await validateOutput(procedure, result.output);
-      return {
-        ...result,
-        output: validatedOutput
-      };
+      return await validateOutput(procedure, output);
     }
-    return result;
+    return output;
   };
-  return (await next({})).output;
+  return next(0, options.context, options.input);
 }
 
 const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
@@ -239,7 +264,7 @@ function enhanceRouter(router, options) {
     return accessible;
   }
   if (isProcedure(router)) {
-    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares);
+    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, { dedupeLeading: options.dedupeLeadingMiddlewares });
     const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
     const enhanced2 = new Procedure({
       ...router["~orpc"],
@@ -339,8 +364,4 @@ function call(procedure, input, ...rest) {
   return createProcedureClient(procedure, ...rest)(input);
 }
 
-function toHttpPath(path) {
-  return `/${path.map(encodeURIComponent).join("/")}`;
-}
-
-export { LAZY_SYMBOL as L, Procedure as P, toHttpPath as a, createContractedProcedure as b, createProcedureClient as c, addMiddleware as d, enhanceRouter as e, isLazy as f, getRouter as g, createAssertedLazyProcedure as h, isProcedure as i, getLazyMeta as j, call as k, lazy as l, middlewareOutputFn as m, getHiddenRouterContract as n, createAccessibleLazyRouter as o, unlazyRouter as p, resolveContractProcedures as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u };
+export { LAZY_SYMBOL as L, Procedure as P, createContractedProcedure as a, addMiddleware as b, createProcedureClient as c, isLazy as d, enhanceRouter as e, createAssertedLazyProcedure as f, getRouter as g, createORPCErrorConstructorMap as h, isProcedure as i, getLazyMeta as j, middlewareOutputFn as k, lazy as l, mergeCurrentContext as m, isStartWithMiddlewares as n, mergeMiddlewares as o, call as p, getHiddenRouterContract as q, createAccessibleLazyRouter as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u, validateORPCError as v, resolveContractProcedures as w, unlazyRouter as x };

package/dist/shared/{server.CPteJIPP.d.mts → server.DPWk5pjW.d.mts}

@@ -1,19 +1,19 @@
-import { ORPCErrorCode, ORPCErrorOptions, ORPCError, ClientContext, Client } from '@orpc/client';
-import { IsNever, MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
-import { ErrorMap, ErrorMapItem, InferSchemaInput, HTTPPath, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, HTTPPath, ClientContext, Client } from '@orpc/client';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
+import { MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
 
-type Context = Record<string, any>;
-type MergedContext<T extends Context, U extends Context> = T & U;
-declare function mergeContext<T extends Context, U extends Context>(context: T, other: U): MergedContext<T, U>;
-type ConflictContextGuard<T extends Context> = true extends IsNever<T> | {
-    [K in keyof T]: IsNever<T[K]>;
-}[keyof T] ? never : unknown;
+type Context = Record<PropertyKey, any>;
+type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
+type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
+declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
 
 type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
 type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
 type ORPCErrorConstructorMap<T extends ErrorMap> = {
     [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, InferSchemaInput<UInputSchema>> : never : never;
 };
+declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
+declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
 
 declare const LAZY_SYMBOL: unique symbol;
 interface LazyMeta {
@@ -28,6 +28,9 @@ interface Lazy<T> {
     };
 }
 type Lazyable<T> = T | Lazy<T>;
+/**
+ * Create a lazy thing.
+ */
 declare function lazy<T>(loader: () => Promise<{
     default: T;
 }>, meta?: LazyMeta): Lazy<T>;
@@ -51,12 +54,20 @@ interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutp
 }
 interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
     __initialContext?: (type: TInitialContext) => unknown;
-    middlewares: AnyMiddleware[];
+    middlewares: readonly AnyMiddleware[];
     inputValidationIndex: number;
     outputValidationIndex: number;
     handler: ProcedureHandler<TCurrentContext, any, any, any, any>;
 }
+/**
+ * This class represents a procedure.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
+ */
 declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    /**
+     * This property holds the defined options.
+     */
     '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
     constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>);
 }
@@ -72,8 +83,8 @@ type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never>
 } : {
     context: TOutContext;
 };
-interface MiddlewareNextFn<TInContext extends Context, TOutput> {
-    <U extends Context & Partial<TInContext> = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
+interface MiddlewareNextFn<TOutput> {
+    <U extends Context = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
 }
 interface MiddlewareOutputFn<TOutput> {
     (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
@@ -84,9 +95,14 @@ interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstruct
     procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
     signal?: AbortSignal;
     lastEventId: string | undefined;
-    next: MiddlewareNextFn<TInContext, TOutput>;
+    next: MiddlewareNextFn<TOutput>;
     errors: TErrorConstructorMap;
 }
+/**
+ * A function that represents a middleware.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+ */
 interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
     (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
 }
@@ -97,47 +113,80 @@ interface MapInputMiddleware<TInput, TMappedInput> {
 declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
 
 type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
-interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
     context: TInitialContext;
-    input: InferSchemaInput<TInputSchema>;
+    input: unknown;
     errors: ORPCErrorConstructorMap<TErrorMap>;
     path: readonly string[];
     procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
     signal?: AbortSignal;
     lastEventId: string | undefined;
 }
-/**
- * Options for creating a procedure caller with comprehensive type safety
- */
-type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
     /**
      * This is helpful for logging and analytics.
      */
     path?: readonly string[];
-    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TInputSchema, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
 } & (Record<never, never> extends TInitialContext ? {
     context?: Value<TInitialContext, [clientContext: TClientContext]>;
 } : {
     context: Value<TInitialContext, [clientContext: TClientContext]>;
 });
-declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+/**
+ * Create Server-side client from a procedure.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
+ */
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
 
+/**
+ * Represents a router, which defines a hierarchical structure of procedures.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/contract-first/define-contract#contract-router Contract Router Docs}
+ */
 type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, UErrorMap, UMeta> : {
     [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;
 };
 type AnyRouter = Router<any, any>;
 type InferRouterInitialContext<T extends AnyRouter> = T extends Router<any, infer UInitialContext> ? UInitialContext : never;
+/**
+ * Infer all initial context of the router.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
 type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, 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.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
 type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any, any> ? UCurrentContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
 };
+/**
+ * Infer all router inputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
 type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
 };
+/**
+ * Infer all router outputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
 type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 
-export { type AnyProcedure as A, createProcedureClient as B, type Context as C, type InferRouterInitialContexts as D, type InferRouterCurrentContexts as E, type InferRouterInputs as F, type InferRouterOutputs as G, type InferRouterInitialContext as I, type Lazyable as L, type Middleware as M, type ORPCErrorConstructorMap as O, type ProcedureClientInterceptorOptions as P, type Router as R, type AnyRouter as a, Procedure as b, type ConflictContextGuard as c, type MergedContext as d, type MapInputMiddleware as e, type CreateProcedureClientOptions as f, type ProcedureClient as g, type AnyMiddleware as h, type Lazy as i, type ProcedureHandler as j, LAZY_SYMBOL as k, type LazyMeta as l, mergeContext as m, lazy as n, isLazy as o, getLazyMeta as p, type MiddlewareResult as q, type MiddlewareNextFnOptions as r, type MiddlewareNextFn as s, type MiddlewareOutputFn as t, unlazy as u, type MiddlewareOptions as v, middlewareOutputFn as w, type ProcedureHandlerOptions as x, type ProcedureDef as y, isProcedure as z };
+export { isProcedure as E, createProcedureClient as G, Procedure as P, createORPCErrorConstructorMap as l, mergeCurrentContext as m, LAZY_SYMBOL as n, lazy as p, isLazy as q, getLazyMeta as r, unlazy as u, validateORPCError as v, middlewareOutputFn as z };
+export type { AnyMiddleware as A, ProcedureHandlerOptions as B, Context as C, ProcedureDef as D, ProcedureClientInterceptorOptions as F, InferRouterInitialContexts as H, InferRouterInitialContext as I, InferRouterCurrentContexts as J, InferRouterInputs as K, Lazyable as L, Middleware as M, InferRouterOutputs as N, ORPCErrorConstructorMap as O, Router as R, MergedInitialContext as a, MergedCurrentContext as b, MapInputMiddleware as c, CreateProcedureClientOptions as d, ProcedureClient as e, AnyRouter as f, Lazy as g, AnyProcedure as h, ProcedureHandler as i, ORPCErrorConstructorMapItemOptions as j, ORPCErrorConstructorMapItem as k, LazyMeta as o, MiddlewareResult as s, MiddlewareNextFnOptions as t, MiddlewareNextFn as w, MiddlewareOutputFn as x, MiddlewareOptions as y };

package/dist/shared/{server.CPteJIPP.d.ts → server.DPWk5pjW.d.ts}

@@ -1,19 +1,19 @@
-import { ORPCErrorCode, ORPCErrorOptions, ORPCError, ClientContext, Client } from '@orpc/client';
-import { IsNever, MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
-import { ErrorMap, ErrorMapItem, InferSchemaInput, HTTPPath, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, HTTPPath, ClientContext, Client } from '@orpc/client';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
+import { MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
 
-type Context = Record<string, any>;
-type MergedContext<T extends Context, U extends Context> = T & U;
-declare function mergeContext<T extends Context, U extends Context>(context: T, other: U): MergedContext<T, U>;
-type ConflictContextGuard<T extends Context> = true extends IsNever<T> | {
-    [K in keyof T]: IsNever<T[K]>;
-}[keyof T] ? never : unknown;
+type Context = Record<PropertyKey, any>;
+type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
+type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
+declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
 
 type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
 type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
 type ORPCErrorConstructorMap<T extends ErrorMap> = {
     [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, InferSchemaInput<UInputSchema>> : never : never;
 };
+declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
+declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
 
 declare const LAZY_SYMBOL: unique symbol;
 interface LazyMeta {
@@ -28,6 +28,9 @@ interface Lazy<T> {
     };
 }
 type Lazyable<T> = T | Lazy<T>;
+/**
+ * Create a lazy thing.
+ */
 declare function lazy<T>(loader: () => Promise<{
     default: T;
 }>, meta?: LazyMeta): Lazy<T>;
@@ -51,12 +54,20 @@ interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutp
 }
 interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
     __initialContext?: (type: TInitialContext) => unknown;
-    middlewares: AnyMiddleware[];
+    middlewares: readonly AnyMiddleware[];
     inputValidationIndex: number;
     outputValidationIndex: number;
     handler: ProcedureHandler<TCurrentContext, any, any, any, any>;
 }
+/**
+ * This class represents a procedure.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
+ */
 declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    /**
+     * This property holds the defined options.
+     */
     '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
     constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>);
 }
@@ -72,8 +83,8 @@ type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never>
 } : {
     context: TOutContext;
 };
-interface MiddlewareNextFn<TInContext extends Context, TOutput> {
-    <U extends Context & Partial<TInContext> = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
+interface MiddlewareNextFn<TOutput> {
+    <U extends Context = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
 }
 interface MiddlewareOutputFn<TOutput> {
     (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
@@ -84,9 +95,14 @@ interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstruct
     procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
     signal?: AbortSignal;
     lastEventId: string | undefined;
-    next: MiddlewareNextFn<TInContext, TOutput>;
+    next: MiddlewareNextFn<TOutput>;
     errors: TErrorConstructorMap;
 }
+/**
+ * A function that represents a middleware.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+ */
 interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
     (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
 }
@@ -97,47 +113,80 @@ interface MapInputMiddleware<TInput, TMappedInput> {
 declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
 
 type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
-interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
     context: TInitialContext;
-    input: InferSchemaInput<TInputSchema>;
+    input: unknown;
     errors: ORPCErrorConstructorMap<TErrorMap>;
     path: readonly string[];
     procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
     signal?: AbortSignal;
     lastEventId: string | undefined;
 }
-/**
- * Options for creating a procedure caller with comprehensive type safety
- */
-type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
     /**
      * This is helpful for logging and analytics.
      */
     path?: readonly string[];
-    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TInputSchema, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
 } & (Record<never, never> extends TInitialContext ? {
     context?: Value<TInitialContext, [clientContext: TClientContext]>;
 } : {
     context: Value<TInitialContext, [clientContext: TClientContext]>;
 });
-declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+/**
+ * Create Server-side client from a procedure.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
+ */
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
 
+/**
+ * Represents a router, which defines a hierarchical structure of procedures.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/contract-first/define-contract#contract-router Contract Router Docs}
+ */
 type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, UErrorMap, UMeta> : {
     [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;
 };
 type AnyRouter = Router<any, any>;
 type InferRouterInitialContext<T extends AnyRouter> = T extends Router<any, infer UInitialContext> ? UInitialContext : never;
+/**
+ * Infer all initial context of the router.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
 type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, 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.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
 type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any, any> ? UCurrentContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
 };
+/**
+ * Infer all router inputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
 type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
 };
+/**
+ * Infer all router outputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
 type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 
-export { type AnyProcedure as A, createProcedureClient as B, type Context as C, type InferRouterInitialContexts as D, type InferRouterCurrentContexts as E, type InferRouterInputs as F, type InferRouterOutputs as G, type InferRouterInitialContext as I, type Lazyable as L, type Middleware as M, type ORPCErrorConstructorMap as O, type ProcedureClientInterceptorOptions as P, type Router as R, type AnyRouter as a, Procedure as b, type ConflictContextGuard as c, type MergedContext as d, type MapInputMiddleware as e, type CreateProcedureClientOptions as f, type ProcedureClient as g, type AnyMiddleware as h, type Lazy as i, type ProcedureHandler as j, LAZY_SYMBOL as k, type LazyMeta as l, mergeContext as m, lazy as n, isLazy as o, getLazyMeta as p, type MiddlewareResult as q, type MiddlewareNextFnOptions as r, type MiddlewareNextFn as s, type MiddlewareOutputFn as t, unlazy as u, type MiddlewareOptions as v, middlewareOutputFn as w, type ProcedureHandlerOptions as x, type ProcedureDef as y, isProcedure as z };
+export { isProcedure as E, createProcedureClient as G, Procedure as P, createORPCErrorConstructorMap as l, mergeCurrentContext as m, LAZY_SYMBOL as n, lazy as p, isLazy as q, getLazyMeta as r, unlazy as u, validateORPCError as v, middlewareOutputFn as z };
+export type { AnyMiddleware as A, ProcedureHandlerOptions as B, Context as C, ProcedureDef as D, ProcedureClientInterceptorOptions as F, InferRouterInitialContexts as H, InferRouterInitialContext as I, InferRouterCurrentContexts as J, InferRouterInputs as K, Lazyable as L, Middleware as M, InferRouterOutputs as N, ORPCErrorConstructorMap as O, Router as R, MergedInitialContext as a, MergedCurrentContext as b, MapInputMiddleware as c, CreateProcedureClientOptions as d, ProcedureClient as e, AnyRouter as f, Lazy as g, AnyProcedure as h, ProcedureHandler as i, ORPCErrorConstructorMapItemOptions as j, ORPCErrorConstructorMapItem as k, LazyMeta as o, MiddlewareResult as s, MiddlewareNextFnOptions as t, MiddlewareNextFn as w, MiddlewareOutputFn as x, MiddlewareOptions as y };

package/dist/shared/{server.DmW25ynm.d.ts → server.DY7OKEoj.d.mts}

@@ -1,8 +1,18 @@
-import { HTTPPath, AnySchema, Meta, InferSchemaOutput, ErrorFromErrorMap } from '@orpc/contract';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { HTTPPath, ORPCError } from '@orpc/client';
+import { Meta, InferSchemaOutput, AnySchema, ErrorFromErrorMap } from '@orpc/contract';
+import { Interceptor, ThrowableError } from '@orpc/shared';
 import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
-import { a as AnyRouter, A as AnyProcedure, C as Context, P as ProcedureClientInterceptorOptions, R as Router } from './server.CPteJIPP.js';
-import { ORPCError } from '@orpc/client';
+import { C as Context, f as AnyRouter, h as AnyProcedure, F as ProcedureClientInterceptorOptions, R as Router } from './server.DPWk5pjW.mjs';
+
+interface StandardHandlerPlugin<TContext extends Context> {
+    order?: number;
+    init?(options: StandardHandlerOptions<TContext>): void;
+}
+declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
+    protected readonly plugins: TPlugin[];
+    constructor(plugins?: readonly TPlugin[]);
+    init(options: StandardHandlerOptions<T>): void;
+}
 
 type StandardParams = Record<string, string>;
 type StandardMatchResult = {
@@ -20,13 +30,10 @@ interface StandardCodec {
     decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
 }
 
-type StandardHandleOptions<T extends Context> = {
+interface StandardHandleOptions<T extends Context> {
     prefix?: HTTPPath;
-} & (Record<never, never> extends T ? {
-    context?: T;
-} : {
     context: T;
-});
+}
 type StandardHandleResult = {
     matched: true;
     response: StandardResponse;
@@ -34,42 +41,34 @@ type StandardHandleResult = {
     matched: false;
     response: undefined;
 };
-type StandardHandlerInterceptorOptions<T extends Context> = StandardHandleOptions<T> & {
-    context: T;
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
     request: StandardLazyRequest;
-};
+}
 interface StandardHandlerOptions<TContext extends Context> {
-    plugins?: HandlerPlugin<TContext>[];
+    plugins?: StandardHandlerPlugin<TContext>[];
     /**
      * Interceptors at the request level, helpful when you want catch errors
      */
-    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
     /**
      * Interceptors at the root level, helpful when you want override the request/response
      */
-    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
     /**
      *
      * Interceptors for procedure client.
      */
-    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, AnySchema, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
 }
 declare class StandardHandler<T extends Context> {
     private readonly matcher;
     private readonly codec;
-    private readonly options;
-    private readonly plugin;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    private readonly rootInterceptors;
     constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
-    handle(request: StandardLazyRequest, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<StandardHandleResult>;
-}
-
-interface HandlerPlugin<TContext extends Context> {
-    init?(options: StandardHandlerOptions<TContext>): void;
-}
-declare class CompositePlugin<TContext extends Context> implements HandlerPlugin<TContext> {
-    private readonly plugins;
-    constructor(plugins?: HandlerPlugin<TContext>[]);
-    init(options: StandardHandlerOptions<TContext>): void;
+    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
 }
 
-export { CompositePlugin as C, type HandlerPlugin as H, type StandardHandleOptions as S, type StandardHandlerInterceptorOptions as a, type StandardHandlerOptions as b, type StandardCodec as c, type StandardParams as d, type StandardMatcher as e, type StandardMatchResult as f, type StandardHandleResult as g, StandardHandler as h };
+export { CompositeStandardHandlerPlugin as C, StandardHandler as i };
+export type { StandardHandlerInterceptorOptions as S, StandardHandlerPlugin as a, StandardHandlerOptions as b, StandardCodec as c, StandardParams as d, StandardMatcher as e, StandardMatchResult as f, StandardHandleOptions as g, StandardHandleResult as h };

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

@@ -0,0 +1,10 @@
+import { C as Context } from './server.DPWk5pjW.mjs';
+import { g as StandardHandleOptions } from './server.DY7OKEoj.mjs';
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+
+export type { FriendlyStandardHandleOptions as F };