effect-cf 0.0.4 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dan van der Merwe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,70 +1,56 @@
 # effect-cf
 
-Effect-native primitives for Cloudflare Workers and bindings.
+Effect-native Cloudflare primitives for Workers, Durable Objects, bindings, KV, and Durable Object storage.
 
-## Design Goal
+## Install
 
-Cloudflare services should be described as `Context`, `Layer`, and `Effect` values and executed through package-owned Cloudflare entrypoint/runtime boundaries. Consumer code should stay in `Effect`; bindings and storage helpers wrap Promise-returning Cloudflare APIs so applications do not call `Effect.runPromise` or manually bridge Promises.
+`effect-cf` currently targets Effect 4 beta.
 
-The low-level Worker entrypoint factory is exported as `Worker.make`. It returns a `WorkerEntrypoint` class with a `fetch` handler and optional typed RPC methods. Durable Object support starts with `DurableObject.make`, which routes Durable Object lifecycle methods and RPC handlers through one managed runtime for each Durable Object instance.
-
-Worker fetch handlers can return either web `Response` values or Effect `HttpServerResponse` values. `Worker.make` renders `HttpServerResponse` back to a web `Response` at the Cloudflare boundary, so application handlers can stay in Effect HTTP primitives.
-
-Request-scoped app services belong in the implementation layer that owns request semantics, such as `HttpRouter` middleware, RPC middleware, or explicit `Effect.provide(...)` inside a custom fetch effect. `Worker.make` stays focused on Cloudflare boundary services: `NativeRequest`, `HttpServerRequest`, `WorkerEnvironment`, `ExecutionContext`, and `WorkerContext`.
+```bash
+bun add effect-cf "effect@^4.0.0-beta.65"
+```
 
-For modules that need an `ExportedHandler` object instead of a `WorkerEntrypoint` class, use `Worker.makeFetchHandler`. This helper is fetch-only and intentionally does not accept Worker RPC methods.
+```bash
+pnpm add effect-cf "effect@^4.0.0-beta.65"
+```
 
-RPC contracts can be described as classes with `Worker.Tag` and `DurableObject.Tag`. Contract classes expose `.make(...)` for runtime entrypoint creation and `.Binding(...)` / `.Namespace(...)` for typed bindings. Bindings infer call types from the same code-owned contract classes. Definition-backed calls encode/decode arguments and success values with their Effect schemas at Worker and Durable Object boundaries.
+```bash
+npm install effect-cf "effect@^4.0.0-beta.65"
+```
 
-Binding helpers expose two RPC paths:
+## Goal
 
-- `call(...)` awaits one RPC result inside `Effect`. Use it for ordinary structured-cloneable values.
-- `rpc(...)` returns Cloudflare's native RPC thenable/stub without awaiting it, preserving promise pipelining.
-- `scopedCall(...)` awaits the result and registers any `Symbol.dispose` disposer with the current Effect `Scope`.
+Cloudflare APIs return promises and expose platform-specific bindings. `effect-cf` wraps those boundaries as `Context`, `Layer`, and `Effect` values so application code stays inside one managed Effect runtime.
 
-Client APIs use Cloudflare-style provider types, so object results expose pipelined property and method access. `ServerApi` remains available when a plain implementation-shaped `(...args) => Promise<A>` contract is needed.
+Runtime creation belongs at Cloudflare entrypoints, not inside binding helpers.
 
-## Current Exports
+## Exports
 
-- `Worker` - WorkerEntrypoint class factory, schema-backed RPC contract tags, and service binding helpers
-- `DurableObject` - Durable Object class factory, schema-backed RPC contract tags, and namespace helpers
-- `WorkerDefinition`, `DurableObjectDefinition` - compatibility exports for the lower-level definition modules
-- `DurableObjectNamespace` - typed Durable Object namespace binding helper
-- `DurableObjectState`, `DurableObjectStorage` - small Effect wrappers for Durable Object state, alarms, SQL, and embedded KV storage
-- `DurableObjectWebSocket` - Durable Object WebSocket upgrade helpers built on `WebSocketPair` and `acceptWebSocket`
-- `Binding` - low-level binding service helper
+- `Worker` - Worker entrypoint factory, request services, and typed Worker bindings
+- `DurableObject` - Durable Object entrypoint factory and typed namespace helpers
+- `DurableObjectState` / `DurableObjectStorage` - Effect wrappers for state, alarms, SQL, and embedded KV
+- `DurableObjectWebSocket` - WebSocket upgrade helpers for Durable Objects
 - `Kv` - typed KV namespace helper
