@orpc/server 0.0.0-next.d137cdf → 0.0.0-next.e361acd

package/dist/index.js

@@ -1,308 +1,396 @@
 import {
   LAZY_LOADER_SYMBOL,
   Procedure,
-  createFlattenLazy,
-  createLazy,
-  createProcedureCaller,
-  decorateLazy,
-  decorateMiddleware,
-  decorateProcedure,
+  createProcedureClient,
+  flatLazy,
+  getRouterChild,
   isLazy,
   isProcedure,
-  loadLazy,
-  loadProcedure,
-  mergeContext
-} from "./chunk-MZXEMHFS.js";
+  lazy,
+  mergeContext,
+  unlazy
+} from "./chunk-FN62GL22.js";
 
 // src/builder.ts
-import {
-  ContractProcedure,
-  isContractProcedure as isContractProcedure2
-} from "@orpc/contract";
+import { ContractProcedure } from "@orpc/contract";
 
-// src/procedure-builder.ts
-import {
-  DecoratedContractProcedure as DecoratedContractProcedure2
-} from "@orpc/contract";
+// src/implementer-chainable.ts
+import { isContractProcedure } from "@orpc/contract";
+import { createCallableObject } from "@orpc/shared";
 
-// src/router-builder.ts
-import { DecoratedContractProcedure, prefixHTTPPath } from "@orpc/contract";
+// src/middleware-decorated.ts
+function decorateMiddleware(middleware) {
+  const decorated = middleware;
+  decorated.mapInput = (mapInput) => {
+    const mapped = decorateMiddleware(
+      (input, ...rest) => middleware(mapInput(input), ...rest)
+    );
+    return mapped;
+  };
+  decorated.concat = (concatMiddleware, mapInput) => {
+    const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
+    const concatted = decorateMiddleware((input, context, meta, ...rest) => {
+      const next = async (options) => {
+        return mapped(input, mergeContext(context, options.context), meta, ...rest);
+      };
+      const merged = middleware(input, context, { ...meta, next }, ...rest);
+      return merged;
+    });
+    return concatted;
+  };
+  return decorated;
+}
+
+// src/procedure-decorated.ts
+import { DecoratedContractProcedure } from "@orpc/contract";
+function decorateProcedure(procedure) {
+  const caller = createProcedureClient({
+    procedure,
+    context: void 0
+  });
+  const decorated = caller;
+  decorated["~type"] = procedure["~type"];
+  decorated["~orpc"] = procedure["~orpc"];
+  decorated.prefix = (prefix) => {
+    return decorateProcedure(new Procedure({
+      ...procedure["~orpc"],
+      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).prefix(prefix)
+    }));
+  };
+  decorated.route = (route) => {
+    return decorateProcedure(new Procedure({
+      ...procedure["~orpc"],
+      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).route(route)
+    }));
+  };
+  decorated.use = (middleware, mapInput) => {
+    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+    return decorateProcedure(new Procedure({
+      ...procedure["~orpc"],
+      middlewares: [...procedure["~orpc"].middlewares ?? [], middleware_]
+    }));
+  };
+  decorated.unshiftTag = (...tags) => {
+    return decorateProcedure(new Procedure({
+      ...procedure["~orpc"],
+      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).unshiftTag(...tags)
+    }));
+  };
+  decorated.unshiftMiddleware = (...middlewares) => {
+    if (procedure["~orpc"].middlewares?.length) {
+      let min = 0;
+      for (let i = 0; i < procedure["~orpc"].middlewares.length; i++) {
+        const index = middlewares.indexOf(procedure["~orpc"].middlewares[i], min);
+        if (index === -1) {
+          middlewares.push(...procedure["~orpc"].middlewares.slice(i));
+          break;
+        }
+        min = index + 1;
+      }
+    }
+    return decorateProcedure(new Procedure({
+      ...procedure["~orpc"],
+      middlewares
+    }));
+  };
+  return decorated;
+}
+
+// src/procedure-implementer.ts
+var ProcedureImplementer = class _ProcedureImplementer {
+  "~type" = "ProcedureImplementer";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  use(middleware, mapInput) {
+    const mappedMiddleware = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+    return new _ProcedureImplementer({
+      ...this["~orpc"],
+      middlewares: [...this["~orpc"].middlewares ?? [], mappedMiddleware]
+    });
+  }
+  func(func) {
+    return decorateProcedure(new Procedure({
+      middlewares: this["~orpc"].middlewares,
+      contract: this["~orpc"].contract,
+      func
+    }));
+  }
+};
+
+// src/hidden.ts
+var ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_ROUTER_CONTRACT");
+function setRouterContract(obj, contract) {
+  return new Proxy(obj, {
+    get(target, key) {
+      if (key === ROUTER_CONTRACT_SYMBOL) {
+        return contract;
+      }
+      return Reflect.get(target, key);
+    }
+  });
+}
+function getRouterContract(obj) {
+  return obj[ROUTER_CONTRACT_SYMBOL];
+}
 var LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
