@orpc/server 1.14.11 → 1.14.13

package/dist/index.mjs

@@ -1,399 +1,492 @@
-import { mergeErrorMap, resolveMetaPlugins, getHiddenMetaPlugins, ProcedureContract } from '@orpc/contract';
-export { ValidationError, asyncIteratorObject, defineMeta, eventIterator, reconcileORPCError, type } from '@orpc/contract';
-import { toArray, bindMethods, getOrBind, isTypescriptObject, resolveMaybeOptionalOptions } from '@orpc/shared';
-export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, streamToAsyncIteratorObject as streamToEventIterator } from '@orpc/shared';
-import { L as Lazy, P as Procedure, c as createProcedureClient } from './shared/server.DofEOwf-.mjs';
-export { a as createORPCErrorConstructorMap, u as unlazy } from './shared/server.DofEOwf-.mjs';
-import { D as DecoratedProcedure } from './shared/server.DBs0rrf9.mjs';
-import { b as augmentRouter, d as augmentImplementedRouter, e as withHiddenRouterContract, f as createGuardedProcedureLazy, g as getRouter } from './shared/server.BoiFpNT7.mjs';
-export { a as DEFAULT_ERROR_STATUS, D as DEFAULT_SUCCESS_STATUS, h as call, c as createContractProcedure, i as getHiddenRouterContract, u as unlazyRouter, j as walkProcedureContractsAsync, w as walkProcedureContractsSync } from './shared/server.BoiFpNT7.mjs';
-import { RECURSIVE_CLIENT_UNWRAP_KEYS } from '@orpc/client';
-export { COMMON_ERROR_STATUS_MAP, ORPCError, RPCJsonSerializer, RPCSerializer, cloneORPCError, isDefinedError, isInferableError, safe, toORPCError } from '@orpc/client';
-export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/core';
+import { mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, mergeTags, isContractProcedure, getContractRouter, fallbackContractConfig } from '@orpc/contract';
+export { ValidationError, eventIterator, type, validateORPCError } from '@orpc/contract';
+import { P as Procedure, b as addMiddleware, c as createProcedureClient, e as enhanceRouter, l as lazy, s as setHiddenRouterContract, u as unlazy, g as getRouter, i as isProcedure, d as isLazy, f as createAssertedLazyProcedure } from './shared/server.DEBcqOjg.mjs';
+export { L as LAZY_SYMBOL, p as call, r as createAccessibleLazyRouter, a as createContractedProcedure, h as createORPCErrorConstructorMap, q as getHiddenRouterContract, j as getLazyMeta, n as isStartWithMiddlewares, m as mergeCurrentContext, o as mergeMiddlewares, k as middlewareOutputFn, v as resolveContractProcedures, t as traverseContractProcedures, w as unlazyRouter } from './shared/server.DEBcqOjg.mjs';
+import { toORPCError } from '@orpc/client';
+export { ORPCError, isDefinedError, safe } from '@orpc/client';
+import { isObject, resolveMaybeOptionalOptions } from '@orpc/shared';
+export { AsyncIteratorClass, EventPublisher, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
+export { ErrorEvent, getEventMeta, withEventMeta } from '@orpc/standard-server';
+
+const DEFAULT_CONFIG = {
+  initialInputValidationIndex: 0,
+  initialOutputValidationIndex: 0,
+  dedupeLeadingMiddlewares: true
+};
+function fallbackConfig(key, value) {
+  if (value === void 0) {
+    return DEFAULT_CONFIG[key];
+  }
+  return value;
+}
 
 function decorateMiddleware(middleware) {
   const decorated = ((...args) => middleware(...args));
-  decorated["~orpc"] = middleware["~orpc"];
-  Object.defineProperty(decorated, "name", {
-    value: middleware.name
-  });
-  decorated.adaptInput = (adapt) => {
+  decorated.mapInput = (mapInput) => {
     const mapped = decorateMiddleware(
-      (opts, input, ...args) => {
-        return middleware(opts, adapt(input), ...args);
-      }
+      (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
     );
-    mapped["~orpc"] = middleware["~orpc"];
-    Object.defineProperty(mapped, "name", {
-      value: middleware.name
-    });
     return mapped;
   };
-  decorated.errors = (errors) => {
-    const newMiddleware = decorateMiddleware(decorated);
-    newMiddleware["~orpc"] = {
-      ...decorated["~orpc"],
-      errorMap: mergeErrorMap(decorated["~orpc"]?.errorMap, errors)
-    };
-    return newMiddleware;
-  };
-  decorated.use = (usedMiddleware) => {
-    const merged = decorateMiddleware((opts, ...args) => {
-      return middleware(
-        {
-          ...opts,
-          async next(nextOpts1) {
-            const result = await usedMiddleware({
-              ...opts,
-              context: { ...opts.context, ...nextOpts1?.context },
-              next(nextOpts2, ...args2) {
-                return opts.next({
-                  ...opts,
-                  context: {
-                    ...nextOpts1?.context,
-                    ...nextOpts2?.context
-                  }
-                }, ...args2);
-              }
-            }, ...args);
-            return {
-              ...result,
-              context: {
-                ...nextOpts1?.context,
-                ...result.context
-              }
-            };
-          }
-        },
-        ...args
-      );
-    });
-    merged["~orpc"] = {
-      ...decorated["~orpc"],
-      errorMap: mergeErrorMap(usedMiddleware["~orpc"]?.errorMap, decorated["~orpc"]?.errorMap),
-      metaPlugins: [
-        ...toArray(middleware["~orpc"]?.metaPlugins),
-        ...toArray(usedMiddleware["~orpc"]?.metaPlugins)
-      ]
-    };
-    Object.defineProperty(merged, "name", {
-      value: `${middleware.name} + ${usedMiddleware.name}`
+  decorated.concat = (concatMiddleware, mapInput) => {
+    const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
+    const concatted = decorateMiddleware((options, 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 merged;
+    return concatted;
   };
   return decorated;
 }
 
+function createActionableClient(client) {
+  const action = async (input) => {
+    try {
+      return [null, await client(input)];
+    } catch (error) {
+      if (error instanceof Error && "digest" in error && typeof error.digest === "string" && error.digest.startsWith("NEXT_")) {
+        throw error;
+      }
+      if (error instanceof Response && "options" in error && isObject(error.options) || isObject(error) && error.isNotFound === true) {
+        throw error;
+      }
+      return [toORPCError(error).toJSON(), void 0];
+    }
+  };
+  return action;
+}
+
+class DecoratedProcedure extends Procedure {
+  /**
+   * Adds type-safe custom errors.
+   * The provided errors are spared-merged with any existing errors.
+   *
+   * @see {@link https://orpc.dev/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
+   */
+  errors(errors) {
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
+    });
+  }
+  /**
+   * Sets or updates the metadata.
+   * The provided metadata is spared-merged with any existing metadata.
+   *
+   * @see {@link https://orpc.dev/docs/metadata Metadata Docs}
+   */
+  meta(meta) {
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      meta: mergeMeta(this["~orpc"].meta, meta)
+    });
+  }
+  /**
+   * Sets or updates the route definition.
+   * The provided route is spared-merged with any existing route.
+   * This option is typically relevant when integrating with OpenAPI.
+   *
+   * @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+   * @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+   */
+  route(route) {
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      route: mergeRoute(this["~orpc"].route, route)
+    });
+  }
+  use(middleware, mapInput) {
+    const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
+    });
+  }
+  /**
+   * Make this procedure callable (works like a function while still being a procedure).
+   *
+   * @see {@link https://orpc.dev/docs/client/server-side Server-side Client Docs}
+   */
+  callable(...rest) {
+    const client = createProcedureClient(this, ...rest);
+    return new Proxy(client, {
+      get: (target, key) => {
+        return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
+      },
+      has: (target, key) => {
+        return Reflect.has(this, key) || Reflect.has(target, key);
+      }
+    });
+  }
+  /**
+   * Make this procedure compatible with server action.
+   *
+   * @see {@link https://orpc.dev/docs/server-action Server Action Docs}
+   */
+  actionable(...rest) {
+    const action = createActionableClient(createProcedureClient(this, ...rest));
+    return new Proxy(action, {
+      get: (target, key) => {
+        return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
+      },
+      has: (target, key) => {
+        return Reflect.has(this, key) || Reflect.has(target, key);
+      }
+    });
+  }
+}
+
 class Builder {
+  /**
+   * This property holds the defined options.
+   */
   "~orpc";
-  constructor(definition) {
-    this["~orpc"] = definition;
+  constructor(def) {
+    this["~orpc"] = def;
   }
-  static create() {
+  /**
+   * Sets or overrides the config.
+   *
+   * @see {@link https://orpc.dev/docs/client/server-side#middlewares-order Middlewares Order Docs}
+   * @see {@link https://orpc.dev/docs/best-practices/dedupe-middleware#configuration Dedupe Middleware Docs}
+   */
+  $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({
-      errorMap: {},
-      meta: {},
-      orderedMiddlewares: []
+      ...this["~orpc"],
+      config,
+      dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares),
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", config.initialInputValidationIndex) + inputValidationCount,
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config.initialOutputValidationIndex) + outputValidationCount
     });
   }
