effect-cf 0.39.1 → 0.40.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # effect-cf
 
+## 0.40.0
+
+### Minor Changes
+
+- [#146](https://github.com/danieljvdm/effect-cf/pull/146) [`376c9cc`](https://github.com/danieljvdm/effect-cf/commit/376c9ccb16c7ee6a3d6ac2c6f8d6c91ad0b237fc) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add schema-bound scheduling, cancellation, and transactions through `DurableObjectAlarm.Tag`. Register the service's complete `handlers(...)` implementation in a Durable Object's `alarms:` option, then yield the service to schedule work. Missing registration or handlers fail typechecking. Scheduling checks tag/payload pairs and schema-encodes payloads before storage.
+
+  Durable Object entrypoints provide registered alarm services to application layers and handlers. The raw scheduler is provided automatically and remains available for dynamic tags; existing explicit layers and handler-only `define(...)` calls remain supported.
+
+  Unknown stored alarm tags now report `StoredAlarmDecodeError` and follow the delivery failure policy instead of being silently acknowledged. Applications intentionally retiring tags can handle them through `onFailure`.
+
 ## 0.39.1
 
 ### Patch Changes

package/README.md

@@ -45,10 +45,18 @@ const greeting = Effect.gen(function* () {
 
 Declare `SETTINGS` in `wrangler.jsonc` and pass `SettingsLive` to `Worker.make`. Other bindings use the same tag/layer pattern.
 
-The [counter example](https://github.com/danieljvdm/effect-cf/tree/main/examples/counter) shows `DurableObject.Tag`, storage, a typed RPC call, and the complete Wrangler configuration.
+The [document outbox example](https://github.com/danieljvdm/effect-cf/tree/main/examples/outbox) saves document revisions and their delivery alarms atomically, then archives them to R2 outside the transaction.
 
 For atomic application writes and alarm changes, see the [alarm transaction example](tests/fixtures/alarm-transaction-consumer.ts) and [API contract](src/DurableObjectAlarm.ts).
 
+Define a typed alarm service with `class Alarms extends DurableObjectAlarm.Tag<Alarms>()("Alarms", { ...schemas }) {}`. Pass `Alarms.handlers({ ...implementations })` to the DO's `alarms:` option, then `yield* Alarms` to schedule or cancel alarms and open transactions. All declared handlers are required. The registration provides the service to application layers, initialization, and event handlers; declaring schemas alone does not provide a scheduler.
+
+Scheduling accepts decoded payloads, encodes them with the declared schema, and checks that the result is JSON before storage. Transaction callbacks expose the same typed mutations and retain the raw scheduler's rollback and callback-lifetime rules.
+
+`DurableObject.make` and tagged definitions' `.make` still provide the raw `DurableObjectAlarm` service automatically for dynamic tags and JSON payloads. `DurableObjectAlarm.define({ ... }).handlers(...)` remains a handler-only helper for raw scheduling. No alarm tables or native alarms are created until the scheduler is used. Outside these entrypoints, provide the raw scheduler layer explicitly. A typed registration exposes `layer` and `run` for custom runtimes and tests; custom runtimes must install both.
+
+Unknown stored tags produce `StoredAlarmDecodeError` and follow the configured delivery failure policy rather than being acknowledged silently. Use the raw scheduler's `cancelAlarm` to remove retired tags, including repeating alarms.
+
 ## Cloudflare Observability traces
 
 `CloudflareTracer.layer` sends existing `Effect.withSpan` and named `Effect.fn`

package/dist/index.d.mts

@@ -568,6 +568,183 @@ declare const Service: <Self>() => <Id extends string>(id: Id, definition: D1Def
   definition: D1Definition;
   sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
+declare namespace DurableObjectAlarm_d_exports {
+  export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRegistration, AlarmRetryPolicy, AlarmScheduler, AlarmService, AlarmTagClass, AlarmTransaction, DefinedAlarmEvent, DefinedAlarmHandlers, DefinedAlarmScheduler, DefinedAlarmTransaction, DefinedScheduleAlarmInput, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsMode, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, StoredAlarmDecodeError, Tag$8 as Tag, define, processDue };
+}
+type AlarmPayload = Schema.Json;
+declare const InvalidAlarmRefError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "InvalidAlarmRefError";
+} & Readonly<A>;
+declare class InvalidAlarmRefError extends InvalidAlarmRefError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const InvalidAlarmPayloadError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "InvalidAlarmPayloadError";
+} & Readonly<A>;
+declare class InvalidAlarmPayloadError extends InvalidAlarmPayloadError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const InvalidRepeatEveryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "InvalidRepeatEveryError";
+} & Readonly<A>;
+declare class InvalidRepeatEveryError extends InvalidRepeatEveryError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const InvalidProcessDueAlarmsOptionsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "InvalidProcessDueAlarmsOptionsError";
+} & Readonly<A>;
+declare class InvalidProcessDueAlarmsOptionsError extends InvalidProcessDueAlarmsOptionsError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const StoredAlarmDecodeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "StoredAlarmDecodeError";
+} & Readonly<A>;
+declare class StoredAlarmDecodeError extends StoredAlarmDecodeError_base<{
+  readonly cause: unknown;
+  readonly storageId: string;
+}> {
+  get message(): string;
+}
+type DurableObjectAlarmError = InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidProcessDueAlarmsOptionsError | InvalidRepeatEveryError | StorageOperationError | StoredAlarmDecodeError;
+declare const DurableObjectAlarmEvent: Schema.TaggedUnion<{
+  readonly AlarmDue: Schema.TaggedStruct<"AlarmDue", {
+    readonly id: Schema.NonEmptyString;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    /** Persisted due time, which can differ from the invocation time during retries. */
+    readonly scheduledAt: Schema.DateTimeUtc;
+    readonly tag: Schema.NonEmptyString;
+  }>;
+}>;
+type DurableObjectAlarmEvent = typeof DurableObjectAlarmEvent.Type;
+type AlarmRef<Tag extends string = string> = {
+  readonly id: string;
+  readonly tag: Tag;
+};
+/** Reusing `{tag, id}` replaces an alarm. Repeats run after success, never as fixed-cadence catch-up. */
+type ScheduleAlarmInput<Tag extends string = string> = AlarmRef<Tag> & {
+  readonly payload: AlarmPayload;
+  readonly repeatEvery?: Duration.Input;
+  readonly runAt: DateTime.Utc;
+};
+type ProcessDueAlarmsMode = "isolated" | "ordered";
+interface ProcessDueAlarmsFailure {
+  readonly cause: unknown;
+  readonly event?: DurableObjectAlarmEvent;
+  readonly id: string;
+  readonly storageId: string;
+  readonly tag: string;
+}
+interface ProcessDueAlarmsResult {
+  readonly failed: readonly ProcessDueAlarmsFailure[];
+  readonly handled: readonly DurableObjectAlarmEvent[];
+}
+type ProcessDueAlarmsFailureAction = "ordered" | "retry" | "skip-and-advance-repeat" | {
+  readonly mode: "ordered";
+} | {
+  readonly mode: "retry";
+  readonly retryFailedAfter?: Duration.Input;
+} | {
+  readonly mode: "skip-and-advance-repeat";
+};
+interface ProcessDueAlarmsOptions<OnFailureR = never, OnFailureE = never> {
+  readonly limit?: number;
+  /** `isolated` retries only the failed row; `ordered` stops before later rows. */
+  readonly mode?: ProcessDueAlarmsMode;
+  readonly onFailure?: (failure: ProcessDueAlarmsFailure) => Effect.Effect<ProcessDueAlarmsFailureAction | void, OnFailureE, OnFailureR>;
+  readonly retryFailedAfter?: Duration.Input;
+}
+type ProcessDueAlarmsHandler<R = never, E = never> = (event: DurableObjectAlarmEvent) => Effect.Effect<void, E, R>;
+/**
+ * Alarm mutations owned by one transaction callback. Run them in the callback's
+ * fiber; forked work and use after the callback ends fail with StorageOperationError.
+ */
+type AlarmTransaction = Pick<AlarmScheduler, "scheduleAlarm" | "cancelAlarm">;
+/** Own `storage.setAlarm()` exclusively: a Durable Object has one platform alarm timestamp. */
+type AlarmScheduler = {
+  /**
+   * Commits local application storage and logical alarms in one native SQLite
+   * Durable Object transaction, reconciling the native alarm before commit.
+   * Use the supplied mutations, not standalone alarm methods or nested transactions.
+   * SqlClient queries must use this same Durable Object's storage.
+   *
+   * Failure, defects and interruption before commit roll back. A lost reply or
+   * interruption after commit does not undo committed state. Keep RPC and other
+   * external effects outside; atomically pre-arm a later wake before fallible work.
+   * Cloudflare's native retries are bounded; composition does not remove the
+   * pre-arm requirement or promise infinite retry liveness.
+   */
+  readonly transaction: <A, E, R>(closure: (alarms: AlarmTransaction) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | StorageOperationError, R>;
+  readonly cancelAlarm: (input: AlarmRef) => Effect.Effect<void, InvalidAlarmRefError | StorageOperationError>;
+  /** Acknowledge after handling. Conditional writes preserve handler replacements; alarms are at-least-once. */
+  readonly processDueAlarms: <R = never, E = never, OnFailureR = never, OnFailureE = never>(handle: ProcessDueAlarmsHandler<R, E>, options?: ProcessDueAlarmsOptions<OnFailureR, OnFailureE>) => Effect.Effect<ProcessDueAlarmsResult, E | OnFailureE | DurableObjectAlarmError, R | OnFailureR>;
+  /** A failed platform setAlarm rolls back the logical schedule in the same transaction. */
+  readonly scheduleAlarm: (input: ScheduleAlarmInput) => Effect.Effect<void, InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidRepeatEveryError | StorageOperationError>;
+};
+declare const processDue: <R = never, E = never, OnFailureR = never, OnFailureE = never>(handle: ProcessDueAlarmsHandler<R, E>, options?: ProcessDueAlarmsOptions<OnFailureR, OnFailureE>) => Effect.Effect<ProcessDueAlarmsResult, E | OnFailureE | DurableObjectAlarmError, OnFailureR | R | DurableObjectAlarm>;
+type AlarmPayloadSchema = Schema.Codec<any, any, never, never>;
+type AlarmFailurePolicy = "ordered" | "retry" | "skip-and-advance-repeat";
+interface AlarmRetryPolicy {
+  readonly initialDelay?: Duration.Input;
+}
+interface AlarmDefinitionConfig<Payload extends AlarmPayloadSchema = AlarmPayloadSchema> {
+  readonly failure?: AlarmFailurePolicy;
+  readonly payload: Payload;
+  readonly retry?: AlarmRetryPolicy;
+}
+type AlarmDefinitionEntry = AlarmDefinitionConfig | AlarmPayloadSchema;
+type AlarmDefinitions = Readonly<Record<string, AlarmDefinitionEntry>>;
+type AlarmDefinitionSchema<Definition> = Definition extends AlarmDefinitionConfig<infer Payload> ? Payload : Definition;
+type AlarmDefinitionPayload<Definition> = AlarmDefinitionSchema<Definition> extends Schema.Codec<infer A, any, never, never> ? A : never;
+type DefinedAlarmEvent<Tag extends string, Payload> = Omit<DurableObjectAlarmEvent, "payload" | "tag"> & {
+  readonly payload: Payload;
+  readonly tag: Tag;
+};
+type DefinedAlarmHandlers<Definitions extends AlarmDefinitions, R = never, E = never> = { readonly [Tag in keyof Definitions & string]: (event: DefinedAlarmEvent<Tag$8, AlarmDefinitionPayload<Definitions[Tag$8]>>) => Effect.Effect<void, E, R>; };
+/** A discriminated union keeps each tag paired with its decoded payload type. */
+type DefinedScheduleAlarmInput<Definitions extends AlarmDefinitions> = { readonly [Tag in keyof Definitions & string]: Omit<ScheduleAlarmInput<Tag$8>, "payload"> & {
+  readonly payload: AlarmDefinitionPayload<Definitions[Tag$8]>;
+}; }[keyof Definitions & string];
+interface DefinedAlarmTransaction<Definitions extends AlarmDefinitions> {
+  readonly scheduleAlarm: (input: DefinedScheduleAlarmInput<Definitions>) => ReturnType<AlarmScheduler["scheduleAlarm"]>;
+  readonly cancelAlarm: (input: AlarmRef<keyof Definitions & string>) => ReturnType<AlarmScheduler["cancelAlarm"]>;
+}
+declare const TypedAlarmSchedulerTypeId: unique symbol;
+/** Identifies service requirements whose scheduler needs a registered dispatcher. */
+interface AlarmService {
+  readonly Service: {
+    readonly [TypedAlarmSchedulerTypeId]: typeof TypedAlarmSchedulerTypeId;
+  };
+}
+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. */
+interface AlarmRegistration<Self, R = never, E = never> {
+  readonly layer: Layer.Layer<Self, never, DurableObjectAlarm>;
+  readonly run: Effect.Effect<ProcessDueAlarmsResult, E | DurableObjectAlarmError, R | DurableObjectAlarm>;
+}
+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>;
+}
+/** Handler-only definitions for applications using the raw scheduler. Prefer Tag for typed scheduling. */
+declare const define: <const Definitions extends AlarmDefinitions>(definitions: Definitions) => {
+  handlers: <R = never, E = never>(handlers: DefinedAlarmHandlers<Definitions, R, E>, options?: ProcessDueAlarmsOptions<R, E> | undefined) => Effect.Effect<ProcessDueAlarmsResult, E | DurableObjectAlarmError, R | DurableObjectAlarm>;
+};
+/** The typed scheduler becomes available when its handlers are registered on a Durable Object. */
+declare const Tag$8: <Self>() => <const Id extends string, const Definitions extends AlarmDefinitions>(id: Id, definitions: Definitions) => AlarmTagClass<Self, Id, Definitions>;
+declare const DurableObjectAlarm_base: Context.ServiceClass<DurableObjectAlarm, "effect-cf/DurableObjectAlarm", AlarmScheduler>;
+declare class DurableObjectAlarm extends DurableObjectAlarm_base {
+  static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState>;
+}
 declare namespace DurableObjectNamespace_d_exports {
   export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer$7 as layer, makeClient$5 as makeClient, makeDirectMethods };
 }
