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

package/dist/index.js

@@ -1,20 +1,15 @@
 import {
-  getCurrentServices
-} from "./chunk-I5EWBI42.js";
+  getCurrentServices,
+  runWithServices
+} from "./chunk-SXPXGZUW.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 } 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";
+import { Layer as Layer3 } from "effect";
 
 // src/effect-enhance-router.ts
 import {
@@ -34,12 +29,17 @@ import {
 // src/effect-procedure.ts
 import { mergeMeta, mergeRoute } from "@orpc/contract";
 import {
+  Procedure,
   addMiddleware,
   createActionableClient,
   createProcedureClient,
-  decorateMiddleware,
-  Procedure
+  decorateMiddleware
 } from "@orpc/server";
+import { Layer } from "effect";
+
+// src/effect-runtime.ts
+import { ORPCError as ORPCError2 } from "@orpc/contract";
+import { Cause as Cause2, Effect, Exit, Option, Result } from "effect";
 
 // src/tagged-error.ts
 import {
@@ -174,155 +174,7 @@ function effectErrorMapToErrorMap(errorMap) {
   return result;
 }
 
-// src/effect-procedure.ts
-var EffectProcedure = class extends Procedure {
-  constructor(def) {
-    super(def);
-    this["~effect"] = def;
-  }
-};
-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)
-    });
-  }
-  /**
-   * Make this procedure callable (works like a function while still being a procedure).
-   *
-   * @see {@link https://orpc.dev/docs/client/server-side Server-side Client Docs}
-   */
-  callable(...rest) {
-    const client = createProcedureClient(this, ...rest);
-    return new Proxy(client, {
-      get: (target, key) => {
-        return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
-      },
-      has: (target, key) => {
-        return Reflect.has(this, key) || Reflect.has(target, key);
-      }
-    });
-  }
-  /**
-   * Make this procedure compatible with server action.
-   *
-   * @see {@link https://orpc.dev/docs/server-action Server Action Docs}
-   */
-  actionable(...rest) {
-    const action = createActionableClient(createProcedureClient(this, ...rest));
-    return new Proxy(action, {
-      get: (target, key) => {
-        return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
-      },
-      has: (target, key) => {
-        return Reflect.has(this, key) || Reflect.has(target, key);
-      }
-    });
-  }
-};
-
-// src/effect-enhance-router.ts
-function enhanceEffectRouter(router, options) {
-  if (isLazy(router)) {
-    const laziedMeta = getLazyMeta(router);
-    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);
-      },
-      {
-        ...laziedMeta,
-        prefix: enhancedPrefix
-      }
-    );
-    const accessible = createAccessibleLazyRouter(enhanced2);
-    return accessible;
-  }
-  if (isProcedure(router)) {
-    const newMiddlewares = mergeMiddlewares(
-      options.middlewares,
-      router["~orpc"].middlewares,
-      { dedupeLeading: options.dedupeLeadingMiddlewares }
-    );
-    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
-    const effectErrorMap = {
-      ...options.errorMap,
-      ...router["~orpc"].errorMap
-    };
-    const errorMap = effectErrorMapToErrorMap(effectErrorMap);
-    const enhanced2 = new EffectProcedure({
-      ...router["~orpc"],
-      route: enhanceRoute(router["~orpc"].route, options),
-      effectErrorMap,
-      errorMap,
-      middlewares: newMiddlewares,
-      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
-      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded,
-      runtime: options.runtime
-    });
-    return enhanced2;
-  }
-  const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = enhanceEffectRouter(router[key], options);
-  }
-  return enhanced;
-}
-
 // src/effect-runtime.ts
