effect-orpc 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-orpc",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "keywords": [
     "effect",
     "orpc",

package/src/contract.ts

@@ -34,8 +34,11 @@ import { enhanceEffectRouter } from "./effect-enhance-router";
 import { EffectDecoratedProcedure } from "./effect-procedure";
 import { createEffectProcedureHandler } from "./effect-runtime";
 import { effectContractSymbol, getEffectContractErrorMap } from "./eoc";
-import type { EffectRuntimeSource } from "./runtime-source";
-import { toManagedRuntime } from "./runtime-source";
+import type {
+  EffectRuntimeRunner,
+  EffectRuntimeSource,
+} from "./runtime-source";
+import { makeEffectRuntimeRunner } from "./runtime-source";
 import type { EffectErrorMap } from "./tagged-error";
 import { effectErrorMapToErrorMap } from "./tagged-error";
 import type { EffectErrorMapToErrorMap, EffectProcedureHandler } from "./types";
@@ -316,13 +319,13 @@ const CONTRACT_HIDDEN_METHODS = new Set([
 ]);
 
 function makeEnhanceOptions<TRequirementsProvided, TRuntimeError>(
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>,
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>,
 ) {
   return {
     middlewares: [],
     errorMap: {},
     dedupeLeadingMiddlewares: true,
-    runtime,
+    runner,
   } as const;
 }
 
@@ -333,7 +336,7 @@ function wrapContractNode<
 >(
   contract: TContract,
   target: any,
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>,
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>,
 ): EffectImplementerInternal<
   TContract,
   Context,
@@ -362,9 +365,9 @@ function wrapContractNode<
               ...currentTarget["~orpc"],
               errorMap: effectErrorMapToErrorMap(effectErrorMap),
               effectErrorMap,
-              runtime,
+              runner,
               handler: createEffectProcedureHandler({
-                runtime,
+                runner,
                 effectErrorMap,
                 effectFn,
                 defaultCaptureStackTrace: addSpanStackTrace(),
@@ -385,7 +388,7 @@ function wrapContractNode<
                 currentTarget,
                 args,
               ),
-              runtime,
+              runner,
             );
 
           cache.set(prop, use);
@@ -405,7 +408,7 @@ function wrapContractNode<
                 currentTarget,
                 args,
               ),
-              runtime,
+              runner,
             );
 
           cache.set(prop, wrappedMethod);
@@ -420,7 +423,7 @@ function wrapContractNode<
                 currentTarget,
                 args,
               ) as any,
-              makeEnhanceOptions(runtime),
+              makeEnhanceOptions(runner),
             );
 
           cache.set(prop, wrappedMethod);
@@ -431,7 +434,7 @@ function wrapContractNode<
           const child = wrapContractNode(
             (contract as Record<string, AnyContractRouter>)[prop]!,
             Reflect.get(currentTarget, prop, receiver),
-            runtime,
+            runner,
           );
 
           cache.set(prop, child);
@@ -512,7 +515,7 @@ export function implementEffect<
   return wrapContractNode(
     contract,
     implement(contract),
-    toManagedRuntime(source),
+    makeEffectRuntimeRunner(source),
   ) as EffectImplementer<
     TContract,
     Record<never, never>,

package/src/effect-builder.ts

@@ -28,7 +28,7 @@ import {
   type EffectProxyTarget,
 } from "./extension/state";
 import type { EffectRuntimeSource } from "./runtime-source";
