effect-cf 0.0.2 → 0.0.4

package/README.md

@@ -8,6 +8,12 @@ Cloudflare services should be described as `Context`, `Layer`, and `Effect` valu
 
 The low-level Worker entrypoint factory is exported as `Worker.make`. It returns a `WorkerEntrypoint` class with a `fetch` handler and optional typed RPC methods. Durable Object support starts with `DurableObject.make`, which routes Durable Object lifecycle methods and RPC handlers through one managed runtime for each Durable Object instance.
 
+Worker fetch handlers can return either web `Response` values or Effect `HttpServerResponse` values. `Worker.make` renders `HttpServerResponse` back to a web `Response` at the Cloudflare boundary, so application handlers can stay in Effect HTTP primitives.
+
+Request-scoped app services belong in the implementation layer that owns request semantics, such as `HttpRouter` middleware, RPC middleware, or explicit `Effect.provide(...)` inside a custom fetch effect. `Worker.make` stays focused on Cloudflare boundary services: `NativeRequest`, `HttpServerRequest`, `WorkerEnvironment`, `ExecutionContext`, and `WorkerContext`.
+
+For modules that need an `ExportedHandler` object instead of a `WorkerEntrypoint` class, use `Worker.makeFetchHandler`. This helper is fetch-only and intentionally does not accept Worker RPC methods.
+
 RPC contracts can be described as classes with `Worker.Tag` and `DurableObject.Tag`. Contract classes expose `.make(...)` for runtime entrypoint creation and `.Binding(...)` / `.Namespace(...)` for typed bindings. Bindings infer call types from the same code-owned contract classes. Definition-backed calls encode/decode arguments and success values with their Effect schemas at Worker and Durable Object boundaries.
 
 Binding helpers expose two RPC paths:
@@ -31,6 +37,7 @@ Client APIs use Cloudflare-style provider types, so object results expose pipeli
 - `Rpc` - Cloudflare RPC type helpers, `RpcTarget` / `RpcStub` re-exports, and scoped disposal utilities
 - `ServiceBinding` - typed Worker-to-Worker service binding helper
 - `WorkerEnvironment` - request environment service
+- `WorkerConfig` - Effect `Config` helpers backed by Cloudflare worker `env`, including `layerWith` for custom env-to-config mapping
 
 ## RPC Values
 

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { Cause, Config, ConfigProvider, Context, Effect, Layer, Option, Schema, Scope } from "effect";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
-import { HttpServerRequest } from "effect/unstable/http";
+import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
 import * as _$effect_Types0 from "effect/Types";
@@ -63,6 +63,13 @@ declare namespace WorkerConfig {
   const integer: <const Name extends Key>(name: Name) => Config.Config<number>;
   /** Read a scalar Cloudflare var or secret as a boolean. */
   const boolean: <const Name extends Key>(name: Name) => Config.Config<boolean>;
+  /** Build a `ConfigProvider` from a Cloudflare worker `env` object. */
+  const providerFromEnv: (env: WorkerEnv) => ConfigProvider.ConfigProvider;
+  /**
+   * Build a `ConfigProvider` from the current `WorkerEnvironment` with a custom
+   * conversion function.
+   */
+  const providerWith: (makeProvider: (env: WorkerEnv) => ConfigProvider.ConfigProvider) => Effect.Effect<ConfigProvider.ConfigProvider, never, WorkerEnvironment>;
   /** Build a `ConfigProvider` from the current `WorkerEnvironment`. */
   const provider: Effect.Effect<ConfigProvider.ConfigProvider, never, WorkerEnvironment>;
   /**
@@ -72,6 +79,8 @@ declare namespace WorkerConfig {
   const providerLayer: _$effect_Layer0.Layer<never, never, WorkerEnvironment>;
   /** Alias for `providerLayer` for concise use in worker layers. */
   const layer: _$effect_Layer0.Layer<never, never, WorkerEnvironment>;
+  /** Build a `ConfigProvider` layer with a custom `env` conversion function. */
+  const layerWith: (makeProvider: (env: WorkerEnv) => ConfigProvider.ConfigProvider) => _$effect_Layer0.Layer<never, never, WorkerEnvironment>;
 }
 declare namespace Binding_d_exports {
   export { BindingNotFoundError, BindingValidationError, Service$3 as Service, TypeId$2 as TypeId };
@@ -985,7 +994,7 @@ declare const Service$1: <Self, Api extends object = never>() => <Id extends str
   readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Awaited<Result<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>>, unknown, Self | _$effect_Scope0.Scope>;
 };
 declare namespace Worker_d_exports {
-  export { Api$1 as Api, Definition$1 as Definition, ExecutionContext, HandlerEffect$1 as HandlerEffect, Handlers$1 as Handlers, NativeRequest, Options$1 as Options, ReservedMethodName, RpcHandlers$1 as RpcHandlers, ServerApi$2 as ServerApi, Tag$1 as Tag, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$1 as implement, isWebSocketUpgrade, make$2 as make, method$1 as method };
+  export { Api$1 as Api, Definition$1 as Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect$1 as HandlerEffect, Handlers$1 as Handlers, NativeRequest, Options$1 as Options, ReservedMethodName, RpcHandlers$1 as RpcHandlers, ServerApi$2 as ServerApi, Tag$1 as Tag, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$1 as implement, isWebSocketUpgrade, make$2 as make, makeFetchHandler, method$1 as method, renderHttpResponse };
 }
 declare const ExecutionContext_base: Context.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
 declare class ExecutionContext extends ExecutionContext_base {}
