effect-cf 0.0.2 → 0.0.3

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.
+
+Use `requestLayer` on `Worker.make` for per-request services such as auth/session context, tenant metadata, request IDs, or request-local clients. The request layer scope is the handler evaluation scope: it closes when the handler produces a `Response`, not when a streaming response body is later consumed by the platform.
+
+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 };
@@ -798,7 +807,7 @@ type BoundaryHandlers<ROut, Self extends Definition$2.Any> = { readonly [Key in
 /**
  * Worker constructor options for a specific RPC definition.
  */
-interface Options$2<ROut, Self extends Definition$2.Any> extends Omit<WorkerOptions<ROut, Handlers$2<ROut, Self>>, "rpc"> {
+interface Options$2<ROut, Self extends Definition$2.Any, RRequest = never, RequestLayerError = never> extends Omit<WorkerOptions<ROut, Handlers$2<ROut, Self>, RRequest, RequestLayerError>, "rpc"> {
   readonly rpc: Handlers$2<ROut, Self>;
 }
 /**
@@ -806,7 +815,7 @@ interface Options$2<ROut, Self extends Definition$2.Any> extends Omit<WorkerOpti
  */
 declare const method$2: typeof method$4;
 declare const make$3: <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape, ReservedMethodName$2>) => Definition$2<Id, MethodsShape> & {
-  make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$2<ROut, Definition$2<Id, MethodsShape>>) => WorkerClass<BoundaryHandlers<ROut, Definition$2<Id, MethodsShape>>, ROut>;
+  make: <ROut, LayerError, RRequest = never, RequestLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$2<ROut, Definition$2<Id, MethodsShape>, RRequest, RequestLayerError>) => WorkerClass<BoundaryHandlers<ROut, Definition$2<Id, MethodsShape>>, ROut>;
   Binding: <Self>() => <BindingId extends string>(bindingId: BindingId, binding: Omit<ServiceBindingDefinition<Definition$2<Id, MethodsShape>>, "definition">) => _$effect_Context0.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>>>> & {
     "effect-cf/Binding": "effect-cf/Binding";
     binding: string;
@@ -833,7 +842,7 @@ declare const make$3: <Id extends string, const MethodsShape extends Methods>(id
   };
 };
 declare const Tag$2: <_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<BoundaryHandlers<ROut, Definition$2<Id, MethodsShape>>, ROut>;
+  make: <ROut, LayerError, RRequest = never, RequestLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$2<ROut, Definition$2<Id, MethodsShape>, RRequest, RequestLayerError>) => WorkerClass<BoundaryHandlers<ROut, Definition$2<Id, MethodsShape>>, ROut>;
   Binding: <Self>() => <BindingId extends string>(bindingId: BindingId, binding: Omit<ServiceBindingDefinition<Definition$2<Id, MethodsShape>>, "definition">) => _$effect_Context0.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>>>> & {
     "effect-cf/Binding": "effect-cf/Binding";
     binding: string;
@@ -860,7 +869,7 @@ declare const Tag$2: <_Self>() => <Id extends string, const MethodsShape extends
   };
 });
 declare const Worker: <_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<BoundaryHandlers<ROut, Definition$2<Id, MethodsShape>>, ROut>;
