effect-orpc 0.3.0 → 0.4.0

package/README.md

@@ -30,7 +30,7 @@ Runnable demos live in the repository's `examples/` directory.
 ```ts
 import { os } from "@orpc/server";
 import { Effect, ManagedRuntime } from "effect";
-import { makeEffectORPC, ORPCTaggedError } from "effect-orpc";
+import { eos, makeEffectORPC, ORPCTaggedError } from "effect-orpc";
 
 interface User {
   id: number;
@@ -43,15 +43,6 @@ let users: User[] = [
   { id: 3, name: "James Dane" },
 ];
 
-// Authenticated os with initial context & errors set
-const authedOs = os
-  .errors({ UNAUTHORIZED: { status: 401 } })
-  .$context<{ userId?: number }>()
-  .use(({ context, errors, next }) => {
-    if (context.userId === undefined) throw errors.UNAUTHORIZED();
-    return next({ context: { ...context, userId: context.userId } });
-  });
-
 // Define your services
 class UsersRepo extends Effect.Service<UsersRepo>()("UsersRepo", {
   accessors: true,
@@ -65,26 +56,27 @@ class UserNotFoundError extends ORPCTaggedError("UserNotFoundError", {
   status: 404,
 }) {}
 
-// Create an Effect-aware oRPC builder with your service layer, optionally from
-// another base oRPC builder, and provide tagged errors.
-const effectOs = makeEffectORPC(UsersRepo.Default, authedOs).errors({
-  UserNotFoundError,
-});
+// Create an Effect-aware oRPC builder with your service layer, context, errors,
+// and middleware.
+const effectProcedure = eos
+  .provide(UsersRepo.Default)
+  .errors({ UNAUTHORIZED: { status: 401 }, UserNotFoundError })
+  .$context<{ userId?: number }>()
+  .use(({ context, errors, next }) => {
+    if (context.userId === undefined) throw errors.UNAUTHORIZED();
+    return next({ context: { ...context, userId: context.userId } });
+  });
 
-// You can also pass an explicit ManagedRuntime if you need lifecycle control:
+// Use ManagedRuntime only when scoped resources should be acquired once and
+// released on shutdown, for example a shared cache, database pool, or telemetry SDK:
 // const runtime = ManagedRuntime.make(UsersRepo.Default);
-// const effectOs = makeEffectORPC(runtime, authedOs).errors({ UserNotFoundError });
-
-// Or start with only the builder and provide the layer later:
-// const effectOs = makeEffectORPC(authedOs)
-//   .provide(UsersRepo.Default)
-//   .errors({ UserNotFoundError });
+// const effectProcedure = makeEffectORPC(runtime).errors({ UserNotFoundError });
 
 // Create the router with mixed procedures
 export const router = {
   health: os.handler(() => "ok"),
   users: {
-    me: effectOs.effect(function* ({ context: { userId } }) {
+    me: effectProcedure.effect(function* ({ context: { userId } }) {
       const user = yield* UsersRepo.get(userId);
       if (!user) {
         return yield* new UserNotFoundError();
@@ -103,7 +95,7 @@ The wrapper enforces that Effect procedures only use services provided by `.prov
 
 ```ts
 import { Context, Effect, Layer } from "effect";
-import { makeEffectORPC } from "effect-orpc";
+import { eos } from "effect-orpc";
 
 class ProvidedService extends Context.Tag("ProvidedService")<
   ProvidedService,
@@ -119,16 +111,16 @@ const AppLive = Layer.succeed(ProvidedService, {
   doSomething: () => Effect.succeed("ok"),
 });
 
-const effectOs = makeEffectORPC(AppLive);
+const effectProcedure = eos.provide(AppLive);
 
 // ✅ This compiles - ProvidedService is provided by AppLive
-const works = effectOs.effect(function* () {
+const works = effectProcedure.effect(function* () {
   const service = yield* ProvidedService;
   return yield* service.doSomething();
 });
 
 // ❌ This fails to compile - MissingService is not provided
-const fails = effectOs.effect(function* () {
+const fails = effectProcedure.effect(function* () {
   const service = yield* MissingService; // Type error!
   return yield* service.doSomething();
 });
@@ -145,7 +137,7 @@ const fails = effectOs.effect(function* () {
 Make sure the tagged error class is passed to the effect `.errors()` to be able to yield the error class directly and make the client recognize it as defined.
 
 ```ts
