effect-cf 0.52.0 → 0.54.0

package/dist/DurableObjectAlarm.mjs

@@ -12,26 +12,34 @@ import * as Exit from "effect/Exit";
 import * as Duration from "effect/Duration";
 import * as Clock from "effect/Clock";
 import * as DateTime from "effect/DateTime";
+import * as Deferred from "effect/Deferred";
+import * as Semaphore from "effect/Semaphore";
 //#region src/DurableObjectAlarm.ts
 var DurableObjectAlarm_exports = /* @__PURE__ */ __exportAll({
 	AlarmParked: () => AlarmParked,
 	AlarmReporter: () => AlarmReporter,
 	DEFAULT_MIN_REPEAT_INTERVAL_MS: () => DEFAULT_MIN_REPEAT_INTERVAL_MS,
+	DispatchAfterEvent: () => DispatchAfterEvent,
 	DurableObjectAlarm: () => DurableObjectAlarm,
 	DurableObjectAlarmEvent: () => DurableObjectAlarmEvent,
+	HasDueAlarms: () => HasDueAlarms,
 	InvalidAlarmPayloadError: () => InvalidAlarmPayloadError,
 	InvalidAlarmRefError: () => InvalidAlarmRefError,
+	InvalidAlarmRegistrationError: () => InvalidAlarmRegistrationError,
 	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,
+	RunAlarm: () => RunAlarm,
 	ScheduleConfiguration: () => ScheduleConfiguration,
 	StoredAlarmDecodeError: () => StoredAlarmDecodeError,
 	Tag: () => Tag,
 	UNCHANGED_ATTEMPT_BUDGET: () => 8,
 	define: () => define,
+	dispatchRawAlarm: () => dispatchRawAlarm,
+	mergeAll: () => mergeAll,
 	processDue: () => processDue
 });
 const INIT_TABLE_SQL = `
@@ -39,6 +47,7 @@ CREATE TABLE IF NOT EXISTS effect_cf_scheduled_alarms (
   storage_id TEXT PRIMARY KEY,
   alarm_id TEXT NOT NULL,
   tag TEXT NOT NULL,
+  lifecycle TEXT NOT NULL DEFAULT 'automatic',
   run_at INTEGER NOT NULL,
   wake_at INTEGER NOT NULL DEFAULT 0,
   repeat_every_ms INTEGER,
@@ -54,6 +63,7 @@ CREATE TABLE IF NOT EXISTS effect_cf_alarm_attempts (
 );
 `;
 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 DEFAULT_PROCESS_DUE_ALARMS_LIMIT = 100;
 const MIN_RETRY_DELAY_MS = 1e3;
 /** Minimum and default parked recovery interval. */