+function deepSetLazyRouterPrefix(router, prefix) {
+  return new Proxy(router, {
+    get(target, key) {
+      if (key !== LAZY_ROUTER_PREFIX_SYMBOL) {
+        const val = Reflect.get(target, key);
+        if (val && (typeof val === "object" || typeof val === "function")) {
+          return deepSetLazyRouterPrefix(val, prefix);
+        }
+        return val;
+      }
+      return prefix;
+    }
+  });
+}
+function getLazyRouterPrefix(obj) {
+  return obj[LAZY_ROUTER_PREFIX_SYMBOL];
+}
+
+// src/lazy-utils.ts
+function createLazyProcedureFormAnyLazy(lazied) {
+  const lazyProcedure = lazy(async () => {
+    const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
+    if (!isProcedure(maybeProcedure)) {
+      throw new Error(`
+            Expected a lazy<procedure> but got lazy<unknown>.
+            This should be caught by TypeScript compilation.
+            Please report this issue if this makes you feel uncomfortable.
+        `);
+    }
+    return { default: maybeProcedure };
+  });
+  return lazyProcedure;
+}
+
+// src/lazy-decorated.ts
+function decorateLazy(lazied) {
+  const flattenLazy = flatLazy(lazied);
+  const procedureProcedureClient = createProcedureClient({
+    procedure: createLazyProcedureFormAnyLazy(flattenLazy),
+    context: void 0
+  });
+  Object.assign(procedureProcedureClient, flattenLazy);
+  const recursive = new Proxy(procedureProcedureClient, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      const next = getRouterChild(flattenLazy, key);
+      return decorateLazy(next);
+    }
+  });
+  return recursive;
+}
+
+// src/router-builder.ts
 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');
+  "~type" = "RouterBuilder";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+    if (def.prefix && def.prefix.includes("{")) {
+      throw new Error(`
+        Dynamic routing in prefix not supported yet.
+        Please remove "{" from "${def.prefix}".
+      `);
     }
   }
   prefix(prefix) {
     return new _RouterBuilder({
-      ...this.zz$rb,
-      prefix: `${this.zz$rb.prefix ?? ""}${prefix}`
+      ...this["~orpc"],
+      prefix: `${this["~orpc"].prefix ?? ""}${prefix}`
     });
   }
