@orpc/server 0.12.0 → 0.14.0

package/dist/chunk-MZXEMHFS.js

@@ -0,0 +1,272 @@
+// 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 { executeWithHooks, trim, value } from "@orpc/shared";
+import { ORPCError } from "@orpc/shared/error";
+
+// 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 caller = async (input) => {
+    const path = options.path ?? [];
+    const procedure = await loadProcedure(options.procedure);
+    const context = await value(options.context);
+    const execute = async () => {
+      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 = 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: (output3) => ({ output: output3, context: void 0 })
+          });
+        } else {
+          return {
+            output: await await procedure.zz$p.func(validInput, currentContext, {
+              path,
+              procedure
+            }),
+            context: currentContext
+          };
+        }
+      };
+      const output2 = (await next({})).output;
+      const validOutput = await (async () => {
+        const schema = procedure.zz$p.contract.zz$cp.OutputSchema;
+        if (!schema) {
+          return output2;
+        }
+        const result = await schema.safeParseAsync(output2);
+        if (result.error) {
+          throw new ORPCError({
+            message: "Validation output failed",
+            code: "INTERNAL_SERVER_ERROR",
+            cause: result.error
+          });
+        }
+        return result.data;
+      })();
+      return validOutput;
+    };
+    const output = await executeWithHooks({
+      hooks: options,
+      input,
+      context,
+      meta: {
+        path,
+        procedure
+      },
+      execute
+    });
+    return output;
+  };
+  return caller;
+}
+async function loadProcedure(procedure) {
+  let loadedProcedure;
+  if (isLazy(procedure)) {
+    loadedProcedure = (await loadLazy(procedure)).default;
+  } else {
+    loadedProcedure = procedure;
+  }
+  if (!isProcedure(loadedProcedure)) {
+    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 loadedProcedure;
+}
+
+// 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,
+  loadProcedure,
+  Procedure,
+  decorateProcedure,
+  isProcedure
+};
+//# sourceMappingURL=chunk-MZXEMHFS.js.map

package/dist/fetch.js

@@ -1,7 +1,8 @@
 import {
   createProcedureCaller,
+  isLazy,
   isProcedure
-} from "./chunk-CVLK2PBB.js";
+} from "./chunk-MZXEMHFS.js";
 
 // src/fetch/handle.ts
 import { ORPCError } from "@orpc/shared/error";
