effect-cf 0.39.1 → 0.40.1

package/src/DurableObject.ts

@@ -1,9 +1,17 @@
 import { DurableObject as CloudflareDurableObject } from "cloudflare:workers";
-import { Effect, Layer, type ManagedRuntime, type Scope, Tracer } from "effect";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Tracer from "effect/Tracer";
+import type { ManagedRuntime, Scope } from "effect";
 
 import { NativeRequest } from "./Worker";
 import { WorkerEnvironment, type WorkerEnv } from "./Environment";
 import { DurableObjectState, fromDurableObjectState } from "./DurableObjectState";
+import {
+  DurableObjectAlarm,
+  type AlarmRegistration,
+  type AlarmService,
+} from "./DurableObjectAlarm";
 import { fromWebSocket, type DurableWebSocket } from "./DurableObjectWebSocket";
 import * as RpcDefinition from "./RpcDefinition";
 import * as Entrypoint from "./internal/Entrypoint";
@@ -13,7 +21,11 @@ import type { ReceiverOptions, RpcInvocationInfo } from "./RpcTracing";
 
 const reservedMethodNames: ReadonlySet<string> = RpcDefinition.reservedMethodNames;
 
-type RuntimeContext<ROut> = DurableObjectState | WorkerEnvironment | ROut;
+export type RuntimeContext<ROut> =
+  | DurableObjectState
+  | DurableObjectAlarm
+  | WorkerEnvironment
+  | ROut;
 
 type HandlerContext<ROut> = RuntimeContext<ROut> | Scope.Scope;
 
@@ -80,11 +92,12 @@ export type RpcHandlers<ROut, Api> = {
     : never;
 };
 
-export interface DurableObjectOptions<
+interface DurableObjectOptionsBase<
   RRuntime,
   REvent = never,
   EventLayerError = never,
-  Rpc extends DurableObjectRpc<RRuntime | REvent> = Record<never, never>,
+  Rpc extends DurableObjectRpc<RRuntime | REvent | RAlarm> = Record<never, never>,
+  RAlarm = never,
 > {
   /**
    * Layer provided around each Cloudflare event handled by this Durable Object.
@@ -96,7 +109,7 @@ export interface DurableObjectOptions<
   readonly eventLayer?: Layer.Layer<
     REvent,
     EventLayerError,
-    DurableObjectState | WorkerEnvironment | RRuntime
+    RuntimeContext<NoInfer<RRuntime | RAlarm>>
   >;
   /**
    * Effect run when Cloudflare loads this Durable Object instance into memory.
@@ -106,7 +119,7 @@ export interface DurableObjectOptions<
    * 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<RRuntime>>;
+  readonly initialize?: Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime | RAlarm>>>;
   /**
    * Optional RPC methods exposed as Durable Object instance methods.
    *
@@ -118,9 +131,20 @@ export interface DurableObjectOptions<
   readonly rpc?: Rpc;
   /** Accept live native trace metadata. The client must also enable rpcTracing. */
   readonly rpcTracing?: ReceiverOptions;
-  readonly fetch?: Effect.Effect<Response, unknown, FetchContext<RRuntime | REvent>>;
+  readonly fetch?: Effect.Effect<
+    Response,
+    unknown,
+    FetchContext<NoInfer<RRuntime | REvent | RAlarm>>
+  >;
 
-  readonly alarms?: Effect.Effect<unknown, unknown, HandlerContext<RRuntime | REvent>>;
+  /** Register handlers to provide their typed scheduler to application layers and all DO events. */
+  readonly alarms?:
+    | Effect.Effect<unknown, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>
+    | AlarmRegistration<
+        RAlarm,
+        HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>,
+        unknown
+      >;
   /**
    * Optional raw alarm handler.
    *
@@ -131,23 +155,58 @@ export interface DurableObjectOptions<
    */
   readonly alarm?: (
     alarmInfo?: globalThis.AlarmInvocationInfo,
-  ) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
+  ) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
   readonly webSocketMessage?: (
     socket: DurableWebSocket,
     message: string | ArrayBuffer,
-  ) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
+  ) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
   readonly webSocketClose?: (
     socket: DurableWebSocket,
     code: number,
     reason: string,
     wasClean: boolean,
-  ) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
+  ) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
   readonly webSocketError?: (
     socket: DurableWebSocket,
     cause: unknown,
-  ) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
+  ) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
 }
 
