effect-orpc 0.2.2 → 0.4.0

package/dist/node.js

@@ -1,19 +1,20 @@
 import {
   installFiberContextBridge
-} from "./chunk-VOWRLWZZ.js";
+} from "./chunk-IJP6L2XR.js";
 
 // src/node.ts
 import { AsyncLocalStorage } from "async_hooks";
 import { Effect } from "effect";
 var fiberRefsStorage = new AsyncLocalStorage();
 var bridge = {
-  getCurrentFiberRefs: () => fiberRefsStorage.getStore()
+  getCurrentFiberRefs: () => fiberRefsStorage.getStore(),
+  runWithFiberRefs: (fiberRefs, fn) => fiberRefsStorage.run(fiberRefs, fn)
 };
 installFiberContextBridge(bridge);
 function withFiberContext(fn) {
   return Effect.flatMap(
     Effect.getFiberRefs,
-    (fiberRefs) => Effect.promise(() => fiberRefsStorage.run(fiberRefs, fn))
+    (fiberRefs) => Effect.promise(() => bridge.runWithFiberRefs(fiberRefs, fn))
   );
 }
 export {

package/dist/node.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/node.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"node:async_hooks\";\n\nimport type { FiberRefs } from \"effect\";\nimport { Effect } from \"effect\";\n\nimport {\n  installFiberContextBridge,\n  type FiberContextBridge,\n} from \"./fiber-context-bridge\";\n\nconst fiberRefsStorage = new AsyncLocalStorage<FiberRefs.FiberRefs>();\n\nconst bridge: FiberContextBridge = {\n  getCurrentFiberRefs: () => fiberRefsStorage.getStore(),\n};\n\ninstallFiberContextBridge(bridge);\n\nexport function withFiberContext<T>(fn: () => Promise<T>): Effect.Effect<T> {\n  return Effect.flatMap(Effect.getFiberRefs, (fiberRefs) =>\n    Effect.promise(() => fiberRefsStorage.run(fiberRefs, fn)),\n  );\n}\n"],"mappings":";;;;;AAAA,SAAS,yBAAyB;AAGlC,SAAS,cAAc;AAOvB,IAAM,mBAAmB,IAAI,kBAAuC;AAEpE,IAAM,SAA6B;AAAA,EACjC,qBAAqB,MAAM,iBAAiB,SAAS;AACvD;AAEA,0BAA0B,MAAM;AAEzB,SAAS,iBAAoB,IAAwC;AAC1E,SAAO,OAAO;AAAA,IAAQ,OAAO;AAAA,IAAc,CAAC,cAC1C,OAAO,QAAQ,MAAM,iBAAiB,IAAI,WAAW,EAAE,CAAC;AAAA,EAC1D;AACF;","names":[]}
+{"version":3,"sources":["../src/node.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"node:async_hooks\";\n\nimport type { FiberRefs } from \"effect\";\nimport { Effect } from \"effect\";\n\nimport {\n  installFiberContextBridge,\n  type FiberContextBridge,\n} from \"./fiber-context-bridge\";\n\nconst fiberRefsStorage = new AsyncLocalStorage<FiberRefs.FiberRefs>();\n\nconst bridge: FiberContextBridge = {\n  getCurrentFiberRefs: () => fiberRefsStorage.getStore(),\n  runWithFiberRefs: (fiberRefs, fn) => fiberRefsStorage.run(fiberRefs, fn),\n};\n\ninstallFiberContextBridge(bridge);\n\nexport function withFiberContext<T>(fn: () => Promise<T>): Effect.Effect<T> {\n  return Effect.flatMap(Effect.getFiberRefs, (fiberRefs) =>\n    Effect.promise(() => bridge.runWithFiberRefs!(fiberRefs, fn)),\n  );\n}\n"],"mappings":";;;;;AAAA,SAAS,yBAAyB;AAGlC,SAAS,cAAc;AAOvB,IAAM,mBAAmB,IAAI,kBAAuC;AAEpE,IAAM,SAA6B;AAAA,EACjC,qBAAqB,MAAM,iBAAiB,SAAS;AAAA,EACrD,kBAAkB,CAAC,WAAW,OAAO,iBAAiB,IAAI,WAAW,EAAE;AACzE;AAEA,0BAA0B,MAAM;AAEzB,SAAS,iBAAoB,IAAwC;AAC1E,SAAO,OAAO;AAAA,IAAQ,OAAO;AAAA,IAAc,CAAC,cAC1C,OAAO,QAAQ,MAAM,OAAO,iBAAkB,WAAW,EAAE,CAAC;AAAA,EAC9D;AACF;","names":[]}

