@yielded/agent-platform-cloudflare 0.1.0-beta.173 → 0.1.0-beta.175

package/dist/{Alarm-BMEAZo3p.mjs → Alarm-B44efvB1.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { DurableObjectContext } from "./CloudflareBindings.mjs";
+import { DurableObjectContext, ThreadObjectPlacement } from "./CloudflareBindings.mjs";
 import { AuxiliaryDispatchMillis, CloudflareDurableRuntimeConfig } from "./CloudflareConfig.mjs";
 import { r as safeCauseMessage } from "./boundary-BguazVkh.mjs";
 import { CurrentNativeSource } from "@yielded/agent-storage-cloudflare/port-routing";
@@ -108,7 +108,7 @@ const make = (storage) => {
 		}
 	};
 	const write = (changes) => {
-		if (decode(sql.exec(`WITH changes (id, revision, dueAt, stalls, progressKey, notBefore, state, reported, expected_revision) AS (
+		if (sql.exec(`WITH changes (id, revision, dueAt, stalls, progressKey, notBefore, state, reported, expected_revision) AS (
             VALUES ${changes.map(() => "(?, ?, ?, ?, ?, ?, ?, ?, ?)").join(", ")}
           ) INSERT INTO platform_cloudflare_due_queue
             (id, revision, dueAt, stalls, progressKey, notBefore, state, reported)
@@ -118,7 +118,7 @@ const make = (storage) => {
             notBefore = excluded.notBefore, state = excluded.state, reported = excluded.reported
           WHERE platform_cloudflare_due_queue.revision = (
             SELECT expected_revision FROM changes WHERE changes.id = excluded.id
-          ) RETURNING id, revision, dueAt, stalls, progressKey, notBefore, state, reported`, ...changes.flatMap(({ before, after }) => [
+          ) RETURNING 1`, ...changes.flatMap(({ before, after }) => [
 			after.id,
 			after.revision,
 			after.dueAt,
@@ -128,7 +128,7 @@ const make = (storage) => {
 			after.state,
 			after.reported,
 			before?.revision ?? -1
-		])).toArray()).length !== changes.length) throw new Error("Maintenance due revision changed during transaction");
+		])).toArray().length !== changes.length) throw new Error("Maintenance due revision changed during transaction");
 	};
 	const flush = (frame) => {
 		if (frame.parent !== void 0) return;
@@ -205,6 +205,14 @@ const make = (storage) => {
 			progressKey: progressKey ?? row?.progressKey ?? null
 		}));
 	};
+	/** Native checkpoints fence the generation, not each source commit. Once progress
+	* resets a claimed lane, further native commits owe the same recovery opportunity.
+	* A new claim, deadline, or retry budget makes the next commit advance it again. */
+	const progressNative = (dueAt) => {
+		const row = read().find((row) => row.id === Native);
+		if (row?.state === "pending" && row.dueAt !== null && row.dueAt <= dueAt && row.stalls === 0 && row.notBefore === 0 && row.reported === 0) return;
+		dirty(Native, dueAt, true);
+	};
 	/** A strictly increasing source cursor; old or repeated notices cannot renew a budget. */
 	const progress = (id, dueAt, cursor) => {
 		Schema.decodeSync(Schema.BigInt.check(Schema.isGreaterThanOrEqualToBigInt(0n)))(cursor);
@@ -287,6 +295,7 @@ const make = (storage) => {
 		transaction,
 		read,
 		dirty,
+		progressNative,
 		progress,
 		register,
 		claim,
@@ -384,8 +393,8 @@ var DurableAlarmService = class DurableAlarmService extends Context.Service()("@
 			ensureScheduledBy: (at) => wrap("advance maintenance checkpoint", alarms.scheduleAlarmEarlier(maintenanceAlarmInput(at))),
 			scheduleNow: Ref.get(inlineWork).pipe(Effect.flatMap((active) => active > 0 ? Effect.void : wrap("hint maintenance checkpoint", alarms.transaction((tx) => Effect.gen(function* () {
 				const now = yield* Clock.currentTimeMillis;
-				const next$4 = next(make(ctx.storage).read());
-				if (Number.isFinite(next$4)) yield* tx.scheduleAlarmEarlier(maintenanceAlarmInput(Math.max(now, next$4)));
+				const next$6 = next(make(ctx.storage).read());
+				if (Number.isFinite(next$6)) yield* tx.scheduleAlarmEarlier(maintenanceAlarmInput(Math.max(now, next$6)));
 			}))))),
 			withHintsDeferred: (body) => Effect.acquireUseRelease(Ref.update(inlineWork, (active) => active + 1), () => body, () => Ref.update(inlineWork, (active) => active - 1)),
 			cancel: wrap("cancel maintenance checkpoint", alarms.cancelAlarm(maintenanceAlarmRef))
@@ -420,12 +429,16 @@ const makeAlarmOperation = Effect.gen(function* () {
 		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: /* @__PURE__ */ new Error("Unwrapped SQL transaction cannot own buffered maintenance intent")
+			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.sync(() => {
-				if (transaction._tag === "None") throw new Error("SQL transaction unavailable");
+			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({
 				try: () => {
@@ -442,8 +455,12 @@ const makeAlarmOperation = Effect.gen(function* () {
 		}));
 	}).pipe(Effect.provideService(SqlClient, sql));
 	const run = (operation, execute) => {
-		const commit = Effect.flatMap(CurrentCheckpoint, (tx) => {
-			if (tx === void 0) return Effect.die(/* @__PURE__ */ new Error("Maintenance checkpoint transaction unavailable"));
+		const commit = Effect.withFiber((fiber) => {
+			const tx = fiber.getRef(CurrentCheckpoint);
+			if (tx === void 0) return Effect.die(DurableAlarmError.make({
+				operation: "checkpoint",
+				message: "Maintenance checkpoint transaction unavailable"
+			}));
 			return tx.requireActive.pipe(Effect.andThen(Effect.suspend(() => {
 				let checkpoint = Effect.void;
 				const intent = {
@@ -463,9 +480,9 @@ const makeAlarmOperation = Effect.gen(function* () {
 				}).pipe(Effect.tap(() => checkpoint));
 			})));
 		});
-		return Effect.gen(function* () {
-			if ((yield* CurrentCheckpoint) !== void 0) return yield* commit;
-			return yield* (yield* Effect.serviceOption(sql.transactionService))._tag === "Some" && !buffering(ctx.storage) ? transaction(commit).pipe(Effect.ensuring(Effect.sync(() => invalidate(ctx.storage)))) : withTransaction(commit);
+		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);
 		}).pipe(Effect.uninterruptible, Effect.mapError(alarmFailure(operation)));
 	};
 	return {
@@ -607,6 +624,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({
@@ -684,18 +709,30 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 		const { ctx } = yield* DurableObjectContext;
 		const sql = yield* SqlClient;
 		const dueQueue = make(ctx.storage);
+		const placement = yield* Effect.serviceOption(ThreadObjectPlacement);
+		const singleThread = Option.isSome(placement) && placement.value.threadId !== void 0;
 		const config = yield* CloudflareDurableRuntimeConfig;
 		const failpoint = yield* ThreadMaintenanceFailpoint;
 		const activeMutations = yield* Ref.make(0);
 		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;
@@ -721,8 +758,8 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 						dirty: state.dirty + 1n
 					})));
 				}
-				const next$6 = next(dueQueue.read());
-				if (Number.isFinite(next$6)) checkpoint.earlier(Math.max(next$6, 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;
@@ -779,7 +816,8 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 			const now = yield* Clock.currentTimeMillis;
 			const nativeSource = yield* CurrentNativeSource;
 			yield* runAlarmTransaction("record maintenance producer progress", async (transaction, checkpoint) => {
-				for (const id of affected) dueQueue.dirty(id, now, true);
+				for (const id of affected) if (singleThread && nativeSource && id === "effect-agent:native") dueQueue.progressNative(now);
+				else dueQueue.dirty(id, now, true);
 				if (affected.has("effect-agent:native")) {
 					const { state, initialized } = await readMaintenanceState(transaction);
 					if (!initialized || !nativeSource || state.retry !== void 0) await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(ThreadMaintenanceState.make({
@@ -789,7 +827,7 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 				}
 				checkpoint.earlier(now + minimumAlarmDelay);
 			});
-			yield* notify;
+			if (!(singleThread && nativeSource && affected.size === 1 && affected.has("effect-agent:native"))) yield* notify;
 		});
 		return ThreadMutationGate.of({
 			withTransaction,
@@ -798,7 +836,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))
 		});
 	}));
@@ -829,6 +871,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;
@@ -845,6 +888,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 }));
@@ -894,8 +939,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;
 				});
