@orpc/server 0.0.0-next.9b3a030 → 0.0.0-next.9fe2a8b

package/dist/index.js

@@ -1,23 +1,38 @@
 import {
   LAZY_LOADER_SYMBOL,
   Procedure,
-  createORPCErrorConstructorMap,
+  adaptRouter,
+  addMiddleware,
+  createAccessibleLazyRouter,
+  createLazyProcedureFormAnyLazy,
   createProcedureClient,
+  deepSetLazyRouterPrefix,
   flatLazy,
+  getLazyRouterPrefix,
   getRouterChild,
+  getRouterContract,
   isLazy,
   isProcedure,
   lazy,
-  mergeContext,
+  middlewareOutputFn,
+  setRouterContract,
   unlazy
-} from "./chunk-DNG2IB3R.js";
+} from "./chunk-KK4SDLC7.js";
 
 // src/builder.ts
-import { ContractProcedure } from "@orpc/contract";
+import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";
 
-// src/implementer-chainable.ts
-import { isContractProcedure } from "@orpc/contract";
-import { createCallableObject } from "@orpc/shared";
+// 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) {
@@ -31,8 +46,8 @@ 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 next = async (...[nextOptions]) => {
+        return mapped({ ...options, context: { ...nextOptions?.context, ...options.context } }, input, output, ...rest);
       };
       const merged = middleware({ ...options, next }, input, output, ...rest);
       return merged;
