@effect-agent/platform-cloudflare 0.1.0-beta.113 → 0.1.0-beta.115

package/dist/Alarm.d.mts

@@ -1,6 +1,6 @@
 import { DurableObjectContext } from "./CloudflareBindings.mjs";
 import { s as CloudflareDurableRuntimeConfig } from "./CloudflareConfig-DKXGo8L3.mjs";
-import { Cause, Context, DateTime, Effect, Layer, Option, Schema, Scope } from "effect";
+import { Cause, Context, Effect, Layer, Option, Schema, Scope } from "effect";
 import { DurableBindingFailure } from "effect-agent/agent-registration";
 import { DurableAgentRuntime, DurableRuntimeConfig, DurableWorkerFailure, RecoveryFailure } from "effect-agent/durable-agent-runtime";
 import { ThreadId } from "effect-agent/identifiers";
@@ -10,7 +10,7 @@ import { ThreadProjectionError, ThreadProjectionMaintenance } from "effect-agent
 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, ThreadMaintenanceActivity, ThreadMaintenanceFailpoint, ThreadMaintenanceFailpointHandler, ThreadMaintenanceFailpointLocation, ThreadMessageDelivery, ThreadMutationGate, ThreadPublication, ThreadPublicationService, ThreadRecoveryFault, publishCommitted };
