effect-cf 0.12.0 → 0.13.1

package/package.json

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

package/src/CloudflareOtlp.ts

@@ -10,10 +10,8 @@ import {
   OtlpTracer,
 } from "effect/unstable/observability";
 
-import * as DurableObject from "./DurableObject";
 import { DurableObjectState } from "./DurableObjectState";
 import { WorkerConfig, WorkerEnvironment } from "./Environment";
-import * as Worker from "./Worker";
 
 /** Telemetry signal groups supported by the Cloudflare OTLP layers. */
 export type Signal = "logs" | "traces" | "metrics";
@@ -516,113 +514,3 @@ export const durableObjectLayer = (options: LayerOptions & DurableObjectResource
       }),
     ),
   );
-
-const provideRpcLayer = <
-  Rpc extends Record<string, (...args: Array<any>) => Effect.Effect<any, any, any>>,
-  RLayer,
->(
-  rpc: Rpc | undefined,
-  layer: Layer.Layer<never, never, RLayer>,
-): Rpc | undefined => {
-  if (rpc === undefined) {
-    return undefined;
-  }
-
-  return new Proxy(rpc, {
-    get(target, property, receiver) {
-      const handler = Reflect.get(target, property, receiver);
-      if (typeof handler !== "function") {
-        return handler;
-      }
-
-      return (...args: Array<any>) =>
-        Effect.suspend(() => Reflect.apply(handler, receiver, args)).pipe(Effect.provide(layer));
-    },
-  });
-};
-
-/**
- * Instrument Worker lifecycle handlers with event-scoped OTLP telemetry.
- *
- * Each defined handler is provided with {@link workerLayer}. Because Worker
- * handlers run inside `Effect.scoped`, the exporter scope closes and flushes at
- * the end of each Cloudflare event.
- */
-export const instrumentWorkerOptions =
-  (options?: LayerOptions & WorkerResourceOptions) =>
-  <ROut, Rpc extends Worker.WorkerRpc<ROut>>(
-    handlers: Worker.WorkerOptions<ROut, Rpc>,
-  ): Worker.WorkerOptions<ROut | WorkerEnvironment | CloudflareOtlpSettings, Rpc> => {
-    const telemetryLayer = workerLayer(options);
-    const queue = handlers.queue;
-
-    return {
-      ...handlers,
-      fetch:
-        handlers.fetch === undefined
-          ? undefined
-          : handlers.fetch.pipe(Effect.provide(telemetryLayer)),
-      queue:
-        queue === undefined
-          ? undefined
-          : (batch) => queue(batch).pipe(Effect.provide(telemetryLayer)),
-      rpc: provideRpcLayer(handlers.rpc, telemetryLayer),
-    };
-  };
-
-/**
- * Instrument Durable Object lifecycle handlers with event-scoped OTLP telemetry.
- *
- * Each defined handler is provided with {@link durableObjectLayer}. Because
- * Durable Object handlers run inside `Effect.scoped`, the exporter scope closes
- * and flushes at the end of each Cloudflare event.
- */
-export const instrumentDurableObjectOptions =
-  (options?: LayerOptions & DurableObjectResourceOptions) =>
-  <ROut, Rpc extends DurableObject.DurableObjectRpc<ROut>>(
-    handlers: DurableObject.DurableObjectOptions<ROut, Rpc>,
-  ): DurableObject.DurableObjectOptions<
-    ROut | WorkerEnvironment | DurableObjectState | CloudflareOtlpSettings,
-    Rpc
-  > => {
-    const telemetryLayer = durableObjectLayer(options);
-    const alarm = handlers.alarm;
-    const webSocketMessage = handlers.webSocketMessage;
-    const webSocketClose = handlers.webSocketClose;
-    const webSocketError = handlers.webSocketError;
-
-    return {
-      ...handlers,
-      initialize:
-        handlers.initialize === undefined
-          ? undefined
-          : handlers.initialize.pipe(Effect.provide(telemetryLayer)),
-      fetch:
-        handlers.fetch === undefined
-          ? undefined
-          : handlers.fetch.pipe(Effect.provide(telemetryLayer)),
-      alarms:
-        handlers.alarms === undefined
-          ? undefined
-          : handlers.alarms.pipe(Effect.provide(telemetryLayer)),
-      alarm:
-        alarm === undefined
-          ? undefined
-          : (alarmInfo) => alarm(alarmInfo).pipe(Effect.provide(telemetryLayer)),
-      webSocketMessage:
-        webSocketMessage === undefined
-          ? undefined
-          : (socket, message) =>
-              webSocketMessage(socket, message).pipe(Effect.provide(telemetryLayer)),
-      webSocketClose:
-        webSocketClose === undefined
-          ? undefined
-          : (socket, code, reason, wasClean) =>
-              webSocketClose(socket, code, reason, wasClean).pipe(Effect.provide(telemetryLayer)),
-      webSocketError:
-        webSocketError === undefined
-          ? undefined
-          : (socket, error) => webSocketError(socket, error).pipe(Effect.provide(telemetryLayer)),
-      rpc: provideRpcLayer(handlers.rpc, telemetryLayer),
-    };
-  };

