@orpc/server 1.14.9 → 1.14.11

package/dist/index.mjs

@@ -1,492 +1,399 @@
-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;
-}
+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';
 
 function decorateMiddleware(middleware) {
   const decorated = ((...args) => middleware(...args));
-  decorated.mapInput = (mapInput) => {
+  decorated["~orpc"] = middleware["~orpc"];
+  Object.defineProperty(decorated, "name", {
+    value: middleware.name
+  });
+  decorated.adaptInput = (adapt) => {
     const mapped = decorateMiddleware(
-      (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
+      (opts, input, ...args) => {
+        return middleware(opts, adapt(input), ...args);
+      }
     );
+    mapped["~orpc"] = middleware["~orpc"];
+    Object.defineProperty(mapped, "name", {
+      value: middleware.name
+    });
     return mapped;
   };
-  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 concatted;
+  decorated.errors = (errors) => {
+    const newMiddleware = decorateMiddleware(decorated);
+    newMiddleware["~orpc"] = {
+      ...decorated["~orpc"],
+      errorMap: mergeErrorMap(decorated["~orpc"]?.errorMap, errors)
+    };
+    return newMiddleware;
   };
-  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);
-      }
+  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
+      );
     });
-  }
-  /**
-   * 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);
-      }
+    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}`
     });
-  }
+    return merged;
+  };
+  return decorated;
 }
 
 class Builder {
-  /**
-   * This property holds the defined options.
-   */
   "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
+  constructor(definition) {
+    this["~orpc"] = definition;
   }