+  export { DurableAlarmError, DurableAlarmService, MaintenancePassFailure, MaintenancePassReport, ThreadHostMaintenance, ThreadHostMaintenanceLane, ThreadMaintenance, ThreadMaintenanceFailpoint, ThreadMaintenanceFailpointHandler, ThreadMaintenanceFailpointLocation, ThreadMessageDelivery, ThreadMutationGate, ThreadPublication, ThreadPublicationService, ThreadRecoveryFault, publishCommitted };
 }
 declare const DurableAlarmError_base: Schema.Class<DurableAlarmError, Schema.TaggedStruct<"DurableAlarmError", {
   readonly operation: Schema.String;
@@ -114,61 +114,44 @@ declare const ThreadPublication_base: Context.ServiceClass<ThreadPublication, "@
 export declare class ThreadPublication extends ThreadPublication_base {
   static readonly layer: Layer.Layer<ThreadPublication, never, never>;
 }
-declare const ThreadMaintenanceActivity_base: Context.ServiceClass<ThreadMaintenanceActivity, "@effect-agent/platform-cloudflare/ThreadMaintenanceActivity", {
-  /**
-   * Account for one finite selection/dispatch, through joined completion or interruption.
-   * Register before reading/claiming work. After dispatch closes the body is not started.
-   * Host waves retain their declared allowance from this call; message Claims keep the driver's
-   * own deadline. Waiting for notifications belongs outside this bracket.
-   */
-  readonly run: <R>(wave: Effect.Effect<void, DurableAlarmError, R>) => Effect.Effect<void, DurableAlarmError, R>;
-  /** Acknowledge all initial subscriptions/scans. Composite hosts use `all` below. */
-  readonly ready: Effect.Effect<void>;
-  /**
-   * Acquire an independent scoped subscription before the initial scan and `ready`.
-   * The returned wait observes coalesced native scan hints, including those published before
-   * its first execution. Each hint requests a current local due-work check.
-   */
-  readonly subscribeChanges: Effect.Effect<Effect.Effect<void>, never, Scope.Scope>;
-}>;
-/** Event-local accounting shared by the existing maintenance pumps and native scheduler. */
-export declare class ThreadMaintenanceActivity extends ThreadMaintenanceActivity_base {
-  /** Join child pumps; acknowledge the parent only after every child is ready or has exited. */
-  static readonly all: <A, E, R>(lanes: readonly Effect.Effect<A, E, R>[]) => Effect.Effect<readonly A[], E, R | ThreadMaintenanceActivity>;
-}
 /**
- * Host-assembled native message recovery. The driver bounds each actual Claim and persists its
- * timeout/retry before this pump returns. Do not add a second timer starting at batch selection:
- * local Claim setup may take time, and expiration still owes the driver's local retry commit.
+ * Host-assembled native message recovery. Preparation is a bounded local selection; the
+ * driver bounds each actual Claim and persists its timeout/retry before `run` returns.
+ * The alarm must not add a timer starting at selection: Claim setup and retry commits belong
+ * to the driver. The prepared allowance decides only whether a wave fits this event.
  */
 export declare const ThreadMessageDelivery: Context.Reference<{
-  readonly drainUntil: (dispatchClosed: Effect.Effect<void>, dispatchUntil: DateTime.Utc) => Effect.Effect<void, DurableAlarmError, Scope.Scope | ThreadMaintenanceActivity>;
+  readonly prepare: Effect.Effect<{
+    readonly timeoutMillis: number;
+    readonly run: Effect.Effect<void, DurableAlarmError>;
+  }, DurableAlarmError>;
   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 and ThreadMaintenanceActivity.subscribeChanges until
- * dispatchClosed. Yield the event's ThreadMaintenanceActivity to bracket each finite lane with
- * run and acknowledge initial setup with ready.
- * Passive subscriptions do not count as active work. Closure stops both new waves and native
- * Attempts; local admission/control subscriptions belong to the event Scope until teardown.
- * No deadline sleeps or automatic retry loops. Return after already-admitted waves finish.
+ * One independently schedulable application obligation. `run` selects and joins one finite
+ * wave, including its retry/receipt commits. The alarm gives every lane an initial opportunity,
+ * then checks its local pending deadline on completion, native progress, wakes and bounded scans.
+ * No subscriptions, readiness acknowledgements, deadline sleeps or dispatch loops are needed.
  *
- * 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 an admitted wave's allowance. Maintenance bounds each registered wave,
- * interrupts and joins event Scope, then reads local deadlines under the mutation gate.
+ * Declare a whole-wave allowance (1..300000ms), including selection, local commits and cleanup. A wave
+ * starts only if that allowance fits the event and later arrivals cannot renew it. A failed
+ * lane is not retried within the event. The alarm joins admitted work and closes its Scope
+ * before reading durable deadlines under the shared ThreadMutationGate.
  *
- * Setup and pendingDeadline are bounded local operations. Persist claims/envelopes before
- * dispatch; interrupted waits leave exact retries/receipts recoverable. Cancellation is local,
- * not remote rollback. Retry accounting is unchanged. Network waits/finalizers must be
- * interruptible; short local atomic commits may be uninterruptible. Hooks never write the raw
- * alarm slot. Required native publication gates belong to ThreadPublication.
+ * `pendingDeadline` is bounded local control state, never a retained-history scan. Persist
+ * envelopes/claims before dispatch; cancellation is local, not remote rollback. Network waits
+ * and finalizers must be interruptible; short atomic commits may be uninterruptible. Mutations
+ * use the shared gate and producers notify the existing WakeScheduler after commit. Hooks never
+ * write the raw alarm slot. Required native publication gates belong to ThreadPublication.
  */
-export declare const ThreadHostMaintenance: Context.Reference<{
+export interface ThreadHostMaintenanceLane {
   readonly dispatchTimeoutMillis: number;
-  readonly drainUntil: (dispatchClosed: Effect.Effect<void>, dispatchUntil: DateTime.Utc) => Effect.Effect<void, DurableAlarmError, Scope.Scope | ThreadMaintenanceActivity>;
+  readonly run: Effect.Effect<void, DurableAlarmError, Scope.Scope>;
   readonly pendingDeadline: Effect.Effect<Option.Option<number>, DurableAlarmError>;
+}
+/** Independent lanes share the existing alarm; compose hosts by concatenating their lanes. */
+export declare const ThreadHostMaintenance: Context.Reference<{
+  readonly lanes: ReadonlyArray<ThreadHostMaintenanceLane>;
 }>;
 /** @internal A committed source operation must not become a failed operation because delivery failed. */
 export declare const publishCommitted: Effect.Effect<void, never, ThreadPublication>;
@@ -240,10 +223,11 @@ declare const ThreadMaintenance_base: Context.ServiceClass<ThreadMaintenance, "@
  * 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.
+ *    producer keeps its generation dirty and immediately eligible. Quiescent native retries
+ *    retain their durable backoff.
  * 3. Keep native and delivery admission open together while finite waves remain active, so
  *    fresh replies and abort controls can progress during unrelated cleanup. Close atomically
- *    at quiescence, or at the original ten-minute yield deadline, before retiring listeners.
+ *    at quiescence, or at the original ten-minute yield deadline, then join admitted waves.
  * 4. Native message delivery retains its driver-owned Claim deadline. Host/backfill waves are
  *    bounded independently; incoming native work never restarts or cancels their attempts.
  *    Auxiliary failures are reported after the current native opportunity.

package/dist/Alarm.mjs

@@ -2,7 +2,7 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { DurableObjectContext } from "./CloudflareBindings.mjs";
 import { AuxiliaryDispatchMillis, CloudflareDurableRuntimeConfig } from "./CloudflareConfig.mjs";
 import { r as safeCauseMessage } from "./boundary-BguazVkh.mjs";
-import { Cause, Clock, Context, DateTime, Deferred, Effect, Exit, Fiber, Layer, Option, PubSub, Random, Ref, Result, Schema, Scope, Semaphore, Stream, Struct } from "effect";
+import { Cause, Clock, Context, DateTime, Deferred, Effect, Exit, Fiber, Layer, Option, Random, Ref, Result, Schema, Scope, Semaphore, Stream, Struct } from "effect";
 import "effect-agent/agent-registration";
 import { DurableAgentRuntime, DurableRuntimeConfig, RecoveryBlocked, RecoveryFailure, RecoverySweepResult, isolateRecovery } from "effect-agent/durable-agent-runtime";
 import { SubmissionId, ThreadId } from "effect-agent/identifiers";
@@ -18,7 +18,6 @@ var Alarm_exports = /* @__PURE__ */ __exportAll({
 	MaintenancePassReport: () => MaintenancePassReport,
 	ThreadHostMaintenance: () => ThreadHostMaintenance,
 	ThreadMaintenance: () => ThreadMaintenance,
-	ThreadMaintenanceActivity: () => ThreadMaintenanceActivity,
 	ThreadMaintenanceFailpoint: () => ThreadMaintenanceFailpoint,
 	ThreadMessageDelivery: () => ThreadMessageDelivery,
 	ThreadMutationGate: () => ThreadMutationGate,
@@ -112,61 +111,21 @@ var ThreadPublication = class extends Context.Service()("@effect-agent/platform-
 		pendingDeadline: Effect.succeed(Option.none())
 	});
 };
-/** Event-local accounting shared by the existing maintenance pumps and native scheduler. */
-var ThreadMaintenanceActivity = class ThreadMaintenanceActivity extends Context.Service()("@effect-agent/platform-cloudflare/ThreadMaintenanceActivity") {
-	/** Join child pumps; acknowledge the parent only after every child is ready or has exited. */
-	static all = Effect.fnUntraced(function* (lanes) {
-		const activity = yield* ThreadMaintenanceActivity;
-		let remaining = lanes.length;
-		if (remaining === 0) return yield* activity.ready.pipe(Effect.as([]));
-		return yield* Effect.forEach(lanes, (lane) => {
-			let ready = false;
-			const child = {
-				...activity,
-				ready: Effect.suspend(() => {
-					if (ready) return Effect.void;
-					ready = true;
-					return --remaining === 0 ? activity.ready : Effect.void;
-				}).pipe(Effect.uninterruptible)
-			};
-			return lane.pipe(Effect.provideService(ThreadMaintenanceActivity, child), Effect.onExit(() => child.ready));
-		}, { concurrency: "unbounded" });
-	});
-};
 /**
-* Host-assembled native message recovery. The driver bounds each actual Claim and persists its
-* timeout/retry before this pump returns. Do not add a second timer starting at batch selection:
-* local Claim setup may take time, and expiration still owes the driver's local retry commit.
+* Host-assembled native message recovery. Preparation is a bounded local selection; the
+* driver bounds each actual Claim and persists its timeout/retry before `run` returns.
+* The alarm must not add a timer starting at selection: Claim setup and retry commits belong
+* to the driver. The prepared allowance decides only whether a wave fits this event.
 */
 const ThreadMessageDelivery = Context.Reference("@effect-agent/platform-cloudflare/ThreadMessageDelivery", { defaultValue: () => ({
-	drainUntil: () => Effect.void,
-	pendingDeadline: Effect.succeed(Option.none())
-}) });
-/**
-* Application obligations sharing this Object's alarm. Admit one initial external wave even on
-* a caught-up pass, then respond to wakes and ThreadMaintenanceActivity.subscribeChanges until
-* dispatchClosed. Yield the event's ThreadMaintenanceActivity to bracket each finite lane with
-* run and acknowledge initial setup with ready.
-* Passive subscriptions do not count as active work. Closure stops both new waves and native
-* Attempts; local admission/control subscriptions belong to the event Scope until teardown.
-* 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 an admitted wave's allowance. Maintenance bounds each registered wave,
-* interrupts and joins event Scope, then reads local deadlines under the mutation gate.
-*
-* Setup and pendingDeadline are bounded local operations. Persist claims/envelopes before
-* dispatch; interrupted waits leave exact retries/receipts recoverable. Cancellation is local,
-* not remote rollback. Retry accounting is unchanged. Network waits/finalizers must be
-* interruptible; short local atomic commits may be uninterruptible. Hooks never write the raw
-* alarm slot. Required native publication gates belong to ThreadPublication.
-*/
-const ThreadHostMaintenance = Context.Reference("@effect-agent/platform-cloudflare/ThreadHostMaintenance", { defaultValue: () => ({
-	dispatchTimeoutMillis: 1,
-	drainUntil: () => Effect.void,
+	prepare: Effect.succeed({
+		timeoutMillis: 1,
+		run: Effect.void
+	}),
 	pendingDeadline: Effect.succeed(Option.none())
 }) });
+/** Independent lanes share the existing alarm; compose hosts by concatenating their lanes. */
+const ThreadHostMaintenance = Context.Reference("@effect-agent/platform-cloudflare/ThreadHostMaintenance", { defaultValue: () => ({ lanes: [] }) });
 const earliestDeadline = (left, right) => Option.isSome(left) ? Option.isSome(right) ? Option.some(Math.min(left.value, right.value)) : left : right;
 /** @internal A committed source operation must not become a failed operation because delivery failed. */
 const publishCommitted = Effect.gen(function* () {
@@ -309,10 +268,11 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 * 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.
+*    producer keeps its generation dirty and immediately eligible. Quiescent native retries
+*    retain their durable backoff.
 * 3. Keep native and delivery admission open together while finite waves remain active, so
 *    fresh replies and abort controls can progress during unrelated cleanup. Close atomically
-*    at quiescence, or at the original ten-minute yield deadline, before retiring listeners.
+*    at quiescence, or at the original ten-minute yield deadline, then join admitted waves.
 * 4. Native message delivery retains its driver-owned Claim deadline. Host/backfill waves are
 *    bounded independently; incoming native work never restarts or cancels their attempts.
 *    Auxiliary failures are reported after the current native opportunity.
@@ -337,7 +297,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 		const authorizer = yield* OperationAuthorizer;
 		const projectionDeadline = projection.pendingDeadline.pipe(Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), (cause) => Effect.logError("Thread projection deadline unavailable", cause).pipe(Effect.as(Option.some(0)))));
 		const pendingDeadline = Effect.gen(function* () {
-			return earliestDeadline(earliestDeadline(yield* publication.pendingDeadline, yield* messages.pendingDeadline), earliestDeadline(yield* projectionDeadline, yield* host.pendingDeadline));
+			return earliestDeadline(earliestDeadline(yield* publication.pendingDeadline, yield* messages.pendingDeadline), earliestDeadline(yield* projectionDeadline, (yield* Effect.forEach(host.lanes, (lane) => lane.pendingDeadline)).reduce(earliestDeadline, Option.none())));
 		});
 		const maintenancePassGate = yield* Semaphore.make(1);
 		const minimumAlarmDelay = Math.max(1, Math.ceil(config.alarmBackoffBase / 2));
@@ -632,13 +592,15 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			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 || observation.activeAtStart > 0 || started.activeAtStart > 0 || active > 0 ? state.processed : state.processed > observation.generation ? state.processed : observation.generation;
+				const mutationOverlap = observation.activeAtStart > 0 || started.activeAtStart > 0 || active > 0;
+				const processed = autonomous || mutationOverlap ? state.processed : state.processed > observation.generation ? state.processed : observation.generation;
+				const canBackoff = !mutationOverlap && state.dirty === 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({
+					...autonomous && !progressed && canBackoff ? { retry: MaintenanceRetry.make({
 						generation: started.generation,
 						notBefore: now + delay,
 						nativeOnly: true,
@@ -646,8 +608,8 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 					}) } : {}
 				});
 				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;
+				if (autonomous) return now + (canBackoff ? delay : minimumAlarmDelay);
+				return mutationOverlap || next.dirty > next.processed ? now + minimumAlarmDelay : void 0;
 			})));
 			yield* failpoint.hit("maintenance:checkpoint:after");
 			return {
@@ -661,47 +623,17 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			const notified = (yield* Stream.toPull(wakes.wakes)).pipe(Effect.asVoid, Effect.catch(() => Effect.never));
 			const 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 checks = yield* PubSub.sliding(1);
-			yield* Effect.addFinalizer(() => PubSub.shutdown(checks));
-			let dispatchOpen = true;
-			let activityChanged = yield* Deferred.make();
-			const signalActivity = Effect.suspend(() => Deferred.succeed(activityChanged, void 0));
-			const closeDispatch = Effect.sync(() => {
-				dispatchOpen = false;
-			}).pipe(Effect.andThen(Deferred.succeed(dispatchClosed, void 0)));
-			const makeActivity = Effect.fnUntraced(function* (allowance) {
-				const initialized = yield* Deferred.make();
-				let active = 0;
-				let failed = false;
-				return {
-					activity: {
-						ready: Deferred.succeed(initialized, void 0).pipe(Effect.andThen(signalActivity), Effect.asVoid, Effect.uninterruptible),
-						subscribeChanges: PubSub.subscribe(checks).pipe(Effect.map(PubSub.take)),
-						run: (wave) => Effect.acquireUseRelease(Effect.sync(() => {
-							if (!dispatchOpen) return false;
-							active++;
-							return true;
-						}), (admitted) => !admitted ? Effect.void : (allowance === void 0 ? wave : wave.pipe(Effect.timeoutOrElse({
-							duration: allowance,
-							orElse: () => DurableAlarmError.make({
-								operation: "host dispatch allowance",
-								message: "The admitted host wave exceeded its allowance; durable work remains pending"
-							})
-						}))).pipe(Effect.onExit((exit) => Effect.sync(() => {
-							if (Exit.isFailure(exit)) failed = true;
-						}))), (admitted) => Effect.sync(() => {
-							if (admitted) active--;
-						}).pipe(Effect.andThen(signalActivity)))
-					},
-					initialized: Deferred.await(initialized),
-					quiet: () => active === 0 && Deferred.isDoneUnsafe(initialized),
-					failed: () => failed
-				};
-			});
-			const messageActivity = yield* makeActivity();
-			const hostActivity = yield* makeActivity(host.dispatchTimeoutMillis);
+			const fork = (work) => Effect.forkIn(work, auxiliaryScope);
+			const lanes = host.lanes.map((lane) => ({
+				...lane,
+				initial: true,
+				check: true,
+				exhausted: false,
+				fiber: void 0
+			}));
+			let messageExhausted = false;
+			let delivery;
+			let failure;
 			const recovery = {
 				queue: yield* Deferred.make(),
 				pending: /* @__PURE__ */ new Set(),
@@ -713,7 +645,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				recovered: 0,
 				repaired: false
 			};
-			const recoveryFiber = yield* Effect.forkIn(Effect.gen(function* () {
+			const recoveryFiber = yield* fork(Effect.gen(function* () {
 				for (const threadId of yield* Deferred.await(recovery.queue)) {
 					yield* failpoint.hit("maintenance:select:before");
 					yield* runTransaction("select old recovery lane", () => ctx.storage.transaction(async (transaction) => {
@@ -728,90 +660,156 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 					recovery.pending.delete(threadId);
 					yield* wakes.notify(threadId);
 				}
-			}), auxiliaryScope);
-			const deliveryFiber = yield* Effect.forkIn(Scope.provide(auxiliaryScope)(messages.drainUntil(stopDispatch, dispatchUntil).pipe(Effect.provideService(ThreadMaintenanceActivity, messageActivity.activity), Effect.onExit(() => messageActivity.activity.ready))), 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
-				})));
-				const initialization = hostActivity.initialized.pipe(Effect.timeoutOrElse({
-					duration: host.dispatchTimeoutMillis,
-					orElse: () => DurableAlarmError.make({
-						operation: "host initialization",
-						message: "The host did not account for initial maintenance before its allowance; durable work remains pending"
-					})
-				}), Effect.andThen(Effect.never));
-				yield* Effect.raceFirst(host.drainUntil(stopDispatch, dispatchUntil).pipe(Effect.provideService(ThreadMaintenanceActivity, hostActivity.activity)), initialization);
-			}).pipe(Effect.onExit(() => hostActivity.activity.ready))), auxiliaryScope);
-			const backfill = yield* Effect.forkIn(drainDue.pipe(Effect.provideService(ThreadProjectionMaintenance, projection), Effect.timeoutOption(config.projectionDispatchTimeoutMillis), Effect.onExit(() => signalActivity)), auxiliaryScope);
-			let result = yield* advance(started, yieldAfter, observed, recovery);
-			recovery.started = true;
-			yield* Deferred.succeed(recovery.queue, []);
+			}));
+			const backfill = yield* fork(drainDue.pipe(Effect.provideService(ThreadProjectionMaintenance, projection), Effect.timeoutOption(config.projectionDispatchTimeoutMillis)));
+			let backfillObserved = false;
+			let recoveryObserved = false;
+			let native = yield* fork(advance(started, yieldAfter, observed, recovery));
+			let result = {
+				phase: "caught-up",
+				settled: 0,
+				nonterminal: started.nonterminal,
+				nextAttemptAt: void 0
+			};
 			let phase = result.phase;