-- `Rpc` - Cloudflare RPC type helpers, `RpcTarget` / `RpcStub` re-exports, and scoped disposal utilities
-- `ServiceBinding` - typed Worker-to-Worker service binding helper
-- `WorkerEnvironment` - request environment service
-- `WorkerConfig` - Effect `Config` helpers backed by Cloudflare worker `env`, including `layerWith` for custom env-to-config mapping
-
-## RPC Values
-
-Definition-backed RPC methods are intended for schema-backed structured values. If a Cloudflare RPC method returns a lifecycle-managed RPC object or stub, expose that through a lower-level binding API instead of a `WorkerDefinition` / `DurableObjectDefinition` method so disposal remains explicit.
+- `Rpc` - Cloudflare RPC type helpers and scoped disposal utilities
+- `WorkerConfig` - Effect `Config` helpers backed by Cloudflare `env`
 
-## Durable Object WebSocket Example
+## Worker Example
 
 ```ts
-const request = yield * Worker.NativeRequest;
+import { HttpServerResponse } from "effect";
+import { Worker } from "effect-cf";
 
-if (!Worker.isWebSocketUpgrade(request)) {
-  return new Response("Expected WebSocket upgrade", { status: 426 });
-}
-
-const upgrade =
-  yield *
-  DurableObjectWebSocket.acceptUpgrade({
-    tags: ["room:general"],
-    attachment: { roomId: "general" },
-  });
-
-return upgrade.response;
+export default Worker.make({
+  fetch: () => HttpServerResponse.text("ok"),
+});
 ```
 
 ## Durable Object Example
 
 ```ts
+import { Effect, Layer, Schema as S } from "effect";
+import { DurableObject, DurableObjectState } from "effect-cf";
+
 export class Counter extends DurableObject.Tag<Counter>()("Counter", {
   get: DurableObject.method({ success: S.Number }),
 }) {}
@@ -83,4 +69,8 @@ export const CounterDurableObject = Counter.make(Layer.empty, {
 });
 ```
 
