effect-orpc 0.2.1 → 0.3.0

package/src/effect-builder.ts

@@ -7,11 +7,15 @@ import type {
 } from "@orpc/contract";
 import type { Context, Router } from "@orpc/server";
 import { Builder, fallbackConfig, lazy } from "@orpc/server";
-import type { ManagedRuntime } from "effect";
+import { Layer, ManagedRuntime } from "effect";
 
 import { enhanceEffectRouter } from "./effect-enhance-router";
 import { EffectDecoratedProcedure } from "./effect-procedure";
-import { createEffectProcedureHandler } from "./effect-runtime";
+import {
+  createEffectPipelineMiddleware,
+  createEffectProcedureHandler,
+  isEffectMiddleware,
+} from "./effect-runtime";
 import {
   createNodeProxy,
   unhandled,
@@ -23,6 +27,8 @@ import {
   unwrapEffectUpstream,
   type EffectProxyTarget,
 } from "./extension/state";
+import type { EffectRuntimeSource } from "./runtime-source";
+import { toManagedRuntime } from "./runtime-source";
 import type { EffectErrorMap, MergedEffectErrorMap } from "./tagged-error";
 import { effectErrorMapToErrorMap } from "./tagged-error";
 import type {
@@ -43,6 +49,9 @@ const 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 },
 } as const;
@@ -51,6 +60,9 @@ const builderVirtualKeys = [
   "~effect",
   "errors",
   "effect",
+  "middleware",
+  "provide",
+  "provideOptional",
   "traced",
   "handler",
   "router",
@@ -96,6 +108,8 @@ function getEffectBuilderDef(
     effectErrorMap: context.state.effectErrorMap,
     runtime: context.state.runtime,
     spanConfig: context.state.spanConfig,
+    effectSteps: context.state.effectSteps,
+    effectHandler: context.state.effectHandler,
   };
 }
 
@@ -109,11 +123,55 @@ function wrapBuilderLike(
       effectErrorMap: state.effectErrorMap,
       runtime: state.runtime,
       spanConfig: state.spanConfig,
+      effectSteps: state.effectSteps,
+      effectHandler: state.effectHandler,
     },
     unwrapEffectUpstream(builder),
   );
 }
 
