@orpc/server 0.0.0-next.44bdf93 → 0.0.0-next.47e44e3

package/dist/index.js

@@ -1,32 +1,42 @@
 import {
   LAZY_LOADER_SYMBOL,
   Procedure,
-  createORPCErrorConstructorMap,
+  adaptRouter,
+  addMiddleware,
+  convertPathToHttpPath,
+  createAccessibleLazyRouter,
+  createContractedProcedure,
+  createLazyProcedureFormAnyLazy,
   createProcedureClient,
+  deepSetLazyRouterPrefix,
+  eachAllContractProcedure,
+  eachContractProcedure,
   flatLazy,
+  getLazyRouterPrefix,
   getRouterChild,
+  getRouterContract,
   isLazy,
   isProcedure,
   lazy,
-  mergeContext,
   middlewareOutputFn,
+  setRouterContract,
   unlazy
-} from "./chunk-GK2Z6B6W.js";
+} from "./chunk-MHVECKBC.js";
 
 // src/builder.ts
-import { ContractProcedure as ContractProcedure4 } from "@orpc/contract";
-
-// src/builder-with-errors.ts
-import { ContractProcedure as ContractProcedure2 } from "@orpc/contract";
+import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } 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/config.ts
+var DEFAULT_CONFIG = {
+  initialInputValidationIndex: 0,
+  initialOutputValidationIndex: 0
+};
+function fallbackConfig(key, value) {
+  if (value === void 0) {
+    return DEFAULT_CONFIG[key];
+  }
+  return value;
+}
 
 // src/middleware-decorated.ts
 function decorateMiddleware(middleware) {
@@ -40,10 +50,14 @@ function decorateMiddleware(middleware) {
   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);
+      const merged = middleware({
+        ...options,
+        next: (...[nextOptions1]) => mapped({
+          ...options,
+          context: { ...options.context, ...nextOptions1?.context },
+          next: (...[nextOptions2]) => options.next({ context: { ...nextOptions1?.context, ...nextOptions2?.context } })
+        }, input, output, ...rest)
+      }, input, output, ...rest);
       return merged;
     });
     return concatted;
@@ -52,64 +66,31 @@ function decorateMiddleware(middleware) {
 }
 
 // src/procedure-decorated.ts
-import { DecoratedContractProcedure } from "@orpc/contract";
+import { mergeErrorMap, mergeMeta, mergeRoute } 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)
+      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+  meta(meta) {
     return new _DecoratedProcedure({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares, middleware_]
+      meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
-  unshiftTag(...tags) {
+  route(route) {
     return new _DecoratedProcedure({
       ...this["~orpc"],
-      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).unshiftTag(...tags)
+      route: mergeRoute(this["~orpc"].route, route)
     });
   }
-  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;
+  use(middleware, mapInput) {
+    const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
     return new _DecoratedProcedure({
       ...this["~orpc"],
-      inputValidationIndex: this["~orpc"].inputValidationIndex + numNewMiddlewares,
-      outputValidationIndex: this["~orpc"].outputValidationIndex + numNewMiddlewares,
-      middlewares: castedMiddlewares
+      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
     });
   }
   /**
@@ -129,796 +110,230 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
   }
 };
 
-// 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";
+// src/builder.ts
+var Builder = class _Builder {
   "~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({
+  /**
+   * Reset config
+   */
+  $config(config) {
+    const inputValidationCount = this["~orpc"].inputValidationIndex - fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex);
+    const outputValidationCount = this["~orpc"].outputValidationIndex - fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex);
+    return new _Builder({
       ...this["~orpc"],
-      contract: new ContractProcedureBuilder(this["~orpc"].contract["~orpc"]).input(schema, example)
+      config,
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", config.initialInputValidationIndex) + inputValidationCount,
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config.initialOutputValidationIndex) + outputValidationCount
     });
   }
