@orpc/server 0.0.0-next.e9dc36e → 0.0.0-next.ed15210

package/dist/index.js

@@ -1,394 +1,1043 @@
 import {
+  LAZY_LOADER_SYMBOL,
   Procedure,
-  createProcedureCaller,
-  decorateMiddleware,
-  decorateProcedure,
+  createORPCErrorConstructorMap,
+  createProcedureClient,
+  flatLazy,
+  getRouterChild,
+  isLazy,
   isProcedure,
-  mergeContext
-} from "./chunk-TDFYNRZV.js";
+  lazy,
+  middlewareOutputFn,
+  unlazy
+} from "./chunk-XHFINNVL.js";
 
 // src/builder.ts
-import {
-  ContractProcedure,
-  isContractProcedure as isContractProcedure2
-} from "@orpc/contract";
+import { ContractProcedure as ContractProcedure4, fallbackContractConfig as fallbackContractConfig4 } from "@orpc/contract";
+
+// src/builder-with-errors.ts
+import { ContractProcedure as ContractProcedure2, fallbackContractConfig as fallbackContractConfig2 } from "@orpc/contract";
+
+// src/builder-with-errors-middlewares.ts
+import { ContractProcedure, fallbackContractConfig } from "@orpc/contract";
 
 // src/procedure-builder.ts
-import {
-  DecoratedContractProcedure
-} from "@orpc/contract";
+import { ContractProcedureBuilder, DecoratedContractProcedure as DecoratedContractProcedure4 } from "@orpc/contract";
+
+// src/procedure-builder-with-input.ts
+import { ContractProcedureBuilderWithInput, DecoratedContractProcedure as DecoratedContractProcedure2 } from "@orpc/contract";
+
+// src/middleware-decorated.ts
+function decorateMiddleware(middleware) {
+  const decorated = middleware;
+  decorated.mapInput = (mapInput) => {
+    const mapped = decorateMiddleware(
+      (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
+    );
+    return mapped;
+  };
+  decorated.concat = (concatMiddleware, mapInput) => {
+    const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
+    const concatted = decorateMiddleware((options, input, output, ...rest) => {
+      const next = async (...[nextOptions]) => {
+        return mapped({ ...options, context: { ...nextOptions?.context, ...options.context } }, input, output, ...rest);
+      };
+      const merged = middleware({ ...options, next }, input, output, ...rest);
+      return merged;
+    });
+    return concatted;
+  };
+  return decorated;
+}
+
+// src/procedure-decorated.ts
+import { DecoratedContractProcedure } from "@orpc/contract";
+var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
+  static decorate(procedure) {
+    if (procedure instanceof _DecoratedProcedure) {
+      return procedure;
+    }
+    return new _DecoratedProcedure(procedure["~orpc"]);
+  }
+  prefix(prefix) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).prefix(prefix)
+    });
+  }
+  route(route) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).route(route)
+    });
+  }
+  errors(errors) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).errors(errors)
+    });
+  }
+  use(middleware, mapInput) {
+    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      middlewares: [...this["~orpc"].middlewares, middleware_]
+    });
+  }
+  unshiftTag(...tags) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).unshiftTag(...tags)
+    });
+  }
+  unshiftMiddleware(...middlewares) {
+    const castedMiddlewares = middlewares;
+    if (this["~orpc"].middlewares.length) {
+      let min = 0;
+      for (let i = 0; i < this["~orpc"].middlewares.length; i++) {
+        const index = castedMiddlewares.indexOf(this["~orpc"].middlewares[i], min);
+        if (index === -1) {
+          castedMiddlewares.push(...this["~orpc"].middlewares.slice(i));
+          break;
+        }
+        min = index + 1;
+      }
+    }
+    const numNewMiddlewares = castedMiddlewares.length - this["~orpc"].middlewares.length;
+    const decorated = new _DecoratedProcedure({
+      ...this["~orpc"],
+      inputValidationIndex: this["~orpc"].inputValidationIndex + numNewMiddlewares,
+      outputValidationIndex: this["~orpc"].outputValidationIndex + numNewMiddlewares,
+      middlewares: castedMiddlewares
+    });
+    return decorated;
+  }
+  /**
+   * Make this procedure callable (works like a function while still being a procedure).
+   */
+  callable(...rest) {
+    return Object.assign(createProcedureClient(this, ...rest), {
+      "~type": "Procedure",
+      "~orpc": this["~orpc"]
+    });
+  }
+  /**
+   * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
+   */
+  actionable(...rest) {
+    return this.callable(...rest);
+  }
+};
 
 // src/procedure-implementer.ts
 var ProcedureImplementer = class _ProcedureImplementer {
-  constructor(zz$pi) {
-    this.zz$pi = zz$pi;
+  "~type" = "ProcedureImplementer";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
   }
   use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+    const mappedMiddleware = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
     return new _ProcedureImplementer({
-      ...this.zz$pi,
-      middlewares: [...this.zz$pi.middlewares ?? [], middleware_]
+      ...this["~orpc"],
+      middlewares: [...this["~orpc"].middlewares, mappedMiddleware]
     });
   }