@@ -712,7 +889,7 @@ declare const makeDirectMethods: <R, Api extends object, Definition extends Defi
   readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
 }) => DirectMethods<R, Api, Definition>;
 declare namespace DurableObjectDefinition_d_exports {
-  export { Api, Definition$3 as Definition, DurableObject$1 as DurableObject, HandlerEffect, Handlers, LayerOptions$8 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, implement$2 as implement, make$7 as make, method };
+  export { Api, Definition$3 as Definition, DurableObject$1 as DurableObject, HandlerEffect, Handlers, LayerOptions$8 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag$7 as Tag, TagClass$7 as TagClass, implement$2 as implement, make$7 as make, method };
 }
 type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
 interface Method$1<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
@@ -754,9 +931,9 @@ type Handlers<ROut, Self extends Definition$3.Any> = { readonly [Key in keyof Se
 /**
  * Durable Object constructor options for a specific RPC definition.
  */
-interface Options$2<ROut, Self extends Definition$3.Any, REvent = never, EventLayerError = never> extends Omit<DurableObjectOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>, "rpc"> {
-  readonly rpc: Handlers<ROut | REvent, Self>;
-}
+type Options$2<ROut, Self extends Definition$3.Any, REvent = never, EventLayerError = never, RAlarm = never> = DurableObjectOptions<ROut, REvent, EventLayerError, Handlers<NoInfer<ROut> | REvent | NoInfer<RAlarm>, Self>, RAlarm> & {
+  readonly rpc: Handlers<NoInfer<ROut> | REvent | NoInfer<RAlarm>, Self>;
+};
 type LayerOptions$8 = {
   readonly binding: string;
   readonly rpcTracing?: boolean;
@@ -764,7 +941,7 @@ type LayerOptions$8 = {
 type TagClass$7<Self, Id extends string, MethodDefinitions extends Methods> = Context.ServiceClass<Self, `effect-cf/DurableObject/${Id}`, DurableObjectNamespaceEffectClient<Api<Definition$3<Id, MethodDefinitions>>, Definition$3<Id, MethodDefinitions>>> & DurableObjectNamespaceStaticClient<Self, Api<Definition$3<Id, MethodDefinitions>>, Definition$3<Id, MethodDefinitions>> & {
   readonly id: Id;
   readonly methods: MethodDefinitions;
-  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$2<ROut, Definition$3<Id, MethodDefinitions>, REvent, EventLayerError>) => DurableObjectClass<Handlers<ROut | REvent, Definition$3<Id, MethodDefinitions>>, ROut | REvent>;
+  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never, RAlarm = never>(layer: Layer.Layer<ROut, LayerError, RuntimeContext$1<NoInfer<RAlarm>>>, options: Options$2<ROut, Definition$3<Id, MethodDefinitions>, REvent, EventLayerError, RAlarm>) => DurableObjectClass<Handlers<ROut | REvent | RAlarm, Definition$3<Id, MethodDefinitions>>, ROut | REvent | RAlarm>;
   readonly layer: (options: LayerOptions$8) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
 /**
@@ -778,8 +955,8 @@ declare function method<const Args extends ReadonlyArray<ServiceFreeSchema>, Suc
   readonly success: Success;
 }): Method$1<Args, Success>;
 declare const make$7: <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass$7<Definition$3<Id, MethodDefinitions>, Id, MethodDefinitions>;
-declare const Tag$8: <Self>() => <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass$7<Self, Id, MethodDefinitions>;
-declare const DurableObject$1: typeof Tag$8;
+declare const Tag$7: <Self>() => <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass$7<Self, Id, MethodDefinitions>;
+declare const DurableObject$1: typeof Tag$7;
 /**
  * Helper for implementing handlers with the exact method shape of a definition.
  */
@@ -789,9 +966,9 @@ declare const implement$2: <ROut, const Self extends Definition$3.Any>(_definiti
  */
 type HandlerEffect<ROut, Self extends Definition$3.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method$1.Success<Self["methods"][Key]>>;
 declare namespace DurableObject_d_exports {
-  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcApi, DurableObjectRpcApi as DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$8 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, ServerApi, ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, implement$2 as implement, make$6 as make, method };
+  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcApi, DurableObjectRpcApi as DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$8 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, RuntimeContext$1 as RuntimeContext, ServerApi, ServiceFreeSchema, Tag$7 as Tag, TagClass$7 as TagClass, implement$2 as implement, make$6 as make, method };
 }
-type RuntimeContext$1<ROut> = DurableObjectState | WorkerEnvironment | ROut;
+type RuntimeContext$1<ROut> = DurableObjectState | DurableObjectAlarm | WorkerEnvironment | ROut;
 type HandlerContext<ROut> = RuntimeContext$1<ROut> | Scope.Scope;
 type FetchContext<ROut> = HandlerContext<ROut> | NativeRequest;
 /** Metadata available before an event effect or its event layer starts. */
@@ -812,7 +989,7 @@ type DurableObjectHandler<ROut, A = unknown> = Effect.Effect<A, unknown, Handler
 type DurableObjectRpc<ROut> = Record<string, (...args: Array<any>) => DurableObjectHandler<ROut>>;
 type DurableObjectRpcApi<Rpc extends DurableObjectRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, HandlerContext<ROut>>) ? (...args: Args) => Promise<A> : never; };
 type RpcHandlers<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof DurableObject<WorkerEnv> ? never : Key extends string ? [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<any>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => DurableObjectHandler<ROut, A> : never; };
-interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never, Rpc extends DurableObjectRpc<RRuntime | REvent> = Record<never, never>> {
+interface DurableObjectOptionsBase<RRuntime, REvent = never, EventLayerError = never, Rpc extends DurableObjectRpc<RRuntime | REvent | RAlarm> = Record<never, never>, RAlarm = never> {
   /**
    * Layer provided around each Cloudflare event handled by this Durable Object.
    *
@@ -820,7 +997,7 @@ interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never
    * 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>;
+  readonly eventLayer?: Layer.Layer<REvent, EventLayerError, RuntimeContext$1<NoInfer<RRuntime | RAlarm>>>;
   /**
    * Effect run when Cloudflare loads this Durable Object instance into memory.
    *
@@ -829,7 +1006,7 @@ interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never
    * 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.
    *
@@ -841,8 +1018,9 @@ interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never
   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 alarms?: Effect.Effect<unknown, unknown, HandlerContext<RRuntime | REvent>>;
+  readonly fetch?: Effect.Effect<Response, unknown, FetchContext<NoInfer<RRuntime | REvent | RAlarm>>>;
+  /** 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.
    *
@@ -851,11 +1029,18 @@ interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never
    * scheduled flush silently settles within two seconds even if the exporter
    * does not.
    */
-  readonly alarm?: (alarmInfo?: globalThis.AlarmInvocationInfo) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
-  readonly webSocketMessage?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
-  readonly webSocketClose?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
-  readonly webSocketError?: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
-}
+  readonly alarm?: (alarmInfo?: globalThis.AlarmInvocationInfo) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
+  readonly webSocketMessage?: (socket: DurableWebSocket, message: string | ArrayBuffer) => 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<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
+  readonly webSocketError?: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
+}
+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. */
+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$1<RRuntime | RAlarm> | Scope.Scope>] extends [never] ? unknown : {
+  readonly eventLayer: Layer.Layer<REvent, EventLayerError, RuntimeContext$1<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}.
  */