+function appendEffectStep(
+  state: NodeProxyContext<EffectBuilderTarget, AnyBuilderLike>["state"],
+  step: NonNullable<
+    NodeProxyContext<
+      EffectBuilderTarget,
+      AnyBuilderLike
+    >["state"]["effectSteps"]
+  >[number],
+): NodeProxyContext<EffectBuilderTarget, AnyBuilderLike>["state"] {
+  return {
+    ...state,
+    effectSteps: [...(state.effectSteps ?? []), step],
+  };
+}
+
+function flushEffectSteps(
+  builder: AnyBuilderLike,
+  state: NodeProxyContext<EffectBuilderTarget, AnyBuilderLike>["state"],
+): {
+  builder: AnyBuilderLike;
+  state: NodeProxyContext<EffectBuilderTarget, AnyBuilderLike>["state"];
+} {
+  if (!state.effectSteps?.length) {
+    return { builder, state };
+  }
+
+  const middleware = createEffectPipelineMiddleware({
+    effectErrorMap: state.effectErrorMap,
+    runtime: state.runtime,
+    steps: state.effectSteps,
+  });
+  return {
+    builder: Reflect.apply(Reflect.get(builder, "use", builder), builder, [
+      middleware,
+    ]) as AnyBuilderLike,
+    state: {
+      ...state,
+      effectSteps: undefined,
+    },
+  };
+}
+
 function createEffectBuilderProxy(
   target: EffectBuilderTarget,
 ): EffectBuilderTarget {
@@ -166,13 +224,20 @@ function createEffectBuilderProxy(
               >[0],
             ) => {
               const defaultCaptureStackTrace = addSpanStackTrace();
+              const effectHandler = {
+                defaultCaptureStackTrace,
+                effectFn,
+                spanConfig: state.spanConfig,
+              };
               return new EffectDecoratedProcedure({
                 ...effectDef,
+                effectHandler,
                 handler: async (opts) => {
                   return createEffectProcedureHandler({
                     defaultCaptureStackTrace,
                     effectErrorMap: state.effectErrorMap,
                     effectFn,
+                    effectSteps: state.effectSteps,
                     runtime: state.runtime,
                     spanConfig: state.spanConfig,
                   })(opts as any);
@@ -180,6 +245,82 @@ function createEffectBuilderProxy(
               });
             };
           });
+        case "middleware":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (middleware: any) => {
+              if (isEffectMiddleware(middleware)) {
+                const effectMiddleware = createEffectPipelineMiddleware({
+                  effectErrorMap: state.effectErrorMap,
+                  runtime: state.runtime,
+                  steps: [
+                    ...(state.effectSteps ?? []),
+                    { _tag: "middleware" as const, middleware },
+                  ],
+                });
+
+                return Reflect.apply(
+                  Reflect.get(source, "middleware", source),
+                  source,
+                  [effectMiddleware],
+                );
+              }
+
+              return Reflect.apply(
+                Reflect.get(source, "middleware", source),
+                source,
+                [middleware],
+              );
+            };
+          });
+        case "provide":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (tagOrLayer: any, provider?: any) => {
+              return wrapBuilderLike(
+                source,
+                appendEffectStep(
+                  state,
+                  Layer.isLayer(tagOrLayer)
+                    ? { _tag: "provideLayer", layer: tagOrLayer }
+                    : { _tag: "provide", provider, tag: tagOrLayer },
+                ),
+              );
+            };
+          });
+        case "provideOptional":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (tag: any, provider: any) => {
+              return wrapBuilderLike(
+                source,
+                appendEffectStep(state, {
+                  _tag: "provideOptional",
+                  provider,
+                  tag,
+                }),
+              );
+            };
+          });
+        case "use":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (middleware: any, ...rest: unknown[]) => {
+              if (isEffectMiddleware(middleware) && rest.length === 0) {
+                return wrapBuilderLike(
+                  source,
+                  appendEffectStep(state, {
+                    _tag: "middleware",
+                    middleware,
+                  }),
+                );
+              }
+
+              const flushed = flushEffectSteps(source, state);
+              const nextBuilder: AnyBuilderLike = Reflect.apply(
+                Reflect.get(flushed.builder, "use", flushed.builder),
+                flushed.builder,
+                [middleware, ...rest],
+              );
+              return wrapBuilderLike(nextBuilder, flushed.state);
+            };
+          });
         case "traced":
           return getOrCreateVirtualMethod(context, prop, () => {
             return (spanName: string) =>
@@ -292,6 +433,12 @@ export class EffectBuilder<
   TRequirementsProvided,
   TRuntimeError
 > {
+  /**
+   * Sets or overrides the config.
+   *
+   * @see {@link https://orpc.dev/docs/client/server-side#middlewares-order Middlewares Order Docs}
+   * @see {@link https://orpc.dev/docs/best-practices/dedupe-middleware#configuration Dedupe Middleware Docs}
+   */
   declare $config: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -302,6 +449,11 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["$config"];
+  /**
+   * Set or override the initial context.
+   *
+   * @see {@link https://orpc.dev/docs/context Context Docs}
+   */
   declare $context: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -312,6 +464,11 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["$context"];
+  /**
+   * Sets or overrides the initial meta.
+   *
+   * @see {@link https://orpc.dev/docs/metadata Metadata Docs}
+   */
   declare $meta: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -322,6 +479,13 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["$meta"];
+  /**
+   * Sets or overrides the initial route.
+   * This option is typically relevant when integrating with OpenAPI.
+   *
+   * @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+   * @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+   */
   declare $route: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -332,6 +496,11 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["$route"];
+  /**
+   * Sets or overrides the initial input schema.
+   *
+   * @see {@link https://orpc.dev/docs/procedure#initial-configuration Initial Procedure Configuration Docs}
+   */
   declare $input: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -342,6 +511,9 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["$input"];
+  /**
+   * This property holds the defined options and the effect-specific properties.
+   */
   declare "~effect": EffectBuilderDef<
     TInputSchema,
     TOutputSchema,
@@ -350,6 +522,9 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >;
+  /**
+   * This property holds the defined options.
+   */
   declare "~orpc": EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -360,6 +535,11 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["~orpc"];
+  /**
+   * Creates a middleware.
+   *
+   * @see {@link https://orpc.dev/docs/middleware Middleware Docs}
+   */
   declare middleware: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -370,6 +550,27 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["middleware"];
+  /**
+   * Adds type-safe custom errors.
+   * Supports both traditional oRPC error definitions and ORPCTaggedError classes.
+   *
+   * @example
+   * ```ts
+   * // Traditional format
+   * builder.errors({ BAD_REQUEST: { status: 400, message: 'Bad request' } })
+   *
+   * // Tagged error class
+   * builder.errors({ USER_NOT_FOUND: UserNotFoundError })
+   *
+   * // Mixed
+   * builder.errors({
+   *   BAD_REQUEST: { status: 400 },
+   *   USER_NOT_FOUND: UserNotFoundError,
+   * })
+   * ```
+   *
+   * @see {@link https://orpc.dev/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
+   */
   declare errors: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -380,6 +581,13 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["errors"];
+  /**
+   * Uses a middleware to modify the context or improve the pipeline.
+   *
+   * @info Supports both normal middleware and inline middleware implementations.
+   * @note The current context must be satisfy middleware dependent-context
+   * @see {@link https://orpc.dev/docs/middleware Middleware Docs}
+   */
   declare use: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -390,6 +598,38 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["use"];
+  /**
+   * Provides a request-scoped Effect service to downstream procedures.
+   */
+  declare provide: EffectBuilderSurface<
+    TInitialContext,
+    TCurrentContext,
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta,
+    TRequirementsProvided,
+    TRuntimeError
+  >["provide"];
+  /**
+   * Optionally provides a request-scoped Effect service to downstream procedures.
+   */
+  declare provideOptional: EffectBuilderSurface<
+    TInitialContext,
+    TCurrentContext,
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta,
+    TRequirementsProvided,
+    TRuntimeError
+  >["provideOptional"];
+  /**
+   * Sets or updates the metadata.
+   * The provided metadata is spared-merged with any existing metadata.
+   *
+   * @see {@link https://orpc.dev/docs/metadata Metadata Docs}
+   */
   declare meta: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -400,6 +640,14 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["meta"];
+  /**
+   * Sets or updates the route definition.
+   * The provided route is spared-merged with any existing route.
+   * This option is typically relevant when integrating with OpenAPI.
+   *
+   * @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+   * @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+   */
   declare route: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -410,6 +658,11 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["route"];
+  /**
+   * Defines the input validation schema.
+   *
+   * @see {@link https://orpc.dev/docs/procedure#input-output-validation Input Validation Docs}
+   */
   declare input: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -420,6 +673,11 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["input"];
+  /**
+   * Defines the output validation schema.
+   *
+   * @see {@link https://orpc.dev/docs/procedure#input-output-validation Output Validation Docs}
+   */
   declare output: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -430,6 +688,25 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["output"];
+  /**
+   * Adds a traceable span to the procedure for telemetry.
+   * The span name is used for Effect tracing via `Effect.withSpan`.
+   * Stack trace is captured at the call site for better error reporting.
+   *
+   * @param spanName - The name of the span for telemetry (e.g., 'users.getUser')
+   * @returns An EffectBuilder with span tracing configured
+   *
+   * @example
+   * ```ts
+   * const getUser = effectOs
+   *   .input(z.object({ id: z.string() }))
+   *   .traced('users.getUser')
+   *   .effect(function* ({ input }) {
+   *     const userService = yield* UserService
+   *     return yield* userService.findById(input.id)
+   *   })
+   * ```
+   */
   declare traced: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -440,6 +717,11 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["traced"];
+  /**
+   * Defines the handler of the procedure using a standard async/sync function.
+   *
+   * @see {@link https://orpc.dev/docs/procedure Procedure Docs}
+   */
   declare handler: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -450,6 +732,13 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["handler"];
+  /**
+   * Defines the handler of the procedure using an Effect.
+   * The Effect is executed using the ManagedRuntime provided during builder creation.
+   * The effect is automatically wrapped with `Effect.withSpan`.
+   *
+   * @see {@link https://orpc.dev/docs/procedure Procedure Docs}
+   */
   declare effect: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -460,6 +749,14 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["effect"];
+  /**
+   * Prefixes all procedures in the router.
+   * The provided prefix is post-appended to any existing router prefix.
+   *
+   * @note This option does not affect procedures that do not define a path in their route definition.
+   *
+   * @see {@link https://orpc.dev/docs/openapi/routing#route-prefixes OpenAPI Route Prefixes Docs}
+   */
   declare prefix: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -470,6 +767,12 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["prefix"];
+  /**
+   * Adds tags to all procedures in the router.
+   * This helpful when you want to group procedures together in the OpenAPI specification.
+   *
+   * @see {@link https://orpc.dev/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+   */
   declare tag: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -480,6 +783,11 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["tag"];
+  /**
+   * Applies all of the previously defined options to the specified router.
+   *
+   * @see {@link https://orpc.dev/docs/router#extending-router Extending Router Docs}
+   */
   declare router: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -490,6 +798,12 @@ export class EffectBuilder<
     TRequirementsProvided,
     TRuntimeError
   >["router"];
+  /**
+   * Create a lazy router
+   * And applies all of the previously defined options to the specified router.
+   *
+   * @see {@link https://orpc.dev/docs/router#extending-router Extending Router Docs}
+   */
   declare lazy: EffectBuilderSurface<
     TInitialContext,
     TCurrentContext,
@@ -512,9 +826,12 @@ export class EffectBuilder<
     >,
     builder?: AnyBuilderLike,
   ) {
-    const { runtime, spanConfig, effectErrorMap, ...orpcDef } = def;
+    const { runtime, spanConfig, effectErrorMap, effectSteps, ...orpcDef } =
+      def;
 
     attachEffectState(this, builder ?? new Builder(orpcDef), {
+      effectSteps,
+      effectHandler: def.effectHandler,
       effectErrorMap,
       runtime,
       spanConfig,
@@ -524,12 +841,76 @@ export class EffectBuilder<
   }
 }
 
+/**
+ * Creates an Effect-aware procedure builder with the specified Layer.
+ * Uses the default builder shape from `@orpc/server`.
+ *
+ * @param layer - The Layer that provides services for Effect procedures
+ * @returns An EffectBuilder instance for creating Effect-native procedures
+ *
+ * @example
+ * ```ts
+ * import { makeEffectORPC } from '@orpc/effect'
+ * import { Effect, Layer } from 'effect'
+ *
+ * const effectOs = makeEffectORPC(Layer.empty)
+ *
+ * const hello = effectOs.effect(() => Effect.succeed('Hello!'))
+ * ```
+ */
+export function makeEffectORPC(): EffectBuilder<
+  Context,
+  Context,
+  Schema<unknown, unknown>,
+  Schema<unknown, unknown>,
+  Record<never, never>,
+  Record<never, never>,
+  never,
+  never
+>;
+
+export function makeEffectORPC<
+  TBuilder extends AnyBuilderLike<
+    TInputSchema,
+    TOutputSchema,
+    TErrorMap,
+    TMeta
+  >,
+  TInputSchema extends AnySchema,
+  TOutputSchema extends AnySchema,
+  TErrorMap extends ErrorMap,
+  TMeta extends Meta,
+>(
+  builder: TBuilder,
+): EffectBuilder<
+  InferBuilderInitialContext<TBuilder>,
+  InferBuilderCurrentContext<TBuilder>,
+  InferBuilderInputSchema<TBuilder>,
+  InferBuilderOutputSchema<TBuilder>,
+  InferBuilderErrorMap<TBuilder>,
+  InferBuilderMeta<TBuilder>,
+  never,
+  never
+>;
+
+export function makeEffectORPC<TRequirementsProvided, TRuntimeError>(
+  layer: Layer.Layer<TRequirementsProvided, TRuntimeError, never>,
+): EffectBuilder<
+  Context,
+  Context,
+  Schema<unknown, unknown>,
+  Schema<unknown, unknown>,
+  Record<never, never>,
+  Record<never, never>,
+  TRequirementsProvided,
+  TRuntimeError
+>;
+
 /**
  * Creates an Effect-aware procedure builder with the specified ManagedRuntime.
  * Uses the default builder shape from `@orpc/server`.
  *
  * @param runtime - The ManagedRuntime that provides services for Effect procedures
- * @returns An EffectBuilder instance for creating Effect-native procedures
  */
 export function makeEffectORPC<TRequirementsProvided, TRuntimeError>(
   runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>,
@@ -546,11 +927,33 @@ export function makeEffectORPC<TRequirementsProvided, TRuntimeError>(
 
 /**
  * Creates an Effect-aware procedure builder by wrapping an existing oRPC Builder
- * with the specified ManagedRuntime.
+ * with the specified Layer.
  *
- * @param runtime - The ManagedRuntime that provides services for Effect procedures
- * @param builder - The oRPC Builder instance to wrap
+ * @param layer - The Layer that provides services for Effect procedures
+ * @param builder - The oRPC Builder instance to wrap (e.g., a customized `os`)
  * @returns An EffectBuilder instance that extends the original builder with Effect support
+ *
+ * @example
+ * ```ts
+ * import { makeEffectORPC } from '@orpc/effect'
+ * import { os } from '@orpc/server'
+ * import { Effect, Layer } from 'effect'
+ *
+ * // Create a customized builder
+ * const authedOs = os.use(authMiddleware)
+ *
+ * // Wrap it with Effect support
+ * const effectOs = makeEffectORPC(UserServiceLive, authedOs)
+ *
+ * const getUser = effectOs
+ *   .input(z.object({ id: z.string() }))
+ *   .effect(
+ *     Effect.fn(function* ({ input }) {
+ *       const userService = yield* UserService
+ *       return yield* userService.findById(input.id)
+ *     })
+ *   )
+ * ```
  */
 export function makeEffectORPC<
   TBuilder extends AnyBuilderLike<
@@ -566,7 +969,7 @@ export function makeEffectORPC<
   TRequirementsProvided,
   TRuntimeError,
 >(
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>,
+  layer: Layer.Layer<TRequirementsProvided, TRuntimeError, never>,
   builder: TBuilder,
 ): EffectBuilder<
   InferBuilderInitialContext<TBuilder>,
@@ -579,21 +982,52 @@ export function makeEffectORPC<
   TRuntimeError
 >;
 
-export function makeEffectORPC<TRequirementsProvided, TRuntimeError>(
+/**
+ * Creates an Effect-aware procedure builder by wrapping an existing oRPC Builder
+ * with the specified ManagedRuntime.
+ *
+ * @param runtime - The ManagedRuntime that provides services for Effect procedures
+ * @param builder - The oRPC Builder instance to wrap (e.g., a customized `os`)
+ */
+export function makeEffectORPC<
+  TBuilder extends AnyBuilderLike<
+    TInputSchema,
+    TOutputSchema,
+    TErrorMap,
+    TMeta
+  >,
+  TInputSchema extends AnySchema,
+  TOutputSchema extends AnySchema,
+  TErrorMap extends ErrorMap,
+  TMeta extends Meta,
+  TRequirementsProvided,
+  TRuntimeError,
+>(
   runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>,
-  builder?: AnyBuilderLike,
+  builder: TBuilder,
 ): EffectBuilder<
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
+  InferBuilderInitialContext<TBuilder>,
+  InferBuilderCurrentContext<TBuilder>,
+  InferBuilderInputSchema<TBuilder>,
+  InferBuilderOutputSchema<TBuilder>,
+  InferBuilderErrorMap<TBuilder>,
+  InferBuilderMeta<TBuilder>,
   TRequirementsProvided,
   TRuntimeError
-> {
-  const resolvedBuilder = builder ?? emptyBuilder();
+>;
+
+export function makeEffectORPC(
+  source?: EffectRuntimeSource<any, any> | AnyBuilderLike,
+  builder?: AnyBuilderLike,
+): any {
+  const sourceIsBuilder = source !== undefined && isBuilderLike(source);
+  const resolvedBuilder = sourceIsBuilder
+    ? source
+    : (builder ?? emptyBuilder());
   const effectErrorMap = getEffectErrorMap(resolvedBuilder);
+  const runtime = toManagedRuntime(
+    sourceIsBuilder || source === undefined ? Layer.empty : source,
+  );
   return new EffectBuilder(
     {
       ...resolvedBuilder["~orpc"],