-			let settled = result.settled;
-			observed.nativeOnly = false;
-			const hostJoin = yield* Effect.forkIn(Effect.gen(function* () {
-				yield* stopDispatch;
-				const remaining = Math.max(1, DateTime.toEpochMillis(dispatchUntil) - (yield* Clock.currentTimeMillis));
-				const outcome = yield* Fiber.join(hostFiber).pipe(Effect.timeoutOption(Math.min(host.dispatchTimeoutMillis, remaining)));
-				yield* Effect.annotateCurrentSpan({ "host.timedOut": Option.isNone(outcome) });
-			}), auxiliaryScope);
-			const retired = yield* Effect.forkChild(Fiber.joinAll([
-				deliveryFiber,
-				hostJoin,
-				backfill,
-				recoveryFiber
-			]));
+			let settled = 0;
+			let nativeCheck = false;
+			const until = DateTime.toEpochMillis(yieldAfter);
+			const dispatchEnd = DateTime.toEpochMillis(dispatchUntil);
+			const checkLanes = () => {
+				for (const lane of lanes) lane.check = true;
+			};
 			while (true) {
-				const recoveryFinished = recoveryFiber.pollUnsafe() !== void 0;
-				const retiredExit = retired.pollUnsafe();
-				if (recoveryFinished) {
-					if (recovery.needsCheckpoint) {
-						yield* Fiber.join(recoveryFiber);
-						result = yield* advance(started, yieldAfter, observed, recovery, settled === 0);
-						if (result.phase === "actionable") phase = "actionable";
-						settled += result.settled;
-						recovery.needsCheckpoint = false;
-						yield* PubSub.publish(checks, void 0);
+				if (native?.pollUnsafe() !== void 0) {
+					result = yield* Fiber.join(native);
+					native = void 0;
+					if (result.phase === "actionable") phase = "actionable";
+					settled += result.settled;
+					observed.nativeOnly = false;
+					recovery.started = true;
+					yield* Deferred.succeed(recovery.queue, []);
+					checkLanes();
+				}
+				if (!recoveryObserved && recoveryFiber.pollUnsafe() !== void 0) {
+					yield* Fiber.join(recoveryFiber);
+					recoveryObserved = true;
+					nativeCheck = recovery.needsCheckpoint;
+				}
+				if (!backfillObserved) {
+					const exit = backfill.pollUnsafe();
+					if (exit !== void 0) {
+						backfillObserved = true;
+						if (Exit.isFailure(exit)) failure ??= exit.cause;
 					}
 				}
-				if (retiredExit !== void 0 && Exit.isFailure(retiredExit)) break;
-				if (recoveryFinished && backfill.pollUnsafe() !== void 0 && messageActivity.quiet() && hostActivity.quiet()) {
-					const now = yield* Clock.currentTimeMillis;
-					const messageDeadline = yield* messages.pendingDeadline;
-					const hostDeadline = yield* host.pendingDeadline;
-					const messageDue = deliveryFiber.pollUnsafe() === void 0 && !messageActivity.failed() && Option.isSome(messageDeadline) && messageDeadline.value <= now;
-					const hostDue = hostFiber.pollUnsafe() === void 0 && !hostActivity.failed() && now + host.dispatchTimeoutMillis <= DateTime.toEpochMillis(dispatchUntil) && Option.isSome(hostDeadline) && hostDeadline.value <= now;
-					if (yield* Effect.sync(() => {
-						if (messageDue || hostDue || !messageActivity.quiet() || !hostActivity.quiet()) return false;
-						dispatchOpen = false;
-						return true;
-					})) break;
-					yield* PubSub.publish(checks, void 0);
+				for (const lane of lanes) {
+					const exit = lane.fiber?.pollUnsafe();
+					if (exit === void 0) continue;
+					lane.fiber = void 0;
+					if (Exit.isFailure(exit)) {
+						failure ??= exit.cause;
+						lane.exhausted = true;
+					} else lane.check ||= exit.value;
+				}
+				const deliveryExit = delivery?.pollUnsafe();
+				if (deliveryExit !== void 0) {
+					delivery = void 0;
+					if (Exit.isFailure(deliveryExit)) {
+						failure ??= deliveryExit.cause;
+						messageExhausted = true;
+					}
 				}
+				if (failure !== void 0 && native === void 0) return yield* Effect.failCause(failure);
 				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);
-				const recoveryDone = recoveryFinished ? Effect.never : Fiber.await(recoveryFiber);
-				const retirementDone = retiredExit === void 0 ? Fiber.await(retired) : Effect.never;
-				const changed = activityChanged;
-				const ready = yield* Effect.raceFirst(Effect.raceFirst(notified, Effect.sleep(Math.max(0, next - now))).pipe(Effect.as("native")), Effect.raceFirst(recoveryDone.pipe(Effect.as("recovery")), Effect.raceFirst(retirementDone.pipe(Effect.as("retired")), Deferred.await(changed).pipe(Effect.as("activity")))));
-				if (ready === "recovery" || ready === "retired") continue;
-				if (ready === "activity") activityChanged = yield* Deferred.make();
-				if ((yield* Clock.currentTimeMillis) >= until) break;
-				if (ready === "native") yield* PubSub.publish(checks, void 0);
-				const awakened = yield* beginNative(observed);
-				result = yield* advance(awakened, yieldAfter, observed, recovery);
+				for (const lane of lanes) {
+					if (lane.fiber !== void 0 || lane.exhausted || !lane.check) continue;
+					lane.check = false;
+					lane.fiber = yield* fork(Effect.gen(function* () {
+						yield* Schema.decodeEffect(AuxiliaryDispatchMillis)(lane.dispatchTimeoutMillis).pipe(Effect.mapError((cause) => DurableAlarmError.make({
+							operation: "host dispatch allowance",
+							message: "Declare an integer whole-wave allowance between 1 and 300000 milliseconds",
+							cause
+						})));
+						if ((yield* Clock.currentTimeMillis) + lane.dispatchTimeoutMillis > dispatchEnd) {
+							lane.exhausted = true;
+							return false;
+						}
+						return yield* Effect.gen(function* () {
+							if (!lane.initial) {
+								const deadline = yield* lane.pendingDeadline;
+								if (Option.isNone(deadline) || deadline.value > (yield* Clock.currentTimeMillis)) return false;
+							}
+							const selectedAt = yield* Clock.currentTimeMillis;
+							if (selectedAt >= until || selectedAt + lane.dispatchTimeoutMillis > dispatchEnd) {
+								lane.exhausted = true;
+								return false;
+							}
+							lane.initial = false;
+							yield* lane.run;
+							return true;
+						}).pipe(Effect.scoped, Effect.timeoutOrElse({
+							duration: lane.dispatchTimeoutMillis,
+							orElse: () => DurableAlarmError.make({
+								operation: "host dispatch allowance",
+								message: "The admitted host wave exceeded its allowance; durable work remains pending"
+							})
+						}));
+					}));
+				}
+				if (delivery === void 0 && !messageExhausted) {
+					const selected = yield* Effect.gen(function* () {
+						const deadline = yield* messages.pendingDeadline;
+						return Option.isSome(deadline) && deadline.value <= (yield* Clock.currentTimeMillis) ? Option.some(yield* messages.prepare) : Option.none();
+					}).pipe(Effect.exit);
+					if (Exit.isFailure(selected)) {
+						failure ??= selected.cause;
+						messageExhausted = true;
+					} else if (Option.isSome(selected.value)) {
+						const wave = selected.value.value;
+						const selectedAt = yield* Clock.currentTimeMillis;
+						if (selectedAt >= until || selectedAt + wave.timeoutMillis > dispatchEnd) messageExhausted = true;
+						else delivery = yield* fork(wave.run);
+					}
+				}
+				if (native === void 0 && recoveryObserved && !recovery.needsCheckpoint && backfillObserved && delivery === void 0 && lanes.every((lane) => lane.fiber === void 0)) break;
+				if (native === void 0 && nativeCheck) {
+					nativeCheck = false;
+					const checkpoint = recoveryObserved && recovery.needsCheckpoint;
+					if (checkpoint) recovery.needsCheckpoint = false;
+					native = yield* fork(Effect.gen(function* () {
+						const awakened = checkpoint ? started : yield* beginNative(observed);
+						return yield* advance(awakened, yieldAfter, observed, recovery, !checkpoint || settled === 0);
+					}));
+				}
+				const next = Math.min(native === void 0 ? result.nextAttemptAt ?? Infinity : Infinity, now + config.wakeScanInterval, until);
+				const completing = [
+					...native === void 0 ? [] : [native],
+					...recoveryObserved ? [] : [recoveryFiber],
+					...backfillObserved ? [] : [backfill],
+					...delivery === void 0 ? [] : [delivery],
+					...lanes.flatMap((lane) => lane.fiber === void 0 ? [] : [lane.fiber])
+				];
+				if ((yield* Effect.raceAllFirst([...completing.map((fiber) => Fiber.await(fiber).pipe(Effect.as("completed"))), Effect.raceFirst(notified, Effect.sleep(Math.max(0, next - now))).pipe(Effect.as("scan"))])) === "scan") {
+					nativeCheck = true;
+					checkLanes();
+				}
+			}
+			if (native !== void 0) {
+				result = yield* Fiber.join(native);
 				if (result.phase === "actionable") phase = "actionable";
 				settled += result.settled;
 				observed.nativeOnly = false;
-				if (result.settled > 0) yield* PubSub.publish(checks, void 0);
+				recovery.started = true;
+				yield* Deferred.succeed(recovery.queue, []);
 			}
-			yield* closeDispatch;
-			yield* Fiber.join(retired);
+			yield* Fiber.joinAll([
+				recoveryFiber,
+				backfill,
+				...delivery === void 0 ? [] : [delivery],
+				...lanes.flatMap((lane) => lane.fiber === void 0 ? [] : [lane.fiber])
+			]);
+			if (failure !== void 0) return yield* Effect.failCause(failure);
 			if (recovery.needsCheckpoint) {
 				result = yield* advance(started, yieldAfter, observed, recovery, false);
 				if (result.phase === "actionable") phase = "actionable";
@@ -872,6 +870,6 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 	}));
 };
 //#endregion
-export { DurableAlarmError, DurableAlarmService, MaintenancePassReport, ThreadHostMaintenance, ThreadMaintenance, ThreadMaintenanceActivity, ThreadMaintenanceFailpoint, ThreadMessageDelivery, ThreadMutationGate, ThreadPublication, ThreadRecoveryFault, publishCommitted, Alarm_exports as t };
+export { DurableAlarmError, DurableAlarmService, MaintenancePassReport, ThreadHostMaintenance, ThreadMaintenance, ThreadMaintenanceFailpoint, ThreadMessageDelivery, ThreadMutationGate, ThreadPublication, ThreadRecoveryFault, publishCommitted, Alarm_exports as t };
 
 //# sourceMappingURL=Alarm.mjs.map