@@ -1006,19 +1015,28 @@ type ReservedMethodName = ReservedMethodName$5 | "fetch" | "connect" | "alarm" |
 type WorkerBaseContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
 type WorkerFetchContext<ROut> = WorkerBaseContext<ROut> | NativeRequest | HttpServerRequest.HttpServerRequest | Scope.Scope;
 type WorkerRpcContext<ROut> = WorkerBaseContext<ROut> | Scope.Scope;
-type WorkerHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerFetchContext<ROut>>;
+type WorkerFetchSuccess = Response | HttpServerResponse.HttpServerResponse;
+type WorkerHandler<ROut, A = WorkerFetchSuccess> = Effect.Effect<A, unknown, WorkerFetchContext<ROut>>;
 type WorkerRpcHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerRpcContext<ROut>>;
 type WorkerRpc<ROut> = Record<string, (...args: Array<any>) => WorkerRpcHandler<ROut>>;
 type WorkerRpcShape<Rpc extends WorkerRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, WorkerRpcContext<ROut>>) ? (...args: Args) => Promise<A> : never };
 type RpcHandlers$1<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof WorkerEntrypoint ? never : Key extends string ? Key extends ReservedMethodName ? never : [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<unknown>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => WorkerRpcHandler<ROut, A> : never };
 interface WorkerOptions<ROut, Rpc extends WorkerRpc<ROut>> {
-  readonly fetch?: Effect.Effect<Response, unknown, WorkerFetchContext<ROut>>;
+  readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<ROut>>;
   readonly rpc?: Rpc;
 }
+type FetchWorkerOptions<ROut> = Omit<WorkerOptions<ROut, Record<never, never>>, "rpc"> & {
+  readonly rpc?: never;
+};
 type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (ctx: globalThis.ExecutionContext, env: WorkerEnv) => WorkerEntrypoint<WorkerEnv> & {
   fetch(request: Request): Promise<Response>;
 } & WorkerRpcShape<Rpc, ROut>;
+interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
+  readonly fetch: (request: Request, env: Env, ctx: globalThis.ExecutionContext) => Promise<Response>;
+}
+declare const renderHttpResponse: <A extends HttpServerResponse.HttpServerResponse, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Response, E, R>;
 declare const make$2: <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, Rpc>) => WorkerClass<Rpc, ROut>;
