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

package/dist/{chunk-TDFYNRZV.js → chunk-FL4ZAGNE.js}

@@ -45,13 +45,92 @@ function decorateMiddleware(middleware) {
 }
 
 // src/procedure-caller.ts
-import { value } from "@orpc/shared";
+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 path = options.path ?? [];
-  const procedure = options.procedure;
+  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;
@@ -121,70 +200,68 @@ function createProcedureCaller(options) {
   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,
+// 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
-  }), {
-    [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 ?? []]
-        }
-      });
+  });
+  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] };
+      }));
     }
   });
-}
-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";
+  return recursive;
 }
 
 export {
   mergeContext,
   decorateMiddleware,
+  LAZY_LOADER_SYMBOL,
+  createLazy,
+  loadLazy,
+  isLazy,
+  createFlattenLazy,
+  decorateLazy,
   createProcedureCaller,
   Procedure,
   decorateProcedure,
   isProcedure
 };
-//# sourceMappingURL=chunk-TDFYNRZV.js.map
+//# sourceMappingURL=chunk-FL4ZAGNE.js.map

package/dist/fetch.js

@@ -1,7 +1,8 @@
 import {
   createProcedureCaller,
+  isLazy,
   isProcedure
-} from "./chunk-TDFYNRZV.js";
+} from "./chunk-FL4ZAGNE.js";
 
 // src/fetch/handle.ts
 import { ORPCError } from "@orpc/shared/error";
@@ -77,13 +78,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;

package/dist/index.js

@@ -1,11 +1,17 @@
 import {
+  LAZY_LOADER_SYMBOL,
   Procedure,
+  createFlattenLazy,
+  createLazy,
   createProcedureCaller,
+  decorateLazy,
   decorateMiddleware,
   decorateProcedure,
+  isLazy,
   isProcedure,
+  loadLazy,
   mergeContext
-} from "./chunk-TDFYNRZV.js";
+} from "./chunk-FL4ZAGNE.js";
 
 // src/builder.ts
 import {
@@ -15,9 +21,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 +174,9 @@ var ProcedureImplementer = class _ProcedureImplementer {
       }
     });
   }
+  lazy(loader) {
+    return new RouterBuilder(this.zz$pi).lazy(loader);
+  }
 };
 
 // src/procedure-builder.ts
@@ -52,7 +190,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 +198,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 +207,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 +239,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 +275,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 +383,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 +409,32 @@ 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,
+  return createRouterCallerInternal({
+    current: options.router,
+    context: options.context,
+    path: options.basePath ?? []
+  });
+}
+function createRouterCallerInternal(options) {
+  const procedureCaller = isLazy(options.current) || isProcedure(options.current) ? createProcedureCaller({
+    procedure: options.current,
+    context: options.context,
+    path: options.path
+  }) : {};
+  const recursive = new Proxy(procedureCaller, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      const next = options.current[key];
+      return createRouterCallerInternal({
+        current: next,
         context: options.context,
-        basePath: path
+        path: [...options.path, key]
       });
     }
-  }
-  return caller;
+  });
+  return recursive;
 }
 
 // src/index.ts
@@ -376,17 +442,25 @@ 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,
   mergeContext,
   os,
   toContractRouter

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,5 +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/index.d.ts

@@ -1,11 +1,13 @@
 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';

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/procedure-caller.d.ts

@@ -1,12 +1,13 @@
 import type { SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { Procedure } from './procedure';
+import type { Lazy } from './lazy';
 import { type Value } from '@orpc/shared';
-export interface CreateProcedureCallerOptions<TProcedure extends Procedure<any, any, any, any, any>> {
+import { type ANY_LAZY_PROCEDURE, type ANY_PROCEDURE, type Procedure } from './procedure';
+export interface CreateProcedureCallerOptions<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> {
     procedure: TProcedure;
     /**
      * The context used when calling the procedure.
      */
-    context: Value<TProcedure extends Procedure<infer UContext, any, any, any, any> ? UContext : never>;
+    context: Value<TProcedure extends Procedure<infer UContext, any, any, any, any> | Lazy<Procedure<infer UContext, any, any, any, any>> ? UContext : never>;
     /**
      * This is helpful for logging and analytics.
      *
@@ -14,6 +15,6 @@ export interface CreateProcedureCallerOptions<TProcedure extends Procedure<any,
      */
     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>;
+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> | FormData] | (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>;
 //# 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,5 +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,6 +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,5 +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,6 +1,6 @@
 import type { 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>> {
     router: TRouter;
@@ -16,7 +16,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,11 +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,14 +1,15 @@
 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>> = {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.c59d67c",
+  "version": "0.0.0-next.db1f26d",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -35,15 +35,15 @@
   ],
   "peerDependencies": {
     "zod": ">=3.23.0",
-    "@orpc/zod": "0.0.0-next.c59d67c"
+    "@orpc/zod": "0.0.0-next.db1f26d"
   },
   "dependencies": {
-    "@orpc/contract": "0.0.0-next.c59d67c",
-    "@orpc/shared": "0.0.0-next.c59d67c",
-    "@orpc/transformer": "0.0.0-next.c59d67c"
+    "@orpc/contract": "0.0.0-next.db1f26d",
+    "@orpc/shared": "0.0.0-next.db1f26d",
+    "@orpc/transformer": "0.0.0-next.db1f26d"
   },
   "devDependencies": {
-    "@orpc/openapi": "0.0.0-next.c59d67c"
+    "@orpc/openapi": "0.0.0-next.db1f26d"
   },
   "scripts": {
     "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",