-  func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$pi.middlewares,
-        contract: this.zz$pi.contract,
-        func
-      }
+  handler(handler) {
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      handler
+    });
+  }
+};
+
+// src/procedure-builder-with-input.ts
+var ProcedureBuilderWithInput = class _ProcedureBuilderWithInput {
+  "~type" = "ProcedureBuilderWithInput";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  errors(errors) {
+    return new _ProcedureBuilderWithInput({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).errors(errors)
+    });
+  }
+  route(route) {
+    return new _ProcedureBuilderWithInput({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).route(route)
+    });
+  }
+  use(middleware, mapInput) {
+    const maybeWithMapInput = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+    return new _ProcedureBuilderWithInput({
+      ...this["~orpc"],
+      outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
+      middlewares: [...this["~orpc"].middlewares, maybeWithMapInput]
+    });
+  }
+  output(schema, example) {
+    return new ProcedureImplementer({
+      ...this["~orpc"],
+      contract: new ContractProcedureBuilderWithInput(this["~orpc"].contract["~orpc"]).output(schema, example)
+    });
+  }
+  handler(handler) {
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      handler
+    });
+  }
+};
+
+// src/procedure-builder-with-output.ts
+import { ContractProcedureBuilderWithOutput, DecoratedContractProcedure as DecoratedContractProcedure3 } from "@orpc/contract";
+var ProcedureBuilderWithOutput = class _ProcedureBuilderWithOutput {
+  "~type" = "ProcedureBuilderWithOutput";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  errors(errors) {
+    return new _ProcedureBuilderWithOutput({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure3.decorate(this["~orpc"].contract).errors(errors)
+    });
+  }
+  route(route) {
+    return new _ProcedureBuilderWithOutput({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure3.decorate(this["~orpc"].contract).route(route)
+    });
+  }
+  use(middleware) {
+    const builder = new _ProcedureBuilderWithOutput({
+      contract: this["~orpc"].contract,
+      outputValidationIndex: this["~orpc"].outputValidationIndex,
+      inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
+      middlewares: [...this["~orpc"].middlewares, middleware]
+    });
+    return builder;
+  }
+  input(schema, example) {
+    return new ProcedureImplementer({
+      ...this["~orpc"],
+      contract: new ContractProcedureBuilderWithOutput(this["~orpc"].contract["~orpc"]).input(schema, example)
+    });
+  }
+  handler(handler) {
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      handler
     });
   }
 };
 
 // src/procedure-builder.ts
 var ProcedureBuilder = class _ProcedureBuilder {
-  constructor(zz$pb) {
-    this.zz$pb = zz$pb;
+  "~type" = "ProcedureBuilder";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
   }
-  /**
-   * Self chainable
-   */
-  route(opts) {
+  errors(errors) {
     return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).route(
-        opts
-      )
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure4.decorate(this["~orpc"].contract).errors(errors)
     });
   }
-  input(schema, example) {
+  route(route) {
     return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).input(
-        schema,
-        example
-      )
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure4.decorate(this["~orpc"].contract).route(route)
     });
   }
-  output(schema, example) {
-    return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).output(
-        schema,
-        example
-      )
+  use(middleware) {
+    const builder = new _ProcedureBuilder({
+      contract: this["~orpc"].contract,
+      inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
+      outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
+      middlewares: [...this["~orpc"].middlewares, middleware]
     });
+    return builder;
   }