+// Providing a scheduler through an ordinary layer does not install its dispatcher.
+type CheckAlarmRegistration<RProvided, RAlarm> = [
+  Exclude<Extract<NoInfer<RProvided>, AlarmService>, NoInfer<RAlarm>>,
+] extends [never]
+  ? unknown
+  : never;
+
+/** A declared event or alarm service must have its corresponding provider. */
+export type DurableObjectOptions<
+  RRuntime,
+  REvent = never,
+  EventLayerError = never,
+  Rpc extends DurableObjectRpc<RRuntime | REvent | RAlarm> = Record<never, never>,
+  RAlarm = never,
+> = DurableObjectOptionsBase<RRuntime, REvent, EventLayerError, Rpc, RAlarm> &
+  CheckAlarmRegistration<RRuntime | REvent, RAlarm> &
+  ([Exclude<REvent, RuntimeContext<RRuntime | RAlarm> | Scope.Scope>] extends [never]
+    ? unknown
+    : {
+        readonly eventLayer: Layer.Layer<
+          REvent,
+          EventLayerError,
+          RuntimeContext<NoInfer<RRuntime | RAlarm>>
+        >;
+      }) &
+  ([RAlarm] extends [never]
+    ? unknown
+    : {
+        readonly alarms: AlarmRegistration<
+          RAlarm,
+          HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>,
+          unknown
+        >;
+      });
+
 /**
  * Cloudflare `DurableObject` constructor produced by {@link make}.
  */