package/package.json

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

package/src/contract.ts

@@ -27,13 +27,18 @@ import type {
 } from "@orpc/server";
 import { implement } from "@orpc/server";
 import type { IntersectPick } from "@orpc/shared";
-import type { ManagedRuntime } from "effect";
+import type { Layer, ManagedRuntime } from "effect";
 
 import { addSpanStackTrace } from "./effect-builder";
 import { enhanceEffectRouter } from "./effect-enhance-router";
 import { EffectDecoratedProcedure } from "./effect-procedure";
 import { createEffectProcedureHandler } from "./effect-runtime";
 import { effectContractSymbol, getEffectContractErrorMap } from "./eoc";
+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";
@@ -314,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;
 }
 
@@ -331,7 +336,7 @@ function wrapContractNode<
 >(
   contract: TContract,
   target: any,
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>,
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>,
 ): EffectImplementerInternal<
   TContract,
   Context,
@@ -360,9 +365,9 @@ function wrapContractNode<
               ...currentTarget["~orpc"],
               errorMap: effectErrorMapToErrorMap(effectErrorMap),
               effectErrorMap,
-              runtime,
+              runner,
               handler: createEffectProcedureHandler({
-                runtime,
+                runner,
                 effectErrorMap,
                 effectFn,
                 defaultCaptureStackTrace: addSpanStackTrace(),
@@ -383,7 +388,7 @@ function wrapContractNode<
                 currentTarget,
                 args,
               ),
-              runtime,
+              runner,
             );
 
           cache.set(prop, use);
@@ -403,7 +408,7 @@ function wrapContractNode<
                 currentTarget,
                 args,
               ),
-              runtime,
+              runner,
             );
 
           cache.set(prop, wrappedMethod);
@@ -418,7 +423,7 @@ function wrapContractNode<
                 currentTarget,
                 args,
               ) as any,
-              makeEnhanceOptions(runtime),
+              makeEnhanceOptions(runner),
             );
 
           cache.set(prop, wrappedMethod);
@@ -429,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);
@@ -463,6 +468,21 @@ function wrapContractNode<
   >;
 }
 
+export function implementEffect<
+  TContract extends AnyContractRouter,
+  TRequirementsProvided,
+  TRuntimeError,
+>(
+  contract: TContract,
+  layer: Layer.Layer<TRequirementsProvided, TRuntimeError, never>,
+): EffectImplementer<
+  TContract,
+  Record<never, never>,
+  Record<never, never>,
+  TRequirementsProvided,
+  TRuntimeError
+>;
+
 export function implementEffect<
   TContract extends AnyContractRouter,
   TRequirementsProvided,
@@ -476,11 +496,26 @@ export function implementEffect<
   Record<never, never>,
   TRequirementsProvided,
   TRuntimeError
+>;
+
+export function implementEffect<
+  TContract extends AnyContractRouter,
+  TRequirementsProvided,
+  TRuntimeError,
+>(
+  contract: TContract,
+  source: EffectRuntimeSource<TRequirementsProvided, TRuntimeError>,
+): EffectImplementer<
+  TContract,
+  Record<never, never>,
+  Record<never, never>,
+  TRequirementsProvided,
+  TRuntimeError
 > {
   return wrapContractNode(
     contract,
     implement(contract),
-    runtime,
+    makeEffectRuntimeRunner(source),
   ) as EffectImplementer<
     TContract,
     Record<never, never>,

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 { makeEffectRuntimeRunner } 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",
@@ -94,8 +106,10 @@ 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,
   };
 }
 