+  make: <ROut, LayerError, RRequest = never, RequestLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$2<ROut, Definition$2<Id, MethodsShape>, RRequest, RequestLayerError>) => WorkerClass<BoundaryHandlers<ROut, Definition$2<Id, MethodsShape>>, ROut>;
   Binding: <Self>() => <BindingId extends string>(bindingId: BindingId, binding: Omit<ServiceBindingDefinition<Definition$2<Id, MethodsShape>>, "definition">) => _$effect_Context0.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>>>> & {
     "effect-cf/Binding": "effect-cf/Binding";
     binding: string;
@@ -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,21 +1015,37 @@ 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>>;
+interface WorkerOptions<ROut, Rpc extends WorkerRpc<ROut>, RRequest = never, RequestLayerError = never> {
+  readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<ROut | RRequest>>;
+  /**
+   * Per-request services provided while evaluating the fetch handler.
+   *
+   * This scope closes when the handler produces a `Response`; it is not kept
+   * open until a streaming response body is consumed by the platform.
+   */
+  readonly requestLayer?: Layer.Layer<RRequest, RequestLayerError, WorkerFetchContext<ROut>>;
   readonly rpc?: Rpc;
 }
+type FetchWorkerOptions<ROut, RRequest = never, RequestLayerError = never> = Omit<WorkerOptions<ROut, Record<never, never>, RRequest, RequestLayerError>, "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>;
-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>;
+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>, RRequest = never, RequestLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, Rpc, RRequest, RequestLayerError>) => WorkerClass<Rpc, ROut>;
+declare const makeFetchHandler: <ROut, LayerError, RRequest = never, RequestLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, RRequest, RequestLayerError>) => 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>;
+  make: <ROut, LayerError, RRequest = never, RequestLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$2<ROut, Definition$2<Id, MethodsShape>, RRequest, RequestLayerError>) => 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>>>> & {
     "effect-cf/Binding": "effect-cf/Binding";
     binding: string;
@@ -1055,7 +1080,7 @@ declare namespace Definition$1 {
 type ServerApi$2<Self extends Definition$2.Any> = ServerApi$3<Self>;
 type Api$1<Self extends Definition$2.Any> = Api$2<Self>;
 type Handlers$1<ROut, Self extends Definition$2.Any> = Handlers$2<ROut, Self>;
-type Options$1<ROut, Self extends Definition$2.Any> = Options$2<ROut, Self>;
+type Options$1<ROut, Self extends Definition$2.Any, RRequest = never, RequestLayerError = never> = Options$2<ROut, Self, RRequest, RequestLayerError>;
 type HandlerEffect$1<ROut, Self extends Definition$2.Any, Key extends keyof Self["methods"]> = HandlerEffect$2<ROut, Self, Key>;
 declare namespace DurableObject_d_exports {
   export { Api, Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcShape, HandlerEffect, Handlers, Options, RpcHandlers, ServerApi$1 as ServerApi, Tag, implement, make$1 as make, method };

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,19 @@ 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)));
+			const fetchEffect = renderFetchSuccess(fetchHandler);
+			const requestEffect = options.requestLayer === void 0 ? fetchEffect : fetchEffect.pipe(Effect.provide(options.requestLayer));
+			return this[RunSymbol$1](requestEffect.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.3",
   "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>>;
 
@@ -152,11 +167,30 @@ export type RpcHandlers<ROut, Api> = {
     : never;
 };
 
-export interface WorkerOptions<ROut, Rpc extends WorkerRpc<ROut>> {
-  readonly fetch?: Effect.Effect<Response, unknown, WorkerFetchContext<ROut>>;
+export interface WorkerOptions<
+  ROut,
+  Rpc extends WorkerRpc<ROut>,
+  RRequest = never,
+  RequestLayerError = never,
+> {
+  readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<ROut | RRequest>>;
+  /**
+   * Per-request services provided while evaluating the fetch handler.
+   *
+   * This scope closes when the handler produces a `Response`; it is not kept
+   * open until a streaming response body is consumed by the platform.
+   */
+  readonly requestLayer?: Layer.Layer<RRequest, RequestLayerError, WorkerFetchContext<ROut>>;
   readonly rpc?: Rpc;
 }
 
+export type FetchWorkerOptions<ROut, RRequest = never, RequestLayerError = never> = Omit<
+  WorkerOptions<ROut, Record<never, never>, RRequest, RequestLayerError>,
+  "rpc"
+> & {
+  readonly rpc?: never;
+};
+
 export type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (
   ctx: globalThis.ExecutionContext,
   env: WorkerEnv,
@@ -164,9 +198,43 @@ export type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (
   fetch(request: Request): Promise<Response>;
 } & WorkerRpcShape<Rpc, ROut>;
 
-export const make = <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(
+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>,
+  RRequest = never,
+  RequestLayerError = never,
+>(
   layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
-  options: WorkerOptions<ROut, Rpc>,
+  options: WorkerOptions<ROut, Rpc, RRequest, RequestLayerError>,
 ): WorkerClass<Rpc, ROut> => {
   class EffectWorker extends CloudflareWorkerEntrypoint<WorkerEnv> {
     readonly runtime: ManagedRuntime.ManagedRuntime<RuntimeContext<ROut>, LayerError>;
@@ -179,14 +247,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 +277,22 @@ 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)),
+      );
+      const fetchEffect = renderFetchSuccess(fetchHandler);
+      const requestEffect =
+        options.requestLayer === undefined
+          ? fetchEffect
+          : fetchEffect.pipe(Effect.provide(options.requestLayer));
+
       return this[RunSymbol](
-        fetchHandler.pipe(
-          Effect.provideService(NativeRequest, request),
-          Effect.provideService(
-            HttpServerRequest.HttpServerRequest,
-            HttpServerRequest.fromWeb(request),
-          ),
-        ),
+        requestEffect.pipe(Effect.provide(requestServices)) as Effect.Effect<
+          Response,
+          unknown,
+          RuntimeContext<ROut> | Scope.Scope
+        >,
       );
     }
   }
@@ -227,6 +308,23 @@ export const make = <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Recor
   return Entrypoint.assumeEntrypointClass<WorkerClass<Rpc, ROut>>(EffectWorker);
 };
 
