effect-orpc 0.3.0 → 0.5.0

package/dist/index.js

@@ -175,6 +175,7 @@ function effectErrorMapToErrorMap(errorMap) {
 }
 
 // src/effect-runtime.ts
+var HybridContinuationSymbol = /* @__PURE__ */ Symbol("effect-orpc/HybridContinuation");
 function toORPCErrorFromCause(cause) {
   return Cause2.match(cause, {
     onDie(defect) {
@@ -211,7 +212,7 @@ function toORPCErrorFromCause(cause) {
 }
 function createEffectProcedureHandler(options) {
   const {
-    runtime,
+    runner,
     effectErrorMap,
     effectFn,
     effectSteps = [],
@@ -230,26 +231,25 @@ function createEffectProcedureHandler(options) {
     };
     const spanName = spanConfig?.name ?? opts.path.join(".");
     const captureStackTrace = spanConfig?.captureStackTrace ?? defaultCaptureStackTrace;
-    const resolver = Effect.fnUntraced(effectFn);
-    const handlerEffect = resolver(effectOpts);
+    const handlerEffect = callEffectCallback(effectFn, effectOpts);
     const tracedEffect = Effect.withSpan(
       runEffectPipeline({
         baseOptions: effectOpts,
         effectErrorMap,
         final: (context) => Effect.map(
-          context === effectOpts.context ? handlerEffect : resolver({ ...effectOpts, context }),
+          context === effectOpts.context ? handlerEffect : callEffectCallback(effectFn, { ...effectOpts, context }),
           (output) => ({ output, context: {} })
         ),
         input: opts.input,
+        runner,
         steps: effectSteps
       }),
       spanName,
       { captureStackTrace }
     );
-    const exit = await runtime.runPromiseExit(
-      withParentFiberRefs(tracedEffect),
-      { signal: opts.signal }
-    );
+    const exit = await runner.runPromiseExit(tracedEffect, {
+      signal: opts.signal
+    });
     if (Exit.isFailure(exit)) {
       throw toORPCErrorFromCause(exit.cause);
     }
@@ -257,7 +257,7 @@ function createEffectProcedureHandler(options) {
   };
 }
 function createEffectPipelineMiddleware(options) {
-  const { runtime, effectErrorMap, steps } = options;
+  const { runner, effectErrorMap, steps } = options;
   return async (opts, input) => {
     const baseOptions = makeEffectOptions(opts, input, effectErrorMap);
     const effect = runEffectPipeline({
@@ -269,29 +269,169 @@ function createEffectPipelineMiddleware(options) {
         )
       ),
       input,
+      runner,
       steps
     });
-    const exit = await runtime.runPromiseExit(
-      withParentFiberRefs(effect),
-      { signal: opts.signal }
-    );
+    const exit = await runner.runPromiseExit(effect, {
+      signal: opts.signal
+    });
     if (Exit.isFailure(exit)) throw toORPCErrorFromCause(exit.cause);
     return exit.value;
   };
 }
+function createEffectOrORPCMiddleware(options) {
+  const { runner, effectErrorMap, middleware } = options;
+  return async (opts, input, output) => {
+    const effectOptions = makeEffectMiddlewareOptions({
+      effectErrorMap,
+      final: opts.next,
+      options: opts,
+      output
+    });
+    return runEffectOrORPCMiddlewareCallback({
+      effectOptions,
+      input,
+      middleware,
+      nativeNext: opts.next,
+      runner,
+      signal: opts.signal
+    });
+  };
+}
+async function runEffectOrORPCMiddlewareCallback(options) {
+  const result = options.middleware(
+    options.effectOptions,
+    options.input,
+    options.effectOptions.output
+  );
+  const classified = classifyEffectOrORPCMiddlewareResult(result);
+  switch (classified._tag) {
+    case "nativeContinuation":
+      return classified.result;
+    case "nativeGuardOnly":
+      return options.nativeNext();
+    case "nativeResult":
+      return classified.result;
+    case "effect": {
+      const exit = await options.runner.runPromiseExit(
+        runEffectMiddlewareResult({
+          autoNext: () => options.effectOptions.next(),
+          effect: classified.effect,
+          nextInvoked: options.effectOptions.nextTracker.nextInvoked,
+          nextResult: options.effectOptions.nextTracker.nextResult
+        }),
+        { signal: options.signal }
+      );
+      if (Exit.isFailure(exit)) throw toORPCErrorFromCause(exit.cause);
+      return exit.value;
+    }
+  }
+}
+function classifyEffectOrORPCMiddlewareResult(result) {
+  if (isHybridContinuation(result)) {
+    return {
+      _tag: "nativeContinuation",
+      result
+    };
+  }
+  if (Effect.isEffect(result) || isGeneratorIterator(result)) {
+    return {
+      _tag: "effect",
+      effect: effectFromCallbackResult(result)
+    };
+  }
+  if (result === void 0) {
+    return { _tag: "nativeGuardOnly" };
+  }
+  return {
+    _tag: "nativeResult",
+    result
+  };
+}
+function runEffectMiddlewareResult(options) {
+  return Effect.flatMap(
+    options.effect,
+    (result) => resolveEffectMiddlewareContinuation({
+      autoNext: options.autoNext,
+      nextInvoked: options.nextInvoked,
+      nextResult: options.nextResult,
+      result
+    })
+  );
+}
+function makeEffectMiddlewareOptions(options) {
+  const nextTracker = createMiddlewareNextTracker();
+  const effectOptions = {
+    context: options.options.context,
+    path: options.options.path,
+    procedure: options.options.procedure,
+    signal: options.options.signal,
+    lastEventId: options.options.lastEventId,
+    errors: createEffectErrorConstructorMap(options.effectErrorMap),
+    next: nextTracker.wrapNext(
+      (...rest) => makeHybridMiddlewareContinuation({
+        final: options.final,
+        nextTracker,
+        rest
+      })
+    ),
+    nextTracker,
+    output: makeEffectMiddlewareOutput(options.output)
+  };
+  return effectOptions;
+}
+function makeHybridMiddlewareContinuation(options) {
+  const nextContext = options.rest[0]?.context ?? {};
+  const toEffectResult = (result) => ({
+    output: result.output,
+    context: nextContext
+  });
+  const effect = Effect.map(
+    withCurrentFiberContext(() => options.final(...options.rest)),
+    toEffectResult
+  );
+  return makeHybridContinuation(effect, {
+    onResult: options.nextTracker.setNextResult,
+    run: () => options.final(...options.rest),
+    toEffectResult
+  });
+}
+function makeHybridContinuation(effect, options) {
+  markHybridContinuation(effect);
+  attachPromiseLikeContinuation(
+    effect,
+    (onFulfilled, onRejected) => Promise.resolve(options.run()).then(options.toEffectResult).then((result) => {
+      options.onResult?.(result);
+      return result;
+    }).then(onFulfilled, onRejected)
+  );
+  return effect;
+}
+function markHybridContinuation(value) {
+  Object.defineProperty(value, HybridContinuationSymbol, {
+    configurable: true,
+    value: true
+  });
+}
+function attachPromiseLikeContinuation(value, then) {
+  Object.defineProperty(value, "then", {
+    configurable: true,
+    value: then
+  });
+}
 function createEffectProviderMiddleware(options) {
-  const { runtime, effectErrorMap, tag, provider } = options;
+  const { runner, effectErrorMap, tag, provider } = options;
   return async (opts, input) => {
     const effectOpts = makeEffectOptions(opts, input, effectErrorMap);
     const effect = Effect.flatMap(
-      provider(effectOpts),
+      callEffectCallback(provider, effectOpts),
       (service) => Effect.provideService(
         withCurrentFiberContext(() => opts.next()),
         tag,
         service
       )
     );
-    const exit = await runtime.runPromiseExit(withParentFiberRefs(effect), {
+    const exit = await runner.runPromiseExit(effect, {
       signal: opts.signal
     });
     if (Exit.isFailure(exit)) throw toORPCErrorFromCause(exit.cause);
@@ -299,11 +439,11 @@ function createEffectProviderMiddleware(options) {
   };
 }
 function createEffectOptionalProviderMiddleware(options) {
-  const { runtime, effectErrorMap, tag, provider } = options;
+  const { runner, effectErrorMap, tag, provider } = options;
   return async (opts, input) => {
     const effectOpts = makeEffectOptions(opts, input, effectErrorMap);
     const effect = Effect.flatMap(
-      provider(effectOpts),
+      callEffectCallback(provider, effectOpts),
       (service) => Option.match(service, {
         onNone: () => withCurrentFiberContext(() => opts.next()),
         onSome: (value) => Effect.provideService(
@@ -313,16 +453,57 @@ function createEffectOptionalProviderMiddleware(options) {
         )
       })
     );
-    const exit = await runtime.runPromiseExit(withParentFiberRefs(effect), {
+    const exit = await runner.runPromiseExit(effect, {
       signal: opts.signal
     });
     if (Exit.isFailure(exit)) throw toORPCErrorFromCause(exit.cause);
     return exit.value;
   };
 }
-function isEffectMiddleware(value) {
+function callEffectCallback(callback, ...args) {
+  if (isGeneratorFunction(callback)) {
+    return Effect.fnUntraced(callback)(...args);
+  }
+  return Effect.suspend(() => {
+    try {
+      return effectFromCallbackResult(callback(...args));
+    } catch (error) {
+      return Effect.fail(error);
+    }
+  });
+}
+function effectFromCallbackResult(result) {
+  if (Effect.isEffect(result)) {
+    return result;
+  }
+  if (isGeneratorIterator(result)) {
+    return Effect.fnUntraced(function* () {
+      return yield* result;
+    })();
+  }
+  if (isPromiseLike(result)) {
+    return Effect.promise(() => result);
+  }
+  return Effect.succeed(result);
+}
+function isGeneratorIterator(value) {
+  return typeof value === "object" && value !== null && "next" in value && typeof value.next === "function" && "throw" in value && typeof value.throw === "function";
+}
+function isHybridContinuation(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && HybridContinuationSymbol in value;
+}
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+}
+function isGeneratorFunction(value) {
   return typeof value === "function" && value.constructor?.name === "GeneratorFunction";
 }
+function isEffectMiddleware(value) {
+  return isGeneratorFunction(value);
+}
+function isDecoratedMiddleware(value) {
+  return typeof value === "function" && "mapInput" in value && "concat" in value;
+}
 function makeEffectOptions(opts, input, effectErrorMap) {
   return {
     context: opts.context,
@@ -341,13 +522,13 @@ function runEffectPipeline(options) {
     const stepOptions = { ...options.baseOptions, context };
     if (step._tag === "provide") {
       return Effect.flatMap(
-        step.provider(stepOptions),
+        callEffectCallback(step.provider, stepOptions),
         (service) => Effect.provideService(run(index + 1, context), step.tag, service)
       );
     }
     if (step._tag === "provideOptional") {
       return Effect.flatMap(
-        step.provider(stepOptions),
+        callEffectCallback(step.provider, stepOptions),
         (service) => Option.match(service, {
           onNone: () => run(index + 1, context),
           onSome: (value) => Effect.provideService(run(index + 1, context), step.tag, value)
@@ -357,46 +538,57 @@ function runEffectPipeline(options) {
     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 Effect.flatMap(Effect.getFiberRefs, (fiberRefs) => {
+      const makeThenable = (effect) => makeThenableEffect(
+        effect,
+        options.runner,
+        fiberRefs,
+        stepOptions.signal
+      );
+      const nextTracker = createMiddlewareNextTracker(
+        makeThenable
+      );
+      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: {} }), makeThenable);
+      const middlewareEffect = callEffectCallback(
+        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() {
+function createMiddlewareNextTracker(makeThenable) {
   let nextInvoked = false;
   let nextResult;
   return {
@@ -406,13 +598,26 @@ function createMiddlewareNextTracker() {
     get nextResult() {
       return nextResult;
     },
+    setNextResult(result) {
+      nextResult = result;
+    },
     wrapNext(nextFn) {
       return ((...args) => {
         nextInvoked = true;
-        return Effect.map(nextFn(...args), (result) => {
+        const inner = nextFn(...args);
+        const tracked = Effect.map(inner, (result) => {
           nextResult = result;
           return result;
         });
+        if (isHybridContinuation(inner)) {
+          markHybridContinuation(tracked);
+          attachPromiseLikeContinuation(
+            tracked,
+            inner.then.bind(inner)
+          );
+          return tracked;
+        }
+        return makeThenable ? makeThenable(tracked) : tracked;
       });
     }
   };
@@ -434,27 +639,51 @@ function resolveEffectMiddlewareContinuation(options) {
   }
   return autoNext();
 }
-function makeEffectMiddlewareOutput(output) {
-  return (value) => withCurrentFiberContext(() => output(value));
+function makeEffectMiddlewareOutput(output, makeThenable) {
+  return (value) => {
+    const effect = withCurrentFiberContext(() => output(value));
+    return makeThenable ? makeThenable(effect) : effect;
+  };
 }
-function withCurrentFiberContext(fn) {
-  return Effect.flatMap(
-    Effect.getFiberRefs,
-    (fiberRefs) => Effect.promise(
-      () => runWithFiberRefs(fiberRefs, () => Promise.resolve(fn()))
+function makeThenableEffect(effect, runner, fiberRefs, signal) {
+  if ("then" in effect) {
+    return effect;
+  }
+  attachPromiseLikeContinuation(
+    effect,
+    (onFulfilled, onRejected) => runNestedEffect(effect, runner, fiberRefs, signal).then(
+      onFulfilled,
+      onRejected
     )
   );
+  return effect;
 }
-function withParentFiberRefs(effect) {
-  const parentFiberRefs = getCurrentFiberRefs();
-  return parentFiberRefs ? Effect.fiberIdWith(
+async function runNestedEffect(effect, runner, fiberRefs, signal) {
+  const exit = await runner.runPromiseExit(withFiberRefs(effect, fiberRefs), {
+    signal
+  });
+  if (Exit.isFailure(exit)) {
+    throw toORPCErrorFromCause(exit.cause);
+  }
+  return exit.value;
+}
+function withFiberRefs(effect, parentFiberRefs) {
+  return Effect.fiberIdWith(
     (fiberId) => Effect.flatMap(
       Effect.getFiberRefs,
       (fiberRefs) => Effect.setFiberRefs(
         FiberRefs.joinAs(fiberRefs, fiberId, parentFiberRefs)
       ).pipe(Effect.andThen(effect))
     )
-  ) : effect;
+  );
+}
+function withCurrentFiberContext(fn) {
+  return Effect.flatMap(
+    Effect.getFiberRefs,
+    (fiberRefs) => Effect.promise(
+      () => runWithFiberRefs(fiberRefs, () => Promise.resolve(fn()))
+    )
+  );
 }
 
 // src/extension/compose-surfaces.ts
@@ -668,7 +897,7 @@ function getEffectProcedureDef(context) {
     effectSteps: context.state.effectSteps,
     effectHandler: context.state.effectHandler,
     effectErrorMap: context.state.effectErrorMap,
-    runtime: context.state.runtime
+    runner: context.state.runner
   };
 }
 function makeEffectProcedureHandler(def) {
@@ -680,7 +909,7 @@ function makeEffectProcedureHandler(def) {
     effectErrorMap: def.effectErrorMap,
     effectFn: def.effectHandler.effectFn,
     effectSteps: def.effectSteps,
-    runtime: def.runtime,
+    runner: def.runner,
     spanConfig: def.effectHandler.spanConfig
   });
 }
@@ -702,7 +931,7 @@ function flushEffectSteps(def) {
   }
   const middleware = createEffectPipelineMiddleware({
     effectErrorMap: def.effectErrorMap,
-    runtime: def.runtime,
+    runner: def.runner,
     steps: def.effectSteps
   });
   return withRebuiltEffectHandler({
@@ -770,7 +999,7 @@ function createEffectProcedureProxy(target, decorated) {
                     def.middlewares,
                     createEffectPipelineMiddleware({
                       effectErrorMap: state.effectErrorMap,
-                      runtime: state.runtime,
+                      runner: state.runner,
                       steps: [step]
                     })
                   )
@@ -792,7 +1021,7 @@ function createEffectProcedureProxy(target, decorated) {
                   createEffectProviderMiddleware({
                     effectErrorMap: state.effectErrorMap,
                     provider,
-                    runtime: state.runtime,
+                    runner: state.runner,
                     tag: tagOrLayer
                   })
                 )
@@ -819,7 +1048,7 @@ function createEffectProcedureProxy(target, decorated) {
                   createEffectOptionalProviderMiddleware({
                     effectErrorMap: state.effectErrorMap,
                     provider,
-                    runtime: state.runtime,
+                    runner: state.runner,
                     tag
                   })
                 )
@@ -831,15 +1060,33 @@ function createEffectProcedureProxy(target, decorated) {
             return (middleware, mapInput) => {
               const def = getEffectProcedureDef(context);
               if (!mapInput && isEffectMiddleware(middleware)) {
-                return new EffectDecoratedProcedure(
-                  appendEffectStep(def, {
-                    _tag: "middleware",
-                    middleware
-                  })
-                );
+                const step = {
+                  _tag: "middleware",
+                  middleware
+                };
+                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]
+                    })
+                  )
+                });
               }
               const flushedDef = flushEffectSteps(def);
-              const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+              const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : isDecoratedMiddleware(middleware) ? middleware : createEffectOrORPCMiddleware({
+                effectErrorMap: state.effectErrorMap,
+                middleware,
+                runner: state.runner
+              });
               return new EffectDecoratedProcedure({
                 ...flushedDef,
                 middlewares: addMiddleware(flushedDef.middlewares, mapped)
@@ -885,7 +1132,7 @@ var EffectProcedure = class _EffectProcedure extends Procedure {
       effectSteps,
       effectHandler,
       effectErrorMap: def.effectErrorMap,
-      runtime: def.runtime
+      runner: def.runner
     });
     if (new.target === _EffectProcedure) {
       return createEffectProcedureProxy(this, false);
@@ -940,7 +1187,7 @@ function enhanceEffectRouter(router, options) {
       middlewares,
       inputValidationIndex: source["~orpc"].inputValidationIndex + newMiddlewareAdded,
       outputValidationIndex: source["~orpc"].outputValidationIndex + newMiddlewareAdded,
-      runtime: options.runtime
+      runner: options.runner
     });
   }
   const enhanced = {};
@@ -951,11 +1198,42 @@ function enhanceEffectRouter(router, options) {
 }
 
 // src/runtime-source.ts
-import { ManagedRuntime } from "effect";
-function toManagedRuntime(source) {
-  return ManagedRuntime.isManagedRuntime(source) ? source : ManagedRuntime.make(
-    source
-  );
+import { Effect as Effect2, FiberRefs as FiberRefs2, ManagedRuntime } from "effect";
+function makeEffectRuntimeRunner(source) {
+  if (source === void 0) {
+    return {
+      runPromiseExit: (effect, options) => Effect2.runPromiseExit(withParentFiberRefs(effect), {
+        signal: options?.signal
+      })
+    };
+  }
+  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(
+        FiberRefs2.joinAs(fiberRefs, fiberId, parentFiberRefs)
+      ).pipe(Effect2.andThen(effect))
+    )
+  ) : effect;
 }
 
 // src/effect-builder.ts
@@ -999,7 +1277,7 @@ function getEffectBuilderDef(context) {
   return {
     ...context.upstream["~orpc"],
     effectErrorMap: context.state.effectErrorMap,
-    runtime: context.state.runtime,
+    runner: context.state.runner,
     spanConfig: context.state.spanConfig,
     effectSteps: context.state.effectSteps,
     effectHandler: context.state.effectHandler
@@ -1010,7 +1288,7 @@ function wrapBuilderLike(builder, state) {
     {
       ...builder["~orpc"],
       effectErrorMap: state.effectErrorMap,
-      runtime: state.runtime,
+      runner: state.runner,
       spanConfig: state.spanConfig,
       effectSteps: state.effectSteps,
       effectHandler: state.effectHandler
@@ -1030,7 +1308,7 @@ function flushEffectSteps2(builder, state) {
   }
   const middleware = createEffectPipelineMiddleware({
     effectErrorMap: state.effectErrorMap,
-    runtime: state.runtime,
+    runner: state.runner,
     steps: state.effectSteps
   });
   return {
@@ -1088,7 +1366,7 @@ function createEffectBuilderProxy(target) {
                     effectErrorMap: state.effectErrorMap,
                     effectFn,
                     effectSteps: state.effectSteps,
-                    runtime: state.runtime,
+                    runner: state.runner,
                     spanConfig: state.spanConfig
                   })(opts);
                 }
@@ -1098,25 +1376,22 @@ function createEffectBuilderProxy(target) {
         case "middleware":
           return getOrCreateVirtualMethod2(context, prop, () => {
             return (middleware) => {
-              if (isEffectMiddleware(middleware)) {
-                const effectMiddleware = createEffectPipelineMiddleware({
-                  effectErrorMap: state.effectErrorMap,
-                  runtime: state.runtime,
-                  steps: [
-                    ...state.effectSteps ?? [],
-                    { _tag: "middleware", middleware }
-                  ]
-                });
-                return Reflect.apply(
-                  Reflect.get(source, "middleware", source),
-                  source,
-                  [effectMiddleware]
-                );
-              }
+              const effectMiddleware = isEffectMiddleware(middleware) ? createEffectPipelineMiddleware({
+                effectErrorMap: state.effectErrorMap,
+                runner: state.runner,
+                steps: [
+                  ...state.effectSteps ?? [],
+                  { _tag: "middleware", middleware }
+                ]
+              }) : createEffectOrORPCMiddleware({
+                effectErrorMap: state.effectErrorMap,
+                middleware,
+                runner: state.runner
+              });
               return Reflect.apply(
                 Reflect.get(source, "middleware", source),
                 source,
-                [middleware]
+                [effectMiddleware]
               );
             };
           });
@@ -1148,7 +1423,7 @@ function createEffectBuilderProxy(target) {
         case "use":
           return getOrCreateVirtualMethod2(context, prop, () => {
             return (middleware, ...rest) => {
-              if (isEffectMiddleware(middleware) && rest.length === 0) {
+              if (rest.length === 0 && isEffectMiddleware(middleware)) {
                 return wrapBuilderLike(
                   source,
                   appendEffectStep2(state, {
@@ -1161,7 +1436,14 @@ function createEffectBuilderProxy(target) {
               const nextBuilder = Reflect.apply(
                 Reflect.get(flushed.builder, "use", flushed.builder),
                 flushed.builder,
-                [middleware, ...rest]
+                [
+                  rest.length === 0 && !isDecoratedMiddleware(middleware) ? createEffectOrORPCMiddleware({
+                    effectErrorMap: flushed.state.effectErrorMap,
+                    middleware,
+                    runner: flushed.state.runner
+                  }) : middleware,
+                  ...rest
+                ]
               );
               return wrapBuilderLike(nextBuilder, flushed.state);
             };
@@ -1178,10 +1460,16 @@ function createEffectBuilderProxy(target) {
           });
         case "handler":
           return getOrCreateVirtualMethod2(context, prop, () => {
-            return (handler) => new EffectDecoratedProcedure({
-              ...effectDef,
-              handler
-            });
+            return (handler) => {
+              const flushed = flushEffectSteps2(source, state);
+              return new EffectDecoratedProcedure({
+                ...flushed.builder["~orpc"],
+                effectErrorMap: flushed.state.effectErrorMap,
+                runner: flushed.state.runner,
+                effectSteps: flushed.state.effectSteps,
+                handler
+              });
+            };
           });
         case "router":
           return getOrCreateVirtualMethod2(context, prop, () => {
@@ -1227,12 +1515,12 @@ function addSpanStackTrace() {
 }
 var EffectBuilder = class {
   constructor(def, builder) {
-    const { runtime, spanConfig, effectErrorMap, effectSteps, ...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);
@@ -1242,15 +1530,13 @@ function makeEffectORPC(source, builder) {
   const sourceIsBuilder = source !== void 0 && isBuilderLike(source);
   const resolvedBuilder = sourceIsBuilder ? source : builder ?? emptyBuilder();
   const effectErrorMap = getEffectErrorMap(resolvedBuilder);
-  const runtime = toManagedRuntime(
-    sourceIsBuilder || source === void 0 ? Layer3.empty : source
-  );
+  const runner = sourceIsBuilder || source === void 0 ? makeEffectRuntimeRunner() : makeEffectRuntimeRunner(source);
   return new EffectBuilder(
     {
       ...resolvedBuilder["~orpc"],
       effectErrorMap,
       errorMap: effectErrorMapToErrorMap(effectErrorMap),
-      runtime
+      runner
     },
     unwrapEffectUpstream(resolvedBuilder)
   );
@@ -1267,6 +1553,7 @@ function emptyBuilder() {
     route: {}
   });
 }
+var eos = makeEffectORPC();
 
 // src/eoc.ts
 import { isContractProcedure, oc } from "@orpc/contract";
@@ -1405,15 +1692,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) {
@@ -1428,9 +1715,9 @@ function wrapContractNode(contract, target, runtime) {
               ...currentTarget["~orpc"],
               errorMap: effectErrorMapToErrorMap(effectErrorMap),
               effectErrorMap,
-              runtime,
+              runner,
               handler: createEffectProcedureHandler({
-                runtime,
+                runner,
                 effectErrorMap,
                 effectFn,
                 defaultCaptureStackTrace: addSpanStackTrace()
@@ -1448,7 +1735,7 @@ function wrapContractNode(contract, target, runtime) {
               currentTarget,
               args
             ),
-            runtime
+            runner
           );
           cache.set(prop, use);
           return use;
@@ -1465,7 +1752,7 @@ function wrapContractNode(contract, target, runtime) {
               currentTarget,
               args
             ),
-            runtime
+            runner
           );
           cache.set(prop, wrappedMethod);
           return wrappedMethod;
@@ -1477,7 +1764,7 @@ function wrapContractNode(contract, target, runtime) {
               currentTarget,
               args
             ),
-            makeEnhanceOptions(runtime)
+            makeEnhanceOptions(runner)
           );
           cache.set(prop, wrappedMethod);
           return wrappedMethod;
@@ -1486,7 +1773,7 @@ function wrapContractNode(contract, target, runtime) {
           const child = wrapContractNode(
             contract[prop],
             Reflect.get(currentTarget, prop, receiver),
-            runtime
+            runner
           );
           cache.set(prop, child);
           return child;
@@ -1514,7 +1801,7 @@ function implementEffect(contract, source) {
   return wrapContractNode(
     contract,
     implement(contract),
-    toManagedRuntime(source)
+    makeEffectRuntimeRunner(source)
   );
 }
 export {
@@ -1526,6 +1813,7 @@ export {
   createEffectErrorConstructorMap,
   effectErrorMapToErrorMap,
   eoc,
+  eos,
   implementEffect,
   isORPCTaggedError,
   isORPCTaggedErrorClass,