@@ -107,13 +121,57 @@ function wrapBuilderLike(
     {
       ...builder["~orpc"],
       effectErrorMap: state.effectErrorMap,
-      runtime: state.runtime,
+      runner: state.runner,
       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,
+    runner: state.runner,
+    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,20 +224,103 @@ 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,
-                    runtime: state.runtime,
+                    effectSteps: state.effectSteps,
+                    runner: state.runner,
                     spanConfig: state.spanConfig,
                   })(opts as any);
                 },
               });
             };
           });
+        case "middleware":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (middleware: any) => {
+              if (isEffectMiddleware(middleware)) {
+                const effectMiddleware = createEffectPipelineMiddleware({
+                  effectErrorMap: state.effectErrorMap,
+                  runner: state.runner,
+                  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) =>
@@ -457,6 +598,32 @@ 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.
@@ -531,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 }) {
@@ -567,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}
@@ -659,11 +826,13 @@ export class EffectBuilder<
     >,
     builder?: AnyBuilderLike,
   ) {
-    const { runtime, spanConfig, effectErrorMap, ...orpcDef } = def;
+    const { runner, spanConfig, effectErrorMap, effectSteps, ...orpcDef } = def;
 
     attachEffectState(this, builder ?? new Builder(orpcDef), {
+      effectSteps,
+      effectHandler: def.effectHandler,
       effectErrorMap,
-      runtime,
+      runner,
       spanConfig,
     });
 
@@ -672,23 +841,76 @@ export class EffectBuilder<
 }
 
 /**
- * Creates an Effect-aware procedure builder with the specified ManagedRuntime.
+ * Creates an Effect-aware procedure builder with the specified Layer.
  * Uses the default builder shape from `@orpc/server`.
  *
- * @param runtime - The ManagedRuntime that provides services for Effect procedures
+ * @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, ManagedRuntime } from 'effect'
+ * import { Effect, Layer } from 'effect'
  *
- * const runtime = ManagedRuntime.make(Layer.empty)
- * const effectOs = makeEffectORPC(runtime)
+ * const effectProcedure = makeEffectORPC(Layer.empty)
  *
- * const hello = effectOs.effect(() => Effect.succeed('Hello!'))
+ * const hello = effectProcedure.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
+ */
 export function makeEffectORPC<TRequirementsProvided, TRuntimeError>(
   runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>,
 ): EffectBuilder<
@@ -704,9 +926,9 @@ 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 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
  *
@@ -714,16 +936,15 @@ export function makeEffectORPC<TRequirementsProvided, TRuntimeError>(
  * ```ts
  * import { makeEffectORPC } from '@orpc/effect'
  * import { os } from '@orpc/server'
- * import { Effect, Layer, ManagedRuntime } from 'effect'
+ * import { Effect, Layer } from 'effect'
  *
  * // Create a customized builder
  * const authedOs = os.use(authMiddleware)
  *
  * // Wrap it with Effect support
- * const runtime = ManagedRuntime.make(UserServiceLive)
- * const effectOs = makeEffectORPC(runtime, authedOs)
+ * const effectProcedure = makeEffectORPC(UserServiceLive, authedOs)
  *
- * const getUser = effectOs
+ * const getUser = effectProcedure
  *   .input(z.object({ id: z.string() }))
  *   .effect(
  *     Effect.fn(function* ({ input }) {
@@ -747,7 +968,7 @@ export function makeEffectORPC<
   TRequirementsProvided,
   TRuntimeError,
 >(
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>,
+  layer: Layer.Layer<TRequirementsProvided, TRuntimeError, never>,
   builder: TBuilder,
 ): EffectBuilder<
   InferBuilderInitialContext<TBuilder>,
@@ -760,27 +981,59 @@ 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 runner =
+    sourceIsBuilder || source === undefined
+      ? makeEffectRuntimeRunner()
+      : makeEffectRuntimeRunner(source);
   return new EffectBuilder(
     {
       ...resolvedBuilder["~orpc"],
       effectErrorMap: effectErrorMap,
       errorMap: effectErrorMapToErrorMap(effectErrorMap),
-      runtime,
+      runner,
     },
     unwrapEffectUpstream(resolvedBuilder),
   );
@@ -798,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();