+declare const makeFetchHandler: <ROut, LayerError, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut>) => FetchHandler<Env>;
 declare const Tag$1: <_Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape, ReservedMethodName$2>) => (abstract new () => object) & (Definition$2<Id, MethodsShape> & {
   make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$2<ROut, Definition$2<Id, MethodsShape>>) => WorkerClass<{ readonly [Key in keyof MethodsShape]: (...args: Array<unknown>) => WorkerRpcHandler<ROut, _$effect_Schema0.Codec.Encoded<MethodsShape[Key]["success"]>> }, ROut>;
   Binding: <Self>() => <BindingId extends string>(bindingId: BindingId, binding: Omit<ServiceBindingDefinition<Definition$2<Id, MethodsShape>>, "definition">) => Context.ServiceClass<Self, BindingId, ServiceBindingClient<[Api$2<Definition$2<Id, MethodsShape>>] extends [never] ? Definition$2<Id, MethodsShape> extends infer T ? T extends Definition$2<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$3<T> : never : never : never : Api$2<Definition$2<Id, MethodsShape>>>> & {

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
 import { Cause, Config, ConfigProvider, Context, Data, Effect, Exit, Layer, ManagedRuntime, Option, Queue, Schema } from "effect";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
-import { HttpServerRequest } from "effect/unstable/http";
+import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
@@ -17,8 +17,11 @@ let WorkerConfig;
 	_WorkerConfig.number = (name) => Config.number(name);
 	_WorkerConfig.integer = (name) => Config.int(name);
 	_WorkerConfig.boolean = (name) => Config.boolean(name);
-	const provider = _WorkerConfig.provider = Effect.map(WorkerEnvironment.asEffect(), ConfigProvider.fromUnknown);
+	const providerFromEnv = _WorkerConfig.providerFromEnv = (env) => ConfigProvider.fromUnknown(env);
+	const providerWith = _WorkerConfig.providerWith = (makeProvider) => Effect.map(WorkerEnvironment.asEffect(), makeProvider);
+	const provider = _WorkerConfig.provider = providerWith(providerFromEnv);
 	_WorkerConfig.layer = _WorkerConfig.providerLayer = ConfigProvider.layer(provider);
+	_WorkerConfig.layerWith = (makeProvider) => ConfigProvider.layer(providerWith(makeProvider));
 })(WorkerConfig || (WorkerConfig = {}));
 //#endregion
 //#region src/Binding.ts
@@ -430,7 +433,9 @@ var Worker_exports = /* @__PURE__ */ __exportAll({
 	implement: () => implement$2,
 	isWebSocketUpgrade: () => isWebSocketUpgrade,
 	make: () => make$3,
-	method: () => method$2
+	makeFetchHandler: () => makeFetchHandler,
+	method: () => method$2,
+	renderHttpResponse: () => renderHttpResponse
 });
 var ExecutionContext = class extends Context.Service()("effect-cf/ExecutionContext") {};
 var WorkerContext = class extends Context.Service()("effect-cf/WorkerContext") {};
@@ -460,13 +465,15 @@ const reservedMethodNames$2 = new Set([
 	"webSocketError"
 ]);
 const RunSymbol$1 = Symbol.for("effect-cf/Worker/run");
+const renderHttpResponse = (effect) => Effect.flatMap(effect, (response) => Effect.map(Effect.context(), (context) => HttpServerResponse.toWeb(response, { context })));
+const renderFetchSuccess = (effect) => Effect.flatMap(effect, (response) => response instanceof Response ? Effect.succeed(response) : Effect.map(Effect.context(), (context) => HttpServerResponse.toWeb(response, { context })));
 const make$3 = (layer, options) => {
 	class EffectWorker extends WorkerEntrypoint {
 		runtime;
 		constructor(ctx, env) {
 			super(ctx, env);
 			let runWaitUntilEffect = () => Promise.resolve(Exit.die(/* @__PURE__ */ new Error("WorkerContext runtime is not initialized")));
-			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env)));
+			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env)));
 			this.runtime = ManagedRuntime.make(runtimeLayer);
 			runWaitUntilEffect = (effect) => this.runtime.runPromiseExit(effect);
 		}