@@ -168,27 +227,62 @@ export type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (
  * that layer are not guaranteed to run. Put resources that require timely
  * release in `eventLayer`, whose scope closes after each handled event.
  */
-export const make = <
+export function make<ROut, LayerError>(
+  layer: Layer.Layer<ROut, LayerError, RuntimeContext<never>> & CheckAlarmRegistration<ROut, never>,
+): DurableObjectClass<Record<never, never>, ROut>;
+export function make<
+  ROut,
+  LayerError,
+  REvent = never,
+  EventLayerError = never,
+  const Rpc extends DurableObjectRpc<NoInfer<ROut> | REvent | NoInfer<RAlarm>> = Record<
+    never,
+    never
+  >,
+  RAlarm = never,
+>(
+  layer: Layer.Layer<ROut, LayerError, RuntimeContext<NoInfer<RAlarm>>>,
+  options: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc, RAlarm>,
+): DurableObjectClass<Rpc, ROut | REvent | RAlarm>;
+export function make<
   ROut,
   LayerError,
   REvent = never,
   EventLayerError = never,
-  const Rpc extends DurableObjectRpc<ROut | REvent> = Record<never, never>,
+  const Rpc extends DurableObjectRpc<NoInfer<ROut> | REvent | NoInfer<RAlarm>> = Record<
+    never,
+    never
+  >,
+  RAlarm = never,
 >(
-  layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>,
-  options: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc> = {},
-): DurableObjectClass<Rpc, ROut | REvent> => {
+  layer: Layer.Layer<ROut, LayerError, RuntimeContext<NoInfer<RAlarm>>>,
+  options: DurableObjectOptionsBase<ROut, REvent, EventLayerError, Rpc, RAlarm> = {},
+): DurableObjectClass<Rpc, ROut | REvent | RAlarm> {
+  const registration =
+    options.alarms !== undefined && !Effect.isEffect(options.alarms) ? options.alarms : undefined;
+  const logicalAlarms = (
+    registration?.run ?? (Effect.isEffect(options.alarms) ? options.alarms : undefined)
+  )?.pipe(Effect.asVoid);
+
   class EffectDurableObject extends CloudflareDurableObject<WorkerEnv> {
-    readonly runtime: ManagedRuntime.ManagedRuntime<RuntimeContext<ROut>, LayerError>;
+    readonly runtime: ManagedRuntime.ManagedRuntime<RuntimeContext<ROut | RAlarm>, LayerError>;
 
     constructor(state: globalThis.DurableObjectState, env: WorkerEnv) {
       super(state, env);
 
-      this.runtime = Runtime.makeEntrypointRuntime<ROut, LayerError, DurableObjectState>(
-        layer,
-        env,
-        Layer.succeed(DurableObjectState, fromDurableObjectState(state)),
+      const baseServices = DurableObjectAlarm.layer.pipe(
+        Layer.provideMerge(Layer.succeed(DurableObjectState, fromDurableObjectState(state))),
       );
+      // SAFETY: RAlarm is inferred only from the registration's layer; without a registration it is never.
+      const services = (registration?.layer ?? Layer.empty).pipe(
+        Layer.provideMerge(baseServices),
+      ) as Layer.Layer<DurableObjectState | DurableObjectAlarm | RAlarm>;
+
+      this.runtime = Runtime.makeEntrypointRuntime<
+        ROut,
+        LayerError,
+        DurableObjectState | DurableObjectAlarm | RAlarm
+      >(layer, env, services);
 
       const initialize = options.initialize;
 
@@ -198,7 +292,7 @@ export const make = <
     }
 
     [RunSymbol]<A, E>(
-      effect: Effect.Effect<A, E, HandlerContext<ROut | REvent>>,
+      effect: Effect.Effect<A, E, HandlerContext<ROut | REvent | RAlarm>>,
       runOptions: RunOptions = {},
     ): Promise<A> {
       const eventLayer = runOptions.eventLayer === false ? undefined : options.eventLayer;
@@ -206,11 +300,11 @@ export const make = <
       const parentSpan = parent === undefined ? undefined : Tracer.externalSpan(parent);
 
       if (eventLayer === undefined) {
-        // SAFETY: event-layer bypass is used only for initialize; otherwise an absent layer means REvent is never.
+        // SAFETY: initialize cannot require event services; without an event layer, all requirements are already provided.
         return Runtime.runEventPromise(
           this.runtime,
           // @effect-diagnostics-next-line unsafeEffectTypeAssertion:off
-          effect as Effect.Effect<A, E, HandlerContext<ROut>>,
+          effect as Effect.Effect<A, E, HandlerContext<ROut | RAlarm>>,
           undefined,
           parentSpan,
         );
@@ -219,7 +313,7 @@ export const make = <
       return Runtime.runEventPromise<
         A,
         E,
-        RuntimeContext<ROut>,
+        RuntimeContext<ROut | RAlarm>,
         REvent,
         EventLayerError,
         LayerError
@@ -239,7 +333,6 @@ export const make = <
     }
 
     alarm(alarmInfo?: globalThis.AlarmInvocationInfo): Promise<void> | void {
-      const logicalAlarms = options.alarms?.pipe(Effect.asVoid);
       const rawAlarm = options.alarm?.(alarmInfo);
       const alarmEffect =
         logicalAlarms !== undefined && rawAlarm !== undefined
@@ -297,10 +390,10 @@ export const make = <
     options.rpcTracing,
   );
 
-  return Entrypoint.assumeEntrypointClass<DurableObjectClass<Rpc, ROut | REvent>>(
+  return Entrypoint.assumeEntrypointClass<DurableObjectClass<Rpc, ROut | REvent | RAlarm>>(
     EffectDurableObject,
   );
-};
+}
 
 export type {
   Api,

package/src/DurableObjectAlarm.ts

@@ -1,15 +1,13 @@
-import {
-  Clock,
-  Context,
-  Data,
-  DateTime,
-  Duration,
-  Effect,
-  Exit,
-  Layer,
-  Predicate,
-  Schema as S,
-} from "effect";
+import * as Clock from "effect/Clock";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as DateTime from "effect/DateTime";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as S from "effect/Schema";
 
 import { DurableObjectState } from "./DurableObjectState";
 import { type SqlStorageValue, StorageOperationError } from "./DurableObjectStorage";
@@ -368,6 +366,63 @@ export type DefinedAlarmHandlers<Definitions extends AlarmDefinitions, R = never
   ) => Effect.Effect<void, E, R>;
 };
 
+/** A discriminated union keeps each tag paired with its decoded payload type. */
+export type DefinedScheduleAlarmInput<Definitions extends AlarmDefinitions> = {
+  readonly [Tag in keyof Definitions & string]: Omit<ScheduleAlarmInput<Tag>, "payload"> & {
+    readonly payload: AlarmDefinitionPayload<Definitions[Tag]>;
+  };
+}[keyof Definitions & string];
+
+export interface DefinedAlarmTransaction<Definitions extends AlarmDefinitions> {
+  readonly scheduleAlarm: (
+    input: DefinedScheduleAlarmInput<Definitions>,
+  ) => ReturnType<AlarmScheduler["scheduleAlarm"]>;
+  readonly cancelAlarm: (
+    input: AlarmRef<keyof Definitions & string>,
+  ) => ReturnType<AlarmScheduler["cancelAlarm"]>;
+}
+
+const TypedAlarmSchedulerTypeId: unique symbol = Symbol.for(
+  "effect-cf/DurableObjectAlarm/TypedScheduler",
+);
+
+/** Identifies service requirements whose scheduler needs a registered dispatcher. */
+export interface AlarmService {
+  readonly Service: {
+    readonly [TypedAlarmSchedulerTypeId]: typeof TypedAlarmSchedulerTypeId;
+  };
+}
+
+export interface DefinedAlarmScheduler<
+  Definitions extends AlarmDefinitions,
+> extends DefinedAlarmTransaction<Definitions> {
+  readonly [TypedAlarmSchedulerTypeId]: typeof TypedAlarmSchedulerTypeId;
+  readonly transaction: <A, E, R>(
+    closure: (alarms: DefinedAlarmTransaction<Definitions>) => Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, E | StorageOperationError, R>;
+}
+
+/** Registers a dispatcher and the service authorized to schedule its alarms. */
+export interface AlarmRegistration<Self, R = never, E = never> {
+  readonly layer: Layer.Layer<Self, never, DurableObjectAlarm>;
+  readonly run: Effect.Effect<
+    ProcessDueAlarmsResult,
+    E | DurableObjectAlarmError,
+    R | DurableObjectAlarm
+  >;
+}
+
+export interface AlarmTagClass<
+  Self,
+  Id extends string,
+  Definitions extends AlarmDefinitions,
+> extends Context.ServiceClass<Self, Id, DefinedAlarmScheduler<Definitions>> {
+  readonly handlers: <R = never, E = never>(
+    handlers: DefinedAlarmHandlers<Definitions, R, E>,
+    options?: ProcessDueAlarmsOptions<R, E>,
+  ) => AlarmRegistration<Self, R, E>;
+}
+
 const isAlarmDefinitionConfig = (
   definition: AlarmDefinitionEntry,
 ): definition is AlarmDefinitionConfig => Predicate.isObject(definition) && "payload" in definition;
@@ -391,55 +446,133 @@ const getAlarmDefinitionFailureAction = (
     : { mode: definition.failure };
 };
 
-export const define = <const Definitions extends AlarmDefinitions>(definitions: Definitions) => ({
-  handlers: <R = never, E = never>(
-    handlers: DefinedAlarmHandlers<Definitions, R, E>,
-    options?: ProcessDueAlarmsOptions<R, E>,
-  ) =>
-    processDue(
-      (event) =>
-        Effect.gen(function* () {
-          const definition = definitions[event.tag];
+const makeDefinition = <const Definitions extends AlarmDefinitions>(definitions: Definitions) => {
+  const definitionFor = (tag: string) =>
+    Object.hasOwn(definitions, tag) ? definitions[tag] : undefined;
 
-          if (definition === undefined) {
-            return;
-          }
+  const bind = (mutations: AlarmTransaction): DefinedAlarmTransaction<Definitions> => ({
+    scheduleAlarm: Effect.fn("DefinedAlarms.scheduleAlarm")(function* (
+      input: DefinedScheduleAlarmInput<Definitions>,
+    ) {
+      const definition = definitionFor(input.tag);
 
-          const schema = getAlarmDefinitionSchema(definition);
-          // SAFETY: schema is selected from the same tagged definition used to select its handler.
-          const payload = yield* (
-            S.decodeUnknownEffect(schema)(event.payload) as Effect.Effect<
-              AlarmDefinitionPayload<Definitions[keyof Definitions & string]>,
-              unknown
-            >
-          ).pipe(
-            Effect.mapError(
-              (cause) =>
+      if (definition === undefined) {
+        return yield* Effect.fail(
+          new InvalidAlarmRefError({
+            cause: new Error(`Unknown alarm tag "${input.tag}"`),
+          }),
+        );
+      }
+      const payload = yield* S.encodeEffect(getAlarmDefinitionSchema(definition))(
+        input.payload,
+      ).pipe(
+        Effect.flatMap(S.decodeUnknownEffect(S.Json)),
+        Effect.mapError((cause) => new InvalidAlarmPayloadError({ cause })),
+      );
+
+      yield* mutations.scheduleAlarm({ ...input, payload });
+    }),
+    cancelAlarm: Effect.fn("DefinedAlarms.cancelAlarm")(function* (
+      input: AlarmRef<keyof Definitions & string>,
+    ) {
+      if (definitionFor(input.tag) === undefined) {
+        return yield* Effect.fail(
+          new InvalidAlarmRefError({
+            cause: new Error(`Unknown alarm tag "${input.tag}"`),
+          }),
+        );
+      }
+
+      yield* mutations.cancelAlarm(input);
+    }),
+  });
+
+  return {
+    make: (alarms: AlarmScheduler): DefinedAlarmScheduler<Definitions> => ({
+      [TypedAlarmSchedulerTypeId]: TypedAlarmSchedulerTypeId,
+      ...bind(alarms),
+      transaction: (closure) => alarms.transaction((tx) => closure(bind(tx))),
+    }),
+    handlers: <R = never, E = never>(
+      handlers: DefinedAlarmHandlers<Definitions, R, E>,
+      options?: ProcessDueAlarmsOptions<R, E>,
+    ) =>
+      processDue(
+        (event) =>
+          Effect.gen(function* () {
+            const definition = definitionFor(event.tag);
+
+            if (definition === undefined) {
+              return yield* Effect.fail(
                 new StoredAlarmDecodeError({
-                  cause,
+                  cause: new Error(`Unknown alarm tag "${event.tag}"`),
                   storageId: getScheduledEventId(event),
                 }),
-            ),
-          );
-          const handler = handlers[event.tag];
+              );
+            }
 
-          // SAFETY: event.tag indexes the matching definition and handler, whose payload schema was decoded above.
-          yield* handler({ ...event, payload } as never);
-        }),
-      {
-        ...options,
-        onFailure: (failure) =>
-          Effect.gen(function* () {
-            const action = getAlarmDefinitionFailureAction(definitions[failure.tag]);
-            const optionAction =
-              options?.onFailure === undefined ? undefined : yield* options.onFailure(failure);
+            const schema = getAlarmDefinitionSchema(definition);
+            // SAFETY: schema is selected from the same tagged definition used to select its handler.
+            const payload = yield* (
+              S.decodeUnknownEffect(schema)(event.payload) as Effect.Effect<
+                AlarmDefinitionPayload<Definitions[keyof Definitions & string]>,
+                unknown
+              >
+            ).pipe(
+              Effect.mapError(
+                (cause) =>
+                  new StoredAlarmDecodeError({
+                    cause,
+                    storageId: getScheduledEventId(event),
+                  }),
+              ),
+            );
+            const handler = handlers[event.tag];
 
-            return action ?? optionAction;
+            // SAFETY: event.tag indexes the matching definition and handler, whose payload schema was decoded above.
+            yield* handler({ ...event, payload } as never);
           }),
-      },
-    ),
+        {
+          ...options,
+          onFailure: (failure) =>
+            Effect.gen(function* () {
+              const action = getAlarmDefinitionFailureAction(definitionFor(failure.tag));
+              const optionAction =
+                options?.onFailure === undefined ? undefined : yield* options.onFailure(failure);
+
+              return action ?? optionAction;
+            }),
+        },
+      ),
+  };
+};
+
+/** Handler-only definitions for applications using the raw scheduler. Prefer Tag for typed scheduling. */
+export const define = <const Definitions extends AlarmDefinitions>(definitions: Definitions) => ({
+  handlers: makeDefinition(definitions).handlers,
 });
 
+/** The typed scheduler becomes available when its handlers are registered on a Durable Object. */
+export const Tag =
+  <Self>() =>
+  <const Id extends string, const Definitions extends AlarmDefinitions>(
+    id: Id,
+    definitions: Definitions,
+  ): AlarmTagClass<Self, Id, Definitions> => {
+    const tag = Context.Service<Self, DefinedAlarmScheduler<Definitions>>()(id);
+    const definition = makeDefinition(definitions);
+
+    return Object.assign(tag, {
+      handlers: <R = never, E = never>(
+        handlers: DefinedAlarmHandlers<Definitions, R, E>,
+        options?: ProcessDueAlarmsOptions<R, E>,
+      ): AlarmRegistration<Self, R, E> => ({
+        layer: Layer.effect(tag, Effect.map(DurableObjectAlarm, definition.make)),
+        run: definition.handlers(handlers, options),
+      }),
+    });
+  };
+
 export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, AlarmScheduler>()(
   "effect-cf/DurableObjectAlarm",
 ) {
@@ -723,6 +856,6 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
         scheduleAlarm: (input) => transaction((alarms) => alarms.scheduleAlarm(input)),
         transaction,
       });
-    }).pipe(Effect.withSpan("DurableObjectAlarm.layer")),
+    }),
   );
 }

package/src/DurableObjectDefinition.ts

@@ -1,10 +1,11 @@
-import { Context, Effect, type Layer, type Schema as S } from "effect";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type { Layer, Schema as S } from "effect";
 
 import type * as Binding from "./Binding";
 import * as DurableObjectEntrypoint from "./DurableObject";
 import type { DurableObjectHandler } from "./DurableObject";
 import * as DurableObjectNamespace from "./DurableObjectNamespace";
-import type { DurableObjectState } from "./DurableObjectState";
 import type * as Rpc from "./Rpc";
 import * as RpcDefinition from "./RpcDefinition";
 import { recordDecodedArgs } from "./internal/RpcInvocation";
@@ -118,22 +119,21 @@ type MutableBoundaryHandlers<ROut, Self extends Definition.Any> = {
 /**
  * Durable Object constructor options for a specific RPC definition.
  */
-export interface Options<
+export type 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 | REvent, Self>;
-}
+  RAlarm = never,
+> = DurableObjectEntrypoint.DurableObjectOptions<
+  ROut,
+  REvent,
+  EventLayerError,
+  Handlers<NoInfer<ROut> | REvent | NoInfer<RAlarm>, Self>,
+  RAlarm
+> & {
+  readonly rpc: Handlers<NoInfer<ROut> | REvent | NoInfer<RAlarm>, Self>;
+};
 
 export type LayerOptions = {
   readonly binding: string;
@@ -159,12 +159,12 @@ export type TagClass<
   > & {
     readonly id: Id;
     readonly methods: MethodDefinitions;
-    readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(
-      layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>,
-      options: Options<ROut, Definition<Id, MethodDefinitions>, REvent, EventLayerError>,
+    readonly make: <ROut, LayerError, REvent = never, EventLayerError = never, RAlarm = never>(
+      layer: Layer.Layer<ROut, LayerError, DurableObjectEntrypoint.RuntimeContext<NoInfer<RAlarm>>>,
+      options: Options<ROut, Definition<Id, MethodDefinitions>, REvent, EventLayerError, RAlarm>,
     ) => DurableObjectEntrypoint.DurableObjectClass<
-      Handlers<ROut | REvent, Definition<Id, MethodDefinitions>>,
-      ROut | REvent
+      Handlers<ROut | REvent | RAlarm, Definition<Id, MethodDefinitions>>,
+      ROut | REvent | RAlarm
     >;
     readonly layer: (
       options: LayerOptions,
@@ -201,9 +201,9 @@ const makeDefinition = <Id extends string, const MethodDefinitions extends Metho
   const definition: SelfDefinition = RpcDefinition.make(id, methods);
 
   return Object.assign(definition, {
-    make: <ROut, LayerError, REvent = never, EventLayerError = never>(
-      layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>,
-      options: Options<ROut, SelfDefinition, REvent, EventLayerError>,
+    make: <ROut, LayerError, REvent = never, EventLayerError = never, RAlarm = never>(
+      layer: Layer.Layer<ROut, LayerError, DurableObjectEntrypoint.RuntimeContext<NoInfer<RAlarm>>>,
+      options: Options<ROut, SelfDefinition, REvent, EventLayerError, RAlarm>,
     ) =>
       DurableObjectEntrypoint.make(layer, {
         ...options,

package/src/DurableObjectNamespace.ts

@@ -1,4 +1,7 @@
-import { Data, Effect, Predicate, type Context, type Layer, type Scope } from "effect";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import type { Context, Layer, Scope } from "effect";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";

package/src/DurableObjectRpcWebSocket.ts

@@ -1,4 +1,10 @@
-import { Context, Effect, Layer, Option, Predicate, Queue, Schema } from "effect";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Queue from "effect/Queue";
+import * as Schema from "effect/Schema";
 import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";

package/src/DurableObjectSqlite.ts

@@ -1,5 +1,6 @@
 import { SqliteClient } from "@effect/sql-sqlite-do";
-import { Effect, Layer } from "effect";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
 import type { SqlClient } from "effect/unstable/sql";
 
 import { DurableObjectState } from "./DurableObjectState";

package/src/DurableObjectState.ts

@@ -1,4 +1,7 @@
-import { Cause, Context, Effect, Exit } from "effect";
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
 
 import { fromDurableObjectStorage, type DurableObjectStorage } from "./DurableObjectStorage";
 import { fromWebSocket, type DurableWebSocket } from "./DurableObjectWebSocket";