effect-orpc 1.0.0-effect-v4.4 → 1.0.0-effect-v4.5

package/dist/index.js

@@ -7,14 +7,7 @@ import { isContractProcedure as isContractProcedure2 } from "@orpc/contract";
 import { implement } from "@orpc/server";
 
 // src/effect-builder.ts
-import { mergeMeta as mergeMeta2, mergePrefix as mergePrefix2, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";
-import {
-  addMiddleware as addMiddleware2,
-  Builder,
-  decorateMiddleware as decorateMiddleware2,
-  fallbackConfig,
-  lazy as lazy2
-} from "@orpc/server";
+import { Builder, fallbackConfig, lazy as lazy2 } from "@orpc/server";
 
 // src/effect-enhance-router.ts
 import {
@@ -41,6 +34,177 @@ import {
   Procedure
 } from "@orpc/server";
 
+// src/extension/compose-surfaces.ts
+function composeSurfaceProxy(surface, target) {
+  return new Proxy(target, {
+    get(currentTarget, prop, receiver) {
+      return Reflect.has(surface, prop) ? Reflect.get(surface, prop, surface) : Reflect.get(currentTarget, prop, receiver);
+    },
+    has(currentTarget, prop) {
+      return Reflect.has(surface, prop) || Reflect.has(currentTarget, prop);
+    }
+  });
+}
+
+// src/extension/state.ts
+var effectInternalsSymbol = /* @__PURE__ */ Symbol("effect-orpc/internals");
+function attachEffectState(target, upstream, state) {
+  Object.defineProperties(target, {
+    [effectInternalsSymbol]: {
+      configurable: true,
+      value: {
+        methodCache: /* @__PURE__ */ new Map(),
+        state,
+        upstream
+      }
+    }
+  });
+}
+function getEffectInternals(target) {
+  return target[effectInternalsSymbol];
+}
+function getEffectUpstream(target) {
+  return getEffectInternals(target).upstream;
+}
+function hasEffectState(value) {
+  return typeof value === "object" && value !== null && effectInternalsSymbol in value;
+}
+function assertEffectState(value) {
+  if (!hasEffectState(value)) {
+    throw new Error("Expected effect state to be attached");
+  }
+}
+function getEffectErrorMap(value) {
+  return value["~effect"]?.effectErrorMap ?? value["~orpc"].errorMap;
+}
+function unwrapEffectUpstream(value) {
+  return hasEffectState(value) ? getEffectUpstream(value) : value;
+}
+
+// src/extension/create-node-proxy.ts
+var unhandledProperty = /* @__PURE__ */ Symbol("effect-orpc/unhandledProperty");
+function createNodeProxyContext(target) {
+  const internals = getEffectInternals(target);
+  return {
+    methodCache: internals.methodCache,
+    state: internals.state,
+    target,
+    upstream: internals.upstream
+  };
+}
+function createBoundMethod(context, prop, value, config, receiver) {
+  const cache = context.methodCache;
+  if (cache.has(prop)) {
+    return cache.get(prop);
+  }
+  const wrapped = (...args) => {
+    const result = Reflect.apply(value, context.upstream, args);
+    return config.wrapResult?.(context, prop, result, receiver) ?? result;
+  };
+  cache.set(prop, wrapped);
+  return wrapped;
+}
+function createNodeProxy(target, config) {
+  const privateKeys = /* @__PURE__ */ new Set([effectInternalsSymbol]);
+  const virtualKeys = new Set(config.virtualKeys ?? []);
+  return new Proxy(target, {
+    get(currentTarget, prop, receiver) {
+      if (privateKeys.has(prop)) {
+        return Reflect.get(currentTarget, prop, receiver);
+      }
+      const context = createNodeProxyContext(
+        currentTarget
+      );
+      const virtualValue = config.getVirtual?.(context, prop, receiver);
+      if (virtualValue !== void 0 && virtualValue !== unhandledProperty) {
+        return virtualValue;
+      }
+      const propertyValue = config.getProperty?.(context, prop, receiver);
+      if (propertyValue !== void 0 && propertyValue !== unhandledProperty) {
+        return propertyValue;
+      }
+      const sourceValue = Reflect.get(context.upstream, prop, context.upstream);
+      if (Reflect.has(context.upstream, prop)) {
+        if (typeof sourceValue === "function") {
+          return createBoundMethod(
+            context,
+            prop,
+            sourceValue,
+            config,
+            receiver
+          );
+        }
+        return sourceValue;
+      }
+      return Reflect.get(currentTarget, prop, receiver);
+    },
+    has(currentTarget, prop) {
+      if (virtualKeys.has(prop)) {
+        return true;
+      }
+      const context = createNodeProxyContext(currentTarget);
+      return Reflect.has(context.upstream, prop) || Reflect.has(currentTarget, prop);
+    },
+    ownKeys(currentTarget) {
+      const keys = /* @__PURE__ */ new Set();
+      for (const key of Reflect.ownKeys(currentTarget)) {
+        if (!privateKeys.has(key)) {
+          keys.add(key);
+        }
+      }
+      const context = createNodeProxyContext(
+        currentTarget
+      );
+      for (const key of Reflect.ownKeys(context.upstream)) {
+        keys.add(key);
+      }
+      for (const key of virtualKeys) {
+        keys.add(key);
+      }
+      return [...keys];
+    },
+    getOwnPropertyDescriptor(currentTarget, prop) {
+      const context = createNodeProxyContext(
+        currentTarget
+      );
+      if (virtualKeys.has(prop)) {
+        const value = config.getVirtual?.(context, prop, currentTarget);
+        if (value !== void 0 && value !== unhandledProperty) {
+          return {
+            configurable: true,
+            enumerable: config.virtualDescriptors?.[prop]?.enumerable ?? false,
+            value,
+            writable: false
+          };
+        }
+      }
+      const descriptor = Reflect.getOwnPropertyDescriptor(
+        context.upstream,
+        prop
+      );
+      if (descriptor === void 0) {
+        return Reflect.getOwnPropertyDescriptor(currentTarget, prop);
+      }
+      if ("value" in descriptor && typeof descriptor.value === "function") {
+        return {
+          ...descriptor,
+          value: createBoundMethod(
+            context,
+            prop,
+            descriptor.value,
+            config,
+            currentTarget
+          )
+        };
+      }
+      return descriptor;
+    }
+  });
+}
+function unhandled() {
+  return unhandledProperty;
+}
+
 // src/tagged-error.ts
 import {
   fallbackORPCErrorMessage,
@@ -175,98 +339,141 @@ function effectErrorMapToErrorMap(errorMap) {
 }
 
 // src/effect-procedure.ts
-var EffectProcedure = class extends Procedure {
-  constructor(def) {
-    super(def);
-    this["~effect"] = def;
-  }
+var procedureVirtualDescriptors = {
+  "~effect": { enumerable: true },
+  actionable: { enumerable: false },
+  callable: { enumerable: false },
+  errors: { enumerable: false },
+  meta: { enumerable: false },
+  route: { enumerable: false },
+  use: { enumerable: false }
 };
-var EffectDecoratedProcedure = class _EffectDecoratedProcedure extends EffectProcedure {
-  constructor(def) {
-    super(def);
-    this["~effect"] = def;
-  }
-  /**
-   * Adds type-safe custom errors.
-   * Supports both traditional oRPC error definitions and ORPCTaggedError classes.
-   *
-   * @see {@link https://orpc.dev/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
-   */
-  errors(errors) {
-    const newEffectErrorMap = {
-      ...this["~effect"].effectErrorMap,
-      ...errors
-    };
-    return new _EffectDecoratedProcedure({
-      ...this["~effect"],
-      effectErrorMap: newEffectErrorMap,
-      errorMap: effectErrorMapToErrorMap(newEffectErrorMap)
-    });
-  }
-  /**
-   * 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 _EffectDecoratedProcedure({
-      ...this["~effect"],
-      meta: mergeMeta(this["~effect"].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 _EffectDecoratedProcedure({
-      ...this["~effect"],
-      route: mergeRoute(this["~effect"].route, route)
-    });
-  }
-  use(middleware, mapInput) {
-    const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _EffectDecoratedProcedure({
-      ...this["~effect"],
-      middlewares: addMiddleware(this["~effect"].middlewares, mapped)
-    });
+var baseProcedureVirtualKeys = ["~effect"];
+var decoratedProcedureVirtualKeys = [
+  ...baseProcedureVirtualKeys,
+  "errors",
+  "meta",
+  "route",
+  "use",
+  "callable",
+  "actionable"
+];
+function getOrCreateVirtualMethod(context, prop, factory) {
+  const cache = context.methodCache;
+  if (cache.has(prop)) {
+    return cache.get(prop);
   }
-  /**
-   * 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);
+  const value = factory();
+  cache.set(prop, value);
+  return value;
+}
+function getEffectProcedureDef(context) {
+  return {
+    ...context.upstream["~orpc"],
+    effectErrorMap: context.state.effectErrorMap,
+    runtime: context.state.runtime
+  };
+}
+function createEffectProcedureProxy(target, decorated) {
+  return createNodeProxy(target, {
+    getVirtual(context, prop, receiver) {
+      if (prop === "~effect") {
+        return getEffectProcedureDef(context);
       }
-    });
-  }
-  /**
-   * 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);
+      if (!decorated) {
+        return unhandled();
+      }
+      const state = context.state;
+      switch (prop) {
+        case "errors":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (errors) => {
+              const nextEffectErrorMap = {
+                ...state.effectErrorMap,
+                ...errors
+              };
+              return new EffectDecoratedProcedure({
+                ...getEffectProcedureDef(context),
+                effectErrorMap: nextEffectErrorMap,
+                errorMap: effectErrorMapToErrorMap(nextEffectErrorMap)
+              });
+            };
+          });
+        case "meta":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (meta) => new EffectDecoratedProcedure({
+              ...getEffectProcedureDef(context),
+              meta: mergeMeta(getEffectProcedureDef(context).meta, meta)
+            });
+          });
+        case "route":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (route) => new EffectDecoratedProcedure({
+              ...getEffectProcedureDef(context),
+              route: mergeRoute(getEffectProcedureDef(context).route, route)
+            });
+          });
+        case "use":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (middleware, mapInput) => {
+              const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+              return new EffectDecoratedProcedure({
+                ...getEffectProcedureDef(context),
+                middlewares: addMiddleware(
+                  getEffectProcedureDef(context).middlewares,
+                  mapped
+                )
+              });
+            };
+          });
+        case "callable":
+          return (...rest) => {
+            const client = createProcedureClient(
+              receiver,
+              ...rest
+            );
+            return composeSurfaceProxy(
+              receiver,
+              client
+            );
+          };
+        case "actionable":
+          return (...rest) => {
+            const client = createProcedureClient(
+              receiver,
+              ...rest
+            );
+            const action = createActionableClient(client);
+            return composeSurfaceProxy(
+              receiver,
+              action
+            );
+          };
+        default:
+          return unhandled();
       }
+    },
+    virtualDescriptors: procedureVirtualDescriptors,
+    virtualKeys: decorated ? decoratedProcedureVirtualKeys : baseProcedureVirtualKeys
+  });
+}
+var EffectProcedure = class _EffectProcedure extends Procedure {
+  constructor(def, procedure) {
+    super(def);
+    attachEffectState(this, procedure ?? new Procedure(def), {
+      effectErrorMap: def.effectErrorMap,
+      runtime: def.runtime
     });
+    if (new.target === _EffectProcedure) {
+      return createEffectProcedureProxy(this, false);
+    }
+  }
+};
+var EffectDecoratedProcedure = class extends EffectProcedure {
+  constructor(def, procedure) {
+    super(def, procedure);
+    assertEffectState(this);
+    return createEffectProcedureProxy(this, true);
   }
 };
 
@@ -274,44 +481,44 @@ var EffectDecoratedProcedure = class _EffectDecoratedProcedure extends EffectPro
 function enhanceEffectRouter(router, options) {
   if (isLazy(router)) {
     const laziedMeta = getLazyMeta(router);
-    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
+    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta.prefix) : options.prefix;
     const enhanced2 = lazy(
       async () => {
         const { default: unlaziedRouter } = await unlazy(router);
-        const enhanced3 = enhanceEffectRouter(unlaziedRouter, options);
-        return unlazy(enhanced3);
+        const wrappedRouter = enhanceEffectRouter(unlaziedRouter, options);
+        return unlazy(wrappedRouter);
       },
       {
         ...laziedMeta,
         prefix: enhancedPrefix
       }
     );
-    const accessible = createAccessibleLazyRouter(enhanced2);
-    return accessible;
+    return createAccessibleLazyRouter(enhanced2);
   }
   if (isProcedure(router)) {
-    const newMiddlewares = mergeMiddlewares(
+    const source = unwrapEffectUpstream(router);
+    const sourceEffectErrorMap = getEffectErrorMap(router);
+    const middlewares = mergeMiddlewares(
       options.middlewares,
-      router["~orpc"].middlewares,
+      source["~orpc"].middlewares,
       { dedupeLeading: options.dedupeLeadingMiddlewares }
     );
-    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
+    const newMiddlewareAdded = middlewares.length - source["~orpc"].middlewares.length;
     const effectErrorMap = {
       ...options.errorMap,
-      ...router["~orpc"].errorMap
+      ...sourceEffectErrorMap
     };
     const errorMap = effectErrorMapToErrorMap(effectErrorMap);
-    const enhanced2 = new EffectProcedure({
-      ...router["~orpc"],
-      route: enhanceRoute(router["~orpc"].route, options),
+    return new EffectProcedure({
+      ...source["~orpc"],
+      route: enhanceRoute(source["~orpc"].route, options),
       effectErrorMap,
       errorMap,
-      middlewares: newMiddlewares,
-      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
-      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded,
+      middlewares,
+      inputValidationIndex: source["~orpc"].inputValidationIndex + newMiddlewareAdded,
+      outputValidationIndex: source["~orpc"].outputValidationIndex + newMiddlewareAdded,
       runtime: options.runtime
     });
-    return enhanced2;
   }
   const enhanced = {};
   for (const key in router) {
@@ -404,6 +611,139 @@ function createEffectProcedureHandler(options) {
 }
 
 // src/effect-builder.ts
+var builderVirtualDescriptors = {
+  "~effect": { enumerable: true },
+  effect: { enumerable: false },
+  errors: { enumerable: false },
+  handler: { enumerable: false },
+  lazy: { enumerable: false },
+  router: { enumerable: false },
+  traced: { enumerable: false }
+};
+var builderVirtualKeys = [
+  "~effect",
+  "errors",
+  "effect",
+  "traced",
+  "handler",
+  "router",
+  "lazy"
+];
+function isBuilderLike(value) {
+  return typeof value === "object" && value !== null && "~orpc" in value;
+}
+function getOrCreateVirtualMethod2(context, prop, factory) {
+  const cache = context.methodCache;
+  if (cache.has(prop)) {
+    return cache.get(prop);
+  }
+  const value = factory();
+  cache.set(prop, value);
+  return value;
+}
+function getEffectBuilderDef(context) {
+  return {
+    ...context.upstream["~orpc"],
+    effectErrorMap: context.state.effectErrorMap,
+    runtime: context.state.runtime,
+    spanConfig: context.state.spanConfig
+  };
+}
+function wrapBuilderLike(builder, state) {
+  return new EffectBuilder(
+    {
+      ...builder["~orpc"],
+      effectErrorMap: state.effectErrorMap,
+      runtime: state.runtime,
+      spanConfig: state.spanConfig
+    },
+    unwrapEffectUpstream(builder)
+  );
+}
+function createEffectBuilderProxy(target) {
+  return createNodeProxy(target, {
+    getVirtual(context, prop) {
+      const effectDef = getEffectBuilderDef(context);
+      if (prop === "~effect") {
+        return getEffectBuilderDef(context);
+      }
+      const { upstream: source, state } = context;
+      switch (prop) {
+        case "errors":
+          return getOrCreateVirtualMethod2(context, prop, () => {
+            return (errors) => {
+              const nextEffectErrorMap = {
+                ...state.effectErrorMap,
+                ...errors
+              };
+              const nextBuilder = Reflect.apply(
+                Reflect.get(source, "errors", source),
+                source,
+                [effectErrorMapToErrorMap(errors)]
+              );
+              return wrapBuilderLike(nextBuilder, {
+                ...state,
+                effectErrorMap: nextEffectErrorMap
+              });
+            };
+          });
+        case "effect":
+          return getOrCreateVirtualMethod2(context, prop, () => {
+            return (effectFn) => {
+              const defaultCaptureStackTrace = addSpanStackTrace();
+              return new EffectDecoratedProcedure({
+                ...effectDef,
+                handler: async (opts) => {
+                  return createEffectProcedureHandler({
+                    defaultCaptureStackTrace,
+                    effectErrorMap: state.effectErrorMap,
+                    effectFn,
+                    runtime: state.runtime,
+                    spanConfig: state.spanConfig
+                  })(opts);
+                }
+              });
+            };
+          });
+        case "traced":
+          return getOrCreateVirtualMethod2(context, prop, () => {
+            return (spanName) => wrapBuilderLike(source, {
+              ...state,
+              spanConfig: {
+                captureStackTrace: addSpanStackTrace(),
+                name: spanName
+              }
+            });
+          });
+        case "handler":
+          return getOrCreateVirtualMethod2(context, prop, () => {
+            return (handler) => new EffectDecoratedProcedure({
+              ...effectDef,
+              handler
+            });
+          });
+        case "router":
+          return getOrCreateVirtualMethod2(context, prop, () => {
+            return (router) => enhanceEffectRouter(router, effectDef);
+          });
+        case "lazy":
+          return getOrCreateVirtualMethod2(context, prop, () => {
+            return (loader) => enhanceEffectRouter(lazy2(loader), effectDef);
+          });
+        default:
+          return unhandled();
+      }
+    },
+    virtualDescriptors: builderVirtualDescriptors,
+    virtualKeys: builderVirtualKeys,
+    wrapResult(context, _prop, result) {
+      if (!isBuilderLike(result)) {
+        return result;
+      }
+      return wrapBuilderLike(result, context.state);
+    }
+  });
+}
 function addSpanStackTrace() {
   const ErrorConstructor = Error;
   const limit = ErrorConstructor.stackTraceLimit;
@@ -424,330 +764,40 @@ function addSpanStackTrace() {
     }
   };
 }
-var EffectBuilder = class _EffectBuilder {
-  constructor(def) {
+var EffectBuilder = class {
+  constructor(def, builder) {
     const { runtime, spanConfig, effectErrorMap, ...orpcDef } = def;
-    this["~orpc"] = orpcDef;
-    this["~effect"] = { runtime, spanConfig, effectErrorMap, ...orpcDef };
-  }
-  /**
-   * 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["~effect"].inputValidationIndex - fallbackConfig(
-      "initialInputValidationIndex",
-      this["~effect"].config.initialInputValidationIndex
-    );
-    const outputValidationCount = this["~effect"].outputValidationIndex - fallbackConfig(
-      "initialOutputValidationIndex",
-      this["~effect"].config.initialOutputValidationIndex
-    );
-    return new _EffectBuilder({
-      ...this["~effect"],
-      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 new _EffectBuilder({
-      ...this["~effect"],
-      middlewares: [],
-      inputValidationIndex: fallbackConfig(
-        "initialInputValidationIndex",
-        this["~effect"].config.initialInputValidationIndex
-      ),
-      outputValidationIndex: fallbackConfig(
-        "initialOutputValidationIndex",
-        this["~effect"].config.initialOutputValidationIndex
-      )
-    });
-  }
-  /**
-   * Sets or overrides the initial meta.
-   *
-   * @see {@link https://orpc.dev/docs/metadata Metadata Docs}
-   */
-  $meta(initialMeta) {
-    return new _EffectBuilder({
-      ...this["~effect"],
-      meta: initialMeta
-    });
-  }
-  /**
-   * 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 _EffectBuilder({
-      ...this["~effect"],
-      route: initialRoute
-    });
-  }
-  /**
-   * Sets or overrides the initial input schema.
-   *
-   * @see {@link https://orpc.dev/docs/procedure#initial-configuration Initial Procedure Configuration Docs}
-   */
-  $input(initialInputSchema) {
-    return new _EffectBuilder({
-      ...this["~effect"],
-      inputSchema: initialInputSchema
-    });
-  }
-  /**
-   * Creates a middleware.
-   *
-   * @see {@link https://orpc.dev/docs/middleware Middleware Docs}
-   */
-  middleware(middleware) {
-    return decorateMiddleware2(middleware);
-  }
-  /**
-   * Adds type-safe custom errors.
-   * Supports both traditional oRPC error definitions and ORPCTaggedError classes.
-   *
-   * @example
-   * ```ts
-   * // Traditional format
-   * builder.errors({ BAD_REQUEST: { status: 400, message: 'Bad request' } })
-   *
-   * // Tagged error class
-   * builder.errors({ USER_NOT_FOUND: UserNotFoundError })
-   *
-   * // Mixed
-   * builder.errors({
-   *   BAD_REQUEST: { status: 400 },
-   *   USER_NOT_FOUND: UserNotFoundError,
-   * })
-   * ```
-   *
-   * @see {@link https://orpc.dev/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
-   */
-  errors(errors) {
-    const newEffectErrorMap = {
-      ...this["~effect"].effectErrorMap,
-      ...errors
-    };
-    return new _EffectBuilder({
-      ...this["~effect"],
-      errorMap: effectErrorMapToErrorMap(newEffectErrorMap),
-      effectErrorMap: newEffectErrorMap
-    });
-  }
-  use(middleware, mapInput) {
-    const mapped = mapInput ? decorateMiddleware2(middleware).mapInput(mapInput) : middleware;
-    return new _EffectBuilder({
-      ...this["~effect"],
-      middlewares: addMiddleware2(this["~effect"].middlewares, mapped)
-    });
-  }
-  /**
-   * 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 _EffectBuilder({
-      ...this["~effect"],
-      meta: mergeMeta2(this["~effect"].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 _EffectBuilder({
-      ...this["~effect"],
-      route: mergeRoute2(this["~effect"].route, route)
-    });
-  }
-  /**
-   * Defines the input validation schema.
-   *
-   * @see {@link https://orpc.dev/docs/procedure#input-output-validation Input Validation Docs}
-   */
-  input(schema) {
-    return new _EffectBuilder({
-      ...this["~effect"],
-      inputSchema: schema,
-      inputValidationIndex: fallbackConfig(
-        "initialInputValidationIndex",
-        this["~effect"].config.initialInputValidationIndex
-      ) + this["~effect"].middlewares.length
-      // we cast to any because EffectProcedureBuilderWithInput is expecting
-      // use() input type to be defined, and EffectBuilder types its use() input
-      // to unknown to allow any middleware to be passed
-      // ---
-      // note: the original implentation of the builder also uses any for the same reason
-    });
-  }
-  /**
-   * Defines the output validation schema.
-   *
-   * @see {@link https://orpc.dev/docs/procedure#input-output-validation Output Validation Docs}
-   */
-  output(schema) {
-    return new _EffectBuilder({
-      ...this["~effect"],
-      outputSchema: schema,
-      outputValidationIndex: fallbackConfig(
-        "initialOutputValidationIndex",
-        this["~effect"].config.initialOutputValidationIndex
-      ) + this["~effect"].middlewares.length
-    });
-  }
-  /**
-   * Adds a traceable span to the procedure for telemetry.
-   * The span name is used for Effect tracing via `Effect.withSpan`.
-   * Stack trace is captured at the call site for better error reporting.
-   *
-   * @param spanName - The name of the span for telemetry (e.g., 'users.getUser')
-   * @returns An EffectBuilder with span tracing configured
-   *
-   * @example
-   * ```ts
-   * const getUser = effectOs
-   *   .input(z.object({ id: z.string() }))
-   *   .traced('users.getUser')
-   *   .effect(function* ({ input }) {
-   *     const userService = yield* UserService
-   *     return yield* userService.findById(input.id)
-   *   })
-   * ```
-   */
-  traced(spanName) {
-    return new _EffectBuilder({
-      ...this["~effect"],
-      spanConfig: {
-        name: spanName,
-        captureStackTrace: addSpanStackTrace()
-      }
-    });
-  }
-  handler(handler) {
-    return new EffectDecoratedProcedure({
-      ...this["~effect"],
-      handler
-    });
-  }
-  /**
-   * Defines the handler of the procedure using an Effect.
-   * The Effect is executed using the ManagedRuntime provided during builder creation.
-   * The effect is automatically wrapped with `Effect.withSpan`.
-   *
-   * @see {@link https://orpc.dev/docs/procedure Procedure Docs}
-   */
-  effect(effectFn) {
-    const { runtime, spanConfig } = this["~effect"];
-    const defaultCaptureStackTrace = addSpanStackTrace();
-    return new EffectDecoratedProcedure({
-      ...this["~effect"],
-      handler: async (opts) => {
-        return createEffectProcedureHandler({
-          runtime,
-          effectErrorMap: this["~effect"].effectErrorMap,
-          effectFn,
-          spanConfig,
-          defaultCaptureStackTrace
-        })(opts);
-      }
-    });
-  }
-  /**
-   * 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 _EffectBuilder({
-      ...this["~effect"],
-      prefix: mergePrefix2(this["~effect"].prefix, prefix)
-    });
-  }
-  /**
-   * 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 _EffectBuilder({
-      ...this["~effect"],
-      tags: mergeTags(this["~effect"].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) {
-    return enhanceEffectRouter(router, {
-      ...this["~effect"]
-    });
-  }
-  /**
-   * 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 enhanceEffectRouter(lazy2(loader), {
-      ...this["~effect"]
+    attachEffectState(this, builder ?? new Builder(orpcDef), {
+      effectErrorMap,
+      runtime,
+      spanConfig
     });
+    return createEffectBuilderProxy(this);
   }
 };
 function makeEffectORPC(runtime, builder) {
   const resolvedBuilder = builder ?? emptyBuilder();
-  return new EffectBuilder({
-    ...resolvedBuilder["~orpc"],
-    errorMap: effectErrorMapToErrorMap(resolvedBuilder["~orpc"].errorMap),
-    effectErrorMap: resolvedBuilder["~orpc"].errorMap,
-    runtime
-  });
+  const effectErrorMap = getEffectErrorMap(resolvedBuilder);
+  return new EffectBuilder(
+    {
+      ...resolvedBuilder["~orpc"],
+      effectErrorMap,
+      errorMap: effectErrorMapToErrorMap(effectErrorMap),
+      runtime
+    },
+    unwrapEffectUpstream(resolvedBuilder)
+  );
 }
 function emptyBuilder() {
   return new Builder({
     config: {},
-    route: {},
-    meta: {},
+    dedupeLeadingMiddlewares: true,
     errorMap: {},
     inputValidationIndex: fallbackConfig("initialInputValidationIndex"),
-    outputValidationIndex: fallbackConfig("initialOutputValidationIndex"),
+    meta: {},
     middlewares: [],
-    dedupeLeadingMiddlewares: true
+    outputValidationIndex: fallbackConfig("initialOutputValidationIndex"),
+    route: {}
   });
 }