-  tags(...tags) {
-    if (!tags.length)
-      return this;
+  tag(...tags) {
     return new _RouterBuilder({
-      ...this.zz$rb,
-      tags: [...this.zz$rb.tags ?? [], ...tags]
+      ...this["~orpc"],
+      tags: [...this["~orpc"].tags ?? [], ...tags]
     });
   }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+  use(middleware) {
     return new _RouterBuilder({
-      ...this.zz$rb,
-      middlewares: [...this.zz$rb.middlewares || [], middleware_]
+      ...this["~orpc"],
+      middlewares: [...this["~orpc"].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;
+    const adapted = adapt(router, this["~orpc"]);
+    return adapted;
   }
   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;
+    const adapted = adapt(flatLazy(lazy(loader)), this["~orpc"]);
+    return adapted;
   }
 };
-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];
+function adapt(item, options) {
+  if (isLazy(item)) {
+    const adaptedLazy = decorateLazy(lazy(async () => {
+      const routerOrProcedure = (await unlazy(item)).default;
+      const adapted2 = adapt(routerOrProcedure, options);
+      return { default: adapted2 };
+    }));
+    const lazyPrefix = getLazyRouterPrefix(item);
+    if (options.prefix || lazyPrefix) {
+      const prefixed = deepSetLazyRouterPrefix(adaptedLazy, `${options.prefix ?? ""}${lazyPrefix ?? ""}`);
+      return prefixed;
+    }
+    return adaptedLazy;
   }
-  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] };
-        })
-      });
+  if (isProcedure(item)) {
+    let decorated = decorateProcedure(item);
+    if (options.tags?.length) {
+      decorated = decorated.unshiftTag(...options.tags);
     }
-  });
-  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
+    if (options.prefix) {
+      decorated = decorated.prefix(options.prefix);
     }
-  });
+    if (options.middlewares?.length) {
+      decorated = decorated.unshiftMiddleware(...options.middlewares);
+    }
+    return decorated;
+  }
+  const adapted = {};
+  for (const key in item) {
+    adapted[key] = adapt(item[key], options);
+  }
+  return adapted;
 }
 
-// src/procedure-implementer.ts
-var ProcedureImplementer = class _ProcedureImplementer {
-  constructor(zz$pi) {
-    this.zz$pi = zz$pi;
-  }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _ProcedureImplementer({
-      ...this.zz$pi,
-      middlewares: [...this.zz$pi.middlewares ?? [], middleware_]
+// src/router-implementer.ts
+var RouterImplementer = class _RouterImplementer {
+  "~type" = "RouterImplementer";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  use(middleware) {
+    return new _RouterImplementer({
+      ...this["~orpc"],
+      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
     });
   }
-  func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$pi.middlewares,
-        contract: this.zz$pi.contract,
-        func
-      }
-    });
+  router(router) {
+    const adapted = new RouterBuilder(this["~orpc"]).router(router);
+    const contracted = setRouterContract(adapted, this["~orpc"].contract);
+    return contracted;
   }
   lazy(loader) {
-    return new RouterBuilder(this.zz$pi).lazy(loader);
+    const adapted = new RouterBuilder(this["~orpc"]).lazy(loader);
+    const contracted = setRouterContract(adapted, this["~orpc"].contract);
+    return contracted;
   }
 };
 
+// src/implementer-chainable.ts
+function createChainableImplementer(contract, middlewares) {
+  if (isContractProcedure(contract)) {
+    const implementer = new ProcedureImplementer({
+      contract,
+      middlewares
+    });
+    return implementer;
+  }
+  const chainable = {};
+  for (const key in contract) {
+    chainable[key] = createChainableImplementer(contract[key], middlewares);
+  }
+  const routerImplementer = new RouterImplementer({ contract, middlewares });
+  const merged = new Proxy(chainable, {
+    get(target, key) {
+      const next = Reflect.get(target, key);
+      const method = Reflect.get(routerImplementer, key);
+      if (typeof key !== "string" || typeof method !== "function") {
+        return next;
+      }
+      if (!next) {
+        return method.bind(routerImplementer);
+      }
+      return createCallableObject(next, method.bind(routerImplementer));
+    }
+  });
+  return merged;
+}
+
 // src/procedure-builder.ts
+import {
+  DecoratedContractProcedure as DecoratedContractProcedure2
+} from "@orpc/contract";
 var ProcedureBuilder = class _ProcedureBuilder {
-  constructor(zz$pb) {
-    this.zz$pb = zz$pb;
+  "~type" = "ProcedureBuilder";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
   }
-  /**
-   * Self chainable
-   */
-  route(opts) {
+  route(route) {
     return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure2.decorate(this.zz$pb.contract).route(
-        opts
-      )
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).route(route)
     });
   }
   input(schema, example) {
     return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure2.decorate(this.zz$pb.contract).input(
-        schema,
-        example
-      )
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).input(schema, example)
     });
   }
   output(schema, example) {
     return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure2.decorate(this.zz$pb.contract).output(
-        schema,
-        example
-      )
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).output(schema, example)
     });
   }
   use(middleware, mapInput) {
     if (!mapInput) {
       return new ProcedureImplementer({
-        contract: this.zz$pb.contract,
-        middlewares: this.zz$pb.middlewares
+        contract: this["~orpc"].contract,
+        middlewares: this["~orpc"].middlewares
       }).use(middleware);
     }
     return new ProcedureImplementer({
-      contract: this.zz$pb.contract,
-      middlewares: this.zz$pb.middlewares
+      contract: this["~orpc"].contract,
+      middlewares: this["~orpc"].middlewares
     }).use(middleware, mapInput);
   }
-  /**
-   * Convert to Procedure
-   */
   func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$pb.middlewares,
-        contract: this.zz$pb.contract,
-        func
-      }
-    });
+    return decorateProcedure(new Procedure({
+      middlewares: this["~orpc"].middlewares,
+      contract: this["~orpc"].contract,
+      func
+    }));
   }
 };
 
-// src/router-implementer.ts
-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) {
-    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) {
-  const result = {};
-  for (const key in contract) {
-    const item = contract[key];
-    if (isContractProcedure(item)) {
-      result[key] = new ProcedureImplementer({
-        contract: item,
-        middlewares
-      });
-    } else {
-      result[key] = chainRouterImplementer(item, middlewares);
-    }
-  }
-  const implementer = new RouterImplementer({ contract });
-  return Object.assign(implementer, result);
-}
-
 // src/builder.ts
 var Builder = class _Builder {
-  constructor(zz$b = {}) {
-    this.zz$b = zz$b;
+  "~type" = "Builder";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
   }
-  /**
-   * Self chainable
-   */
   context() {
-    return this;
+    return new _Builder({});
   }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+  use(middleware) {
     return new _Builder({
-      ...this.zz$b,
-      middlewares: [...this.zz$b.middlewares || [], middleware_]
+      ...this["~orpc"],
+      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
     });
   }
-  /**
-   * Convert to ContractProcedureBuilder
-   */
-  route(opts) {
+  middleware(middleware) {
+    return decorateMiddleware(middleware);
+  }
+  route(route) {
     return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
+      middlewares: this["~orpc"].middlewares,
       contract: new ContractProcedure({
-        ...opts,
+        route,
         InputSchema: void 0,
         OutputSchema: void 0
       })
@@ -310,7 +398,7 @@ var Builder = class _Builder {
   }
   input(schema, example) {
     return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
+      middlewares: this["~orpc"].middlewares,
       contract: new ContractProcedure({
         OutputSchema: void 0,
         InputSchema: schema,
@@ -320,7 +408,7 @@ var Builder = class _Builder {
   }
   output(schema, example) {
     return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
+      middlewares: this["~orpc"].middlewares,
       contract: new ContractProcedure({
         InputSchema: void 0,
         OutputSchema: schema,
@@ -328,107 +416,69 @@ var Builder = class _Builder {
       })
     });
   }
-  /**
-   * Convert to Procedure
-   */
   func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$b.middlewares,
-        contract: new ContractProcedure({
-          InputSchema: void 0,
-          OutputSchema: void 0
-        }),
-        func
-      }
-    });
-  }
-  /**
-   * Convert to ProcedureImplementer | RouterBuilder
-   */
-  contract(contract) {
-    if (isContractProcedure2(contract)) {
-      return new ProcedureImplementer({
-        contract,
-        middlewares: this.zz$b.middlewares
-      });
-    }
-    return chainRouterImplementer(
-      contract,
-      this.zz$b.middlewares
-    );
-  }
-  /**
-   * Create ExtendedMiddleware
-   */
-  // TODO: TOutput always any, infer not work at all, because TOutput used inside middleware params,
-  // solution (maybe): create new generic for .output() method
-  middleware(middleware) {
-    return decorateMiddleware(middleware);
+    return decorateProcedure(new Procedure({
+      middlewares: this["~orpc"].middlewares,
+      contract: new ContractProcedure({
+        InputSchema: void 0,
+        OutputSchema: void 0
+      }),
+      func
+    }));
   }
   prefix(prefix) {
     return new RouterBuilder({
-      ...this.zz$b,
+      middlewares: this["~orpc"].middlewares,
       prefix
     });
   }
-  tags(...tags) {
+  tag(...tags) {
     return new RouterBuilder({
-      ...this.zz$b,
+      middlewares: this["~orpc"].middlewares,
       tags
     });
   }
-  /**
-   * Create DecoratedRouter
-   */
   router(router) {
-    return new RouterBuilder(this.zz$b).router(router);
+    return new RouterBuilder(this["~orpc"]).router(router);
   }
   lazy(loader) {
-    return new RouterBuilder(this.zz$b).lazy(loader);
+    return new RouterBuilder(this["~orpc"]).lazy(loader);
+  }
+  contract(contract) {
+    return createChainableImplementer(contract, this["~orpc"].middlewares);
   }
 };
 
-// src/router.ts
-import {
-  isContractProcedure as isContractProcedure3
-} from "@orpc/contract";
-function toContractRouter(router) {
-  const contract = {};
-  for (const key in router) {
-    const item = router[key];
-    if (isContractProcedure3(item)) {
-      contract[key] = item;
-    } else if (isProcedure(item)) {
-      contract[key] = item.zz$p.contract;
-    } else {
-      contract[key] = toContractRouter(item);
-    }
+// src/router-client.ts
+function createRouterClient(options) {
+  if (isProcedure(options.router)) {
+    const caller = createProcedureClient({
+      ...options,
+      procedure: options.router,
+      context: options.context,
+      path: options.path
+    });
+    return caller;
   }
-  return contract;
-}
-
-// src/router-caller.ts
-function createRouterCaller(options) {
-  return createRouterCallerInternal(options);
-}
-function createRouterCallerInternal(options) {
-  const procedureCaller = isLazy(options.router) || isProcedure(options.router) ? createProcedureCaller({
+  const procedureCaller = isLazy(options.router) ? createProcedureClient({
     ...options,
-    procedure: options.router,
+    procedure: createLazyProcedureFormAnyLazy(options.router),
     context: options.context,
-    path: options.basePath
+    path: options.path
   }) : {};
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
       }
-      const next = options.router[key];
-      return createRouterCallerInternal({
+      const next = getRouterChild(options.router, key);
+      if (!next) {
+        return Reflect.get(target, key);
+      }
+      return createRouterClient({
         ...options,
         router: next,
-        basePath: [...options.basePath ?? [], key]
+        path: [...options.path ?? [], key]
       });
     }
   });
@@ -437,31 +487,32 @@ function createRouterCallerInternal(options) {
 
 // src/index.ts
 export * from "@orpc/shared/error";
-var os = new Builder();
+var os = new Builder({});
 export {
   Builder,
   LAZY_LOADER_SYMBOL,
-  LAZY_ROUTER_PREFIX_SYMBOL,
   Procedure,
   ProcedureBuilder,
   ProcedureImplementer,
-  ROUTER_CONTRACT_SYMBOL,
   RouterBuilder,
   RouterImplementer,
-  chainRouterImplementer,
-  createFlattenLazy,
-  createLazy,
-  createProcedureCaller,
-  createRouterCaller,
+  createChainableImplementer,
+  createProcedureClient,
+  createRouterClient,
   decorateLazy,
   decorateMiddleware,
   decorateProcedure,
+  deepSetLazyRouterPrefix,
+  flatLazy,
+  getLazyRouterPrefix,
+  getRouterChild,
+  getRouterContract,
   isLazy,
   isProcedure,
-  loadLazy,
-  loadProcedure,
+  lazy,
   mergeContext,
   os,
-  toContractRouter
+  setRouterContract,
+  unlazy
 };
 //# sourceMappingURL=index.js.map