@orpc/server 0.0.0-next.db1f26d → 0.0.0-next.df024bb

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

@@ -0,0 +1,158 @@
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, ClientContext, Client } from '@orpc/client';
+import { IsNever, MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
+import { ErrorMap, ErrorMapItem, SchemaInput, HTTPPath, Meta, Schema, ContractProcedureDef, SchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure, MergedErrorMap } from '@orpc/contract';
+
+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 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, SchemaInput<UInputSchema>> : never : never;
+};
+
+declare const LAZY_LOADER_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_LOADER_SYMBOL](): Promise<{
+        default: T;
+    }>;
+}
+type Lazyable<T> = T | Lazy<T>;
+interface LazyOptions {
+    prefix?: HTTPPath;
+}
+declare function lazy<T>(loader: () => Promise<{
+    default: T;
+}>): Lazy<T>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never> extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+};
+interface MiddlewareNextFn<TInContext extends Context, TOutput> {
+    <U extends Context & Partial<TInContext> = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TInContext;
+    path: string[];
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    next: MiddlewareNextFn<TInContext, TOutput>;
+    errors: TErrorConstructorMap;
+}
+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>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TCurrentContext;
+    input: TInput;
+    path: string[];
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    errors: TErrorConstructorMap;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    (opt: ProcedureHandlerOptions<TCurrentContext, TInput, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
+}
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    __initialContext?: (type: TInitialContext) => unknown;
+    middlewares: AnyMiddleware[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+    handler: ProcedureHandler<TCurrentContext, any, THandlerOutput, any, any>;
+}
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>;
+    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>);
+}
+type AnyProcedure = Procedure<any, any, any, any, any, any, any>;
+declare function isProcedure(item: unknown): item is AnyProcedure;
+
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    context: TInitialContext;
+    input: SchemaInput<TInputSchema>;
+    errors: ORPCErrorConstructorMap<TErrorMap>;
+    path: string[];
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+}
+/**
+ * Options for creating a procedure caller with comprehensive type safety
+ */
+type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+    /**
+     * This is helpful for logging and analytics.
+     */
+    path?: string[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TInputSchema, TErrorMap, TMeta>, SchemaOutput<TOutputSchema, THandlerOutput>, 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 Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+
+type AccessibleLazyRouter<T extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : Lazy<T> & (T extends AnyProcedure | undefined ? unknown : {
+    [K in keyof T]: T[K] extends AnyRouter ? AccessibleLazyRouter<T[K]> : never;
+});
+declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
+
+type Router<TInitialContext extends Context, TContract extends AnyContractRouter> = Lazyable<TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, any, UErrorMap, UMeta> : {
+    [K in keyof TContract]: TContract[K] extends AnyContractRouter ? Router<TInitialContext, TContract[K]> : never;
+}>;
+type AnyRouter = Router<any, any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer UInitialContext, any> ? UInitialContext : never;
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : T extends Procedure<infer UInitialContext, any, any, any, any, any, any> ? UInitialContext : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterInitialContexts<T[K]> : never;
+};
+type InferRouterCurrentContexts<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : T extends Procedure<any, infer UCurrentContext, any, any, any, any, any> ? UCurrentContext : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterCurrentContexts<T[K]> : never;
+};
+type InferRouterInputs<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterInputs<U> : T extends Procedure<any, any, infer UInputSchema, any, any, any, any> ? SchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterInputs<T[K]> : never;
+};
+type InferRouterOutputs<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterOutputs<U> : T extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput, any, any> ? SchemaOutput<UOutputSchema, UFuncOutput> : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterOutputs<T[K]> : never;
+};
+type AdaptedRouter<TRouter extends AnyRouter, TInitialContext extends Context, TErrorMap extends ErrorMap> = TRouter extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<AdaptedRouter<U, TInitialContext, TErrorMap>> : TRouter extends Procedure<any, infer UCurrentContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, UCurrentContext, UInputSchema, UOutputSchema, UFuncOutput, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
+    [K in keyof TRouter]: TRouter[K] extends AnyRouter ? AdaptedRouter<TRouter[K], TInitialContext, TErrorMap> : never;
+};
+interface AdaptRouterOptions<TErrorMap extends ErrorMap> {
+    middlewares: AnyMiddleware[];
+    tags?: readonly string[];
+    prefix?: HTTPPath;
+    errorMap: TErrorMap;
+}
+declare function adaptRouter<TRouter extends AnyRouter, TInitialContext extends Context, TErrorMap extends ErrorMap>(router: TRouter, options: AdaptRouterOptions<TErrorMap>): AdaptedRouter<TRouter, TInitialContext, TErrorMap>;
+declare function getRouterChild<T extends AnyRouter | Lazy<undefined>>(router: T, ...path: string[]): T extends Lazy<any> ? Lazy<AnyProcedure> | Lazy<Record<string, AnyRouter>> | Lazy<undefined> : AnyRouter | Lazy<undefined> | undefined;
+
+export { type AnyProcedure as A, type ProcedureDef as B, type Context as C, isProcedure as D, createProcedureClient as E, type InferRouterInitialContexts as F, type InferRouterCurrentContexts as G, type InferRouterInputs as H, type InferRouterInitialContext as I, type InferRouterOutputs as J, adaptRouter as K, type Lazy as L, type Middleware as M, getRouterChild as N, type ORPCErrorConstructorMap as O, type ProcedureClientInterceptorOptions as P, type AccessibleLazyRouter as Q, type Router as R, createAccessibleLazyRouter as S, 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 ProcedureHandler as h, type AdaptRouterOptions as i, type AdaptedRouter as j, type AnyMiddleware as k, type Lazyable as l, mergeContext as m, LAZY_LOADER_SYMBOL as n, type LazyMeta as o, type LazyOptions as p, lazy as q, isLazy as r, type MiddlewareResult as s, type MiddlewareNextFnOptions as t, unlazy as u, type MiddlewareNextFn as v, type MiddlewareOutputFn as w, type MiddlewareOptions as x, middlewareOutputFn as y, type ProcedureHandlerOptions as z };

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

