@effect-agent/platform-cloudflare 0.1.0-beta.103 → 0.1.0-beta.106

package/dist/Alarm.d.mts

@@ -5,6 +5,7 @@ import { DurableBindingFailure } from "effect-agent/agent-registration";
 import { DurableAgentRuntime, DurableWorkerFailure } from "effect-agent/durable-agent-runtime";
 import { SubmissionLedger } from "effect-agent/submission-ledger";
 import { ThreadProjectionError, ThreadProjectionMaintenance } from "effect-agent/thread-projection-maintenance";
+import { WakeScheduler } from "effect-agent/wake-scheduler";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
 declare namespace Alarm_d_exports {
   export { DurableAlarmError, DurableAlarmService, MaintenancePassFailure, MaintenancePassReport, ThreadHostMaintenance, ThreadMaintenance, ThreadMaintenanceFailpoint, ThreadMaintenanceFailpointHandler, ThreadMaintenanceFailpointLocation, ThreadMessageDelivery, ThreadMutationGate, ThreadPublication, ThreadPublicationService, publishCommitted };
@@ -65,7 +66,7 @@ declare const MaintenancePassReport_base: Schema.Class<MaintenancePassReport, Sc
   readonly phase: Schema.Literals<readonly ["caught-up", "actionable"]>;
   /** Recovery decisions executed (or deferred) BEFORE any new claim in this pass. */
   readonly recovered: Schema.Int;
-  /** Whether the head Attempt settled. Joined input may settle with that head. */
+  /** Head Attempts settled during the event. Joined input may settle with each head. */
   readonly settled: Schema.Int;
   /** Submissions still nonterminal after the pass (suspended/unknown lanes stay honest). */
   readonly nonterminal: Schema.Int;
@@ -75,7 +76,7 @@ declare const MaintenancePassReport_base: Schema.Class<MaintenancePassReport, Sc
 /** What one maintenance pass did — auditable evidence mirroring `NodeDurableHost`'s report. */
 export declare class MaintenancePassReport extends MaintenancePassReport_base {}
 /** Fault boundaries around every maintenance-owned durable mutation. */
-export type ThreadMaintenanceFailpointLocation = "maintenance:dirty:before" | "maintenance:dirty:after" | "maintenance:mutation:armed" | "maintenance:mutation:finished" | "maintenance:ensure:before" | "maintenance:ensure:after" | "maintenance:begin:before" | "maintenance:begin:after" | "maintenance:select:before" | "maintenance:select:after" | "maintenance:binding-retry:before" | "maintenance:binding-retry:after" | "maintenance:retry:before" | "maintenance:retry:after" | "maintenance:finish:before" | "maintenance:finish:after";
+export type ThreadMaintenanceFailpointLocation = "maintenance:dirty:before" | "maintenance:dirty:after" | "maintenance:mutation:armed" | "maintenance:mutation:finished" | "maintenance:ensure:before" | "maintenance:ensure:after" | "maintenance:begin:before" | "maintenance:begin:after" | "maintenance:select:before" | "maintenance:select:after" | "maintenance:binding-retry:before" | "maintenance:binding-retry:after" | "maintenance:retry:before" | "maintenance:retry:after" | "maintenance:checkpoint:before" | "maintenance:checkpoint:after" | "maintenance:finish:before" | "maintenance:finish:after";
 export type ThreadMaintenanceFailpointHandler = (location: ThreadMaintenanceFailpointLocation) => Effect.Effect<void>;
 declare const ThreadMaintenanceFailpoint_base: Context.ServiceClass<ThreadMaintenanceFailpoint, "@effect-agent/platform-cloudflare/ThreadMaintenanceFailpoint", {
   readonly hit: ThreadMaintenanceFailpointHandler;
@@ -117,19 +118,19 @@ export declare class ThreadPublication extends ThreadPublication_base {
  * local Claim setup may take time, and expiration still owes the driver's local retry commit.
  */
 export declare const ThreadMessageDelivery: Context.Reference<{
-  readonly drainUntil: (sourceFinished: Effect.Effect<void>, dispatchUntil: DateTime.Utc) => Effect.Effect<void, DurableAlarmError, Scope.Scope>;
+  readonly drainUntil: (dispatchClosed: Effect.Effect<void>, dispatchUntil: DateTime.Utc) => Effect.Effect<void, DurableAlarmError, Scope.Scope>;
   readonly pendingDeadline: Effect.Effect<Option.Option<number>, DurableAlarmError>;
 }>;
 /**
  * Application obligations sharing this Object's alarm. Admit one initial external wave even on
- * a caught-up pass, then respond to wakes while native work runs. sourceFinished closes only
- * admission of NEW external waves. Keep local admission/hub subscriptions in the supplied event
- * Scope until maintenance tears it down; do not scope them to sourceFinished or to this Effect.
+ * a caught-up pass, then respond to wakes until dispatchClosed. This closes only admission
+ * of NEW external waves; native work can continue while admitted waves finish. Keep local
+ * admission/hub subscriptions in the event Scope until maintenance tears it down.
  * No deadline sleeps or automatic retry loops. Return after already-admitted waves finish.
  *
  * Declare a finite whole-wave allowance (1..300000ms): maximum for parallel lanes, sum for
  * sequential operations. Admit a wave only if its allowance fits before dispatchUntil. Later
- * arrivals cannot renew the retirement window. Maintenance bounds the join after sourceFinished,
+ * arrivals cannot renew the retirement window. Maintenance bounds the join after dispatchClosed,
  * interrupts and joins event Scope, then reads local deadlines under the mutation gate.
  *
  * Setup and pendingDeadline are bounded local operations. Persist claims/envelopes before
@@ -140,7 +141,7 @@ export declare const ThreadMessageDelivery: Context.Reference<{
  */
 export declare const ThreadHostMaintenance: Context.Reference<{
   readonly dispatchTimeoutMillis: number;
-  readonly drainUntil: (sourceFinished: Effect.Effect<void>, dispatchUntil: DateTime.Utc) => Effect.Effect<void, DurableAlarmError, Scope.Scope>;
+  readonly drainUntil: (dispatchClosed: Effect.Effect<void>, dispatchUntil: DateTime.Utc) => Effect.Effect<void, DurableAlarmError, Scope.Scope>;
   readonly pendingDeadline: Effect.Effect<Option.Option<number>, DurableAlarmError>;
 }>;
 /** @internal A committed source operation must not become a failed operation because delivery failed. */
@@ -184,23 +185,23 @@ declare const ThreadMaintenance_base: Context.ServiceClass<ThreadMaintenance, "@
 /**
  * Incremental, quiescent maintenance over a durable dirty/processed generation (issue #93).
  *
- * `pass` = generation snapshot/pre-arm → recovery → one head Attempt → generation acknowledgement:
+ * One physical event owns native scheduling, auxiliary delivery and final alarm rearming.
  *
- * 1. One storage transaction reads dirty/processed and re-arms before work. A caught-up forced
- *    alarm takes an O(1) path without recovery, ledger scans, or canonical-history reads.
- * 2. Recovery strictly precedes a new claim. One head Attempt advances the lane and requests
- *    a safe yield after ten minutes. The whole event has a fourteen-minute cooperative timeout.
- * 3. Auxiliary dispatch and listeners belong to the event Scope. After native completion,
- *    stop new external waves, join native delivery through its driver-owned Claim deadline,
- *    and bound host/backfill work by explicit allowances before closing and joining Scope.
- *    Ordinary auxiliary setup failures are reported after the one native opportunity.
- * 4. The final transaction acknowledges only the generation observed at pass start. A racing
- *    mutation therefore remains `dirty > processed` and retains its atomically-established alarm.
- * 5. Stable external waits acknowledge and clear. Autonomous retry, indeterminate, and lease
- *    recovery states leave their generation dirty and retain bounded backoff rearming.
+ * 1. Prearm before any work. A caught-up native step uses the O(1) generation record without
+ *    recovery, ledger scans or canonical-history reads.
+ * 2. Reconcile before each head Attempt, then checkpoint only the observed generation. A racing
+ *    producer keeps its newer generation dirty. Native retries retain their durable backoff.
+ * 3. After the initial native opportunity, stop admitting new external waves and let the
+ *    active waves finish. While they remain in flight, native wakes and bounded scans can
+ *    advance more heads. All Attempts share the event's original ten-minute yield deadline.
+ * 4. Native message delivery retains its driver-owned Claim deadline. Host/backfill joins are
+ *    bounded independently; incoming native work never restarts or cancels their attempts.
+ *    Auxiliary failures are reported after the current native opportunity.
+ * 5. Close every event resource before the final gated deadline snapshot and alarm decision.
+ *    The whole event retains one fourteen-minute cooperative timeout.
  */
 export declare class ThreadMaintenance extends ThreadMaintenance_base {
-  static readonly layer: Layer.Layer<ThreadMaintenance, never, ThreadMutationGate | ThreadPublication | ThreadProjectionMaintenance | DurableAgentRuntime | SubmissionLedger | DurableAlarmService | ThreadMaintenanceFailpoint | CloudflareDurableRuntimeConfig | DurableObjectContext | SqlClient>;
+  static readonly layer: Layer.Layer<ThreadMaintenance, never, ThreadMutationGate | ThreadPublication | ThreadProjectionMaintenance | DurableAgentRuntime | SubmissionLedger | WakeScheduler | DurableAlarmService | ThreadMaintenanceFailpoint | CloudflareDurableRuntimeConfig | DurableObjectContext | SqlClient>;
 }
 //#endregion
 export { Alarm_d_exports as t };

package/dist/Alarm.mjs

@@ -8,6 +8,7 @@ import { DurableAgentRuntime } from "effect-agent/durable-agent-runtime";
 import { SubmissionId, ThreadId } from "effect-agent/identifiers";
 import { SubmissionLedger } from "effect-agent/submission-ledger";
 import { ThreadProjectionMaintenance, drainDue } from "effect-agent/thread-projection-maintenance";
+import { WakeScheduler } from "effect-agent/wake-scheduler";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
 //#region src/Alarm.ts
 var Alarm_exports = /* @__PURE__ */ __exportAll({
@@ -88,7 +89,7 @@ var MaintenancePassReport = class extends Schema.Class("@effect-agent/platform-c
 	phase: Schema.Literals(["caught-up", "actionable"]),
 	/** Recovery decisions executed (or deferred) BEFORE any new claim in this pass. */
 	recovered: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-	/** Whether the head Attempt settled. Joined input may settle with that head. */
+	/** Head Attempts settled during the event. Joined input may settle with each head. */
 	settled: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
 	/** Submissions still nonterminal after the pass (suspended/unknown lanes stay honest). */
 	nonterminal: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
@@ -119,14 +120,14 @@ const ThreadMessageDelivery = Context.Reference("@effect-agent/platform-cloudfla
 }) });
 /**
 * Application obligations sharing this Object's alarm. Admit one initial external wave even on
-* a caught-up pass, then respond to wakes while native work runs. sourceFinished closes only
-* admission of NEW external waves. Keep local admission/hub subscriptions in the supplied event
-* Scope until maintenance tears it down; do not scope them to sourceFinished or to this Effect.
+* a caught-up pass, then respond to wakes until dispatchClosed. This closes only admission
+* of NEW external waves; native work can continue while admitted waves finish. Keep local
+* admission/hub subscriptions in the event Scope until maintenance tears it down.
 * No deadline sleeps or automatic retry loops. Return after already-admitted waves finish.
 *
 * Declare a finite whole-wave allowance (1..300000ms): maximum for parallel lanes, sum for
 * sequential operations. Admit a wave only if its allowance fits before dispatchUntil. Later
-* arrivals cannot renew the retirement window. Maintenance bounds the join after sourceFinished,
+* arrivals cannot renew the retirement window. Maintenance bounds the join after dispatchClosed,
 * interrupts and joins event Scope, then reads local deadlines under the mutation gate.
 *
 * Setup and pendingDeadline are bounded local operations. Persist claims/envelopes before
@@ -251,25 +252,26 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 /**
 * Incremental, quiescent maintenance over a durable dirty/processed generation (issue #93).
 *
-* `pass` = generation snapshot/pre-arm → recovery → one head Attempt → generation acknowledgement:
+* One physical event owns native scheduling, auxiliary delivery and final alarm rearming.
 *
-* 1. One storage transaction reads dirty/processed and re-arms before work. A caught-up forced
-*    alarm takes an O(1) path without recovery, ledger scans, or canonical-history reads.
-* 2. Recovery strictly precedes a new claim. One head Attempt advances the lane and requests
-*    a safe yield after ten minutes. The whole event has a fourteen-minute cooperative timeout.
-* 3. Auxiliary dispatch and listeners belong to the event Scope. After native completion,
-*    stop new external waves, join native delivery through its driver-owned Claim deadline,
-*    and bound host/backfill work by explicit allowances before closing and joining Scope.
-*    Ordinary auxiliary setup failures are reported after the one native opportunity.
-* 4. The final transaction acknowledges only the generation observed at pass start. A racing
-*    mutation therefore remains `dirty > processed` and retains its atomically-established alarm.
-* 5. Stable external waits acknowledge and clear. Autonomous retry, indeterminate, and lease
-*    recovery states leave their generation dirty and retain bounded backoff rearming.
+* 1. Prearm before any work. A caught-up native step uses the O(1) generation record without
+*    recovery, ledger scans or canonical-history reads.
+* 2. Reconcile before each head Attempt, then checkpoint only the observed generation. A racing
+*    producer keeps its newer generation dirty. Native retries retain their durable backoff.
+* 3. After the initial native opportunity, stop admitting new external waves and let the
+*    active waves finish. While they remain in flight, native wakes and bounded scans can
+*    advance more heads. All Attempts share the event's original ten-minute yield deadline.
+* 4. Native message delivery retains its driver-owned Claim deadline. Host/backfill joins are
+*    bounded independently; incoming native work never restarts or cancels their attempts.
+*    Auxiliary failures are reported after the current native opportunity.
+* 5. Close every event resource before the final gated deadline snapshot and alarm decision.
+*    The whole event retains one fourteen-minute cooperative timeout.
 */
 var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effect-agent/platform-cloudflare/ThreadMaintenance") {
 	static layer = Layer.effect(ThreadMaintenance)(Effect.gen(function* () {
 		const runtime = yield* DurableAgentRuntime;
 		const ledger = yield* SubmissionLedger;
+		const wakes = yield* WakeScheduler;
 		const alarm = yield* DurableAlarmService;
 		const config = yield* CloudflareDurableRuntimeConfig;
 		const { ctx } = yield* DurableObjectContext;
@@ -339,7 +341,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				const jitter = yield* Random.next;
 				yield* runTransaction("back off failed maintenance", () => ctx.storage.transaction(async (transaction) => {
 					const { state } = await readMaintenanceState(transaction);
-					const previous = state.retry?.generation === generation ? state.retry : void 0;
+					const previous = state.retry?.generation === generation && state.retry.nativeOnly === nativeOnly ? state.retry : void 0;
 					const retry = MaintenanceRetry.make({
 						generation,
 						notBefore: Math.max(previous?.notBefore ?? 0, now + backoffDelay(previous?.stalls ?? 0, jitter)),
@@ -356,15 +358,8 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			}));
 			yield* failpoint.hit("maintenance:retry:after");
 		});
-		const pass = Effect.fn("ThreadMaintenance.pass")(function* (yieldAfter, dispatchUntil, observed) {
-			const annotate = (report) => Effect.annotateCurrentSpan({
-				phase: report.phase,
-				recovered: report.recovered,
-				settled: report.settled,
-				nonterminal: report.nonterminal,
-				alarm: report.alarm
-			}).pipe(Effect.as(report));
-			const started = yield* mutations.withSnapshot((activeAtStart) => Effect.gen(function* () {
+		const beginNative = Effect.fn("ThreadMaintenance.beginNative")(function* (observed) {
+			return yield* mutations.withSnapshot((activeAtStart) => Effect.gen(function* () {
 				const generation = yield* beginPass(observed);
 				if (generation._tag === "Actionable" && activeAtStart === 0) yield* publication.prepareGeneration(generation.generation);
 				return {
@@ -372,59 +367,26 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 					activeAtStart
 				};
 			}));
-			const auxiliaryScope = yield* Effect.acquireRelease(Scope.make("parallel"), (scope, exit) => Scope.close(scope, exit));
-			const sourceFinished = yield* Deferred.make();
-			const finished = Deferred.await(sourceFinished);
-			const deliveryFiber = yield* Effect.forkIn(Scope.provide(auxiliaryScope)(messages.drainUntil(finished, dispatchUntil)), auxiliaryScope);
-			const hostFiber = yield* Effect.forkIn(Scope.provide(auxiliaryScope)(Effect.gen(function* () {
-				yield* Schema.decodeEffect(AuxiliaryDispatchMillis)(host.dispatchTimeoutMillis).pipe(Effect.mapError((cause) => DurableAlarmError.make({
-					operation: "host dispatch allowance",
-					message: "Declare an integer whole-wave allowance between 1 and 300000 milliseconds",
-					cause
-				})));
-				yield* host.drainUntil(finished, dispatchUntil);
-			})), auxiliaryScope);
-			const backfill = yield* Effect.forkIn(drainDue.pipe(Effect.provideService(ThreadProjectionMaintenance, projection), Effect.timeoutOption(config.projectionDispatchTimeoutMillis)), auxiliaryScope);
-			const finishAuxiliary = Effect.gen(function* () {
-				yield* Deferred.succeed(sourceFinished, void 0);
-				const remaining = Math.max(1, DateTime.toEpochMillis(dispatchUntil) - (yield* Clock.currentTimeMillis));
-				const hostJoin = yield* Effect.forkIn(Fiber.join(hostFiber).pipe(Effect.timeoutOption(Math.min(host.dispatchTimeoutMillis, remaining)), Effect.tap((result) => Effect.annotateCurrentSpan({ "host.timedOut": Option.isNone(result) }))), auxiliaryScope);
-				yield* Fiber.joinAll([
-					deliveryFiber,
-					hostJoin,
-					backfill
-				]);
-				yield* Scope.close(auxiliaryScope, Exit.void);
-			});
+		});
+		const advance = Effect.fn("ThreadMaintenance.advance")(function* (started, yieldAfter, observed) {
 			const deadline = yield* publication.pendingDeadline;
 			if (started._tag === "Actionable" || Option.isSome(deadline) && deadline.value <= (yield* Clock.currentTimeMillis)) yield* publication.drain;
 			const pending = yield* publication.pendingDeadline;
 			if (started._tag === "CaughtUp" || Option.isSome(pending)) {
-				yield* finishAuxiliary;
-				yield* failpoint.hit("maintenance:finish:before");
-				const disposition = yield* mutations.withSnapshot((active) => Effect.gen(function* () {
-					const latest = yield* pendingDeadline;
+				const nextAttemptAt = yield* mutations.withSnapshot((active) => Effect.gen(function* () {
 					const now = yield* Clock.currentTimeMillis;
-					return yield* runTransaction("finish publication pass", () => ctx.storage.transaction(async (transaction) => {
-						const { state } = await readMaintenanceState(transaction);
-						const nativeDeadline = active > 0 || state.dirty > state.processed ? state.retry?.generation === state.dirty && active === 0 ? Math.max(now + minimumAlarmDelay, state.retry.notBefore) : now + config.wakeScanInterval : Infinity;
-						const next = Option.isSome(latest) ? Math.min(nativeDeadline, latest.value) : nativeDeadline;
-						if (Number.isFinite(next)) {
-							await transaction.setAlarm(Math.max(now + minimumAlarmDelay, next));
-							return "rearmed";
-						}
-						await transaction.deleteAlarm();
-						return "cleared";
-					}));
+					const { state } = yield* runTransaction("read native maintenance deadline", () => ctx.storage.transaction((transaction) => readMaintenanceState(transaction)));
+					const native = active > 0 || state.dirty > state.processed ? state.retry?.generation === state.dirty && active === 0 ? state.retry.notBefore : now + minimumAlarmDelay : Infinity;
+					const next = Option.isSome(pending) ? pending.value : native;
+					return Number.isFinite(next) ? Math.max(now + minimumAlarmDelay, next) : void 0;
 				}));
-				yield* failpoint.hit("maintenance:finish:after");
-				return yield* annotate(MaintenancePassReport.make({
+				return {
 					phase: "caught-up",
 					recovered: 0,
 					settled: 0,
 					nonterminal: started.nonterminal,
-					alarm: disposition
-				}));
+					nextAttemptAt
+				};
 			}
 			observed.nativeOnly = true;
 			const recovered = yield* runtime.runRecovery;
@@ -491,8 +453,6 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				}
 				if (bindingFailure !== void 0) yield* reportBindingFailure ? Effect.logError("Thread awaits a current agent binding; original work remains pending", Cause.fail(bindingFailure)) : Effect.logDebug("Thread binding retry remains pending", Cause.fail(bindingFailure));
 			}
-			observed.nativeOnly = false;
-			yield* finishAuxiliary;
 			const remaining = yield* Stream.runCollect(ledger.scanNonterminal);
 			const waitingHeads = /* @__PURE__ */ new Map();
 			const autonomous = remaining.some((snapshot) => {
@@ -508,36 +468,91 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			const nextEligible = eligible.map((threadId) => retries.find((retry) => retry.submissionId === heads.get(threadId)?.submissionId)?.notBefore ?? now);
 			const bindingDelay = nextEligible.length === 0 ? 0 : Math.max(0, Math.min(...nextEligible) - now);
 			const delay = Math.max(ordinaryDelay, bindingDelay);
+			yield* failpoint.hit("maintenance:checkpoint:before");
+			const nextAttemptAt = yield* mutations.withSnapshot((active) => runTransaction("checkpoint native maintenance", () => ctx.storage.transaction(async (transaction) => {
+				const { state } = await readMaintenanceState(transaction);
+				const processed = autonomous || started.activeAtStart > 0 || active > 0 ? state.processed : state.processed > started.generation ? state.processed : started.generation;
+				const next = ThreadMaintenanceState.make({
+					...Struct.omit(state, ["retry"]),
+					processed,
+					nonterminal: remaining.length,
+					bindingRetries: (state.bindingRetries ?? []).filter((retry) => remaining.some((row) => row.submissionId === retry.submissionId)),
+					...autonomous && !progressed ? { retry: MaintenanceRetry.make({
+						generation: started.generation,
+						notBefore: now + delay,
+						nativeOnly: true,
+						stalls: Math.min(30, started.stalls + 1)
+					}) } : {}
+				});
+				await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(next));
+				if (autonomous) return started.activeAtStart > 0 || active > 0 || state.dirty !== started.generation ? now + minimumAlarmDelay : now + delay;
+				return started.activeAtStart > 0 || active > 0 || next.dirty > next.processed ? now + minimumAlarmDelay : void 0;
+			})));
+			yield* failpoint.hit("maintenance:checkpoint:after");
+			return {
+				phase: "actionable",
+				recovered: recovered.length,
+				settled: Option.isSome(settlement) ? 1 : 0,
+				nonterminal: remaining.length,
+				nextAttemptAt
+			};
+		});
+		const pass = Effect.fn("ThreadMaintenance.pass")(function* (yieldAfter, dispatchUntil, observed) {
+			const notified = (yield* Stream.toPull(wakes.wakes)).pipe(Effect.asVoid, Effect.catch(() => Effect.never));
+			let started = yield* beginNative(observed);
+			const auxiliaryScope = yield* Effect.acquireRelease(Scope.make("parallel"), (scope, exit) => Scope.close(scope, exit));
+			const dispatchClosed = yield* Deferred.make();
+			const stopDispatch = Deferred.await(dispatchClosed);
+			const deliveryFiber = yield* Effect.forkIn(Scope.provide(auxiliaryScope)(messages.drainUntil(stopDispatch, dispatchUntil)), auxiliaryScope);
+			const hostFiber = yield* Effect.forkIn(Scope.provide(auxiliaryScope)(Effect.gen(function* () {
+				yield* Schema.decodeEffect(AuxiliaryDispatchMillis)(host.dispatchTimeoutMillis).pipe(Effect.mapError((cause) => DurableAlarmError.make({
+					operation: "host dispatch allowance",
+					message: "Declare an integer whole-wave allowance between 1 and 300000 milliseconds",
+					cause
+				})));
+				yield* host.drainUntil(stopDispatch, dispatchUntil);
+			})), auxiliaryScope);
+			const backfill = yield* Effect.forkIn(drainDue.pipe(Effect.provideService(ThreadProjectionMaintenance, projection), Effect.timeoutOption(config.projectionDispatchTimeoutMillis)), auxiliaryScope);
+			let result = yield* advance(started, yieldAfter, observed);
+			let phase = result.phase;
+			let recovered = result.recovered;
+			let settled = result.settled;
+			observed.nativeOnly = false;
+			yield* Deferred.succeed(dispatchClosed, void 0);
+			const remaining = Math.max(1, DateTime.toEpochMillis(dispatchUntil) - (yield* Clock.currentTimeMillis));
+			const hostJoin = yield* Effect.forkIn(Fiber.join(hostFiber).pipe(Effect.timeoutOption(Math.min(host.dispatchTimeoutMillis, remaining)), Effect.tap((outcome) => Effect.annotateCurrentSpan({ "host.timedOut": Option.isNone(outcome) }))), auxiliaryScope);
+			const retired = yield* Effect.forkChild(Fiber.joinAll([
+				deliveryFiber,
+				hostJoin,
+				backfill
+			]));
+			const auxiliaryPending = () => deliveryFiber.pollUnsafe() === void 0 || hostFiber.pollUnsafe() === void 0 || backfill.pollUnsafe() === void 0;
+			while (retired.pollUnsafe() === void 0 && auxiliaryPending()) {
+				const now = yield* Clock.currentTimeMillis;
+				const until = DateTime.toEpochMillis(yieldAfter);
+				if (now >= until) break;
+				const next = Math.min(result.nextAttemptAt ?? Infinity, now + config.wakeScanInterval, until);
+				if (!(yield* Effect.raceFirst(Effect.raceFirst(notified, Effect.sleep(Math.max(0, next - now))).pipe(Effect.as(true)), Fiber.await(retired).pipe(Effect.as(false)))) || retired.pollUnsafe() !== void 0 || !auxiliaryPending()) break;
+				if ((yield* Clock.currentTimeMillis) >= until) break;
+				started = yield* beginNative(observed);
+				result = yield* advance(started, yieldAfter, observed);
+				if (result.phase === "actionable") phase = "actionable";
+				recovered += result.recovered;
+				settled += result.settled;
+				observed.nativeOnly = false;
+			}
+			yield* Fiber.join(retired);
+			yield* Scope.close(auxiliaryScope, Exit.void);
 			yield* failpoint.hit("maintenance:finish:before");
-			const alarmDisposition = yield* mutations.withSnapshot((active) => Effect.gen(function* () {
-				const publicationDeadline = yield* pendingDeadline;
-				return yield* runTransaction("finish maintenance pass", () => ctx.storage.transaction(async (transaction) => {
+			const disposition = yield* mutations.withSnapshot((active) => Effect.gen(function* () {
+				const latest = yield* pendingDeadline;
+				const now = yield* Clock.currentTimeMillis;
+				return yield* runTransaction("finish maintenance event", () => ctx.storage.transaction(async (transaction) => {
 					const { state } = await readMaintenanceState(transaction);
-					const processed = autonomous || started.activeAtStart > 0 || active > 0 ? state.processed : state.processed > started.generation ? state.processed : started.generation;
-					const next = ThreadMaintenanceState.make({
-						...Struct.omit(state, ["retry"]),
-						processed,
-						nonterminal: remaining.length,
-						bindingRetries: (state.bindingRetries ?? []).filter((retry) => remaining.some((row) => row.submissionId === retry.submissionId)),
-						...autonomous && !progressed ? { retry: MaintenanceRetry.make({
-							generation: started.generation,
-							notBefore: now + delay,
-							nativeOnly: true,
-							stalls: Math.min(30, started.stalls + 1)
-						}) } : {}
-					});
-					await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(next));
-					if (autonomous) {
-						const nativeDeadline = started.activeAtStart > 0 || active > 0 || state.dirty !== started.generation ? now + minimumAlarmDelay : now + delay;
-						await transaction.setAlarm(Option.isSome(publicationDeadline) ? Math.max(now + minimumAlarmDelay, Math.min(nativeDeadline, publicationDeadline.value)) : nativeDeadline);
-						return "rearmed";
-					}
-					if (started.activeAtStart > 0 || active > 0 || next.dirty > next.processed) {
-						await ensureTransactionAlarmBy(transaction, Option.isSome(publicationDeadline) ? Math.max(now + minimumAlarmDelay, Math.min(now + config.wakeScanInterval, publicationDeadline.value)) : now + config.wakeScanInterval);
-						return "rearmed";
-					}
-					if (Option.isSome(publicationDeadline)) {
-						await transaction.setAlarm(Math.max(now + minimumAlarmDelay, publicationDeadline.value));
+					const native = active > 0 || state.dirty > state.processed ? state.retry?.generation === state.dirty && active === 0 ? Math.max(now + minimumAlarmDelay, state.retry.notBefore) : state.dirty === observed.generation && active === 0 ? result.nextAttemptAt ?? now + config.wakeScanInterval : now + minimumAlarmDelay : Infinity;
+					const next = Option.isSome(latest) ? Math.min(native, latest.value) : native;
+					if (Number.isFinite(next)) {
+						await transaction.setAlarm(Math.max(now + minimumAlarmDelay, next));
 						return "rearmed";
 					}
 					await transaction.deleteAlarm();
@@ -545,13 +560,21 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				}));
 			}));
 			yield* failpoint.hit("maintenance:finish:after");
-			return yield* annotate(MaintenancePassReport.make({
-				phase: "actionable",
-				recovered: recovered.length,
-				settled: Option.isSome(settlement) ? 1 : 0,
-				nonterminal: remaining.length,
-				alarm: alarmDisposition
-			}));
+			const report = MaintenancePassReport.make({
+				phase,
+				recovered,
+				settled,
+				nonterminal: result.nonterminal,
+				alarm: disposition
+			});
+			yield* Effect.annotateCurrentSpan({
+				phase: report.phase,
+				recovered: report.recovered,
+				settled: report.settled,
+				nonterminal: report.nonterminal,
+				alarm: report.alarm
+			});
+			return report;
 		});
 		return ThreadMaintenance.of({
 			pass: Effect.gen(function* () {