+  /**
+   * Set or override the initial context.
+   *
+   * @see {@link https://orpc.dev/docs/context Context Docs}
+   */
   $context() {
-    return this;
-  }
-  $config(config) {
     return new Builder({
       ...this["~orpc"],
-      ...config
+      middlewares: [],
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex)
     });
   }
-  meta(...plugins) {
-    const [meta, metaPlugins] = resolveMetaPlugins(
-      this["~orpc"].meta,
-      this["~orpc"].metaPlugins,
-      plugins
-    );
+  /**
+   * Sets or overrides the initial meta.
+   *
+   * @see {@link https://orpc.dev/docs/metadata Metadata Docs}
+   */
+  $meta(initialMeta) {
     return new Builder({
       ...this["~orpc"],
-      meta,
-      metaPlugins
+      meta: initialMeta
     });
   }
-  errors(errors) {
-    let builder = new Builder({
+  /**
+   * Sets or overrides the initial route.
+   * This option is typically relevant when integrating with OpenAPI.
+   *
+   * @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+   * @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+   */
+  $route(initialRoute) {
+    return new Builder({
       ...this["~orpc"],
-      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
+      route: initialRoute
     });
-    const plugins = getHiddenMetaPlugins(errors);
-    if (plugins) {
-      builder = builder.meta(...plugins);
-    }
-    return builder;
   }
-  use(middleware) {
-    let builder = new Builder({
+  /**
+   * Sets or overrides the initial input schema.
+   *
+   * @see {@link https://orpc.dev/docs/procedure#initial-configuration Initial Procedure Configuration Docs}
+   */
+  $input(initialInputSchema) {
+    return new Builder({
       ...this["~orpc"],
-      errorMap: mergeErrorMap(middleware["~orpc"]?.errorMap ?? {}, this["~orpc"].errorMap),
-      orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
-        middleware,
-        inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
-        outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
-      }]
+      inputSchema: initialInputSchema
     });
-    if (middleware["~orpc"]?.metaPlugins) {
-      builder = builder.meta(...middleware["~orpc"]?.metaPlugins);
-    }
-    return builder;
   }
+  /**
+   * Creates a middleware.
+   *
+   * @see {@link https://orpc.dev/docs/middleware Middleware Docs}
+   */
   middleware(middleware) {
-    const allMiddlewares = [
-      ...this["~orpc"].orderedMiddlewares.map(({ middleware: middleware2 }) => middleware2),
-      middleware
-    ];
-    let current = decorateMiddleware(allMiddlewares.shift());
-    for (const mid of allMiddlewares) {
-      current = current.use(mid);
-    }
-    current["~orpc"] = {
-      ...current["~orpc"],
-      errorMap: this["~orpc"].errorMap,
-      metaPlugins: [
-        ...toArray(this["~orpc"].metaPlugins),
-        ...toArray(middleware["~orpc"]?.metaPlugins)
-      ]
-    };
-    return current;
+    return decorateMiddleware(middleware);
   }
-  input(schema) {
-    let builder = new Builder({
+  /**
+   * Adds type-safe custom errors.
+   * The provided errors are spared-merged with any existing errors.
+   *
+   * @see {@link https://orpc.dev/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
+   */
+  errors(errors) {
+    return new Builder({
       ...this["~orpc"],
-      inputSchemas: [...toArray(this["~orpc"].inputSchemas), schema]
+      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
-    const plugins = getHiddenMetaPlugins(schema);
-    if (plugins) {
-      builder = builder.meta(...plugins);
-    }
-    return builder;
   }
-  output(schema) {
-    let builder = new Builder({
+  use(middleware, mapInput) {
+    const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+    return new Builder({
       ...this["~orpc"],
-      outputSchemas: [...toArray(this["~orpc"].outputSchemas), schema]
+      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
     });
-    const plugins = getHiddenMetaPlugins(schema);
-    if (plugins) {
-      builder = builder.meta(...plugins);
-    }
-    return builder;
   }
-  handler(handler) {
-    let procedure = new DecoratedProcedure({
+  /**
+   * Sets or updates the metadata.
+   * The provided metadata is spared-merged with any existing metadata.
+   *
+   * @see {@link https://orpc.dev/docs/metadata Metadata Docs}
+   */
+  meta(meta) {
+    return new Builder({
       ...this["~orpc"],
-      handler
+      meta: mergeMeta(this["~orpc"].meta, meta)
     });
-    const plugins = getHiddenMetaPlugins(handler);
-    if (plugins) {
-      procedure = procedure.meta(...plugins);
-    }
-    return procedure;
   }
-  router(router) {
-    return augmentRouter(router, {
+  /**
+   * Sets or updates the route definition.
+   * The provided route is spared-merged with any existing route.
+   * This option is typically relevant when integrating with OpenAPI.
+   *
+   * @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+   * @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+   */
+  route(route) {
+    return new Builder({
       ...this["~orpc"],
-      middlewares: this["~orpc"].orderedMiddlewares.map(({ middleware }) => middleware)
+      route: mergeRoute(this["~orpc"].route, route)
     });
   }
-  lazy(loader) {
-    return new Lazy({
-      loader: async () => {
-        const { default: router } = await loader();
-        return {
-          default: this.router(router)
-        };
-      },
-      meta: this["~orpc"].meta,
-      metaPlugins: this["~orpc"].metaPlugins
+  /**
+   * Defines the input validation schema.
+   *
+   * @see {@link https://orpc.dev/docs/procedure#input-output-validation Input Validation Docs}
+   */
+  input(schema) {
+    return new Builder({
+      ...this["~orpc"],
+      inputSchema: schema,
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex) + this["~orpc"].middlewares.length
     });
   }
-}
-const os = Builder.create();
-
-class ProcedureImplementer {
-  "~orpc";
-  constructor(definition) {
-    this["~orpc"] = definition;
-  }
-  "use"(middleware) {
-    return new ProcedureImplementer({
+  /**
+   * Defines the output validation schema.
+   *
+   * @see {@link https://orpc.dev/docs/procedure#input-output-validation Output Validation Docs}
+   */
+  output(schema) {
+    return new Builder({
       ...this["~orpc"],
-      orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
-        middleware,
-        inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
-        outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
-      }]
+      outputSchema: schema,
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + this["~orpc"].middlewares.length
     });
   }
-  "handler"(handler) {
-    return new ImplementedProcedure({
+  /**
+   * Defines the handler of the procedure.
+   *
+   * @see {@link https://orpc.dev/docs/procedure Procedure Docs}
+   */
+  handler(handler) {
+    return new DecoratedProcedure({
       ...this["~orpc"],
-      handler,
-      /**
-       * When enabled, errors returned (not thrown) by the handler are passed through as-is,
-       * rather than being transformed into inferrable errors.
-       *
-       * This is intended for the contract-first approach, where the procedure adheres to an
-       * external contract and returned errors should not affect the inferred contract types.
-       */
-      opaqueReturnedErrors: true
+      handler
     });
   }
-}
-class ImplementedProcedure extends Procedure {
-  use(middleware) {
-    return new ImplementedProcedure({
+  /**
+   * Prefixes all procedures in the router.
+   * The provided prefix is post-appended to any existing router prefix.
+   *
+   * @note This option does not affect procedures that do not define a path in their route definition.
+   *
+   * @see {@link https://orpc.dev/docs/openapi/routing#route-prefixes OpenAPI Route Prefixes Docs}
+   */
+  prefix(prefix) {
+    return new Builder({
       ...this["~orpc"],
-      orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
-        middleware,
-        inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
-        outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
-      }]
+      prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
   }
-}
-
-class SharedRouterImplementer {
-  constructor(contract, config, middlewares) {
-    this.contract = contract;
-    this.config = config;
-    this.middlewares = middlewares;
-  }
-  static create(contract, config, middlewares = []) {
-    return new SharedRouterImplementer(
-      contract,
-      config,
-      middlewares
-    );
-  }
-  use(middleware) {
-    return createRouterImplementerInternal(this.contract, this.config, [...this.middlewares, middleware]);
-  }
-  middleware(middleware) {
-    const allMiddlewares = [
-      ...this.middlewares,
-      middleware
-    ];
-    let current = decorateMiddleware(allMiddlewares.shift());
-    for (const mid of allMiddlewares) {
-      current = current.use(mid);
-    }
-    return current;
+  /**
+   * Adds tags to all procedures in the router.
+   * This helpful when you want to group procedures together in the OpenAPI specification.
+   *
+   * @see {@link https://orpc.dev/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+   */
+  tag(...tags) {
+    return new Builder({
+      ...this["~orpc"],
+      tags: mergeTags(this["~orpc"].tags, tags)
+    });
   }
+  /**
+   * Applies all of the previously defined options to the specified router.
+   *
+   * @see {@link https://orpc.dev/docs/router#extending-router Extending Router Docs}
+   */
   router(router) {
-    if (this.middlewares.length) {
-      router = augmentImplementedRouter(router, {
-        ...this.config,
-        middlewares: this.middlewares
-      });
-    }
-    return withHiddenRouterContract(router, this.contract);
+    return enhanceRouter(router, this["~orpc"]);
   }
+  /**
+   * Create a lazy router
+   * And applies all of the previously defined options to the specified router.
+   *
+   * @see {@link https://orpc.dev/docs/router#extending-router Extending Router Docs}
+   */
   lazy(loader) {
-    if (this.middlewares.length) {
-      const originalLoader = loader;
-      loader = async () => {
-        const { default: router } = await originalLoader();
-        return {
-          default: augmentImplementedRouter(router, {
-            ...this.config,
-            middlewares: this.middlewares
-          })
-        };
-      };
-    }
-    return new Lazy({ loader, meta: {} });
+    return enhanceRouter(lazy(loader), this["~orpc"]);
   }
 }
-function createRouterImplementer(contract, config) {
-  return createRouterImplementerInternal(contract, config, []);
-}
-function createRouterImplementerInternal(contract, config, middlewares) {
-  if (contract instanceof ProcedureContract) {
-    return new ProcedureImplementer({
-      ...config,
+const os = new Builder({
+  config: {},
+  route: {},
+  meta: {},
+  errorMap: {},
+  inputValidationIndex: fallbackConfig("initialInputValidationIndex"),
+  outputValidationIndex: fallbackConfig("initialOutputValidationIndex"),
+  middlewares: [],
+  dedupeLeadingMiddlewares: true
+});
+
+function implementerInternal(contract, config, middlewares) {
+  if (isContractProcedure(contract)) {
+    const impl2 = new Builder({
       ...contract["~orpc"],
-      orderedMiddlewares: middlewares.map((middleware) => ({ middleware }))
+      config,
+      middlewares,
+      inputValidationIndex: fallbackConfig("initialInputValidationIndex", config?.initialInputValidationIndex) + middlewares.length,
+      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config?.initialOutputValidationIndex) + middlewares.length,
+      dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares)
     });
+    return impl2;
   }
-  const implementer = {};
-  for (const key in contract) {
-    const child = contract[key];
-    implementer[key] = createRouterImplementerInternal(child, config, middlewares);
-  }
-  const shared = bindMethods(SharedRouterImplementer.create(contract, config, middlewares));
-  for (const key in shared) {
-    const method = shared[key];
-    if (key in implementer) {
-      const child = implementer[key];
-      implementer[key] = new Proxy(method, {
-        get(_, p) {
-          return getOrBind(child, p);
-        }
-      });
-    } else {
-      implementer[key] = method;
-    }
-  }
-  return implementer;
-}
-
-function implement(contract, config = {}) {
-  const routerImplementer = createRouterImplementer(contract, config);
-  const implementer = new Proxy(routerImplementer, {
-    get(_, p) {
+  const impl = new Proxy(contract, {
+    get: (target, key) => {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
       let method;
-      if (p === "$context") {
-        method = () => implementer;
-      } else if (p === "$config") {
-        method = (incoming) => implement(contract, { ...config, ...incoming });
+      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 = enhanceRouter(router, {
+            middlewares,
+            errorMap: {},
+            prefix: void 0,
+            tags: void 0,
+            dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares)
+          });
+          return setHiddenRouterContract(adapted, contract);
+        };
+      } else if (key === "lazy") {
+        method = (loader) => {
+          const adapted = enhanceRouter(lazy(loader), {
+            middlewares,
+            errorMap: {},
+            prefix: void 0,
+            tags: void 0,
+            dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares)
+          });
+          return setHiddenRouterContract(adapted, contract);
+        };
+      }
+      const next = getContractRouter(target, [key]);
+      if (!next) {
+        return method ?? next;
       }
-      const value = getOrBind(routerImplementer, p);
+      const nextImpl = implementerInternal(next, config, middlewares);
       if (method) {
-        if (!isTypescriptObject(value)) {
-          return method;
-        }
         return new Proxy(method, {
-          get(_2, p2) {
-            return getOrBind(value, p2);
+          get(_, key2) {
+            return Reflect.get(nextImpl, key2);
           }
         });
       }
-      return value;
+      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 (!method || !next || typeof next !== "function" && typeof next !== "object") {
+        return method || next;
+      }
+      return new Proxy(method, {
+        get(_, key2) {
+          return Reflect.get(next, key2);
+        }
+      });
     }
   });
-  return implementer;
+  return impl;
+}
+
+function inferRPCMethodFromRouter(router) {
+  return async (_, path) => {
+    const { default: procedure } = await unlazy(getRouter(router, path));
+    if (!isProcedure(procedure)) {
+      throw new Error(
+        `[inferRPCMethodFromRouter] No valid procedure found at path "${path.join(".")}". This may happen when the router is not properly configured.`
+      );
+    }
+    const method = fallbackContractConfig("defaultMethod", procedure["~orpc"].route.method);
+    return method === "HEAD" ? "GET" : method;
+  };
 }
 
 function createRouterClient(router, ...rest) {
   const options = resolveMaybeOptionalOptions(rest);
-  if (router instanceof Procedure) {
-    return createProcedureClient(router, options);
+  if (isProcedure(router)) {
+    const caller = createProcedureClient(router, options);
+    return caller;
   }
-  const procedureCaller = router instanceof Lazy ? createProcedureClient(createGuardedProcedureLazy(router), options) : {};
+  const procedureCaller = isLazy(router) ? createProcedureClient(createAssertedLazyProcedure(router), options) : {};
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
-      if (typeof key !== "string" || router instanceof Lazy && RECURSIVE_CLIENT_UNWRAP_KEYS.has(key)) {
-        return getOrBind(target, key);
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
       }
       const next = getRouter(router, [key]);
       if (!next) {
-        return getOrBind(target, key);
+        return Reflect.get(target, key);
       }
-      const nextClient = createRouterClient(next, {
-        ...options,
-        path: [...toArray(options.path), key]
+      return createRouterClient(next, {
+        ...rest[0],
+        path: [...rest[0]?.path ?? [], key]
       });
-      return nextClient;
     }
   });
   return recursive;
 }
 
-export { Builder, DecoratedProcedure, ImplementedProcedure, Lazy, Procedure, ProcedureImplementer, SharedRouterImplementer, augmentImplementedRouter, augmentRouter, createGuardedProcedureLazy, createProcedureClient, createRouterClient, createRouterImplementer, decorateMiddleware, getRouter, implement, os, withHiddenRouterContract };
+export { Builder, DecoratedProcedure, Procedure, addMiddleware, createActionableClient, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, fallbackConfig, getRouter, implement, implementerInternal, inferRPCMethodFromRouter, isLazy, isProcedure, lazy, os, setHiddenRouterContract, unlazy };