effect-orpc 0.2.2 → 0.4.0

package/dist/index.js

@@ -1,6 +1,7 @@
 import {
-  getCurrentFiberRefs
-} from "./chunk-VOWRLWZZ.js";
+  getCurrentFiberRefs,
+  runWithFiberRefs
+} from "./chunk-IJP6L2XR.js";
 
 // src/contract.ts
 import { isContractProcedure as isContractProcedure2 } from "@orpc/contract";
@@ -8,6 +9,7 @@ import { implement } from "@orpc/server";
 
 // src/effect-builder.ts
 import { Builder, fallbackConfig, lazy as lazy2 } from "@orpc/server";
+import { Layer as Layer3 } from "effect";
 
 // src/effect-enhance-router.ts
 import {
@@ -27,12 +29,420 @@ 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 } from "effect";
+
+// src/tagged-error.ts
+import {
+  fallbackORPCErrorMessage,
+  fallbackORPCErrorStatus,
+  isORPCErrorStatus,
+  ORPCError
+} from "@orpc/client";
+import { resolveMaybeOptionalOptions } from "@orpc/shared";
+import "effect/Cause";
+import * as Data from "effect/Data";
+var ORPCErrorSymbol = /* @__PURE__ */ Symbol.for(
+  "@orpc/effect/ORPCTaggedError"
+);
+function isORPCTaggedErrorClass(value) {
+  return typeof value === "function" && "_tag" in value && "code" in value && typeof value._tag === "string" && typeof value.code === "string";
+}
+function isORPCTaggedError(value) {
+  return typeof value === "object" && value !== null && ORPCErrorSymbol in value;
+}
+function toConstantCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toUpperCase();
+}
+function ORPCTaggedError(tag, props) {
+  const code = props?.code ?? toConstantCase(tag);
+  class ORPCTaggedErrorBase extends Data.TaggedError(tag) {
+    status;
+    defined;
+    data;
+    code = code;
+    schema = props?.schema;
+    [ORPCErrorSymbol];
+    constructor(...rest) {
+      super();
+      const opts = resolveMaybeOptionalOptions(rest);
+      const status = opts.status ?? props?.status;
+      if (status !== void 0 && !isORPCErrorStatus(status)) {
+        throw new globalThis.Error(
+          "[ORPCTaggedError] Invalid error status code."
+        );
+      }
+      this.status = fallbackORPCErrorStatus(code, status);
+      this.defined = opts.defined ?? true;
+      this.data = opts.data;
+      this.message = fallbackORPCErrorMessage(
+        this.code,
+        opts.message ?? props?.message
+      );
+      this.cause = opts.cause;
+      this[ORPCErrorSymbol] = new ORPCError(
+        this.code,
+        {
+          status: this.status,
+          message: this.message,
+          data: this.data,
+          defined: this.defined,
+          cause: this.cause
+        }
+      );
+    }
+    /**
+     * Converts this error to a plain ORPCError.
+     * Useful when you need to return from an oRPC handler.
+     */
+    toORPCError() {
+      return this[ORPCErrorSymbol];
+    }
+    toJSON() {
+      return {
+        _tag: this._tag,
+        defined: this[ORPCErrorSymbol].defined,
+        code: this[ORPCErrorSymbol].code,
+        status: this[ORPCErrorSymbol].status,
+        message: this[ORPCErrorSymbol].message,
+        data: this[ORPCErrorSymbol].data
+      };
+    }
+  }
+  return Object.assign(ORPCTaggedErrorBase, {
+    _tag: tag,
+    code
+  });
+}
+function toORPCError(error) {
+  return error[ORPCErrorSymbol];
+}
+function createEffectErrorConstructorMap(errors) {
+  const target = errors ?? {};
+  const proxy = new Proxy(target, {
+    get(proxyTarget, code) {
+      if (typeof code !== "string") {
+        return Reflect.get(proxyTarget, code);
+      }
+      const config = target[code];
+      if (isORPCTaggedErrorClass(config)) {
+        return (...opts) => new config(...opts);
+      }
+      return (...rest) => {
+        const options = resolveMaybeOptionalOptions(rest);
+        return new ORPCError(code, {
+          defined: Boolean(config),
+          status: config?.status,
+          message: options.message ?? config?.message,
+          data: options.data,
+          cause: options.cause
+        });
+      };
+    }
+  });
+  return proxy;
+}
+function effectErrorMapToErrorMap(errorMap) {
+  const result = {};
+  if (!errorMap) {
+    return result;
+  }
+  for (const [code, ClassOrErrorItem] of Object.entries(errorMap)) {
+    if (!ClassOrErrorItem) {
+      continue;
+    }
+    if (isORPCTaggedErrorClass(ClassOrErrorItem)) {
+      const classInstance = new ClassOrErrorItem();
+      result[classInstance.code] = {
+        status: classInstance.status,
+        message: classInstance.message,
+        data: classInstance.schema
+      };
+    } else {
+      result[code] = ClassOrErrorItem;
+    }
+  }
+  return result;
+}
+
+// src/effect-runtime.ts
+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 {
+    runner,
+    effectErrorMap,
+    effectFn,
+    effectSteps = [],
+    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 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.output;
+  };
+}
+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) => withCurrentFiberContext(
+        () => 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;
+  };
+}
+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(
+        withCurrentFiberContext(() => opts.next()),
+        tag,
+        service
+      )
+    );
+    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: () => withCurrentFiberContext(() => opts.next()),
+        onSome: (value) => Effect.provideService(
+          withCurrentFiberContext(() => opts.next()),
+          tag,
+          value
+        )
+      })
+    );
+    const exit = await runner.runPromiseExit(effect, {
+      signal: opts.signal
+    });
+    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);
+  }
+  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);
+  }
+  return autoNext();
+}
+function makeEffectMiddlewareOutput(output) {
+  return (value) => withCurrentFiberContext(() => output(value));
+}
+function withCurrentFiberContext(fn) {
+  return Effect.flatMap(
+    Effect.getFiberRefs,
+    (fiberRefs) => Effect.promise(
+      () => runWithFiberRefs(fiberRefs, () => Promise.resolve(fn()))
+    )
+  );
+}
 
 // src/extension/compose-surfaces.ts
 function composeSurfaceProxy(surface, target) {
@@ -98,7 +508,8 @@ function createBoundMethod(context, prop, value, config, receiver) {
     return cache.get(prop);
   }
   const wrapped = (...args) => {
-    const result = Reflect.apply(value, context.upstream, 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);
@@ -158,184 +569,51 @@ function createNodeProxy(target, config) {
       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,
-  fallbackORPCErrorStatus,
-  isORPCErrorStatus,
-  ORPCError
-} from "@orpc/client";
-import { resolveMaybeOptionalOptions } from "@orpc/shared";
-import "effect/Cause";
-import * as Data from "effect/Data";
-var ORPCErrorSymbol = /* @__PURE__ */ Symbol.for(
-  "@orpc/effect/ORPCTaggedError"
-);
-function isORPCTaggedErrorClass(value) {
-  return typeof value === "function" && "_tag" in value && "code" in value && typeof value._tag === "string" && typeof value.code === "string";
-}
-function isORPCTaggedError(value) {
-  return typeof value === "object" && value !== null && ORPCErrorSymbol in value;
-}
-function toConstantCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toUpperCase();
-}
-function ORPCTaggedError(tag, props) {
-  const code = props?.code ?? toConstantCase(tag);
-  class ORPCTaggedErrorBase extends Data.TaggedError(tag) {
-    status;
-    defined;
-    data;
-    code = code;
-    schema = props?.schema;
-    [ORPCErrorSymbol];
-    constructor(...rest) {
-      super();
-      const opts = resolveMaybeOptionalOptions(rest);
-      const status = opts.status ?? props?.status;
-      if (status !== void 0 && !isORPCErrorStatus(status)) {
-        throw new globalThis.Error(
-          "[ORPCTaggedError] Invalid error status code."
-        );
-      }
-      this.status = fallbackORPCErrorStatus(code, status);
-      this.defined = opts.defined ?? true;
-      this.data = opts.data;
-      this.message = fallbackORPCErrorMessage(
-        this.code,
-        opts.message ?? props?.message
+      for (const key of virtualKeys) {
+        keys.add(key);
+      }
+      return [...keys];
+    },
+    getOwnPropertyDescriptor(currentTarget, prop) {
+      const context = createNodeProxyContext(
+        currentTarget
       );
-      this.cause = opts.cause;
-      this[ORPCErrorSymbol] = new ORPCError(
-        this.code,
-        {
-          status: this.status,
-          message: this.message,
-          data: this.data,
-          defined: this.defined,
-          cause: this.cause
+      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
       );
-    }
-    /**
-     * Converts this error to a plain ORPCError.
-     * Useful when you need to return from an oRPC handler.
-     */
-    toORPCError() {
-      return this[ORPCErrorSymbol];
-    }
-    toJSON() {
-      return {
-        _tag: this._tag,
-        defined: this[ORPCErrorSymbol].defined,
-        code: this[ORPCErrorSymbol].code,
-        status: this[ORPCErrorSymbol].status,
-        message: this[ORPCErrorSymbol].message,
-        data: this[ORPCErrorSymbol].data
-      };
-    }
-  }
-  return Object.assign(ORPCTaggedErrorBase, {
-    _tag: tag,
-    code
-  });
-}
-function toORPCError(error) {
-  return error[ORPCErrorSymbol];
-}
-function createEffectErrorConstructorMap(errors) {
-  const target = errors ?? {};
-  const proxy = new Proxy(target, {
-    get(proxyTarget, code) {
-      if (typeof code !== "string") {
-        return Reflect.get(proxyTarget, code);
+      if (descriptor === void 0) {
+        return Reflect.getOwnPropertyDescriptor(currentTarget, prop);
       }
-      const config = target[code];
-      if (isORPCTaggedErrorClass(config)) {
-        return (...opts) => new config(...opts);
+      if ("value" in descriptor && typeof descriptor.value === "function") {
+        return {
+          ...descriptor,
+          value: createBoundMethod(
+            context,
+            prop,
+            descriptor.value,
+            config,
+            currentTarget
+          )
+        };
       }
-      return (...rest) => {
-        const options = resolveMaybeOptionalOptions(rest);
-        return new ORPCError(code, {
-          defined: Boolean(config),
-          status: config?.status,
-          message: options.message ?? config?.message,
-          data: options.data,
-          cause: options.cause
-        });
-      };
+      return descriptor;
     }
   });
-  return proxy;
 }
-function effectErrorMapToErrorMap(errorMap) {
-  const result = {};
-  if (!errorMap) {
-    return result;
-  }
-  for (const [code, ClassOrErrorItem] of Object.entries(errorMap)) {
-    if (!ClassOrErrorItem) {
-      continue;
-    }
-    if (isORPCTaggedErrorClass(ClassOrErrorItem)) {
-      const classInstance = new ClassOrErrorItem();
-      result[classInstance.code] = {
-        status: classInstance.status,
-        message: classInstance.message,
-        data: classInstance.schema
-      };
-    } else {
-      result[code] = ClassOrErrorItem;
-    }
-  }
-  return result;
+function unhandled() {
+  return unhandledProperty;
 }
 
 // src/effect-procedure.ts
@@ -345,6 +623,8 @@ var procedureVirtualDescriptors = {
   callable: { enumerable: false },
   errors: { enumerable: false },
   meta: { enumerable: false },
+  provide: { enumerable: false },
+  provideOptional: { enumerable: false },
   route: { enumerable: false },
   use: { enumerable: false }
 };
@@ -353,6 +633,8 @@ var decoratedProcedureVirtualKeys = [
   ...baseProcedureVirtualKeys,
   "errors",
   "meta",
+  "provide",
+  "provideOptional",
   "route",
   "use",
   "callable",
@@ -370,10 +652,52 @@ function getOrCreateVirtualMethod(context, prop, factory) {
 function getEffectProcedureDef(context) {
   return {
     ...context.upstream["~orpc"],
+    effectSteps: context.state.effectSteps,
+    effectHandler: context.state.effectHandler,
     effectErrorMap: context.state.effectErrorMap,
-    runtime: context.state.runtime
+    runner: context.state.runner
+  };
+}
+function makeEffectProcedureHandler(def) {
+  if (!def.effectHandler) {
+    return def.handler;
+  }
+  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;
+  }
+  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) {
@@ -413,16 +737,99 @@ function createEffectProcedureProxy(target, decorated) {
               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({
-                ...getEffectProcedureDef(context),
-                middlewares: addMiddleware(
-                  getEffectProcedureDef(context).middlewares,
-                  mapped
-                )
+                ...flushedDef,
+                middlewares: addMiddleware(flushedDef.middlewares, mapped)
               });
             };
           });
@@ -459,10 +866,13 @@ function createEffectProcedureProxy(target, decorated) {
 }
 var EffectProcedure = class _EffectProcedure extends Procedure {
   constructor(def, procedure) {
-    super(def);
-    attachEffectState(this, procedure ?? new Procedure(def), {
+    const { effectSteps, effectHandler, ...procedureDef } = def;
+    super(procedureDef);
+    attachEffectState(this, procedure ?? new Procedure(procedureDef), {
+      effectSteps,
+      effectHandler,
       effectErrorMap: def.effectErrorMap,
-      runtime: def.runtime
+      runner: def.runner
     });
     if (new.target === _EffectProcedure) {
       return createEffectProcedureProxy(this, false);
@@ -517,7 +927,7 @@ function enhanceEffectRouter(router, options) {
       middlewares,
       inputValidationIndex: source["~orpc"].inputValidationIndex + newMiddlewareAdded,
       outputValidationIndex: source["~orpc"].outputValidationIndex + newMiddlewareAdded,
-      runtime: options.runtime
+      runner: options.runner
     });
   }
   const enhanced = {};
@@ -527,85 +937,44 @@ 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)
+// src/runtime-source.ts
+import { Effect as Effect2, FiberRefs, ManagedRuntime } from "effect";
+function makeEffectRuntimeRunner(source) {
+  if (source === void 0) {
+    return {
+      runPromiseExit: (effect, options) => Effect2.runPromiseExit(withParentFiberRefs(effect), {
+        signal: options?.signal
+      })
     };
-    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;
+  }
+  if (ManagedRuntime.isManagedRuntime(source)) {
+    const runtime = source;
+    return {
+      runtime,
+      runPromiseExit: (effect, options) => runtime.runPromiseExit(withParentFiberRefs(effect), {
+        signal: options?.signal
+      })
+    };
+  }
+  const layer = source;
+  return {
+    runPromiseExit: (effect, options) => Effect2.runPromiseExit(
+      withParentFiberRefs(Effect2.provide(effect, layer)),
+      { signal: options?.signal }
+    )
   };
 }
+function withParentFiberRefs(effect) {
+  const parentFiberRefs = getCurrentFiberRefs();
+  return parentFiberRefs ? Effect2.fiberIdWith(
+    (fiberId) => Effect2.flatMap(
+      Effect2.getFiberRefs,
+      (fiberRefs) => Effect2.setFiberRefs(
+        FiberRefs.joinAs(fiberRefs, fiberId, parentFiberRefs)
+      ).pipe(Effect2.andThen(effect))
+    )
+  ) : effect;
+}
 
 // src/effect-builder.ts
 var builderVirtualDescriptors = {
@@ -614,6 +983,9 @@ var builderVirtualDescriptors = {
   errors: { enumerable: false },
   handler: { enumerable: false },
   lazy: { enumerable: false },
+  middleware: { enumerable: false },
+  provide: { enumerable: false },
+  provideOptional: { enumerable: false },
   router: { enumerable: false },
   traced: { enumerable: false }
 };
@@ -621,6 +993,9 @@ var builderVirtualKeys = [
   "~effect",
   "errors",
   "effect",
+  "middleware",
+  "provide",
+  "provideOptional",
   "traced",
   "handler",
   "router",
@@ -642,8 +1017,10 @@ function getEffectBuilderDef(context) {
   return {
     ...context.upstream["~orpc"],
     effectErrorMap: context.state.effectErrorMap,
-    runtime: context.state.runtime,
-    spanConfig: context.state.spanConfig
+    runner: context.state.runner,
+    spanConfig: context.state.spanConfig,
+    effectSteps: context.state.effectSteps,
+    effectHandler: context.state.effectHandler
   };
 }
 function wrapBuilderLike(builder, state) {
@@ -651,12 +1028,39 @@ function wrapBuilderLike(builder, state) {
     {
       ...builder["~orpc"],
       effectErrorMap: state.effectErrorMap,
-      runtime: state.runtime,
-      spanConfig: state.spanConfig
+      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 };
+  }
+  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) {
@@ -688,20 +1092,98 @@ function createEffectBuilderProxy(target) {
           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,
-                    runtime: state.runtime,
+                    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, {
@@ -763,24 +1245,28 @@ function addSpanStackTrace() {
 }
 var EffectBuilder = class {
   constructor(def, builder) {
-    const { runtime, spanConfig, effectErrorMap, ...orpcDef } = def;
+    const { runner, spanConfig, effectErrorMap, effectSteps, ...orpcDef } = def;
     attachEffectState(this, builder ?? new Builder(orpcDef), {
+      effectSteps,
+      effectHandler: def.effectHandler,
       effectErrorMap,
-      runtime,
+      runner,
       spanConfig
     });
     return createEffectBuilderProxy(this);
   }
 };
-function makeEffectORPC(runtime, builder) {
-  const resolvedBuilder = builder ?? emptyBuilder();
+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),
-      runtime
+      runner
     },
     unwrapEffectUpstream(resolvedBuilder)
   );
@@ -797,6 +1283,7 @@ function emptyBuilder() {
     route: {}
   });
 }
+var eos = makeEffectORPC();
 
 // src/eoc.ts
 import { isContractProcedure, oc } from "@orpc/contract";
@@ -935,15 +1422,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) {
@@ -958,9 +1445,9 @@ function wrapContractNode(contract, target, runtime) {
               ...currentTarget["~orpc"],
               errorMap: effectErrorMapToErrorMap(effectErrorMap),
               effectErrorMap,
-              runtime,
+              runner,
               handler: createEffectProcedureHandler({
-                runtime,
+                runner,
                 effectErrorMap,
                 effectFn,
                 defaultCaptureStackTrace: addSpanStackTrace()
@@ -978,7 +1465,7 @@ function wrapContractNode(contract, target, runtime) {
               currentTarget,
               args
             ),
-            runtime
+            runner
           );
           cache.set(prop, use);
           return use;
@@ -995,7 +1482,7 @@ function wrapContractNode(contract, target, runtime) {
               currentTarget,
               args
             ),
-            runtime
+            runner
           );
           cache.set(prop, wrappedMethod);
           return wrappedMethod;
@@ -1007,7 +1494,7 @@ function wrapContractNode(contract, target, runtime) {
               currentTarget,
               args
             ),
-            makeEnhanceOptions(runtime)
+            makeEnhanceOptions(runner)
           );
           cache.set(prop, wrappedMethod);
           return wrappedMethod;
@@ -1016,7 +1503,7 @@ function wrapContractNode(contract, target, runtime) {
           const child = wrapContractNode(
             contract[prop],
             Reflect.get(currentTarget, prop, receiver),
-            runtime
+            runner
           );
           cache.set(prop, child);
           return child;
@@ -1040,11 +1527,11 @@ function wrapContractNode(contract, target, runtime) {
     }
   });
 }
-function implementEffect(contract, runtime) {
+function implementEffect(contract, source) {
   return wrapContractNode(
     contract,
     implement(contract),
-    runtime
+    makeEffectRuntimeRunner(source)
   );
 }
 export {
@@ -1056,6 +1543,7 @@ export {
   createEffectErrorConstructorMap,
   effectErrorMapToErrorMap,
   eoc,
+  eos,
   implementEffect,
   isORPCTaggedError,
   isORPCTaggedErrorClass,