effect-orpc 0.1.4 → 0.2.1

package/dist/index.js

@@ -2,22 +2,12 @@ import {
   getCurrentFiberRefs
 } from "./chunk-VOWRLWZZ.js";
 
+// src/contract.ts
+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,
-  ORPCError as ORPCError2
-} from "@orpc/contract";
-import {
-  addMiddleware as addMiddleware2,
-  Builder,
-  decorateMiddleware as decorateMiddleware2,
-  fallbackConfig,
-  lazy as lazy2
-} from "@orpc/server";
-import { Cause as Cause2, Effect, Exit, FiberRefs } from "effect";
+import { Builder, fallbackConfig, lazy as lazy2 } from "@orpc/server";
 
 // src/effect-enhance-router.ts
 import {
@@ -44,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,
@@ -178,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;
+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);
   }
-  /**
-   * 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)
-    });
-  }
-  /**
-   * 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);
   }
 };
 
@@ -277,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) {
@@ -323,7 +527,220 @@ function enhanceEffectRouter(router, options) {
   return enhanced;
 }
 
+// src/effect-runtime.ts
+import { ORPCError as ORPCError2 } from "@orpc/contract";
+import { Cause as Cause2, Effect, Exit, FiberRefs } from "effect";
+function toORPCErrorFromCause(cause) {
+  return Cause2.match(cause, {
+    onDie(defect) {
+      return new ORPCError2("INTERNAL_SERVER_ERROR", {
+        cause: defect
+      });
+    },
+    onFail(error) {
+      if (isORPCTaggedError(error)) {
+        return error.toORPCError();
+      }
+      if (error instanceof ORPCError2) {
+        return error;
+      }
+      return new ORPCError2("INTERNAL_SERVER_ERROR", {
+        cause: error
+      });
+    },
+    onInterrupt(fiberId) {
+      return new ORPCError2("INTERNAL_SERVER_ERROR", {
+        cause: new Error(`${fiberId} Interrupted`)
+      });
+    },
+    onSequential(left) {
+      return left;
+    },
+    onEmpty: new ORPCError2("INTERNAL_SERVER_ERROR", {
+      cause: new Error("Unknown error")
+    }),
+    onParallel(left) {
+      return left;
+    }
+  });
+}
+function createEffectProcedureHandler(options) {
+  const {
+    runtime,
+    effectErrorMap,
+    effectFn,
+    spanConfig,
+    defaultCaptureStackTrace
+  } = options;
+  return async (opts) => {
+    const effectOpts = {
+      context: opts.context,
+      input: opts.input,
+      path: opts.path,
+      procedure: opts.procedure,
+      signal: opts.signal,
+      lastEventId: opts.lastEventId,
+      errors: createEffectErrorConstructorMap(effectErrorMap)
+    };
+    const spanName = spanConfig?.name ?? opts.path.join(".");
+    const captureStackTrace = spanConfig?.captureStackTrace ?? defaultCaptureStackTrace;
+    const resolver = Effect.fnUntraced(effectFn);
+    const tracedEffect = Effect.withSpan(resolver(effectOpts), spanName, {
+      captureStackTrace
+    });
+    const parentFiberRefs = getCurrentFiberRefs();
+    const effectWithRefs = parentFiberRefs ? Effect.fiberIdWith(
+      (fiberId) => Effect.flatMap(
+        Effect.getFiberRefs,
+        (fiberRefs) => Effect.setFiberRefs(
+          FiberRefs.joinAs(fiberRefs, fiberId, parentFiberRefs)
+        ).pipe(Effect.andThen(tracedEffect))
+      )
+    ) : tracedEffect;
+    const exit = await runtime.runPromiseExit(effectWithRefs, {
+      signal: opts.signal
+    });
+    if (Exit.isFailure(exit)) {
+      throw toORPCErrorFromCause(exit.cause);
+    }
+    return exit.value;
+  };
+}
+
 // 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;
@@ -344,381 +761,292 @@ 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
+    attachEffectState(this, builder ?? new Builder(orpcDef), {
+      effectErrorMap,
+      runtime,
+      spanConfig
     });
+    return createEffectBuilderProxy(this);
   }
-  /**
-   * 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
-    });
+};
+function makeEffectORPC(runtime, builder) {
+  const resolvedBuilder = builder ?? emptyBuilder();
+  const effectErrorMap = getEffectErrorMap(resolvedBuilder);
+  return new EffectBuilder(
+    {
+      ...resolvedBuilder["~orpc"],
+      effectErrorMap,
+      errorMap: effectErrorMapToErrorMap(effectErrorMap),
+      runtime
+    },
+    unwrapEffectUpstream(resolvedBuilder)
+  );
+}
+function emptyBuilder() {
+  return new Builder({
+    config: {},
+    dedupeLeadingMiddlewares: true,
+    errorMap: {},
+    inputValidationIndex: fallbackConfig("initialInputValidationIndex"),
+    meta: {},
+    middlewares: [],
+    outputValidationIndex: fallbackConfig("initialOutputValidationIndex"),
+    route: {}
+  });
+}
+
+// src/eoc.ts
+import { isContractProcedure, oc } from "@orpc/contract";
+var effectContractSymbol = /* @__PURE__ */ Symbol.for(
+  "@orpc/effect/contract"
+);
+function isWrappableContractBuilder(value) {
+  return typeof value === "object" && value !== null && "~orpc" in value;
+}
+function mergeEffectErrorMaps(left, right) {
+  if (!left) {
+    return right;
   }
-  use(middleware, mapInput) {
-    const mapped = mapInput ? decorateMiddleware2(middleware).mapInput(mapInput) : middleware;
-    return new _EffectBuilder({
-      ...this["~effect"],
-      middlewares: addMiddleware2(this["~effect"].middlewares, mapped)
-    });
+  if (!right) {
+    return left;
   }
-  /**
-   * 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)
-    });
+  return {
+    ...left,
+    ...right
+  };
+}
+function setEffectContractErrorMap(value, effectErrorMap) {
+  if (!effectErrorMap) {
+    return;
   }
-  /**
-   * 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)
-    });
+  Object.defineProperty(value, effectContractSymbol, {
+    value: { errorMap: effectErrorMap },
+    enumerable: false,
+    configurable: true
+  });
+}
+function getEffectContractErrorMap(value) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
   }
-  /**
-   * 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
-    });
+  return value[effectContractSymbol]?.errorMap;
+}
+function applyEffectContractErrorMapToRouter(router, source, inheritedEffectErrorMap) {
+  const routerRecord = router;
+  const sourceRecord = source;
+  for (const key of Object.keys(routerRecord)) {
+    const routerValue = routerRecord[key];
+    const sourceValue = sourceRecord && typeof sourceRecord === "object" ? sourceRecord[key] : void 0;
+    if (!routerValue) {
+      continue;
+    }
+    if (isContractProcedure(routerValue)) {
+      const sourceEffectErrorMap = getEffectContractErrorMap(sourceValue);
+      setEffectContractErrorMap(
+        routerValue,
+        mergeEffectErrorMaps(inheritedEffectErrorMap, sourceEffectErrorMap)
+      );
+      continue;
+    }
+    if (typeof routerValue === "object") {
+      applyEffectContractErrorMapToRouter(
+        routerValue,
+        sourceValue,
+        inheritedEffectErrorMap
+      );
+    }
   }
-  /**
-   * 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
-    });
+}
+function wrapEffectContractBuilder(builder, inheritedEffectErrorMap) {
+  const currentEffectErrorMap = inheritedEffectErrorMap ?? getEffectContractErrorMap(builder);
+  if (typeof builder === "object" && builder !== null) {
+    setEffectContractErrorMap(builder, currentEffectErrorMap);
   }
-  /**
-   * 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()
+  const proxy = new Proxy(builder, {
+    get(target, prop, receiver) {
+      if (prop === effectContractSymbol) {
+        return currentEffectErrorMap ? { errorMap: currentEffectErrorMap } : void 0;
       }
-    });
-  }
-  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) => {
-        const effectOpts = {
-          context: opts.context,
-          input: opts.input,
-          path: opts.path,
-          procedure: opts.procedure,
-          signal: opts.signal,
-          lastEventId: opts.lastEventId,
-          errors: createEffectErrorConstructorMap(
-            this["~effect"].effectErrorMap
-          )
+      if (prop === "errors") {
+        return (errors) => {
+          const nextEffectErrorMap = mergeEffectErrorMaps(
+            currentEffectErrorMap,
+            errors
+          );
+          return wrapEffectContractBuilder(
+            Reflect.apply(Reflect.get(target, prop, receiver), target, [
+              effectErrorMapToErrorMap(errors)
+            ]),
+            nextEffectErrorMap
+          );
         };
-        const spanName = spanConfig?.name ?? opts.path.join(".");
-        const captureStackTrace = spanConfig?.captureStackTrace ?? defaultCaptureStackTrace;
-        const resolver = Effect.fnUntraced(effectFn);
-        const tracedEffect = Effect.withSpan(resolver(effectOpts), spanName, {
-          captureStackTrace
-        });
-        const parentFiberRefs = getCurrentFiberRefs();
-        const effectWithRefs = parentFiberRefs ? Effect.fiberIdWith(
-          (fiberId) => Effect.flatMap(
-            Effect.getFiberRefs,
-            (fiberRefs) => Effect.setFiberRefs(
-              FiberRefs.joinAs(fiberRefs, fiberId, parentFiberRefs)
-            ).pipe(Effect.andThen(tracedEffect))
-          )
-        ) : tracedEffect;
-        const exit = await runtime.runPromiseExit(effectWithRefs, {
-          signal: opts.signal
-        });
-        if (Exit.isFailure(exit)) {
-          throw Cause2.match(exit.cause, {
-            onDie(defect) {
-              return new ORPCError2("INTERNAL_SERVER_ERROR", {
-                cause: defect
-              });
-            },
-            onFail(error) {
-              if (isORPCTaggedError(error)) {
-                return error.toORPCError();
-              }
-              if (error instanceof ORPCError2) {
-                return error;
-              }
-              return new ORPCError2("INTERNAL_SERVER_ERROR", {
-                cause: error
-              });
-            },
-            onInterrupt(fiberId) {
-              return new ORPCError2("INTERNAL_SERVER_ERROR", {
-                cause: new Error(`${fiberId} Interrupted`)
-              });
-            },
-            onSequential(left) {
-              return left;
-            },
-            onEmpty: new ORPCError2("INTERNAL_SERVER_ERROR", {
-              cause: new Error("Unknown error")
-            }),
-            onParallel(left) {
-              return left;
-            }
-          });
-        }
-        return exit.value;
       }
-    });
-  }
-  /**
-   * 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"]
-    });
-  }
-};
-function makeEffectORPC(runtime, builder) {
-  const resolvedBuilder = builder ?? emptyBuilder();
-  return new EffectBuilder({
-    ...resolvedBuilder["~orpc"],
-    errorMap: effectErrorMapToErrorMap(resolvedBuilder["~orpc"].errorMap),
-    effectErrorMap: resolvedBuilder["~orpc"].errorMap,
-    runtime
+      if (prop === "router") {
+        return (router) => {
+          const result = Reflect.apply(
+            Reflect.get(target, prop, receiver),
+            target,
+            [router]
+          );
+          applyEffectContractErrorMapToRouter(
+            result,
+            router,
+            currentEffectErrorMap
+          );
+          return result;
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      return (...args) => {
+        const result = Reflect.apply(value, target, args);
+        return isWrappableContractBuilder(result) ? wrapEffectContractBuilder(result, currentEffectErrorMap) : result;
+      };
+    }
   });
+  setEffectContractErrorMap(proxy, currentEffectErrorMap);
+  return proxy;
 }
-function emptyBuilder() {
-  return new Builder({
-    config: {},
-    route: {},
-    meta: {},
-    errorMap: {},
-    inputValidationIndex: fallbackConfig("initialInputValidationIndex"),
-    outputValidationIndex: fallbackConfig("initialOutputValidationIndex"),
+var eoc = wrapEffectContractBuilder(
+  oc,
+  {}
+);
+
+// src/contract.ts
+var CONTRACT_HIDDEN_METHODS = /* @__PURE__ */ new Set([
+  "$config",
+  "$context",
+  "$input",
+  "$meta",
+  "$route",
+  "errors",
+  "input",
+  "lazy",
+  "meta",
+  "middleware",
+  "output",
+  "prefix",
+  "route",
+  "router",
+  "tag"
+]);
+function makeEnhanceOptions(runtime) {
+  return {
     middlewares: [],
-    dedupeLeadingMiddlewares: true
+    errorMap: {},
+    dedupeLeadingMiddlewares: true,
+    runtime
+  };
+}
+function wrapContractNode(contract, target, runtime) {
+  const cache = /* @__PURE__ */ new Map();
+  return new Proxy(target, {
+    get(currentTarget, prop, receiver) {
+      if (cache.has(prop)) {
+        return cache.get(prop);
+      }
+      if (isContractProcedure2(contract)) {
+        if (prop === "effect") {
+          const effect = (effectFn) => {
+            const effectErrorMap = getEffectContractErrorMap(contract) ?? currentTarget["~orpc"].errorMap;
+            return new EffectDecoratedProcedure({
+              ...currentTarget["~orpc"],
+              errorMap: effectErrorMapToErrorMap(effectErrorMap),
+              effectErrorMap,
+              runtime,
+              handler: createEffectProcedureHandler({
+                runtime,
+                effectErrorMap,
+                effectFn,
+                defaultCaptureStackTrace: addSpanStackTrace()
+              })
+            });
+          };
+          cache.set(prop, effect);
+          return effect;
+        }
+        if (prop === "use") {
+          const use = (...args) => wrapContractNode(
+            contract,
+            Reflect.apply(
+              Reflect.get(currentTarget, prop, currentTarget),
+              currentTarget,
+              args
+            ),
+            runtime
+          );
+          cache.set(prop, use);
+          return use;
+        }
+        if (CONTRACT_HIDDEN_METHODS.has(String(prop))) {
+          return void 0;
+        }
+      } else {
+        if (prop === "$context" || prop === "$config" || prop === "use") {
+          const wrappedMethod = (...args) => wrapContractNode(
+            contract,
+            Reflect.apply(
+              Reflect.get(currentTarget, prop, currentTarget),
+              currentTarget,
+              args
+            ),
+            runtime
+          );
+          cache.set(prop, wrappedMethod);
+          return wrappedMethod;
+        }
+        if (prop === "router" || prop === "lazy") {
+          const wrappedMethod = (...args) => enhanceEffectRouter(
+            Reflect.apply(
+              Reflect.get(currentTarget, prop, currentTarget),
+              currentTarget,
+              args
+            ),
+            makeEnhanceOptions(runtime)
+          );
+          cache.set(prop, wrappedMethod);
+          return wrappedMethod;
+        }
+        if (typeof prop === "string" && prop in contract) {
+          const child = wrapContractNode(
+            contract[prop],
+            Reflect.get(currentTarget, prop, receiver),
+            runtime
+          );
+          cache.set(prop, child);
+          return child;
+        }
+      }
+      const value = Reflect.get(currentTarget, prop, receiver);
+      return typeof value === "function" ? value.bind(currentTarget) : value;
+    },
+    has(currentTarget, prop) {
+      if (isContractProcedure2(contract)) {
+        if (prop === "effect") {
+          return true;
+        }
+        if (CONTRACT_HIDDEN_METHODS.has(String(prop))) {
+          return false;
+        }
+      } else if (typeof prop === "string" && prop in contract) {
+        return true;
+      }
+      return Reflect.has(currentTarget, prop);
+    }
   });
 }
+function implementEffect(contract, runtime) {
+  return wrapContractNode(
+    contract,
+    implement(contract),
+    runtime
+  );
+}
 export {
   EffectBuilder,
   EffectDecoratedProcedure,
@@ -727,6 +1055,8 @@ export {
   addSpanStackTrace,
   createEffectErrorConstructorMap,
   effectErrorMapToErrorMap,
+  eoc,
+  implementEffect,
   isORPCTaggedError,
   isORPCTaggedErrorClass,
   makeEffectORPC,