effect-cf 0.50.0 → 0.52.0

package/dist/DurableObjectAlarm.mjs

@@ -9,19 +9,28 @@ import * as S from "effect/Schema";
 import * as Layer from "effect/Layer";
 import * as Predicate from "effect/Predicate";
 import * as Exit from "effect/Exit";
-import * as Clock from "effect/Clock";
 import * as Duration from "effect/Duration";
+import * as Clock from "effect/Clock";
 import * as DateTime from "effect/DateTime";
 //#region src/DurableObjectAlarm.ts
 var DurableObjectAlarm_exports = /* @__PURE__ */ __exportAll({
+	AlarmParked: () => AlarmParked,
+	AlarmReporter: () => AlarmReporter,
+	DEFAULT_MIN_REPEAT_INTERVAL_MS: () => DEFAULT_MIN_REPEAT_INTERVAL_MS,
 	DurableObjectAlarm: () => DurableObjectAlarm,
 	DurableObjectAlarmEvent: () => DurableObjectAlarmEvent,
 	InvalidAlarmPayloadError: () => InvalidAlarmPayloadError,
 	InvalidAlarmRefError: () => InvalidAlarmRefError,
 	InvalidProcessDueAlarmsOptionsError: () => InvalidProcessDueAlarmsOptionsError,
 	InvalidRepeatEveryError: () => InvalidRepeatEveryError,
+	InvalidScheduleConfigurationError: () => InvalidScheduleConfigurationError,
+	MIN_REPEAT_INTERVAL_MS: () => MIN_REPEAT_INTERVAL_MS,
+	MIN_RETRY_DELAY_MS: () => MIN_RETRY_DELAY_MS,
+	PARKED_RETRY_DELAY_MS: () => PARKED_RETRY_DELAY_MS,
+	ScheduleConfiguration: () => ScheduleConfiguration,
 	StoredAlarmDecodeError: () => StoredAlarmDecodeError,
 	Tag: () => Tag,
+	UNCHANGED_ATTEMPT_BUDGET: () => 8,
 	define: () => define,
 	processDue: () => processDue
 });
@@ -31,15 +40,55 @@ CREATE TABLE IF NOT EXISTS effect_cf_scheduled_alarms (
   alarm_id TEXT NOT NULL,
   tag TEXT NOT NULL,
   run_at INTEGER NOT NULL,
+  wake_at INTEGER NOT NULL DEFAULT 0,
   repeat_every_ms INTEGER,
   payload TEXT NOT NULL
 );