-  use(middleware, mapInput) {
-    if (!mapInput) {
-      return new ProcedureImplementer({
-        contract: this.zz$pb.contract,
-        middlewares: this.zz$pb.middlewares
-      }).use(middleware);
-    }
-    return new ProcedureImplementer({
-      contract: this.zz$pb.contract,
-      middlewares: this.zz$pb.middlewares
-    }).use(middleware, mapInput);
+  input(schema, example) {
+    return new ProcedureBuilderWithInput({
+      ...this["~orpc"],
+      contract: new ContractProcedureBuilder(this["~orpc"].contract["~orpc"]).input(schema, example)
+    });
   }
-  /**
-   * Convert to Procedure
-   */
-  func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$pb.middlewares,
-        contract: this.zz$pb.contract,
-        func
-      }
+  output(schema, example) {
+    return new ProcedureBuilderWithOutput({
+      ...this["~orpc"],
+      contract: new ContractProcedureBuilder(this["~orpc"].contract["~orpc"]).output(schema, example)
+    });
+  }
+  handler(handler) {
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      handler
     });
   }
 };
 
 // src/router-builder.ts
-import { DecoratedContractProcedure as DecoratedContractProcedure2 } from "@orpc/contract";
+import { mergePrefix, mergeTags } from "@orpc/contract";
+
+// src/hidden.ts
+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-decorated.ts
+function decorateLazy(lazied) {
+  const flattenLazy = flatLazy(lazied);
+  const recursive = new Proxy(flattenLazy, {
+    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;
+  "~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: mergePrefix(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: mergeTags(this["~orpc"].tags, tags)
     });
   }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+  errors(errors) {
     return new _RouterBuilder({
-      ...this.zz$rb,
-      middlewares: [...this.zz$rb.middlewares || [], middleware_]
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
+  use(middleware) {
+    const builder = new _RouterBuilder({
+      tags: this["~orpc"].tags,
+      prefix: this["~orpc"].prefix,
+      errorMap: this["~orpc"].errorMap,
+      middlewares: [...this["~orpc"].middlewares, middleware]
     });
+    return builder;
   }
   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);
-      }
+    const adapted = adapt(router, this["~orpc"]);
+    return adapted;
+  }
+  lazy(loader) {
+    const adapted = adapt(flatLazy(lazy(loader)), this["~orpc"]);
+    return adapted;
+  }
+};
+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;
+  }
+  if (isProcedure(item)) {
+    let decorated = DecoratedProcedure.decorate(item);
+    if (options.tags?.length) {
+      decorated = decorated.unshiftTag(...options.tags);
+    }
+    if (options.prefix) {
+      decorated = decorated.prefix(options.prefix);
+    }
+    if (options.middlewares?.length) {
+      decorated = decorated.unshiftMiddleware(...options.middlewares);
     }
-    return handled;
+    if (Object.keys(options.errorMap).length) {
+      decorated = decorated.errors(options.errorMap);
+    }
+    return decorated;
+  }
+  const adapted = {};
+  for (const key in item) {
+    adapted[key] = adapt(item[key], options);
+  }
+  return adapted;
+}
+
+// src/builder-with-errors-middlewares.ts
+var BuilderWithErrorsMiddlewares = class _BuilderWithErrorsMiddlewares {
+  "~type" = "BuilderWithErrorsMiddlewares";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  errors(errors) {
+    return new _BuilderWithErrorsMiddlewares({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
+  use(middleware) {
+    const builder = new _BuilderWithErrorsMiddlewares({
+      config: this["~orpc"].config,
+      errorMap: this["~orpc"].errorMap,
+      inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
+      outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
+      middlewares: [...this["~orpc"].middlewares, middleware]
+    });
+    return builder;
+  }
+  route(route) {
+    return new ProcedureBuilder({
+      ...this["~orpc"],
+      contract: new ContractProcedure({
+        route: {
+          ...this["~orpc"].config.initialRoute,
+          ...route
+        },
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: this["~orpc"].errorMap
+      })
+    });
+  }
+  input(schema, example) {
+    return new ProcedureBuilderWithInput({
+      ...this["~orpc"],
+      contract: new ContractProcedure({
+        route: fallbackContractConfig("defaultInitialRoute", this["~orpc"].config.initialRoute),
+        OutputSchema: void 0,
+        InputSchema: schema,
+        inputExample: example,
+        errorMap: this["~orpc"].errorMap
+      })
+    });
+  }
+  output(schema, example) {
+    return new ProcedureBuilderWithOutput({
+      ...this["~orpc"],
+      contract: new ContractProcedure({
+        route: fallbackContractConfig("defaultInitialRoute", this["~orpc"].config.initialRoute),
+        InputSchema: void 0,
+        OutputSchema: schema,
+        outputExample: example,
+        errorMap: this["~orpc"].errorMap
+      })
+    });
+  }
+  handler(handler) {
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      contract: new ContractProcedure({
+        route: fallbackContractConfig("defaultInitialRoute", this["~orpc"].config.initialRoute),
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: this["~orpc"].errorMap
+      }),
+      handler
+    });
+  }
+  prefix(prefix) {
+    return new RouterBuilder({
+      ...this["~orpc"],
+      prefix
+    });
+  }
+  tag(...tags) {
+    return new RouterBuilder({
+      ...this["~orpc"],
+      tags
+    });
+  }
+  router(router) {
+    return new RouterBuilder(this["~orpc"]).router(router);
+  }
+  lazy(loader) {
+    return new RouterBuilder(this["~orpc"]).lazy(loader);
   }
 };
 
-// src/router-implementer.ts
-import {
-  isContractProcedure
-} from "@orpc/contract";
-var RouterImplementer = class {
-  constructor(zz$ri) {
-    this.zz$ri = zz$ri;
+// src/config.ts
+var DEFAULT_CONFIG = {
+  initialInputValidationIndex: 0,
+  initialOutputValidationIndex: 0
+};
+function fallbackConfig(key, value) {
+  if (value === void 0) {
+    return DEFAULT_CONFIG[key];
+  }
+  return value;
+}
+
+// src/builder-with-errors.ts
+var BuilderWithErrors = class _BuilderWithErrors {
+  "~type" = "BuilderWithErrors";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  config(config) {
+    return new _BuilderWithErrors({
+      ...this["~orpc"],
+      config: {
+        ...this["~orpc"].config,
+        ...config
+      }
+    });
+  }
+  context() {
+    return this;
+  }
+  errors(errors) {
+    return new _BuilderWithErrors({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
+  middleware(middleware) {
+    return decorateMiddleware(middleware);
+  }
+  use(middleware) {
+    return new BuilderWithErrorsMiddlewares({
+      ...this["~orpc"],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex) + 1,
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + 1,
+      middlewares: [middleware]
+    });
+  }
+  route(route) {
+    return new ProcedureBuilder({
+      middlewares: [],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
+      contract: new ContractProcedure2({
+        route: {
+          ...fallbackContractConfig2("defaultInitialRoute", this["~orpc"].config.initialRoute),
+          ...route
+        },
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: this["~orpc"].errorMap
+      })
+    });
+  }
+  input(schema, example) {
+    return new ProcedureBuilderWithInput({
+      middlewares: [],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
+      contract: new ContractProcedure2({
+        route: fallbackContractConfig2("defaultInitialRoute", this["~orpc"].config.initialRoute),
+        OutputSchema: void 0,
+        InputSchema: schema,
+        inputExample: example,
+        errorMap: this["~orpc"].errorMap
+      })
+    });
+  }
+  output(schema, example) {
+    return new ProcedureBuilderWithOutput({
+      middlewares: [],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
+      contract: new ContractProcedure2({
+        route: fallbackContractConfig2("defaultInitialRoute", this["~orpc"].config.initialRoute),
+        InputSchema: void 0,
+        OutputSchema: schema,
+        outputExample: example,
+        errorMap: this["~orpc"].errorMap
+      })
+    });
+  }
+  handler(handler) {
+    return new DecoratedProcedure({
+      middlewares: [],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
+      contract: new ContractProcedure2({
+        route: fallbackContractConfig2("defaultInitialRoute", this["~orpc"].config.initialRoute),
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: this["~orpc"].errorMap
+      }),
+      handler
+    });
+  }
+  prefix(prefix) {
+    return new RouterBuilder({
+      middlewares: [],
+      errorMap: this["~orpc"].errorMap,
+      prefix
+    });
+  }
+  tag(...tags) {
+    return new RouterBuilder({
+      middlewares: [],
+      errorMap: this["~orpc"].errorMap,
+      tags
+    });
   }
   router(router) {
-    assertRouterImplementation(this.zz$ri.contract, router);
-    return router;
+    return new RouterBuilder({
+      middlewares: [],
+      ...this["~orpc"]
+    }).router(router);
+  }
+  lazy(loader) {
+    return new RouterBuilder({
+      middlewares: [],
+      ...this["~orpc"]
+    }).lazy(loader);
   }
 };
-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);
+
+// src/builder-with-middlewares.ts
+import { ContractProcedure as ContractProcedure3, fallbackContractConfig as fallbackContractConfig3 } from "@orpc/contract";
+
+// src/implementer-chainable.ts
+import { isContractProcedure } from "@orpc/contract";
+import { createCallableObject } from "@orpc/shared";
+
+// src/router-utils.ts
+function unshiftMiddlewaresRouter(router, options) {
+  if (isLazy(router)) {
+    const applied2 = decorateLazy(lazy(async () => {
+      const unlaziedRouter = (await unlazy(router)).default;
+      const applied3 = unshiftMiddlewaresRouter(unlaziedRouter, options);
+      return { default: applied3 };
+    }));
+    return applied2;
+  }
+  if (isProcedure(router)) {
+    let decorated = DecoratedProcedure.decorate(router);
+    if (options.middlewares.length) {
+      decorated = decorated.unshiftMiddleware(...options.middlewares);
     }
+    return decorated;
+  }
+  const applied = {};
+  for (const key in router) {
+    applied[key] = unshiftMiddlewaresRouter(router[key], options);
   }
-  const implementer = new RouterImplementer({ contract });
-  return Object.assign(implementer, result);
+  return applied;
 }
-function assertRouterImplementation(contract, router, path = []) {
+
+// src/router-implementer.ts
+var RouterImplementer = class _RouterImplementer {
+  "~type" = "RouterImplementer";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  use(middleware) {
+    const builder = new _RouterImplementer({
+      contract: this["~orpc"].contract,
+      middlewares: [...this["~orpc"].middlewares, middleware]
+    });
+    return builder;
+  }
+  router(router) {
+    const applied = unshiftMiddlewaresRouter(router, this["~orpc"]);
+    return applied;
+  }
+  lazy(loader) {
+    const applied = unshiftMiddlewaresRouter(flatLazy(lazy(loader)), this["~orpc"]);
+    return applied;
+  }
+};
+
+// src/implementer-chainable.ts
+function createChainableImplementer(contract, options) {
+  if (isContractProcedure(contract)) {
+    const implementer = new ProcedureImplementer({
+      contract,
+      middlewares: options.middlewares,
+      inputValidationIndex: options.inputValidationIndex,
+      outputValidationIndex: options.outputValidationIndex
+    });
+    return implementer;
+  }
+  const chainable = {};
   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(".")}]`
-        );
+    chainable[key] = createChainableImplementer(contract[key], options);
+  }
+  const routerImplementer = new RouterImplementer({
+    contract,
+    middlewares: options.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;
       }
-    } else {
-      assertRouterImplementation(
-        contractItem,
-        routerItem,
-        currentPath
-      );
+      if (!next) {
+        return method.bind(routerImplementer);
+      }
+      return createCallableObject(next, method.bind(routerImplementer));
     }
-  }
+  });
+  return merged;
 }
 
-// src/builder.ts
-var Builder = class _Builder {
-  constructor(zz$b = {}) {
-    this.zz$b = zz$b;
+// src/builder-with-middlewares.ts
+var BuilderWithMiddlewares = class _BuilderWithMiddlewares {
+  "~type" = "BuilderHasMiddlewares";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
   }
-  /**
-   * Self chainable
-   */
-  context() {
-    return this;
+  use(middleware) {
+    const builder = new _BuilderWithMiddlewares({
+      config: this["~orpc"].config,
+      inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
+      outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
+      middlewares: [...this["~orpc"].middlewares, middleware]
+    });
+    return builder;
   }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _Builder({
-      ...this.zz$b,
-      middlewares: [...this.zz$b.middlewares || [], middleware_]
+  errors(errors) {
+    return new BuilderWithErrorsMiddlewares({
+      ...this["~orpc"],
+      errorMap: errors
     });
   }
-  /**
-   * Convert to ContractProcedureBuilder
-   */
-  route(opts) {
+  route(route) {
     return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
-        ...opts,
+      ...this["~orpc"],
+      contract: new ContractProcedure3({
+        route: {
+          ...this["~orpc"].config.initialRoute,
+          ...route
+        },
         InputSchema: void 0,
-        OutputSchema: void 0
+        OutputSchema: void 0,
+        errorMap: {}
       })
     });
   }
   input(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
+    return new ProcedureBuilderWithInput({
+      ...this["~orpc"],
+      contract: new ContractProcedure3({
+        route: fallbackContractConfig3("defaultInitialRoute", this["~orpc"].config.initialRoute),
         OutputSchema: void 0,
         InputSchema: schema,
-        inputExample: example
+        inputExample: example,
+        errorMap: {}
       })
     });
   }
   output(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
+    return new ProcedureBuilderWithOutput({
+      ...this["~orpc"],
+      contract: new ContractProcedure3({
+        route: fallbackContractConfig3("defaultInitialRoute", this["~orpc"].config.initialRoute),
         InputSchema: void 0,
         OutputSchema: schema,
-        outputExample: example
+        outputExample: example,
+        errorMap: {}
       })
     });
   }
-  /**
-   * Convert to Procedure
-   */
-  func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$b.middlewares,
-        contract: new ContractProcedure({
-          InputSchema: void 0,
-          OutputSchema: void 0
-        }),
-        func
-      }
+  handler(handler) {
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      contract: new ContractProcedure3({
+        route: fallbackContractConfig3("defaultInitialRoute", this["~orpc"].config.initialRoute),
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: {}
+      }),
+      handler
     });
   }
-  /**
-   * Convert to ProcedureImplementer | RouterBuilder
-   */
+  prefix(prefix) {
+    return new RouterBuilder({
+      middlewares: this["~orpc"].middlewares,
+      errorMap: {},
+      prefix
+    });
+  }
+  tag(...tags) {
+    return new RouterBuilder({
+      middlewares: this["~orpc"].middlewares,
+      errorMap: {},
+      tags
+    });
+  }
+  router(router) {
+    return unshiftMiddlewaresRouter(router, this["~orpc"]);
+  }
+  lazy(loader) {
+    return unshiftMiddlewaresRouter(flatLazy(lazy(loader)), this["~orpc"]);
+  }
   contract(contract) {
-    if (isContractProcedure2(contract)) {
-      return new ProcedureImplementer({
-        contract,
-        middlewares: this.zz$b.middlewares
-      });
-    }
-    return chainRouterImplementer(
-      contract,
-      this.zz$b.middlewares
-    );
+    return createChainableImplementer(contract, this["~orpc"]);
+  }
+};
+
+// src/builder.ts
+var Builder = class _Builder {
+  "~type" = "Builder";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  config(config) {
+    return new _Builder({
+      ...this["~orpc"],
+      config: {
+        ...this["~orpc"].config,
+        ...config
+      }
+    });
+  }
+  context() {
+    return this;
   }
-  /**
-   * 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);
   }
+  errors(errors) {
+    return new BuilderWithErrors({
+      ...this["~orpc"],
+      errorMap: errors
+    });
+  }
+  use(middleware) {
+    const builder = new BuilderWithMiddlewares({
+      ...this["~orpc"],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex) + 1,
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + 1,
+      middlewares: [middleware]
+      // FIXME: I believe we can remove `as any` here
+    });
+    return builder;
+  }
+  route(route) {
+    return new ProcedureBuilder({
+      middlewares: [],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
+      contract: new ContractProcedure4({
+        route: {
+          ...this["~orpc"].config.initialRoute,
+          ...route
+        },
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: {}
+      })
+    });
+  }
+  input(schema, example) {
+    return new ProcedureBuilderWithInput({
+      middlewares: [],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
+      contract: new ContractProcedure4({
+        route: fallbackContractConfig4("defaultInitialRoute", this["~orpc"].config.initialRoute),
+        OutputSchema: void 0,
+        InputSchema: schema,
+        inputExample: example,
+        errorMap: {}
+      })
+    });
+  }
+  output(schema, example) {
+    return new ProcedureBuilderWithOutput({
+      middlewares: [],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
+      contract: new ContractProcedure4({
+        route: fallbackContractConfig4("defaultInitialRoute", this["~orpc"].config.initialRoute),
+        InputSchema: void 0,
+        OutputSchema: schema,
+        outputExample: example,
+        errorMap: {}
+      })
+    });
+  }
+  handler(handler) {
+    return new DecoratedProcedure({
+      middlewares: [],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
+      contract: new ContractProcedure4({
+        route: fallbackContractConfig4("defaultInitialRoute", this["~orpc"].config.initialRoute),
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: {}
+      }),
+      handler
+    });
+  }
   prefix(prefix) {
     return new RouterBuilder({
-      ...this.zz$b,
+      middlewares: [],
+      errorMap: {},
       prefix
     });
   }
-  tags(...tags) {
+  tag(...tags) {
     return new RouterBuilder({
-      ...this.zz$b,
+      middlewares: [],
+      errorMap: {},
       tags
     });
   }
-  /**
-   * Create DecoratedRouter
-   */
   router(router) {
-    return new RouterBuilder(this.zz$b).router(router);
+    return router;
+  }
+  lazy(loader) {
+    return decorateLazy(flatLazy(lazy(loader)));
+  }
+  contract(contract) {
+    return createChainableImplementer(contract, {
+      middlewares: [],
+      inputValidationIndex: 0,
+      outputValidationIndex: 0
+    });
   }
 };
 
-// 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/procedure-utils.ts
+function call(procedure, input, ...rest) {
+  return createProcedureClient(procedure, ...rest)(input);
+}
+
+// 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 contract;
+    return { default: maybeProcedure };
+  });
+  return lazyProcedure;
 }
 
-// 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
+// src/router-client.ts
+function createRouterClient(router, ...rest) {
+  if (isProcedure(router)) {
+    const caller = createProcedureClient(router, ...rest);
+    return caller;
+  }
+  const procedureCaller = isLazy(router) ? createProcedureClient(createLazyProcedureFormAnyLazy(router), ...rest) : {};
+  const recursive = new Proxy(procedureCaller, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      const next = getRouterChild(router, key);
+      if (!next) {
+        return Reflect.get(target, key);
+      }
+      const [options] = rest;
+      return createRouterClient(next, {
+        ...options,
+        path: [...options?.path ?? [], key]
       });
     }
-  }
-  return caller;
+  });
+  return recursive;
 }
 
 // src/index.ts
-export * from "@orpc/shared/error";
-var os = new Builder();
+import { isDefinedError, ORPCError, safe, type } from "@orpc/contract";
+var os = new Builder({
+  config: {}
+});
 export {
   Builder,
+  DecoratedProcedure,
+  LAZY_LOADER_SYMBOL,
+  ORPCError,
   Procedure,
   ProcedureBuilder,
   ProcedureImplementer,
+  RouterBuilder,
   RouterImplementer,
-  assertRouterImplementation,
-  chainRouterImplementer,
-  createProcedureCaller,
-  createRouterCaller,
+  call,
+  createChainableImplementer,
+  createORPCErrorConstructorMap,
+  createProcedureClient,
+  createRouterClient,
+  decorateLazy,
   decorateMiddleware,
-  decorateProcedure,
+  deepSetLazyRouterPrefix,
+  fallbackConfig,
+  flatLazy,
+  getLazyRouterPrefix,
+  getRouterChild,
+  isDefinedError,
+  isLazy,
   isProcedure,
-  mergeContext,
+  lazy,
+  middlewareOutputFn,
   os,
-  toContractRouter
+  safe,
+  type,
+  unlazy,
+  unshiftMiddlewaresRouter
 };
 //# sourceMappingURL=index.js.map