-Define the Wrangler binding and SQLite migration in the application. This package intentionally does not replace `wrangler.jsonc`.
+Define Wrangler bindings and migrations in the consuming application.
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { Cause, Config, ConfigProvider, Context, Effect, Layer, Option, Schema, Scope } from "effect";
+import { Cause, Config, ConfigProvider, Context, DateTime, Duration, Effect, Layer, Option, Schema, Scope } from "effect";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
@@ -440,7 +440,7 @@ declare class DurableObjectState extends DurableObjectState_base {}
  */
 declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
 declare namespace DurableObjectDefinition_d_exports {
-  export { Api$3 as Api, Definition$3 as Definition, DurableObject$1 as DurableObject, HandlerEffect$3 as HandlerEffect, Handlers$3 as Handlers, NamespaceService, Options$3 as Options, ReservedMethodName$4 as ReservedMethodName, ServerApi$4 as ServerApi, Tag$3 as Tag, implement$3 as implement, make$4 as make, method$3 as method };
+  export { Api$3 as Api, Definition$3 as Definition, DurableObject$1 as DurableObject, HandlerEffect$3 as HandlerEffect, Handlers$3 as Handlers, NamespaceService, Options$3 as Options, ReservedMethodName$4 as ReservedMethodName, ServerApi$4 as ServerApi, Tag$4 as Tag, implement$3 as implement, make$4 as make, method$3 as method };
 }
 /**
  * RPC contract for a Durable Object class.
@@ -533,7 +533,7 @@ declare const make$4: <Id extends string, const MethodsShape extends Methods>(id
     readonly scopedCall: <Method extends (([Api$3<Definition$3<Id, MethodsShape>>] extends [never] ? Definition$3<Id, MethodsShape> extends infer T ? T extends Definition$3<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$4<T> : never : never : never : Api$3<Definition$3<Id, MethodsShape>>) extends infer T_2 ? { [Key in keyof T_2]-?: Key extends string ? T_2[Key] extends ((...args: any[]) => Promise<unknown>) ? Key : never : never } : never)[keyof ([Api$3<Definition$3<Id, MethodsShape>>] extends [never] ? Definition$3<Id, MethodsShape> extends infer T ? T extends Definition$3<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$4<T> : never : never : never : Api$3<Definition$3<Id, MethodsShape>>)]>(stub: DurableObjectStubClient<[Api$3<Definition$3<Id, MethodsShape>>] extends [never] ? Definition$3<Id, MethodsShape> extends infer T ? T extends Definition$3<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$4<T> : never : never : never : Api$3<Definition$3<Id, MethodsShape>>>, method: Method, ...args: AsyncMethodArgs<[Api$3<Definition$3<Id, MethodsShape>>] extends [never] ? Definition$3<Id, MethodsShape> extends infer T ? T extends Definition$3<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$4<T> : never : never : never : Api$3<Definition$3<Id, MethodsShape>>, Method>) => Effect.Effect<Awaited<Result<AsyncMethodSuccess<[Api$3<Definition$3<Id, MethodsShape>>] extends [never] ? Definition$3<Id, MethodsShape> extends infer T ? T extends Definition$3<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$4<T> : never : never : never : Api$3<Definition$3<Id, MethodsShape>>, Method>>>, unknown, _$effect_Scope0.Scope>;
   };
 };
-declare const Tag$3: <_Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape, ReservedMethodName$4>) => (abstract new () => object) & (Definition$3<Id, MethodsShape> & {
+declare const Tag$4: <_Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape, ReservedMethodName$4>) => (abstract new () => object) & (Definition$3<Id, MethodsShape> & {
   make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$3<ROut, Definition$3<Id, MethodsShape>>) => DurableObjectClass<BoundaryHandlers$1<ROut, Definition$3<Id, MethodsShape>>, ROut>;
   Namespace: <Self>() => <BindingId extends string>(bindingId: BindingId, binding: Omit<DurableObjectNamespaceBindingDefinition<Definition$3<Id, MethodsShape>>, "definition">) => _$effect_Context0.ServiceClass<Self, BindingId, DurableObjectNamespaceClient<[Api$3<Definition$3<Id, MethodsShape>>] extends [never] ? Definition$3<Id, MethodsShape> extends infer T ? T extends Definition$3<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$4<T> : never : never : never : Api$3<Definition$3<Id, MethodsShape>>>> & {
     "effect-cf/Binding": "effect-cf/Binding";
@@ -771,7 +771,7 @@ declare const Service$2: <Self, Api extends object = never>() => <Id extends str
   readonly scopedCall: <Method extends StubMethodKey<ApiOrDefinition$1<Api, Definition>>>(stub: DurableObjectStubClient<ApiOrDefinition$1<Api, Definition>>, method: Method, ...args: StubMethodArgs<ApiOrDefinition$1<Api, Definition>, Method>) => Effect.Effect<Awaited<Result<AsyncMethodSuccess<ApiOrDefinition$1<Api, Definition>, Method>>>, unknown, _$effect_Scope0.Scope>;
 };
 declare namespace WorkerDefinition_d_exports {
-  export { Api$2 as Api, BindingService, Definition$2 as Definition, HandlerEffect$2 as HandlerEffect, Handlers$2 as Handlers, Options$2 as Options, ReservedMethodName$2 as ReservedMethodName, ServerApi$3 as ServerApi, Tag$2 as Tag, Worker, implement$2 as implement, make$3 as make, method$2 as method };
+  export { Api$2 as Api, BindingService, Definition$2 as Definition, HandlerEffect$2 as HandlerEffect, Handlers$2 as Handlers, Options$2 as Options, ReservedMethodName$2 as ReservedMethodName, ServerApi$3 as ServerApi, Tag$3 as Tag, Worker, implement$2 as implement, make$3 as make, method$2 as method };
 }
 /**
  * RPC contract for a Worker service.
@@ -841,7 +841,7 @@ declare const make$3: <Id extends string, const MethodsShape extends Methods>(id
     readonly scopedCall: <Method extends (([Api$2<Definition$2<Id, MethodsShape>>] extends [never] ? Definition$2<Id, MethodsShape> extends infer T ? T extends Definition$2<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$3<T> : never : never : never : Api$2<Definition$2<Id, MethodsShape>>) extends infer T_2 ? { [Key in keyof T_2]-?: Key extends string ? T_2[Key] extends ((...args: any[]) => Promise<unknown>) ? Key : never : never } : never)[keyof ([Api$2<Definition$2<Id, MethodsShape>>] extends [never] ? Definition$2<Id, MethodsShape> extends infer T ? T extends Definition$2<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$3<T> : never : never : never : Api$2<Definition$2<Id, MethodsShape>>)]>(method: Method, ...args: AsyncMethodArgs<[Api$2<Definition$2<Id, MethodsShape>>] extends [never] ? Definition$2<Id, MethodsShape> extends infer T ? T extends Definition$2<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$3<T> : never : never : never : Api$2<Definition$2<Id, MethodsShape>>, Method>) => Effect.Effect<Awaited<Result<AsyncMethodSuccess<[Api$2<Definition$2<Id, MethodsShape>>] extends [never] ? Definition$2<Id, MethodsShape> extends infer T ? T extends Definition$2<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$3<T> : never : never : never : Api$2<Definition$2<Id, MethodsShape>>, Method>>>, unknown, BindingService<BindingId, Definition$2<Id, MethodsShape>> | _$effect_Scope0.Scope>;
   };
 };
-declare const Tag$2: <_Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape, ReservedMethodName$2>) => (abstract new () => object) & (Definition$2<Id, MethodsShape> & {
+declare const Tag$3: <_Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape, ReservedMethodName$2>) => (abstract new () => object) & (Definition$2<Id, MethodsShape> & {
   make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$2<ROut, Definition$2<Id, MethodsShape>>) => WorkerClass<BoundaryHandlers<ROut, Definition$2<Id, MethodsShape>>, ROut>;
   Binding: <Self>() => <BindingId extends string>(bindingId: BindingId, binding: Omit<ServiceBindingDefinition<Definition$2<Id, MethodsShape>>, "definition">) => _$effect_Context0.ServiceClass<Self, BindingId, ServiceBindingClient<[Api$2<Definition$2<Id, MethodsShape>>] extends [never] ? Definition$2<Id, MethodsShape> extends infer T ? T extends Definition$2<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$3<T> : never : never : never : Api$2<Definition$2<Id, MethodsShape>>>> & {
     "effect-cf/Binding": "effect-cf/Binding";
@@ -994,7 +994,7 @@ declare const Service$1: <Self, Api extends object = never>() => <Id extends str
   readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Awaited<Result<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>>, unknown, Self | _$effect_Scope0.Scope>;
 };
 declare namespace Worker_d_exports {
-  export { Api$1 as Api, Definition$1 as Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect$1 as HandlerEffect, Handlers$1 as Handlers, NativeRequest, Options$1 as Options, ReservedMethodName, RpcHandlers$1 as RpcHandlers, ServerApi$2 as ServerApi, Tag$1 as Tag, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$1 as implement, isWebSocketUpgrade, make$2 as make, makeFetchHandler, method$1 as method, renderHttpResponse };
+  export { Api$1 as Api, Definition$1 as Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect$1 as HandlerEffect, Handlers$1 as Handlers, NativeRequest, Options$1 as Options, ReservedMethodName, RpcHandlers$1 as RpcHandlers, ServerApi$2 as ServerApi, Tag$2 as Tag, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$1 as implement, isWebSocketUpgrade, make$2 as make, makeFetchHandler, method$1 as method, renderHttpResponse };
 }
 declare const ExecutionContext_base: Context.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
 declare class ExecutionContext extends ExecutionContext_base {}
@@ -1037,7 +1037,7 @@ interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
 declare const renderHttpResponse: <A extends HttpServerResponse.HttpServerResponse, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Response, E, R>;
 declare const make$2: <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, Rpc>) => WorkerClass<Rpc, ROut>;
 declare const makeFetchHandler: <ROut, LayerError, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut>) => FetchHandler<Env>;
-declare const Tag$1: <_Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape, ReservedMethodName$2>) => (abstract new () => object) & (Definition$2<Id, MethodsShape> & {
+declare const Tag$2: <_Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape, ReservedMethodName$2>) => (abstract new () => object) & (Definition$2<Id, MethodsShape> & {
   make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$2<ROut, Definition$2<Id, MethodsShape>>) => WorkerClass<{ readonly [Key in keyof MethodsShape]: (...args: Array<unknown>) => WorkerRpcHandler<ROut, _$effect_Schema0.Codec.Encoded<MethodsShape[Key]["success"]>> }, ROut>;
   Binding: <Self>() => <BindingId extends string>(bindingId: BindingId, binding: Omit<ServiceBindingDefinition<Definition$2<Id, MethodsShape>>, "definition">) => Context.ServiceClass<Self, BindingId, ServiceBindingClient<[Api$2<Definition$2<Id, MethodsShape>>] extends [never] ? Definition$2<Id, MethodsShape> extends infer T ? T extends Definition$2<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$3<T> : never : never : never : Api$2<Definition$2<Id, MethodsShape>>>> & {
     "effect-cf/Binding": "effect-cf/Binding";
@@ -1076,7 +1076,7 @@ type Handlers$1<ROut, Self extends Definition$2.Any> = Handlers$2<ROut, Self>;
 type Options$1<ROut, Self extends Definition$2.Any> = Options$2<ROut, Self>;
 type HandlerEffect$1<ROut, Self extends Definition$2.Any, Key extends keyof Self["methods"]> = HandlerEffect$2<ROut, Self, Key>;
 declare namespace DurableObject_d_exports {
-  export { Api, Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcShape, HandlerEffect, Handlers, Options, RpcHandlers, ServerApi$1 as ServerApi, Tag, implement, make$1 as make, method };
+  export { Api, Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcShape, HandlerEffect, Handlers, Options, RpcHandlers, ServerApi$1 as ServerApi, Tag$1 as Tag, implement, make$1 as make, method };
 }
 type RuntimeContext<ROut> = DurableObjectState | WorkerEnvironment | ROut;
 type HandlerContext<ROut> = RuntimeContext<ROut> | Scope.Scope;
@@ -1099,6 +1099,14 @@ interface DurableObjectOptions<ROut, Rpc extends DurableObjectRpc<ROut>> {
   readonly rpc?: Rpc;
   /** Optional fetch handler for HTTP/WebSocket requests. */
   readonly fetch?: Effect.Effect<Response, unknown, FetchContext<ROut>>;