-import { toManagedRuntime } from "./runtime-source";
+import { makeEffectRuntimeRunner } from "./runtime-source";
 import type { EffectErrorMap, MergedEffectErrorMap } from "./tagged-error";
 import { effectErrorMapToErrorMap } from "./tagged-error";
 import type {
@@ -106,7 +106,7 @@ function getEffectBuilderDef(
   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,
@@ -121,7 +121,7 @@ function wrapBuilderLike(
     {
       ...builder["~orpc"],
       effectErrorMap: state.effectErrorMap,
-      runtime: state.runtime,
+      runner: state.runner,
       spanConfig: state.spanConfig,
       effectSteps: state.effectSteps,
       effectHandler: state.effectHandler,
@@ -158,7 +158,7 @@ function flushEffectSteps(
 
   const middleware = createEffectPipelineMiddleware({
     effectErrorMap: state.effectErrorMap,
-    runtime: state.runtime,
+    runner: state.runner,
     steps: state.effectSteps,
   });
   return {
@@ -238,7 +238,7 @@ function createEffectBuilderProxy(
                     effectErrorMap: state.effectErrorMap,
                     effectFn,
                     effectSteps: state.effectSteps,
-                    runtime: state.runtime,
+                    runner: state.runner,
                     spanConfig: state.spanConfig,
                   })(opts as any);
                 },
@@ -251,7 +251,7 @@ function createEffectBuilderProxy(
               if (isEffectMiddleware(middleware)) {
                 const effectMiddleware = createEffectPipelineMiddleware({
                   effectErrorMap: state.effectErrorMap,
-                  runtime: state.runtime,
+                  runner: state.runner,
                   steps: [
                     ...(state.effectSteps ?? []),
                     { _tag: "middleware" as const, middleware },
@@ -698,7 +698,7 @@ export class EffectBuilder<
    *
    * @example
    * ```ts
-   * const getUser = effectOs
+   * const getUser = effectProcedure
    *   .input(z.object({ id: z.string() }))
    *   .traced('users.getUser')
    *   .effect(function* ({ input }) {
@@ -734,7 +734,7 @@ export class EffectBuilder<
   >["handler"];
   /**
    * Defines the handler of the procedure using an Effect.
-   * The Effect is executed using the ManagedRuntime provided during builder creation.
+   * The Effect is executed using the configured Effect runtime source.
    * The effect is automatically wrapped with `Effect.withSpan`.
    *
    * @see {@link https://orpc.dev/docs/procedure Procedure Docs}
@@ -826,14 +826,13 @@ export class EffectBuilder<
     >,
     builder?: AnyBuilderLike,
   ) {
-    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,
     });
 
@@ -853,9 +852,9 @@ export class EffectBuilder<
  * import { makeEffectORPC } from '@orpc/effect'
  * import { Effect, Layer } from 'effect'
  *
- * const effectOs = makeEffectORPC(Layer.empty)
+ * const effectProcedure = makeEffectORPC(Layer.empty)
  *
- * const hello = effectOs.effect(() => Effect.succeed('Hello!'))
+ * const hello = effectProcedure.effect(() => Effect.succeed('Hello!'))
  * ```
  */
 export function makeEffectORPC(): EffectBuilder<
@@ -943,9 +942,9 @@ export function makeEffectORPC<TRequirementsProvided, TRuntimeError>(
  * const authedOs = os.use(authMiddleware)
  *
  * // Wrap it with Effect support
- * const effectOs = makeEffectORPC(UserServiceLive, authedOs)
+ * const effectProcedure = makeEffectORPC(UserServiceLive, authedOs)
  *
- * const getUser = effectOs
+ * const getUser = effectProcedure
  *   .input(z.object({ id: z.string() }))
  *   .effect(
  *     Effect.fn(function* ({ input }) {
@@ -1025,15 +1024,16 @@ export function makeEffectORPC(
     ? source
     : (builder ?? emptyBuilder());
   const effectErrorMap = getEffectErrorMap(resolvedBuilder);
-  const runtime = toManagedRuntime(
-    sourceIsBuilder || source === undefined ? Layer.empty : source,
-  );
+  const runner =
+    sourceIsBuilder || source === undefined
+      ? makeEffectRuntimeRunner()
+      : makeEffectRuntimeRunner(source);
   return new EffectBuilder(
     {
       ...resolvedBuilder["~orpc"],
       effectErrorMap: effectErrorMap,
       errorMap: effectErrorMapToErrorMap(effectErrorMap),
-      runtime,
+      runner,
     },
     unwrapEffectUpstream(resolvedBuilder),
   );
@@ -1051,3 +1051,12 @@ function emptyBuilder(): AnyBuilderLike {
     route: {},
   });
 }
+
+/**
+ * Runtime-less Effect oRPC builder, analogous to oRPC's `os` export.
+ *
+ * Provide application services with `.provide(layer)` or use
+ * `makeEffectORPC(runtime)` when you need explicit ManagedRuntime lifecycle
+ * control.
+ */
+export const eos = makeEffectORPC();

package/src/effect-enhance-router.ts

@@ -16,10 +16,10 @@ import {
   type Context,
   type Lazyable,
 } from "@orpc/server";
-import type { ManagedRuntime } from "effect/ManagedRuntime";
 
 import { EffectProcedure } from "./effect-procedure";
 import { getEffectErrorMap, unwrapEffectUpstream } from "./extension/state";
+import type { EffectRuntimeRunner } from "./runtime-source";
 import { effectErrorMapToErrorMap, type EffectErrorMap } from "./tagged-error";
 import type { EffectErrorMapToErrorMap, EnhancedEffectRouter } from "./types";
 
@@ -31,7 +31,7 @@ interface EnhanceEffectRouterOptions<
   middlewares: readonly AnyMiddleware[];
   errorMap: TEffectErrorMap;
   dedupeLeadingMiddlewares: boolean;
-  runtime: ManagedRuntime<TRequirementsProvided, TRuntimeError>;
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
 }
 
 export function enhanceEffectRouter<
@@ -97,7 +97,7 @@ export function enhanceEffectRouter<
         source["~orpc"].inputValidationIndex + newMiddlewareAdded,
       outputValidationIndex:
         source["~orpc"].outputValidationIndex + newMiddlewareAdded,
-      runtime: options.runtime,
+      runner: options.runner,
     }) as any;
   }
 

package/src/effect-procedure.ts

@@ -120,7 +120,7 @@ function getEffectProcedureDef(
     effectSteps: context.state.effectSteps,
     effectHandler: context.state.effectHandler,
     effectErrorMap: context.state.effectErrorMap,
-    runtime: context.state.runtime,
+    runner: context.state.runner,
   };
 }
 
@@ -136,7 +136,7 @@ function makeEffectProcedureHandler(
     effectErrorMap: def.effectErrorMap,
     effectFn: def.effectHandler.effectFn,
     effectSteps: def.effectSteps,
-    runtime: def.runtime,
+    runner: def.runner,
     spanConfig: def.effectHandler.spanConfig,
   });
 }
@@ -169,7 +169,7 @@ function flushEffectSteps(
 
   const middleware = createEffectPipelineMiddleware({
     effectErrorMap: def.effectErrorMap,
-    runtime: def.runtime,
+    runner: def.runner,
     steps: def.effectSteps,
   });
 
@@ -255,7 +255,7 @@ function createEffectProcedureProxy<
                     def.middlewares,
                     createEffectPipelineMiddleware({
                       effectErrorMap: state.effectErrorMap,
-                      runtime: state.runtime,
+                      runner: state.runner,
                       steps: [step],
                     }),
                   ),
@@ -279,7 +279,7 @@ function createEffectProcedureProxy<
                   createEffectProviderMiddleware({
                     effectErrorMap: state.effectErrorMap,
                     provider,
-                    runtime: state.runtime,
+                    runner: state.runner,
                     tag: tagOrLayer,
                   }),
                 ),
@@ -308,7 +308,7 @@ function createEffectProcedureProxy<
                   createEffectOptionalProviderMiddleware({
                     effectErrorMap: state.effectErrorMap,
                     provider,
-                    runtime: state.runtime,
+                    runner: state.runner,
                     tag,
                   }),
                 ),
@@ -473,7 +473,7 @@ export class EffectProcedure<
       effectSteps,
       effectHandler,
       effectErrorMap: def.effectErrorMap,
-      runtime: def.runtime,
+      runner: def.runner,
     });
 
     if (new.target === EffectProcedure) {

package/src/effect-runtime.ts

@@ -9,10 +9,10 @@ import type {
   ProcedureHandlerOptions,
 } from "@orpc/server";
 import type { Promisable } from "@orpc/shared";
-import type { ManagedRuntime } from "effect";
-import { Cause, Effect, Exit, FiberRefs, Option } from "effect";
+import { Cause, Effect, Exit, Option } from "effect";
 
-import { getCurrentFiberRefs, runWithFiberRefs } from "./fiber-context-bridge";
+import { runWithFiberRefs } from "./fiber-context-bridge";
+import type { EffectRuntimeRunner } from "./runtime-source";
 import type { EffectErrorConstructorMap, EffectErrorMap } from "./tagged-error";
 import {
   createEffectErrorConstructorMap,
@@ -78,7 +78,7 @@ export function createEffectProcedureHandler<
   TRuntimeError,
   TMeta extends Meta,
 >(options: {
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>;
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
   effectErrorMap: TEffectErrorMap;
   effectFn: EffectProcedureHandler<
     TCurrentContext,
@@ -99,7 +99,7 @@ export function createEffectProcedureHandler<
   TMeta & Record<never, never>
 > {
   const {
-    runtime,
+    runner,
     effectErrorMap,
     effectFn,
     effectSteps = [],
@@ -145,10 +145,9 @@ export function createEffectProcedureHandler<
       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);
@@ -166,7 +165,7 @@ export function createEffectPipelineMiddleware<
   TRuntimeError,
   TMeta extends Meta,
 >(options: {
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>;
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
   effectErrorMap: TEffectErrorMap;
   steps: readonly EffectPipelineStep[];
 }): Middleware<
@@ -177,7 +176,7 @@ export function createEffectPipelineMiddleware<
   any,
   TMeta
 > {
-  const { runtime, effectErrorMap, steps } = options;
+  const { runner, effectErrorMap, steps } = options;
 
   return async (opts, input) => {
     const baseOptions = makeEffectOptions<
@@ -186,7 +185,14 @@ export function createEffectPipelineMiddleware<
       TEffectErrorMap,
       TMeta
     >(opts, input, effectErrorMap);
-    const effect = runEffectPipeline({
+    const effect = runEffectPipeline<
+      TCurrentContext,
+      unknown,
+      TOutput,
+      TEffectErrorMap,
+      TRequirementsProvided,
+      TMeta
+    >({
       baseOptions,
       effectErrorMap,
       final: (context) =>
@@ -200,10 +206,9 @@ export function createEffectPipelineMiddleware<
       input,
       steps,
     });
-    const exit = await runtime.runPromiseExit(
-      withParentFiberRefs(effect as any),
-      { signal: opts.signal },
-    );
+    const exit = await runner.runPromiseExit(effect, {
+      signal: opts.signal,
+    });
 
     if (Exit.isFailure(exit)) throw toORPCErrorFromCause(exit.cause);
 
@@ -220,7 +225,7 @@ export function createEffectProviderMiddleware<
   TMeta extends Meta,
   TTag extends EffectTag,
 >(options: {
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>;
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
   effectErrorMap: TEffectErrorMap;
   tag: TTag;
   provider: EffectProvider<
@@ -232,7 +237,7 @@ export function createEffectProviderMiddleware<
     TTag
   >;
 }): Middleware<TCurrentContext, Record<never, never>, TInput, any, any, TMeta> {
-  const { runtime, effectErrorMap, tag, provider } = options;
+  const { runner, effectErrorMap, tag, provider } = options;
 
   return async (opts, input) => {
     const effectOpts = makeEffectOptions<
@@ -248,7 +253,7 @@ export function createEffectProviderMiddleware<
         service,
       ),
     );
-    const exit = await runtime.runPromiseExit(withParentFiberRefs(effect), {
+    const exit = await runner.runPromiseExit(effect, {
       signal: opts.signal,
     });
 
@@ -267,7 +272,7 @@ export function createEffectOptionalProviderMiddleware<
   TMeta extends Meta,
   TTag extends EffectTag,
 >(options: {
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>;
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
   effectErrorMap: TEffectErrorMap;
   tag: TTag;
   provider: EffectOptionalProvider<
@@ -279,7 +284,7 @@ export function createEffectOptionalProviderMiddleware<
     TTag
   >;
 }): Middleware<TCurrentContext, Record<never, never>, TInput, any, any, TMeta> {
-  const { runtime, effectErrorMap, tag, provider } = options;
+  const { runner, effectErrorMap, tag, provider } = options;
 
   return async (opts, input) => {
     const effectOpts = makeEffectOptions<
@@ -299,7 +304,7 @@ export function createEffectOptionalProviderMiddleware<
           ),
       }),
     );
-    const exit = await runtime.runPromiseExit(withParentFiberRefs(effect), {
+    const exit = await runner.runPromiseExit(effect, {
       signal: opts.signal,
     });
 
@@ -549,18 +554,3 @@ function withCurrentFiberContext<T>(fn: () => Promisable<T>): Effect.Effect<T> {
     ),
   );
 }
-
-function withParentFiberRefs<A, E, R>(
-  effect: Effect.Effect<A, E, R>,
-): Effect.Effect<A, E, R> {
-  const parentFiberRefs = getCurrentFiberRefs();
-  return parentFiberRefs
-    ? Effect.fiberIdWith((fiberId) =>
-        Effect.flatMap(Effect.getFiberRefs, (fiberRefs) =>
-          Effect.setFiberRefs(
-            FiberRefs.joinAs(fiberRefs, fiberId, parentFiberRefs),
-          ).pipe(Effect.andThen(effect)),
-        ),
-      )
-    : effect;
-}

package/src/extension/state.ts

@@ -1,5 +1,4 @@
-import type { ManagedRuntime } from "effect";
-
+import type { EffectRuntimeRunner } from "../runtime-source";
 import type { EffectErrorMap } from "../tagged-error";
 import type {
   EffectPipelineStep,
@@ -17,10 +16,9 @@ export interface EffectExtensionState<
    */
   effectErrorMap: EffectErrorMap;
   /**
-   * The Effect ManagedRuntime that provides services for Effect procedures.
-   * @see {@link ManagedRuntime.ManagedRuntime}
+   * Executes Effect values with the services configured for this builder.
    */
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>;
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
   /**
    * Configuration for Effect span tracing.
    * @see {@link EffectSpanConfig}

package/src/index.ts

@@ -16,6 +16,7 @@ export type {
 export {
   addSpanStackTrace,
   EffectBuilder,
+  eos,
   makeEffectORPC,
 } from "./effect-builder";
 export { EffectDecoratedProcedure } from "./effect-procedure";

package/src/runtime-source.ts

@@ -1,18 +1,76 @@
-import { Layer, ManagedRuntime } from "effect";
+import { Effect, Exit, FiberRefs, Layer, ManagedRuntime } from "effect";
+
+import { getCurrentFiberRefs } from "./fiber-context-bridge";
 
 export type EffectRuntimeSource<TRequirementsProvided, TRuntimeError> =
   | ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>
   | Layer.Layer<TRequirementsProvided, TRuntimeError, never>;
 
-export function toManagedRuntime<TRequirementsProvided, TRuntimeError>(
-  source: EffectRuntimeSource<TRequirementsProvided, TRuntimeError>,
-): ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError> {
-  return ManagedRuntime.isManagedRuntime(source)
-    ? (source as ManagedRuntime.ManagedRuntime<
-        TRequirementsProvided,
-        TRuntimeError
-      >)
-    : ManagedRuntime.make(
-        source as Layer.Layer<TRequirementsProvided, TRuntimeError, never>,
-      );
+export interface EffectRuntimeRunner<TRequirementsProvided, TRuntimeError> {
+  readonly runtime?: ManagedRuntime.ManagedRuntime<
+    TRequirementsProvided,
+    TRuntimeError
+  >;
+  readonly runPromiseExit: <A, E>(
+    effect: Effect.Effect<A, E, TRequirementsProvided>,
+    options?: { readonly signal?: AbortSignal },
+  ) => Promise<Exit.Exit<A, E | TRuntimeError>>;
+}
+
+export function makeEffectRuntimeRunner<
+  TRequirementsProvided = never,
+  TRuntimeError = never,
+>(
+  source?: EffectRuntimeSource<TRequirementsProvided, TRuntimeError>,
+): EffectRuntimeRunner<TRequirementsProvided, TRuntimeError> {
+  if (source === undefined) {
+    return {
+      runPromiseExit: (effect, options) =>
+        Effect.runPromiseExit(withParentFiberRefs(effect as any), {
+          signal: options?.signal,
+        }) as Promise<Exit.Exit<any, any>>,
+    };
+  }
+
+  if (ManagedRuntime.isManagedRuntime(source)) {
+    const runtime = source as ManagedRuntime.ManagedRuntime<
+      TRequirementsProvided,
+      TRuntimeError
+    >;
+    return {
+      runtime,
+      runPromiseExit: (effect, options) =>
+        runtime.runPromiseExit(withParentFiberRefs(effect), {
+          signal: options?.signal,
+        }),
+    };
+  }
+
+  const layer = source as Layer.Layer<
+    TRequirementsProvided,
+    TRuntimeError,
+    never
+  >;
+  return {
+    runPromiseExit: (effect, options) =>
+      Effect.runPromiseExit(
+        withParentFiberRefs(Effect.provide(effect as any, layer)),
+        { signal: options?.signal },
+      ) as Promise<Exit.Exit<any, any>>,
+  };
+}
+
+function withParentFiberRefs<A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+): Effect.Effect<A, E, R> {
+  const parentFiberRefs = getCurrentFiberRefs();
+  return parentFiberRefs
+    ? Effect.fiberIdWith((fiberId) =>
+        Effect.flatMap(Effect.getFiberRefs, (fiberRefs) =>
+          Effect.setFiberRefs(
+            FiberRefs.joinAs(fiberRefs, fiberId, parentFiberRefs),
+          ).pipe(Effect.andThen(effect)),
+        ),
+      )
+    : effect;
 }

package/src/tagged-error.ts

@@ -341,7 +341,7 @@ export function ORPCTaggedError<
  *
  * @example
  * ```ts
- * const handler = effectOs.effect(function* () {
+ * const handler = effectProcedure.effect(function* () {
  *   const result = yield* someOperation.pipe(
  *     Effect.catchTag('UserNotFoundError', (e) =>
  *       Effect.fail(toORPCError(e))

package/src/tests/contract.test.ts

@@ -76,14 +76,11 @@ describe("implementEffect", () => {
       };
     });
 
-    try {
-      await expect(call(procedure, { amount: 2 })).resolves.toEqual({
-        next: 3,
-        requestId: "layer",
-      });
-    } finally {
-      await procedure["~effect"].runtime.dispose();
-    }
+    expect(procedure["~effect"].runner.runtime).toBeUndefined();
+    await expect(call(procedure, { amount: 2 })).resolves.toEqual({
+      next: 3,
+      requestId: "layer",
+    });
   });
 
   it("preserves contract enforcement at the root router", async () => {

package/src/tests/effect-builder.proxy.test.ts

@@ -121,7 +121,7 @@ describe("effectBuilder proxy compatibility", () => {
       ({ input }: { input: { id: string } }) => input,
     );
     expect(procedure).toBeInstanceOf(EffectDecoratedProcedure);
-    expect(procedure["~effect"].runtime).toBe(runtime);
+    expect(procedure["~effect"].runner.runtime).toBe(runtime);
   });
 
   it("preserves tagged class support in errors()", () => {
@@ -155,11 +155,11 @@ describe("effectBuilder proxy compatibility", () => {
 
     expect(handled).toBeInstanceOf(EffectDecoratedProcedure);
     expect(effected).toBeInstanceOf(EffectDecoratedProcedure);
-    expect(routed.ping["~effect"].runtime).toBe(runtime);
+    expect(routed.ping["~effect"].runner.runtime).toBe(runtime);
     expect(isLazy(lazied)).toBe(true);
 
     const { default: resolved } = await unlazy(lazied as any);
-    expect(resolved.ping["~effect"].runtime).toBe(runtime);
+    expect(resolved.ping["~effect"].runner.runtime).toBe(runtime);
   });
 
   it("preserves decorated procedure proxy reflection and extracted methods", () => {
@@ -214,7 +214,7 @@ describe("effectBuilder proxy compatibility", () => {
 
     await expect(callable("hello")).resolves.toEqual({ echoed: "hello" });
     expect(callable).toSatisfy(isProcedure);
-    expect(callable["~effect"].runtime).toBe(runtime);
+    expect(callable["~effect"].runner.runtime).toBe(runtime);
     expect(callable.route({ path: "/echo" })).toBeInstanceOf(
       EffectDecoratedProcedure,
     );