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

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/fetch/handle.d.ts

@@ -0,0 +1,7 @@
+import type { Router } from '../router';
+import type { FetchHandler, FetchHandlerOptions } from './types';
+export type HandleFetchRequestOptions<TRouter extends Router<any>> = FetchHandlerOptions<TRouter> & {
+    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

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

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

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

package/dist/src/{adapters/fetch.d.ts → fetch/types.d.ts}

@@ -4,21 +4,12 @@ export interface FetchHandlerHooks {
     next: () => Promise<Response>;
     response: (response: Response) => Response;
 }
-export interface CreateFetchHandlerOptions<TRouter extends Router<any>> {
-    router: TRouter;
-    /**
-     * Hooks for executing logics on lifecycle events.
-     */
-    hooks?: (context: TRouter extends Router<infer UContext> ? UContext : never, hooks: FetchHandlerHooks) => Promisable<Response>;
+export type FetchHandlerOptions<TRouter extends Router<any>> = {
     /**
-     * It will help improve the cold start time. But it will increase the performance.
+     * The `router` used for handling the request and routing,
      *
-     * @default false
      */
-    serverless?: boolean;
-}
-export declare function createFetchHandler<TRouter extends Router<any>>(options: CreateFetchHandlerOptions<TRouter>): FetchHandler<TRouter>;
-export type FetchHandlerOptions<TRouter extends Router<any>> = {
+    router: TRouter;
     /**
      * The request need to be handled.
      */
@@ -30,13 +21,15 @@ 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>;
 }>;
-export interface FetchHandler<TRouter extends Router<any>> {
-    (options: FetchHandlerOptions<TRouter>): Promise<Response>;
-}
-//# sourceMappingURL=fetch.d.ts.map
+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,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