package/src/DurableObject.ts

@@ -10,6 +10,7 @@ import type * as Binding from "./Binding";
 import * as DurableObjectDefinition from "./DurableObjectDefinition";
 import type * as DurableObjectNamespace from "./DurableObjectNamespace";
 import type * as Rpc from "./Rpc";
+import * as CloudflareClock from "./internal/Clock";
 import * as Entrypoint from "./internal/Entrypoint";
 
 const reservedMethodNames = new Set<string>([
@@ -27,6 +28,9 @@ type RuntimeContext<ROut> = DurableObjectState | WorkerEnvironment | ROut;
 type HandlerContext<ROut> = RuntimeContext<ROut> | Scope.Scope;
 
 type FetchContext<ROut> = HandlerContext<ROut> | NativeRequest;
+type RunOptions = {
+  readonly eventLayer?: boolean;
+};
 
 const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
 
@@ -72,7 +76,24 @@ export type RpcHandlers<ROut, Api> = {
 /**
  * Options for creating a Durable Object class backed by Effect handlers.
  */
-export interface DurableObjectOptions<ROut, Rpc extends DurableObjectRpc<ROut>> {
+export interface DurableObjectOptions<
+  RRuntime,
+  REvent = never,
+  EventLayerError = never,
+  Rpc extends DurableObjectRpc<RRuntime | REvent> = Record<never, never>,
+> {
+  /**
+   * Layer provided around each Cloudflare event handled by this Durable Object.
+   *
+   * The layer is built inside the event's Effect scope and finalized when the
+   * event effect completes. It is not applied to `initialize`, which is an
+   * instance-load lifecycle hook rather than a platform event.
+   */
+  readonly eventLayer?: Layer.Layer<
+    REvent,
+    EventLayerError,
+    DurableObjectState | WorkerEnvironment | RRuntime
+  >;
   /**
    * Effect run when Cloudflare loads this Durable Object instance into memory.
    *
@@ -81,11 +102,11 @@ export interface DurableObjectOptions<ROut, Rpc extends DurableObjectRpc<ROut>>
    * the same Durable Object id again after eviction or restart; use Durable
    * Object storage if work must happen only once per id.
    */
-  readonly initialize?: Effect.Effect<void, unknown, HandlerContext<ROut>>;
+  readonly initialize?: Effect.Effect<void, unknown, HandlerContext<RRuntime>>;
   /** Optional RPC methods exposed as Durable Object instance methods. */
   readonly rpc?: Rpc;
   /** Optional fetch handler for HTTP/WebSocket requests. */
-  readonly fetch?: Effect.Effect<Response, unknown, FetchContext<ROut>>;
+  readonly fetch?: Effect.Effect<Response, unknown, FetchContext<RRuntime | REvent>>;
   /**
    * Optional logical alarm processing effect.
    *
@@ -93,24 +114,24 @@ export interface DurableObjectOptions<ROut, Rpc extends DurableObjectRpc<ROut>>
    * `DurableObjectAlarm.processDue(...)` so the reusable scheduler stays inside
    * the Durable Object's single managed runtime boundary.
    */
-  readonly alarms?: Effect.Effect<unknown, unknown, HandlerContext<ROut>>;
+  readonly alarms?: Effect.Effect<unknown, unknown, HandlerContext<RRuntime | REvent>>;
   readonly alarm?: (
     alarmInfo?: globalThis.AlarmInvocationInfo,
-  ) => Effect.Effect<void, unknown, HandlerContext<ROut>>;
+  ) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
   readonly webSocketMessage?: (
     socket: DurableWebSocket,
     message: string | ArrayBuffer,
-  ) => Effect.Effect<void, unknown, HandlerContext<ROut>>;
+  ) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
   readonly webSocketClose?: (
     socket: DurableWebSocket,
     code: number,
     reason: string,
     wasClean: boolean,
-  ) => Effect.Effect<void, unknown, HandlerContext<ROut>>;
+  ) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
   readonly webSocketError?: (
     socket: DurableWebSocket,
     error: unknown,
-  ) => Effect.Effect<void, unknown, HandlerContext<ROut>>;
+  ) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
 }
 
 /**
@@ -127,11 +148,13 @@ export type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (
 export const make = <
   ROut,
   LayerError,
-  const Rpc extends DurableObjectRpc<ROut> = Record<never, never>,
+  REvent = never,
+  EventLayerError = never,
+  const Rpc extends DurableObjectRpc<ROut | REvent> = Record<never, never>,
 >(
   layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>,
-  options: DurableObjectOptions<ROut, Rpc> = {},
-): DurableObjectClass<Rpc, ROut> => {
+  options: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc> = {},
+): DurableObjectClass<Rpc, ROut | REvent> => {
   class EffectDurableObject extends CloudflareDurableObject<WorkerEnv> {
     readonly runtime: ManagedRuntime.ManagedRuntime<RuntimeContext<ROut>, LayerError>;
 
@@ -139,6 +162,7 @@ export const make = <
       super(state, env);
 
       const services = Layer.mergeAll(
+        CloudflareClock.layer,
         Layer.succeed(DurableObjectState, fromDurableObjectState(state)),
         Layer.succeed(WorkerEnvironment, env),
       );
@@ -149,12 +173,24 @@ export const make = <
 
       const initialize = options.initialize;
       if (initialize !== undefined) {
-        state.waitUntil(this[RunSymbol](initialize));
+        state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
       }
     }
 
-    [RunSymbol]<A, E>(effect: Effect.Effect<A, E, HandlerContext<ROut>>): Promise<A> {
-      return this.runtime.runPromise(Effect.scoped(effect));
+    [RunSymbol]<A, E>(
+      effect: Effect.Effect<A, E, HandlerContext<ROut | REvent>>,
+      runOptions: RunOptions = {},
+    ): Promise<A> {
+      const effectWithEventLayer =
+        runOptions.eventLayer === false || options.eventLayer === undefined
+          ? effect
+          : effect.pipe(Effect.provide(options.eventLayer, { local: true }));
+
+      return this.runtime.runPromise(
+        Effect.scoped(
+          effectWithEventLayer as Effect.Effect<A, E | EventLayerError, HandlerContext<ROut>>,
+        ),
+      );
     }
 
     fetch(request: Request): Promise<Response> {
@@ -223,7 +259,9 @@ export const make = <
     (self, effect) => self[RunSymbol](effect),
   );
 
-  return Entrypoint.assumeEntrypointClass<DurableObjectClass<Rpc, ROut>>(EffectDurableObject);
+  return Entrypoint.assumeEntrypointClass<DurableObjectClass<Rpc, ROut | REvent>>(
+    EffectDurableObject,
+  );
 };
 
 export type ServiceFreeSchema = S.Codec<any, any, never, never>;
@@ -285,11 +323,16 @@ export type Handlers<ROut, Self extends Definition.Any> = {
   ) => DurableObjectHandler<ROut, Method.Success<Self["methods"][Key]>>;
 };
 
-export interface Options<ROut, Self extends Definition.Any> extends Omit<
-  DurableObjectOptions<ROut, Handlers<ROut, Self>>,
+export interface Options<
+  ROut,
+  Self extends Definition.Any,
+  REvent = never,
+  EventLayerError = never,
+> extends Omit<
+  DurableObjectOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>,
   "rpc"
 > {
-  readonly rpc: Handlers<ROut, Self>;
+  readonly rpc: Handlers<ROut | REvent, Self>;
 }
 
 export type TagClass<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<
@@ -307,10 +350,10 @@ export type TagClass<Self, Id extends string, MethodsShape extends Methods> = Co
   > & {
     readonly id: Id;
     readonly methods: MethodsShape;
-    readonly make: <ROut, LayerError>(
+    readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(
       layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>,
-      options: Options<ROut, Definition<Id, MethodsShape>>,
-    ) => DurableObjectClass<Handlers<ROut, Definition<Id, MethodsShape>>, ROut>;
+      options: Options<ROut, Definition<Id, MethodsShape>, REvent, EventLayerError>,
+    ) => DurableObjectClass<Handlers<ROut | REvent, Definition<Id, MethodsShape>>, ROut | REvent>;
     readonly layer: (
       options: LayerOptions,
     ) => Layer.Layer<

package/src/DurableObjectDefinition.ts

@@ -115,11 +115,21 @@ type BoundaryHandlers<ROut, Self extends Definition.Any> = {
 /**
  * Durable Object constructor options for a specific RPC definition.
  */
