@orpc/server 0.0.0-next.4220427 → 0.0.0-next.43c0c87

package/dist/index.js

@@ -9,15 +9,24 @@ import {
   isProcedure,
   lazy,
   mergeContext,
+  middlewareOutputFn,
   unlazy
-} from "./chunk-DNG2IB3R.js";
+} from "./chunk-GK2Z6B6W.js";
 
 // src/builder.ts
+import { ContractProcedure as ContractProcedure4 } from "@orpc/contract";
+
+// src/builder-with-errors.ts
+import { ContractProcedure as ContractProcedure2 } from "@orpc/contract";
+
+// src/builder-with-errors-middlewares.ts
 import { ContractProcedure } from "@orpc/contract";
 
-// src/implementer-chainable.ts
-import { isContractProcedure } from "@orpc/contract";
-import { createCallableObject } from "@orpc/shared";
+// src/procedure-builder.ts
+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) {
@@ -44,58 +53,81 @@ function decorateMiddleware(middleware) {
 
 // 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) => {
+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 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) {
+    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 < procedure["~orpc"].middlewares.length; i++) {
-        const index = middlewares.indexOf(procedure["~orpc"].middlewares[i], min);
+      for (let i = 0; i < this["~orpc"].middlewares.length; i++) {
+        const index = castedMiddlewares.indexOf(this["~orpc"].middlewares[i], min);
         if (index === -1) {
-          middlewares.push(...procedure["~orpc"].middlewares.slice(i));
+          castedMiddlewares.push(...this["~orpc"].middlewares.slice(i));
           break;
         }
         min = index + 1;
       }
     }
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      middlewares
-    }));
-  };
-  return decorated;
-}
+    const numNewMiddlewares = castedMiddlewares.length - this["~orpc"].middlewares.length;
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      inputValidationIndex: this["~orpc"].inputValidationIndex + numNewMiddlewares,
+      outputValidationIndex: this["~orpc"].outputValidationIndex + numNewMiddlewares,
+      middlewares: castedMiddlewares
+    });
+  }
+  /**
+   * 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 {
@@ -108,15 +140,143 @@ var ProcedureImplementer = class _ProcedureImplementer {
     const mappedMiddleware = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
     return new _ProcedureImplementer({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], mappedMiddleware]
+      middlewares: [...this["~orpc"].middlewares, mappedMiddleware]
     });
   }
   handler(handler) {
-    return decorateProcedure(new Procedure({
-      middlewares: this["~orpc"].middlewares,
-      contract: this["~orpc"].contract,
+    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) {
+    return new _ProcedureBuilderWithOutput({
+      ...this["~orpc"],
+      inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
+      middlewares: [...this["~orpc"].middlewares, middleware]
+    });
+  }
+  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 {
+  "~type" = "ProcedureBuilder";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  errors(errors) {
+    return new _ProcedureBuilder({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure4.decorate(this["~orpc"].contract).errors(errors)
+    });
+  }
+  route(route) {
+    return new _ProcedureBuilder({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure4.decorate(this["~orpc"].contract).route(route)
+    });
+  }
+  use(middleware) {
+    return new _ProcedureBuilder({
+      ...this["~orpc"],
+      inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
+      outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
+      middlewares: [...this["~orpc"].middlewares, middleware]
+    });
+  }
+  input(schema, example) {
+    return new ProcedureBuilderWithInput({
+      ...this["~orpc"],
+      contract: new ContractProcedureBuilder(this["~orpc"].contract["~orpc"]).input(schema, example)
+    });
+  }
+  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
+    });
   }
 };
 
@@ -154,31 +314,10 @@ 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, {
+  const recursive = new Proxy(flattenLazy, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
@@ -215,10 +354,19 @@ var RouterBuilder = class _RouterBuilder {
       tags: [...this["~orpc"].tags ?? [], ...tags]
     });
   }
+  errors(errors) {
+    return new _RouterBuilder({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
   use(middleware) {
     return new _RouterBuilder({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
+      middlewares: [...this["~orpc"].middlewares, middleware]
     });
   }
   router(router) {
@@ -245,7 +393,7 @@ function adapt(item, options) {
     return adaptedLazy;
   }
   if (isProcedure(item)) {
-    let decorated = decorateProcedure(item);
+    let decorated = DecoratedProcedure.decorate(item);
     if (options.tags?.length) {
       decorated = decorated.unshiftTag(...options.tags);
     }
@@ -255,6 +403,9 @@ function adapt(item, options) {
     if (options.middlewares?.length) {
       decorated = decorated.unshiftMiddleware(...options.middlewares);
     }
+    if (Object.keys(options.errorMap).length) {
+      decorated = decorated.errors(options.errorMap);
+    }
     return decorated;
   }
   const adapted = {};
@@ -264,6 +415,213 @@ function adapt(item, 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) {
+    return new _BuilderWithErrorsMiddlewares({
+      ...this["~orpc"],
+      inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
+      outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
+      middlewares: [...this["~orpc"].middlewares, middleware]
+      // FIXME: I believe we can remove `as any` here
+    });
+  }
+  route(route) {
+    return new ProcedureBuilder({
+      ...this["~orpc"],
+      contract: new ContractProcedure({
+        route,
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: this["~orpc"].errorMap
+      })
+    });
+  }
+  input(schema, example) {
+    return new ProcedureBuilderWithInput({
+      ...this["~orpc"],
+      contract: new ContractProcedure({
+        OutputSchema: void 0,
+        InputSchema: schema,
+        inputExample: example,
+        errorMap: this["~orpc"].errorMap
+      })
+    });
+  }
+  output(schema, example) {
+    return new ProcedureBuilderWithOutput({
+      ...this["~orpc"],
+      contract: new ContractProcedure({
+        InputSchema: void 0,
+        OutputSchema: schema,
+        outputExample: example,
+        errorMap: this["~orpc"].errorMap
+      })
+    });
+  }
+  handler(handler) {
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      contract: new ContractProcedure({
+        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/builder-with-errors.ts
+var BuilderWithErrors = class _BuilderWithErrors {
+  "~type" = "BuilderWithErrors";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  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: 1,
+      outputValidationIndex: 1,
+      middlewares: [middleware]
+      // FIXME: I believe we can remove `as any` here
+    });
+  }
+  route(route) {
+    return new ProcedureBuilder({
+      middlewares: [],
+      inputValidationIndex: 0,
+      outputValidationIndex: 0,
+      contract: new ContractProcedure2({
+        route,
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: this["~orpc"].errorMap
+      })
+    });
+  }
+  input(schema, example) {
+    return new ProcedureBuilderWithInput({
+      middlewares: [],
+      inputValidationIndex: 0,
+      outputValidationIndex: 0,
+      contract: new ContractProcedure2({
+        OutputSchema: void 0,
+        InputSchema: schema,
+        inputExample: example,
+        errorMap: this["~orpc"].errorMap
+      })
+    });
+  }
+  output(schema, example) {
+    return new ProcedureBuilderWithOutput({
+      middlewares: [],
+      inputValidationIndex: 0,
+      outputValidationIndex: 0,
+      contract: new ContractProcedure2({
+        InputSchema: void 0,
+        OutputSchema: schema,
+        outputExample: example,
+        errorMap: this["~orpc"].errorMap
+      })
+    });
+  }
+  handler(handler) {
+    return new DecoratedProcedure({
+      middlewares: [],
+      inputValidationIndex: 0,
+      outputValidationIndex: 0,
+      contract: new ContractProcedure2({
+        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) {
+    return new RouterBuilder({
+      middlewares: [],
+      ...this["~orpc"]
+    }).router(router);
+  }
+  lazy(loader) {
+    return new RouterBuilder({
+      middlewares: [],
+      ...this["~orpc"]
+    }).lazy(loader);
+  }
+};
+
+// src/builder-with-middlewares.ts
+import { ContractProcedure as ContractProcedure3 } from "@orpc/contract";
+
+// src/implementer-chainable.ts
+import { isContractProcedure } from "@orpc/contract";
+import { createCallableObject } from "@orpc/shared";
+
 // src/router-implementer.ts
 var RouterImplementer = class _RouterImplementer {
   "~type" = "RouterImplementer";
@@ -278,31 +636,42 @@ var RouterImplementer = class _RouterImplementer {
     });
   }
   router(router) {
-    const adapted = new RouterBuilder(this["~orpc"]).router(router);
+    const adapted = new RouterBuilder({
+      ...this["~orpc"],
+      errorMap: {}
+    }).router(router);
     const contracted = setRouterContract(adapted, this["~orpc"].contract);
     return contracted;
   }
   lazy(loader) {
-    const adapted = new RouterBuilder(this["~orpc"]).lazy(loader);
+    const adapted = new RouterBuilder({
+      ...this["~orpc"],
+      errorMap: {}
+    }).lazy(loader);
     const contracted = setRouterContract(adapted, this["~orpc"].contract);
     return contracted;
   }
 };
 
 // src/implementer-chainable.ts
-function createChainableImplementer(contract, middlewares) {
+function createChainableImplementer(contract, options) {
   if (isContractProcedure(contract)) {
     const implementer = new ProcedureImplementer({
       contract,
-      middlewares
+      middlewares: options.middlewares,
+      inputValidationIndex: options.inputValidationIndex,
+      outputValidationIndex: options.outputValidationIndex
     });
     return implementer;
   }
   const chainable = {};
   for (const key in contract) {
-    chainable[key] = createChainableImplementer(contract[key], middlewares);
+    chainable[key] = createChainableImplementer(contract[key], options);
   }
-  const routerImplementer = new RouterImplementer({ contract, middlewares });
+  const routerImplementer = new RouterImplementer({
+    contract,
+    middlewares: options.middlewares
+  });
   const merged = new Proxy(chainable, {
     get(target, key) {
       const next = Reflect.get(target, key);
@@ -319,187 +688,257 @@ function createChainableImplementer(contract, middlewares) {
   return merged;
 }
 
-// src/procedure-builder.ts
-import {
-  DecoratedContractProcedure as DecoratedContractProcedure2
-} from "@orpc/contract";
-var ProcedureBuilder = class _ProcedureBuilder {
-  "~type" = "ProcedureBuilder";
+// src/builder-with-middlewares.ts
+var BuilderWithMiddlewares = class _BuilderWithMiddlewares {
+  "~type" = "BuilderHasMiddlewares";
   "~orpc";
   constructor(def) {
     this["~orpc"] = def;
   }
+  use(middleware) {
+    return new _BuilderWithMiddlewares({
+      ...this["~orpc"],
+      inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
+      outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
+      middlewares: [...this["~orpc"].middlewares, middleware]
+    });
+  }
+  errors(errors) {
+    return new BuilderWithErrorsMiddlewares({
+      ...this["~orpc"],
+      errorMap: errors
+    });
+  }
   route(route) {
-    return new _ProcedureBuilder({
+    return new ProcedureBuilder({
       ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).route(route)
+      contract: new ContractProcedure3({
+        route,
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: {}
+      })
     });
   }
   input(schema, example) {
-    return new _ProcedureBuilder({
+    return new ProcedureBuilderWithInput({
       ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).input(schema, example)
+      contract: new ContractProcedure3({
+        OutputSchema: void 0,
+        InputSchema: schema,
+        inputExample: example,
+        errorMap: {}
+      })
     });
   }
   output(schema, example) {
-    return new _ProcedureBuilder({
+    return new ProcedureBuilderWithOutput({
       ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).output(schema, example)
+      contract: new ContractProcedure3({
+        InputSchema: void 0,
+        OutputSchema: schema,
+        outputExample: example,
+        errorMap: {}
+      })
     });
   }
-  errors(errors) {
-    return new _ProcedureBuilder({
+  handler(handler) {
+    return new DecoratedProcedure({
       ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).errors(errors)
+      contract: new ContractProcedure3({
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: {}
+      }),
+      handler
     });
   }
-  use(middleware, mapInput) {
-    if (!mapInput) {
-      return new ProcedureImplementer({
-        contract: this["~orpc"].contract,
-        middlewares: this["~orpc"].middlewares
-      }).use(middleware);
-    }
-    return new ProcedureImplementer({
-      contract: this["~orpc"].contract,
-      middlewares: this["~orpc"].middlewares
-    }).use(middleware, mapInput);
+  prefix(prefix) {
+    return new RouterBuilder({
+      middlewares: this["~orpc"].middlewares,
+      errorMap: {},
+      prefix
+    });
   }
-  handler(handler) {
-    return decorateProcedure(new Procedure({
+  tag(...tags) {
+    return new RouterBuilder({
       middlewares: this["~orpc"].middlewares,
-      contract: this["~orpc"].contract,
-      handler
-    }));
+      errorMap: {},
+      tags
+    });
+  }
+  router(router) {
+    return new RouterBuilder({
+      errorMap: {},
+      ...this["~orpc"]
+    }).router(router);
+  }
+  lazy(loader) {
+    return new RouterBuilder({
+      errorMap: {},
+      ...this["~orpc"]
+    }).lazy(loader);
+  }
+  contract(contract) {
+    return createChainableImplementer(contract, this["~orpc"]);
   }
 };
 
 // src/builder.ts
-var Builder = class _Builder {
+var Builder = class {
   "~type" = "Builder";
   "~orpc";
   constructor(def) {
     this["~orpc"] = def;
   }
   context() {
-    return new _Builder({});
+    return this;
+  }
+  middleware(middleware) {
+    return decorateMiddleware(middleware);
+  }
+  errors(errors) {
+    return new BuilderWithErrors({
+      errorMap: errors
+    });
   }
   use(middleware) {
-    return new _Builder({
+    return new BuilderWithMiddlewares({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
+      inputValidationIndex: 1,
+      outputValidationIndex: 1,
+      middlewares: [middleware]
+      // FIXME: I believe we can remove `as any` here
     });
   }
-  middleware(middleware) {
-    return decorateMiddleware(middleware);
-  }
   route(route) {
     return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
+      middlewares: [],
+      inputValidationIndex: 0,
+      outputValidationIndex: 0,
+      contract: new ContractProcedure4({
         route,
         InputSchema: void 0,
         OutputSchema: void 0,
-        errorMap: void 0
+        errorMap: {}
       })
     });
   }
   input(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
+    return new ProcedureBuilderWithInput({
+      middlewares: [],
+      inputValidationIndex: 0,
+      outputValidationIndex: 0,
+      contract: new ContractProcedure4({
         OutputSchema: void 0,
         InputSchema: schema,
         inputExample: example,
-        errorMap: void 0
+        errorMap: {}
       })
     });
   }
   output(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
+    return new ProcedureBuilderWithOutput({
+      middlewares: [],
+      inputValidationIndex: 0,
+      outputValidationIndex: 0,
+      contract: new ContractProcedure4({
         InputSchema: void 0,
         OutputSchema: schema,
         outputExample: example,
-        errorMap: void 0
-      })
-    });
-  }
-  errors(errors) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: errors
+        errorMap: {}
       })
     });
   }
   handler(handler) {
-    return decorateProcedure(new Procedure({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
+    return new DecoratedProcedure({
+      middlewares: [],
+      inputValidationIndex: 0,
+      outputValidationIndex: 0,
+      contract: new ContractProcedure4({
         InputSchema: void 0,
         OutputSchema: void 0,
-        errorMap: void 0
+        errorMap: {}
       }),
       handler
-    }));
+    });
   }
   prefix(prefix) {
     return new RouterBuilder({
-      middlewares: this["~orpc"].middlewares,
+      middlewares: [],
+      errorMap: {},
       prefix
     });
   }
   tag(...tags) {
     return new RouterBuilder({
-      middlewares: this["~orpc"].middlewares,
+      middlewares: [],
+      errorMap: {},
       tags
     });
   }
   router(router) {
-    return new RouterBuilder(this["~orpc"]).router(router);
+    return new RouterBuilder({
+      middlewares: [],
+      errorMap: []
+    }).router(router);
   }
   lazy(loader) {
-    return new RouterBuilder(this["~orpc"]).lazy(loader);
+    return new RouterBuilder({
+      middlewares: [],
+      errorMap: {}
+    }).lazy(loader);
   }
   contract(contract) {
-    return createChainableImplementer(contract, this["~orpc"].middlewares);
+    return createChainableImplementer(contract, {
+      middlewares: [],
+      inputValidationIndex: 0,
+      outputValidationIndex: 0
+    });
   }
 };
 
+// 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 { default: maybeProcedure };
+  });
+  return lazyProcedure;
+}
+
 // src/router-client.ts
-function createRouterClient(options) {
-  if (isProcedure(options.router)) {
-    const caller = createProcedureClient({
-      ...options,
-      procedure: options.router,
-      context: options.context,
-      path: options.path
-    });
+function createRouterClient(router, ...rest) {
+  if (isProcedure(router)) {
+    const caller = createProcedureClient(router, ...rest);
     return caller;
   }
-  const procedureCaller = isLazy(options.router) ? createProcedureClient({
-    ...options,
-    procedure: createLazyProcedureFormAnyLazy(options.router),
-    context: options.context,
-    path: options.path
-  }) : {};
+  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(options.router, key);
+      const next = getRouterChild(router, key);
       if (!next) {
         return Reflect.get(target, key);
       }
-      return createRouterClient({
+      const [options] = rest;
+      return createRouterClient(next, {
         ...options,
-        router: next,
-        path: [...options.path ?? [], key]
+        path: [...options?.path ?? [], key]
       });
     }
   });
@@ -511,6 +950,7 @@ import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe }
 var os = new Builder({});
 export {
   Builder,
+  DecoratedProcedure,
   LAZY_LOADER_SYMBOL,
   ORPCError,
   Procedure,
@@ -518,6 +958,7 @@ export {
   ProcedureImplementer,
   RouterBuilder,
   RouterImplementer,
+  call,
   configGlobal,
   createChainableImplementer,
   createORPCErrorConstructorMap,
@@ -525,7 +966,6 @@ export {
   createRouterClient,
   decorateLazy,
   decorateMiddleware,
-  decorateProcedure,
   deepSetLazyRouterPrefix,
   fallbackToGlobalConfig,
   flatLazy,
@@ -537,6 +977,7 @@ export {
   isProcedure,
   lazy,
   mergeContext,
+  middlewareOutputFn,
   os,
   safe,
   setRouterContract,