@@ -476,12 +483,17 @@ const make$3 = (layer, options) => {
 		fetch(request) {
 			const fetchHandler = options.fetch;
 			if (fetchHandler === void 0) return Promise.resolve(new Response("Not Found", { status: 404 }));
-			return this[RunSymbol$1](fetchHandler.pipe(Effect.provideService(NativeRequest, request), Effect.provideService(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request))));
+			const requestServices = Layer.mergeAll(Layer.succeed(NativeRequest, request), Layer.succeed(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request)));
+			return this[RunSymbol$1](renderFetchSuccess(fetchHandler).pipe(Effect.provide(requestServices)));
 		}
 	}
 	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect) => self[RunSymbol$1](effect));
 	return assumeEntrypointClass(EffectWorker);
 };
+const makeFetchHandler = (layer, options) => {
+	const WorkerClass = make$3(layer, options);
+	return { fetch: (request, env, ctx) => Promise.resolve(new WorkerClass(ctx, env).fetch(request)) };
+};
 const Tag$2 = Tag$3;
 const method$2 = method$3;
 const implement$2 = implement$3;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

package/src/Environment.ts

@@ -72,8 +72,18 @@ export namespace WorkerConfig {
   /** Read a scalar Cloudflare var or secret as a boolean. */
   export const boolean = <const Name extends Key>(name: Name) => Config.boolean(name);
 
+  /** Build a `ConfigProvider` from a Cloudflare worker `env` object. */
+  export const providerFromEnv = (env: WorkerEnv) => ConfigProvider.fromUnknown(env);
+
+  /**
+   * Build a `ConfigProvider` from the current `WorkerEnvironment` with a custom
+   * conversion function.
+   */
+  export const providerWith = (makeProvider: (env: WorkerEnv) => ConfigProvider.ConfigProvider) =>
+    Effect.map(WorkerEnvironment.asEffect(), makeProvider);
+
   /** Build a `ConfigProvider` from the current `WorkerEnvironment`. */
-  export const provider = Effect.map(WorkerEnvironment.asEffect(), ConfigProvider.fromUnknown);
+  export const provider = providerWith(providerFromEnv);
 
   /**
    * Replace the active Effect `ConfigProvider` with one backed by the current
@@ -83,4 +93,8 @@ export namespace WorkerConfig {
 
   /** Alias for `providerLayer` for concise use in worker layers. */
   export const layer = providerLayer;
+
+  /** Build a `ConfigProvider` layer with a custom `env` conversion function. */
+  export const layerWith = (makeProvider: (env: WorkerEnv) => ConfigProvider.ConfigProvider) =>
+    ConfigProvider.layer(providerWith(makeProvider));
 }

package/src/Worker.ts

@@ -1,8 +1,17 @@
 import { WorkerEntrypoint as CloudflareWorkerEntrypoint } from "cloudflare:workers";
-import { Cause, Context, Effect, Exit, Layer, ManagedRuntime, type Scope } from "effect";
-import { HttpServerRequest } from "effect/unstable/http";
-
-import { WorkerEnvironment, type WorkerEnv } from "./Environment";
+import {
+  Cause,
+  ConfigProvider,
+  Context,
+  Effect,
+  Exit,
+  Layer,
+  ManagedRuntime,
+  type Scope,
+} from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+
+import { WorkerConfig, WorkerEnvironment, type WorkerEnv } from "./Environment";
 import type * as RpcDefinition from "./RpcDefinition";
 import * as WorkerDefinition from "./WorkerDefinition";
 import * as Entrypoint from "./internal/Entrypoint";
@@ -122,7 +131,13 @@ type RuntimeContext<ROut> = WorkerBaseContext<ROut>;
 
 const RunSymbol = Symbol.for("effect-cf/Worker/run");
 
-export type WorkerHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerFetchContext<ROut>>;
+export type WorkerFetchSuccess = Response | HttpServerResponse.HttpServerResponse;
+
+export type WorkerHandler<ROut, A = WorkerFetchSuccess> = Effect.Effect<
+  A,
+  unknown,
+  WorkerFetchContext<ROut>
+>;
 
 export type WorkerRpcHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerRpcContext<ROut>>;
 
@@ -153,10 +168,14 @@ export type RpcHandlers<ROut, Api> = {
 };
 
 export interface WorkerOptions<ROut, Rpc extends WorkerRpc<ROut>> {
-  readonly fetch?: Effect.Effect<Response, unknown, WorkerFetchContext<ROut>>;
+  readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<ROut>>;
   readonly rpc?: Rpc;
 }
 