-export interface Options<ROut, Self extends Definition.Any> extends Omit<
-  DurableObjectEntrypoint.DurableObjectOptions<ROut, Handlers<ROut, Self>>,
+export interface Options<
+  ROut,
+  Self extends Definition.Any,
+  REvent = never,
+  EventLayerError = never,
+> extends Omit<
+  DurableObjectEntrypoint.DurableObjectOptions<
+    ROut,
+    REvent,
+    EventLayerError,
+    Handlers<ROut | REvent, Self>
+  >,
   "rpc"
 > {
-  readonly rpc: Handlers<ROut, Self>;
+  readonly rpc: Handlers<ROut | REvent, Self>;
 }
 
 export type LayerOptions = {
@@ -141,12 +151,12 @@ export type TagClass<Self, Id extends string, MethodsShape extends Methods> = Co
   > & {
     readonly id: Id;
     readonly methods: MethodsShape;
-    readonly make: <ROut, LayerError>(
+    readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(
       layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>,
-      options: Options<ROut, Definition<Id, MethodsShape>>,
+      options: Options<ROut, Definition<Id, MethodsShape>, REvent, EventLayerError>,
     ) => DurableObjectEntrypoint.DurableObjectClass<
-      Handlers<ROut, Definition<Id, MethodsShape>>,
-      ROut
+      Handlers<ROut | REvent, Definition<Id, MethodsShape>>,
+      ROut | REvent
     >;
     readonly layer: (
       options: LayerOptions,
@@ -195,9 +205,9 @@ const makeDefinition = <Id extends string, const MethodsShape extends Methods>(
   const definition: SelfDefinition = RpcDefinition.make(id, methods);
 
   return Object.assign(definition, {
-    make: <ROut, LayerError>(
+    make: <ROut, LayerError, REvent = never, EventLayerError = never>(
       layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>,
-      options: Options<ROut, SelfDefinition>,
+      options: Options<ROut, SelfDefinition, REvent, EventLayerError>,
     ) =>
       DurableObjectEntrypoint.make(layer, {
         ...options,

package/src/Worker.ts

@@ -10,6 +10,7 @@ import type * as Rpc from "./Rpc";
 import type * as RpcDefinition from "./RpcDefinition";
 import type * as ServiceBinding from "./ServiceBinding";
 import * as WorkerDefinition from "./WorkerDefinition";
+import * as CloudflareClock from "./internal/Clock";
 import * as Entrypoint from "./internal/Entrypoint";
 import { fromExecutionContext, type RunWaitUntilEffect } from "./internal/WorkerContext";
 
@@ -88,6 +89,9 @@ type WorkerFetchContext<ROut> =
 type WorkerRpcContext<ROut> = WorkerBaseContext<ROut> | Scope.Scope;
 
 type RuntimeContext<ROut> = WorkerBaseContext<ROut>;
+type RunOptions = {
+  readonly eventLayer?: boolean;
+};
 
 const RunSymbol = Symbol.for("effect-cf/Worker/run");
 
@@ -127,13 +131,33 @@ export type RpcHandlers<ROut, Api> = {
     : never;
 };
 
-export interface WorkerOptions<ROut, Rpc extends WorkerRpc<ROut>> {
-  readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<ROut>>;
-  readonly queue?: QueueHandler<ROut>;
+export interface WorkerOptions<
+  RRuntime,
+  REvent = never,
+  EventLayerError = never,
+  Rpc extends WorkerRpc<RRuntime | REvent> = Record<never, never>,
+> {
+  /**
+   * Layer provided around each Cloudflare event handled by this Worker.
+   *
+   * The layer is built inside the event's Effect scope and finalized when the
+   * event effect completes. Use this for event-scoped resources such as OTLP
+   * trace/log exporters that should flush at event completion.
+   */
+  readonly eventLayer?: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
+  readonly fetch?: Effect.Effect<
+    WorkerFetchSuccess,
+    unknown,
+    WorkerFetchContext<RRuntime | REvent>
+  >;
+  readonly queue?: QueueHandler<RRuntime | REvent>;
   readonly rpc?: Rpc;
 }
 
-export type FetchWorkerOptions<ROut> = Omit<WorkerOptions<ROut, Record<never, never>>, "rpc"> & {
+export type FetchWorkerOptions<RRuntime, REvent = never, EventLayerError = never> = Omit<
+  WorkerOptions<RRuntime, REvent, EventLayerError, Record<never, never>>,
+  "rpc"
+> & {
   readonly rpc?: never;
 };
 
@@ -173,28 +197,40 @@ const renderFetchSuccess = <E, R>(
         ),
   );
 
-const isWorkerOptions = <ROut, Rpc extends WorkerRpc<ROut>>(
-  options: WorkerOptions<ROut, Rpc> | WorkerHandler<ROut>,
-): options is WorkerOptions<ROut, Rpc> =>
+const isWorkerOptions = <ROut, REvent, EventLayerError, Rpc extends WorkerRpc<ROut | REvent>>(
+  options: WorkerOptions<ROut, REvent, EventLayerError, Rpc> | WorkerHandler<ROut>,
+): options is WorkerOptions<ROut, REvent, EventLayerError, Rpc> =>
   typeof options === "object" &&
   options !== null &&
-  ("fetch" in options || "queue" in options || "rpc" in options);
+  ("eventLayer" in options || "fetch" in options || "queue" in options || "rpc" in options);
 
 export function make<ROut, LayerError>(
   layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
   fetch: WorkerHandler<ROut>,
 ): WorkerClass<Record<never, never>, ROut>;
-export function make<ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(
+export function make<
+  ROut,
+  LayerError,
+  REvent = never,
+  EventLayerError = never,
+  const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>,
+>(
   layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
-  options: WorkerOptions<ROut, Rpc>,
-): WorkerClass<Rpc, ROut>;
-export function make<ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(
+  options: WorkerOptions<ROut, REvent, EventLayerError, Rpc>,
+): WorkerClass<Rpc, ROut | REvent>;
+export function make<
+  ROut,
+  LayerError,
+  REvent = never,
+  EventLayerError = never,
+  const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>,
+>(
   layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
-  optionsOrFetch: WorkerOptions<ROut, Rpc> | WorkerHandler<ROut>,
-): WorkerClass<Rpc, ROut> {
+  optionsOrFetch: WorkerOptions<ROut, REvent, EventLayerError, Rpc> | WorkerHandler<ROut>,
+): WorkerClass<Rpc, ROut | REvent> {
   const options = isWorkerOptions(optionsOrFetch)
     ? optionsOrFetch
-    : ({ fetch: optionsOrFetch } as WorkerOptions<ROut, Rpc>);
+    : ({ fetch: optionsOrFetch } as WorkerOptions<ROut, REvent, EventLayerError, Rpc>);
 
   class EffectWorker extends CloudflareWorkerEntrypoint<WorkerEnv> {
     readonly runtime: ManagedRuntime.ManagedRuntime<RuntimeContext<ROut>, LayerError>;
@@ -206,6 +242,7 @@ export function make<ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Recor
         Promise.reject(new Error("WorkerContext runtime is not initialized"));
 
       const services = Layer.mergeAll(
+        CloudflareClock.layer,
         Layer.succeed(ExecutionContext, ctx),
         ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))),
         Layer.succeed(
@@ -226,8 +263,24 @@ export function make<ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Recor
         this.runtime.runPromiseExit(effect as Effect.Effect<A, E, RuntimeContext<ROut>>);
     }
 
-    [RunSymbol]<A, E>(effect: Effect.Effect<A, E, RuntimeContext<ROut> | Scope.Scope>): Promise<A> {
-      return this.runtime.runPromise(Effect.scoped(effect));
+    [RunSymbol]<A, E>(
+      effect: Effect.Effect<A, E, RuntimeContext<ROut> | REvent | Scope.Scope>,
+      runOptions: RunOptions = {},
+    ): Promise<A> {
+      const effectWithEventLayer =
+        runOptions.eventLayer === false || options.eventLayer === undefined
+          ? effect
+          : effect.pipe(Effect.provide(options.eventLayer, { local: true }));
+
+      return this.runtime.runPromise(
+        Effect.scoped(
+          effectWithEventLayer as Effect.Effect<
+            A,
+            E | EventLayerError,
+            RuntimeContext<ROut> | Scope.Scope
+          >,
+        ),
+      );
     }
 
     fetch(request: Request): Promise<Response> {
@@ -246,7 +299,7 @@ export function make<ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Recor
         renderFetchSuccess(fetchHandler).pipe(Effect.provide(requestServices)) as Effect.Effect<
           Response,
           unknown,
-          RuntimeContext<ROut> | Scope.Scope
+          RuntimeContext<ROut> | REvent | Scope.Scope
         >,
       );
     }
@@ -272,12 +325,18 @@ export function make<ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Recor
     (self, effect) => self[RunSymbol](effect),
   );
 
-  return Entrypoint.assumeEntrypointClass<WorkerClass<Rpc, ROut>>(EffectWorker);
+  return Entrypoint.assumeEntrypointClass<WorkerClass<Rpc, ROut | REvent>>(EffectWorker);
 }
 
-export const makeFetchHandler = <ROut, LayerError, Env extends WorkerEnv = WorkerEnv>(
+export const makeFetchHandler = <
+  ROut,
+  LayerError,
+  REvent = never,
+  EventLayerError = never,
+  Env extends WorkerEnv = WorkerEnv,
+>(
   layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
-  options: FetchWorkerOptions<ROut>,
+  options: FetchWorkerOptions<ROut, REvent, EventLayerError>,
 ): FetchHandler<Env> => {
   const WorkerClass = make(layer, options);
 
@@ -341,11 +400,13 @@ export type Handlers<ROut, Self extends Definition.Any> = {
   ) => WorkerRpcHandler<ROut, Method.Success<Self["methods"][Key]>>;
 };
 
-export interface Options<ROut, Self extends Definition.Any> extends Omit<
-  WorkerOptions<ROut, Handlers<ROut, Self>>,
-  "rpc"
-> {
-  readonly rpc: Handlers<ROut, Self>;
+export interface Options<
+  ROut,
+  Self extends Definition.Any,
+  REvent = never,
+  EventLayerError = never,
+> extends Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>, "rpc"> {
+  readonly rpc: Handlers<ROut | REvent, Self>;
 }
 
 export type LayerOptions = WorkerDefinition.LayerOptions;
@@ -365,10 +426,10 @@ export type TagClass<Self, Id extends string, MethodsShape extends Methods> = Co
   > & {
     readonly id: Id;
     readonly methods: MethodsShape;
-    readonly make: <ROut, LayerError>(
+    readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(
       layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
-      options: Options<ROut, Definition<Id, MethodsShape>>,
-    ) => WorkerClass<Handlers<ROut, Definition<Id, MethodsShape>>, ROut>;
+      options: Options<ROut, Definition<Id, MethodsShape>, REvent, EventLayerError>,
+    ) => WorkerClass<Handlers<ROut | REvent, Definition<Id, MethodsShape>>, ROut | REvent>;
     readonly layer: (
       options: LayerOptions,
     ) => Layer.Layer<

package/src/WorkerDefinition.ts

@@ -118,11 +118,16 @@ 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,
+  REvent = never,
+  EventLayerError = never,
+> extends Omit<
+  WorkerEntrypoint.WorkerOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>,
   "rpc"
 > {
-  readonly rpc: Handlers<ROut, Self>;
+  readonly rpc: Handlers<ROut | REvent, Self>;
 }
 
 export type LayerOptions = {
@@ -144,14 +149,17 @@ export type TagClass<Self, Id extends string, MethodsShape extends Methods> = Co
   > & {
     readonly id: Id;
     readonly methods: MethodsShape;
-    readonly make: <ROut, LayerError>(
+    readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(
       layer: Layer.Layer<
         ROut,
         LayerError,
         WorkerEntrypoint.ExecutionContext | WorkerEntrypoint.WorkerContext | WorkerEnvironment
       >,
-      options: Options<ROut, Definition<Id, MethodsShape>>,
-    ) => WorkerEntrypoint.WorkerClass<Handlers<ROut, Definition<Id, MethodsShape>>, ROut>;
+      options: Options<ROut, Definition<Id, MethodsShape>, REvent, EventLayerError>,
+    ) => WorkerEntrypoint.WorkerClass<
+      Handlers<ROut | REvent, Definition<Id, MethodsShape>>,
+      ROut | REvent
+    >;
     readonly layer: (
       options: LayerOptions,
     ) => Layer.Layer<
@@ -199,13 +207,13 @@ const makeDefinition = <Id extends string, const MethodsShape extends Methods>(
   const definition: SelfDefinition = RpcDefinition.make(id, methods);
 
   return Object.assign(definition, {
-    make: <ROut, LayerError>(
+    make: <ROut, LayerError, REvent = never, EventLayerError = never>(
       layer: Layer.Layer<
         ROut,
         LayerError,
         WorkerEntrypoint.ExecutionContext | WorkerEntrypoint.WorkerContext | WorkerEnvironment
       >,
-      options: Options<ROut, SelfDefinition>,
+      options: Options<ROut, SelfDefinition, REvent, EventLayerError>,
     ) =>
       WorkerEntrypoint.make(layer, {
         ...options,

package/src/internal/Clock.ts

@@ -0,0 +1,28 @@
+import { Clock, Duration, Effect, Layer } from "effect";
+
+const maxTimerMillis = 2 ** 31 - 1;
+const nanosPerMilli = BigInt(1_000_000);
+
+export const clock: Clock.Clock = {
+  currentTimeMillisUnsafe: () => Date.now(),
+  currentTimeMillis: Effect.sync(() => clock.currentTimeMillisUnsafe()),
+  currentTimeNanosUnsafe: () => BigInt(Date.now()) * nanosPerMilli,
+  currentTimeNanos: Effect.sync(() => clock.currentTimeNanosUnsafe()),
+  sleep: (duration) => {
+    const millis = Duration.toMillis(duration);
+    if (millis <= 0) {
+      return Effect.yieldNow;
+    }
+
+    return Effect.callback<void>((resume) => {
+      if (millis > maxTimerMillis) {
+        return;
+      }
+
+      const handle = setTimeout(() => resume(Effect.void), millis);
+      return Effect.sync(() => clearTimeout(handle));
+    });
+  },
+};
+
+export const layer = Layer.effect(Clock.Clock, Effect.succeed(clock));