@@ -868,154 +1053,8 @@ type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state:
  * that layer are not guaranteed to run. Put resources that require timely
  * release in `eventLayer`, whose scope closes after each handled event.
  */
-declare const make$6: <ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends DurableObjectRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options?: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc>) => DurableObjectClass<Rpc, ROut | REvent>;
-declare namespace DurableObjectAlarm_d_exports {
-  export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRetryPolicy, AlarmScheduler, AlarmTransaction, DefinedAlarmEvent, DefinedAlarmHandlers, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsMode, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, StoredAlarmDecodeError, define, processDue };
-}
-type AlarmPayload = Schema.Json;
-declare const InvalidAlarmRefError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "InvalidAlarmRefError";
-} & Readonly<A>;
-declare class InvalidAlarmRefError extends InvalidAlarmRefError_base<{
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const InvalidAlarmPayloadError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "InvalidAlarmPayloadError";
-} & Readonly<A>;
-declare class InvalidAlarmPayloadError extends InvalidAlarmPayloadError_base<{
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const InvalidRepeatEveryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "InvalidRepeatEveryError";
-} & Readonly<A>;
-declare class InvalidRepeatEveryError extends InvalidRepeatEveryError_base<{
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const InvalidProcessDueAlarmsOptionsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "InvalidProcessDueAlarmsOptionsError";
-} & Readonly<A>;
-declare class InvalidProcessDueAlarmsOptionsError extends InvalidProcessDueAlarmsOptionsError_base<{
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const StoredAlarmDecodeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "StoredAlarmDecodeError";
-} & Readonly<A>;
-declare class StoredAlarmDecodeError extends StoredAlarmDecodeError_base<{
-  readonly cause: unknown;
-  readonly storageId: string;
-}> {
-  get message(): string;
-}
-type DurableObjectAlarmError = InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidProcessDueAlarmsOptionsError | InvalidRepeatEveryError | StorageOperationError | StoredAlarmDecodeError;
-declare const DurableObjectAlarmEvent: Schema.TaggedUnion<{
-  readonly AlarmDue: Schema.TaggedStruct<"AlarmDue", {
-    readonly id: Schema.NonEmptyString;
-    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-    /** Persisted due time, which can differ from the invocation time during retries. */
-    readonly scheduledAt: Schema.DateTimeUtc;
-    readonly tag: Schema.NonEmptyString;
-  }>;
-}>;
-type DurableObjectAlarmEvent = typeof DurableObjectAlarmEvent.Type;
-type AlarmRef<Tag extends string = string> = {
-  readonly id: string;
-  readonly tag: Tag;
-};
-/** Reusing `{tag, id}` replaces an alarm. Repeats run after success, never as fixed-cadence catch-up. */
-type ScheduleAlarmInput<Tag extends string = string> = AlarmRef<Tag> & {
-  readonly payload: AlarmPayload;
-  readonly repeatEvery?: Duration.Input;
-  readonly runAt: DateTime.Utc;
-};
-type ProcessDueAlarmsMode = "isolated" | "ordered";
-interface ProcessDueAlarmsFailure {
-  readonly cause: unknown;
-  readonly event?: DurableObjectAlarmEvent;
-  readonly id: string;
-  readonly storageId: string;
-  readonly tag: string;
-}
-interface ProcessDueAlarmsResult {
-  readonly failed: readonly ProcessDueAlarmsFailure[];
-  readonly handled: readonly DurableObjectAlarmEvent[];
-}
-type ProcessDueAlarmsFailureAction = "ordered" | "retry" | "skip-and-advance-repeat" | {
-  readonly mode: "ordered";
-} | {
-  readonly mode: "retry";
-  readonly retryFailedAfter?: Duration.Input;
-} | {
-  readonly mode: "skip-and-advance-repeat";
-};
-interface ProcessDueAlarmsOptions<OnFailureR = never, OnFailureE = never> {
-  readonly limit?: number;
-  /** `isolated` retries only the failed row; `ordered` stops before later rows. */
-  readonly mode?: ProcessDueAlarmsMode;
-  readonly onFailure?: (failure: ProcessDueAlarmsFailure) => Effect.Effect<ProcessDueAlarmsFailureAction | void, OnFailureE, OnFailureR>;
-  readonly retryFailedAfter?: Duration.Input;
-}
-type ProcessDueAlarmsHandler<R = never, E = never> = (event: DurableObjectAlarmEvent) => Effect.Effect<void, E, R>;
-/**
- * Alarm mutations owned by one transaction callback. Run them in the callback's
- * fiber; forked work and use after the callback ends fail with StorageOperationError.
- */
-type AlarmTransaction = Pick<AlarmScheduler, "scheduleAlarm" | "cancelAlarm">;
-/** Own `storage.setAlarm()` exclusively: a Durable Object has one platform alarm timestamp. */
-type AlarmScheduler = {
-  /**
-   * Commits local application storage and logical alarms in one native SQLite
-   * Durable Object transaction, reconciling the native alarm before commit.
-   * Use the supplied mutations, not standalone alarm methods or nested transactions.
-   * SqlClient queries must use this same Durable Object's storage.
-   *
-   * Failure, defects and interruption before commit roll back. A lost reply or
-   * interruption after commit does not undo committed state. Keep RPC and other
-   * external effects outside; atomically pre-arm a later wake before fallible work.
-   * Cloudflare's native retries are bounded; composition does not remove the
-   * pre-arm requirement or promise infinite retry liveness.
-   */
-  readonly transaction: <A, E, R>(closure: (alarms: AlarmTransaction) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | StorageOperationError, R>;
-  readonly cancelAlarm: (input: AlarmRef) => Effect.Effect<void, InvalidAlarmRefError | StorageOperationError>;
-  /** Acknowledge after handling. Conditional writes preserve handler replacements; alarms are at-least-once. */
-  readonly processDueAlarms: <R = never, E = never, OnFailureR = never, OnFailureE = never>(handle: ProcessDueAlarmsHandler<R, E>, options?: ProcessDueAlarmsOptions<OnFailureR, OnFailureE>) => Effect.Effect<ProcessDueAlarmsResult, E | OnFailureE | DurableObjectAlarmError, R | OnFailureR>;
-  /** A failed platform setAlarm rolls back the logical schedule in the same transaction. */
-  readonly scheduleAlarm: (input: ScheduleAlarmInput) => Effect.Effect<void, InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidRepeatEveryError | StorageOperationError>;
-};
-declare const processDue: <R = never, E = never, OnFailureR = never, OnFailureE = never>(handle: ProcessDueAlarmsHandler<R, E>, options?: ProcessDueAlarmsOptions<OnFailureR, OnFailureE>) => Effect.Effect<ProcessDueAlarmsResult, E | OnFailureE | DurableObjectAlarmError, OnFailureR | R | DurableObjectAlarm>;
-type AlarmPayloadSchema = Schema.Codec<any, any, never, never>;
-type AlarmFailurePolicy = "ordered" | "retry" | "skip-and-advance-repeat";
-interface AlarmRetryPolicy {
-  readonly initialDelay?: Duration.Input;
-}
-interface AlarmDefinitionConfig<Payload extends AlarmPayloadSchema = AlarmPayloadSchema> {
-  readonly failure?: AlarmFailurePolicy;
-  readonly payload: Payload;
-  readonly retry?: AlarmRetryPolicy;
-}
-type AlarmDefinitionEntry = AlarmDefinitionConfig | AlarmPayloadSchema;
-type AlarmDefinitions = Readonly<Record<string, AlarmDefinitionEntry>>;
-type AlarmDefinitionSchema<Definition> = Definition extends AlarmDefinitionConfig<infer Payload> ? Payload : Definition;
-type AlarmDefinitionPayload<Definition> = AlarmDefinitionSchema<Definition> extends Schema.Codec<infer A, any, never, never> ? A : never;
-type DefinedAlarmEvent<Tag extends string, Payload> = Omit<DurableObjectAlarmEvent, "payload" | "tag"> & {
-  readonly payload: Payload;
-  readonly tag: Tag;
-};
-type DefinedAlarmHandlers<Definitions extends AlarmDefinitions, R = never, E = never> = { readonly [Tag in keyof Definitions & string]: (event: DefinedAlarmEvent<Tag, AlarmDefinitionPayload<Definitions[Tag]>>) => Effect.Effect<void, E, R>; };
-declare const define: <const Definitions extends AlarmDefinitions>(definitions: Definitions) => {
-  handlers: <R = never, E = never>(handlers: DefinedAlarmHandlers<Definitions, R, E>, options?: ProcessDueAlarmsOptions<R, E>) => Effect.Effect<ProcessDueAlarmsResult, E | DurableObjectAlarmError, R | DurableObjectAlarm>;
-};
-declare const DurableObjectAlarm_base: Context.ServiceClass<DurableObjectAlarm, "effect-cf/DurableObjectAlarm", AlarmScheduler>;
-declare class DurableObjectAlarm extends DurableObjectAlarm_base {
-  static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState>;
-}
+declare function make$6<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, RuntimeContext$1<never>> & CheckAlarmRegistration<ROut, never>): DurableObjectClass<Record<never, never>, ROut>;
+declare function make$6<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$1<NoInfer<RAlarm>>>, options: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc, RAlarm>): DurableObjectClass<Rpc, ROut | REvent | RAlarm>;
 declare namespace DurableObjectRpcWebSocket_d_exports {
   export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, HeartbeatPolicy, LayerOptions$7 as LayerOptions, NativeWebSocketMessage, ResumableStreamDeclaration, RpcWebSocketAttachment, layer$6 as layer, resumableStream };
 }