-const getUser = effectOs
+const getUser = effectProcedure
   // Mixed error maps
   .errors({
     // Regular oRPC error
@@ -214,19 +206,19 @@ All Effect procedures are automatically traced with `Effect.withSpan`. By defaul
 const router = {
   users: {
     // Span name: "users.get"
-    get: effectOs.input(z.object({ id: z.string() })).effect(function* ({
+    get: effectProcedure.input(z.object({ id: z.string() })).effect(function* ({
       input,
     }) {
       const userService = yield* UserService;
       return yield* userService.findById(input.id);
     }),
     // Span name: "users.create"
-    create: effectOs.input(z.object({ name: z.string() })).effect(function* ({
-      input,
-    }) {
-      const userService = yield* UserService;
-      return yield* userService.create(input.name);
-    }),
+    create: effectProcedure
+      .input(z.object({ name: z.string() }))
+      .effect(function* ({ input }) {
+        const userService = yield* UserService;
+        return yield* userService.create(input.name);
+      }),
   },
 };
 ```
@@ -234,7 +226,7 @@ const router = {
 Use `.traced()` to override the default span name:
 
 ```ts
-const getUser = effectOs
+const getUser = effectProcedure
   .input(z.object({ id: z.string() }))
   .traced("custom.span.name") // Override the default path-based name
   .effect(function* ({ input }) {
@@ -261,7 +253,7 @@ const TracingLive = NodeSdk.layer(
 
 const AppLive = Layer.mergeAll(UserServiceLive, TracingLive);
 
-const effectOs = makeEffectORPC(AppLive);
+const effectProcedure = eos.provide(AppLive);
 ```
 
 ### Error Stack Traces
@@ -283,7 +275,7 @@ middleware. Two patterns are supported:
 automatically (no need to call `next`):
 
 ```ts
-effectOs.use(function* () {
+effectProcedure.use(function* () {
   const user = yield* CurrentUser;
   yield* requireActiveUser(user);
 });
@@ -293,7 +285,7 @@ effectOs.use(function* () {
 middleware that uses `return next(...)`, use `return yield* next(...)`:
 
 ```ts
-effectOs.use(function* ({ next }) {
+effectProcedure.use(function* ({ next }) {
   const user = yield* CurrentUser;
   yield* requireActiveUser(user);
 
@@ -306,7 +298,7 @@ effectOs.use(function* ({ next }) {
 To transform the downstream output, capture `next()` and pass through `output`:
 
 ```ts
-effectOs.use(function* ({ next }, _input, output) {
+effectProcedure.use(function* ({ next }, _input, output) {
   const result = yield* next();
   return yield* output(`${result.output}-wrapped`);
 });
@@ -323,7 +315,8 @@ Effect-native steps are `.provide(...)`, `.provideOptional(...)`, generator
 `.use(function* ...)`, and `.effect(function* ...)`.
 
 ```ts
-makeEffectORPC(AppLive)
+eos
+  .provide(AppLive)
   .provide(CurrentUser, ({ context }) => Effect.succeed(context.user))
   .use(function* ({ next }) {
     const user = yield* CurrentUser;
@@ -336,13 +329,14 @@ makeEffectORPC(AppLive)
 ```
 
 The example above runs the provider, middleware, and handler inside a single
-internal `runtime.runPromiseExit(...)` call.
+Effect execution boundary.
 
 A native oRPC middleware breaks the contiguous Effect pipeline. Pending Effect
 steps are flushed into one generated oRPC middleware before the native middleware:
 
 ```ts
-makeEffectORPC(AppLive)
+eos
+  .provide(AppLive)
   .provide(CurrentUser, getCurrentUser) // Effect group #1
   .use(function* ({ next }) {
     return yield* next();
@@ -370,10 +364,11 @@ Effect group #2.
 
 Procedure-level `.provide*` after a native `.handler(...)` has no Effect handler
 boundary to attach to, so it is installed as an oRPC middleware that runs its
-provider Effect through the runtime:
+provider Effect through the configured runtime source:
 
 ```ts
-makeEffectORPC(AppLive)
+eos
+  .provide(AppLive)
   .handler(() => "ok") // native oRPC handler
   .provide(CurrentUser, getCurrentUser); // fallback provider middleware
 ```
@@ -397,10 +392,10 @@ oRPC pipeline and should be visible inside handlers:
 ```ts
 import { Hono } from "hono";
 import { Effect } from "effect";
-import { makeEffectORPC } from "effect-orpc";
+import { eos } from "effect-orpc";
 import { withFiberContext } from "effect-orpc/node";
 
-const effectOs = makeEffectORPC(AppLive);
+const effectProcedure = eos.provide(AppLive);
 const app = new Hono();
 
 app.use("*", async (c, next) => {
@@ -432,8 +427,8 @@ relies on `AsyncLocalStorage` from `node:async_hooks`.
 
 Use `implementEffect(contract, layerOrRuntime)` when you already have an oRPC
 contract and want to keep contract-first enforcement while adding Effect-native
-handlers. Use `makeEffectORPC(layerOrRuntime, builder?)` when you want to build
-procedures directly from an oRPC builder.
+handlers. Use `eos.provide(layer)` when you want to build procedures directly
+from the default Effect-aware builder.
 
 ```ts
 import { Effect } from "effect";
@@ -478,29 +473,33 @@ directly from the `ORPCTaggedError` class.
 
 ## API Reference
 
-### `makeEffectORPC(layerOrRuntime, builder?)`
+### `eos`
 
-Creates an Effect-aware procedure builder. The recommended default is to pass
-your application `Layer` up front.
+The default Effect-aware procedure builder. Provide your application services
+with `.provide(layer)`:
 
-Returns an `EffectBuilder` instance.
+```ts
+const effectProcedure = eos.provide(AppLive);
+```
+
+Use `makeEffectORPC(runtime)` when a scoped `Layer` should be acquired once and
+released by your application shutdown path, such as a shared cache, database
+pool, HTTP client, or telemetry SDK:
 
 ```ts
-// With default builder
-const effectOs = makeEffectORPC(AppLive);
+const runtime = ManagedRuntime.make(AppLive);
+
+const effectProcedure = makeEffectORPC(runtime);
 
-// With customized builder
-const effectAuthedOs = makeEffectORPC(AppLive, authedBuilder);
+// later, during app shutdown
+await runtime.dispose();
 ```
 
-You can also start from a builder and provide the layer later, or pass a
-`ManagedRuntime` when you need explicit runtime lifecycle control:
+`makeEffectORPC(builder)` is also available when you need to wrap an existing
+oRPC builder:
 
 ```ts
-const effectOsWithProvidedLayer = makeEffectORPC().provide(AppLive);
-const effectAuthedOsWithProvidedLayer =
-  makeEffectORPC(authedBuilder).provide(AppLive);
-const effectOsFromRuntime = makeEffectORPC(runtime);
+const effectAuthedOs = makeEffectORPC(authedBuilder).provide(AppLive);
 ```
 
 ### `implementEffect(contract, layerOrRuntime)`
@@ -508,7 +507,7 @@ const effectOsFromRuntime = makeEffectORPC(runtime);
 Creates an Effect-aware contract implementer.
 
 - `contract` - An oRPC contract router built with `oc`
-- `layerOrRuntime` - A `Layer<R, E, never>` or `ManagedRuntime<R, E>` that provides services for Effect procedures
+- `layerOrRuntime` - A `Layer<R, E, never>` provided per call, or a user-owned `ManagedRuntime<R, E>` when the application should control acquisition and release (for example, a shared cache, database pool, or telemetry SDK)
 
 Returns a contract-shaped implementer tree whose leaves support `.effect(...)`.
 

package/dist/index.js

@@ -39,7 +39,7 @@ import { Layer } from "effect";
 
 // src/effect-runtime.ts
 import { ORPCError as ORPCError2 } from "@orpc/contract";
-import { Cause as Cause2, Effect, Exit, FiberRefs, Option } from "effect";
+import { Cause as Cause2, Effect, Exit, Option } from "effect";
 
 // src/tagged-error.ts
 import {
@@ -211,7 +211,7 @@ function toORPCErrorFromCause(cause) {
 }
 function createEffectProcedureHandler(options) {
   const {
-    runtime,
+    runner,
     effectErrorMap,
     effectFn,
     effectSteps = [],
@@ -246,10 +246,9 @@ function createEffectProcedureHandler(options) {
       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 +256,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({
@@ -271,16 +270,15 @@ function createEffectPipelineMiddleware(options) {
       input,
       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 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(
@@ -291,7 +289,7 @@ function createEffectProviderMiddleware(options) {
         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,7 +297,7 @@ 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(
@@ -313,7 +311,7 @@ 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);
@@ -445,17 +443,6 @@ function withCurrentFiberContext(fn) {
     )
   );
 }
-function withParentFiberRefs(effect) {
-  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;
-}
 
 // src/extension/compose-surfaces.ts
 function composeSurfaceProxy(surface, target) {
@@ -668,7 +655,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 +667,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 +689,7 @@ function flushEffectSteps(def) {
   }
   const middleware = createEffectPipelineMiddleware({
     effectErrorMap: def.effectErrorMap,
-    runtime: def.runtime,
+    runner: def.runner,
     steps: def.effectSteps
   });
   return withRebuiltEffectHandler({
@@ -770,7 +757,7 @@ function createEffectProcedureProxy(target, decorated) {
                     def.middlewares,
                     createEffectPipelineMiddleware({
                       effectErrorMap: state.effectErrorMap,
-                      runtime: state.runtime,
+                      runner: state.runner,
                       steps: [step]
                     })
                   )
@@ -792,7 +779,7 @@ function createEffectProcedureProxy(target, decorated) {
                   createEffectProviderMiddleware({
                     effectErrorMap: state.effectErrorMap,
                     provider,
-                    runtime: state.runtime,
+                    runner: state.runner,
                     tag: tagOrLayer
                   })
                 )
@@ -819,7 +806,7 @@ function createEffectProcedureProxy(target, decorated) {
                   createEffectOptionalProviderMiddleware({
                     effectErrorMap: state.effectErrorMap,
                     provider,
-                    runtime: state.runtime,
+                    runner: state.runner,
                     tag
                   })
                 )
@@ -885,7 +872,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 +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 = {};
@@ -951,11 +938,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, 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(
+        FiberRefs.joinAs(fiberRefs, fiberId, parentFiberRefs)
+      ).pipe(Effect2.andThen(effect))
+    )
+  ) : effect;
 }
 
 // src/effect-builder.ts
@@ -999,7 +1017,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 +1028,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 +1048,7 @@ function flushEffectSteps2(builder, state) {
   }
   const middleware = createEffectPipelineMiddleware({
     effectErrorMap: state.effectErrorMap,
-    runtime: state.runtime,
+    runner: state.runner,
     steps: state.effectSteps
   });
   return {
@@ -1088,7 +1106,7 @@ function createEffectBuilderProxy(target) {
                     effectErrorMap: state.effectErrorMap,
                     effectFn,
                     effectSteps: state.effectSteps,
-                    runtime: state.runtime,
+                    runner: state.runner,
                     spanConfig: state.spanConfig
                   })(opts);
                 }
@@ -1101,7 +1119,7 @@ function createEffectBuilderProxy(target) {
               if (isEffectMiddleware(middleware)) {
                 const effectMiddleware = createEffectPipelineMiddleware({
                   effectErrorMap: state.effectErrorMap,
-                  runtime: state.runtime,
+                  runner: state.runner,
                   steps: [
                     ...state.effectSteps ?? [],
                     { _tag: "middleware", middleware }
@@ -1227,12 +1245,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 +1260,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 +1283,7 @@ function emptyBuilder() {
     route: {}
   });
 }
+var eos = makeEffectORPC();
 
 // src/eoc.ts
 import { isContractProcedure, oc } from "@orpc/contract";
@@ -1405,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) {
@@ -1428,9 +1445,9 @@ function wrapContractNode(contract, target, runtime) {
               ...currentTarget["~orpc"],
               errorMap: effectErrorMapToErrorMap(effectErrorMap),
               effectErrorMap,
-              runtime,
+              runner,
               handler: createEffectProcedureHandler({
-                runtime,
+                runner,
                 effectErrorMap,
                 effectFn,
                 defaultCaptureStackTrace: addSpanStackTrace()
@@ -1448,7 +1465,7 @@ function wrapContractNode(contract, target, runtime) {
               currentTarget,
               args
             ),
-            runtime
+            runner
           );
           cache.set(prop, use);
           return use;
@@ -1465,7 +1482,7 @@ function wrapContractNode(contract, target, runtime) {
               currentTarget,
               args
             ),
-            runtime
+            runner
           );
           cache.set(prop, wrappedMethod);
           return wrappedMethod;
@@ -1477,7 +1494,7 @@ function wrapContractNode(contract, target, runtime) {
               currentTarget,
               args
             ),
-            makeEnhanceOptions(runtime)
+            makeEnhanceOptions(runner)
           );
           cache.set(prop, wrappedMethod);
           return wrappedMethod;
@@ -1486,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;
@@ -1514,7 +1531,7 @@ function implementEffect(contract, source) {
   return wrapContractNode(
     contract,
     implement(contract),
-    toManagedRuntime(source)
+    makeEffectRuntimeRunner(source)
   );
 }
 export {
@@ -1526,6 +1543,7 @@ export {
   createEffectErrorConstructorMap,
   effectErrorMapToErrorMap,
   eoc,
+  eos,
   implementEffect,
   isORPCTaggedError,
   isORPCTaggedErrorClass,