effect-cf 0.53.0 → 0.55.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # effect-cf
 
+## 0.55.0
+
+### Minor Changes
+
+- [#211](https://github.com/danieljvdm/effect-cf/pull/211) [`2764143`](https://github.com/danieljvdm/effect-cf/commit/276414374c3fe71f619c26ef1c447ab0f52f9ab4) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Keep in-flight Durable Object work recoverable through a configurable short alarm deadline while preserving hourly parked recovery. Coalesce native deliveries with active processing without starting another pass.
+
+## 0.54.0
+
+### Minor Changes
+
+- [#208](https://github.com/danieljvdm/effect-cf/pull/208) [`be9befa`](https://github.com/danieljvdm/effect-cf/commit/be9befaf7e07cdfff2a5c92e886065725edf90e6) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add an Effect-native RateLimit binding client with service layers, native admission outcomes, and typed operation errors preserving the original cause.
+
+- [#210](https://github.com/danieljvdm/effect-cf/pull/210) [`abcdb42`](https://github.com/danieljvdm/effect-cf/commit/abcdb4204b3b32d7e979f449e36d9727693e5d73) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Compose typed alarm services with `DurableObjectAlarm.mergeAll` under one native Durable Object alarm owner. Use `lifecycle: "manual"` for queues that own completion and retry policy, and `deferWakes` to coalesce native alarm changes during processing while retaining durable recovery.
+
+  Enable `ScheduleConfiguration.dispatchAfterEvent` to dispatch due alarms after RPC/fetch responses unwind, using the same scoped pass as native delivery. Overlapping native alarms join the pass, deferred regions delay dispatch, and durable native scheduling retains recovery authority. Cold Objects can deliver responses later because post-response processing shares the same CPU.
+
 ## 0.53.0
 
 ### Minor Changes

package/README.md

@@ -220,6 +220,12 @@ Applications own SERVER spans. Override the exported `DurableObject.RunSymbol` o
 
 This metadata belongs only to the live native call. Do not store it in domain envelopes, alarms, queues, or WebSocket attachments, or reuse it for resumed work. Sampling and exporter configuration remain application choices.
 
+## Native rate limiting
+
+Use `RateLimit.Tag` or `RateLimit.make` to call a native binding as an Effect:
+`yield* requests.limit({ key })` returns `{ success }`, including ordinary denial.
+See [binding configuration and usage](../../docs/rate-limiting.md).
+
 ## API
 
 See the [exports](src/index.ts) and [tests](https://github.com/danieljvdm/effect-cf/tree/main/packages/effect-cf/tests) for the remaining APIs.

package/dist/DurableObject.d.mts

@@ -94,6 +94,7 @@ type DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never, Rpc
  * Cloudflare `DurableObject` constructor produced by {@link make}.
  */
 type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state: globalThis.DurableObjectState, env: WorkerEnv) => DurableObject<WorkerEnv> & DurableObjectRpcApi<Rpc, ROut> & {
+  alarm(alarmInfo?: globalThis.AlarmInvocationInfo): Promise<void> | void;
   [RunSymbol]<A, E>(effect: Effect.Effect<A, E, HandlerContext<ROut>>, options?: RunOptions): Promise<A>;
 };
 /**

package/dist/DurableObject.mjs

@@ -3,10 +3,10 @@ import { fromWebSocket } from "./DurableObjectWebSocket.mjs";
 import { DurableObjectState, fromDurableObjectState } from "./DurableObjectState.mjs";
 import { reservedMethodNames as reservedMethodNames$1 } from "./RpcDefinition.mjs";
 import { assumeEntrypointClass, defineEntrypointRpcMethods } from "./internal/Entrypoint.mjs";
-import { makeEntrypointRuntime, runEventPromise } from "./internal/Runtime.mjs";
+import { makeEntrypointRuntime, runEventPromise, scopeEvent } from "./internal/Runtime.mjs";
 import { scheduleTelemetryFlush as scheduleTelemetryFlush$1 } from "./internal/Telemetry.mjs";
 import { NativeRequest } from "./Worker.mjs";
-import { DurableObjectAlarm } from "./DurableObjectAlarm.mjs";
+import { DispatchAfterEvent, DurableObjectAlarm, HasDueAlarms, RunAlarm, dispatchRawAlarm } from "./DurableObjectAlarm.mjs";
 import { Tag, implement, method, native } from "./DurableObjectDefinition.mjs";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -28,7 +28,7 @@ const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
 const scheduleTelemetryFlush = scheduleTelemetryFlush$1((flush) => Effect.flatMap(DurableObjectState, (state) => state.waitUntil(flush)));
 function make(layer, options = {}) {
 	const registration = options.alarms !== void 0 && !Effect.isEffect(options.alarms) ? options.alarms : void 0;
-	const logicalAlarms = (registration?.run ?? (Effect.isEffect(options.alarms) ? options.alarms : void 0))?.pipe(Effect.asVoid);
+	const legacyAlarms = Effect.isEffect(options.alarms) ? options.alarms.pipe(Effect.asVoid) : void 0;
 	class EffectDurableObject extends DurableObject {
 		runtime;
 		constructor(state, env) {
@@ -46,8 +46,18 @@ function make(layer, options = {}) {
 			const eventLayer = runOptions.eventLayer === false ? void 0 : options.eventLayer;
 			const parent = runOptions.rpc?.parent;
 			const parentSpan = parent === void 0 ? void 0 : Tracer.externalSpan(parent);
-			if (eventLayer === void 0) return runEventPromise(this.runtime, effect, void 0, parentSpan, runOptions.onFailure);
-			return runEventPromise(this.runtime, effect, eventLayer, parentSpan, runOptions.onFailure);
+			const afterResponse = runOptions.event === "rpc" || runOptions.event === "fetch";
+			let dispatchAfterEvent = false;
+			const handler = afterResponse ? effect.pipe(Effect.onExit(() => Effect.flatMap(DurableObjectAlarm, (alarms) => Effect.map(alarms[DispatchAfterEvent], (enabled) => {
+				dispatchAfterEvent = enabled;
+			})))) : effect;
+			let response;
+			if (eventLayer === void 0) response = runEventPromise(this.runtime, handler, void 0, parentSpan, runOptions.onFailure);
+			else response = runEventPromise(this.runtime, handler, eventLayer, parentSpan, runOptions.onFailure);
+			if (!afterResponse) return response;
+			return response.finally(() => {
+				if (dispatchAfterEvent) this.ctx.waitUntil(Effect.runPromise(Effect.yieldNow.pipe(Effect.andThen(Effect.promise(() => this.#runAlarm(false))))));
+			});
 		}
 		fetch(request) {
 			const fetchHandler = options.fetch;
@@ -55,12 +65,24 @@ function make(layer, options = {}) {
 			return this[RunSymbol](Effect.provideService(fetchHandler, NativeRequest, request), { event: "fetch" });
 		}
 		alarm(alarmInfo) {
-			const rawAlarm = options.alarm?.(alarmInfo);
-			const alarmEffect = logicalAlarms !== void 0 && rawAlarm !== void 0 ? Effect.gen(function* () {
-				yield* logicalAlarms;
-				yield* rawAlarm;
-			}) : logicalAlarms ?? rawAlarm;
-			if (alarmEffect !== void 0) return this[RunSymbol](alarmEffect.pipe(Effect.onExit(() => scheduleTelemetryFlush)), { event: "alarm" });
+			return this.#runAlarm(true, alarmInfo);
+		}
+		#runAlarm(native, alarmInfo) {
+			const event = (beginDispatch) => {
+				const alarmEffect = Effect.gen(function* () {
+					const alarms = yield* DurableObjectAlarm;
+					if (!native && !(yield* alarms[HasDueAlarms])) return;
+					const rawAlarm = options.alarm?.(alarmInfo);
+					const customAlarm = legacyAlarms === void 0 ? rawAlarm ?? Effect.void : legacyAlarms.pipe(Effect.andThen(rawAlarm ?? Effect.void));
+					yield* beginDispatch;
+					yield* registration === void 0 || rawAlarm !== void 0 ? dispatchRawAlarm(customAlarm, registration) : registration.run.pipe(Effect.asVoid);
+				}).pipe(Effect.onExit(() => scheduleTelemetryFlush));
+				return scopeEvent(options.eventLayer === void 0 ? alarmEffect : alarmEffect.pipe(Effect.provide(options.eventLayer, { local: true })));
+			};
+			return this[RunSymbol](Effect.flatMap(DurableObjectAlarm, (alarms) => alarms[RunAlarm](event, native)), {
+				event: "alarm",
+				eventLayer: false
+			});
 		}
 		webSocketMessage(socket, message) {
 			if (options.webSocketMessage !== void 0) return this[RunSymbol](options.webSocketMessage(fromWebSocket(socket), message), { event: "webSocketMessage" });

package/dist/DurableObjectAlarm.d.mts

@@ -7,7 +7,7 @@ import * as Layer from "effect/Layer";
 import * as Duration from "effect/Duration";
 import * as DateTime from "effect/DateTime";
 declare namespace DurableObjectAlarm_d_exports {
-  export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmParked, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRegistration, AlarmReporter, AlarmRetryPolicy, AlarmScheduler, AlarmService, AlarmStatus, AlarmTagClass, AlarmTransaction, DEFAULT_MIN_REPEAT_INTERVAL_MS, DefinedAlarmEvent, DefinedAlarmHandlers, DefinedAlarmScheduler, DefinedAlarmTransaction, DefinedScheduleAlarmInput, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, InvalidScheduleConfigurationError, MIN_REPEAT_INTERVAL_MS, MIN_RETRY_DELAY_MS, PARKED_RETRY_DELAY_MS, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, ScheduleConfiguration, StoredAlarmDecodeError, Tag, UNCHANGED_ATTEMPT_BUDGET, define, processDue };
+  export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmLifecycle, AlarmParked, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRegistration, AlarmReporter, AlarmRetryPolicy, AlarmScheduler, AlarmService, AlarmStatus, AlarmTagClass, AlarmTransaction, DEFAULT_MIN_REPEAT_INTERVAL_MS, DefinedAlarmEvent, DefinedAlarmHandlers, DefinedAlarmScheduler, DefinedAlarmTransaction, DefinedScheduleAlarmInput, DispatchAfterEvent, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, HasDueAlarms, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidAlarmRegistrationError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, InvalidScheduleConfigurationError, MIN_REPEAT_INTERVAL_MS, MIN_RETRY_DELAY_MS, PARKED_RETRY_DELAY_MS, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, RunAlarm, ScheduleAlarmInput, ScheduleConfiguration, StoredAlarmDecodeError, Tag, UNCHANGED_ATTEMPT_BUDGET, define, dispatchRawAlarm, mergeAll, processDue };
 }
 declare const MIN_RETRY_DELAY_MS = 1000;
 /** Default unchanged-attempt budget. */
@@ -19,6 +19,10 @@ declare const MIN_REPEAT_INTERVAL_MS = 1000;
 /** Default product schedule floor. Never use repeats to poll state. */
 declare const DEFAULT_MIN_REPEAT_INTERVAL_MS = 60000;
 interface ScheduleConfiguration {
+  /** Check for due alarms after RPC/fetch responses unwind. Native alarms remain recovery authority. */
+  readonly dispatchAfterEvent?: boolean;
+  /** Positive recovery deadline while dispatch or deferWakes is active. Defaults to one second. */
+  readonly inFlightRecovery?: Duration.Input;
   /** Retry floor, at least one second. Defaults to one second. */
   readonly minimumRetryDelay?: Duration.Input;
   /** Positive safe integer. Defaults to eight unchanged attempts. */
@@ -30,6 +34,8 @@ interface ScheduleConfiguration {
 }
 /** Optional policy overrides. Provide with Layer.succeed in the Durable Object's application layer. */
 declare const ScheduleConfiguration: Context.Reference<ScheduleConfiguration>;
+/** Automatic alarms acknowledge/retry on handler exit; manual alarms retain consumer control. */
+type AlarmLifecycle = "automatic" | "manual";
 type AlarmPayload = S.Json;
 /** Content-free: no alarm identifiers, payload, error text or consumer state. */
 declare const AlarmParked: S.TaggedStruct<"AlarmParked", {
@@ -39,6 +45,7 @@ declare const AlarmParked: S.TaggedStruct<"AlarmParked", {
 type AlarmParked = typeof AlarmParked.Type;
 /** Install with Layer.succeed / Effect.provideService. Reporting cannot undo a committed guard. */
 declare const AlarmReporter: Context.Reference<(event: AlarmParked) => Effect.Effect<void>>;
+declare const ManualTags: unique symbol;
 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>;
@@ -79,6 +86,14 @@ declare class InvalidScheduleConfigurationError extends InvalidScheduleConfigura
 }> {
   get message(): string;
 }
+declare const InvalidAlarmRegistrationError_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: "InvalidAlarmRegistrationError";
+} & Readonly<A>;
+declare class InvalidAlarmRegistrationError extends InvalidAlarmRegistrationError_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>;
@@ -88,7 +103,7 @@ declare class StoredAlarmDecodeError extends StoredAlarmDecodeError_base<{
 }> {
   get message(): string;
 }
-type DurableObjectAlarmError = InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidProcessDueAlarmsOptionsError | InvalidRepeatEveryError | InvalidScheduleConfigurationError | StorageOperationError | StoredAlarmDecodeError;
+type DurableObjectAlarmError = InvalidAlarmRegistrationError | InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidProcessDueAlarmsOptionsError | InvalidRepeatEveryError | InvalidScheduleConfigurationError | StorageOperationError | StoredAlarmDecodeError;
 declare const DurableObjectAlarmEvent: S.TaggedUnion<{
   readonly AlarmDue: S.TaggedStruct<"AlarmDue", {
     readonly id: S.NonEmptyString;
@@ -108,6 +123,8 @@ type AlarmRef<Tag extends string = string> = {
  * Reusing `{tag, id}` replaces an alarm. Product repeats use the configured floor and run after completion.
  */
 type ScheduleAlarmInput<Tag extends string = string> = AlarmRef<Tag> & {
+  /** Prefer selecting the lifecycle in a typed Tag definition. Defaults to automatic. */
+  readonly lifecycle?: AlarmLifecycle;
   readonly payload: AlarmPayload;
   readonly repeatEvery?: Duration.Input;
   readonly runAt: DateTime.Utc;
@@ -133,6 +150,7 @@ type ProcessDueAlarmsFailureAction = "retry" | "skip-and-advance-repeat" | {
   readonly mode: "skip-and-advance-repeat";
 };
 interface ProcessDueAlarmsOptions<OnFailureR = never, OnFailureE = never> {
+  readonly [ManualTags]?: ReadonlySet<string>;
   readonly limit?: number;
   readonly onFailure?: (failure: ProcessDueAlarmsFailure) => Effect.Effect<ProcessDueAlarmsFailureAction | void, OnFailureE, OnFailureR>;
   readonly retryFailedAfter?: Duration.Input;
@@ -149,8 +167,29 @@ interface AlarmStatus {
   readonly runAt: DateTime.Utc;
   readonly retryAt: DateTime.Utc | undefined;
 }
+/** @internal */
+declare const RunAlarm: unique symbol;
+/** @internal */
+declare const DispatchAfterEvent: unique symbol;
+/** @internal */
+declare const HasDueAlarms: unique symbol;
 /** Own `storage.setAlarm()` exclusively: a Durable Object has one platform alarm timestamp. */
 type AlarmScheduler = {
+  /** @internal DurableObject.make shares this scoped event across native and post-event dispatch. */
+  readonly [RunAlarm]: <R>(event: (beginDispatch: Effect.Effect<void, InvalidScheduleConfigurationError>) => Effect.Effect<void, unknown, R>, native: boolean) => Effect.Effect<void, unknown, R>;
+  /** @internal Read the current event's opt-in without acquiring another event layer. */
+  readonly [DispatchAfterEvent]: Effect.Effect<boolean>;
+  /** @internal Check inside the alarm event so its clock and configuration apply. */
+  readonly [HasDueAlarms]: Effect.Effect<boolean, StorageOperationError>;
+  /**
+   * Keep a native recovery alarm armed while coalescing checkpoint changes across this
+   * object's concurrent and nested scopes. Source/checkpoint transactions still commit;
+   * the last scope reconciles their current deadlines on success, failure or interruption.
+   * Run outside transactions, around bounded maintenance or inline work. The first scope's
+   * inFlightRecovery bounds the shared guard; renew it if it expires and is consumed while
+   * scopes remain active. A process loss before exit recovers at that retained alarm.
+   */
+  readonly deferWakes: <A, E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E | InvalidScheduleConfigurationError | StorageOperationError, R>;
   /**
    * Commits local application storage and logical alarms in one native SQLite
    * Durable Object transaction, reconciling the native alarm before commit.
@@ -183,11 +222,17 @@ type AlarmFailurePolicy = "retry" | "skip-and-advance-repeat";
 interface AlarmRetryPolicy {
   readonly initialDelay?: Duration.Input;
 }
-interface AlarmDefinitionConfig<Payload extends AlarmPayloadSchema = AlarmPayloadSchema> {
-  readonly failure?: AlarmFailurePolicy;
+type AlarmDefinitionConfig<Payload extends AlarmPayloadSchema = AlarmPayloadSchema> = {
   readonly payload: Payload;
+} & ({
+  readonly lifecycle?: "automatic";
+  readonly failure?: AlarmFailurePolicy;
   readonly retry?: AlarmRetryPolicy;
-}
+} | {
+  readonly lifecycle: "manual";
+  readonly failure?: never;
+  readonly retry?: never;
+});
 type AlarmDefinitionEntry = AlarmDefinitionConfig | AlarmPayloadSchema;
 type AlarmDefinitions = Readonly<Record<string, AlarmDefinitionEntry>>;
 type AlarmDefinitionSchema<Definition> = Definition extends AlarmDefinitionConfig<infer Payload> ? Payload : Definition;
@@ -198,9 +243,14 @@ type DefinedAlarmEvent<Tag extends string, Payload> = Omit<DurableObjectAlarmEve
 };
 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>; };
 /** 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>, "payload"> & {
+type DefinedScheduleAlarmInput<Definitions extends AlarmDefinitions> = { readonly [Tag in keyof Definitions & string]: Omit<ScheduleAlarmInput<Tag>, "payload" | "lifecycle" | "repeatEvery" | "progress"> & {
   readonly payload: AlarmDefinitionPayload<Definitions[Tag]>;
-}; }[keyof Definitions & string];
+} & (Definitions[Tag] extends {
+  readonly lifecycle: "manual";
+} ? {
+  readonly repeatEvery?: never;
+  readonly progress?: never;
+} : Pick<ScheduleAlarmInput<Tag>, "repeatEvery" | "progress">); }[keyof Definitions & string];
 interface DefinedAlarmTransaction<Definitions extends AlarmDefinitions> {
   readonly scheduleAlarm: (input: DefinedScheduleAlarmInput<Definitions>) => ReturnType<AlarmScheduler["scheduleAlarm"]>;
   readonly scheduleAlarmEarlier: DefinedAlarmTransaction<Definitions>["scheduleAlarm"];
@@ -215,14 +265,29 @@ interface AlarmService {
 }
 interface DefinedAlarmScheduler<Definitions extends AlarmDefinitions> extends DefinedAlarmTransaction<Definitions> {
   readonly [TypedAlarmSchedulerTypeId]: typeof TypedAlarmSchedulerTypeId;
+  readonly deferWakes: AlarmScheduler["deferWakes"];
   readonly getAlarmStatus: (input: AlarmRef<keyof Definitions & string>) => ReturnType<AlarmScheduler["getAlarmStatus"]>;
   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 layer: Layer.Layer<Self, InvalidAlarmRegistrationError, DurableObjectAlarm>;
   readonly run: Effect.Effect<ProcessDueAlarmsResult, E | DurableObjectAlarmError, R | DurableObjectAlarm>;
+  readonly [RegistrationParts]?: RegistrationParts<R, E>;
+}
+declare const RegistrationParts: unique symbol;
+interface AlarmDispatcher<R, E> {
+  readonly tags: readonly string[];
+  readonly automatic: boolean;
+  readonly run: AlarmRegistration<never, R, E>["run"];
+}
+interface RegistrationParts<R, E> {
+  readonly services: readonly string[];
+  readonly dispatchers: readonly AlarmDispatcher<R, E>[];
+  readonly invalid?: string;
 }
+/** Compose independent typed alarm registrations under one native alarm owner. */
+declare function mergeAll<const Registrations extends readonly [AlarmRegistration<never, unknown, unknown>, ...AlarmRegistration<never, unknown, unknown>[]]>(...registrations: Registrations): AlarmRegistration<Layer.Success<Registrations[number]["layer"]>, Exclude<Effect.Services<Registrations[number]["run"]>, DurableObjectAlarm>, Exclude<Effect.Error<Registrations[number]["run"]>, DurableObjectAlarmError>>;
 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>;
 }
@@ -230,6 +295,8 @@ interface AlarmTagClass<Self, Id extends string, Definitions extends AlarmDefini
 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>;
 };
+/** @internal Preserve custom dispatch while recovering retained alarms after deployments. */
+declare const dispatchRawAlarm: <Self, E, R>(rawAlarm: Effect.Effect<void, E, R>, registration?: AlarmRegistration<Self, R, E>) => Effect.Effect<void, E | DurableObjectAlarmError, R | DurableObjectAlarm | DurableObjectState>;
 /** The typed scheduler becomes available when its handlers are registered on a Durable Object. */
 declare const Tag: <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>;
@@ -237,4 +304,4 @@ declare class DurableObjectAlarm extends DurableObjectAlarm_base {
   static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState>;
 }
 //#endregion
-export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmParked, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRegistration, AlarmReporter, AlarmRetryPolicy, AlarmScheduler, AlarmService, AlarmStatus, AlarmTagClass, AlarmTransaction, DEFAULT_MIN_REPEAT_INTERVAL_MS, DefinedAlarmEvent, DefinedAlarmHandlers, DefinedAlarmScheduler, DefinedAlarmTransaction, DefinedScheduleAlarmInput, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, DurableObjectAlarm_d_exports, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, InvalidScheduleConfigurationError, MIN_REPEAT_INTERVAL_MS, MIN_RETRY_DELAY_MS, PARKED_RETRY_DELAY_MS, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, ScheduleConfiguration, StoredAlarmDecodeError, Tag, UNCHANGED_ATTEMPT_BUDGET, define, processDue };
+export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmLifecycle, AlarmParked, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRegistration, AlarmReporter, AlarmRetryPolicy, AlarmScheduler, AlarmService, AlarmStatus, AlarmTagClass, AlarmTransaction, DEFAULT_MIN_REPEAT_INTERVAL_MS, DefinedAlarmEvent, DefinedAlarmHandlers, DefinedAlarmScheduler, DefinedAlarmTransaction, DefinedScheduleAlarmInput, DispatchAfterEvent, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, DurableObjectAlarm_d_exports, HasDueAlarms, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidAlarmRegistrationError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, InvalidScheduleConfigurationError, MIN_REPEAT_INTERVAL_MS, MIN_RETRY_DELAY_MS, PARKED_RETRY_DELAY_MS, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, RunAlarm, ScheduleAlarmInput, ScheduleConfiguration, StoredAlarmDecodeError, Tag, UNCHANGED_ATTEMPT_BUDGET, define, dispatchRawAlarm, mergeAll, processDue };