effect-cf 0.0.3 → 0.1.0

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.
@@ -807,7 +807,7 @@ type BoundaryHandlers<ROut, Self extends Definition$2.Any> = { readonly [Key in
 /**
  * Worker constructor options for a specific RPC definition.
  */
-interface Options$2<ROut, Self extends Definition$2.Any, RRequest = never, RequestLayerError = never> extends Omit<WorkerOptions<ROut, Handlers$2<ROut, Self>, RRequest, RequestLayerError>, "rpc"> {
+interface Options$2<ROut, Self extends Definition$2.Any> extends Omit<WorkerOptions<ROut, Handlers$2<ROut, Self>>, "rpc"> {
   readonly rpc: Handlers$2<ROut, Self>;
 }
 /**
@@ -815,7 +815,7 @@ interface Options$2<ROut, Self extends Definition$2.Any, RRequest = never, Reque
  */
 declare const method$2: typeof method$4;
 declare const make$3: <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape, ReservedMethodName$2>) => Definition$2<Id, MethodsShape> & {
-  make: <ROut, LayerError, RRequest = never, RequestLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$2<ROut, Definition$2<Id, MethodsShape>, RRequest, RequestLayerError>) => WorkerClass<BoundaryHandlers<ROut, Definition$2<Id, MethodsShape>>, ROut>;
+  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";
     binding: string;
@@ -841,8 +841,8 @@ 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> & {
-  make: <ROut, LayerError, RRequest = never, RequestLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$2<ROut, Definition$2<Id, MethodsShape>, RRequest, RequestLayerError>) => WorkerClass<BoundaryHandlers<ROut, Definition$2<Id, MethodsShape>>, ROut>;
+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";
     binding: string;
@@ -869,7 +869,7 @@ declare const Tag$2: <_Self>() => <Id extends string, const MethodsShape extends
   };
 });
 declare const Worker: <_Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape, ReservedMethodName$2>) => (abstract new () => object) & (Definition$2<Id, MethodsShape> & {
-  make: <ROut, LayerError, RRequest = never, RequestLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$2<ROut, Definition$2<Id, MethodsShape>, RRequest, RequestLayerError>) => WorkerClass<BoundaryHandlers<ROut, Definition$2<Id, MethodsShape>>, ROut>;
+  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";
     binding: string;
@@ -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 {}
@@ -1021,18 +1021,11 @@ type WorkerRpcHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerRpcCo
 type WorkerRpc<ROut> = Record<string, (...args: Array<any>) => WorkerRpcHandler<ROut>>;
 type WorkerRpcShape<Rpc extends WorkerRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, WorkerRpcContext<ROut>>) ? (...args: Args) => Promise<A> : never };
 type RpcHandlers$1<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof WorkerEntrypoint ? never : Key extends string ? Key extends ReservedMethodName ? never : [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<unknown>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => WorkerRpcHandler<ROut, A> : never };
-interface WorkerOptions<ROut, Rpc extends WorkerRpc<ROut>, RRequest = never, RequestLayerError = never> {
-  readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<ROut | RRequest>>;
-  /**
-   * Per-request services provided while evaluating the fetch handler.
-   *
-   * This scope closes when the handler produces a `Response`; it is not kept
-   * open until a streaming response body is consumed by the platform.
-   */
-  readonly requestLayer?: Layer.Layer<RRequest, RequestLayerError, WorkerFetchContext<ROut>>;
+interface WorkerOptions<ROut, Rpc extends WorkerRpc<ROut>> {
+  readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<ROut>>;
   readonly rpc?: Rpc;
 }
-type FetchWorkerOptions<ROut, RRequest = never, RequestLayerError = never> = Omit<WorkerOptions<ROut, Record<never, never>, RRequest, RequestLayerError>, "rpc"> & {
+type FetchWorkerOptions<ROut> = Omit<WorkerOptions<ROut, Record<never, never>>, "rpc"> & {
   readonly rpc?: never;
 };
 type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (ctx: globalThis.ExecutionContext, env: WorkerEnv) => WorkerEntrypoint<WorkerEnv> & {
@@ -1042,10 +1035,10 @@ interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
   readonly fetch: (request: Request, env: Env, ctx: globalThis.ExecutionContext) => Promise<Response>;
 }
 declare const renderHttpResponse: <A extends HttpServerResponse.HttpServerResponse, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Response, E, R>;
-declare const make$2: <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>, RRequest = never, RequestLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, Rpc, RRequest, RequestLayerError>) => WorkerClass<Rpc, ROut>;
-declare const makeFetchHandler: <ROut, LayerError, RRequest = never, RequestLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, RRequest, RequestLayerError>) => FetchHandler<Env>;
-declare const Tag$1: <_Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape, ReservedMethodName$2>) => (abstract new () => object) & (Definition$2<Id, MethodsShape> & {
-  make: <ROut, LayerError, RRequest = never, RequestLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$2<ROut, Definition$2<Id, MethodsShape>, RRequest, RequestLayerError>) => WorkerClass<{ readonly [Key in keyof MethodsShape]: (...args: Array<unknown>) => WorkerRpcHandler<ROut, _$effect_Schema0.Codec.Encoded<MethodsShape[Key]["success"]>> }, ROut>;
+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$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";
     binding: string;
@@ -1080,10 +1073,10 @@ declare namespace Definition$1 {
 type ServerApi$2<Self extends Definition$2.Any> = ServerApi$3<Self>;
 type Api$1<Self extends Definition$2.Any> = Api$2<Self>;
 type Handlers$1<ROut, Self extends Definition$2.Any> = Handlers$2<ROut, Self>;
-type Options$1<ROut, Self extends Definition$2.Any, RRequest = never, RequestLayerError = never> = Options$2<ROut, Self, RRequest, RequestLayerError>;
+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;
@@ -1106,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>>;
@@ -1119,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";
@@ -1183,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 };
 }
@@ -1384,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 };