-  /**
-   * 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);
+  static create() {
     return new Builder({
-      ...this["~orpc"],
-      config,
-      dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares),
-      inputValidationIndex: fallbackConfig("initialInputValidationIndex", config.initialInputValidationIndex) + inputValidationCount,
-      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config.initialOutputValidationIndex) + outputValidationCount
+      errorMap: {},
+      meta: {},
+      orderedMiddlewares: []
     });
   }
-  /**
-   * 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"],
-      middlewares: [],
-      inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
-      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex)
+      ...config
     });
   }
-  /**
-   * Sets or overrides the initial meta.
-   *
-   * @see {@link https://orpc.dev/docs/metadata Metadata Docs}
-   */
-  $meta(initialMeta) {
+  meta(...plugins) {
+    const [meta, metaPlugins] = resolveMetaPlugins(
+      this["~orpc"].meta,
+      this["~orpc"].metaPlugins,
+      plugins
+    );
     return new Builder({
       ...this["~orpc"],
-      meta: initialMeta
+      meta,
+      metaPlugins
     });
   }
-  /**
-   * 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({
+  errors(errors) {
+    let builder = new Builder({
       ...this["~orpc"],
-      route: initialRoute
+      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
+    const plugins = getHiddenMetaPlugins(errors);
+    if (plugins) {
+      builder = builder.meta(...plugins);
+    }
+    return 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({
+  use(middleware) {
+    let builder = new Builder({
       ...this["~orpc"],
-      inputSchema: initialInputSchema
+      errorMap: mergeErrorMap(middleware["~orpc"]?.errorMap ?? {}, this["~orpc"].errorMap),
+      orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
+        middleware,
+        inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
+        outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
+      }]
     });
+    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) {
-    return decorateMiddleware(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;
   }
-  /**
-   * 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({
+  input(schema) {
+    let builder = new Builder({
       ...this["~orpc"],
-      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
+      inputSchemas: [...toArray(this["~orpc"].inputSchemas), schema]
     });
+    const plugins = getHiddenMetaPlugins(schema);
+    if (plugins) {
+      builder = builder.meta(...plugins);
+    }
+    return builder;
   }
-  use(middleware, mapInput) {
-    const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new Builder({
+  output(schema) {
+    let builder = new Builder({
       ...this["~orpc"],
-      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
+      outputSchemas: [...toArray(this["~orpc"].outputSchemas), schema]
     });
+    const plugins = getHiddenMetaPlugins(schema);
+    if (plugins) {
+      builder = builder.meta(...plugins);
+    }
+    return builder;
   }
-  /**
-   * 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({
+  handler(handler) {
+    let procedure = new DecoratedProcedure({
       ...this["~orpc"],
-      meta: mergeMeta(this["~orpc"].meta, meta)
+      handler
     });
+    const plugins = getHiddenMetaPlugins(handler);
+    if (plugins) {
+      procedure = procedure.meta(...plugins);
+    }
+    return procedure;
   }
-  /**
-   * 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({
+  router(router) {
+    return augmentRouter(router, {
       ...this["~orpc"],
-      route: mergeRoute(this["~orpc"].route, route)
+      middlewares: this["~orpc"].orderedMiddlewares.map(({ middleware }) => middleware)
     });
   }
-  /**
-   * 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
+  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 output validation schema.
-   *
-   * @see {@link https://orpc.dev/docs/procedure#input-output-validation Output Validation Docs}
-   */
-  output(schema) {
-    return new Builder({
-      ...this["~orpc"],
-      outputSchema: schema,
-      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + this["~orpc"].middlewares.length
-    });
+}
+const os = Builder.create();
+
+class ProcedureImplementer {
+  "~orpc";
+  constructor(definition) {
+    this["~orpc"] = definition;
   }
-  /**
-   * Defines the handler of the procedure.
-   *
-   * @see {@link https://orpc.dev/docs/procedure Procedure Docs}
-   */
-  handler(handler) {
-    return new DecoratedProcedure({
+  "use"(middleware) {
+    return new ProcedureImplementer({
       ...this["~orpc"],
-      handler
+      orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
+        middleware,
+        inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
+        outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
+      }]
     });
   }
-  /**
-   * 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({
+  "handler"(handler) {
+    return new ImplementedProcedure({
       ...this["~orpc"],
-      prefix: mergePrefix(this["~orpc"].prefix, prefix)
+      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
     });
   }
-  /**
-   * 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({
+}
+class ImplementedProcedure extends Procedure {
+  use(middleware) {
+    return new ImplementedProcedure({
       ...this["~orpc"],
-      tags: mergeTags(this["~orpc"].tags, tags)
+      orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
+        middleware,
+        inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
+        outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
+      }]
     });
   }
-  /**
-   * Applies all of the previously defined options to the specified router.
-   *
-   * @see {@link https://orpc.dev/docs/router#extending-router Extending Router Docs}
-   */
+}
+
+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;
+  }
   router(router) {
-    return enhanceRouter(router, this["~orpc"]);
+    if (this.middlewares.length) {
+      router = augmentImplementedRouter(router, {
+        ...this.config,
+        middlewares: this.middlewares
+      });
+    }
+    return withHiddenRouterContract(router, this.contract);
   }
-  /**
-   * 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) {
-    return enhanceRouter(lazy(loader), this["~orpc"]);
+    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: {} });
   }
 }
-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({
+function createRouterImplementer(contract, config) {
+  return createRouterImplementerInternal(contract, config, []);
+}
+function createRouterImplementerInternal(contract, config, middlewares) {
+  if (contract instanceof ProcedureContract) {
+    return new ProcedureImplementer({
+      ...config,
       ...contract["~orpc"],
-      config,
-      middlewares,
-      inputValidationIndex: fallbackConfig("initialInputValidationIndex", config?.initialInputValidationIndex) + middlewares.length,
-      outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config?.initialOutputValidationIndex) + middlewares.length,
-      dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares)
+      orderedMiddlewares: middlewares.map((middleware) => ({ middleware }))
     });
-    return impl2;
   }
-  const impl = new Proxy(contract, {
-    get: (target, key) => {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
+  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) {
       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 = 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;
+      if (p === "$context") {
+        method = () => implementer;
+      } else if (p === "$config") {
+        method = (incoming) => implement(contract, { ...config, ...incoming });
       }
-      const nextImpl = implementerInternal(next, config, middlewares);
+      const value = getOrBind(routerImplementer, p);
       if (method) {
+        if (!isTypescriptObject(value)) {
+          return method;
+        }
         return new Proxy(method, {
-          get(_, key2) {
-            return Reflect.get(nextImpl, key2);
+          get(_2, p2) {
+            return getOrBind(value, p2);
           }
         });
       }
-      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 value;
     }
   });
-  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;
-  };
+  return implementer;
 }
 
 function createRouterClient(router, ...rest) {
   const options = resolveMaybeOptionalOptions(rest);
-  if (isProcedure(router)) {
-    const caller = createProcedureClient(router, options);
-    return caller;
+  if (router instanceof Procedure) {
+    return createProcedureClient(router, options);
   }
-  const procedureCaller = isLazy(router) ? createProcedureClient(createAssertedLazyProcedure(router), options) : {};
+  const procedureCaller = router instanceof Lazy ? createProcedureClient(createGuardedProcedureLazy(router), options) : {};
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
+      if (typeof key !== "string" || router instanceof Lazy && RECURSIVE_CLIENT_UNWRAP_KEYS.has(key)) {
+        return getOrBind(target, key);
       }
       const next = getRouter(router, [key]);
       if (!next) {
-        return Reflect.get(target, key);
+        return getOrBind(target, key);
       }
-      return createRouterClient(next, {
-        ...rest[0],
-        path: [...rest[0]?.path ?? [], key]
+      const nextClient = createRouterClient(next, {
+        ...options,
+        path: [...toArray(options.path), key]
       });
+      return nextClient;
     }
   });
   return recursive;
 }
 
-export { Builder, DecoratedProcedure, Procedure, addMiddleware, createActionableClient, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, fallbackConfig, getRouter, implement, implementerInternal, inferRPCMethodFromRouter, isLazy, isProcedure, lazy, os, setHiddenRouterContract, unlazy };
+export { Builder, DecoratedProcedure, ImplementedProcedure, Lazy, Procedure, ProcedureImplementer, SharedRouterImplementer, augmentImplementedRouter, augmentRouter, createGuardedProcedureLazy, createProcedureClient, createRouterClient, createRouterImplementer, decorateMiddleware, getRouter, implement, os, withHiddenRouterContract };