@@ -65,7 +75,9 @@ 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 AlarmLifecycleSchema = S.Literals(["automatic", "manual"]);
 const ScheduleConfigurationSchema = S.Struct({
+	dispatchAfterEvent: S.Boolean,
 	minimumRetryDelay: safeIntegerAtLeast(MIN_RETRY_DELAY_MS),
 	unchangedAttemptBudget: safeIntegerAtLeast(1),
 	parkedRetryDelay: safeIntegerAtLeast(PARKED_RETRY_DELAY_MS),
@@ -89,6 +101,9 @@ const AlarmParked = S.TaggedStruct("AlarmParked", {
 /** 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 });
+/** One dispatcher's view of a registration pass: its tags, shared manual permits, raw tracking. */
+const CurrentDispatch = Context.Reference("effect-cf/DurableObjectAlarm/CurrentDispatch", { defaultValue: () => void 0 });
+const ManualTags = Symbol("effect-cf/DurableObjectAlarm/ManualTags");
 var InvalidAlarmRefError = class extends Data.TaggedError("InvalidAlarmRefError") {
 	get message() {
 		return `Invalid Durable Object alarm ref: ${causeMessage(this.cause)}`;
@@ -114,6 +129,11 @@ var InvalidScheduleConfigurationError = class extends Data.TaggedError("InvalidS
 		return `Invalid Durable Object alarm configuration: ${causeMessage(this.cause)}`;
 	}
 };
+var InvalidAlarmRegistrationError = class extends Data.TaggedError("InvalidAlarmRegistrationError") {
+	get message() {
+		return `Invalid Durable Object alarm registration: ${causeMessage(this.cause)}`;
+	}
+};
 const getScheduleConfiguration = Effect.fnUntraced(function* (defaults) {
 	const input = {
 		...defaults,
@@ -121,6 +141,7 @@ const getScheduleConfiguration = Effect.fnUntraced(function* (defaults) {
 	};
 	return yield* Effect.try({
 		try: () => S.decodeUnknownSync(ScheduleConfigurationSchema)({
+			dispatchAfterEvent: input.dispatchAfterEvent ?? false,
 			minimumRetryDelay: Math.ceil(Duration.toMillis(input.minimumRetryDelay ?? 1e3)),
 			unchangedAttemptBudget: input.unchangedAttemptBudget ?? 8,
 			parkedRetryDelay: Math.ceil(Duration.toMillis(input.parkedRetryDelay ?? 36e5)),
@@ -146,7 +167,14 @@ const AlarmRefSchema = S.Struct({
 	tag: S.NonEmptyString
 });
 const decodeAlarmRef = (input) => S.decodeUnknownEffect(AlarmRefSchema)(input).pipe(Effect.mapError((cause) => new InvalidAlarmRefError({ cause })));
+/** @internal */
+const RunAlarm = Symbol("effect-cf/DurableObjectAlarm/RunAlarm");
+/** @internal */
+const DispatchAfterEvent = Symbol("effect-cf/DurableObjectAlarm/DispatchAfterEvent");
+/** @internal */
+const HasDueAlarms = Symbol("effect-cf/DurableObjectAlarm/HasDueAlarms");
 const StoredPayloadString = S.fromJsonString(S.Json);
+const StoredTags = S.fromJsonString(S.Array(S.String));
 const decodeStoredPayload = (row) => S.decodeUnknownEffect(StoredPayloadString)(row.payload).pipe(Effect.mapError((cause) => new StoredAlarmDecodeError({
 	cause,
 	storageId: row.storage_id
@@ -154,15 +182,19 @@ 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 = ?", WAKE_INDEX)).toArray()).length > 0) return;
+	if ((yield* (yield* state.storage.sql.exec("SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?", LIFECYCLE_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");
+	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");
 	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)`);
+	yield* state.storage.sql.exec(`CREATE INDEX IF NOT EXISTS ${LIFECYCLE_INDEX}
+    ON effect_cf_scheduled_alarms (lifecycle, wake_at, storage_id)`);
 });
 const toRepeatEveryMillis = (input, minimum) => {
 	if (input === void 0) return Effect.succeed(null);
@@ -208,6 +240,71 @@ const processDue = (handle, options = {}) => Effect.gen(function* () {
 	return yield* (yield* DurableObjectAlarm).processDueAlarms(handle, options);
 });
 const TypedAlarmSchedulerTypeId = Symbol.for("effect-cf/DurableObjectAlarm/TypedScheduler");
+const RegistrationParts = Symbol("effect-cf/DurableObjectAlarm/RegistrationParts");
+const emptyResult = {
+	failed: [],
+	handled: [],
+	parked: []
+};
+const missingAlarm = (tag) => new InvalidAlarmRegistrationError({ cause: /* @__PURE__ */ new Error(`No manual handler registered for alarm tag "${tag}"`) });
+const validateRegistration = (parts) => Effect.try({
+	try: () => {
+		if (parts.invalid !== void 0) throw new Error(parts.invalid);
+		const tags = parts.dispatchers.flatMap((dispatcher) => dispatcher.tags);
+		S.decodeUnknownSync(S.Array(S.NonEmptyString))([...parts.services, ...tags]);
+		if (new Set(parts.services).size !== parts.services.length || new Set(tags).size !== tags.length) throw new Error("Alarm service keys and definition tags must be unique within a Durable Object");
+	},
+	catch: (cause) => new InvalidAlarmRegistrationError({ cause })
+});
+const runRegistrations = (parts, rawAlarm) => Effect.gen(function* () {
+	yield* validateRegistration(parts);
+	const alarms = yield* DurableObjectAlarm;
+	const permits = yield* Semaphore.make(4);
+	const parentRaw = (yield* CurrentDispatch)?.raw;
+	const recoveryScope = {
+		tags: parts.dispatchers.flatMap((dispatcher) => dispatcher.tags),
+		exclude: true,
+		permits,
+		raw: parentRaw
+	};
+	const recovery = rawAlarm === void 0 ? makeDefinition({}).handlers({}).pipe(Effect.provideService(CurrentDispatch, recoveryScope)) : Effect.suspend(() => {
+		const raw = { processed: false };
+		return rawAlarm.pipe(Effect.onExit(() => raw.processed ? Effect.void : makeDefinition({}).handlers({}).pipe(Effect.asVoid)), Effect.provideService(CurrentDispatch, {
+			...recoveryScope,
+			raw
+		}), Effect.as(emptyResult));
+	});
+	return yield* alarms.deferWakes(Effect.gen(function* () {
+		const run = (dispatchers) => Effect.forEach(dispatchers, (dispatcher) => dispatcher.run.pipe(Effect.catchTag("InvalidProcessDueAlarmsOptionsError", (error) => Effect.fail(error).pipe(Effect.onExit(() => makeDefinition({}).handlers({}).pipe(Effect.asVoid)))), Effect.provideService(CurrentDispatch, {
+			tags: dispatcher.tags,
+			exclude: false,
+			permits,
+			raw: parentRaw
+		}), Effect.exit), { concurrency: "unbounded" });
+		const automatic = parts.dispatchers.filter((dispatcher) => rawAlarm !== void 0 && dispatcher.automatic);
+		const independent = parts.dispatchers.filter((dispatcher) => rawAlarm === void 0 || !dispatcher.automatic);
+		const exits = (yield* Effect.all([run(independent), run(automatic).pipe(Effect.flatMap((exits) => Effect.map(Effect.exit(recovery), (exit) => [...exits, exit])))], { concurrency: "unbounded" })).flat();
+		yield* Exit.asVoidAll(exits);
+		return {
+			failed: exits.flatMap((exit) => Exit.isSuccess(exit) ? exit.value.failed : []),
+			handled: exits.flatMap((exit) => Exit.isSuccess(exit) ? exit.value.handled : []),
+			parked: exits.flatMap((exit) => Exit.isSuccess(exit) ? exit.value.parked : [])
+		};
+	}));
+});
+const makeRegistration = (layer, parts) => ({
+	[RegistrationParts]: parts,
+	layer: layer.pipe(Layer.provide(Layer.effectDiscard(validateRegistration(parts)))),
+	run: runRegistrations(parts)
+});
+function mergeAll(registration, ...others) {
+	const parts = [registration, ...others].map((item) => item[RegistrationParts]);
+	return makeRegistration(Layer.mergeAll(registration.layer, ...others.map((item) => item.layer)), {
+		services: parts.flatMap((part) => part?.services ?? []),
+		dispatchers: parts.flatMap((part) => part?.dispatchers ?? []),
+		invalid: parts.some((part) => part === void 0) ? "mergeAll requires registrations returned by Tag.handlers" : parts.find((part) => part?.invalid !== void 0)?.invalid
+	});
+}
 const isAlarmDefinitionConfig = (definition) => Predicate.isObject(definition) && "payload" in definition;
 const getAlarmDefinitionSchema = (definition) => isAlarmDefinitionConfig(definition) ? definition.payload : definition;
 const getAlarmDefinitionFailureAction = (definition) => {
@@ -227,7 +324,8 @@ const makeDefinition = (definitions) => {
 			const payload = yield* S.encodeEffect(getAlarmDefinitionSchema(definition))(input.payload).pipe(Effect.flatMap(S.decodeUnknownEffect(S.Json)), Effect.mapError((cause) => new InvalidAlarmPayloadError({ cause })));
 			yield* mutations[method]({
 				...input,
-				payload
+				payload,
+				lifecycle: isAlarmDefinitionConfig(definition) ? definition.lifecycle : void 0
 			});
 		});
 		return {
@@ -243,6 +341,7 @@ const makeDefinition = (definitions) => {
 		make: (alarms) => ({
 			[TypedAlarmSchedulerTypeId]: TypedAlarmSchedulerTypeId,
 			...bind(alarms),
+			deferWakes: alarms.deferWakes,
 			getAlarmStatus: (input) => alarms.getAlarmStatus(input),
 			transaction: (closure) => alarms.transaction((tx) => closure(bind(tx)))
 		}),
@@ -264,6 +363,7 @@ const makeDefinition = (definitions) => {
 			});
 		}), {
 			...options,
+			[ManualTags]: new Set(Object.entries(definitions).filter(([, definition]) => isAlarmDefinitionConfig(definition) && definition.lifecycle === "manual").map(([tag]) => tag)),
 			onFailure: (failure) => Effect.gen(function* () {
 				const action = getAlarmDefinitionFailureAction(definitionFor(failure.tag));
 				const optionAction = options?.onFailure === void 0 ? void 0 : yield* options.onFailure(failure);
@@ -274,32 +374,70 @@ const makeDefinition = (definitions) => {
 };
 /** Handler-only definitions for applications using the raw scheduler. Prefer Tag for typed scheduling. */
 const define = (definitions) => ({ handlers: makeDefinition(definitions).handlers });
+const hasSchedulerTables = Effect.fnUntraced(function* (state) {
+	return yield* Effect.gen(function* () {
+		if (state.raw.storage.sql === void 0) return false;
+		return (yield* (yield* state.storage.sql.exec("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1", "effect_cf_scheduled_alarms")).toArray()).length > 0;
+	}).pipe(Effect.catchIf((error) => error.cause instanceof Error && (error.cause.message.startsWith("SQL is not enabled for this Durable Object class") || error.cause.message.startsWith("This Durable Object is not backed by SQLite storage")), () => Effect.succeed(false)));
+});
+/** @internal Preserve custom dispatch while recovering retained alarms after deployments. */
+const dispatchRawAlarm = (rawAlarm, registration) => Effect.gen(function* () {
+	const parts = registration?.[RegistrationParts];
+	if (parts !== void 0) return yield* runRegistrations(parts, rawAlarm).pipe(Effect.asVoid);
+	const custom = registration === void 0 ? rawAlarm : registration.run.pipe(Effect.andThen(rawAlarm));
+	const state = yield* DurableObjectState;
+	if (!(yield* hasSchedulerTables(state))) return yield* custom;
+	return yield* runRegistrations({
+		services: [],
+		dispatchers: []
+	}, custom).pipe(Effect.asVoid);
+});
 /** The typed scheduler becomes available when its handlers are registered on a Durable Object. */
 const Tag = () => (id, definitions) => {
 	const tag = Context.Service()(id);
 	const definition = makeDefinition(definitions);
-	return Object.assign(tag, { handlers: (handlers, options) => ({
-		layer: Layer.effect(tag, Effect.map(DurableObjectAlarm, definition.make)),
-		run: definition.handlers(handlers, options)
+	return Object.assign(tag, { handlers: (handlers, options) => makeRegistration(Layer.effect(tag, Effect.map(DurableObjectAlarm, definition.make)), {
+		services: [id],
+		dispatchers: [{
+			tags: Object.keys(definitions),
+			automatic: Object.values(definitions).some((entry) => !isAlarmDefinitionConfig(entry) || entry.lifecycle !== "manual"),
+			run: definition.handlers(handlers, options)
+		}]
 	}) });
 };
 var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("effect-cf/DurableObjectAlarm") {
 	static layer = Layer.effect(DurableObjectAlarm, Effect.gen(function* () {
 		const state = yield* DurableObjectState;
 		const configurationDefaults = { ...yield* ScheduleConfiguration };
+		let wakeDeferrals = 0;
+		let wakesReady;
+		let pendingAlarm;
+		let dispatchActive = false;
+		let dispatchNeedsReconcile = false;
+		let deferredRecoveryDelay = PARKED_RETRY_DELAY_MS;
+		let deferredRecoveryAt = 0;
 		const readRow = Effect.fnUntraced(function* (storageId) {
 			return (yield* (yield* state.storage.sql.exec(`${alarmRowsSql} WHERE a.storage_id = ?`, storageId)).toArray())[0];
 		});
+		const writeNativeAlarm = (runAt) => Effect.tryPromise({
+			try: () => runAt === null ? state.raw.storage.deleteAlarm() : state.raw.storage.setAlarm(runAt),
+			catch: (cause) => new StorageOperationError({
+				operation: runAt === null ? "deleteAlarm" : "setAlarm",
+				cause
+			})
+		});
 		const reconcileAlarm = Effect.fn("DurableObjectAlarm.reconcileAlarm")(function* () {
+			if (wakeDeferrals > 0 || dispatchActive) {
+				if (dispatchActive) dispatchNeedsReconcile = true;
+				const current = yield* state.storage.getAlarm();
+				const now = yield* Clock.currentTimeMillis;
+				if (deferredRecoveryAt <= now) deferredRecoveryAt = now + deferredRecoveryDelay;
+				if (current === null || current <= now || current > deferredRecoveryAt) yield* writeNativeAlarm(deferredRecoveryAt);
+				return;
+			}
 			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
-				})
-			});
+           ORDER BY wake_at, storage_id LIMIT 1`)).toArray())[0];
+			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
@@ -318,17 +456,15 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 		const scheduleAlarm = Effect.fn("DurableObjectAlarm.scheduleAlarm")(function* (input, earlier, reports) {
 			const configuration = yield* getScheduleConfiguration(configurationDefaults);
 			const ref = yield* decodeAlarmRef(input);
+			const lifecycle = yield* S.decodeUnknownEffect(AlarmLifecycleSchema)(input.lifecycle ?? "automatic").pipe(Effect.mapError((cause) => new InvalidAlarmRefError({ cause })));
+			if (lifecycle === "manual" && (input.repeatEvery !== void 0 || input.progress !== void 0)) return yield* Effect.fail(new InvalidAlarmRefError({ cause: /* @__PURE__ */ new Error("Manual alarms own their repeats and progress budgets") }));
 			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 source = lifecycle === "automatic" && pass?.row.lifecycle === "automatic" ? pass.row : void 0;
 			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;
@@ -341,11 +477,11 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			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);
+			const scheduledRepeat = lifecycle === "manual" ? null : keepEarlier ? existing.repeat_every_ms : repeatEveryMillis;
+			const nextProgress = lifecycle === "manual" ? -1 : 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 (?, ?, ?, ?, ?, ?)`, storageId, ref.id, ref.tag, scheduledAt, scheduledRepeat, scheduledPayload);
+            (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);
 			if (parked === 1 && retryAt !== null && (existing?.parked ?? source?.parked ?? 0) === 0) reports.push(storageId);
 		});
@@ -365,10 +501,15 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			}
 		});
 		const transaction = Effect.fnUntraced(function* (closure) {
+			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) => {
 				let active = true;
-				const requireActive = (effect) => Effect.withFiber((fiber) => active && fiber === owner ? effect : Effect.fail(new StorageOperationError({
+				const requireActive = (effect) => Effect.withFiber((fiber) => active && fiber === owner && (pass === void 0 || pass.active) ? effect : Effect.fail(new StorageOperationError({
 					operation: "alarm.transaction",
 					cause: /* @__PURE__ */ new Error("Alarm mutations require their active transaction callback")
 				})));
@@ -388,6 +529,50 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			yield* reportParked(reports);
 			return result;
 		});
+		const deferWakes = (body) => Effect.acquireUseRelease(Effect.gen(function* () {
+			const configuration = yield* getScheduleConfiguration(configurationDefaults);
+			const now = yield* Clock.currentTimeMillis;
+			if (wakeDeferrals === 0) {
+				deferredRecoveryDelay = configuration.parkedRetryDelay;
+				deferredRecoveryAt = now + deferredRecoveryDelay;
+				wakesReady ??= Deferred.makeUnsafe();
+			}
+			wakeDeferrals++;
+		}), () => transaction(() => Effect.void).pipe(Effect.andThen(body)), () => Effect.gen(function* () {
+			wakeDeferrals--;
+			if (wakeDeferrals === 0) yield* (dispatchActive ? Effect.void : transaction(() => Effect.void)).pipe(Effect.ensuring(Effect.sync(() => {
+				if (wakeDeferrals === 0 && wakesReady !== void 0) {
+					Deferred.doneUnsafe(wakesReady, Effect.void);
+					wakesReady = void 0;
+				}
+			})));
+		}));
+		const awaitWakes = Effect.suspend(() => wakesReady === void 0 ? Effect.void : Deferred.await(wakesReady).pipe(Effect.andThen(awaitWakes)));
+		const runAlarm = (event, native) => Effect.flatMap(hasSchedulerTables(state), (managed) => !managed ? native ? event(Effect.void) : Effect.void : Effect.uninterruptibleMask((restore) => Effect.suspend(() => {
+			const pending = pendingAlarm;
+			if (pending !== void 0) return restore((native ? transaction(() => Effect.void) : Effect.void).pipe(Effect.andThen(Deferred.await(pending))));
+			const completed = Deferred.makeUnsafe();
+			let dispatchStarted = false;
+			pendingAlarm = completed;
+			dispatchNeedsReconcile = native;
+			return restore(Effect.gen(function* () {
+				if (native && wakesReady !== void 0) yield* transaction(() => Effect.void);
+				yield* awaitWakes;
+				dispatchActive = true;
+				yield* event(Effect.gen(function* () {
+					yield* getScheduleConfiguration(configurationDefaults);
+					dispatchStarted = true;
+				}));
+			})).pipe(Effect.onExit((exit) => Effect.gen(function* () {
+				const reconcile = dispatchNeedsReconcile || dispatchStarted || Exit.isFailure(exit);
+				dispatchActive = Exit.isFailure(exit) && !dispatchStarted;
+				const reconciled = yield* (reconcile ? transaction(() => Effect.void) : Effect.void).pipe(Effect.exit);
+				dispatchActive = false;
+				pendingAlarm = void 0;
+				yield* Deferred.done(completed, Exit.asVoidAll([exit, reconciled]));
+				yield* reconciled;
+			})));
+		})));
 		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;
@@ -411,8 +596,19 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			const limit = yield* getProcessLimit(options);
 			const initialDelay = yield* getFailureRetryDelay(options, configuration);
 			const now = yield* Clock.currentTimeMillis;
-			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 dispatch = yield* CurrentDispatch;
+			if (dispatch?.raw !== void 0) dispatch.raw.processed = true;
+			const tagFilter = dispatch === void 0 ? "" : ` AND a.tag ${dispatch.exclude ? "NOT IN" : "IN"} (SELECT value FROM json_each(?))`;
+			const tagBindings = dispatch === void 0 ? [] : [S.encodeSync(StoredTags)([...dispatch.tags])];
+			const select = Effect.fnUntraced(function* (lifecycle, batchLimit) {
+				return yield* (yield* state.storage.sql.exec(`${alarmRowsSql} WHERE a.lifecycle = ? AND a.wake_at <= ?${tagFilter}
+             ORDER BY a.wake_at ASC, a.storage_id ASC LIMIT ?`, lifecycle, now, ...tagBindings, batchLimit)).toArray();
+			});
+			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);
+			}));
 			const handled = [];
 			const failed = [];
 			const parked = [];
@@ -437,9 +633,9 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 				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 handleRow = Effect.fnUntraced(function* (row) {
 				const current = yield* readRow(row.storage_id);
-				if (current === void 0 || current.revision !== row.revision) continue;
+				if (current === void 0 || current.revision !== row.revision) return;
 				const inPass = (effect) => {
 					const pass = {
 						row,
@@ -450,21 +646,27 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 						pass.active = false;
 					})));
 				};
+				const manual = row.lifecycle === "manual";
+				if (manual && !options?.[ManualTags]?.has(row.tag)) return yield* Effect.fail(missingAlarm(row.tag));
 				const eventExit = yield* Effect.exit(toAlarmDue(row));
 				if (Exit.isFailure(eventExit)) {
-					yield* inPass(handleFailure(row, void 0, eventExit.cause));
-					continue;
+					if (manual) return yield* Effect.failCause(eventExit.cause);
+					return yield* inPass(handleFailure(row, void 0, eventExit.cause));
 				}
 				const event = eventExit.value;
 				const handleExit = yield* Effect.exit(inPass(Effect.suspend(() => handle(event))));
 				if (Exit.isFailure(handleExit)) {
-					yield* inPass(handleFailure(row, event, handleExit.cause));
-					continue;
+					if (manual) return yield* Effect.failCause(handleExit.cause);
+					return yield* inPass(handleFailure(row, event, handleExit.cause));
 				}
-				yield* transaction(() => acknowledgeAlarm(row, configuration));
+				if (!manual) yield* transaction(() => acknowledgeAlarm(row, configuration));
 				handled.push(event);
-			}
+			});
+			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* Exit.asVoidAll(exits);
 			return {
 				failed,
 				handled,
@@ -472,6 +674,14 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			};
 		});
 		return DurableObjectAlarm.of({
+			[RunAlarm]: runAlarm,
+			[DispatchAfterEvent]: Effect.map(ScheduleConfiguration, (configuration) => (configuration.dispatchAfterEvent ?? configurationDefaults.dispatchAfterEvent) === true),
+			[HasDueAlarms]: Effect.gen(function* () {
+				yield* ensureTable(state);
+				const now = yield* Clock.currentTimeMillis;
+				return (yield* (yield* state.storage.sql.exec("SELECT 1 FROM effect_cf_scheduled_alarms WHERE wake_at <= ? LIMIT 1", now)).toArray()).length > 0;
+			}),
+			deferWakes,
 			cancelAlarm: (input) => transaction((alarms) => alarms.cancelAlarm(input)),
 			getAlarmStatus: Effect.fnUntraced(function* (input) {
 				const ref = yield* decodeAlarmRef(input);
@@ -492,4 +702,4 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 	}));
 };
 //#endregion
-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 };
+export { AlarmParked, AlarmReporter, DEFAULT_MIN_REPEAT_INTERVAL_MS, DispatchAfterEvent, DurableObjectAlarm, DurableObjectAlarmEvent, DurableObjectAlarm_exports, HasDueAlarms, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidAlarmRegistrationError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, InvalidScheduleConfigurationError, MIN_REPEAT_INTERVAL_MS, MIN_RETRY_DELAY_MS, PARKED_RETRY_DELAY_MS, RunAlarm, ScheduleConfiguration, StoredAlarmDecodeError, Tag, define, dispatchRawAlarm, mergeAll, processDue };

package/dist/DurableObjectRpcWebSocket.d.mts

@@ -5,9 +5,9 @@ import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
-import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
-import * as RpcServer from "effect/unstable/rpc/RpcServer";
+import * as RpcMessage from "effect/rpc/RpcMessage";
+import * as RpcSerialization from "effect/rpc/RpcSerialization";
+import * as RpcServer from "effect/rpc/RpcServer";
 declare namespace DurableObjectRpcWebSocket_d_exports {
   export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, HeartbeatPolicy, LayerOptions, NativeWebSocketMessage, ResumableStreamDeclaration, RpcWebSocketAttachment, layer, resumableStream };
 }

package/dist/DurableObjectRpcWebSocket.mjs

@@ -8,9 +8,9 @@ import * as Layer from "effect/Layer";
 import * as Predicate from "effect/Predicate";
 import * as Option from "effect/Option";
 import * as Queue from "effect/Queue";
-import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
-import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
-import * as RpcServer from "effect/unstable/rpc/RpcServer";
+import * as RpcMessage from "effect/rpc/RpcMessage";
+import * as RpcSerialization from "effect/rpc/RpcSerialization";
+import * as RpcServer from "effect/rpc/RpcServer";
 //#region src/DurableObjectRpcWebSocket.ts
 var DurableObjectRpcWebSocket_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectRpcWebSocket: () => DurableObjectRpcWebSocket,

package/dist/DurableObjectSqlite.d.mts

@@ -1,7 +1,7 @@
 import { DurableObjectState } from "./DurableObjectState.mjs";
 import * as Layer from "effect/Layer";
 import { SqliteClient } from "@effect/sql-sqlite-do";
-import { SqlClient } from "effect/unstable/sql";
+import { SqlClient } from "effect/sql";
 declare namespace DurableObjectSqlite_d_exports {
   export { SqliteLayerOptions, layer };
 }

package/dist/DurableObjectSqlite.mjs

@@ -5,8 +5,8 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Scheduler from "effect/Scheduler";
 import { SqliteClient } from "@effect/sql-sqlite-do";
-import * as Reactivity from "effect/unstable/reactivity/Reactivity";
-import { SqlClient } from "effect/unstable/sql";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { SqlClient } from "effect/sql";
 //#region src/DurableObjectSqlite.ts
 var DurableObjectSqlite_exports = /* @__PURE__ */ __exportAll({ layer: () => layer });
 const layer = (options) => Layer.effectContext(Effect.gen(function* () {

package/dist/HyperdrivePg.d.mts

@@ -2,7 +2,7 @@ import { WorkerEnvironment } from "./Environment.mjs";
 import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import { LayerOptions, TagClass } from "./Hyperdrive.mjs";
 import * as Layer from "effect/Layer";
-import { SqlClient, SqlError } from "effect/unstable/sql";
+import { SqlClient, SqlError } from "effect/sql";
 import { PgClient } from "@effect/sql-pg";
 //#region src/HyperdrivePg.d.ts
 type PgLayerOptions = Omit<Parameters<typeof PgClient.makeClient>[0], "url" | "host" | "port" | "path" | "ssl" | "database" | "username" | "password" | "stream">;

package/dist/Mcp.d.mts

@@ -2,8 +2,8 @@ import { NativeRequest } from "./Worker.mjs";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { CreateMcpHandlerOptions, ServerOptions } from "@modelcontextprotocol/server";
-import * as Tool from "effect/unstable/ai/Tool";
-import { Toolkit } from "effect/unstable/ai";
+import * as Tool from "effect/ai/Tool";
+import { Toolkit } from "effect/ai";
 //#region src/Mcp.d.ts
 /**
  * CORS headers applied to MCP responses.
@@ -96,7 +96,7 @@ type FromToolkitContext<Tools extends Record<string, Tool.Any>> = NativeRequest
  *
  * ```ts
  * import { Effect, Layer, Option } from "effect"
- * import { HttpRouter } from "effect/unstable/http"
+ * import { HttpRouter } from "effect/http"
  * import { Worker } from "effect-cf"
  * import * as Mcp from "effect-cf/mcp"
  *

package/dist/Mcp.mjs

@@ -10,8 +10,8 @@ import * as Exit from "effect/Exit";
 import * as Stream from "effect/Stream";
 import { McpServer, createMcpHandler, hostHeaderValidationResponse, localhostAllowedHostnames, localhostAllowedOrigins, originValidationResponse } from "@modelcontextprotocol/server";
 import * as Sink from "effect/Sink";
-import * as AiError from "effect/unstable/ai/AiError";
-import * as Tool from "effect/unstable/ai/Tool";
+import * as AiError from "effect/ai/AiError";
+import * as Tool from "effect/ai/Tool";
 //#region src/Mcp.ts
 const DEFAULT_CORS_OPTIONS = {
 	origin: "*",
@@ -214,7 +214,7 @@ const registerToolkitTool = (server, built, tool, run) => {
 *
 * ```ts
 * import { Effect, Layer, Option } from "effect"
-* import { HttpRouter } from "effect/unstable/http"
+* import { HttpRouter } from "effect/http"
 * import { Worker } from "effect-cf"
 * import * as Mcp from "effect-cf/mcp"
 *

package/dist/RateLimit.d.mts

@@ -0,0 +1,50 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import { Layer } from "effect";
+declare namespace RateLimit_d_exports {
+  export { BindingNotFoundError, BindingValidationError, LayerOptions, RateLimitBinding, RateLimitClient, RateLimitDefinition, RateLimitOperationError, RateLimitOptions, RateLimitOutcome, RateLimitService, Tag, TagClass, isRateLimit, layer, make, makeClient };
+}
+type RateLimitBinding = globalThis.RateLimit;
+type RateLimitOptions = globalThis.RateLimitOptions;
+type RateLimitOutcome = globalThis.RateLimitOutcome;
+declare const RateLimitOperationError_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: "RateLimitOperationError";
+} & Readonly<A>;
+declare class RateLimitOperationError extends RateLimitOperationError_base<{
+  readonly binding: string;
+  readonly operation: "limit";
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+interface RateLimitDefinition {
+  readonly binding: string;
+}
+interface RateLimitClient {
+  /** Denial is a successful result with success: false. Calls are never retried. */
+  readonly limit: (options: RateLimitOptions) => Effect.Effect<RateLimitOutcome, RateLimitOperationError>;
+  readonly rawUnsafe: Effect.Effect<RateLimitBinding>;
+  readonly definition: RateLimitDefinition;
+}
+declare const RateLimitServiceTypeId: unique symbol;
+interface RateLimitService<Id extends string> {
+  readonly [RateLimitServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self, Id, RateLimitClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare const isRateLimit: <Candidate>(value: Candidate) => value is Candidate & RateLimitBinding;
+declare const makeClient: (definition: RateLimitDefinition) => (rateLimit: RateLimitBinding) => RateLimitClient;
+declare const layer: <Self>(tag: Context$1.Service<Self, RateLimitClient>, definition: RateLimitDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<RateLimitService<Id>, Id>;
+declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
+//#endregion
+export { type BindingNotFoundError, type BindingValidationError, LayerOptions, RateLimitBinding, RateLimitClient, RateLimitDefinition, RateLimitOperationError, RateLimitOptions, RateLimitOutcome, RateLimitService, RateLimit_d_exports, Tag, TagClass, isRateLimit, layer, make, makeClient };