+export type FetchWorkerOptions<ROut> = Omit<WorkerOptions<ROut, Record<never, never>>, "rpc"> & {
+  readonly rpc?: never;
+};
+
 export type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (
   ctx: globalThis.ExecutionContext,
   env: WorkerEnv,
@@ -164,6 +183,34 @@ export type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (
   fetch(request: Request): Promise<Response>;
 } & WorkerRpcShape<Rpc, ROut>;
 
+export interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
+  readonly fetch: (
+    request: Request,
+    env: Env,
+    ctx: globalThis.ExecutionContext,
+  ) => Promise<Response>;
+}
+
+export const renderHttpResponse = <A extends HttpServerResponse.HttpServerResponse, E, R>(
+  effect: Effect.Effect<A, E, R>,
+): Effect.Effect<Response, E, R> =>
+  Effect.flatMap(effect, (response) =>
+    Effect.map(Effect.context<never>(), (context) =>
+      HttpServerResponse.toWeb(response, { context }),
+    ),
+  );
+
+const renderFetchSuccess = <E, R>(
+  effect: Effect.Effect<WorkerFetchSuccess, E, R>,
+): Effect.Effect<Response, E, R> =>
+  Effect.flatMap(effect, (response) =>
+    response instanceof Response
+      ? Effect.succeed(response)
+      : Effect.map(Effect.context<never>(), (context) =>
+          HttpServerResponse.toWeb(response, { context }),
+        ),
+  );
+
 export const make = <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(
   layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
   options: WorkerOptions<ROut, Rpc>,
@@ -179,14 +226,19 @@ export const make = <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Recor
 
       const services = Layer.mergeAll(
         Layer.succeed(ExecutionContext, ctx),
+        ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))),
         Layer.succeed(
           WorkerContext,
           fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect)),
         ),
         Layer.succeed(WorkerEnvironment, env),
-      );
+      ) as Layer.Layer<ExecutionContext | WorkerContext | WorkerEnvironment, never, never>;
 
-      const runtimeLayer = Entrypoint.provideEntrypointServices(layer, services);
+      const runtimeLayer = Entrypoint.provideEntrypointServices<
+        ROut,
+        LayerError,
+        ExecutionContext | WorkerContext | WorkerEnvironment
+      >(layer, services);
 
       this.runtime = ManagedRuntime.make(runtimeLayer);
       runWaitUntilEffect = <A, E>(effect: Effect.Effect<A, E, never>) =>
@@ -204,14 +256,17 @@ export const make = <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Recor
         return Promise.resolve(new Response("Not Found", { status: 404 }));
       }
 
+      const requestServices = Layer.mergeAll(
+        Layer.succeed(NativeRequest, request),
+        Layer.succeed(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request)),
+      );
+
       return this[RunSymbol](
-        fetchHandler.pipe(
-          Effect.provideService(NativeRequest, request),
-          Effect.provideService(
-            HttpServerRequest.HttpServerRequest,
-            HttpServerRequest.fromWeb(request),
-          ),
-        ),
+        renderFetchSuccess(fetchHandler).pipe(Effect.provide(requestServices)) as Effect.Effect<
+          Response,
+          unknown,
+          RuntimeContext<ROut> | Scope.Scope
+        >,
       );
     }
   }
@@ -227,6 +282,17 @@ export const make = <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Recor
   return Entrypoint.assumeEntrypointClass<WorkerClass<Rpc, ROut>>(EffectWorker);
 };
 
+export const makeFetchHandler = <ROut, LayerError, Env extends WorkerEnv = WorkerEnv>(
+  layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
+  options: FetchWorkerOptions<ROut>,
+): FetchHandler<Env> => {
+  const WorkerClass = make(layer, options);
+
+  return {
+    fetch: (request, env, ctx) => Promise.resolve(new WorkerClass(ctx, env).fetch(request)),
+  };
+};
+
 export const Tag = WorkerDefinition.Tag;
 
 export const method = WorkerDefinition.method;