@@ -43,463 +58,294 @@ 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) => {
-    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) {
-      let min = 0;
-      for (let i = 0; i < procedure["~orpc"].middlewares.length; i++) {
-        const index = middlewares.indexOf(procedure["~orpc"].middlewares[i], min);
-        if (index === -1) {
-          middlewares.push(...procedure["~orpc"].middlewares.slice(i));
-          break;
-        }
-        min = index + 1;
-      }
-    }
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      middlewares
-    }));
-  };
-  return decorated;
-}
-
-// 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({
+import { mergeErrorMap, mergeMeta, mergeRoute } from "@orpc/contract";
+var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
+  errors(errors) {
+    return new _DecoratedProcedure({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], mappedMiddleware]
+      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
-  handler(handler) {
-    return decorateProcedure(new Procedure({
-      middlewares: this["~orpc"].middlewares,
-      contract: this["~orpc"].contract,
-      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-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, {
-    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({
+  meta(meta) {
+    return new _DecoratedProcedure({
       ...this["~orpc"],
-      prefix: `${this["~orpc"].prefix ?? ""}${prefix}`
+      meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
-  tag(...tags) {
-    return new _RouterBuilder({
+  route(route) {
+    return new _DecoratedProcedure({
       ...this["~orpc"],
-      tags: [...this["~orpc"].tags ?? [], ...tags]
+      route: mergeRoute(this["~orpc"].route, route)
     });
   }
-  use(middleware) {
-    return new _RouterBuilder({
+  use(middleware, mapInput) {
+    const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+    return new _DecoratedProcedure({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
+      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
     });
   }
-  router(router) {
-    const adapted = adapt(router, this["~orpc"]);
-    return adapted;
+  /**
+   * 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"]
+    });
   }
-  lazy(loader) {
-    const adapted = adapt(flatLazy(lazy(loader)), this["~orpc"]);
-    return adapted;
+  /**
+   * 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);
   }
 };
-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 = decorateProcedure(item);
-    if (options.tags?.length) {
-      decorated = decorated.unshiftTag(...options.tags);
-    }
-    if (options.prefix) {
-      decorated = decorated.prefix(options.prefix);
-    }
-    if (options.middlewares?.length) {
-      decorated = decorated.unshiftMiddleware(...options.middlewares);
-    }
-    return decorated;
-  }
-  const adapted = {};
-  for (const key in item) {
-    adapted[key] = adapt(item[key], options);
-  }
-  return adapted;
-}
 
-// src/router-implementer.ts
-var RouterImplementer = class _RouterImplementer {
-  "~type" = "RouterImplementer";
+// src/builder.ts
+var Builder = class _Builder {
   "~orpc";
   constructor(def) {
     this["~orpc"] = def;
   }
-  use(middleware) {
-    return new _RouterImplementer({
+  /**
+   * 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"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
+      config,
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", config.initialInputValidationIndex) + inputValidationCount,
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config.initialOutputValidationIndex) + outputValidationCount
     });
   }
-  router(router) {
-    const adapted = new RouterBuilder(this["~orpc"]).router(router);
-    const contracted = setRouterContract(adapted, this["~orpc"].contract);
-    return contracted;
-  }
-  lazy(loader) {
-    const adapted = new RouterBuilder(this["~orpc"]).lazy(loader);
-    const contracted = setRouterContract(adapted, this["~orpc"].contract);
-    return contracted;
-  }
-};
-
-// src/implementer-chainable.ts
-function createChainableImplementer(contract, middlewares) {
-  if (isContractProcedure(contract)) {
-    const implementer = new ProcedureImplementer({
-      contract,
-      middlewares
-    });
-    return implementer;
-  }
-  const chainable = {};
-  for (const key in contract) {
-    chainable[key] = createChainableImplementer(contract[key], middlewares);
-  }
-  const routerImplementer = new RouterImplementer({ contract, 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/procedure-builder.ts
-import {
-  DecoratedContractProcedure as DecoratedContractProcedure2
-} from "@orpc/contract";
-var ProcedureBuilder = class _ProcedureBuilder {
-  "~type" = "ProcedureBuilder";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  route(route) {
-    return new _ProcedureBuilder({
+  /**
+   * Reset initial context
+   */
+  $context() {
+    return new _Builder({
       ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).route(route)
+      middlewares: [],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex)
     });
   }
-  input(schema, example) {
-    return new _ProcedureBuilder({
+  /**
+   * Reset initial meta
+   */
+  $meta(initialMeta) {
+    return new _Builder({
       ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).input(schema, example)
+      meta: initialMeta
     });
   }
-  output(schema, example) {
-    return new _ProcedureBuilder({
+  /**
+   * Reset initial route
+   */
+  $route(initialRoute) {
+    return new _Builder({
       ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).output(schema, example)
+      route: initialRoute
     });
   }
+  middleware(middleware) {
+    return decorateMiddleware(middleware);
+  }
   errors(errors) {
-    return new _ProcedureBuilder({
+    return new _Builder({
       ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).errors(errors)
+      errorMap: mergeErrorMap2(this["~orpc"].errorMap, errors)
     });
   }
   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);
-  }
-  handler(handler) {
-    return decorateProcedure(new Procedure({
-      middlewares: this["~orpc"].middlewares,
-      contract: this["~orpc"].contract,
-      handler
-    }));
-  }
-};
-
-// src/builder.ts
-var Builder = class _Builder {
-  "~type" = "Builder";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  context() {
-    return new _Builder({});
-  }
-  use(middleware) {
+    const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
     return new _Builder({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
+      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
     });
   }
-  middleware(middleware) {
-    return decorateMiddleware(middleware);
-  }
-  route(route) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        route,
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: void 0
-      })
+  meta(meta) {
+    return new _Builder({
+      ...this["~orpc"],
+      meta: mergeMeta2(this["~orpc"].meta, meta)
     });
   }
-  input(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        OutputSchema: void 0,
-        InputSchema: schema,
-        inputExample: example,
-        errorMap: void 0
-      })
+  route(route) {
+    return new _Builder({
+      ...this["~orpc"],
+      route: mergeRoute2(this["~orpc"].route, route)
     });
   }
-  output(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: schema,
-        outputExample: example,
-        errorMap: void 0
-      })
+  input(schema) {
+    return new _Builder({
+      ...this["~orpc"],
+      inputSchema: schema,
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex) + this["~orpc"].middlewares.length
     });
   }
-  errors(errors) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: errors
-      })
+  output(schema) {
+    return new _Builder({
+      ...this["~orpc"],
+      outputSchema: schema,
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + this["~orpc"].middlewares.length
     });
   }
   handler(handler) {
-    return decorateProcedure(new Procedure({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: void 0
-      }),
+    return new DecoratedProcedure({
+      ...this["~orpc"],
       handler
-    }));
+    });
   }
   prefix(prefix) {
-    return new RouterBuilder({
-      middlewares: this["~orpc"].middlewares,
-      prefix
+    return new _Builder({
+      ...this["~orpc"],
+      prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
   }
   tag(...tags) {
-    return new RouterBuilder({
-      middlewares: this["~orpc"].middlewares,
-      tags
+    return new _Builder({
+      ...this["~orpc"],
+      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);
-  }
-  contract(contract) {
-    return createChainableImplementer(contract, this["~orpc"].middlewares);
+    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/router-client.ts
-function createRouterClient(options) {
-  if (isProcedure(options.router)) {
-    const caller = createProcedureClient({
-      ...options,
-      procedure: options.router,
-      context: options.context,
-      path: options.path
+// src/context.ts
+function mergeContext(context, other) {
+  return { ...context, ...other };
+}
+
+// src/implementer.ts
+import { isContractProcedure } from "@orpc/contract";
+function implementerInternal(contract, config, middlewares) {
+  if (isContractProcedure(contract)) {
+    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;
+    }
+  });
+  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);
+      if (!next || typeof next !== "function" && typeof next !== "object") {
+        return method ?? next;
+      }
+      if (method) {
+        return new Proxy(method, {
+          get(_, key2) {
+            return Reflect.get(next, key2);
+          }
+        });
+      }
+      return next;
+    }
+  });
+  return impl;
+}
+
+// src/procedure-utils.ts
+function call(procedure, input, ...rest) {
+  return createProcedureClient(procedure, ...rest)(input);
+}
+
+// src/router-client.ts
+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]
       });
     }
   });
@@ -507,39 +353,39 @@ function createRouterClient(options) {
 }
 
 // src/index.ts
-import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe } from "@orpc/contract";
-var os = new Builder({});
+import { isDefinedError, ORPCError, safe, type, ValidationError } from "@orpc/contract";
 export {
   Builder,
+  DecoratedProcedure,
   LAZY_LOADER_SYMBOL,
   ORPCError,
   Procedure,
-  ProcedureBuilder,
-  ProcedureImplementer,
-  RouterBuilder,
-  RouterImplementer,
-  configGlobal,
-  createChainableImplementer,
-  createORPCErrorConstructorMap,
+  ValidationError,
+  adaptRouter,
+  call,
+  createAccessibleLazyRouter,
+  createLazyProcedureFormAnyLazy,
   createProcedureClient,
   createRouterClient,
-  decorateLazy,
   decorateMiddleware,
-  decorateProcedure,
   deepSetLazyRouterPrefix,
-  fallbackToGlobalConfig,
+  fallbackConfig,
   flatLazy,
   getLazyRouterPrefix,
   getRouterChild,
   getRouterContract,
+  implement,
+  implementerInternal,
   isDefinedError,
   isLazy,
   isProcedure,
   lazy,
   mergeContext,
+  middlewareOutputFn,
   os,
   safe,
   setRouterContract,
+  type,
   unlazy
 };
 //# sourceMappingURL=index.js.map