effect-cf 0.54.0 → 0.56.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # effect-cf
 
+## 0.56.0
+
+### Minor Changes
+
+- [#213](https://github.com/danieljvdm/effect-cf/pull/213) [`b0e1201`](https://github.com/danieljvdm/effect-cf/commit/b0e1201663c3769fa2e63daad6f46a8a8b0d9b05) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Allow alarm transactions to share a Durable Object SQL client's connection and commit boundary. Reduce manual alarm checkpoint writes while preserving recovery guards and stale-dispatch fencing.
+
+## 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

package/dist/DurableObjectAlarm.d.mts

@@ -6,8 +6,9 @@ import * as S from "effect/Schema";
 import * as Layer from "effect/Layer";
 import * as Duration from "effect/Duration";
 import * as DateTime from "effect/DateTime";
+import { SqlClient } from "effect/sql/SqlClient";
 declare namespace DurableObjectAlarm_d_exports {
-  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 };
+  export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmLifecycle, AlarmParked, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRegistration, AlarmReporter, AlarmRetryPolicy, AlarmScheduler, AlarmService, AlarmStatus, AlarmTagClass, AlarmTransaction, AlarmTransactionOptions, 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. */
@@ -21,6 +22,8 @@ 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. */
@@ -159,6 +162,11 @@ type ProcessDueAlarmsHandler<R = never, E = never> = (event: DurableObjectAlarmE
  * fiber; forked work and use after the callback ends fail with StorageOperationError.
  */
 type AlarmTransaction = Pick<AlarmScheduler, "scheduleAlarm" | "scheduleAlarmEarlier" | "cancelAlarm">;
+/** Share the same native commit and connection permit as the caller's SQL writes. */
+interface AlarmTransactionOptions {
+  /** Must be a storage-backed @effect/sql-sqlite-do client for this Durable Object. */
+  readonly sqlClient: SqlClient;
+}
 interface AlarmStatus {
   readonly attempts: number;
   readonly parked: boolean;
@@ -184,14 +192,14 @@ type AlarmScheduler = {
    * 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
-   * parkedRetryDelay bounds the shared guard; renew it if it expires and is consumed while
+   * 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.
-   * Use the supplied mutations, not standalone alarm methods or nested transactions.
+   * Use the supplied mutations inside the callback instead of standalone alarm methods.
    * SqlClient queries must use this same Durable Object's storage.
    *
    * Failure, defects and interruption before commit roll back. A lost reply or
@@ -200,7 +208,7 @@ type AlarmScheduler = {
    * Cloudflare's native retries are bounded; composition does not remove the
    * pre-arm requirement or promise infinite retry liveness.
    */
-  readonly transaction: <A, E, R>(closure: (alarms: AlarmTransaction) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | StorageOperationError, R>;
+  readonly transaction: <A, E, R>(closure: (alarms: AlarmTransaction) => Effect.Effect<A, E, R>, options?: AlarmTransactionOptions) => Effect.Effect<A, E | StorageOperationError, R>;
   readonly cancelAlarm: (input: AlarmRef) => Effect.Effect<void, InvalidAlarmRefError | StorageOperationError>;
   /** Inspect retained work, including hourly recovery deadlines. */
   readonly getAlarmStatus: (input: AlarmRef) => Effect.Effect<AlarmStatus | undefined, InvalidAlarmRefError | StorageOperationError>;
@@ -265,7 +273,7 @@ interface DefinedAlarmScheduler<Definitions extends AlarmDefinitions> extends De
   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>;
+  readonly transaction: <A, E, R>(closure: (alarms: DefinedAlarmTransaction<Definitions>) => Effect.Effect<A, E, R>, options?: AlarmTransactionOptions) => Effect.Effect<A, E | StorageOperationError, R>;
 }
 /** Registers a dispatcher and the service authorized to schedule its alarms. */
 interface AlarmRegistration<Self, R = never, E = never> {
@@ -302,4 +310,4 @@ declare class DurableObjectAlarm extends DurableObjectAlarm_base {
   static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState>;
 }
 //#endregion
-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 };
+export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmLifecycle, AlarmParked, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRegistration, AlarmReporter, AlarmRetryPolicy, AlarmScheduler, AlarmService, AlarmStatus, AlarmTagClass, AlarmTransaction, AlarmTransactionOptions, 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 };

package/dist/DurableObjectAlarm.mjs

@@ -11,9 +11,11 @@ import * as Predicate from "effect/Predicate";
 import * as Exit from "effect/Exit";
 import * as Duration from "effect/Duration";
 import * as Clock from "effect/Clock";
+import { SqliteClient } from "@effect/sql-sqlite-do";
 import * as DateTime from "effect/DateTime";
 import * as Deferred from "effect/Deferred";
 import * as Semaphore from "effect/Semaphore";
+import { SqlError } from "effect/sql/SqlError";
 //#region src/DurableObjectAlarm.ts
 var DurableObjectAlarm_exports = /* @__PURE__ */ __exportAll({
 	AlarmParked: () => AlarmParked,
@@ -51,23 +53,21 @@ CREATE TABLE IF NOT EXISTS effect_cf_scheduled_alarms (
   run_at INTEGER NOT NULL,
   wake_at INTEGER NOT NULL DEFAULT 0,
   repeat_every_ms INTEGER,
-  payload TEXT NOT NULL
-);
-CREATE TABLE IF NOT EXISTS effect_cf_alarm_attempts (
-  storage_id TEXT PRIMARY KEY,
-  revision TEXT NOT NULL,
-  attempts INTEGER NOT NULL,
-  parked INTEGER NOT NULL,
+  payload TEXT NOT NULL,
+  revision TEXT NOT NULL DEFAULT '',
+  attempts INTEGER NOT NULL DEFAULT 0,
+  parked INTEGER NOT NULL DEFAULT 0,
   retry_at INTEGER,
-  progress INTEGER NOT NULL
+  progress INTEGER NOT NULL DEFAULT -1
 );
 `;
 const WAKE_INDEX = "idx_effect_cf_scheduled_alarms_wake_at_storage_id";
-const LIFECYCLE_INDEX = "idx_effect_cf_scheduled_alarms_lifecycle_wake_at_storage_id";
+const LIFECYCLE_INDEX = "idx_effect_cf_scheduled_alarms_lifecycle_wake_at_storage_id_v2";
 const DEFAULT_PROCESS_DUE_ALARMS_LIMIT = 100;
 const MIN_RETRY_DELAY_MS = 1e3;
 /** Minimum and default parked recovery interval. */
 const PARKED_RETRY_DELAY_MS = 36e5;
+const DEFAULT_IN_FLIGHT_RECOVERY_MS = 1e3;
 /** Absolute product repeat floor. */
 const MIN_REPEAT_INTERVAL_MS = 1e3;
 /** Default product schedule floor. Never use repeats to poll state. */
@@ -78,6 +78,7 @@ const safeIntegerAtLeast = (minimum) => S.Int.check(S.isGreaterThanOrEqualTo(min
 const AlarmLifecycleSchema = S.Literals(["automatic", "manual"]);
 const ScheduleConfigurationSchema = S.Struct({
 	dispatchAfterEvent: S.Boolean,
+	inFlightRecovery: safeIntegerAtLeast(1),
 	minimumRetryDelay: safeIntegerAtLeast(MIN_RETRY_DELAY_MS),
 	unchangedAttemptBudget: safeIntegerAtLeast(1),
 	parkedRetryDelay: safeIntegerAtLeast(PARKED_RETRY_DELAY_MS),
@@ -85,14 +86,8 @@ const ScheduleConfigurationSchema = S.Struct({
 }).check(S.makeFilter((configuration) => configuration.parkedRetryDelay >= configuration.minimumRetryDelay ? void 0 : "parkedRetryDelay must be at least minimumRetryDelay"));
 const retryDelay = (attempts, configuration, parked, initialDelay = configuration.minimumRetryDelay) => parked ? configuration.parkedRetryDelay : Math.min(configuration.parkedRetryDelay, initialDelay * 2 ** (attempts - 1));
 const getScheduledEventId = (input) => `effect-cf-alarm:${encodeURIComponent(input.tag)}:${encodeURIComponent(input.id)}`;
-const alarmRowsSql = `
-  SELECT a.*, COALESCE(s.revision, '') AS revision,
-         COALESCE(s.attempts, 0) AS attempts, COALESCE(s.parked, 0) AS parked,
-         s.retry_at, COALESCE(s.progress, -1) AS progress
-    FROM effect_cf_scheduled_alarms a
-    LEFT JOIN effect_cf_alarm_attempts s USING (storage_id)`;
-const sameRevisionSql = `storage_id = ? AND COALESCE(
-  (SELECT revision FROM effect_cf_alarm_attempts WHERE storage_id = ?), '') = ?`;
+const alarmRowsSql = "SELECT a.* FROM effect_cf_scheduled_alarms a";
+const sameRevisionSql = "storage_id = ? AND revision = ?";
 /** Content-free: no alarm identifiers, payload, error text or consumer state. */
 const AlarmParked = S.TaggedStruct("AlarmParked", {
 	attempts: S.Int,
@@ -142,6 +137,7 @@ const getScheduleConfiguration = Effect.fnUntraced(function* (defaults) {
 	return yield* Effect.try({
 		try: () => S.decodeUnknownSync(ScheduleConfigurationSchema)({
 			dispatchAfterEvent: input.dispatchAfterEvent ?? false,
+			inFlightRecovery: Math.ceil(Duration.toMillis(input.inFlightRecovery ?? DEFAULT_IN_FLIGHT_RECOVERY_MS)),
 			minimumRetryDelay: Math.ceil(Duration.toMillis(input.minimumRetryDelay ?? 1e3)),
 			unchangedAttemptBudget: input.unchangedAttemptBudget ?? 8,
 			parkedRetryDelay: Math.ceil(Duration.toMillis(input.parkedRetryDelay ?? 36e5)),
@@ -167,6 +163,7 @@ const AlarmRefSchema = S.Struct({
 	tag: S.NonEmptyString
 });
 const decodeAlarmRef = (input) => S.decodeUnknownEffect(AlarmRefSchema)(input).pipe(Effect.mapError((cause) => new InvalidAlarmRefError({ cause })));
+const StorageSqlClient = S.declare((value) => Predicate.hasProperty(value, SqliteClient.TypeId));
 /** @internal */
 const RunAlarm = Symbol("effect-cf/DurableObjectAlarm/RunAlarm");
 /** @internal */
@@ -181,15 +178,30 @@ const decodeStoredPayload = (row) => S.decodeUnknownEffect(StoredPayloadString)(
 })));
 const encodeStoredPayload = (payload) => S.encodeEffect(StoredPayloadString)(payload).pipe(Effect.mapError((cause) => new InvalidAlarmPayloadError({ cause })));
 const ensureTable = Effect.fnUntraced(function* (state) {
-	yield* state.storage.sql.exec(INIT_TABLE_SQL);
 	if ((yield* (yield* state.storage.sql.exec("SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?", LIFECYCLE_INDEX)).toArray()).length > 0) return;
+	yield* state.storage.sql.exec(INIT_TABLE_SQL);
 	const columns = yield* state.storage.sql.exec("SELECT name FROM pragma_table_info('effect_cf_scheduled_alarms')");
 	const names = new Set((yield* columns.toArray()).map((column) => column.name));
 	if (!names.has("lifecycle")) yield* state.storage.sql.exec("ALTER TABLE effect_cf_scheduled_alarms ADD COLUMN lifecycle TEXT NOT NULL DEFAULT 'automatic'");
 	if (!names.has("wake_at")) yield* state.storage.sql.exec("ALTER TABLE effect_cf_scheduled_alarms ADD COLUMN wake_at INTEGER NOT NULL DEFAULT 0");
+	for (const [column, definition] of Object.entries({
+		revision: "TEXT NOT NULL DEFAULT ''",
+		attempts: "INTEGER NOT NULL DEFAULT 0",
+		parked: "INTEGER NOT NULL DEFAULT 0",
+		retry_at: "INTEGER",
+		progress: "INTEGER NOT NULL DEFAULT -1"
+	})) if (!names.has(column)) yield* state.storage.sql.exec(`ALTER TABLE effect_cf_scheduled_alarms ADD COLUMN ${column} ${definition}`);
+	if ((yield* (yield* state.storage.sql.exec("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'effect_cf_alarm_attempts'")).toArray()).length > 0) {
+		yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms SET
+      (revision, attempts, parked, retry_at, progress) =
+      (SELECT revision, attempts, parked, retry_at, progress FROM effect_cf_alarm_attempts s
+       WHERE s.storage_id = effect_cf_scheduled_alarms.storage_id)
+      WHERE storage_id IN (SELECT storage_id FROM effect_cf_alarm_attempts)`);
+		yield* state.storage.sql.exec("DROP TABLE effect_cf_alarm_attempts");
+	}
 	yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms SET
-    wake_at = MAX(run_at, COALESCE((SELECT retry_at FROM effect_cf_alarm_attempts s
-      WHERE s.storage_id = effect_cf_scheduled_alarms.storage_id), run_at))`);
+    wake_at = MAX(run_at, COALESCE(retry_at, run_at))`);
+	yield* state.storage.sql.exec("DROP INDEX IF EXISTS idx_effect_cf_scheduled_alarms_lifecycle_wake_at_storage_id");
 	yield* state.storage.sql.exec("DROP INDEX IF EXISTS idx_effect_cf_scheduled_alarms_run_at_storage_id");
 	yield* state.storage.sql.exec(`CREATE INDEX IF NOT EXISTS ${WAKE_INDEX}
     ON effect_cf_scheduled_alarms (wake_at, storage_id)`);
@@ -343,7 +355,7 @@ const makeDefinition = (definitions) => {
 			...bind(alarms),
 			deferWakes: alarms.deferWakes,
 			getAlarmStatus: (input) => alarms.getAlarmStatus(input),
-			transaction: (closure) => alarms.transaction((tx) => closure(bind(tx)))
+			transaction: (closure, options) => alarms.transaction((tx) => closure(bind(tx)), options)
 		}),
 		handlers: (handlers, options) => processDue((event) => Effect.gen(function* () {
 			const definition = definitionFor(event.tag);
@@ -440,18 +452,14 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			yield* writeNativeAlarm(next?.run_at ?? null);
 		});
 		const writeAttempts = Effect.fnUntraced(function* (storageId, attempts, parked, retryAt, progress) {
-			yield* state.storage.sql.exec(`INSERT OR REPLACE INTO effect_cf_alarm_attempts
-            (storage_id, revision, attempts, parked, retry_at, progress)
-           VALUES (?, ?, ?, ?, ?, ?)`, storageId, crypto.randomUUID(), attempts, parked, retryAt, progress);
-			yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms
-            SET wake_at = MAX(run_at, COALESCE(?, run_at))
-            WHERE storage_id = ?`, retryAt, storageId);
+			yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms SET revision = ?, attempts = ?, parked = ?,
+             retry_at = ?, progress = ?, wake_at = MAX(run_at, COALESCE(?, run_at))
+           WHERE storage_id = ?`, crypto.randomUUID(), attempts, parked, retryAt, progress, retryAt, storageId);
 		});
 		const cancelAlarm = Effect.fn("DurableObjectAlarm.cancelAlarm")(function* (input) {
 			const ref = yield* decodeAlarmRef(input);
 			const storageId = getScheduledEventId(ref);
 			yield* state.storage.sql.exec(`DELETE FROM effect_cf_scheduled_alarms WHERE storage_id = ?`, storageId);
-			yield* state.storage.sql.exec(`DELETE FROM effect_cf_alarm_attempts WHERE storage_id = ?`, storageId);
 		});
 		const scheduleAlarm = Effect.fn("DurableObjectAlarm.scheduleAlarm")(function* (input, earlier, reports) {
 			const configuration = yield* getScheduleConfiguration(configurationDefaults);
@@ -461,6 +469,19 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			const repeatEveryMillis = yield* toRepeatEveryMillis(input.repeatEvery, configuration.minimumRepeatInterval);
 			const payload = yield* encodeStoredPayload(input.payload);
 			const storageId = getScheduledEventId(ref);
+			const runAt = DateTime.toEpochMillis(input.runAt);
+			if (lifecycle === "manual") {
+				const deadline = earlier ? "MIN(run_at, excluded.run_at)" : "excluded.run_at";
+				const nextPayload = earlier ? "CASE WHEN run_at <= excluded.run_at THEN payload ELSE excluded.payload END" : "excluded.payload";
+				yield* state.storage.sql.exec(`INSERT INTO effect_cf_scheduled_alarms
+              (storage_id, alarm_id, tag, lifecycle, run_at, wake_at, payload, revision)
+             VALUES (?, ?, ?, 'manual', ?, ?, ?, ?)
+             ON CONFLICT(storage_id) DO UPDATE SET
+               lifecycle = 'manual', run_at = ${deadline}, wake_at = ${deadline},
+               payload = ${nextPayload}, revision = excluded.revision,
+               repeat_every_ms = NULL, attempts = 0, parked = 0, retry_at = NULL, progress = -1`, storageId, ref.id, ref.tag, runAt, runAt, payload, crypto.randomUUID());
+				return;
+			}
 			const existing = yield* readRow(storageId);
 			const pass = yield* CurrentAlarmPass;
 			const source = lifecycle === "automatic" && pass?.row.lifecycle === "automatic" ? pass.row : void 0;
@@ -473,16 +494,15 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			const parked = attempts > 0 && (attempts >= configuration.unchangedAttemptBudget || source?.parked === 1 || existing?.parked === 1) ? 1 : 0;
 			const now = yield* Clock.currentTimeMillis;
 			const retryAt = attempts === 0 ? null : now + retryDelay(attempts, configuration, parked === 1);
-			const runAt = DateTime.toEpochMillis(input.runAt);
 			const keepEarlier = earlier && existing !== void 0 && existing.run_at <= runAt;
 			const scheduledAt = keepEarlier ? existing.run_at : runAt;
 			const scheduledPayload = keepEarlier ? existing.payload : payload;
-			const scheduledRepeat = lifecycle === "manual" ? null : keepEarlier ? existing.repeat_every_ms : repeatEveryMillis;
-			const nextProgress = lifecycle === "manual" ? -1 : Math.max(progress, input.progress ?? -1);
+			const scheduledRepeat = keepEarlier ? existing.repeat_every_ms : repeatEveryMillis;
+			const nextProgress = Math.max(progress, input.progress ?? -1);
 			yield* state.storage.sql.exec(`INSERT OR REPLACE INTO effect_cf_scheduled_alarms
-            (storage_id, alarm_id, tag, lifecycle, run_at, repeat_every_ms, payload)
-           VALUES (?, ?, ?, ?, ?, ?, ?)`, storageId, ref.id, ref.tag, lifecycle, scheduledAt, scheduledRepeat, scheduledPayload);
-			yield* writeAttempts(storageId, attempts, parked, retryAt, nextProgress);
+            (storage_id, alarm_id, tag, lifecycle, run_at, repeat_every_ms, payload,
+             wake_at, revision, attempts, parked, retry_at, progress)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, storageId, ref.id, ref.tag, lifecycle, scheduledAt, scheduledRepeat, scheduledPayload, Math.max(scheduledAt, retryAt ?? scheduledAt), crypto.randomUUID(), attempts, parked, retryAt, nextProgress);
 			if (parked === 1 && retryAt !== null && (existing?.parked ?? source?.parked ?? 0) === 0) reports.push(storageId);
 		});
 		const reportParked = Effect.fnUntraced(function* (storageIds) {
@@ -500,14 +520,14 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 				yield* Effect.exit(Effect.suspend(() => report(event)));
 			}
 		});