-import { ORPCError as ORPCError2 } from "@orpc/contract";
-import { Cause as Cause2, Effect, Exit, Result, Context } from "effect";
 function toORPCErrorFromCause(cause) {
   if (Cause2.hasFails(cause)) {
     const reason = Cause2.findFail(cause);
@@ -366,9 +218,10 @@ function toORPCErrorFromCause(cause) {
 }
 function createEffectProcedureHandler(options) {
   const {
-    runtime,
+    runner,
     effectErrorMap,
     effectFn,
+    effectSteps = [],
     spanConfig,
     defaultCaptureStackTrace
   } = options;
@@ -385,371 +238,1073 @@ function createEffectProcedureHandler(options) {
     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 parentServices = getCurrentServices();
-    const exit = parentServices ? await Effect.runPromiseExitWith(
-      Context.merge(await runtime.context(), parentServices)
-    )(tracedEffect, {
-      signal: opts.signal
-    }) : await runtime.runPromiseExit(tracedEffect, {
+    const handlerEffect = resolver(effectOpts);
+    const tracedEffect = Effect.withSpan(
+      runEffectPipeline({
+        baseOptions: effectOpts,
+        effectErrorMap,
+        final: (context) => Effect.map(
+          context === effectOpts.context ? handlerEffect : resolver({ ...effectOpts, context }),
+          (output) => ({ output, context: {} })
+        ),
+        input: opts.input,
+        steps: effectSteps
+      }),
+      spanName,
+      { captureStackTrace }
+    );
+    const exit = await runner.runPromiseExit(tracedEffect, {
       signal: opts.signal
     });
     if (Exit.isFailure(exit)) {
       throw toORPCErrorFromCause(exit.cause);
     }
-    return exit.value;
+    return exit.value.output;
   };
 }
-
-// src/effect-builder.ts
-function addSpanStackTrace() {
-  const ErrorConstructor = Error;
-  const limit = ErrorConstructor.stackTraceLimit;
-  ErrorConstructor.stackTraceLimit = 3;
-  const traceError = new Error();
-  ErrorConstructor.stackTraceLimit = limit;
-  let cache = false;
-  return () => {
-    if (cache !== false) {
-      return cache;
-    }
-    if (traceError.stack !== void 0) {
-      const stack = traceError.stack.split("\n");
-      if (stack[3] !== void 0) {
-        cache = stack[3].trim();
-        return cache;
-      }
-    }
+function createEffectPipelineMiddleware(options) {
+  const { runner, effectErrorMap, steps } = options;
+  return async (opts, input) => {
+    const baseOptions = makeEffectOptions(opts, input, effectErrorMap);
+    const effect = runEffectPipeline({
+      baseOptions,
+      effectErrorMap,
+      final: (context) => withCurrentServiceContext(
+        () => opts.next(
+          context === opts.context ? void 0 : { context }
+        )
+      ),
+      input,
+      steps
+    });
+    const exit = await runner.runPromiseExit(effect, {
+      signal: opts.signal
+    });
+    if (Exit.isFailure(exit)) throw toORPCErrorFromCause(exit.cause);
+    return exit.value;
   };
 }
-var EffectBuilder = class _EffectBuilder {
-  constructor(def) {
-    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
+function createEffectProviderMiddleware(options) {
+  const { runner, effectErrorMap, tag, provider } = options;
+  return async (opts, input) => {
+    const effectOpts = makeEffectOptions(opts, input, effectErrorMap);
+    const effect = Effect.flatMap(
+      provider(effectOpts),
+      (service) => Effect.provideService(
+        withCurrentServiceContext(() => opts.next()),
+        tag,
+        service
+      )
     );
-    const outputValidationCount = this["~effect"].outputValidationIndex - fallbackConfig(
-      "initialOutputValidationIndex",
-      this["~effect"].config.initialOutputValidationIndex
+    const exit = await runner.runPromiseExit(effect, {
+      signal: opts.signal
+    });
+    if (Exit.isFailure(exit)) throw toORPCErrorFromCause(exit.cause);
+    return exit.value;
+  };
+}
+function createEffectOptionalProviderMiddleware(options) {
+  const { runner, effectErrorMap, tag, provider } = options;
+  return async (opts, input) => {
+    const effectOpts = makeEffectOptions(opts, input, effectErrorMap);
+    const effect = Effect.flatMap(
+      provider(effectOpts),
+      (service) => Option.match(service, {
+        onNone: () => withCurrentServiceContext(() => opts.next()),
+        onSome: (value) => Effect.provideService(
+          withCurrentServiceContext(() => opts.next()),
+          tag,
+          value
+        )
+      })
     );
-    return new _EffectBuilder({
-      ...this["~effect"],
-      config,
-      dedupeLeadingMiddlewares: fallbackConfig(
-        "dedupeLeadingMiddlewares",
-        config.dedupeLeadingMiddlewares
-      ),
-      inputValidationIndex: fallbackConfig(
-        "initialInputValidationIndex",
-        config.initialInputValidationIndex
-      ) + inputValidationCount,
-      outputValidationIndex: fallbackConfig(
-        "initialOutputValidationIndex",
-        config.initialOutputValidationIndex
-      ) + outputValidationCount
+    const exit = await runner.runPromiseExit(effect, {
+      signal: opts.signal
     });
-  }
-  /**
-   * 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
+    if (Exit.isFailure(exit)) throw toORPCErrorFromCause(exit.cause);
+    return exit.value;
+  };
+}
+function isEffectMiddleware(value) {
+  return typeof value === "function" && value.constructor?.name === "GeneratorFunction";
+}
+function makeEffectOptions(opts, input, effectErrorMap) {
+  return {
+    context: opts.context,
+    input,
+    path: opts.path,
+    procedure: opts.procedure,
+    signal: opts.signal,
+    lastEventId: opts.lastEventId,
+    errors: createEffectErrorConstructorMap(effectErrorMap)
+  };
+}
+function runEffectPipeline(options) {
+  const run = (index, context) => {
+    const step = options.steps[index];
+    if (!step) return options.final(context);
+    const stepOptions = { ...options.baseOptions, context };
+    if (step._tag === "provide") {
+      return Effect.flatMap(
+        step.provider(stepOptions),
+        (service) => Effect.provideService(run(index + 1, context), step.tag, service)
+      );
+    }
+    if (step._tag === "provideOptional") {
+      return Effect.flatMap(
+        step.provider(stepOptions),
+        (service) => Option.match(service, {
+          onNone: () => run(index + 1, context),
+          onSome: (value) => Effect.provideService(run(index + 1, context), step.tag, value)
+        })
+      );
+    }
+    if (step._tag === "provideLayer") {
+      return Effect.provide(run(index + 1, context), step.layer);
+    }
+    const nextTracker = createMiddlewareNextTracker();
+    const effectOptions = {
+      context,
+      path: stepOptions.path,
+      procedure: stepOptions.procedure,
+      signal: stepOptions.signal,
+      lastEventId: stepOptions.lastEventId,
+      errors: createEffectErrorConstructorMap(options.effectErrorMap),
+      next: nextTracker.wrapNext(
+        (...rest) => {
+          const nextContext = rest[0]?.context ?? {};
+          return Effect.map(
+            run(index + 1, { ...context, ...nextContext }),
+            (result) => ({
+              output: result.output,
+              context: nextContext
+            })
+          );
+        }
       )
-    });
+    };
+    const effectOutput = makeEffectMiddlewareOutput((output) => ({ output, context: {} }));
+    const middlewareEffect = Effect.fnUntraced(step.middleware)(
+      effectOptions,
+      options.input,
+      effectOutput
+    );
+    return Effect.flatMap(
+      middlewareEffect,
+      (result) => resolveEffectMiddlewareContinuation({
+        autoNext: () => effectOptions.next(),
+        nextInvoked: nextTracker.nextInvoked,
+        nextResult: nextTracker.nextResult,
+        result
+      })
+    );
+  };
+  return run(0, options.baseOptions.context);
+}
+function createMiddlewareNextTracker() {
+  let nextInvoked = false;
+  let nextResult;
+  return {
+    get nextInvoked() {
+      return nextInvoked;
+    },
+    get nextResult() {
+      return nextResult;
+    },
+    wrapNext(nextFn) {
+      return ((...args) => {
+        nextInvoked = true;
+        return Effect.map(nextFn(...args), (result) => {
+          nextResult = result;
+          return result;
+        });
+      });
+    }
+  };
+}
+function resolveEffectMiddlewareContinuation(options) {
+  const { result, nextInvoked, nextResult, autoNext } = options;
+  if (result !== void 0) {
+    return Effect.succeed(result);
   }
-  /**
-   * Sets or overrides the initial meta.
-   *
-   * @see {@link https://orpc.dev/docs/metadata Metadata Docs}
-   */
-  $meta(initialMeta) {
-    return new _EffectBuilder({
-      ...this["~effect"],
-      meta: initialMeta
-    });
+  if (nextInvoked) {
+    if (nextResult === void 0) {
+      return Effect.die(
+        new Error(
+          "Effect middleware invoked next() but did not return its result"
+        )
+      );
+    }
+    return Effect.succeed(nextResult);
   }
-  /**
-   * 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
-    });
+  return autoNext();
+}
+function makeEffectMiddlewareOutput(output) {
+  return (value) => withCurrentServiceContext(() => output(value));
+}
+function withCurrentServiceContext(fn) {
+  return Effect.flatMap(
+    Effect.context(),
+    (services) => Effect.promise(
+      () => runWithServices(services, () => Promise.resolve(fn()))
+    )
+  );
+}
+
+// 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");
   }
-  /**
-   * 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
-    });
+}
+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);
   }
-  /**
-   * Creates a middleware.
-   *
-   * @see {@link https://orpc.dev/docs/middleware Middleware Docs}
-   */
-  middleware(middleware) {
-    return decorateMiddleware2(middleware);
+  const wrapped = (...args) => {
+    const nextArgs = config.wrapArgs?.(context, prop, args, receiver) ?? args;
+    const result = Reflect.apply(value, context.upstream, nextArgs);
+    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/effect-procedure.ts
+var procedureVirtualDescriptors = {
+  "~effect": { enumerable: true },
+  actionable: { enumerable: false },
+  callable: { enumerable: false },
+  errors: { enumerable: false },
+  meta: { enumerable: false },
+  provide: { enumerable: false },
+  provideOptional: { enumerable: false },
+  route: { enumerable: false },
+  use: { enumerable: false }
+};
+var baseProcedureVirtualKeys = ["~effect"];
+var decoratedProcedureVirtualKeys = [
+  ...baseProcedureVirtualKeys,
+  "errors",
+  "meta",
+  "provide",
+  "provideOptional",
+  "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.
-   *
-   * @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
-    });
+  const value = factory();
+  cache.set(prop, value);
+  return value;
+}
+function getEffectProcedureDef(context) {
+  return {
+    ...context.upstream["~orpc"],
+    effectSteps: context.state.effectSteps,
+    effectHandler: context.state.effectHandler,
+    effectErrorMap: context.state.effectErrorMap,
+    runner: context.state.runner
+  };
+}
+function makeEffectProcedureHandler(def) {
+  if (!def.effectHandler) {
+    return def.handler;
   }
-  use(middleware, mapInput) {
-    const mapped = mapInput ? decorateMiddleware2(middleware).mapInput(mapInput) : middleware;
-    return new _EffectBuilder({
-      ...this["~effect"],
-      middlewares: addMiddleware2(this["~effect"].middlewares, mapped)
-    });
+  return createEffectProcedureHandler({
+    defaultCaptureStackTrace: def.effectHandler.defaultCaptureStackTrace,
+    effectErrorMap: def.effectErrorMap,
+    effectFn: def.effectHandler.effectFn,
+    effectSteps: def.effectSteps,
+    runner: def.runner,
+    spanConfig: def.effectHandler.spanConfig
+  });
+}
+function withRebuiltEffectHandler(def) {
+  return {
+    ...def,
+    handler: makeEffectProcedureHandler(def)
+  };
+}
+function appendEffectStep(def, step) {
+  return withRebuiltEffectHandler({
+    ...def,
+    effectSteps: [...def.effectSteps ?? [], step]
+  });
+}
+function flushEffectSteps(def) {
+  if (!def.effectSteps?.length) {
+    return def;
   }
-  /**
-   * 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)
+  const middleware = createEffectPipelineMiddleware({
+    effectErrorMap: def.effectErrorMap,
+    runner: def.runner,
+    steps: def.effectSteps
+  });
+  return withRebuiltEffectHandler({
+    ...def,
+    effectSteps: void 0,
+    middlewares: addMiddleware(def.middlewares, middleware)
+  });
+}
+function createEffectProcedureProxy(target, decorated) {
+  return createNodeProxy(target, {
+    getVirtual(context, prop, receiver) {
+      if (prop === "~effect") {
+        return getEffectProcedureDef(context);
+      }
+      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 "provide":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (tagOrLayer, provider) => {
+              const def = getEffectProcedureDef(context);
+              if (Layer.isLayer(tagOrLayer)) {
+                const step = {
+                  _tag: "provideLayer",
+                  layer: tagOrLayer
+                };
+                if (def.effectHandler) {
+                  return new EffectDecoratedProcedure(
+                    appendEffectStep(def, step)
+                  );
+                }
+                return new EffectDecoratedProcedure({
+                  ...def,
+                  middlewares: addMiddleware(
+                    def.middlewares,
+                    createEffectPipelineMiddleware({
+                      effectErrorMap: state.effectErrorMap,
+                      runner: state.runner,
+                      steps: [step]
+                    })
+                  )
+                });
+              }
+              if (def.effectHandler) {
+                return new EffectDecoratedProcedure(
+                  appendEffectStep(def, {
+                    _tag: "provide",
+                    provider,
+                    tag: tagOrLayer
+                  })
+                );
+              }
+              return new EffectDecoratedProcedure({
+                ...def,
+                middlewares: addMiddleware(
+                  def.middlewares,
+                  createEffectProviderMiddleware({
+                    effectErrorMap: state.effectErrorMap,
+                    provider,
+                    runner: state.runner,
+                    tag: tagOrLayer
+                  })
+                )
+              });
+            };
+          });
+        case "provideOptional":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (tag, provider) => {
+              const def = getEffectProcedureDef(context);
+              if (def.effectHandler) {
+                return new EffectDecoratedProcedure(
+                  appendEffectStep(def, {
+                    _tag: "provideOptional",
+                    provider,
+                    tag
+                  })
+                );
+              }
+              return new EffectDecoratedProcedure({
+                ...def,
+                middlewares: addMiddleware(
+                  def.middlewares,
+                  createEffectOptionalProviderMiddleware({
+                    effectErrorMap: state.effectErrorMap,
+                    provider,
+                    runner: state.runner,
+                    tag
+                  })
+                )
+              });
+            };
+          });
+        case "use":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (middleware, mapInput) => {
+              const def = getEffectProcedureDef(context);
+              if (!mapInput && isEffectMiddleware(middleware)) {
+                return new EffectDecoratedProcedure(
+                  appendEffectStep(def, {
+                    _tag: "middleware",
+                    middleware
+                  })
+                );
+              }
+              const flushedDef = flushEffectSteps(def);
+              const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+              return new EffectDecoratedProcedure({
+                ...flushedDef,
+                middlewares: addMiddleware(flushedDef.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) {
+    const { effectSteps, effectHandler, ...procedureDef } = def;
+    super(procedureDef);
+    attachEffectState(this, procedure ?? new Procedure(procedureDef), {
+      effectSteps,
+      effectHandler,
+      effectErrorMap: def.effectErrorMap,
+      runner: def.runner
     });
+    if (new.target === _EffectProcedure) {
+      return createEffectProcedureProxy(this, false);
+    }
   }
-  /**
-   * 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)
-    });
+};
+var EffectDecoratedProcedure = class extends EffectProcedure {
+  constructor(def, procedure) {
+    super(def, procedure);
+    assertEffectState(this);
+    return createEffectProcedureProxy(this, true);
   }
-  /**
-   * 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
-    });
+};
+
+// src/effect-enhance-router.ts
+function enhanceEffectRouter(router, options) {
+  if (isLazy(router)) {
+    const laziedMeta = getLazyMeta(router);
+    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta.prefix) : options.prefix;
+    const enhanced2 = lazy(
+      async () => {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const wrappedRouter = enhanceEffectRouter(unlaziedRouter, options);
+        return unlazy(wrappedRouter);
+      },
+      {
+        ...laziedMeta,
+        prefix: enhancedPrefix
+      }
+    );
+    return createAccessibleLazyRouter(enhanced2);
   }
-  /**
-   * 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
+  if (isProcedure(router)) {
+    const source = unwrapEffectUpstream(router);
+    const sourceEffectErrorMap = getEffectErrorMap(router);
+    const middlewares = mergeMiddlewares(
+      options.middlewares,
+      source["~orpc"].middlewares,
+      { dedupeLeading: options.dedupeLeadingMiddlewares }
+    );
+    const newMiddlewareAdded = middlewares.length - source["~orpc"].middlewares.length;
+    const effectErrorMap = {
+      ...options.errorMap,
+      ...sourceEffectErrorMap
+    };
+    const errorMap = effectErrorMapToErrorMap(effectErrorMap);
+    return new EffectProcedure({
+      ...source["~orpc"],
+      route: enhanceRoute(source["~orpc"].route, options),
+      effectErrorMap,
+      errorMap,
+      middlewares,
+      inputValidationIndex: source["~orpc"].inputValidationIndex + newMiddlewareAdded,
+      outputValidationIndex: source["~orpc"].outputValidationIndex + newMiddlewareAdded,
+      runner: options.runner
     });
   }
-  /**
-   * 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 enhanced = {};
+  for (const key in router) {
+    enhanced[key] = enhanceEffectRouter(router[key], options);
   }
-  handler(handler) {
-    return new EffectDecoratedProcedure({
-      ...this["~effect"],
-      handler
-    });
+  return enhanced;
+}
+
+// src/runtime-source.ts
+import { Context, Effect as Effect2, Layer as Layer2, ManagedRuntime } from "effect";
+function makeEffectRuntimeRunner(source) {
+  if (source === void 0) {
+    return {
+      runPromiseExit: (effect, options) => runPromiseExitWithCurrentServices(effect, options)
+    };
   }
-  /**
-   * 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);
-      }
-    });
+  if (ManagedRuntime.isManagedRuntime(source)) {
+    const runtime = source;
+    return {
+      runtime,
+      runPromiseExit: (effect, options) => runManagedRuntimePromiseExit(runtime, effect, options)
+    };
   }
-  /**
-   * 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)
-    });
+  const layer = source;
+  return {
+    runPromiseExit: (effect, options) => Effect2.runPromiseExit(
+      provideLayerWithCurrentServices(effect, layer),
+      { signal: options?.signal }
+    )
+  };
+}
+function runPromiseExitWithCurrentServices(effect, options) {
+  const parentServices = getCurrentServices();
+  return parentServices ? Effect2.runPromiseExitWith(parentServices)(effect, {
+    signal: options?.signal
+  }) : Effect2.runPromiseExit(effect, {
+    signal: options?.signal
+  });
+}
+async function runManagedRuntimePromiseExit(runtime, effect, options) {
+  const parentServices = getCurrentServices();
+  return parentServices ? Effect2.runPromiseExitWith(
+    Context.merge(await runtime.context(), parentServices)
+  )(effect, { signal: options?.signal }) : runtime.runPromiseExit(effect, { signal: options?.signal });
+}
+function provideLayerWithCurrentServices(effect, layer) {
+  const parentServices = getCurrentServices();
+  if (!parentServices) {
+    return Effect2.provide(effect, layer);
   }
-  /**
-   * 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)
-    });
+  return Effect2.scoped(
+    Effect2.flatMap(
+      Layer2.build(layer),
+      (layerContext) => Effect2.provide(
+        effect,
+        Context.merge(layerContext, parentServices)
+      )
+    )
+  );
+}
+
+// src/effect-builder.ts
+var builderVirtualDescriptors = {
+  "~effect": { enumerable: true },
+  effect: { enumerable: false },
+  errors: { enumerable: false },
+  handler: { enumerable: false },
+  lazy: { enumerable: false },
+  middleware: { enumerable: false },
+  provide: { enumerable: false },
+  provideOptional: { enumerable: false },
+  router: { enumerable: false },
+  traced: { enumerable: false }
+};
+var builderVirtualKeys = [
+  "~effect",
+  "errors",
+  "effect",
+  "middleware",
+  "provide",
+  "provideOptional",
+  "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);
   }
-  /**
-   * 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"]
-    });
+  const value = factory();
+  cache.set(prop, value);
+  return value;
+}
+function getEffectBuilderDef(context) {
+  return {
+    ...context.upstream["~orpc"],
+    effectErrorMap: context.state.effectErrorMap,
+    runner: context.state.runner,
+    spanConfig: context.state.spanConfig,
+    effectSteps: context.state.effectSteps,
+    effectHandler: context.state.effectHandler
+  };
+}
+function wrapBuilderLike(builder, state) {
+  return new EffectBuilder(
+    {
+      ...builder["~orpc"],
+      effectErrorMap: state.effectErrorMap,
+      runner: state.runner,
+      spanConfig: state.spanConfig,
+      effectSteps: state.effectSteps,
+      effectHandler: state.effectHandler
+    },
+    unwrapEffectUpstream(builder)
+  );
+}
+function appendEffectStep2(state, step) {
+  return {
+    ...state,
+    effectSteps: [...state.effectSteps ?? [], step]
+  };
+}
+function flushEffectSteps2(builder, state) {
+  if (!state.effectSteps?.length) {
+    return { builder, state };
   }
-  /**
-   * 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"]
+  const middleware = createEffectPipelineMiddleware({
+    effectErrorMap: state.effectErrorMap,
+    runner: state.runner,
+    steps: state.effectSteps
+  });
+  return {
+    builder: Reflect.apply(Reflect.get(builder, "use", builder), builder, [
+      middleware
+    ]),
+    state: {
+      ...state,
+      effectSteps: void 0
+    }
+  };
+}
+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();
+              const effectHandler = {
+                defaultCaptureStackTrace,
+                effectFn,
+                spanConfig: state.spanConfig
+              };
+              return new EffectDecoratedProcedure({
+                ...effectDef,
+                effectHandler,
+                handler: async (opts) => {
+                  return createEffectProcedureHandler({
+                    defaultCaptureStackTrace,
+                    effectErrorMap: state.effectErrorMap,
+                    effectFn,
+                    effectSteps: state.effectSteps,
+                    runner: state.runner,
+                    spanConfig: state.spanConfig
+                  })(opts);
+                }
+              });
+            };
+          });
+        case "middleware":
+          return getOrCreateVirtualMethod2(context, prop, () => {
+            return (middleware) => {
+              if (isEffectMiddleware(middleware)) {
+                const effectMiddleware = createEffectPipelineMiddleware({
+                  effectErrorMap: state.effectErrorMap,
+                  runner: state.runner,
+                  steps: [
+                    ...state.effectSteps ?? [],
+                    { _tag: "middleware", middleware }
+                  ]
+                });
+                return Reflect.apply(
+                  Reflect.get(source, "middleware", source),
+                  source,
+                  [effectMiddleware]
+                );
+              }
+              return Reflect.apply(
+                Reflect.get(source, "middleware", source),
+                source,
+                [middleware]
+              );
+            };
+          });
+        case "provide":
+          return getOrCreateVirtualMethod2(context, prop, () => {
+            return (tagOrLayer, provider) => {
+              return wrapBuilderLike(
+                source,
+                appendEffectStep2(
+                  state,
+                  Layer3.isLayer(tagOrLayer) ? { _tag: "provideLayer", layer: tagOrLayer } : { _tag: "provide", provider, tag: tagOrLayer }
+                )
+              );
+            };
+          });
+        case "provideOptional":
+          return getOrCreateVirtualMethod2(context, prop, () => {
+            return (tag, provider) => {
+              return wrapBuilderLike(
+                source,
+                appendEffectStep2(state, {
+                  _tag: "provideOptional",
+                  provider,
+                  tag
+                })
+              );
+            };
+          });
+        case "use":
+          return getOrCreateVirtualMethod2(context, prop, () => {
+            return (middleware, ...rest) => {
+              if (isEffectMiddleware(middleware) && rest.length === 0) {
+                return wrapBuilderLike(
+                  source,
+                  appendEffectStep2(state, {
+                    _tag: "middleware",
+                    middleware
+                  })
+                );
+              }
+              const flushed = flushEffectSteps2(source, state);
+              const nextBuilder = Reflect.apply(
+                Reflect.get(flushed.builder, "use", flushed.builder),
+                flushed.builder,
+                [middleware, ...rest]
+              );
+              return wrapBuilderLike(nextBuilder, flushed.state);
+            };
+          });
+        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;
+  ErrorConstructor.stackTraceLimit = 3;
+  const traceError = new Error();
+  ErrorConstructor.stackTraceLimit = limit;
+  let cache = false;
+  return () => {
+    if (cache !== false) {
+      return cache;
+    }
+    if (traceError.stack !== void 0) {
+      const stack = traceError.stack.split("\n");
+      if (stack[3] !== void 0) {
+        cache = stack[3].trim();
+        return cache;
+      }
+    }
+  };
+}
+var EffectBuilder = class {
+  constructor(def, builder) {
+    const { runner, spanConfig, effectErrorMap, effectSteps, ...orpcDef } = def;
+    attachEffectState(this, builder ?? new Builder(orpcDef), {
+      effectSteps,
+      effectHandler: def.effectHandler,
+      effectErrorMap,
+      runner,
+      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
-  });
+function makeEffectORPC(source, builder) {
+  const sourceIsBuilder = source !== void 0 && isBuilderLike(source);
+  const resolvedBuilder = sourceIsBuilder ? source : builder ?? emptyBuilder();
+  const effectErrorMap = getEffectErrorMap(resolvedBuilder);
+  const runner = sourceIsBuilder || source === void 0 ? makeEffectRuntimeRunner() : makeEffectRuntimeRunner(source);
+  return new EffectBuilder(
+    {
+      ...resolvedBuilder["~orpc"],
+      effectErrorMap,
+      errorMap: effectErrorMapToErrorMap(effectErrorMap),
+      runner
+    },
+    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: {}
   });
 }
+var eos = makeEffectORPC();
 
 // src/eoc.ts
 import { isContractProcedure, oc } from "@orpc/contract";
@@ -888,15 +1443,15 @@ var CONTRACT_HIDDEN_METHODS = /* @__PURE__ */ new Set([
   "router",
   "tag"
 ]);
-function makeEnhanceOptions(runtime) {
+function makeEnhanceOptions(runner) {
   return {
     middlewares: [],
     errorMap: {},
     dedupeLeadingMiddlewares: true,
-    runtime
+    runner
   };
 }
-function wrapContractNode(contract, target, runtime) {
+function wrapContractNode(contract, target, runner) {
   const cache = /* @__PURE__ */ new Map();
   return new Proxy(target, {
     get(currentTarget, prop, receiver) {
@@ -911,9 +1466,9 @@ function wrapContractNode(contract, target, runtime) {
               ...currentTarget["~orpc"],
               errorMap: effectErrorMapToErrorMap(effectErrorMap),
               effectErrorMap,
-              runtime,
+              runner,
               handler: createEffectProcedureHandler({
-                runtime,
+                runner,
                 effectErrorMap,
                 effectFn,
                 defaultCaptureStackTrace: addSpanStackTrace()
@@ -931,7 +1486,7 @@ function wrapContractNode(contract, target, runtime) {
               currentTarget,
               args
             ),
-            runtime
+            runner
           );
           cache.set(prop, use);
           return use;
@@ -948,7 +1503,7 @@ function wrapContractNode(contract, target, runtime) {
               currentTarget,
               args
             ),
-            runtime
+            runner
           );
           cache.set(prop, wrappedMethod);
           return wrappedMethod;
@@ -960,7 +1515,7 @@ function wrapContractNode(contract, target, runtime) {
               currentTarget,
               args
             ),
-            makeEnhanceOptions(runtime)
+            makeEnhanceOptions(runner)
           );
           cache.set(prop, wrappedMethod);
           return wrappedMethod;
@@ -969,7 +1524,7 @@ function wrapContractNode(contract, target, runtime) {
           const child = wrapContractNode(
             contract[prop],
             Reflect.get(currentTarget, prop, receiver),
-            runtime
+            runner
           );
           cache.set(prop, child);
           return child;
@@ -993,11 +1548,11 @@ function wrapContractNode(contract, target, runtime) {
     }
   });
 }
-function implementEffect(contract, runtime) {
+function implementEffect(contract, source) {
   return wrapContractNode(
     contract,
     implement(contract),
-    runtime
+    makeEffectRuntimeRunner(source)
   );
 }
 export {
@@ -1009,6 +1564,7 @@ export {
   createEffectErrorConstructorMap,
   effectErrorMapToErrorMap,
   eoc,
+  eos,
   implementEffect,
   isORPCTaggedError,
   isORPCTaggedErrorClass,