-  output(schema, example) {
-    return new ProcedureBuilderWithOutput({
+  /**
+   * Reset initial context
+   */
+  $context() {
+    return new _Builder({
       ...this["~orpc"],
-      contract: new ContractProcedureBuilder(this["~orpc"].contract["~orpc"]).output(schema, example)
+      middlewares: [],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex)
     });
   }
-  handler(handler) {
-    return new DecoratedProcedure({
+  /**
+   * Reset initial meta
+   */
+  $meta(initialMeta) {
+    return new _Builder({
       ...this["~orpc"],
-      handler
+      meta: initialMeta
     });
   }
-};
-
-// 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({
+  /**
+   * Reset initial route
+   */
+  $route(initialRoute) {
+    return new _Builder({
       ...this["~orpc"],
-      prefix: `${this["~orpc"].prefix ?? ""}${prefix}`
+      route: initialRoute
     });
   }
-  tag(...tags) {
-    return new _RouterBuilder({
-      ...this["~orpc"],
-      tags: [...this["~orpc"].tags ?? [], ...tags]
-    });
+  middleware(middleware) {
+    return decorateMiddleware(middleware);
   }
   errors(errors) {
-    return new _RouterBuilder({
-      ...this["~orpc"],
-      errorMap: {
-        ...this["~orpc"].errorMap,
-        ...errors
-      }
-    });
-  }
-  use(middleware) {
-    return new _RouterBuilder({
+    return new _Builder({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares, middleware]
+      errorMap: mergeErrorMap2(this["~orpc"].errorMap, errors)
     });
   }
-  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({
+  use(middleware, mapInput) {
+    const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+    return new _Builder({
       ...this["~orpc"],
-      errorMap: {
-        ...this["~orpc"].errorMap,
-        ...errors
-      }
+      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
     });
   }
-  use(middleware) {
-    return new _BuilderWithErrorsMiddlewares({
+  meta(meta) {
+    return new _Builder({
       ...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
+      meta: mergeMeta2(this["~orpc"].meta, meta)
     });
   }
   route(route) {
-    return new ProcedureBuilder({
+    return new _Builder({
       ...this["~orpc"],
-      contract: new ContractProcedure({
-        route,
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: this["~orpc"].errorMap
-      })
+      route: mergeRoute2(this["~orpc"].route, route)
     });
   }
-  input(schema, example) {
-    return new ProcedureBuilderWithInput({
+  input(schema) {
+    return new _Builder({
       ...this["~orpc"],
-      contract: new ContractProcedure({
-        OutputSchema: void 0,
-        InputSchema: schema,
-        inputExample: example,
-        errorMap: this["~orpc"].errorMap
-      })
+      inputSchema: schema,
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex) + this["~orpc"].middlewares.length
     });
   }
-  output(schema, example) {
-    return new ProcedureBuilderWithOutput({
+  output(schema) {
+    return new _Builder({
       ...this["~orpc"],
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: schema,
-        outputExample: example,
-        errorMap: this["~orpc"].errorMap
-      })
+      outputSchema: schema,
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + this["~orpc"].middlewares.length
     });
   }
   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({
+    return new _Builder({
       ...this["~orpc"],
-      prefix
+      prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
   }
   tag(...tags) {
-    return new RouterBuilder({
+    return new _Builder({
       ...this["~orpc"],
-      tags
+      tags: mergeTags(this["~orpc"].tags, tags)
     });
   }
   router(router) {
-    return new RouterBuilder(this["~orpc"]).router(router);
+    return adaptRouter(router, this["~orpc"]);
   }
   lazy(loader) {
-    return new RouterBuilder(this["~orpc"]).lazy(loader);
+    return adaptRouter(flatLazy(lazy(loader)), this["~orpc"]);
   }
 };
+var os = new Builder({
+  config: {},
+  route: {},
+  meta: {},
+  errorMap: {},
+  inputSchema: void 0,
+  outputSchema: void 0,
+  inputValidationIndex: fallbackConfig("initialInputValidationIndex"),
+  outputValidationIndex: fallbackConfig("initialOutputValidationIndex"),
+  middlewares: []
+});
 
-// 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/context.ts
+function mergeContext(context, other) {
+  return { ...context, ...other };
+}
 
-// src/implementer-chainable.ts
+// src/implementer.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) {
+function implementerInternal(contract, config, middlewares) {
   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 impl2 = new Builder({
+      ...contract["~orpc"],
+      config,
+      middlewares,
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", config?.initialInputValidationIndex) + middlewares.length,
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config?.initialOutputValidationIndex) + middlewares.length
+    });
+    return impl2;
+  }
+  const impl = new Proxy(contract, {
+    get: (target, key) => {
+      let method;
+      if (key === "middleware") {
+        method = (mid) => decorateMiddleware(mid);
+      } else if (key === "use") {
+        method = (mid) => {
+          return implementerInternal(
+            contract,
+            config,
+            addMiddleware(middlewares, mid)
+          );
+        };
+      } else if (key === "router") {
+        method = (router) => {
+          const adapted = adaptRouter(router, {
+            middlewares,
+            errorMap: {}
+          });
+          return setRouterContract(adapted, contract);
+        };
+      } else if (key === "lazy") {
+        method = (loader) => {
+          const adapted = adaptRouter(flatLazy(lazy(loader)), {
+            middlewares,
+            errorMap: {}
+          });
+          return setRouterContract(adapted, contract);
+        };
+      }
+      const next = Reflect.get(target, key);
+      if (!next || typeof next !== "function" && typeof next !== "object") {
+        return method ?? next;
+      }
+      const nextImpl = implementerInternal(next, config, middlewares);
+      if (method) {
+        return new Proxy(method, {
+          get(_, key2) {
+            return Reflect.get(nextImpl, key2);
+          }
+        });
+      }
+      return nextImpl;
+    }
   });
-  const merged = new Proxy(chainable, {
-    get(target, key) {
+  return impl;
+}
+function implement(contract, config = {}) {
+  const implInternal = implementerInternal(contract, config, []);
+  const impl = new Proxy(implInternal, {
+    get: (target, key) => {
+      let method;
+      if (key === "$context") {
+        method = () => impl;
+      } else if (key === "$config") {
+        method = (config2) => implement(contract, config2);
+      }
       const next = Reflect.get(target, key);
-      const method = Reflect.get(routerImplementer, key);
-      if (typeof key !== "string" || typeof method !== "function") {
-        return next;
+      if (!next || typeof next !== "function" && typeof next !== "object") {
+        return method ?? next;
       }
-      if (!next) {
-        return method.bind(routerImplementer);
+      if (method) {
+        return new Proxy(method, {
+          get(_, key2) {
+            return Reflect.get(next, key2);
+          }
+        });
       }
-      return createCallableObject(next, method.bind(routerImplementer));
+      return next;
     }
   });
-  return merged;
+  return impl;
 }
 
-// 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,
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: {}
-      })
-    });
-  }
-  input(schema, example) {
-    return new ProcedureBuilderWithInput({
-      ...this["~orpc"],
-      contract: new ContractProcedure3({
-        OutputSchema: void 0,
-        InputSchema: schema,
-        inputExample: example,
-        errorMap: {}
-      })
-    });
-  }
-  output(schema, example) {
-    return new ProcedureBuilderWithOutput({
-      ...this["~orpc"],
-      contract: new ContractProcedure3({
-        InputSchema: void 0,
-        OutputSchema: schema,
-        outputExample: example,
-        errorMap: {}
-      })
-    });
-  }
-  handler(handler) {
-    return new DecoratedProcedure({
-      ...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 {
-  "~type" = "Builder";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  context() {
-    return this;
-  }
-  middleware(middleware) {
-    return decorateMiddleware(middleware);
-  }
-  errors(errors) {
-    return new BuilderWithErrors({
-      errorMap: errors
-    });
-  }
-  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: [],
-      inputValidationIndex: 0,
-      outputValidationIndex: 0,
-      contract: new ContractProcedure4({
-        route,
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: {}
-      })
-    });
-  }
-  input(schema, example) {
-    return new ProcedureBuilderWithInput({
-      middlewares: [],
-      inputValidationIndex: 0,
-      outputValidationIndex: 0,
-      contract: new ContractProcedure4({
-        OutputSchema: void 0,
-        InputSchema: schema,
-        inputExample: example,
-        errorMap: {}
-      })
-    });
-  }
-  output(schema, example) {
-    return new ProcedureBuilderWithOutput({
-      middlewares: [],
-      inputValidationIndex: 0,
-      outputValidationIndex: 0,
-      contract: new ContractProcedure4({
-        InputSchema: void 0,
-        OutputSchema: schema,
-        outputExample: example,
-        errorMap: {}
-      })
-    });
-  }
-  handler(handler) {
-    return new DecoratedProcedure({
-      middlewares: [],
-      inputValidationIndex: 0,
-      outputValidationIndex: 0,
-      contract: new ContractProcedure4({
-        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)) {
@@ -946,42 +361,53 @@ function createRouterClient(router, ...rest) {
 }
 
 // src/index.ts
-import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe, type } from "@orpc/contract";
-var os = new Builder({});
+import { isDefinedError, ORPCError, safe } from "@orpc/client";
+import { eventIterator, type, ValidationError } from "@orpc/contract";
+import { getEventMeta, withEventMeta } from "@orpc/server-standard";
+import { onError, onFinish, onStart, onSuccess } from "@orpc/shared";
 export {
   Builder,
   DecoratedProcedure,
   LAZY_LOADER_SYMBOL,
   ORPCError,
   Procedure,
-  ProcedureBuilder,
-  ProcedureImplementer,
-  RouterBuilder,
-  RouterImplementer,
+  ValidationError,
+  adaptRouter,
   call,
-  configGlobal,
-  createChainableImplementer,
-  createORPCErrorConstructorMap,
+  convertPathToHttpPath,
+  createAccessibleLazyRouter,
+  createContractedProcedure,
+  createLazyProcedureFormAnyLazy,
   createProcedureClient,
   createRouterClient,
-  decorateLazy,
   decorateMiddleware,
   deepSetLazyRouterPrefix,
-  fallbackToGlobalConfig,
+  eachAllContractProcedure,
+  eachContractProcedure,
+  eventIterator,
+  fallbackConfig,
   flatLazy,
+  getEventMeta,
   getLazyRouterPrefix,
   getRouterChild,
   getRouterContract,
+  implement,
+  implementerInternal,
   isDefinedError,
   isLazy,
   isProcedure,
   lazy,
   mergeContext,
   middlewareOutputFn,
+  onError,
+  onFinish,
+  onStart,
+  onSuccess,
   os,
   safe,
   setRouterContract,
   type,
-  unlazy
+  unlazy,
+  withEventMeta
 };
 //# sourceMappingURL=index.js.map