+  /**
+   * Optional logical alarm processing effect.
+   *
+   * This runs before `alarm` and should be built with helpers such as
+   * `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 alarm?: (alarmInfo?: globalThis.AlarmInvocationInfo) => Effect.Effect<void, unknown, HandlerContext<ROut>>;
   readonly webSocketMessage?: (socket: WebSocket, message: string | ArrayBuffer) => Effect.Effect<void, unknown, HandlerContext<ROut>>;
   readonly webSocketClose?: (socket: WebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, unknown, HandlerContext<ROut>>;
@@ -1112,7 +1120,7 @@ type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state:
  * Creates a Durable Object class backed by a single managed Effect runtime.
  */
 declare const make$1: <ROut, LayerError, const Rpc extends DurableObjectRpc<ROut> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options?: DurableObjectOptions<ROut, Rpc>) => DurableObjectClass<Rpc, ROut>;
-declare const Tag: <_Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape, ReservedMethodName$4>) => (abstract new () => object) & (Definition$3<Id, MethodsShape> & {
+declare const Tag$1: <_Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape, ReservedMethodName$4>) => (abstract new () => object) & (Definition$3<Id, MethodsShape> & {
   make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$3<ROut, Definition$3<Id, MethodsShape>>) => DurableObjectClass<{ readonly [Key in keyof MethodsShape]: (...args: Array<unknown>) => DurableObjectHandler<ROut, _$effect_Schema0.Codec.Encoded<MethodsShape[Key]["success"]>> }, ROut>;
   Namespace: <Self>() => <BindingId extends string>(bindingId: BindingId, binding: Omit<DurableObjectNamespaceBindingDefinition<Definition$3<Id, MethodsShape>>, "definition">) => _$effect_Context0.ServiceClass<Self, BindingId, DurableObjectNamespaceClient<[Api$3<Definition$3<Id, MethodsShape>>] extends [never] ? Definition$3<Id, MethodsShape> extends infer T ? T extends Definition$3<Id, MethodsShape> ? T extends Definition$4.Any ? ServerApi$4<T> : never : never : never : Api$3<Definition$3<Id, MethodsShape>>>> & {
     "effect-cf/Binding": "effect-cf/Binding";
@@ -1176,6 +1184,330 @@ type Api<Self extends Definition$3.Any> = Api$3<Self>;
 type Handlers<ROut, Self extends Definition$3.Any> = Handlers$3<ROut, Self>;
 type Options<ROut, Self extends Definition$3.Any> = Options$3<ROut, Self>;
 type HandlerEffect<ROut, Self extends Definition$3.Any, Key extends keyof Self["methods"]> = HandlerEffect$3<ROut, Self, Key>;
+declare namespace DurableObjectAlarm_d_exports {
+  export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRetryPolicy, AlarmScheduler, DefinedAlarmEvent, DefinedAlarmHandlers, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsMode, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, StoredAlarmDecodeError, define, process, processDue };
+}
+/**
+ * JSON-serializable alarm payload stored with each scheduled alarm.
+ *
+ * Payloads are intentionally opaque to `DurableObjectAlarm`. Consumers should use
+ * stable `tag` values to route due alarms and then decode the payload for that
+ * tag in their own domain layer.
+ */
+type AlarmPayload = Schema.Json;
+declare const InvalidAlarmRefError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "InvalidAlarmRefError";
+} & Readonly<A>;
+declare class InvalidAlarmRefError extends InvalidAlarmRefError_base<{
+  readonly cause: unknown;
+}> {}
+declare const InvalidAlarmPayloadError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "InvalidAlarmPayloadError";
+} & Readonly<A>;
+declare class InvalidAlarmPayloadError extends InvalidAlarmPayloadError_base<{
+  readonly cause: unknown;
+}> {}
+declare const InvalidRepeatEveryError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "InvalidRepeatEveryError";
+} & Readonly<A>;
+declare class InvalidRepeatEveryError extends InvalidRepeatEveryError_base<{
+  readonly cause: unknown;
+}> {}
+declare const InvalidProcessDueAlarmsOptionsError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "InvalidProcessDueAlarmsOptionsError";
+} & Readonly<A>;
+declare class InvalidProcessDueAlarmsOptionsError extends InvalidProcessDueAlarmsOptionsError_base<{
+  readonly cause: unknown;
+}> {}
+declare const StoredAlarmDecodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "StoredAlarmDecodeError";
+} & Readonly<A>;
+declare class StoredAlarmDecodeError extends StoredAlarmDecodeError_base<{
+  readonly cause: unknown;
+  readonly storageId: string;
+}> {}
+type DurableObjectAlarmError = InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidProcessDueAlarmsOptionsError | InvalidRepeatEveryError | StorageOperationError | StoredAlarmDecodeError;
+/**
+ * Events handled by `processDueAlarms`.
+ *
+ * `AlarmDue` represents one durable alarm whose scheduled time is now due. The
+ * `tag` is the consumer-owned routing key, while `id` is the stable alarm id
+ * within that tag.
+ *
+ * `scheduledAt` is the logical due-after timestamp from durable storage. It is
+ * not expected to match the current Durable Object alarm invocation time,
+ * especially during retries. Retries re-scan durable rows with `run_at <= now`
+ * and identify logical events by `{ tag, id }`.
+ *
+ * @example Handling events by tag
+ * ```ts
+ * yield* durableObjectAlarm.processDueAlarms((event) =>
+ *   event.tag === "heartbeat"
+ *     ? heartbeatManager.handleAlarmEvent(event).pipe(Effect.asVoid)
+ *     : Effect.void
+ * );
+ * ```
+ */
+declare const DurableObjectAlarmEvent: Schema.TaggedUnion<{
+  readonly AlarmDue: Schema.TaggedStruct<"AlarmDue", {
+    readonly id: Schema.NonEmptyString;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly scheduledAt: Schema.DateTimeUtc;
+    readonly tag: Schema.NonEmptyString;
+  }>;
+}>;
+type DurableObjectAlarmEvent = typeof DurableObjectAlarmEvent.Type;
+/**
+ * Stable reference for a scheduled alarm.
+ *
+ * The pair of `tag` and `id` is the durable identity. Scheduling another alarm
+ * with the same pair replaces the previous alarm, and cancellation uses the
+ * same pair.
+ *
+ * @example Cancel an alarm
+ * ```ts
+ * yield* durableObjectAlarm.cancelAlarm({
+ *   tag: "connection-reconnect-grace",
+ *   id: "reconnect-grace-check",
+ * });
+ * ```
+ */
+type AlarmRef<Tag extends string = string> = {
+  readonly id: string;
+  readonly tag: Tag;
+};
+/**
+ * Input for scheduling or replacing an alarm.
+ *
+ * `runAt` is the absolute first fire time. `repeatEvery` can be any Effect
+ * `Duration.Input`, including strings like `"5 seconds"`, numbers interpreted
+ * as milliseconds, or `Duration` values.
+ *
+ * @example One-shot alarm
+ * ```ts
+ * const now = yield* DateTime.now;
+ *
+ * yield* durableObjectAlarm.scheduleAlarm({
+ *   tag: "connection-reconnect-grace",
+ *   id: "reconnect-grace-check",
+ *   runAt: DateTime.add(now, { seconds: 15 }),
+ *   payload: { reason: "socket-closed" },
+ * });
+ * ```
+ *
+ * @example Repeating alarm
+ * ```ts
+ * const now = yield* DateTime.now;
+ *
+ * yield* durableObjectAlarm.scheduleAlarm({
+ *   tag: "heartbeat",
+ *   id: "heartbeat-check",
+ *   runAt: DateTime.add(now, { seconds: 5 }),
+ *   repeatEvery: "5 seconds",
+ *   payload: null,
+ * });
+ * ```
+ */
+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> {
+  /** Maximum due rows to load and process in one invocation. Defaults to 100. */
+  readonly limit?: number;
+  /**
+   * Failure isolation mode. Defaults to `isolated` so one poison logical alarm
+   * does not block unrelated maintenance work.
+   */
+  readonly mode?: ProcessDueAlarmsMode;
+  /**
+   * Callback for logical handler/decode failures. Return a failure action to
+   * override the global failure behavior for this row.
+   */
+  readonly onFailure?: (failure: ProcessDueAlarmsFailure) => Effect.Effect<ProcessDueAlarmsFailureAction | void, OnFailureE, OnFailureR>;
+  /**
+   * Delay before retrying a failed logical row in isolated mode. Defaults to 30
+   * seconds. Ignored by ordered mode unless supplied explicitly.
+   *
+   * Retrying updates only the selected occurrence, so replacements scheduled by
+   * a long-running handler are not clobbered by failure handling.
+   */
+  readonly retryFailedAfter?: Duration.Input;
+}
+/**
+ * Handler invoked for each due alarm before that alarm is acknowledged.
+ *
+ * If the handler fails, `DurableObjectAlarm` leaves the row due and fails the alarm
+ * processing effect. Cloudflare can then retry the Durable Object alarm handler,
+ * and the scheduler will find the same logical row again because `run_at` is
+ * still less than or equal to the retry time.
+ */
+type ProcessDueAlarmsHandler<R = never, E = never> = (event: DurableObjectAlarmEvent) => Effect.Effect<void, E, R>;
+/**
+ * Durable alarm scheduler API.
+ *
+ * This service only owns scheduling semantics. It does not publish, subscribe,
+ * or dispatch events to consumers. Durable Object alarm handlers should pass a
+ * domain handler to `processDueAlarms`; rows are acknowledged only after that
+ * handler succeeds.
+ *
+ * This service must be the only code path that owns `storage.setAlarm()` inside
+ * a Durable Object instance. Cloudflare exposes one platform alarm timestamp per
+ * object, so another scheduler in the same object can clobber this service's
+ * reconciled alarm timestamp.
+ *
+ * @example Durable Object alarm handler
+ * ```ts
+ * const onAlarm = Effect.gen(function* () {
+ *   const durableObjectAlarm = yield* DurableObjectAlarm;
+ *
+ *   yield* durableObjectAlarm.processDueAlarms((event) =>
+ *     Effect.gen(function* () {
+ *       if (event.tag === "heartbeat") {
+ *         yield* heartbeatManager.handleAlarmEvent(event);
+ *         return;
+ *       }
+ *
+ *       if (event.tag === "connection-reconnect-grace") {
+ *         yield* connectionManager.expireReconnectGracePeriods();
+ *       }
+ *     })
+ *   );
+ * });
+ * ```
+ */
+type AlarmScheduler = {
+  /**
+   * Cancel a scheduled alarm by `{ tag, id }`.
+   *
+   * This is idempotent. Cancelling a missing alarm is a no-op. The underlying
+   * Durable Object alarm is reconciled afterward.
+   */
+  readonly cancelAlarm: (input: AlarmRef) => Effect.Effect<void, InvalidAlarmRefError | StorageOperationError>;
+  /**
+   * Process due alarms according to `Clock.currentTimeMillis`.
+   *
+   * Each row is acknowledged only after `handle` succeeds. One-shot alarms are
+   * then deleted. Repeating alarms are rescheduled to `acknowledgedAt +
+   * repeatEvery`, which intentionally behaves as delay-after-success rather
+   * than fixed-cadence catch-up. Acknowledgements are conditional on the stored
+   * row still matching the selected occurrence, so a handler that reschedules
+   * the same `{ tag, id }` will not have its replacement clobbered by the old
+   * acknowledgement.
+   *
+   * Processing is ordered by `runAt` and stable alarm id. By default, logical
+   * handler/decode failures are isolated to the failing row: the row is retried
+   * after `retryFailedAfter`, later due rows still run, and the result reports
+   * both handled and failed rows. Use `mode: "ordered"` when a workflow
+   * intentionally requires strict head-of-line blocking.
+   *
+   * Handlers must still be idempotent: Cloudflare alarms are at-least-once, and
+   * if a handler succeeds but the acknowledgement write fails, the logical event
+   * can be delivered again.
+   */
+  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>;
+  /**
+   * Schedule or replace an alarm by `{ tag, id }`.
+   *
+   * The durable row write and underlying platform alarm reconciliation are run
+   * in one Durable Object storage transaction, so a failed `setAlarm` rolls back
+   * the logical schedule instead of leaving a stored-but-unarmed alarm.
+   */
+  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>;
+declare const process: <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>;
+/**
+ * SQLite-backed Durable Object alarm scheduler.
+ *
+ * `DurableObjectAlarm` stores alarms in the current Durable Object's SQLite storage
+ * and keeps the platform alarm set to the earliest pending scheduled alarm. The
+ * platform alarm timestamp is only a wake-up hint; logical event identity comes
+ * from persisted `{ tag, id }` rows.
+ *
+ * Retry safety depends on acknowledgement ordering. `processDueAlarms` runs the
+ * caller's handler first and only then conditionally deletes or advances the
+ * same selected row. By default, handler failures are isolated: the failed row
+ * is retried after a delay, later due rows continue, and the platform alarm is
+ * reconciled once at the end. Use `mode: "ordered"` for strict workflows where
+ * one failed logical alarm should block later due alarms.
+ *
+ * Provide `DurableObjectAlarm.layer` anywhere `DurableObjectState` is available.
+ *
+ * @example Providing the service
+ * ```ts
+ * const program = Effect.gen(function* () {
+ *   const durableObjectAlarm = yield* DurableObjectAlarm;
+ *   const now = yield* DateTime.now;
+ *
+ *   yield* durableObjectAlarm.scheduleAlarm({
+ *     tag: "heartbeat",
+ *     id: "heartbeat-check",
+ *     runAt: DateTime.add(now, { seconds: 5 }),
+ *     repeatEvery: Duration.seconds(5),
+ *     payload: null,
+ *   });
+ * }).pipe(Effect.provide(DurableObjectAlarm.layer));
+ * ```
+ *
+ * @example Processing due alarms
+ * ```ts
+ * const handledEvents = yield* durableObjectAlarm.processDueAlarms((event) =>
+ *   Effect.gen(function* () {
+ *     if (event.tag === "heartbeat") {
+ *       yield* heartbeatManager.handleAlarmEvent(event);
+ *     }
+ *   })
+ * );
+ * ```
+ */
+declare class DurableObjectAlarm extends DurableObjectAlarm_base {
+  static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState>;
+}
 declare namespace DurableObjectRpcWebSocket_d_exports {
   export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, LayerOptions, NativeWebSocketMessage, layer };
 }
@@ -1377,4 +1709,4 @@ declare const Service: <Self>() => <Id extends string, Key, Value, EncodedValue>
   unsafeRaw: () => Effect.Effect<KVNamespace<string>, never, Self>;
 };
 //#endregion
-export { Binding_d_exports as Binding, DurableObject_d_exports as DurableObject, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Kv_d_exports as Kv, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment };
+export { Binding_d_exports as Binding, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Kv_d_exports as Kv, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment };