@yielded/agent-platform-cloudflare 0.1.0-beta.174 → 0.1.0-beta.176

package/dist/{Alarm-4J9B8Fg8.mjs → Alarm-7uipp6LW.mjs}

@@ -410,49 +410,48 @@ const makeAlarmOperation = Effect.gen(function* () {
 	const queue = make(ctx.storage);
 	const transaction = (body) => alarms.transaction((mutations) => Effect.withFiber((owner) => {
 		let active = true;
-		const requireActive = Effect.withFiber((fiber) => active && fiber === owner ? Effect.void : Effect.fail(DurableAlarmError.make({
-			operation: "enroll maintenance source",
-			message: "Source intent requires its active transaction callback's fiber"
-		})));
-		return body.pipe(Effect.provideService(CurrentCheckpoint, {
+		return Effect.onExitPrimitive(body(owner).pipe(Effect.provideService(CurrentCheckpoint, {
 			mutations,
-			requireActive
-		}), Effect.ensuring(Effect.sync(() => {
+			isActive: (fiber) => active && fiber === owner
+		})), () => {
 			active = false;
-		})));
+		});
 	}), { sqlClient: sql }).pipe(Effect.mapError((cause) => cause instanceof DurableObjectStorage.StorageOperationError ? SqlError.make({ reason: UnknownError.make({
 		operation: "commit maintenance checkpoint",
 		message: "Source facts and maintenance checkpoint could not commit",
 		cause
 	}) }) : cause));
-	const withTransaction = (body) => Effect.flatMap(Effect.serviceOption(sql.transactionService), (ambient) => {
+	const withTransaction = (body) => Effect.withFiber((fiber) => {
+		const ambient = Context.getOption(fiber.context, sql.transactionService);
 		if (ambient._tag === "Some" && !ownsTransaction(ctx.storage, ambient.value[1])) return Effect.fail(SqlError.make({ reason: UnknownError.make({
 			operation: "begin maintenance source transaction",
 			message: "Use ThreadMutationGate.withTransaction at the outermost source transaction",
 			cause: "Unwrapped SQL transaction cannot own buffered maintenance intent"
 		}) }));
-		return Effect.uninterruptibleMask((restore) => Effect.suspend(() => {
-			let frame;
-			return transaction(Effect.flatMap(Effect.serviceOption(sql.transactionService), (transaction) => Effect.gen(function* () {
-				if (transaction._tag === "None") return yield* SqlError.make({ reason: UnknownError.make({
-					operation: "begin maintenance source transaction",
-					message: "SQL transaction unavailable",
-					cause: "SQL transaction unavailable"
-				}) });
-				frame = queue.begin(transaction.value[1]);
-			})).pipe(Effect.andThen(restore(body)), Effect.tap(() => Effect.try({
+		let frame;
+		return Effect.uninterruptibleMask((restore) => Effect.onExitPrimitive(transaction((owner) => {
+			const current = Context.getOption(owner.context, sql.transactionService);
+			if (current._tag === "None") return SqlError.make({ reason: UnknownError.make({
+				operation: "begin maintenance source transaction",
+				message: "SQL transaction unavailable",
+				cause: "SQL transaction unavailable"
+			}) });
+			const started = queue.begin(current.value[1]);
+			frame = started;
+			return Effect.flatMap(restore(body), (value) => Effect.try({
 				try: () => {
-					if (frame !== void 0) queue.flush(frame);
+					queue.flush(started);
+					return value;
 				},
 				catch: (cause) => SqlError.make({ reason: UnknownError.make({
 					cause,
 					operation: "flush maintenance due queue",
 					message: "Maintenance intent could not commit"
 				}) })
-			})))).pipe(Effect.onExit((exit) => Effect.sync(() => {
-				if (frame !== void 0) queue.finish(frame, Exit.isSuccess(exit));
-			})), Effect.provideService(Scheduler.PreventSchedulerYield, true));
-		}));
+			}));
+		}), (exit) => {
+			if (frame !== void 0) queue.finish(frame, Exit.isSuccess(exit));
+		}).pipe(Effect.provideService(Scheduler.PreventSchedulerYield, true)));
 	}).pipe(Effect.provideService(SqlClient, sql));
 	const run = (operation, execute) => {
 		const commit = Effect.withFiber((fiber) => {
@@ -461,28 +460,30 @@ const makeAlarmOperation = Effect.gen(function* () {
 				operation: "checkpoint",
 				message: "Maintenance checkpoint transaction unavailable"
 			}));
-			return tx.requireActive.pipe(Effect.andThen(Effect.suspend(() => {
-				let checkpoint = Effect.void;
-				const intent = {
-					at: (at) => {
-						checkpoint = tx.mutations.scheduleAlarm(maintenanceAlarmInput(at));
-					},
-					earlier: (at) => {
-						checkpoint = tx.mutations.scheduleAlarmEarlier(maintenanceAlarmInput(at));
-					},
-					cancel: () => {
-						checkpoint = tx.mutations.cancelAlarm(maintenanceAlarmRef);
-					}
-				};
-				return Effect.tryPromise({
-					try: () => execute(ctx.storage, intent),
-					catch: alarmFailure(operation)
-				}).pipe(Effect.tap(() => checkpoint));
-			})));
+			if (!tx.isActive(fiber)) return Effect.fail(DurableAlarmError.make({
+				operation: "enroll maintenance source",
+				message: "Source intent requires its active transaction callback's fiber"
+			}));
+			let checkpoint = Effect.void;
+			const intent = {
+				at: (at) => {
+					checkpoint = tx.mutations.scheduleAlarm(maintenanceAlarmInput(at));
+				},
+				earlier: (at) => {
+					checkpoint = tx.mutations.scheduleAlarmEarlier(maintenanceAlarmInput(at));
+				},
+				cancel: () => {
+					checkpoint = tx.mutations.cancelAlarm(maintenanceAlarmRef);
+				}
+			};
+			return Effect.tryPromise({
+				try: () => execute(ctx.storage, intent),
+				catch: alarmFailure(operation)
+			}).pipe(Effect.tap(() => checkpoint));
 		});
 		return Effect.withFiber((fiber) => {
 			if (fiber.getRef(CurrentCheckpoint) !== void 0) return commit;
-			return Context.getOption(fiber.context, sql.transactionService)._tag === "Some" && !buffering(ctx.storage) ? transaction(commit).pipe(Effect.ensuring(Effect.sync(() => invalidate(ctx.storage)))) : withTransaction(commit);
+			return Context.getOption(fiber.context, sql.transactionService)._tag === "Some" && !buffering(ctx.storage) ? transaction(() => commit).pipe(Effect.ensuring(Effect.sync(() => invalidate(ctx.storage)))) : withTransaction(commit);
 		}).pipe(Effect.uninterruptible, Effect.mapError(alarmFailure(operation)));
 	};
 	return {
@@ -624,6 +625,14 @@ const recoveryEvent = (fault, submissionId, transition, occurredAt) => ({
 	firstFailedAt: fault.firstFailedAt,
 	failure: fault.failure
 });
+/** Observe already-owned waves without creating one waiter fiber for each wave. */
+const awaitAnyCompletion = Effect.fnUntraced(function* (fibers, revision) {
+	const mutations = yield* ThreadMutationGate;
+	return yield* Effect.acquireUseRelease(Effect.sync(() => []), (observers) => Effect.callback((resume) => {
+		observers.push(mutations.observeChange(revision, () => resume(Effect.succeed("scan"))));
+		for (const fiber of fibers) observers.push(fiber.addObserver(() => resume(Effect.succeed("completed"))));
+	}), (observers) => Effect.sync(() => observers.forEach((remove) => remove())));
+});
 /** Post-native delivery shares a finite connection budget across independent host lanes. */
 const afterNativeDispatchConcurrency = 2;
 const NativeWorkCursor = Schema.Struct({
@@ -709,12 +718,22 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 		const activeLanes = /* @__PURE__ */ new Map();
 		const generationGate = yield* Semaphore.make(1);
 		let revision = 0;
-		let changed = yield* Deferred.make();
-		const notify = Effect.gen(function* () {
-			const previous = changed;
-			changed = yield* Deferred.make();
+		const listeners = /* @__PURE__ */ new Set();
+		const observeChange = (observed, listener) => {
+			if (observed !== revision) {
+				listener();
+				return () => {};
+			}
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		};
+		const notify = Effect.sync(() => {
 			revision++;
-			yield* Deferred.succeed(previous, void 0);
+			const pending = [...listeners];
+			listeners.clear();
+			for (const listener of pending) listener();
 		});
 		const minimumAlarmDelay = Math.max(1, Math.ceil(config.alarmBackoffBase / 2));
 		const runTransaction = yield* makeStorageOperation;
@@ -740,8 +759,8 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 						dirty: state.dirty + 1n
 					})));
 				}
-				const next$4 = next(dueQueue.read());
-				if (Number.isFinite(next$4)) checkpoint.earlier(Math.max(next$4, now + minimumAlarmDelay));
+				const next$2 = next(dueQueue.read());
+				if (Number.isFinite(next$2)) checkpoint.earlier(Math.max(next$2, now + minimumAlarmDelay));
 			};
 			yield* runAlarmTransaction("schedule maintenance lane", enroll);
 			yield* notify;
@@ -818,7 +837,11 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 			recordProgress,
 			activeLanes: Effect.sync(() => new Set(activeLanes.keys())),
 			revision: Effect.sync(() => revision),
-			awaitChange: (observed) => Effect.suspend(() => observed === revision ? Deferred.await(changed) : Effect.void),
+			observeChange,
+			awaitChange: (observed) => Effect.callback((resume) => {
+				const remove = observeChange(observed, () => resume(Effect.void));
+				return Effect.sync(remove);
+			}),
 			withSnapshot: (body) => generationGate.withPermit(Effect.flatMap(Ref.get(activeMutations), body))
 		});
 	}));
@@ -849,6 +872,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 		const runtime = yield* DurableAgentRuntime;
 		const recoveryConfig = yield* DurableRuntimeConfig;
 		const ledger = yield* SubmissionLedger;
+		const listNonterminal = ledger.listNonterminal ?? Stream.runCollect(ledger.scanNonterminal);
 		const wakes = yield* WakeScheduler;
 		const hints = yield* DurableAlarmService;
 		const alarms = yield* ThreadMaintenanceAlarm;
@@ -865,6 +889,8 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 		const messages = yield* ThreadMessageDelivery;
 		const host = yield* ThreadHostMaintenance;
 		const framework = yield* ThreadNativeMaintenance;
+		const placement = yield* Effect.serviceOption(ThreadObjectPlacement);
+		const nativeThread = Option.isSome(placement) ? placement.value.threadId : void 0;
 		const nativeDispatchConcurrency = () => framework.singleThreadRuntime === runtime ? 1 : 2;
 		for (const lane of host.lanes) yield* Schema.decodeEffect(HostLaneId)(lane.id).pipe(Effect.mapError(alarmFailure("maintenance lane ID")));
 		const recoveryEvents = Option.getOrElse(yield* Effect.serviceOption(ThreadRecoveryEvents), () => ThreadRecoveryEvents.of({ publish: () => Effect.void }));
@@ -914,8 +940,8 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				const now = yield* Clock.currentTimeMillis;
 				const claimed = yield* runAlarmTransaction("charge maintenance attempt", async (_transaction, checkpoint) => {
 					const claimed = dueQueue.claim(selected, now);
-					const next$1 = next(dueQueue.read());
-					if (Number.isFinite(next$1)) checkpoint.at(Math.max(now + minimumAlarmDelay, next$1));
+					const next$3 = next(dueQueue.read());
+					if (Number.isFinite(next$3)) checkpoint.at(Math.max(now + minimumAlarmDelay, next$3));
 					else checkpoint.cancel();
 					return claimed;
 				});
@@ -1008,7 +1034,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			for (const blocked of result.blocked) threads.set(blocked.threadId, blocked.failure);
 			if (threads.size === 0 || [...threads].every(([threadId, failure]) => failure === void 0 && recovery.loaded.has(threadId) && !recovery.faults.has(threadId))) return /* @__PURE__ */ new Map();
 			const now = yield* Clock.currentTimeMillis;
-			const submissions = current ?? (result.blocked.length === 0 ? [] : yield* Stream.runCollect(ledger.scanNonterminal));
+			const submissions = current ?? (result.blocked.length === 0 ? [] : yield* listNonterminal);
 			yield* failpoint.hit("maintenance:recovery-status:before");
 			const retained = yield* runTransaction("record Thread recovery faults", () => dueQueue.transaction(async (transaction) => {
 				const events = [];
@@ -1078,6 +1104,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			do {
 				const result = yield* runtime.runRecovery({
 					threadId,
+					deferUnclaimedAdmissions: true,
 					...cursor === void 0 ? {} : { cursor }
 				}).pipe(Effect.provideService(CurrentNativeSource, true));
 				const faults = yield* recordRecoveryFaults(result, recovery, void 0, threadId);
@@ -1124,8 +1151,8 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				if (!initialized) await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(state));
 				const native = state.dirty > state.processed ? state.retry?.generation === state.dirty ? state.retry.notBefore : rows.find((row) => row.id === "effect-agent:native")?.dueAt ?? now + minimumAlarmDelay : null;
 				dueQueue.checkpointNative(native);
-				const next$3 = next(dueQueue.read());
-				if (Number.isFinite(next$3)) checkpoint.earlier(Math.max(now + minimumAlarmDelay, next$3));
+				const next$1 = next(dueQueue.read());
+				if (Number.isFinite(next$1)) checkpoint.earlier(Math.max(now + minimumAlarmDelay, next$1));
 			});
 			yield* failpoint.hit("maintenance:ensure:after");
 		});
@@ -1199,8 +1226,8 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 						const charged = observed.charged.get(row.id) === row.revision ? row : dueQueue.claim(row, now);
 						if (charged !== void 0) dueQueue.complete(charged, now + backoffDelay(charged.stalls, jitter));
 					}
-					const next$5 = next(dueQueue.read());
-					if (Number.isFinite(next$5)) checkpoint.at(Math.max(now + minimumAlarmDelay, next$5));
+					const next$4 = next(dueQueue.read());
+					if (Number.isFinite(next$4)) checkpoint.at(Math.max(now + minimumAlarmDelay, next$4));
 					else checkpoint.cancel();
 				});
 			}));
@@ -1291,11 +1318,14 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				const { state } = await readMaintenanceState(ctx.storage);
 				return {
 					scannedGeneration: state.dirty,
-					afterWorkThread: state.lastRecoveredThreadId
+					afterWorkThread: framework.singleThreadRuntime === runtime && state.lastRecoveredThreadId === nativeThread ? void 0 : state.lastRecoveredThreadId
 				};
 			});
-			const current = yield* Stream.runCollect(ledger.scanNonterminal);
-			let workOwners = yield* runtime.discoverWorkThreads({
+			const current = yield* listNonterminal;
+			let workOwners = framework.singleThreadRuntime === runtime && nativeThread !== void 0 && current.some((submission) => submission.threadId === nativeThread) ? {
+				threadIds: [nativeThread],
+				afterThreadId: void 0
+			} : yield* runtime.discoverWorkThreads({
 				limit: 32,
 				...afterWorkThread === void 0 ? {} : { afterThreadId: afterWorkThread }
 			}).pipe(Effect.provideService(CurrentNativeSource, true));
@@ -1419,7 +1449,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				nextAttemptAt: void 0,
 				dispatched: selection.selected.length > 0
 			};
-			const remaining = yield* Stream.runCollect(ledger.scanNonterminal);
+			const remaining = yield* listNonterminal;
 			const waitingHeads = /* @__PURE__ */ new Map();
 			const autonomous = recovery.pending.size > 0 || recovery.discoveryPending || recoveryFaults.size > 0 || recovery.retryAtMillis !== void 0 || remaining.some((snapshot) => {
 				if (snapshot.state === "unknown" && waiting(snapshot)) return false;
@@ -1494,7 +1524,8 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			});
 		});
 		const dispatch = Effect.fnUntraced(function* (yieldAfter, dispatchUntil, observed) {
-			const notified = (yield* Stream.toPull(wakes.wakes)).pipe(Effect.asVoid, Effect.catch(() => Effect.never));
+			const leanSelection = framework.singleThreadRuntime === runtime && publication === emptyPublication && host.lanes.length === 0 && framework.lanes.length === 0;
+			const notified = leanSelection ? Effect.never : (yield* Stream.toPull(wakes.wakes)).pipe(Effect.asVoid, Effect.catch(() => Effect.never));
 			const started = yield* beginNative(observed);
 			yield* mutations.withSnapshot(() => Effect.gen(function* () {
 				const queued = yield* queueSnapshot;
@@ -1531,8 +1562,35 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				repaired: false,
 				discoveryPending: false
 			};
-			const recoveryFiber = yield* fork(Effect.gen(function* () {
-				for (const threadId of yield* Deferred.await(recovery.queue)) {
+			let recoveryFiber;
+			let backfill;
+			const dispatch = {
+				scope: auxiliaryScope,
+				active: /* @__PURE__ */ new Map(),
+				deferred: /* @__PURE__ */ new Set(),
+				dispatched: 0,
+				settled: 0,
+				progressed: false,
+				needsCheckpoint: false
+			};
+			let native;
+			let result;
+			let backlog;
+			if (leanSelection) {
+				result = yield* advance(started, yieldAfter, observed, recovery, dispatch);
+				recovery.started = true;
+				yield* Deferred.succeed(recovery.queue, []);
+				backlog = yield* Deferred.await(recovery.queue);
+			} else {
+				native = yield* fork(advance(started, yieldAfter, observed, recovery, dispatch));
+				result = {
+					phase: "caught-up",
+					nonterminal: started.nonterminal,
+					nextAttemptAt: void 0
+				};
+			}
+			if (backlog === void 0 || backlog.length > 0) recoveryFiber = yield* fork(Effect.gen(function* () {
+				for (const threadId of backlog ?? (yield* Deferred.await(recovery.queue))) {
 					yield* failpoint.hit("maintenance:select:before");
 					yield* runTransaction("select old recovery lane", () => dueQueue.transaction(async (transaction) => {
 						const { state } = await readMaintenanceState(transaction);
@@ -1547,31 +1605,11 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 					if (!recovery.faults.has(threadId)) yield* wakes.notify(threadId);
 				}
 			}));
-			const backfill = yield* fork(Effect.gen(function* () {
-				if ((yield* mutations.activeLanes).has("effect-agent:projection")) return;
-				const row = (yield* queueSnapshot).find((row) => row.id === Projection);
-				if (row?.dueAt === null || row === void 0 || row.dueAt > (yield* Clock.currentTimeMillis)) return;
-				return yield* runQueued(row, projection.drain.pipe(Effect.andThen(projection.pendingDeadline)), observed).pipe(Effect.timeoutOption(config.projectionDispatchTimeoutMillis));
-			}));
-			let backfillObserved = false;
-			let recoveryObserved = false;
-			const dispatch = {
-				scope: auxiliaryScope,
-				active: /* @__PURE__ */ new Map(),
-				deferred: /* @__PURE__ */ new Set(),
-				dispatched: 0,
-				settled: 0,
-				progressed: false,
-				needsCheckpoint: false
-			};
-			let native = yield* fork(advance(started, yieldAfter, observed, recovery, dispatch));
-			let result = {
-				phase: "caught-up",
-				nonterminal: started.nonterminal,
-				nextAttemptAt: void 0
-			};
+			const projectionRow = (yield* queueSnapshot).find((row) => row.id === Projection);
+			if (projectionRow !== void 0 && projectionRow.dueAt !== null && projectionRow.dueAt <= (yield* Clock.currentTimeMillis) && !(yield* mutations.activeLanes).has("effect-agent:projection")) backfill = yield* fork(runQueued(projectionRow, projection.drain.pipe(Effect.andThen(projection.pendingDeadline)), observed).pipe(Effect.timeoutOption(config.projectionDispatchTimeoutMillis), Effect.asVoid));
 			let phase = result.phase;
-			let nativeCheck = false;
+			let nativeCheck = result.dispatched === true && dispatch.active.size < nativeDispatchConcurrency();
+			observed.nativeOnly = dispatch.active.size > 0;
 			const until = DateTime.toEpochMillis(yieldAfter);
 			const dispatchEnd = DateTime.toEpochMillis(dispatchUntil);
 			while (true) {
@@ -1599,18 +1637,16 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 					if (exit.value === 0) dispatch.deferred.add(threadId);
 					nativeCheck = true;
 				}
-				if (!recoveryObserved && recoveryFiber.pollUnsafe() !== void 0) {
+				if (recoveryFiber?.pollUnsafe() !== void 0) {
 					yield* Fiber.join(recoveryFiber);
-					recoveryObserved = true;
+					recoveryFiber = void 0;
 					dispatch.scanGeneration = void 0;
 					nativeCheck ||= recovery.needsCheckpoint;
 				}
-				if (!backfillObserved) {
-					const exit = backfill.pollUnsafe();
-					if (exit !== void 0) {
-						backfillObserved = true;
-						if (Exit.isFailure(exit)) failure ??= exit.cause;
-					}
+				const backfillExit = backfill?.pollUnsafe();
+				if (backfillExit !== void 0) {
+					backfill = void 0;
+					if (Exit.isFailure(backfillExit)) failure ??= backfillExit.cause;
 				}
 				for (const lane of lanes) {
 					const exit = lane.fiber?.pollUnsafe();
@@ -1668,11 +1704,11 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 						return yield* wave.run;
 					}), observed).pipe(Effect.asVoid));
 				}
-				if (native === void 0 && dispatch.active.size === 0 && recoveryObserved && !recovery.needsCheckpoint && backfillObserved && delivery === void 0 && lanes.every((lane) => lane.fiber === void 0)) break;
+				if (native === void 0 && dispatch.active.size === 0 && recoveryFiber === void 0 && !recovery.needsCheckpoint && backfill === void 0 && delivery === void 0 && lanes.every((lane) => lane.fiber === void 0)) break;
 				if (native === void 0 && nativeCheck && dispatch.active.size < nativeDispatchConcurrency()) {
 					nativeCheck = false;
 					const nativeCheckpoint = dispatch.needsCheckpoint && dispatch.active.size === 0;
-					const checkpoint = recoveryObserved && recovery.needsCheckpoint || nativeCheckpoint;
+					const checkpoint = recoveryFiber === void 0 && recovery.needsCheckpoint || nativeCheckpoint;
 					if (checkpoint) recovery.needsCheckpoint = false;
 					const reserved = new Set(dispatch.active.keys());
 					native = yield* fork(Effect.gen(function* () {
@@ -1682,18 +1718,19 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				}
 				const next = Math.min(native === void 0 ? result.nextAttemptAt ?? Infinity : Infinity, ...queued.flatMap((row) => row.id !== "effect-agent:native" && row.dueAt !== null && row.dueAt > now ? [row.dueAt] : []), until);
 				const completing = [
-					...native === void 0 ? [] : [native],
+					native,
 					...dispatch.active.values(),
-					...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.raceAllFirst([
-					notified,
-					mutations.awaitChange(queueRevision),
-					Effect.sleep(Math.max(0, next - now))
-				]).pipe(Effect.as("scan"))])) === "scan") nativeCheck = true;
+					recoveryFiber,
+					backfill,
+					delivery,
+					...lanes.map((lane) => lane.fiber)
+				].filter((fiber) => fiber !== void 0);
+				const changed = awaitAnyCompletion(completing, queueRevision);
+				if ((yield* leanSelection && native === void 0 && dispatch.active.size === 1 && completing.length === 1 && !queued.some((row) => row.id !== "effect-agent:native" && row.dueAt !== null && row.dueAt > now && row.dueAt < until) ? changed : Effect.raceAllFirst([
+					changed,
+					...leanSelection ? [] : [notified.pipe(Effect.as("scan"))],
+					Effect.sleep(Math.max(0, next - now)).pipe(Effect.as("scan"))
+				])) === "scan") nativeCheck = true;
 			}
 			if (native !== void 0) {
 				result = yield* Fiber.join(native);
@@ -1712,9 +1749,10 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			for (const fiber of [
 				recoveryFiber,
 				backfill,
-				...delivery === void 0 ? [] : [delivery],
-				...lanes.flatMap((lane) => lane.fiber === void 0 ? [] : [lane.fiber])
+				delivery,
+				...lanes.map((lane) => lane.fiber)
 			]) {
+				if (fiber === void 0) continue;
 				const exit = yield* Fiber.await(fiber);
 				if (Exit.isFailure(exit)) failure ??= exit.cause;
 			}
@@ -1732,7 +1770,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			};
 		});
 		const pass = Effect.fnUntraced(function* (yieldAfter, dispatchUntil, observed) {
-			const concurrent = yield* Effect.exit(Effect.scoped(dispatch(yieldAfter, dispatchUntil, observed)));
+			const concurrent = yield* Effect.exit(Effect.scoped(dispatch(yieldAfter, dispatchUntil, observed)).pipe(Effect.provideService(ThreadMutationGate, mutations)));
 			const afterNative = yield* Effect.gen(function* () {
 				const lanes = [
 					recoveryEventLane,
@@ -1803,9 +1841,9 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 					const { state } = await readMaintenanceState(transaction);
 					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 + minimumAlarmDelay : now + minimumAlarmDelay : Infinity;
 					dueQueue.checkpointNative(Number.isFinite(native) ? native : null);
-					const next$2 = next(dueQueue.read());
-					if (Number.isFinite(next$2)) {
-						checkpoint.at(Math.max(now + minimumAlarmDelay, next$2));
+					const next$5 = next(dueQueue.read());
+					if (Number.isFinite(next$5)) {
+						checkpoint.at(Math.max(now + minimumAlarmDelay, next$5));
 						return "rearmed";
 					}
 					checkpoint.cancel();
@@ -1859,4 +1897,4 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 //#endregion
 export { Lifecycle as _, ThreadHostMaintenance as a, Projection as b, ThreadMaintenanceFailpoint as c, ThreadNativeMaintenance as d, ThreadPublication as f, HostLaneId as g, publishCommitted as h, MaintenancePassReport as i, ThreadMessageDelivery as l, ThreadRecoveryFaultEvent as m, DurableAlarmError as n, ThreadMaintenance as o, ThreadRecoveryEvents as p, DurableAlarmService as r, ThreadMaintenanceAlarm as s, Alarm_exports as t, ThreadMutationGate as u, Messages as v, Publication as x, Native as y };
 
-//# sourceMappingURL=Alarm-4J9B8Fg8.mjs.map
+//# sourceMappingURL=Alarm-7uipp6LW.mjs.map