-CREATE INDEX IF NOT EXISTS idx_effect_cf_scheduled_alarms_run_at_storage_id
-  ON effect_cf_scheduled_alarms (run_at, storage_id);
+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,
+  retry_at INTEGER,
+  progress INTEGER NOT NULL
+);
 `;
+const WAKE_INDEX = "idx_effect_cf_scheduled_alarms_wake_at_storage_id";
 const DEFAULT_PROCESS_DUE_ALARMS_LIMIT = 100;
-const DEFAULT_PROCESS_DUE_ALARMS_FAILURE_RESCHEDULE_AFTER = "30 seconds";
+const MIN_RETRY_DELAY_MS = 1e3;
+/** Minimum and default parked recovery interval. */
+const PARKED_RETRY_DELAY_MS = 36e5;
+/** Absolute product repeat floor. */
+const MIN_REPEAT_INTERVAL_MS = 1e3;
+/** Default product schedule floor. Never use repeats to poll state. */
+const DEFAULT_MIN_REPEAT_INTERVAL_MS = 6e4;
+/** Optional policy overrides. Provide with Layer.succeed in the Durable Object's application layer. */
+const ScheduleConfiguration = Context.Reference("effect-cf/DurableObjectAlarm/ScheduleConfiguration", { defaultValue: () => ({}) });
+const safeIntegerAtLeast = (minimum) => S.Int.check(S.isGreaterThanOrEqualTo(minimum), S.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
+const ScheduleConfigurationSchema = S.Struct({
+	minimumRetryDelay: safeIntegerAtLeast(MIN_RETRY_DELAY_MS),
+	unchangedAttemptBudget: safeIntegerAtLeast(1),
+	parkedRetryDelay: safeIntegerAtLeast(PARKED_RETRY_DELAY_MS),
+	minimumRepeatInterval: safeIntegerAtLeast(MIN_REPEAT_INTERVAL_MS)
+}).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 = ?), '') = ?`;
+/** Content-free: no alarm identifiers, payload, error text or consumer state. */
+const AlarmParked = S.TaggedStruct("AlarmParked", {
+	attempts: S.Int,
+	retryAt: S.DateTimeUtc
+});
+/** Install with Layer.succeed / Effect.provideService. Reporting cannot undo a committed guard. */
+const AlarmReporter = Context.Reference("effect-cf/DurableObjectAlarm/AlarmReporter", { defaultValue: () => (event) => Effect.logWarning(event) });
+const CurrentAlarmPass = Context.Reference("effect-cf/DurableObjectAlarm/CurrentAlarmPass", { defaultValue: () => void 0 });
 var InvalidAlarmRefError = class extends Data.TaggedError("InvalidAlarmRefError") {
 	get message() {
 		return `Invalid Durable Object alarm ref: ${causeMessage(this.cause)}`;
@@ -60,6 +109,26 @@ var InvalidProcessDueAlarmsOptionsError = class extends Data.TaggedError("Invali
 		return `Invalid processDueAlarms options: ${causeMessage(this.cause)}`;
 	}
 };
+var InvalidScheduleConfigurationError = class extends Data.TaggedError("InvalidScheduleConfigurationError") {
+	get message() {
+		return `Invalid Durable Object alarm configuration: ${causeMessage(this.cause)}`;
+	}
+};
+const getScheduleConfiguration = Effect.fnUntraced(function* (defaults) {
+	const input = {
+		...defaults,
+		...yield* ScheduleConfiguration
+	};
+	return yield* Effect.try({
+		try: () => S.decodeUnknownSync(ScheduleConfigurationSchema)({
+			minimumRetryDelay: Math.ceil(Duration.toMillis(input.minimumRetryDelay ?? 1e3)),
+			unchangedAttemptBudget: input.unchangedAttemptBudget ?? 8,
+			parkedRetryDelay: Math.ceil(Duration.toMillis(input.parkedRetryDelay ?? 36e5)),
+			minimumRepeatInterval: Math.ceil(Duration.toMillis(input.minimumRepeatInterval ?? 6e4))
+		}),
+		catch: (cause) => new InvalidScheduleConfigurationError({ cause })
+	});
+});
 var StoredAlarmDecodeError = class extends Data.TaggedError("StoredAlarmDecodeError") {
 	get message() {
 		return `Failed to decode stored alarm "${this.storageId}": ${causeMessage(this.cause)}`;
@@ -83,13 +152,24 @@ const decodeStoredPayload = (row) => S.decodeUnknownEffect(StoredPayloadString)(
 	storageId: row.storage_id
 })));
 const encodeStoredPayload = (payload) => S.encodeEffect(StoredPayloadString)(payload).pipe(Effect.mapError((cause) => new InvalidAlarmPayloadError({ cause })));