@@ -1122,7 +1161,7 @@ declare namespace DurableObjectSqlite_d_exports {
 type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db" | "storage">;
 declare const layer$5: (options?: SqliteLayerOptions) => Layer.Layer<SqliteClient.SqliteClient | SqlClient.SqlClient, never, DurableObjectState>;
 declare namespace Email_d_exports {
-  export { EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, LayerOptions$6 as LayerOptions, Tag$7 as Tag, TagClass$6 as TagClass, emailErrorCodes, isEmailBinding, layer$4 as layer, make$5 as make, makeClient$4 as makeClient, sendLimits, validateMessage };
+  export { EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, LayerOptions$6 as LayerOptions, Tag$6 as Tag, TagClass$6 as TagClass, emailErrorCodes, isEmailBinding, layer$4 as layer, make$5 as make, makeClient$4 as makeClient, sendLimits, validateMessage };
 }
 declare const sendLimits: {
   readonly maxRecipients: 50;
@@ -1219,9 +1258,9 @@ declare const isEmailBinding: <Candidate>(value: Candidate) => value is Candidat
 declare const makeClient$4: (definition: EmailDefinition, options?: EmailSendOptions) => (email: EmailBinding) => EmailClient;
 declare const layer$4: <Self>(tag: Context.Service<Self, EmailClient>, definition: LayerOptions$6) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$5: <Id extends string>(id: Id) => TagClass$6<EmailService<Id>, Id>;
-declare const Tag$7: <Self>() => <Id extends string>(id: Id) => TagClass$6<Self, Id>;
+declare const Tag$6: <Self>() => <Id extends string>(id: Id) => TagClass$6<Self, Id>;
 declare namespace Images_d_exports {
-  export { DrawStepOptions, HostedImagesClient, ImageDirectUploadOptions, ImageDirectUploadResult, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageSignedUrlOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResponseOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, LayerOptions$5 as LayerOptions, ProcessOptions, Step, Steps, Tag$6 as Tag, TagClass$5 as TagClass, TextOptions, TypeId, draw, empty, isImagesBinding, layer$3 as layer, make$4 as make, makeClient$3 as makeClient, transform };
+  export { DrawStepOptions, HostedImagesClient, ImageDirectUploadOptions, ImageDirectUploadResult, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageSignedUrlOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResponseOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, LayerOptions$5 as LayerOptions, ProcessOptions, Step, Steps, Tag$5 as Tag, TagClass$5 as TagClass, TextOptions, TypeId, draw, empty, isImagesBinding, layer$3 as layer, make$4 as make, makeClient$3 as makeClient, transform };
 }
 declare const TypeId: "~effect-cf/Images/Steps";
 type TypeId = typeof TypeId;
@@ -1401,9 +1440,9 @@ declare const isImagesBinding: <Candidate>(value: Candidate) => value is Candida
 declare const makeClient$3: (definition: ImagesDefinition) => (images: ImagesRuntimeBinding) => ImagesClient;
 declare const layer$3: <Self>(tag: Context.Service<Self, ImagesClient>, definition: ImagesDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$4: <Id extends string>(id: Id) => TagClass$5<ImagesService<Id>, Id>;
-declare const Tag$6: <Self>() => <Id extends string>(id: Id) => TagClass$5<Self, Id>;
+declare const Tag$5: <Self>() => <Id extends string>(id: Id) => TagClass$5<Self, Id>;
 declare namespace Kv_d_exports {
-  export { Definition$2 as Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperation, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions$4 as LayerOptions, Tag$5 as Tag, TagClass$4 as TagClass, isKvNamespace, layer$2 as layer, makeClient$2 as makeClient };
+  export { Definition$2 as Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperation, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions$4 as LayerOptions, Tag$4 as Tag, TagClass$4 as TagClass, isKvNamespace, layer$2 as layer, makeClient$2 as makeClient };
 }
 type KvOperation = "put" | "get" | "getWithMetadata" | "list" | "delete";
 declare const KvOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
@@ -1473,12 +1512,12 @@ interface TagClass$4<Self, Id extends string, Key, Value, EncodedValue> extends
 declare const isKvNamespace: <Candidate>(value: Candidate) => value is Candidate & KVNamespace;
 declare const makeClient$2: <Key, Value, EncodedValue>(definition: KvDefinition<Key, Value, EncodedValue>) => ((kv: KVNamespace) => KvClient<Key, Value, EncodedValue>);
 declare const layer$2: <Self, Key, Value, EncodedValue>(tag: Context.Service<Self, KvClient<Key, Value, EncodedValue>>, definition: KvDefinition<Key, Value, EncodedValue>) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const Tag$5: <Self>() => <Id extends string, Key, Value, EncodedValue>(id: Id, definition: {
+declare const Tag$4: <Self>() => <Id extends string, Key, Value, EncodedValue>(id: Id, definition: {
   readonly key: Schema.Codec<Key, string>;
   readonly value: Schema.Codec<Value, EncodedValue>;
 }) => TagClass$4<Self, Id, Key, Value, EncodedValue>;
 declare namespace R2_d_exports {
-  export { LayerOptions$3 as LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2Operation, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, Tag$4 as Tag, TagClass$3 as TagClass, isR2Bucket, layer$1 as layer, make$3 as make, makeClient$1 as makeClient };
+  export { LayerOptions$3 as LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2Operation, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, Tag$3 as Tag, TagClass$3 as TagClass, isR2Bucket, layer$1 as layer, make$3 as make, makeClient$1 as makeClient };
 }
 type R2Operation = "head" | "get" | "put" | "delete" | "list" | "createMultipartUpload" | "resumeMultipartUpload" | "uploadPart" | "abortMultipartUpload" | "completeMultipartUpload" | "arrayBuffer" | "bytes" | "text" | "json" | "blob";
 declare const R2OperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
@@ -1556,9 +1595,9 @@ declare const isR2Bucket: (value: R2BindingValue) => value is CloudflareR2Bucket
 declare const makeClient$1: (definition: R2Definition) => ((bucket: CloudflareR2Bucket) => R2Client);
 declare const layer$1: <Self>(tag: Context.Service<Self, R2Client>, definition: R2Definition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$3: <Id extends string>(id: Id) => TagClass$3<R2Service<Id>, Id>;
-declare const Tag$4: <Self>() => <Id extends string>(id: Id) => TagClass$3<Self, Id>;
+declare const Tag$3: <Self>() => <Id extends string>(id: Id) => TagClass$3<Self, Id>;
 declare namespace Vectorize_d_exports {
-  export { LayerOptions$2 as LayerOptions, Tag$3 as Tag, TagClass$2 as TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, isVectorizeBinding, layer, make$2 as make, makeClient };
+  export { LayerOptions$2 as LayerOptions, Tag$2 as Tag, TagClass$2 as TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, isVectorizeBinding, layer, make$2 as make, makeClient };
 }
 type VectorizeOperation = "describe" | "query" | "queryById" | "insert" | "upsert" | "deleteByIds" | "getByIds";
 declare const VectorizeOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
@@ -1616,7 +1655,7 @@ declare const isVectorizeBinding: (value: VectorizeBindingValue) => value is Vec
 declare const makeClient: (definition: VectorizeDefinition) => (index: VectorizeBinding) => VectorizeClient;
 declare const layer: <Self>(tag: Context.Service<Self, VectorizeClient>, definition: VectorizeDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$2: <Id extends string>(id: Id) => TagClass$2<VectorizeService<Id>, Id>;
-declare const Tag$3: <Self>() => <Id extends string>(id: Id) => TagClass$2<Self, Id>;
+declare const Tag$2: <Self>() => <Id extends string>(id: Id) => TagClass$2<Self, Id>;
 declare namespace WebTransport_d_exports {
   export { Capabilities, InboundTransport, WebTransportCapability, WebTransportUnsupportedError, capabilities, inboundSessionsUnsupported, inboundTransport, isHttp3 };
 }
@@ -1679,7 +1718,7 @@ declare class WebTransportUnsupportedError extends WebTransportUnsupportedError_
  */
 declare const inboundSessionsUnsupported: Effect.Effect<never, WebTransportUnsupportedError>;
 declare namespace WorkflowDefinition_d_exports {
-  export { Definition$1 as Definition, Handler$1 as Handler, LayerOptions$1 as LayerOptions, Options$1 as Options, Tag$2 as Tag, TagClass$1 as TagClass, Workflow, implement$1 as implement, make$1 as make };
+  export { Definition$1 as Definition, Handler$1 as Handler, LayerOptions$1 as LayerOptions, Options$1 as Options, Tag$1 as Tag, TagClass$1 as TagClass, Workflow, implement$1 as implement, make$1 as make };
 }
 interface Definition$1<Id extends string = string, Payload extends ServiceFreeSchema$1 = ServiceFreeSchema$1, Result extends ServiceFreeSchema$1 = ServiceFreeSchema$1> {
   readonly id: Id;
@@ -1711,14 +1750,14 @@ declare const make$1: <Id extends string, Payload extends ServiceFreeSchema$1, R
   readonly payload: Payload;
   readonly result: Result;
 }) => TagClass$1<Definition$1<Id, Payload, Result>, Id, Payload, Result>;
-declare const Tag$2: <Self>() => <Id extends string, Payload extends ServiceFreeSchema$1, Result extends ServiceFreeSchema$1>(id: Id, definition: {
+declare const Tag$1: <Self>() => <Id extends string, Payload extends ServiceFreeSchema$1, Result extends ServiceFreeSchema$1>(id: Id, definition: {
   readonly payload: Payload;
   readonly result: Result;
 }) => TagClass$1<Self, Id, Payload, Result>;
-declare const Workflow: typeof Tag$2;
+declare const Workflow: typeof Tag$1;
 declare const implement$1: <ROut, const Self extends Definition$1.Any>(_definition: Self, handler: Handler$1<ROut, Self>) => Handler$1<ROut, Self>;
 declare namespace Workflow_d_exports {
-  export { Definition, Handler, LayerOptions, Options, Tag$1 as Tag, TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, implement, make, sleep, sleepUntil, step, waitForEvent };
+  export { Definition, Handler, LayerOptions, Options, Tag, TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, implement, make, sleep, sleepUntil, step, waitForEvent };
 }
 interface WorkflowEventService<Payload = unknown> {
   readonly raw: WorkflowEvent<unknown>;
@@ -1790,7 +1829,7 @@ declare namespace Definition {
 }
 type LayerOptions = LayerOptions$1;
 type TagClass<Self, Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]> = TagClass$1<Self, Id, Payload, Result>;
-declare const Tag$1: <Self>() => <Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]>(id: Id, definition: {
+declare const Tag: <Self>() => <Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]>(id: Id, definition: {
   readonly payload: Payload;
   readonly result: Result;
 }) => TagClass<Self, Id, Payload, Result>;