@orpc/server 0.0.0-next.a2e4a58 → 0.0.0-next.a419c18

package/dist/index.js

@@ -1,1043 +0,0 @@
-import {
-  LAZY_LOADER_SYMBOL,
-  Procedure,
-  createORPCErrorConstructorMap,
-  createProcedureClient,
-  flatLazy,
-  getRouterChild,
-  isLazy,
-  isProcedure,
-  lazy,
-  mergeContext,
-  middlewareOutputFn,
-  unlazy
-} 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/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) {
-  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: mergeContext(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;
-    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 {
-  "~type" = "ProcedureImplementer";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  use(middleware, mapInput) {
-    const mappedMiddleware = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _ProcedureImplementer({
-      ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares, mappedMiddleware]
-    });
-  }
-  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({
-      ...this["~orpc"],
-      handler
-    });
-  }
-};
-
-// src/hidden.ts
-var ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_ROUTER_CONTRACT");
-function setRouterContract(obj, contract) {
-  return new Proxy(obj, {
-    get(target, key) {
-      if (key === ROUTER_CONTRACT_SYMBOL) {
-        return contract;
-      }
-      return Reflect.get(target, key);
-    }
-  });
-}
-function getRouterContract(obj) {
-  return obj[ROUTER_CONTRACT_SYMBOL];
-}
-var LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
-function deepSetLazyRouterPrefix(router, prefix) {
-  return new Proxy(router, {
-    get(target, key) {
-      if (key !== LAZY_ROUTER_PREFIX_SYMBOL) {
-        const val = Reflect.get(target, key);
-        if (val && (typeof val === "object" || typeof val === "function")) {
-          return deepSetLazyRouterPrefix(val, prefix);
-        }
-        return val;
-      }
-      return prefix;
-    }
-  });
-}
-function getLazyRouterPrefix(obj) {
-  return obj[LAZY_ROUTER_PREFIX_SYMBOL];
-}
-
-// src/lazy-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 {
-  "~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["~orpc"],
-      prefix: `${this["~orpc"].prefix ?? ""}${prefix}`
-    });
-  }
-  tag(...tags) {
-    return new _RouterBuilder({
-      ...this["~orpc"],
-      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]
-    });
-  }
-  router(router) {
-    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);
-    }
-    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) {
-    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: {
-          ...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: 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: 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: 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/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]
-      // FIXME: I believe we can remove `as any` here
-    });
-  }
-  route(route) {
-    return new ProcedureBuilder({
-      middlewares: [],
-      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
-      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
-      contract: new ContractProcedure2({
-        route: {
-          ...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: 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: 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: 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) {
-    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";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  use(middleware) {
-    return new _RouterImplementer({
-      ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
-    });
-  }
-  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"],
-      errorMap: {}
-    }).lazy(loader);
-    const contracted = setRouterContract(adapted, this["~orpc"].contract);
-    return contracted;
-  }
-};
-
-// 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) {
-    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;
-      }
-      if (!next) {
-        return method.bind(routerImplementer);
-      }
-      return createCallableObject(next, method.bind(routerImplementer));
-    }
-  });
-  return merged;
-}
-
-// 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({
-      ...this["~orpc"],
-      contract: new ContractProcedure3({
-        route: {
-          ...this["~orpc"].config.initialRoute,
-          ...route
-        },
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: {}
-      })
-    });
-  }
-  input(schema, example) {
-    return new ProcedureBuilderWithInput({
-      ...this["~orpc"],
-      contract: new ContractProcedure3({
-        route: this["~orpc"].config.initialRoute,
-        OutputSchema: void 0,
-        InputSchema: schema,
-        inputExample: example,
-        errorMap: {}
-      })
-    });
-  }
-  output(schema, example) {
-    return new ProcedureBuilderWithOutput({
-      ...this["~orpc"],
-      contract: new ContractProcedure3({
-        route: this["~orpc"].config.initialRoute,
-        InputSchema: void 0,
-        OutputSchema: schema,
-        outputExample: example,
-        errorMap: {}
-      })
-    });
-  }
-  handler(handler) {
-    return new DecoratedProcedure({
-      ...this["~orpc"],
-      contract: new ContractProcedure3({
-        route: this["~orpc"].config.initialRoute,
-        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 {
-  "~type" = "Builder";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  config(config) {
-    return new _Builder({
-      ...this["~orpc"],
-      config: {
-        ...this["~orpc"].config,
-        ...config
-      }
-    });
-  }
-  context() {
-    return this;
-  }
-  middleware(middleware) {
-    return decorateMiddleware(middleware);
-  }
-  errors(errors) {
-    return new BuilderWithErrors({
-      ...this["~orpc"],
-      errorMap: errors
-    });
-  }
-  use(middleware) {
-    return 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
-    });
-  }
-  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: 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: 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: this["~orpc"].config.initialRoute,
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: {}
-      }),
-      handler
-    });
-  }
-  prefix(prefix) {
-    return new RouterBuilder({
-      middlewares: [],
-      errorMap: {},
-      prefix
-    });
-  }
-  tag(...tags) {
-    return new RouterBuilder({
-      middlewares: [],
-      errorMap: {},
-      tags
-    });
-  }
-  router(router) {
-    return new RouterBuilder({
-      middlewares: [],
-      errorMap: []
-    }).router(router);
-  }
-  lazy(loader) {
-    return new RouterBuilder({
-      middlewares: [],
-      errorMap: {}
-    }).lazy(loader);
-  }
-  contract(contract) {
-    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(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 recursive;
-}
-
-// src/index.ts
-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,
-  call,
-  createChainableImplementer,
-  createORPCErrorConstructorMap,
-  createProcedureClient,
-  createRouterClient,
-  decorateLazy,
-  decorateMiddleware,
-  deepSetLazyRouterPrefix,
-  fallbackConfig,
-  flatLazy,
-  getLazyRouterPrefix,
-  getRouterChild,
-  getRouterContract,
-  isDefinedError,
-  isLazy,
-  isProcedure,
-  lazy,
-  mergeContext,
-  middlewareOutputFn,
-  os,
-  safe,
-  setRouterContract,
-  type,
-  unlazy
-};
-//# sourceMappingURL=index.js.map