@@ -0,0 +1,77 @@
+import { HTTPPath, Schema, Meta, SchemaOutput, ErrorFromErrorMap } from '@orpc/contract';
+import { Interceptor, MaybeOptionalOptions } 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.ptXwNGQr.js';
+import { ORPCError } from '@orpc/client';
+
+type StandardParams = Record<string, string>;
+type StandardMatchResult = {
+    path: string[];
+    procedure: AnyProcedure;
+    params?: StandardParams;
+} | undefined;
+interface StandardMatcher {
+    init(router: AnyRouter): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+}
+
+type StandardHandleOptions<T extends Context> = {
+    prefix?: HTTPPath;
+} & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+type WellStandardHandleOptions<T extends Context> = StandardHandleOptions<T> & {
+    context: T;
+};
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+type StandardHandlerInterceptorOptions<TContext extends Context> = WellStandardHandleOptions<TContext> & {
+    request: StandardLazyRequest;
+};
+interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: Plugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Schema, Record<never, never>, Meta>, SchemaOutput<Schema, unknown>, ErrorFromErrorMap<Record<never, never>>>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly options;
+    private readonly plugin;
+    constructor(router: Router<T, any>, matcher: StandardMatcher, codec: StandardCodec, options?: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: StandardLazyRequest, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<StandardHandleResult>;
+}
+
+interface Plugin<TContext extends Context> {
+    init?(options: StandardHandlerOptions<TContext>): void;
+}
+declare class CompositePlugin<TContext extends Context> implements Plugin<TContext> {
+    private readonly plugins;
+    constructor(plugins?: Plugin<TContext>[]);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { CompositePlugin as C, type Plugin as P, type StandardHandleOptions as S, type WellStandardHandleOptions as W, type StandardHandlerOptions as a, type StandardMatcher as b, type StandardCodec as c, type StandardHandlerInterceptorOptions as d, type StandardParams as e, type StandardMatchResult as f, type StandardHandleResult as g, StandardHandler as h };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.db1f26d",
+  "version": "0.0.0-next.df024bb",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,38 +15,61 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
+    },
+    "./standard": {
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
     "./fetch": {
-      "types": "./dist/src/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
+    },
+    "./hono": {
+      "types": "./dist/adapters/hono/index.d.mts",
+      "import": "./dist/adapters/hono/index.mjs",
+      "default": "./dist/adapters/hono/index.mjs"
+    },
+    "./next": {
+      "types": "./dist/adapters/next/index.d.mts",
+      "import": "./dist/adapters/next/index.mjs",
+      "default": "./dist/adapters/next/index.mjs"
     },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+    "./node": {
+      "types": "./dist/adapters/node/index.d.mts",
+      "import": "./dist/adapters/node/index.mjs",
+      "default": "./dist/adapters/node/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "peerDependencies": {
-    "zod": ">=3.23.0",
-    "@orpc/zod": "0.0.0-next.db1f26d"
+    "hono": ">=4.6.0",
+    "next": ">=14.0.0"
   },
   "dependencies": {
-    "@orpc/contract": "0.0.0-next.db1f26d",
-    "@orpc/shared": "0.0.0-next.db1f26d",
-    "@orpc/transformer": "0.0.0-next.db1f26d"
+    "@orpc/client": "0.0.0-next.df024bb",
+    "@orpc/shared": "0.0.0-next.df024bb",
+    "@orpc/standard-server": "0.0.0-next.df024bb",
+    "@orpc/contract": "0.0.0-next.df024bb",
+    "@orpc/standard-server-fetch": "0.0.0-next.df024bb",
+    "@orpc/standard-server-node": "0.0.0-next.df024bb"
   },
   "devDependencies": {
-    "@orpc/openapi": "0.0.0-next.db1f26d"
+    "light-my-request": "^6.5.1"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/chunk-FL4ZAGNE.js

@@ -1,267 +0,0 @@
-// src/utils.ts
-function mergeContext(a, b) {
-  if (!a)
-    return b;
-  if (!b)
-    return a;
-  return {
-    ...a,
-    ...b
-  };
-}
-
-// src/middleware.ts
-var decoratedMiddlewareSymbol = Symbol("\u{1F512}decoratedMiddleware");
-function decorateMiddleware(middleware) {
-  if (Reflect.get(middleware, decoratedMiddlewareSymbol)) {
-    return middleware;
-  }
-  const concat = (concatMiddleware, mapInput2) => {
-    const concatMiddleware_ = mapInput2 ? decorateMiddleware(concatMiddleware).mapInput(mapInput2) : concatMiddleware;
-    return decorateMiddleware(async (input, context, meta, ...rest) => {
-      const input_ = input;
-      const context_ = context;
-      const meta_ = meta;
-      const next = async (options) => {
-        return concatMiddleware_(input_, mergeContext(context_, options.context), meta_, ...rest);
-      };
-      const m1 = await middleware(input_, context_, {
-        ...meta_,
-        next
-      }, ...rest);
-      return m1;
-    });
-  };
-  const mapInput = (map) => {
-    return decorateMiddleware(
-      (input, ...rest) => middleware(map(input), ...rest)
-    );
-  };
-  return Object.assign(middleware, {
-    [decoratedMiddlewareSymbol]: true,
-    concat,
-    mapInput
-  });
-}
-
-// src/procedure-caller.ts
-import { trim, value } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-import { OpenAPIDeserializer } from "@orpc/transformer";
-
-// src/procedure.ts
-import {
-  DecoratedContractProcedure,
-  isContractProcedure
-} from "@orpc/contract";
-var Procedure = class {
-  constructor(zz$p) {
-    this.zz$p = zz$p;
-  }
-};
-var DECORATED_PROCEDURE_SYMBOL = Symbol("DECORATED_PROCEDURE");
-function decorateProcedure(procedure) {
-  if (DECORATED_PROCEDURE_SYMBOL in procedure) {
-    return procedure;
-  }
-  return Object.assign(createProcedureCaller({
-    procedure,
-    context: void 0
-  }), {
-    [DECORATED_PROCEDURE_SYMBOL]: true,
-    zz$p: procedure.zz$p,
-    prefix(prefix) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract
-          ).prefix(prefix)
-        }
-      });
-    },
-    route(opts) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract
-          ).route(opts)
-        }
-      });
-    },
-    use(middleware, mapInput) {
-      const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          middlewares: [middleware_, ...procedure.zz$p.middlewares ?? []]
-        }
-      });
-    }
-  });
-}
-function isProcedure(item) {
-  if (item instanceof Procedure)
-    return true;
-  return (typeof item === "object" || typeof item === "function") && item !== null && "zz$p" in item && typeof item.zz$p === "object" && item.zz$p !== null && "contract" in item.zz$p && isContractProcedure(item.zz$p.contract) && "func" in item.zz$p && typeof item.zz$p.func === "function";
-}
-
-// src/procedure-caller.ts
-function createProcedureCaller(options) {
-  const loadProcedure = async () => {
-    let procedure;
-    if (isLazy(options.procedure)) {
-      procedure = (await loadLazy(options.procedure)).default;
-    } else {
-      procedure = options.procedure;
-    }
-    if (!isProcedure(procedure)) {
-      throw new ORPCError({
-        code: "NOT_FOUND",
-        message: "Not found",
-        cause: new Error(trim(`
-          This error should be caught by the typescript compiler.
-          But if you still see this error, it means that you trying to call a lazy router (expected to be a lazy procedure).
-        `))
-      });
-    }
-    return procedure;
-  };
-  const caller = async (input) => {
-    const path = options.path ?? [];
-    const procedure = await loadProcedure();
-    const input_ = (() => {
-      if (!(input instanceof FormData)) {
-        return input;
-      }
-      const transformer = new OpenAPIDeserializer({
-        schema: procedure.zz$p.contract.zz$cp.InputSchema
-      });
-      return transformer.deserializeAsFormData(input);
-    })();
-    const validInput = (() => {
-      const schema = procedure.zz$p.contract.zz$cp.InputSchema;
-      if (!schema) {
-        return input_;
-      }
-      try {
-        return schema.parse(input_);
-      } catch (e) {
-        throw new ORPCError({
-          message: "Validation input failed",
-          code: "BAD_REQUEST",
-          cause: e
-        });
-      }
-    })();
-    const middlewares = procedure.zz$p.middlewares ?? [];
-    let currentMidIndex = 0;
-    let currentContext = await value(options.context);
-    const next = async (nextOptions) => {
-      const mid = middlewares[currentMidIndex];
-      currentMidIndex += 1;
-      currentContext = mergeContext(currentContext, nextOptions.context);
-      if (mid) {
-        return await mid(validInput, currentContext, {
-          path,
-          procedure,
-          next,
-          output: (output2) => ({ output: output2, context: void 0 })
-        });
-      } else {
-        return {
-          output: await await procedure.zz$p.func(validInput, currentContext, {
-            path,
-            procedure
-          }),
-          context: currentContext
-        };
-      }
-    };
-    const output = (await next({})).output;
-    const validOutput = await (async () => {
-      const schema = procedure.zz$p.contract.zz$cp.OutputSchema;
-      if (!schema) {
-        return output;
-      }
-      const result = await schema.safeParseAsync(output);
-      if (result.error) {
-        throw new ORPCError({
-          message: "Validation output failed",
-          code: "INTERNAL_SERVER_ERROR",
-          cause: result.error
-        });
-      }
-      return result.data;
-    })();
-    return validOutput;
-  };
-  return caller;
-}
-
-// src/lazy.ts
-var LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
-function createLazy(loader) {
-  return {
-    [LAZY_LOADER_SYMBOL]: loader
-  };
-}
-function loadLazy(lazy) {
-  return lazy[LAZY_LOADER_SYMBOL]();
-}
-function isLazy(item) {
-  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_LOADER_SYMBOL in item && typeof item[LAZY_LOADER_SYMBOL] === "function";
-}
-function createFlattenLazy(lazy) {
-  const flattenLoader = async () => {
-    let current = await loadLazy(lazy);
-    while (true) {
-      if (!isLazy(current.default)) {
-        break;
-      }
-      current = await loadLazy(current.default);
-    }
-    return current;
-  };
-  const flattenLazy = {
-    [LAZY_LOADER_SYMBOL]: flattenLoader
-  };
-  return flattenLazy;
-}
-function decorateLazy(lazy) {
-  const flattenLazy = createFlattenLazy(lazy);
-  const procedureCaller = createProcedureCaller({
-    procedure: flattenLazy,
-    context: void 0
-  });
-  Object.assign(procedureCaller, flattenLazy);
-  const recursive = new Proxy(procedureCaller, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      return decorateLazy(createLazy(async () => {
-        const current = await loadLazy(flattenLazy);
-        return { default: current.default[key] };
-      }));
-    }
-  });
-  return recursive;
-}
-
-export {
-  mergeContext,
-  decorateMiddleware,
-  LAZY_LOADER_SYMBOL,
-  createLazy,
-  loadLazy,
-  isLazy,
-  createFlattenLazy,
-  decorateLazy,
-  createProcedureCaller,
-  Procedure,
-  decorateProcedure,
-  isProcedure
-};
-//# sourceMappingURL=chunk-FL4ZAGNE.js.map