+export const makeFetchHandler = <
+  ROut,
+  LayerError,
+  RRequest = never,
+  RequestLayerError = never,
+  Env extends WorkerEnv = WorkerEnv,
+>(
+  layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
+  options: FetchWorkerOptions<ROut, RRequest, RequestLayerError>,
+): 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;
@@ -252,10 +350,12 @@ export type Handlers<
   Self extends WorkerDefinition.Definition.Any,
 > = WorkerDefinition.Handlers<ROut, Self>;
 
-export type Options<ROut, Self extends WorkerDefinition.Definition.Any> = WorkerDefinition.Options<
+export type Options<
   ROut,
-  Self
->;
+  Self extends WorkerDefinition.Definition.Any,
+  RRequest = never,
+  RequestLayerError = never,
+> = WorkerDefinition.Options<ROut, Self, RRequest, RequestLayerError>;
 
 export type HandlerEffect<
   ROut,

package/src/WorkerDefinition.ts

@@ -74,8 +74,13 @@ type BoundaryHandlers<ROut, Self extends Definition.Any> = {
 /**
  * Worker constructor options for a specific RPC definition.
  */
-export interface Options<ROut, Self extends Definition.Any> extends Omit<
-  WorkerEntrypoint.WorkerOptions<ROut, Handlers<ROut, Self>>,
+export interface Options<
+  ROut,
+  Self extends Definition.Any,
+  RRequest = never,
+  RequestLayerError = never,
+> extends Omit<
+  WorkerEntrypoint.WorkerOptions<ROut, Handlers<ROut, Self>, RRequest, RequestLayerError>,
   "rpc"
 > {
   readonly rpc: Handlers<ROut, Self>;
@@ -108,13 +113,13 @@ const makeDefinition = <Id extends string, const MethodsShape extends RpcDefinit
   const definition: SelfDefinition = RpcDefinition.make(id, methods);
 
   return Object.assign(definition, {
-    make: <ROut, LayerError>(
+    make: <ROut, LayerError, RRequest = never, RequestLayerError = never>(
       layer: Layer.Layer<
         ROut,
         LayerError,
         WorkerEntrypoint.ExecutionContext | WorkerEntrypoint.WorkerContext | WorkerEnvironment
       >,
-      options: Options<ROut, SelfDefinition>,
+      options: Options<ROut, SelfDefinition, RRequest, RequestLayerError>,
     ) =>
       WorkerEntrypoint.make(layer, {
         ...options,