@@ -956,10 +1001,10 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 					};
 				}));
 				for (let sequence = range.next; sequence <= range.through; sequence++) {
-					const event = yield* runTransaction("read recovery event", async () => {
-						const event = decodeRecoveryEvent(await ctx.storage.get(recoveryEventKey(sequence)));
-						if (event.sequence !== sequence) throw new Error("Recovery event does not match its sequence key");
-						return event;
+					const event = yield* runTransaction("read recovery event", async () => decodeRecoveryEvent(await ctx.storage.get(recoveryEventKey(sequence))));
+					if (event.sequence !== sequence) return yield* DurableAlarmError.make({
+						operation: "read recovery event",
+						message: "Recovery event does not match its sequence key"
 					});
 					yield* recoveryEvents.publish(event);
 					const acknowledgedAt = yield* Clock.currentTimeMillis;
@@ -986,9 +1031,9 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			for (const report of result.reports) threads.set(report.threadId, void 0);
 			for (const report of result.workReports ?? []) threads.set(report.threadId, void 0);
 			for (const blocked of result.blocked) threads.set(blocked.threadId, blocked.failure);
-			if (threads.size === 0) return /* @__PURE__ */ new Map();
+			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 = [];
@@ -1046,20 +1091,23 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			return retained.faults;
 		});
 		const recoverThread = Effect.fnUntraced(function* (threadId, recovery) {
-			let cursor = yield* runTransaction("read work recovery cursor", async () => {
-				const retained = await ctx.storage.get(workCursorKey(threadId));
-				if (retained === void 0) return void 0;
-				const decoded = Schema.decodeUnknownSync(NativeWorkCursor)(retained);
-				if (decoded.threadId !== threadId) throw new Error("Work cursor belongs to another Thread");
-				return decoded.cursor;
+			const retained = yield* runTransaction("read work recovery cursor", async () => {
+				const value = await ctx.storage.get(workCursorKey(threadId));
+				return value === void 0 ? void 0 : Schema.decodeUnknownSync(NativeWorkCursor)(value);
+			});
+			if (retained !== void 0 && retained.threadId !== threadId) return yield* DurableAlarmError.make({
+				operation: "read work recovery cursor",
+				message: "Work cursor belongs to another Thread"
 			});
+			let cursor = retained?.cursor;
 			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);
-				yield* runTransaction("checkpoint work recovery cursor", async () => {
+				if (cursor !== void 0 || result.cursor !== void 0) yield* runTransaction("checkpoint work recovery cursor", async () => {
 					if (result.cursor === void 0) await ctx.storage.delete(workCursorKey(threadId));
 					else await ctx.storage.put(workCursorKey(threadId), Schema.encodeSync(NativeWorkCursor)({
 						threadId,
@@ -1102,8 +1150,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");
 		});
@@ -1177,8 +1225,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();
 				});
 			}));
@@ -1269,11 +1317,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));
@@ -1360,7 +1411,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				const pivot = Math.max(0, runnable.findIndex((threadId) => state.lastServedThreadId === void 0 || threadId > state.lastServedThreadId));
 				const selected = dispatch ? [...runnable.slice(pivot), ...runnable.slice(0, pivot)].slice(0, nativeDispatchConcurrency() - reserved.size) : [];
 				const next = selected.at(-1);
-				if (next !== void 0) await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(ThreadMaintenanceState.make({
+				if (next !== void 0 && next !== state.lastServedThreadId) await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(ThreadMaintenanceState.make({
 					...state,
 					lastServedThreadId: next
 				})));
@@ -1397,7 +1448,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;
@@ -1472,7 +1523,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;
@@ -1509,8 +1561,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);
@@ -1525,31 +1604,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) {
@@ -1577,18 +1636,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();
@@ -1646,11 +1703,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* () {
@@ -1660,18 +1717,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);
@@ -1690,9 +1748,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;
 			}
@@ -1710,7 +1769,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,
@@ -1781,9 +1840,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();
@@ -1837,4 +1896,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-BMEAZo3p.mjs.map
+//# sourceMappingURL=Alarm-B44efvB1.mjs.map