@orpc/server 0.30.0 → 0.31.0

package/dist/index.js

@@ -11,14 +11,22 @@ import {
   mergeContext,
   middlewareOutputFn,
   unlazy
-} from "./chunk-SA7HGGVY.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 as createCallableObject2 } 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) {
@@ -45,7 +53,6 @@ function decorateMiddleware(middleware) {
 
 // src/procedure-decorated.ts
 import { DecoratedContractProcedure } from "@orpc/contract";
-import { createCallableObject } from "@orpc/shared";
 var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
   static decorate(procedure) {
     if (procedure instanceof _DecoratedProcedure) {
@@ -75,7 +82,7 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
     const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
     return new _DecoratedProcedure({
       ...this["~orpc"],
-      postMiddlewares: [...this["~orpc"].postMiddlewares, middleware_]
+      middlewares: [...this["~orpc"].middlewares, middleware_]
     });
   }
   unshiftTag(...tags) {
@@ -86,32 +93,36 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
   }
   unshiftMiddleware(...middlewares) {
     const castedMiddlewares = middlewares;
-    if (this["~orpc"].preMiddlewares.length) {
+    if (this["~orpc"].middlewares.length) {
       let min = 0;
-      for (let i = 0; i < this["~orpc"].preMiddlewares.length; i++) {
-        const index = castedMiddlewares.indexOf(this["~orpc"].preMiddlewares[i], min);
+      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"].preMiddlewares.slice(i));
+          castedMiddlewares.push(...this["~orpc"].middlewares.slice(i));
           break;
         }
         min = index + 1;
       }
     }
+    const numNewMiddlewares = castedMiddlewares.length - this["~orpc"].middlewares.length;
     return new _DecoratedProcedure({
       ...this["~orpc"],
-      preMiddlewares: castedMiddlewares
+      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).
-   * **Note**: this only takes effect when this method is called at the end of the chain.
    */
   callable(...rest) {
-    return createCallableObject(this, createProcedureClient(this, ...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).
-   * **Note**: this only takes effect when this method is called at the end of the chain.
    */
   actionable(...rest) {
     return this.callable(...rest);
@@ -129,14 +140,141 @@ var ProcedureImplementer = class _ProcedureImplementer {
     const mappedMiddleware = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
     return new _ProcedureImplementer({
       ...this["~orpc"],
-      postMiddlewares: [...this["~orpc"].postMiddlewares, mappedMiddleware]
+      middlewares: [...this["~orpc"].middlewares, mappedMiddleware]
+    });
+  }
+  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) {
+    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({
-      postMiddlewares: this["~orpc"].postMiddlewares,
-      preMiddlewares: this["~orpc"].preMiddlewares,
-      contract: this["~orpc"].contract,
+      ...this["~orpc"],
       handler
     });
   }
@@ -277,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";
@@ -309,20 +654,24 @@ var RouterImplementer = class _RouterImplementer {
 };
 
 // src/implementer-chainable.ts
-function createChainableImplementer(contract, middlewares = []) {
+function createChainableImplementer(contract, options) {
   if (isContractProcedure(contract)) {
     const implementer = new ProcedureImplementer({
       contract,
-      preMiddlewares: middlewares,
-      postMiddlewares: []
+      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);
@@ -333,170 +682,219 @@ function createChainableImplementer(contract, middlewares = []) {
       if (!next) {
         return method.bind(routerImplementer);
       }
-      return createCallableObject2(next, 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 {
-  "~type" = "ProcedureBuilder";
+// src/builder-with-middlewares.ts
+var BuilderWithMiddlewares = class _BuilderWithMiddlewares {
+  "~type" = "BuilderHasMiddlewares";
   "~orpc";
   constructor(def) {
     this["~orpc"] = def;
   }
-  route(route) {
-    return new _ProcedureBuilder({
+  use(middleware) {
+    return new _BuilderWithMiddlewares({
       ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).route(route)
+      inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
+      outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
+      middlewares: [...this["~orpc"].middlewares, middleware]
     });
   }
-  input(schema, example) {
-    return new _ProcedureBuilder({
+  errors(errors) {
+    return new BuilderWithErrorsMiddlewares({
       ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).input(schema, example)
+      errorMap: errors
     });
   }
-  output(schema, example) {
-    return new _ProcedureBuilder({
+  route(route) {
+    return new ProcedureBuilder({
       ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).output(schema, example)
+      contract: new ContractProcedure3({
+        route,
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: {}
+      })
     });
   }
-  errors(errors) {
-    return new _ProcedureBuilder({
+  input(schema, example) {
+    return new ProcedureBuilderWithInput({
       ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).errors(errors)
+      contract: new ContractProcedure3({
+        OutputSchema: void 0,
+        InputSchema: schema,
+        inputExample: example,
+        errorMap: {}
+      })
     });
   }
-  use(middleware, mapInput) {
-    if (!mapInput) {
-      return new ProcedureImplementer({
-        contract: this["~orpc"].contract,
-        preMiddlewares: this["~orpc"].middlewares,
-        postMiddlewares: []
-      }).use(middleware);
-    }
-    return new ProcedureImplementer({
-      contract: this["~orpc"].contract,
-      preMiddlewares: this["~orpc"].middlewares,
-      postMiddlewares: []
-    }).use(middleware, mapInput);
+  output(schema, example) {
+    return new ProcedureBuilderWithOutput({
+      ...this["~orpc"],
+      contract: new ContractProcedure3({
+        InputSchema: void 0,
+        OutputSchema: schema,
+        outputExample: example,
+        errorMap: {}
+      })
+    });
   }
   handler(handler) {
     return new DecoratedProcedure({
-      preMiddlewares: this["~orpc"].middlewares,
-      postMiddlewares: [],
-      contract: this["~orpc"].contract,
+      ...this["~orpc"],
+      contract: new ContractProcedure3({
+        InputSchema: void 0,
+        OutputSchema: void 0,
+        errorMap: {}
+      }),
       handler
     });
   }
+  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 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;
   }
-  // TODO: separate it
   context() {
-    return new _Builder({
-      middlewares: [],
-      errorMap: {}
-    });
+    return this;
   }
-  use(middleware) {
-    return new _Builder({
-      ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares, middleware]
-    });
+  middleware(middleware) {
+    return decorateMiddleware(middleware);
   }
   errors(errors) {
-    return new _Builder({
-      ...this["~orpc"],
-      errorMap: {
-        ...this["~orpc"].errorMap,
-        ...errors
-      }
+    return new BuilderWithErrors({
+      errorMap: errors
     });
   }
-  // TODO: not allow define middleware after has context, or anything else
-  middleware(middleware) {
-    return decorateMiddleware(middleware);
+  use(middleware) {
+    return new BuilderWithMiddlewares({
+      ...this["~orpc"],
+      inputValidationIndex: 1,
+      outputValidationIndex: 1,
+      middlewares: [middleware]
+      // FIXME: I believe we can remove `as any` here
+    });
   }
   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: this["~orpc"].errorMap
+        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: this["~orpc"].errorMap
+        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: this["~orpc"].errorMap
+        errorMap: {}
       })
     });
   }
   handler(handler) {
     return new DecoratedProcedure({
-      preMiddlewares: this["~orpc"].middlewares,
-      postMiddlewares: [],
-      contract: new ContractProcedure({
+      middlewares: [],
+      inputValidationIndex: 0,
+      outputValidationIndex: 0,
+      contract: new ContractProcedure4({
         InputSchema: void 0,
         OutputSchema: void 0,
-        errorMap: this["~orpc"].errorMap
+        errorMap: {}
       }),
       handler
     });
   }
   prefix(prefix) {
     return new RouterBuilder({
-      middlewares: this["~orpc"].middlewares,
-      errorMap: this["~orpc"].errorMap,
+      middlewares: [],
+      errorMap: {},
       prefix
     });
   }
   tag(...tags) {
     return new RouterBuilder({
-      middlewares: this["~orpc"].middlewares,
-      errorMap: this["~orpc"].errorMap,
+      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
+    });
   }
 };
 
@@ -548,11 +946,8 @@ function createRouterClient(router, ...rest) {
 }
 
 // src/index.ts
-import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe } from "@orpc/contract";
-var os = new Builder({
-  middlewares: [],
-  errorMap: {}
-});
+import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe, type } from "@orpc/contract";
+var os = new Builder({});
 export {
   Builder,
   DecoratedProcedure,
@@ -586,6 +981,7 @@ export {
   os,
   safe,
   setRouterContract,
+  type,
   unlazy
 };
 //# sourceMappingURL=index.js.map