-		const transaction = Effect.fnUntraced(function* (closure) {
+		const transaction = Effect.fnUntraced(function* (closure, options) {
 			const pass = yield* CurrentAlarmPass;
 			if (pass !== void 0 && !pass.active) return yield* Effect.fail(new StorageOperationError({
 				operation: "alarm.transaction",
 				cause: /* @__PURE__ */ new Error("Alarm handlers cannot mutate detached work after their pass ends")
 			}));
 			const reports = [];
-			const result = yield* state.storage.transaction(() => Effect.withFiber((owner) => {
+			const body = Effect.withFiber((owner) => {
 				let active = true;
 				const requireActive = (effect) => Effect.withFiber((fiber) => active && fiber === owner && (pass === void 0 || pass.active) ? effect : Effect.fail(new StorageOperationError({
 					operation: "alarm.transaction",
@@ -525,7 +545,21 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 					yield* reconcileAlarm();
 					return result;
 				});
-			}));
+			});
+			const result = yield* options === void 0 ? state.storage.transaction(() => body) : Effect.gen(function* () {
+				const client = yield* S.decodeUnknownEffect(StorageSqlClient)(options.sqlClient).pipe(Effect.mapError((cause) => new StorageOperationError({
+					operation: "alarm.transaction",
+					cause
+				})));
+				if (client.config.storage !== state.raw.storage) return yield* Effect.fail(new StorageOperationError({
+					operation: "alarm.transaction",
+					cause: /* @__PURE__ */ new Error("Alarm transactions require this Durable Object's storage-backed SQL client")
+				}));
+				return yield* client.withTransaction(body).pipe(Effect.mapError((cause) => cause instanceof SqlError ? new StorageOperationError({
+					operation: "alarm.transaction",
+					cause
+				}) : cause));
+			});
 			yield* reportParked(reports);
 			return result;
 		});
@@ -533,7 +567,7 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			const configuration = yield* getScheduleConfiguration(configurationDefaults);
 			const now = yield* Clock.currentTimeMillis;
 			if (wakeDeferrals === 0) {
-				deferredRecoveryDelay = configuration.parkedRetryDelay;
+				deferredRecoveryDelay = configuration.inFlightRecovery;
 				deferredRecoveryAt = now + deferredRecoveryDelay;
 				wakesReady ??= Deferred.makeUnsafe();
 			}
@@ -566,6 +600,16 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			})).pipe(Effect.onExit((exit) => Effect.gen(function* () {
 				const reconcile = dispatchNeedsReconcile || dispatchStarted || Exit.isFailure(exit);
 				dispatchActive = Exit.isFailure(exit) && !dispatchStarted;
+				if (dispatchActive) {
+					const recoveryDelay = yield* getScheduleConfiguration(configurationDefaults).pipe(Effect.match({
+						onFailure: () => PARKED_RETRY_DELAY_MS,
+						onSuccess: (configuration) => configuration.parkedRetryDelay
+					}));
+					if (wakeDeferrals === 0) {
+						deferredRecoveryDelay = recoveryDelay;
+						deferredRecoveryAt = 0;
+					}
+				}
 				const reconciled = yield* (reconcile ? transaction(() => Effect.void) : Effect.void).pipe(Effect.exit);
 				dispatchActive = false;
 				pendingAlarm = void 0;
@@ -584,11 +628,11 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 		});
 		const acknowledgeAlarm = Effect.fnUntraced(function* (row, configuration) {
 			if (row.repeat_every_ms === null) {
-				if ((yield* (yield* state.storage.sql.exec(`DELETE FROM effect_cf_scheduled_alarms WHERE ${sameRevisionSql}`, row.storage_id, row.storage_id, row.revision)).rowsWritten) > 0) yield* state.storage.sql.exec(`DELETE FROM effect_cf_alarm_attempts WHERE storage_id = ?`, row.storage_id);
+				yield* state.storage.sql.exec(`DELETE FROM effect_cf_scheduled_alarms WHERE ${sameRevisionSql}`, row.storage_id, row.revision);
 				return;
 			}
 			const now = yield* Clock.currentTimeMillis;
-			if ((yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms SET run_at = ? WHERE ${sameRevisionSql}`, now + Math.max(configuration.minimumRepeatInterval, row.repeat_every_ms), row.storage_id, row.storage_id, row.revision)).rowsWritten) > 0) yield* writeAttempts(row.storage_id, 0, 0, null, row.progress);
+			if ((yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms SET run_at = ? WHERE ${sameRevisionSql}`, now + Math.max(configuration.minimumRepeatInterval, row.repeat_every_ms), row.storage_id, row.revision)).rowsWritten) > 0) yield* writeAttempts(row.storage_id, 0, 0, null, row.progress);
 		});
 		const processDueAlarms = Effect.fn("DurableObjectAlarm.processDueAlarms")(function* (handle, options) {
 			const configuration = yield* getScheduleConfiguration(configurationDefaults);
@@ -607,7 +651,10 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			const dueRows = yield* select("automatic", limit);
 			const manualRows = yield* select("manual", DEFAULT_PROCESS_DUE_ALARMS_LIMIT);
 			if (manualRows.length > 0) yield* transaction(() => Effect.gen(function* () {
-				for (const row of manualRows) yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms SET run_at = ?, wake_at = ? WHERE ${sameRevisionSql}`, now + configuration.parkedRetryDelay, now + configuration.parkedRetryDelay, row.storage_id, row.storage_id, row.revision);
+				for (const row of manualRows) {
+					const recoveryAt = now + (options?.[ManualTags]?.has(row.tag) ? configuration.inFlightRecovery : configuration.parkedRetryDelay);
+					yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms SET run_at = ?, wake_at = ? WHERE ${sameRevisionSql}`, recoveryAt, recoveryAt, row.storage_id, row.revision);
+				}
 			}));
 			const handled = [];
 			const failed = [];
@@ -665,7 +712,10 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			const permits = dispatch?.permits ?? (yield* Semaphore.make(4));
 			const automatic = Effect.forEach(dueRows, handleRow, { discard: true }).pipe(Effect.exit);
 			const exits = yield* manualRows.length === 0 ? automatic.pipe(Effect.map((exit) => [exit])) : Effect.all([automatic, Effect.forEach(manualRows, (row) => permits.withPermits(1)(handleRow(row)).pipe(Effect.exit), { concurrency: 4 }).pipe(Effect.flatMap(Exit.asVoidAll), Effect.exit)], { concurrency: 2 });
-			yield* transaction(() => Effect.void);
+			yield* transaction(() => Effect.gen(function* () {
+				const recoveryAt = (yield* Clock.currentTimeMillis) + configuration.parkedRetryDelay;
+				for (const row of manualRows) yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms SET run_at = ?, wake_at = ? WHERE ${sameRevisionSql}`, recoveryAt, recoveryAt, row.storage_id, row.revision);
+			}));
 			yield* Exit.asVoidAll(exits);
 			return {
 				failed,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.54.0",
+  "version": "0.56.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

package/src/DurableObjectAlarm.ts

@@ -1,3 +1,4 @@
+import { SqliteClient } from "@effect/sql-sqlite-do";
 import * as Clock from "effect/Clock";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
@@ -10,6 +11,8 @@ import * as Layer from "effect/Layer";
 import * as Predicate from "effect/Predicate";
 import * as S from "effect/Schema";
 import * as Semaphore from "effect/Semaphore";
+import type { SqlClient } from "effect/sql/SqlClient";
+import { SqlError } from "effect/sql/SqlError";
 
 import { DurableObjectState } from "./DurableObjectState";
 import { type SqlStorageValue, StorageOperationError } from "./DurableObjectStorage";
@@ -24,20 +27,17 @@ CREATE TABLE IF NOT EXISTS effect_cf_scheduled_alarms (
   run_at INTEGER NOT NULL,
   wake_at INTEGER NOT NULL DEFAULT 0,
   repeat_every_ms INTEGER,
-  payload TEXT NOT NULL
-);
-CREATE TABLE IF NOT EXISTS effect_cf_alarm_attempts (
-  storage_id TEXT PRIMARY KEY,
-  revision TEXT NOT NULL,
-  attempts INTEGER NOT NULL,
-  parked INTEGER NOT NULL,
+  payload TEXT NOT NULL,
+  revision TEXT NOT NULL DEFAULT '',
+  attempts INTEGER NOT NULL DEFAULT 0,
+  parked INTEGER NOT NULL DEFAULT 0,
   retry_at INTEGER,
-  progress INTEGER NOT NULL
+  progress INTEGER NOT NULL DEFAULT -1
 );
 `;
 
 const WAKE_INDEX = "idx_effect_cf_scheduled_alarms_wake_at_storage_id";
-const LIFECYCLE_INDEX = "idx_effect_cf_scheduled_alarms_lifecycle_wake_at_storage_id";
+const LIFECYCLE_INDEX = "idx_effect_cf_scheduled_alarms_lifecycle_wake_at_storage_id_v2";
 
 const DEFAULT_PROCESS_DUE_ALARMS_LIMIT = 100;
 
@@ -46,6 +46,7 @@ export const MIN_RETRY_DELAY_MS = 1_000;
 export const UNCHANGED_ATTEMPT_BUDGET = 8;
 /** Minimum and default parked recovery interval. */
 export const PARKED_RETRY_DELAY_MS = 3_600_000;
+const DEFAULT_IN_FLIGHT_RECOVERY_MS = 1_000;
 
 /** Absolute product repeat floor. */
 export const MIN_REPEAT_INTERVAL_MS = 1_000;
@@ -55,6 +56,8 @@ export const DEFAULT_MIN_REPEAT_INTERVAL_MS = 60_000;
 export 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. */
@@ -81,6 +84,7 @@ const AlarmLifecycleSchema = S.Literals(["automatic", "manual"]);
 
 const ScheduleConfigurationSchema = S.Struct({
   dispatchAfterEvent: S.Boolean,
+  inFlightRecovery: safeIntegerAtLeast(1),
   minimumRetryDelay: safeIntegerAtLeast(MIN_RETRY_DELAY_MS),
   unchangedAttemptBudget: safeIntegerAtLeast(1),
   parkedRetryDelay: safeIntegerAtLeast(PARKED_RETRY_DELAY_MS),
@@ -126,15 +130,8 @@ interface AlarmRow extends Record<string, SqlStorageValue> {
   readonly progress: number;
 }
 
-const alarmRowsSql = `
-  SELECT a.*, COALESCE(s.revision, '') AS revision,
-         COALESCE(s.attempts, 0) AS attempts, COALESCE(s.parked, 0) AS parked,
-         s.retry_at, COALESCE(s.progress, -1) AS progress
-    FROM effect_cf_scheduled_alarms a
-    LEFT JOIN effect_cf_alarm_attempts s USING (storage_id)`;
-
-const sameRevisionSql = `storage_id = ? AND COALESCE(
-  (SELECT revision FROM effect_cf_alarm_attempts WHERE storage_id = ?), '') = ?`;
+const alarmRowsSql = "SELECT a.* FROM effect_cf_scheduled_alarms a";
+const sameRevisionSql = "storage_id = ? AND revision = ?";
 
 /** Content-free: no alarm identifiers, payload, error text or consumer state. */
 export const AlarmParked = S.TaggedStruct("AlarmParked", {
@@ -230,6 +227,9 @@ const getScheduleConfiguration = Effect.fnUntraced(function* (defaults: Schedule
     try: () =>
       S.decodeUnknownSync(ScheduleConfigurationSchema)({
         dispatchAfterEvent: input.dispatchAfterEvent ?? false,
+        inFlightRecovery: Math.ceil(
+          Duration.toMillis(input.inFlightRecovery ?? DEFAULT_IN_FLIGHT_RECOVERY_MS),
+        ),
         minimumRetryDelay: Math.ceil(
           Duration.toMillis(input.minimumRetryDelay ?? MIN_RETRY_DELAY_MS),
         ),
@@ -351,6 +351,16 @@ export type AlarmTransaction = Pick<
   "scheduleAlarm" | "scheduleAlarmEarlier" | "cancelAlarm"
 >;
 
+/** Share the same native commit and connection permit as the caller's SQL writes. */
+export interface AlarmTransactionOptions {
+  /** Must be a storage-backed @effect/sql-sqlite-do client for this Durable Object. */
+  readonly sqlClient: SqlClient;
+}
+
+const StorageSqlClient = S.declare<SqliteClient.SqliteClient>(
+  (value): value is SqliteClient.SqliteClient => Predicate.hasProperty(value, SqliteClient.TypeId),
+);
+
 export interface AlarmStatus {
   readonly attempts: number;
   readonly parked: boolean;
@@ -385,7 +395,7 @@ export type AlarmScheduler = {
    * 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
-   * parkedRetryDelay bounds the shared guard; renew it if it expires and is consumed while
+   * 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>(
@@ -394,7 +404,7 @@ export type AlarmScheduler = {
   /**
    * Commits local application storage and logical alarms in one native SQLite
    * Durable Object transaction, reconciling the native alarm before commit.
-   * Use the supplied mutations, not standalone alarm methods or nested transactions.
+   * Use the supplied mutations inside the callback instead of standalone alarm methods.
    * SqlClient queries must use this same Durable Object's storage.
    *
    * Failure, defects and interruption before commit roll back. A lost reply or
@@ -405,6 +415,7 @@ export type AlarmScheduler = {
    */
   readonly transaction: <A, E, R>(
     closure: (alarms: AlarmTransaction) => Effect.Effect<A, E, R>,
+    options?: AlarmTransactionOptions,
   ) => Effect.Effect<A, E | StorageOperationError, R>;
 
   readonly cancelAlarm: (
@@ -458,13 +469,13 @@ const encodeStoredPayload = (payload: AlarmPayload) =>
   );
 
 const ensureTable = Effect.fnUntraced(function* (state: DurableObjectState["Service"]) {
-  yield* state.storage.sql.exec(INIT_TABLE_SQL);
   const index = yield* state.storage.sql.exec(
     "SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?",
     LIFECYCLE_INDEX,
   );
 
   if ((yield* index.toArray()).length > 0) return;
+  yield* state.storage.sql.exec(INIT_TABLE_SQL);
   const columns = yield* state.storage.sql.exec<{ name: string }>(
     "SELECT name FROM pragma_table_info('effect_cf_scheduled_alarms')",
   );
@@ -480,11 +491,36 @@ const ensureTable = Effect.fnUntraced(function* (state: DurableObjectState["Serv
       "ALTER TABLE effect_cf_scheduled_alarms ADD COLUMN wake_at INTEGER NOT NULL DEFAULT 0",
     );
   }
-  // Backfill once, including retained schedules from before attempt tracking existed.
-  // The wake index is the durable migration marker and is created only after the backfill.
+  for (const [column, definition] of Object.entries({
+    revision: "TEXT NOT NULL DEFAULT ''",
+    attempts: "INTEGER NOT NULL DEFAULT 0",
+    parked: "INTEGER NOT NULL DEFAULT 0",
+    retry_at: "INTEGER",
+    progress: "INTEGER NOT NULL DEFAULT -1",
+  })) {
+    if (!names.has(column))
+      yield* state.storage.sql.exec(
+        `ALTER TABLE effect_cf_scheduled_alarms ADD COLUMN ${column} ${definition}`,
+      );
+  }
+  const attempts = yield* state.storage.sql.exec(
+    "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'effect_cf_alarm_attempts'",
+  );
+
+  if ((yield* attempts.toArray()).length > 0) {
+    yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms SET
+      (revision, attempts, parked, retry_at, progress) =
+      (SELECT revision, attempts, parked, retry_at, progress FROM effect_cf_alarm_attempts s
+       WHERE s.storage_id = effect_cf_scheduled_alarms.storage_id)
+      WHERE storage_id IN (SELECT storage_id FROM effect_cf_alarm_attempts)`);
+    yield* state.storage.sql.exec("DROP TABLE effect_cf_alarm_attempts");
+  }
+  // The replacement lifecycle index marks the committed single-row migration.
   yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms SET
-    wake_at = MAX(run_at, COALESCE((SELECT retry_at FROM effect_cf_alarm_attempts s
-      WHERE s.storage_id = effect_cf_scheduled_alarms.storage_id), run_at))`);
+    wake_at = MAX(run_at, COALESCE(retry_at, run_at))`);
+  yield* state.storage.sql.exec(
+    "DROP INDEX IF EXISTS idx_effect_cf_scheduled_alarms_lifecycle_wake_at_storage_id",
+  );
   yield* state.storage.sql.exec(
     "DROP INDEX IF EXISTS idx_effect_cf_scheduled_alarms_run_at_storage_id",
   );
@@ -676,6 +712,7 @@ export interface DefinedAlarmScheduler<
   ) => ReturnType<AlarmScheduler["getAlarmStatus"]>;
   readonly transaction: <A, E, R>(
     closure: (alarms: DefinedAlarmTransaction<Definitions>) => Effect.Effect<A, E, R>,
+    options?: AlarmTransactionOptions,
   ) => Effect.Effect<A, E | StorageOperationError, R>;
 }
 
@@ -943,7 +980,7 @@ const makeDefinition = <const Definitions extends AlarmDefinitions>(definitions:
       ...bind(alarms),
       deferWakes: alarms.deferWakes,
       getAlarmStatus: (input) => alarms.getAlarmStatus(input),
-      transaction: (closure) => alarms.transaction((tx) => closure(bind(tx))),
+      transaction: (closure, options) => alarms.transaction((tx) => closure(bind(tx)), options),
     }),
     handlers: <R = never, E = never>(
       handlers: DefinedAlarmHandlers<Definitions, R, E>,
@@ -1154,21 +1191,14 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
         progress: number,
       ) {
         yield* state.storage.sql.exec(
-          `INSERT OR REPLACE INTO effect_cf_alarm_attempts
-            (storage_id, revision, attempts, parked, retry_at, progress)
-           VALUES (?, ?, ?, ?, ?, ?)`,
-          storageId,
+          `UPDATE effect_cf_scheduled_alarms SET revision = ?, attempts = ?, parked = ?,
+             retry_at = ?, progress = ?, wake_at = MAX(run_at, COALESCE(?, run_at))
+           WHERE storage_id = ?`,
           crypto.randomUUID(),
           attempts,
           parked,
           retryAt,
           progress,
-        );
-        // Materialize the effective wake in the same transaction for indexed dispatch/reconciliation.
-        yield* state.storage.sql.exec(
-          `UPDATE effect_cf_scheduled_alarms
-            SET wake_at = MAX(run_at, COALESCE(?, run_at))
-            WHERE storage_id = ?`,
           retryAt,
           storageId,
         );
@@ -1182,10 +1212,6 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
           `DELETE FROM effect_cf_scheduled_alarms WHERE storage_id = ?`,
           storageId,
         );
-        yield* state.storage.sql.exec(
-          `DELETE FROM effect_cf_alarm_attempts WHERE storage_id = ?`,
-          storageId,
-        );
       });
 
       const scheduleAlarm = Effect.fn("DurableObjectAlarm.scheduleAlarm")(function* (
@@ -1215,6 +1241,34 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
         );
         const payload = yield* encodeStoredPayload(input.payload);
         const storageId = getScheduledEventId(ref);
+        const runAt = DateTime.toEpochMillis(input.runAt);
+
+        if (lifecycle === "manual") {
+          // The queue owns attempts. One row carries the aggregate deadline and dispatch fence.
+          const deadline = earlier ? "MIN(run_at, excluded.run_at)" : "excluded.run_at";
+          const nextPayload = earlier
+            ? "CASE WHEN run_at <= excluded.run_at THEN payload ELSE excluded.payload END"
+            : "excluded.payload";
+
+          yield* state.storage.sql.exec(
+            `INSERT INTO effect_cf_scheduled_alarms
+              (storage_id, alarm_id, tag, lifecycle, run_at, wake_at, payload, revision)
+             VALUES (?, ?, ?, 'manual', ?, ?, ?, ?)
+             ON CONFLICT(storage_id) DO UPDATE SET
+               lifecycle = 'manual', run_at = ${deadline}, wake_at = ${deadline},
+               payload = ${nextPayload}, revision = excluded.revision,
+               repeat_every_ms = NULL, attempts = 0, parked = 0, retry_at = NULL, progress = -1`,
+            storageId,
+            ref.id,
+            ref.tag,
+            runAt,
+            runAt,
+            payload,
+            crypto.randomUUID(),
+          );
+
+          return;
+        }
         const existing = yield* readRow(storageId);
         const pass = yield* CurrentAlarmPass;
         const source =
@@ -1252,22 +1306,17 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
         const now = yield* Clock.currentTimeMillis;
         const retryAt =
           attempts === 0 ? null : now + retryDelay(attempts, configuration, parked === 1);
-        const runAt = DateTime.toEpochMillis(input.runAt);
         const keepEarlier = earlier && existing !== undefined && existing.run_at <= runAt;
         const scheduledAt = keepEarlier ? existing.run_at : runAt;
         const scheduledPayload = keepEarlier ? existing.payload : payload;
-        const scheduledRepeat =
-          lifecycle === "manual"
-            ? null
-            : keepEarlier
-              ? existing.repeat_every_ms
-              : repeatEveryMillis;
-        const nextProgress = lifecycle === "manual" ? -1 : Math.max(progress, input.progress ?? -1);
+        const scheduledRepeat = keepEarlier ? existing.repeat_every_ms : repeatEveryMillis;
+        const nextProgress = Math.max(progress, input.progress ?? -1);
 
         yield* state.storage.sql.exec(
           `INSERT OR REPLACE INTO effect_cf_scheduled_alarms
-            (storage_id, alarm_id, tag, lifecycle, run_at, repeat_every_ms, payload)
-           VALUES (?, ?, ?, ?, ?, ?, ?)`,
+            (storage_id, alarm_id, tag, lifecycle, run_at, repeat_every_ms, payload,
+             wake_at, revision, attempts, parked, retry_at, progress)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
           storageId,
           ref.id,
           ref.tag,
@@ -1275,8 +1324,13 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
           scheduledAt,
           scheduledRepeat,
           scheduledPayload,
+          Math.max(scheduledAt, retryAt ?? scheduledAt),
+          crypto.randomUUID(),
+          attempts,
+          parked,
+          retryAt,
+          nextProgress,
         );
-        yield* writeAttempts(storageId, attempts, parked, retryAt, nextProgress);
         if (parked === 1 && retryAt !== null && (existing?.parked ?? source?.parked ?? 0) === 0) {
           reports.push(storageId);
         }
@@ -1303,20 +1357,22 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
         }
       });
 
-      const transaction: AlarmScheduler["transaction"] = Effect.fnUntraced(function* (closure) {
-        const pass = yield* CurrentAlarmPass;
+      const transaction: AlarmScheduler["transaction"] = Effect.fnUntraced(
+        function* (closure, options) {
+          const pass = yield* CurrentAlarmPass;
 
-        if (pass !== undefined && !pass.active) {
-          return yield* Effect.fail(
-            new StorageOperationError({
-              operation: "alarm.transaction",
-              cause: new Error("Alarm handlers cannot mutate detached work after their pass ends"),
-            }),
-          );
-        }
-        const reports: string[] = [];
-        const result = yield* state.storage.transaction(() =>
-          Effect.withFiber((owner) => {
+          if (pass !== undefined && !pass.active) {
+            return yield* Effect.fail(
+              new StorageOperationError({
+                operation: "alarm.transaction",
+                cause: new Error(
+                  "Alarm handlers cannot mutate detached work after their pass ends",
+                ),
+              }),
+            );
+          }
+          const reports: string[] = [];
+          const body = Effect.withFiber((owner) => {
             let active = true;
             const requireActive = <A, E>(effect: Effect.Effect<A, E>) =>
               Effect.withFiber<A, E | StorageOperationError>((fiber) =>
@@ -1354,13 +1410,44 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
 
               return result;
             });
-          }),
-        );
+          });
+          const result = yield* options === undefined
+            ? state.storage.transaction(() => body)
+            : Effect.gen(function* () {
+                const client = yield* S.decodeUnknownEffect(StorageSqlClient)(
+                  options.sqlClient,
+                ).pipe(
+                  Effect.mapError(
+                    (cause) => new StorageOperationError({ operation: "alarm.transaction", cause }),
+                  ),
+                );
 
-        yield* reportParked(reports);
+                if (client.config.storage !== state.raw.storage)
+                  return yield* Effect.fail(
+                    new StorageOperationError({
+                      operation: "alarm.transaction",
+                      cause: new Error(
+                        "Alarm transactions require this Durable Object's storage-backed SQL client",
+                      ),
+                    }),
+                  );
 
-        return result;
-      });
+                return yield* client
+                  .withTransaction(body)
+                  .pipe(
+                    Effect.mapError((cause) =>
+                      cause instanceof SqlError
+                        ? new StorageOperationError({ operation: "alarm.transaction", cause })
+                        : cause,
+                    ),
+                  );
+              });
+
+          yield* reportParked(reports);
+
+          return result;
+        },
+      );
 
       const deferWakes: AlarmScheduler["deferWakes"] = (body) =>
         Effect.acquireUseRelease(
@@ -1369,7 +1456,7 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
             const now = yield* Clock.currentTimeMillis;
 
             if (wakeDeferrals === 0) {
-              deferredRecoveryDelay = configuration.parkedRetryDelay;
+              deferredRecoveryDelay = configuration.inFlightRecovery;
               deferredRecoveryAt = now + deferredRecoveryDelay;
               wakesReady ??= Deferred.makeUnsafe<void>();
             }
@@ -1448,6 +1535,22 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
                           dispatchNeedsReconcile || dispatchStarted || Exit.isFailure(exit);
 
                         dispatchActive = Exit.isFailure(exit) && !dispatchStarted;
+                        if (dispatchActive) {
+                          const recoveryDelay = yield* getScheduleConfiguration(
+                            configurationDefaults,
+                          ).pipe(
+                            Effect.match({
+                              onFailure: () => PARKED_RETRY_DELAY_MS,
+                              onSuccess: (configuration) => configuration.parkedRetryDelay,
+                            }),
+                          );
+
+                          // A concurrent deferred scope retains ownership of its short guard.
+                          if (wakeDeferrals === 0) {
+                            deferredRecoveryDelay = recoveryDelay;
+                            deferredRecoveryAt = 0;
+                          }
+                        }
                         const reconciled = yield* (
                           reconcile ? transaction(() => Effect.void) : Effect.void
                         ).pipe(Effect.exit);
@@ -1493,20 +1596,12 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
         configuration: ResolvedScheduleConfiguration,
       ) {
         if (row.repeat_every_ms === null) {
-          const cursor = yield* state.storage.sql.exec(
+          yield* state.storage.sql.exec(
             `DELETE FROM effect_cf_scheduled_alarms WHERE ${sameRevisionSql}`,
             row.storage_id,
-            row.storage_id,
             row.revision,
           );
 
-          if ((yield* cursor.rowsWritten) > 0) {
-            yield* state.storage.sql.exec(
-              `DELETE FROM effect_cf_alarm_attempts WHERE storage_id = ?`,
-              row.storage_id,
-            );
-          }
-
           return;
         }
         const now = yield* Clock.currentTimeMillis;
@@ -1514,7 +1609,6 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
           `UPDATE effect_cf_scheduled_alarms SET run_at = ? WHERE ${sameRevisionSql}`,
           now + Math.max(configuration.minimumRepeatInterval, row.repeat_every_ms),
           row.storage_id,
-          row.storage_id,
           row.revision,
         );
 
@@ -1570,12 +1664,17 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
           yield* transaction(() =>
             Effect.gen(function* () {
               for (const row of manualRows) {
-                // Keep the selected revision: a racing replacement must survive this guard.
+                // Keep work eligible after eviction; unknown registrations stay parked.
+                const recoveryAt =
+                  now +
+                  (options?.[ManualTags]?.has(row.tag)
+                    ? configuration.inFlightRecovery
+                    : configuration.parkedRetryDelay);
+
                 yield* state.storage.sql.exec(
                   `UPDATE effect_cf_scheduled_alarms SET run_at = ?, wake_at = ? WHERE ${sameRevisionSql}`,
-                  now + configuration.parkedRetryDelay,
-                  now + configuration.parkedRetryDelay,
-                  row.storage_id,
+                  recoveryAt,
+                  recoveryAt,
                   row.storage_id,
                   row.revision,
                 );
@@ -1686,7 +1785,22 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
               { concurrency: 2 },
             );
 
-        yield* transaction(() => Effect.void);
+        yield* transaction(() =>
+          Effect.gen(function* () {
+            const recoveryAt = (yield* Clock.currentTimeMillis) + configuration.parkedRetryDelay;
+
+            for (const row of manualRows) {
+              // Only a returned handler with no newer checkpoint falls back to parked recovery.
+              yield* state.storage.sql.exec(
+                `UPDATE effect_cf_scheduled_alarms SET run_at = ?, wake_at = ? WHERE ${sameRevisionSql}`,
+                recoveryAt,
+                recoveryAt,
+                row.storage_id,
+                row.revision,
+              );
+            }
+          }),
+        );
         yield* Exit.asVoidAll(exits);
 
         return { failed, handled, parked };