@@ -23,7 +24,7 @@ async function handleFetchRequest(options) {
 
 // src/fetch/handler.ts
 import { ORPC_HEADER, ORPC_HEADER_VALUE } from "@orpc/contract";
-import { trim, value } from "@orpc/shared";
+import { executeWithHooks, trim, value } from "@orpc/shared";
 import { ORPCError as ORPCError2 } from "@orpc/shared/error";
 import { ORPCDeserializer, ORPCSerializer } from "@orpc/transformer";
 var serializer = new ORPCSerializer();
@@ -55,10 +56,13 @@ function createORPCHandler() {
       });
     };
     try {
-      return await options.hooks?.(
+      return await executeWithHooks({
+        hooks: options,
         context,
-        { next: handler, response: (response) => response }
-      ) ?? await handler();
+        execute: handler,
+        input: options.request,
+        meta: void 0
+      });
     } catch (e) {
       const error = e instanceof ORPCError2 ? e : new ORPCError2({
         code: "INTERNAL_SERVER_ERROR",
@@ -77,13 +81,13 @@ function resolveORPCRouter(router, pathname) {
   const path = trim(pathname, "/").split("/").map(decodeURIComponent);
   let current = router;
   for (const segment of path) {
-    if ((typeof current !== "object" || current === null) && typeof current !== "function") {
+    if (typeof current !== "object" && typeof current !== "function" || !current) {
       current = void 0;
       break;
     }
     current = current[segment];
   }
-  return isProcedure(current) ? {
+  return isProcedure(current) || isLazy(current) ? {
     procedure: current,
     path
   } : void 0;
@@ -103,3 +107,4 @@ export {
   createORPCHandler,
   handleFetchRequest
 };
+//# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,11 +1,18 @@
 import {
+  LAZY_LOADER_SYMBOL,
   Procedure,
+  createFlattenLazy,
+  createLazy,
   createProcedureCaller,
+  decorateLazy,
   decorateMiddleware,
   decorateProcedure,
+  isLazy,
   isProcedure,
+  loadLazy,
+  loadProcedure,
   mergeContext
-} from "./chunk-CVLK2PBB.js";
+} from "./chunk-MZXEMHFS.js";
 
 // src/builder.ts
 import {
@@ -15,9 +22,138 @@ import {
 
 // src/procedure-builder.ts
 import {
-  DecoratedContractProcedure
+  DecoratedContractProcedure as DecoratedContractProcedure2
 } from "@orpc/contract";
 
+// src/router-builder.ts
+import { DecoratedContractProcedure, prefixHTTPPath } from "@orpc/contract";
+var LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
+var RouterBuilder = class _RouterBuilder {
+  constructor(zz$rb) {
+    this.zz$rb = zz$rb;
+    if (zz$rb.prefix && zz$rb.prefix.includes("{")) {
+      throw new Error('Prefix cannot contain "{" for dynamic routing');
+    }
+  }
+  prefix(prefix) {
+    return new _RouterBuilder({
+      ...this.zz$rb,
+      prefix: `${this.zz$rb.prefix ?? ""}${prefix}`
+    });
+  }
+  tags(...tags) {
+    if (!tags.length)
+      return this;
+    return new _RouterBuilder({
+      ...this.zz$rb,
+      tags: [...this.zz$rb.tags ?? [], ...tags]
+    });
+  }
+  use(middleware, mapInput) {
+    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+    return new _RouterBuilder({
+      ...this.zz$rb,
+      middlewares: [...this.zz$rb.middlewares || [], middleware_]
+    });
+  }
+  router(router) {
+    const handled = adaptRouter({
+      routerOrChild: router,
+      middlewares: this.zz$rb.middlewares,
+      tags: this.zz$rb.tags,
+      prefix: this.zz$rb.prefix
+    });
+    return handled;
+  }
+  lazy(loader) {
+    const lazy = adaptLazyRouter({
+      current: createLazy(loader),
+      middlewares: this.zz$rb.middlewares,
+      tags: this.zz$rb.tags,
+      prefix: this.zz$rb.prefix
+    });
+    return lazy;
+  }
+};
+function adaptRouter(options) {
+  if (isProcedure(options.routerOrChild)) {
+    return adaptProcedure({
+      ...options,
+      procedure: options.routerOrChild
+    });
+  }
+  if (isLazy(options.routerOrChild)) {
+    return adaptLazyRouter({
+      ...options,
+      current: options.routerOrChild
+    });
+  }
+  const handled = {};
+  for (const key in options.routerOrChild) {
+    handled[key] = adaptRouter({
+      ...options,
+      routerOrChild: options.routerOrChild[key]
+    });
+  }
+  return handled;
+}
+function adaptLazyRouter(options) {
+  const loader = async () => {
+    const current = (await loadLazy(options.current)).default;
+    return {
+      default: adaptRouter({
+        ...options,
+        routerOrChild: current
+      })
+    };
+  };
+  let lazyRouterPrefix = options.prefix;
+  if (LAZY_ROUTER_PREFIX_SYMBOL in options.current && typeof options.current[LAZY_ROUTER_PREFIX_SYMBOL] === "string") {
+    lazyRouterPrefix = lazyRouterPrefix ? prefixHTTPPath(options.current[LAZY_ROUTER_PREFIX_SYMBOL], lazyRouterPrefix) : options.current[LAZY_ROUTER_PREFIX_SYMBOL];
+  }
+  const decoratedLazy = Object.assign(decorateLazy(createLazy(loader)), {
+    [LAZY_ROUTER_PREFIX_SYMBOL]: lazyRouterPrefix
+  });
+  const recursive = new Proxy(decoratedLazy, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      return adaptLazyRouter({
+        ...options,
+        current: createLazy(async () => {
+          const current = (await loadLazy(options.current)).default;
+          return { default: current[key] };
+        })
+      });
+    }
+  });
+  return recursive;
+}
+function adaptProcedure(options) {
+  const builderMiddlewares = options.middlewares ?? [];
+  const procedureMiddlewares = options.procedure.zz$p.middlewares ?? [];
+  const middlewares = [
+    ...builderMiddlewares,
+    ...procedureMiddlewares.filter(
+      (item) => !builderMiddlewares.includes(item)
+    )
+  ];
+  let contract = DecoratedContractProcedure.decorate(
+    options.procedure.zz$p.contract
+  ).addTags(...options.tags ?? []);
+  if (options.prefix) {
+    contract = contract.prefix(options.prefix);
+  }
+  return decorateProcedure({
+    zz$p: {
+      ...options.procedure.zz$p,
+      contract,
+      middlewares
+    }
+  });
+}
+
 // src/procedure-implementer.ts
 var ProcedureImplementer = class _ProcedureImplementer {
   constructor(zz$pi) {
@@ -39,6 +175,9 @@ var ProcedureImplementer = class _ProcedureImplementer {
       }
     });
   }
+  lazy(loader) {
+    return new RouterBuilder(this.zz$pi).lazy(loader);
+  }
 };
 
 // src/procedure-builder.ts
@@ -52,7 +191,7 @@ var ProcedureBuilder = class _ProcedureBuilder {
   route(opts) {
     return new _ProcedureBuilder({
       ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).route(
+      contract: DecoratedContractProcedure2.decorate(this.zz$pb.contract).route(
         opts
       )
     });
@@ -60,7 +199,7 @@ var ProcedureBuilder = class _ProcedureBuilder {
   input(schema, example) {
     return new _ProcedureBuilder({
       ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).input(
+      contract: DecoratedContractProcedure2.decorate(this.zz$pb.contract).input(
         schema,
         example
       )
@@ -69,7 +208,7 @@ var ProcedureBuilder = class _ProcedureBuilder {
   output(schema, example) {
     return new _ProcedureBuilder({
       ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).output(
+      contract: DecoratedContractProcedure2.decorate(this.zz$pb.contract).output(
         schema,
         example
       )
@@ -101,75 +240,24 @@ var ProcedureBuilder = class _ProcedureBuilder {
   }
 };
 
-// src/router-builder.ts
-import { DecoratedContractProcedure as DecoratedContractProcedure2 } from "@orpc/contract";
-var RouterBuilder = class _RouterBuilder {
-  constructor(zz$rb) {
-    this.zz$rb = zz$rb;
-  }
-  prefix(prefix) {
-    return new _RouterBuilder({
-      ...this.zz$rb,
-      prefix: `${this.zz$rb.prefix ?? ""}${prefix}`
-    });
-  }
-  tags(...tags) {
-    if (!tags.length)
-      return this;
-    return new _RouterBuilder({
-      ...this.zz$rb,
-      tags: [...this.zz$rb.tags ?? [], ...tags]
-    });
-  }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _RouterBuilder({
-      ...this.zz$rb,
-      middlewares: [...this.zz$rb.middlewares || [], middleware_]
-    });
-  }
-  router(router) {
-    const handled = {};
-    for (const key in router) {
-      const item = router[key];
-      if (isProcedure(item)) {
-        const builderMiddlewares = this.zz$rb.middlewares ?? [];
-        const itemMiddlewares = item.zz$p.middlewares ?? [];
-        const middlewares = [
-          ...builderMiddlewares,
-          ...itemMiddlewares.filter(
-            (item2) => !builderMiddlewares.includes(item2)
-          )
-        ];
-        const contract = DecoratedContractProcedure2.decorate(
-          item.zz$p.contract
-        ).addTags(...this.zz$rb.tags ?? []);
-        handled[key] = decorateProcedure({
-          zz$p: {
-            ...item.zz$p,
-            contract: this.zz$rb.prefix ? contract.prefix(this.zz$rb.prefix) : contract,
-            middlewares
-          }
-        });
-      } else {
-        handled[key] = this.router(item);
-      }
-    }
-    return handled;
-  }
-};
-
 // src/router-implementer.ts
-import {
-  isContractProcedure
-} from "@orpc/contract";
+import { isContractProcedure } from "@orpc/contract";
+var ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_ROUTER_CONTRACT");
 var RouterImplementer = class {
   constructor(zz$ri) {
     this.zz$ri = zz$ri;
   }
   router(router) {
-    assertRouterImplementation(this.zz$ri.contract, router);
-    return router;
+    return Object.assign(new RouterBuilder({}).router(router), {
+      [ROUTER_CONTRACT_SYMBOL]: this.zz$ri.contract
+    });
+  }
+  lazy(loader) {
+    const lazy = createLazy(loader);
+    const decorated = decorateLazy(lazy);
+    return Object.assign(decorated, {
+      [ROUTER_CONTRACT_SYMBOL]: this.zz$ri.contract
+    });
   }
 };
 function chainRouterImplementer(contract, middlewares) {
@@ -188,37 +276,6 @@ function chainRouterImplementer(contract, middlewares) {
   const implementer = new RouterImplementer({ contract });
   return Object.assign(implementer, result);
 }
-function assertRouterImplementation(contract, router, path = []) {
-  for (const key in contract) {
-    const currentPath = [...path, key];
-    const contractItem = contract[key];
-    const routerItem = router[key];
-    if (!routerItem) {
-      throw new Error(
-        `Missing implementation for procedure at [${currentPath.join(".")}]`
-      );
-    }
-    if (isContractProcedure(contractItem)) {
-      if (isProcedure(routerItem)) {
-        if (routerItem.zz$p.contract !== contractItem) {
-          throw new Error(
-            `Mismatch implementation for procedure at [${currentPath.join(".")}]`
-          );
-        }
-      } else {
-        throw new Error(
-          `Mismatch implementation for procedure at [${currentPath.join(".")}]`
-        );
-      }
-    } else {
-      assertRouterImplementation(
-        contractItem,
-        routerItem,
-        currentPath
-      );
-    }
-  }
-}
 
 // src/builder.ts
 var Builder = class _Builder {
@@ -327,6 +384,9 @@ var Builder = class _Builder {
   router(router) {
     return new RouterBuilder(this.zz$b).router(router);
   }
+  lazy(loader) {
+    return new RouterBuilder(this.zz$b).lazy(loader);
+  }
 };
 
 // src/router.ts
@@ -350,25 +410,29 @@ function toContractRouter(router) {
 
 // src/router-caller.ts
 function createRouterCaller(options) {
-  const caller = {};
-  for (const key in options.router) {
-    const path = [...options.basePath ?? [], key];
-    const item = options.router[key];
-    if (isProcedure(item)) {
-      caller[key] = createProcedureCaller({
-        procedure: item,
-        context: options.context,
-        path
-      });
-    } else {
-      caller[key] = createRouterCaller({
-        router: item,
-        context: options.context,
-        basePath: path
+  return createRouterCallerInternal(options);
+}
+function createRouterCallerInternal(options) {
+  const procedureCaller = isLazy(options.router) || isProcedure(options.router) ? createProcedureCaller({
+    ...options,
+    procedure: options.router,
+    context: options.context,
+    path: options.basePath
+  }) : {};
+  const recursive = new Proxy(procedureCaller, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      const next = options.router[key];
+      return createRouterCallerInternal({
+        ...options,
+        router: next,
+        basePath: [...options.basePath ?? [], key]
       });
     }
-  }
-  return caller;
+  });
+  return recursive;
 }
 
 // src/index.ts
@@ -376,18 +440,28 @@ export * from "@orpc/shared/error";
 var os = new Builder();
 export {
   Builder,
+  LAZY_LOADER_SYMBOL,
+  LAZY_ROUTER_PREFIX_SYMBOL,
   Procedure,
   ProcedureBuilder,
   ProcedureImplementer,
+  ROUTER_CONTRACT_SYMBOL,
+  RouterBuilder,
   RouterImplementer,
-  assertRouterImplementation,
   chainRouterImplementer,
+  createFlattenLazy,
+  createLazy,
   createProcedureCaller,
   createRouterCaller,
+  decorateLazy,
   decorateMiddleware,
   decorateProcedure,
+  isLazy,
   isProcedure,
+  loadLazy,
+  loadProcedure,
   mergeContext,
   os,
   toContractRouter
 };
+//# sourceMappingURL=index.js.map

package/dist/src/builder.d.ts

@@ -1,9 +1,10 @@
 import type { IsEqual } from '@orpc/shared';
+import type { DecoratedLazy } from './lazy';
+import type { DecoratedProcedure, Procedure, ProcedureFunc } from './procedure';
 import type { HandledRouter, Router } from './router';
 import type { Context, MergeContext } from './types';
 import { ContractProcedure, type ContractRouter, type HTTPPath, type RouteOptions, type Schema, type SchemaInput, type SchemaOutput } from '@orpc/contract';
 import { type DecoratedMiddleware, type MapInputMiddleware, type Middleware } from './middleware';
-import { type DecoratedProcedure, type ProcedureFunc } from './procedure';
 import { ProcedureBuilder } from './procedure-builder';
 import { ProcedureImplementer } from './procedure-implementer';
 import { RouterBuilder } from './router-builder';
@@ -45,4 +46,8 @@ export declare class Builder<TContext extends Context, TExtraContext extends Con
      * Create DecoratedRouter
      */
     router<URouter extends Router<TContext>>(router: URouter): HandledRouter<URouter>;
+    lazy<U extends Router<TContext> | Procedure<TContext, any, any, any, any>>(loader: () => Promise<{
+        default: U;
+    }>): DecoratedLazy<U>;
 }
+//# sourceMappingURL=builder.d.ts.map

package/dist/src/fetch/handle.d.ts

@@ -4,3 +4,4 @@ export type HandleFetchRequestOptions<TRouter extends Router<any>> = FetchHandle
     handlers: readonly [FetchHandler, ...FetchHandler[]];
 };
 export declare function handleFetchRequest<TRouter extends Router<any>>(options: HandleFetchRequestOptions<TRouter>): Promise<Response>;
+//# sourceMappingURL=handle.d.ts.map

package/dist/src/fetch/handler.d.ts

@@ -1,2 +1,3 @@
 import type { FetchHandler } from './types';
 export declare function createORPCHandler(): FetchHandler;
+//# sourceMappingURL=handler.d.ts.map

package/dist/src/fetch/index.d.ts

@@ -1,3 +1,4 @@
 export * from './handle';
 export * from './handler';
 export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/fetch/types.d.ts

@@ -1,9 +1,5 @@
-import type { PartialOnUndefinedDeep, Promisable, Value } from '@orpc/shared';
+import type { Hooks, PartialOnUndefinedDeep, Value } from '@orpc/shared';
 import type { Router } from '../router';
-export interface FetchHandlerHooks {
-    next: () => Promise<Response>;
-    response: (response: Response) => Response;
-}
 export type FetchHandlerOptions<TRouter extends Router<any>> = {
     /**
      * The `router` used for handling the request and routing,
@@ -21,14 +17,11 @@ export type FetchHandlerOptions<TRouter extends Router<any>> = {
      * @example /api
      */
     prefix?: string;
-    /**
-     * Hooks for executing logics on lifecycle events.
-     */
-    hooks?: (context: TRouter extends Router<infer UContext> ? UContext : never, hooks: FetchHandlerHooks) => Promisable<Response>;
 } & PartialOnUndefinedDeep<{
     /**
      * The context used to handle the request.
      */
     context: Value<TRouter extends Router<infer UContext> ? UContext : never>;
-}>;
+}> & Hooks<Request, Response, TRouter extends Router<infer UContext> ? UContext : never, undefined>;
 export type FetchHandler = <TRouter extends Router<any>>(options: FetchHandlerOptions<TRouter>) => Promise<Response | undefined>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/index.d.ts

@@ -1,14 +1,17 @@
 import { Builder } from './builder';
 export * from './builder';
+export * from './lazy';
 export * from './middleware';
 export * from './procedure';
 export * from './procedure-builder';
 export * from './procedure-caller';
 export * from './procedure-implementer';
 export * from './router';
+export * from './router-builder';
 export * from './router-caller';
 export * from './router-implementer';
 export * from './types';
 export * from './utils';
 export * from '@orpc/shared/error';
 export declare const os: Builder<Record<string, unknown> | undefined, undefined>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lazy.d.ts

@@ -0,0 +1,23 @@
+import type { Procedure } from './procedure';
+import type { ProcedureCaller } from './procedure-caller';
+export declare const LAZY_LOADER_SYMBOL: unique symbol;
+export interface Lazy<T> {
+    [LAZY_LOADER_SYMBOL]: () => Promise<{
+        default: T;
+    }>;
+}
+export type ANY_LAZY = Lazy<any>;
+export declare function createLazy<T>(loader: () => Promise<{
+    default: T;
+}>): Lazy<T>;
+export declare function loadLazy<T>(lazy: Lazy<T>): Promise<{
+    default: T;
+}>;
+export declare function isLazy(item: unknown): item is ANY_LAZY;
+export type FlattenLazy<T> = T extends Lazy<infer U> ? FlattenLazy<U> : Lazy<T>;
+export declare function createFlattenLazy<T>(lazy: Lazy<T>): FlattenLazy<T>;
+export type DecoratedLazy<T> = T extends Lazy<infer U> ? DecoratedLazy<U> : (T extends Procedure<infer UContext, any, any, any, any> ? Lazy<T> & (undefined extends UContext ? ProcedureCaller<T> : unknown) : T extends Record<any, any> ? {
+    [K in keyof T]: DecoratedLazy<T[K]>;
+} /** Notice: this still a lazy, but type not work when I & Lazy<T>, maybe it's a bug, should improve */ : Lazy<T>);
+export declare function decorateLazy<T>(lazy: Lazy<T>): DecoratedLazy<T>;
+//# sourceMappingURL=lazy.d.ts.map

package/dist/src/middleware.d.ts

@@ -23,3 +23,4 @@ export interface DecoratedMiddleware<TContext extends Context, TExtraContext ext
     mapInput: <UInput = unknown>(map: MapInputMiddleware<UInput, TInput>) => DecoratedMiddleware<TContext, TExtraContext, UInput, TOutput>;
 }
 export declare function decorateMiddleware<TContext extends Context, TExtraContext extends Context, TInput, TOutput>(middleware: Middleware<TContext, TExtraContext, TInput, TOutput>): DecoratedMiddleware<TContext, TExtraContext, TInput, TOutput>;
+//# sourceMappingURL=middleware.d.ts.map

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

@@ -28,3 +28,4 @@ export declare class ProcedureBuilder<TContext extends Context, TExtraContext ex
      */
     func<UFuncOutput extends SchemaOutput<TOutputSchema>>(func: ProcedureFunc<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>;
 }
+//# sourceMappingURL=procedure-builder.d.ts.map

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

@@ -1,18 +1,25 @@
 import type { SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { Procedure } from './procedure';
-import { type Value } from '@orpc/shared';
-export interface CreateProcedureCallerOptions<TProcedure extends Procedure<any, any, any, any, any>> {
-    procedure: TProcedure;
-    /**
-     * The context used when calling the procedure.
-     */
-    context: Value<TProcedure extends Procedure<infer UContext, any, any, any, any> ? UContext : never>;
+import type { Hooks, PartialOnUndefinedDeep, Value } from '@orpc/shared';
+import type { Lazy } from './lazy';
+import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE, Procedure } from './procedure';
+export type CreateProcedureCallerOptions<T extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> = T extends Procedure<infer UContext, any, any, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<infer UContext, any, any, infer UOutputSchema, infer UFuncOutput>> ? {
+    procedure: T;
     /**
      * This is helpful for logging and analytics.
      *
      * @internal
      */
     path?: string[];
-}
-export type ProcedureCaller<TProcedure extends Procedure<any, any, any, any, any>> = TProcedure extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? (...input: [input: SchemaInput<UInputSchema> | FormData] | (undefined extends SchemaInput<UInputSchema> ? [] : never)) => Promise<SchemaOutput<UOutputSchema, UFuncOutput>> : never;
-export declare function createProcedureCaller<TProcedure extends Procedure<any, any, any, any, any>>(options: CreateProcedureCallerOptions<TProcedure>): ProcedureCaller<TProcedure>;
+} & PartialOnUndefinedDeep<{
+    /**
+     * The context used when calling the procedure.
+     */
+    context: Value<UContext>;
+}> & Hooks<unknown, SchemaOutput<UOutputSchema, UFuncOutput>, UContext, {
+    path: string[];
+    procedure: ANY_PROCEDURE;
+}> : never;
+export type ProcedureCaller<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> = TProcedure extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput>> ? (...input: [input: SchemaInput<UInputSchema>] | (undefined extends SchemaInput<UInputSchema> ? [] : never)) => Promise<SchemaOutput<UOutputSchema, UFuncOutput>> : never;
+export declare function createProcedureCaller<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE>(options: CreateProcedureCallerOptions<TProcedure>): ProcedureCaller<TProcedure>;
+export declare function loadProcedure(procedure: ANY_PROCEDURE | ANY_LAZY_PROCEDURE): Promise<ANY_PROCEDURE>;
+//# sourceMappingURL=procedure-caller.d.ts.map

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

@@ -1,7 +1,8 @@
 import type { ContractProcedure, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { DecoratedLazy } from './lazy';
+import type { DecoratedProcedure, Procedure, ProcedureFunc } from './procedure';
 import type { Context, MergeContext } from './types';
 import { type MapInputMiddleware, type Middleware } from './middleware';
-import { type DecoratedProcedure, type ProcedureFunc } from './procedure';
 export declare class ProcedureImplementer<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema> {
     zz$pi: {
         contract: ContractProcedure<TInputSchema, TOutputSchema>;
@@ -14,4 +15,8 @@ export declare class ProcedureImplementer<TContext extends Context, TExtraContex
     use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>>): ProcedureImplementer<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema>;
     use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UMappedInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UMappedInput, SchemaInput<TOutputSchema>>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema>, UMappedInput>): ProcedureImplementer<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema>;
     func<UFuncOutput extends SchemaOutput<TOutputSchema>>(func: ProcedureFunc<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>;
+    lazy<U extends Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, SchemaOutput<TOutputSchema>>>(loader: () => Promise<{
+        default: U;
+    }>): DecoratedLazy<U>;
 }
+//# sourceMappingURL=procedure-implementer.d.ts.map

package/dist/src/procedure.d.ts

@@ -1,4 +1,5 @@
 import type { Promisable } from '@orpc/shared';
+import type { Lazy } from './lazy';
 import type { ProcedureCaller } from './procedure-caller';
 import type { Context, MergeContext, Meta } from './types';
 import { type ContractProcedure, type HTTPPath, type RouteOptions, type Schema, type SchemaInput, type SchemaOutput } from '@orpc/contract';
@@ -15,6 +16,9 @@ export declare class Procedure<TContext extends Context, TExtraContext extends C
         func: ProcedureFunc<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>;
     });
 }
+export type ANY_PROCEDURE = Procedure<any, any, any, any, any>;
+export type WELL_DEFINED_PROCEDURE = Procedure<Context, Context, Schema, Schema, unknown>;
+export type ANY_LAZY_PROCEDURE = Lazy<ANY_PROCEDURE>;
 export type DecoratedProcedure<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>> = Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput> & {
     prefix: (prefix: HTTPPath) => DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>;
     route: (opts: RouteOptions) => DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>;
@@ -24,5 +28,5 @@ export interface ProcedureFunc<TContext extends Context, TExtraContext extends C
     (input: SchemaOutput<TInputSchema>, context: MergeContext<TContext, TExtraContext>, meta: Meta): Promisable<SchemaInput<TOutputSchema, TOutput>>;
 }
 export declare function decorateProcedure<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>>(procedure: Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>;
-export type WELL_DEFINED_PROCEDURE = Procedure<Context, Context, Schema, Schema, unknown>;
-export declare function isProcedure(item: unknown): item is WELL_DEFINED_PROCEDURE;
+export declare function isProcedure(item: unknown): item is ANY_PROCEDURE;
+//# sourceMappingURL=procedure.d.ts.map

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

@@ -1,7 +1,9 @@
+import type { DecoratedLazy } from './lazy';
 import type { HandledRouter, Router } from './router';
 import type { Context, MergeContext } from './types';
 import { type HTTPPath } from '@orpc/contract';
 import { type MapInputMiddleware, type Middleware } from './middleware';
+export declare const LAZY_ROUTER_PREFIX_SYMBOL: unique symbol;
 export declare class RouterBuilder<TContext extends Context, TExtraContext extends Context> {
     zz$rb: {
         prefix?: HTTPPath;
@@ -18,4 +20,8 @@ export declare class RouterBuilder<TContext extends Context, TExtraContext exten
     use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, unknown, unknown>): RouterBuilder<TContext, MergeContext<TExtraContext, UExtraContext>>;
     use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UMappedInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UMappedInput, unknown>, mapInput: MapInputMiddleware<unknown, UMappedInput>): RouterBuilder<TContext, MergeContext<TExtraContext, UExtraContext>>;
     router<URouter extends Router<TContext>>(router: URouter): HandledRouter<URouter>;
+    lazy<U extends Router<TContext>>(loader: () => Promise<{
+        default: U;
+    }>): DecoratedLazy<U>;
 }
+//# sourceMappingURL=router-builder.d.ts.map

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

@@ -1,8 +1,11 @@
-import type { Value } from '@orpc/shared';
+import type { Hooks, Value } from '@orpc/shared';
+import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE } from './procedure';
 import type { Router } from './router';
-import { type Procedure } from './procedure';
 import { type ProcedureCaller } from './procedure-caller';
-export interface CreateRouterCallerOptions<TRouter extends Router<any>> {
+export interface CreateRouterCallerOptions<TRouter extends Router<any>> extends Hooks<unknown, unknown, TRouter extends Router<infer UContext> ? UContext : never, {
+    path: string[];
+    procedure: ANY_PROCEDURE;
+}> {
     router: TRouter;
     /**
      * The context used when calling the procedure.
@@ -16,6 +19,7 @@ export interface CreateRouterCallerOptions<TRouter extends Router<any>> {
     basePath?: string[];
 }
 export type RouterCaller<TRouter extends Router<any>> = {
-    [K in keyof TRouter]: TRouter[K] extends Procedure<any, any, any, any, any> ? ProcedureCaller<TRouter[K]> : TRouter[K] extends Router<any> ? RouterCaller<TRouter[K]> : never;
+    [K in keyof TRouter]: TRouter[K] extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE ? ProcedureCaller<TRouter[K]> : TRouter[K] extends Router<any> ? RouterCaller<TRouter[K]> : never;
 };
 export declare function createRouterCaller<TRouter extends Router<any>>(options: CreateRouterCallerOptions<TRouter>): RouterCaller<TRouter>;
+//# sourceMappingURL=router-caller.d.ts.map

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

@@ -1,8 +1,10 @@
+import type { DecoratedLazy } from './lazy';
 import type { Middleware } from './middleware';
-import type { RouterWithContract } from './router';
+import type { HandledRouter, RouterWithContract } from './router';
 import type { Context } from './types';
 import { type ContractProcedure, type ContractRouter } from '@orpc/contract';
 import { ProcedureImplementer } from './procedure-implementer';
+export declare const ROUTER_CONTRACT_SYMBOL: unique symbol;
 export declare class RouterImplementer<TContext extends Context, TContract extends ContractRouter> {
     zz$ri: {
         contract: TContract;
@@ -10,10 +12,13 @@ export declare class RouterImplementer<TContext extends Context, TContract exten
     constructor(zz$ri: {
         contract: TContract;
     });
-    router(router: RouterWithContract<TContext, TContract>): RouterWithContract<TContext, TContract>;
+    router(router: RouterWithContract<TContext, TContract>): HandledRouter<RouterWithContract<TContext, TContract>>;
+    lazy(loader: () => Promise<{
+        default: RouterWithContract<TContext, TContract>;
+    }>): DecoratedLazy<RouterWithContract<TContext, TContract>>;
 }
 export type ChainedRouterImplementer<TContext extends Context, TContract extends ContractRouter, TExtraContext extends Context> = {
     [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema> : TContract[K] extends ContractRouter ? ChainedRouterImplementer<TContext, TContract[K], TExtraContext> : never;
 } & RouterImplementer<TContext, TContract>;
 export declare function chainRouterImplementer<TContext extends Context, TContract extends ContractRouter, TExtraContext extends Context>(contract: TContract, middlewares?: Middleware<any, any, any, any>[]): ChainedRouterImplementer<TContext, TContract, TExtraContext>;
-export declare function assertRouterImplementation(contract: ContractRouter, router: RouterWithContract<any, any>, path?: string[]): void;
+//# sourceMappingURL=router-implementer.d.ts.map

package/dist/src/router.d.ts

@@ -1,19 +1,21 @@
 import type { ContractProcedure, ContractRouter, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ANY_LAZY, DecoratedLazy, Lazy } from './lazy';
 import type { Context } from './types';
 import { type DecoratedProcedure, type Procedure } from './procedure';
 export interface Router<TContext extends Context> {
-    [k: string]: Procedure<TContext, any, any, any, any> | Router<TContext>;
+    [k: string]: Procedure<TContext, any, any, any, any> | Lazy<Procedure<TContext, any, any, any, any>> | Router<TContext> | Lazy<Router<TContext>>;
 }
 export type HandledRouter<TRouter extends Router<any>> = {
-    [K in keyof TRouter]: TRouter[K] extends Procedure<infer UContext, infer UExtraContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? DecoratedProcedure<UContext, UExtraContext, UInputSchema, UOutputSchema, UFuncOutput> : TRouter[K] extends Router<any> ? HandledRouter<TRouter[K]> : never;
+    [K in keyof TRouter]: TRouter[K] extends Procedure<infer UContext, infer UExtraContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? DecoratedProcedure<UContext, UExtraContext, UInputSchema, UOutputSchema, UFuncOutput> : TRouter[K] extends ANY_LAZY ? DecoratedLazy<TRouter[K]> : TRouter[K] extends Router<any> ? HandledRouter<TRouter[K]> : never;
 };
 export type RouterWithContract<TContext extends Context, TContract extends ContractRouter> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? Procedure<TContext, any, UInputSchema, UOutputSchema, any> : TContract[K] extends ContractRouter ? RouterWithContract<TContext, TContract[K]> : never;
+    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? Procedure<TContext, any, UInputSchema, UOutputSchema, any> | Lazy<Procedure<TContext, any, UInputSchema, UOutputSchema, any>> : TContract[K] extends ContractRouter ? RouterWithContract<TContext, TContract[K]> | Lazy<RouterWithContract<TContext, TContract[K]>> : never;
 };
 export declare function toContractRouter(router: ContractRouter | Router<any>): ContractRouter;
 export type InferRouterInputs<T extends Router<any>> = {
-    [K in keyof T]: T[K] extends Procedure<any, any, infer UInputSchema, any, any> ? SchemaInput<UInputSchema> : T[K] extends Router<any> ? InferRouterInputs<T[K]> : never;
+    [K in keyof T]: T[K] extends Procedure<any, any, infer UInputSchema, any, any> | Lazy<Procedure<any, any, infer UInputSchema, any, any>> ? SchemaInput<UInputSchema> : T[K] extends Router<any> ? InferRouterInputs<T[K]> : never;
 };
 export type InferRouterOutputs<T extends Router<any>> = {
-    [K in keyof T]: T[K] extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput> ? SchemaOutput<UOutputSchema, UFuncOutput> : T[K] extends Router<any> ? InferRouterOutputs<T[K]> : never;
+    [K in keyof T]: T[K] extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput>> ? SchemaOutput<UOutputSchema, UFuncOutput> : T[K] extends Router<any> ? InferRouterOutputs<T[K]> : never;
 };
+//# sourceMappingURL=router.d.ts.map

package/dist/src/types.d.ts

@@ -5,3 +5,4 @@ export interface Meta {
     path: string[];
     procedure: WELL_DEFINED_PROCEDURE;
 }
+//# sourceMappingURL=types.d.ts.map

package/dist/src/utils.d.ts

@@ -1,2 +1,3 @@
 import type { Context, MergeContext } from './types';
 export declare function mergeContext<A extends Context, B extends Context>(a: A, b: B): MergeContext<A, B>;
+//# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -29,23 +29,24 @@
     }
   },
   "files": [
-    "!dist/*.tsbuildinfo",
+    "!**/*.map",
+    "!**/*.tsbuildinfo",
     "dist"
   ],
   "peerDependencies": {
     "zod": ">=3.23.0",
-    "@orpc/zod": "0.12.0"
+    "@orpc/zod": "0.14.0"
   },
   "dependencies": {
-    "@orpc/contract": "0.12.0",
-    "@orpc/transformer": "0.12.0",
-    "@orpc/shared": "0.12.0"
+    "@orpc/shared": "0.14.0",
+    "@orpc/transformer": "0.14.0",
+    "@orpc/contract": "0.14.0"
   },
   "devDependencies": {
-    "@orpc/openapi": "0.12.0"
+    "@orpc/openapi": "0.14.0"
   },
   "scripts": {
-    "build": "tsup --clean --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/chunk-CVLK2PBB.js

@@ -1,189 +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 { value } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-import { OpenAPIDeserializer } from "@orpc/transformer";
-function createProcedureCaller(options) {
-  const path = options.path ?? [];
-  const procedure = options.procedure;
-  const caller = async (input) => {
-    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/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";
-}
-
-export {
-  mergeContext,
-  decorateMiddleware,
-  createProcedureCaller,
-  Procedure,
-  decorateProcedure,
-  isProcedure
-};