-const ensureTable = (state) => state.storage.sql.exec(INIT_TABLE_SQL).pipe(Effect.asVoid);
-const toRepeatEveryMillis = (input) => {
+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 = ?", WAKE_INDEX)).toArray()).length > 0) return;
+	const columns = yield* state.storage.sql.exec("SELECT name FROM pragma_table_info('effect_cf_scheduled_alarms')");
+	if (!new Set((yield* columns.toArray()).map((column) => column.name)).has("wake_at")) yield* state.storage.sql.exec("ALTER TABLE effect_cf_scheduled_alarms ADD COLUMN wake_at INTEGER NOT NULL DEFAULT 0");
+	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))`);
+	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)`);
+});
+const toRepeatEveryMillis = (input, minimum) => {
 	if (input === void 0) return Effect.succeed(null);
 	return Effect.try({
 		try: () => {
 			const millis = Duration.toMillis(input);
-			if (!Number.isFinite(millis) || millis <= 0) throw new Error("Alarm repeatEvery must be a positive finite duration");
+			if (!Number.isFinite(millis) || millis < minimum) throw new Error(`Alarm repeatEvery must be at least ${minimum} milliseconds and finite`);
 			return Math.ceil(millis);
 		},
 		catch: (cause) => new InvalidRepeatEveryError({ cause })
@@ -113,15 +193,15 @@ const getProcessLimit = (options) => {
 	if (!Number.isSafeInteger(limit) || limit <= 0) return Effect.fail(new InvalidProcessDueAlarmsOptionsError({ cause: /* @__PURE__ */ new Error("processDueAlarms limit must be a positive safe integer") }));
 	return Effect.succeed(limit);
 };
-const toFailureRescheduleMillis = (input) => Effect.try({
+const toFailureRescheduleMillis = (input, minimum) => Effect.try({
 	try: () => {
 		const millis = Duration.toMillis(input);
 		if (!Number.isFinite(millis) || millis <= 0) throw new Error("Alarm failure rescheduleAfter must be a positive finite duration");
-		return Math.ceil(millis);
+		return Math.max(minimum, Math.ceil(millis));
 	},
 	catch: (cause) => new InvalidProcessDueAlarmsOptionsError({ cause })
 });
-const getFailureRetryDelay = (options) => toFailureRescheduleMillis(options?.retryFailedAfter ?? DEFAULT_PROCESS_DUE_ALARMS_FAILURE_RESCHEDULE_AFTER);
+const getFailureRetryDelay = (options, configuration) => toFailureRescheduleMillis(options?.retryFailedAfter ?? configuration.minimumRetryDelay, configuration.minimumRetryDelay);
 const getFailureActionMode = (action) => Predicate.isString(action) ? action : action.mode;
 const getFailureActionRetryDelay = (action) => Predicate.isString(action) || action.mode !== "retry" ? void 0 : action.retryFailedAfter;
 const processDue = (handle, options = {}) => Effect.gen(function* () {
@@ -140,25 +220,30 @@ const getAlarmDefinitionFailureAction = (definition) => {
 };
 const makeDefinition = (definitions) => {
 	const definitionFor = (tag) => Object.hasOwn(definitions, tag) ? definitions[tag] : void 0;
-	const bind = (mutations) => ({
-		scheduleAlarm: Effect.fn("DefinedAlarms.scheduleAlarm")(function* (input) {
+	const bind = (mutations) => {
+		const schedule = (method) => Effect.fn("DefinedAlarms.scheduleAlarm")(function* (input) {
 			const definition = definitionFor(input.tag);
 			if (definition === void 0) return yield* Effect.fail(new InvalidAlarmRefError({ cause: /* @__PURE__ */ new Error(`Unknown alarm tag "${input.tag}"`) }));
 			const payload = yield* S.encodeEffect(getAlarmDefinitionSchema(definition))(input.payload).pipe(Effect.flatMap(S.decodeUnknownEffect(S.Json)), Effect.mapError((cause) => new InvalidAlarmPayloadError({ cause })));
-			yield* mutations.scheduleAlarm({
+			yield* mutations[method]({
 				...input,
 				payload
 			});
-		}),
-		cancelAlarm: Effect.fn("DefinedAlarms.cancelAlarm")(function* (input) {
-			if (definitionFor(input.tag) === void 0) return yield* Effect.fail(new InvalidAlarmRefError({ cause: /* @__PURE__ */ new Error(`Unknown alarm tag "${input.tag}"`) }));
-			yield* mutations.cancelAlarm(input);
-		})
-	});
+		});
+		return {
+			scheduleAlarm: schedule("scheduleAlarm"),
+			scheduleAlarmEarlier: schedule("scheduleAlarmEarlier"),
+			cancelAlarm: Effect.fn("DefinedAlarms.cancelAlarm")(function* (input) {
+				if (definitionFor(input.tag) === void 0) return yield* Effect.fail(new InvalidAlarmRefError({ cause: /* @__PURE__ */ new Error(`Unknown alarm tag "${input.tag}"`) }));
+				yield* mutations.cancelAlarm(input);
+			})
+		};
+	};
 	return {
 		make: (alarms) => ({
 			[TypedAlarmSchedulerTypeId]: TypedAlarmSchedulerTypeId,
 			...bind(alarms),
+			getAlarmStatus: (input) => alarms.getAlarmStatus(input),
 			transaction: (closure) => alarms.transaction((tx) => closure(bind(tx)))
 		}),
 		handlers: (handlers, options) => processDue((event) => Effect.gen(function* () {
@@ -201,93 +286,137 @@ const Tag = () => (id, definitions) => {
 var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("effect-cf/DurableObjectAlarm") {
 	static layer = Layer.effect(DurableObjectAlarm, Effect.gen(function* () {
 		const state = yield* DurableObjectState;
-		const reconcileAlarm = Effect.fn("DurableObjectAlarm.reconcileAlarm")(function* () {
-			const next = (yield* (yield* state.storage.sql.exec(`SELECT run_at FROM effect_cf_scheduled_alarms ORDER BY run_at ASC, storage_id ASC LIMIT 1`)).toArray())[0];
-			if (next === void 0) {
-				yield* state.storage.deleteAlarm();
-				return;
-			}
-			yield* state.storage.setAlarm(next.run_at);
+		const configurationDefaults = { ...yield* ScheduleConfiguration };
+		const readRow = Effect.fnUntraced(function* (storageId) {
+			return (yield* (yield* state.storage.sql.exec(`${alarmRowsSql} WHERE a.storage_id = ?`, storageId)).toArray())[0];
 		});
-		const rescheduleFailedAlarm = Effect.fn("DurableObjectAlarm.rescheduleFailedAlarm")(function* (row, retryDelayMillis) {
-			const retryAt = (yield* Clock.currentTimeMillis) + retryDelayMillis;
-			if (row.repeat_every_ms === null) {
-				yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms
-                  SET run_at = ?
-                WHERE storage_id = ?
-                  AND run_at = ?
-                  AND repeat_every_ms IS NULL
-                  AND payload = ?`, retryAt, row.storage_id, row.run_at, row.payload)).rowsWritten;
-				return;
-			}
-			yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms
-                SET run_at = ?
-              WHERE storage_id = ?
-                AND run_at = ?
-                AND repeat_every_ms = ?
-                AND payload = ?`, retryAt, row.storage_id, row.run_at, row.repeat_every_ms, row.payload)).rowsWritten;
+		const reconcileAlarm = Effect.fn("DurableObjectAlarm.reconcileAlarm")(function* () {
+			const next = (yield* (yield* state.storage.sql.exec(`SELECT wake_at AS run_at FROM effect_cf_scheduled_alarms
+            ORDER BY wake_at, storage_id LIMIT 1`)).toArray())[0];
+			yield* Effect.tryPromise({
+				try: () => next === void 0 ? state.raw.storage.deleteAlarm() : state.raw.storage.setAlarm(next.run_at),
+				catch: (cause) => new StorageOperationError({
+					operation: next === void 0 ? "deleteAlarm" : "setAlarm",
+					cause
+				})
+			});
 		});
-		const acknowledgeAlarm = Effect.fn("DurableObjectAlarm.acknowledgeAlarm")(function* (row) {
-			if (row.repeat_every_ms === null) {
-				yield* (yield* state.storage.sql.exec(`DELETE FROM effect_cf_scheduled_alarms
-              WHERE storage_id = ?
-                AND run_at = ?
-                AND repeat_every_ms IS NULL
-                AND payload = ?`, row.storage_id, row.run_at, row.payload)).rowsWritten;
-				return;
-			}
-			const acknowledgedAt = yield* Clock.currentTimeMillis;
-			yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms
-              SET run_at = ?
-            WHERE storage_id = ?
-              AND run_at = ?
-              AND repeat_every_ms = ?
-              AND payload = ?`, acknowledgedAt + row.repeat_every_ms, row.storage_id, row.run_at, row.repeat_every_ms, row.payload)).rowsWritten;
+		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);
 		});
 		const cancelAlarm = Effect.fn("DurableObjectAlarm.cancelAlarm")(function* (input) {
 			const ref = yield* decodeAlarmRef(input);
-			yield* state.storage.sql.exec(`DELETE FROM effect_cf_scheduled_alarms WHERE storage_id = ?`, getScheduledEventId(ref));
+			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) {
+		const scheduleAlarm = Effect.fn("DurableObjectAlarm.scheduleAlarm")(function* (input, earlier, reports) {
+			const configuration = yield* getScheduleConfiguration(configurationDefaults);
 			const ref = yield* decodeAlarmRef(input);
-			const repeatEveryMillis = yield* toRepeatEveryMillis(input.repeatEvery);
+			const repeatEveryMillis = yield* toRepeatEveryMillis(input.repeatEvery, configuration.minimumRepeatInterval);
 			const payload = yield* encodeStoredPayload(input.payload);
+			const storageId = getScheduledEventId(ref);
+			const existing = yield* readRow(storageId);
+			const pass = yield* CurrentAlarmPass;
+			const source = pass?.row;
+			const progress = existing?.progress ?? source?.progress ?? -1;
+			if (pass !== void 0 && !pass.active) return yield* Effect.fail(new StorageOperationError({
+				operation: "alarm.schedule",
+				cause: /* @__PURE__ */ new Error("Alarm handlers cannot schedule detached work after their pass ends")
+			}));
+			if (input.progress !== void 0) yield* S.decodeUnknownEffect(S.Natural)(input.progress).pipe(Effect.mapError((cause) => new InvalidAlarmRefError({ cause })));
+			if (source === void 0 && input.progress !== void 0 && input.progress <= progress) return;
+			const progressed = input.progress !== void 0 && input.progress > progress;
+			const sourceProgressed = source !== void 0 && storageId === source.storage_id && progress > source.progress;
+			const attempts = source === void 0 || progressed || sourceProgressed ? 0 : source.parked === 1 || existing?.parked === 1 ? Math.max(source.attempts, existing?.attempts ?? 0) : Math.min(configuration.unchangedAttemptBudget, Math.max(source.attempts + 1, existing?.attempts ?? 0));
+			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 = 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, run_at, repeat_every_ms, payload)
-                 VALUES (?, ?, ?, ?, ?, ?)`, getScheduledEventId(ref), ref.id, ref.tag, runAt, repeatEveryMillis, payload);
+            (storage_id, alarm_id, tag, run_at, repeat_every_ms, payload)
+           VALUES (?, ?, ?, ?, ?, ?)`, storageId, ref.id, ref.tag, scheduledAt, scheduledRepeat, scheduledPayload);
+			yield* writeAttempts(storageId, attempts, parked, retryAt, nextProgress);
+			if (parked === 1 && retryAt !== null && (existing?.parked ?? source?.parked ?? 0) === 0) reports.push(storageId);
 		});
-		const transaction = (closure) => state.storage.transaction(() => Effect.withFiber((owner) => {
-			let active = true;
-			const requireActive = (effect) => Effect.withFiber((fiber) => active && fiber === owner ? effect : Effect.fail(new StorageOperationError({
-				operation: "alarm.transaction",
-				cause: /* @__PURE__ */ new Error("Alarm mutations require their active transaction callback")
-			})));
-			return Effect.gen(function* () {
-				yield* ensureTable(state);
-				const result = yield* Effect.suspend(() => closure({
-					cancelAlarm: (input) => requireActive(cancelAlarm(input)),
-					scheduleAlarm: (input) => requireActive(scheduleAlarm(input))
-				})).pipe(Effect.ensuring(Effect.sync(() => {
-					active = false;
+		const reportParked = Effect.fnUntraced(function* (storageIds) {
+			if (storageIds.length === 0) return;
+			const pass = yield* CurrentAlarmPass;
+			const report = yield* AlarmReporter;
+			for (const storageId of new Set(storageIds)) {
+				const row = yield* readRow(storageId);
+				if (row === void 0 || row.parked === 0 || row.retry_at === null) continue;
+				const event = AlarmParked.make({
+					attempts: row.attempts,
+					retryAt: DateTime.makeUnsafe(Math.max(row.run_at, row.retry_at))
+				});
+				pass?.parked.push(event);
+				yield* Effect.exit(Effect.suspend(() => report(event)));
+			}
+		});
+		const transaction = Effect.fnUntraced(function* (closure) {
+			const reports = [];
+			const result = yield* state.storage.transaction(() => Effect.withFiber((owner) => {
+				let active = true;
+				const requireActive = (effect) => Effect.withFiber((fiber) => active && fiber === owner ? effect : Effect.fail(new StorageOperationError({
+					operation: "alarm.transaction",
+					cause: /* @__PURE__ */ new Error("Alarm mutations require their active transaction callback")
 				})));
-				yield* reconcileAlarm();
-				return result;
-			});
-		}));
+				return Effect.gen(function* () {
+					yield* ensureTable(state);
+					const result = yield* Effect.suspend(() => closure({
+						cancelAlarm: (input) => requireActive(cancelAlarm(input)),
+						scheduleAlarm: (input) => requireActive(scheduleAlarm(input, false, reports)),
+						scheduleAlarmEarlier: (input) => requireActive(scheduleAlarm(input, true, reports))
+					})).pipe(Effect.ensuring(Effect.sync(() => {
+						active = false;
+					})));
+					yield* reconcileAlarm();
+					return result;
+				});
+			}));
+			yield* reportParked(reports);
+			return result;
+		});
+		const rescheduleFailedAlarm = Effect.fnUntraced(function* (row, initialDelay, configuration, reports) {
+			const current = yield* readRow(row.storage_id);
+			if (current === void 0 || current.revision !== row.revision) return;
+			const attempts = row.parked === 1 ? row.attempts : Math.min(configuration.unchangedAttemptBudget, row.attempts + 1);
+			const parked = row.parked === 1 || attempts >= configuration.unchangedAttemptBudget ? 1 : 0;
+			const retryAt = (yield* Clock.currentTimeMillis) + retryDelay(attempts, configuration, parked === 1, initialDelay);
+			yield* writeAttempts(row.storage_id, attempts, parked, retryAt, row.progress);
+			if (parked === 1 && row.parked === 0) reports.push(row.storage_id);
+		});
+		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);
+				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);
+		});
 		const processDueAlarms = Effect.fn("DurableObjectAlarm.processDueAlarms")(function* (handle, options) {
+			const configuration = yield* getScheduleConfiguration(configurationDefaults);
 			yield* ensureTable(state);
-			const mode = options?.mode ?? "isolated";
 			const limit = yield* getProcessLimit(options);
+			const initialDelay = yield* getFailureRetryDelay(options, configuration);
 			const now = yield* Clock.currentTimeMillis;
-			const dueRows = yield* (yield* state.storage.sql.exec(`SELECT storage_id, alarm_id, tag, run_at, repeat_every_ms, payload
-             FROM effect_cf_scheduled_alarms
-            WHERE run_at <= ?
-            ORDER BY run_at ASC, storage_id ASC
-            LIMIT ?`, now, limit)).toArray();
+			const dueRows = yield* (yield* state.storage.sql.exec(`${alarmRowsSql}
+            WHERE a.wake_at <= ? ORDER BY a.wake_at ASC, a.storage_id ASC LIMIT ?`, now, limit)).toArray();
 			const handled = [];
 			const failed = [];
-			const handleFailure = function* (row, event, cause) {
+			const parked = [];
+			const handleFailure = Effect.fnUntraced(function* (row, event, cause) {
 				const failure = {
 					cause,
 					event,
@@ -296,49 +425,71 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 					tag: row.tag
 				};
 				failed.push(failure);
-				const failureAction = options?.onFailure === void 0 ? void 0 : yield* options.onFailure(failure);
-				const actionMode = failureAction === void 0 ? mode : getFailureActionMode(failureAction);
-				if (actionMode === "retry" || actionMode === "isolated") {
-					const actionRetryDelay = failureAction === void 0 ? void 0 : getFailureActionRetryDelay(failureAction);
-					const retryDelay = actionRetryDelay === void 0 ? yield* getFailureRetryDelay(options) : yield* toFailureRescheduleMillis(actionRetryDelay);
-					yield* rescheduleFailedAlarm(row, retryDelay);
-					return "continue";
-				}
-				if (actionMode === "skip-and-advance-repeat") {
-					yield* acknowledgeAlarm(row);
-					return "continue";
-				}
-				yield* reconcileAlarm();
-				return "stop";
-			};
+				const actionExit = yield* Effect.exit(options?.onFailure === void 0 ? Effect.void : Effect.suspend(() => options.onFailure(failure)));
+				const action = Exit.isSuccess(actionExit) ? actionExit.value : void 0;
+				const actionMode = action === void 0 ? "retry" : getFailureActionMode(action);
+				const delayInput = action === void 0 ? void 0 : getFailureActionRetryDelay(action);
+				const delayExit = yield* Effect.exit(delayInput === void 0 ? Effect.succeed(initialDelay) : toFailureRescheduleMillis(delayInput, configuration.minimumRetryDelay));
+				const delay = Exit.isSuccess(delayExit) ? delayExit.value : initialDelay;
+				const reports = [];
+				yield* transaction(() => actionMode === "skip-and-advance-repeat" ? acknowledgeAlarm(row, configuration) : rescheduleFailedAlarm(row, delay, configuration, reports));
+				yield* reportParked(reports);
+				if (Exit.isFailure(actionExit)) return yield* Effect.failCause(actionExit.cause);
+				if (Exit.isFailure(delayExit)) return yield* Effect.failCause(delayExit.cause);
+			});
 			for (const row of dueRows) {
+				const current = yield* readRow(row.storage_id);
+				if (current === void 0 || current.revision !== row.revision) continue;
+				const inPass = (effect) => {
+					const pass = {
+						row,
+						parked,
+						active: true
+					};
+					return effect.pipe(Effect.provideService(CurrentAlarmPass, pass), Effect.ensuring(Effect.sync(() => {
+						pass.active = false;
+					})));
+				};
 				const eventExit = yield* Effect.exit(toAlarmDue(row));
 				if (Exit.isFailure(eventExit)) {
-					if ((yield* handleFailure(row, void 0, eventExit.cause)) === "stop") return yield* Effect.failCause(eventExit.cause);
+					yield* inPass(handleFailure(row, void 0, eventExit.cause));
 					continue;
 				}
 				const event = eventExit.value;
-				const handleExit = yield* Effect.exit(handle(event));
+				const handleExit = yield* Effect.exit(inPass(Effect.suspend(() => handle(event))));
 				if (Exit.isFailure(handleExit)) {
-					if ((yield* handleFailure(row, event, handleExit.cause)) === "stop") return yield* Effect.failCause(handleExit.cause);
+					yield* inPass(handleFailure(row, event, handleExit.cause));
 					continue;
 				}
-				yield* acknowledgeAlarm(row);
+				yield* transaction(() => acknowledgeAlarm(row, configuration));
 				handled.push(event);
 			}
-			yield* reconcileAlarm();
+			yield* transaction(() => Effect.void);
 			return {
 				failed,
-				handled
+				handled,
+				parked
 			};
 		});
 		return DurableObjectAlarm.of({
 			cancelAlarm: (input) => transaction((alarms) => alarms.cancelAlarm(input)),
+			getAlarmStatus: Effect.fnUntraced(function* (input) {
+				const ref = yield* decodeAlarmRef(input);
+				yield* ensureTable(state);
+				const row = yield* readRow(getScheduledEventId(ref));
+				return row === void 0 ? void 0 : {
+					attempts: row.attempts,
+					parked: row.parked === 1,
+					runAt: DateTime.makeUnsafe(row.run_at),
+					retryAt: row.retry_at === null ? void 0 : DateTime.makeUnsafe(row.retry_at)
+				};
+			}),
 			processDueAlarms,
 			scheduleAlarm: (input) => transaction((alarms) => alarms.scheduleAlarm(input)),
+			scheduleAlarmEarlier: (input) => transaction((alarms) => alarms.scheduleAlarmEarlier(input)),
 			transaction
 		});
 	}));
 };
 //#endregion
-export { DurableObjectAlarm, DurableObjectAlarmEvent, DurableObjectAlarm_exports, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, StoredAlarmDecodeError, Tag, define, processDue };
+export { AlarmParked, AlarmReporter, DEFAULT_MIN_REPEAT_INTERVAL_MS, DurableObjectAlarm, DurableObjectAlarmEvent, DurableObjectAlarm_exports, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, InvalidScheduleConfigurationError, MIN_REPEAT_INTERVAL_MS, MIN_RETRY_DELAY_MS, PARKED_RETRY_DELAY_MS, ScheduleConfiguration, StoredAlarmDecodeError, Tag, define, processDue };

package/dist/DurableObjectContainer.d.mts

@@ -3,8 +3,8 @@ import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer$1 from "effect/Layer";
 import * as Option from "effect/Option";
-import * as Duration from "effect/Duration";
 import * as Stream from "effect/Stream";
+import * as Duration from "effect/Duration";
 import { Scope } from "effect";
 declare namespace DurableObjectContainer_d_exports {
   export { ContainerError, ContainerExecOptions, ContainerExecOutput, ContainerExecOutputText, ContainerHttpReadinessOptions, ContainerInfo, ContainerNotConfiguredError, ContainerProcess, ContainerProcessLog, ContainerReadinessTimeoutError, ContainerSnapshot, ContainerSnapshotOptions, ContainerStartOptions, ContainerTcpPort, DurableObjectContainer, DurableObjectContainerService, fromContainer, layer };
@@ -92,6 +92,8 @@ interface ContainerTcpPort {
   readonly proxy: (request: Request) => Effect.Effect<Response, ContainerError>;
   /** The caller owns the returned socket and must close it. */
   readonly connect: (...args: Parameters<globalThis.Fetcher["connect"]>) => Effect.Effect<ReturnType<globalThis.Fetcher["connect"]>, ContainerError>;
+  /** Closes the socket when the scope ends, awaiting cleanup and preserving close failures as defects. */
+  readonly connectScoped: (...args: Parameters<globalThis.Fetcher["connect"]>) => Effect.Effect<ReturnType<globalThis.Fetcher["connect"]>, ContainerError, Scope.Scope>;
 }
 /** Direct container control inside a Durable Object; lifecycle policy belongs to the application. */
 interface DurableObjectContainerService {

package/dist/DurableObjectContainer.mjs

@@ -6,8 +6,8 @@ import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import * as Duration from "effect/Duration";
 import * as Stream from "effect/Stream";
+import * as Duration from "effect/Duration";
 //#region src/DurableObjectContainer.ts
 var DurableObjectContainer_exports = /* @__PURE__ */ __exportAll({
 	ContainerError: () => ContainerError,
@@ -99,6 +99,7 @@ const fromTcpPort = (port) => {
 			signal: callerSignal === null || callerSignal === void 0 ? signal : AbortSignal.any([callerSignal, signal])
 		});
 	});
+	const connect = (...args) => attempt("getTcpPort.connect", () => port.connect(...args));
 	return {
 		raw: port,
 		fetch,
@@ -107,7 +108,8 @@ const fromTcpPort = (port) => {
 			url.protocol = "http:";
 			return new Request(url, request);
 		}).pipe(Effect.flatMap((forwarded) => fetch(forwarded))),
-		connect: (...args) => attempt("getTcpPort.connect", () => port.connect(...args))
+		connect,
+		connectScoped: (...args) => Effect.acquireRelease(connect(...args), (socket) => attemptPromise("getTcpPort.close", () => socket.close()).pipe(Effect.orDie))
 	};
 };
 /** Wraps `ctx.container` without starting it or taking ownership of its lifecycle. */

package/dist/DurableObjectRpcWebSocket.d.mts

@@ -64,8 +64,8 @@ interface LayerOptions {
   readonly attachmentKey?: string | undefined;
   /**
    * Heartbeat behavior. `"auto-response"` (the default) installs Cloudflare's
-   * hibernation-safe text Ping/Pong response while an RPC socket exists and no
-   * non-resumable RPC operation is active, then removes it while one is pending.
+   * hibernation-safe text Ping/Pong response for the lifetime of RPC sockets,
+   * including pending operations. Keepalives never dispatch application code.
    * `"passthrough"` leaves the Durable Object's existing auto-response
    * configuration unchanged and makes the application responsible for waking a
    * lost pending operation.

package/dist/DurableObjectRpcWebSocket.mjs

@@ -70,7 +70,6 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	const declarationsByTag = /* @__PURE__ */ new Map();
 	const replayRequests = [];
 	let nextClientId = 0;
-	let activeNonResumableRequestCount = 0;
 	let writeRequest;
 	for (const declaration of declarations) {
 		if (declaration.id.length === 0 || declaration.rpcTag.length === 0) return yield* Effect.die(/* @__PURE__ */ new Error("Resumable RPC stream declaration ids and tags must be non-empty"));
@@ -137,7 +136,7 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 		return connection;
 	};
 	const heartbeat = yield* makeHeartbeatController(durableObjectState, serialization, heartbeatPolicy);
-	const syncHeartbeat = () => heartbeat.setEnabled(connectionsBySocket.size > 0 && activeNonResumableRequestCount === 0);
+	const syncHeartbeat = () => heartbeat.setEnabled(connectionsBySocket.size > 0);
 	const persistConnection = Effect.fn("DurableObjectRpcWebSocket.persistConnection")(function* (connection) {
 		return yield* Effect.try({
 			try: () => {
@@ -171,7 +170,6 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 		if (connection === void 0) return;
 		connectionsBySocket.delete(socket.raw);
 		connectionsById.delete(connection.id);
-		activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
 		connection.requestIds.clear();
 		connection.nonResumableRequestIds.clear();
 		connection.subscriptionsByRequestId.clear();
@@ -210,7 +208,6 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 		} else {
 			connection.requestIds.add(request.id);
 			connection.nonResumableRequestIds.add(request.id);
-			activeNonResumableRequestCount++;
 		}
 		if (!(yield* persistOrReset(connection))) return false;
 		yield* syncHeartbeat();
@@ -218,7 +215,7 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	});
 	const completeRequest = Effect.fn("DurableObjectRpcWebSocket.completeRequest")(function* (connection, requestId, preserveAckFilter = false) {
 		if (connection.requestIds.delete(requestId)) {
-			if (connection.nonResumableRequestIds.delete(requestId)) activeNonResumableRequestCount--;
+			connection.nonResumableRequestIds.delete(requestId);
 			const subscription = removeSubscription(connection, requestId);
 			connection.currentPendingRequestIds.delete(requestId);
 			if (preserveAckFilter && subscription !== void 0) connection.suppressedAckRequestIds.add(requestId);
@@ -229,7 +226,6 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	});
 	const completeAllRequests = Effect.fn("DurableObjectRpcWebSocket.completeAllRequests")(function* (connection) {
 		const hadRequests = connection.requestIds.size > 0;
-		if (connection.requestIds.size > 0) activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
 		connection.requestIds.clear();
 		connection.nonResumableRequestIds.clear();
 		connection.subscriptionsByRequestId.clear();