@effect-agent/platform-cloudflare 0.1.0-beta.14 → 0.1.0-beta.16

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { Cause, Clock, Context, Duration, Effect, Exit, Fiber, Layer, Option, PubSub, Random, Ref, Schema, Stream } from "effect";
-import { AbortCommand, AbortIntent, AdmissionConflict, AgentBindingResolver, AppendConflict, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, CanonicalRecordEnvelope, CanonicalSequence, ConversationNotMaterialized, ConversationRead, ConversationStore, ConversationStoreError, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, DeploymentId, DigestError, DurableAgentRuntime, DurableRuntimeConfig, DurableRuntimeFailpoint, DurableRuntimeFailpointError, FenceRejected, IdempotencyKey, IntegrityReport, JoinedToHost, LedgerError, ObligationReport, ObligationThresholds, OperationAuthorizationRequest, OperationAuthorizer, OperationDenied, OwnershipLost, PersistedJson, Principal, ProducerId, Receipt, RecoveryExplanation, RecoveryReport, RetryCommand, RetryRefused, RunJournalError, Settlement, SettlementConflict, SubmissionLedger, SubmissionLookupByKey, ToolReconciler, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, WakeScheduler } from "@effect-agent/session";
+import { Cause, Clock, Context, Crypto, Deferred, Duration, Effect, Exit, Fiber, Layer, Option, PubSub, Random, Ref, Schema, Semaphore, Stream } from "effect";
+import { AbortCommand, AbortIntent, AdmissionConflict, AgentBindingResolver, AppendConflict, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, CanonicalRecordEnvelope, CanonicalSequence, ConversationNotMaterialized, ConversationRead, ConversationStore, ConversationStoreError, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, DeploymentId, DigestError, DurableAgentRuntime, DurableRuntimeConfig, DurableRuntimeFailpoint, DurableRuntimeFailpointError, FenceRejected, IdempotencyKey, IntegrityReport, JoinedToHost, LedgerError, ObligationReport, ObligationThresholds, OperationAuthorizationRequest, OperationAuthorizer, OperationDenied, OwnershipLost, PersistedJson, Principal, ProducerId, Receipt, RecoveryExplanation, RecoveryReport, RetryCommand, RetryRefused, RunJournalError, Settlement, SettlementConflict, SubmissionLedger, SubmissionLookupByKey, ToolReconciler, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, WakeScheduler, makeWakeSubscriptionHub, operationAuthorizerLayer } from "@effect-agent/session";
 import { ConversationPortTransport, DEFAULT_MAX_STORED_VALUE_BYTES, conversationStoreLayer, handleEncodedPortRequest, portTransportFailure, routedConversationStoreLayer, routedSubmissionLedgerLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer } from "@effect-agent/storage-cloudflare";
 import { AgentId, AgentInputError, ConversationId, SubmissionId } from "@effect-agent/core";
 import { BrowserCrypto } from "@effect/platform-browser";
@@ -180,11 +180,10 @@ const CLOUDFLARE_RUNTIME_DEFAULTS = {
 * and abort re-checks, retry backoff) multiplexes into one idempotent maintenance pass, and
 * the slot always holds the EARLIEST deadline any caller asked for.
 *
-* The alarm invariant (plan §1.4): committed nonterminal work implies a committed alarm.
-* It is established by pre-arming — every mutating entry point and every pass arms the alarm
-* BEFORE its durable mutations — so an eviction at any failpoint leaves a persisted alarm
-* that workerd re-delivers to a fresh incarnation WITHOUT any incoming request. Spurious
-* alarms are harmless by design: a pass over an all-settled lane simply deletes the slot.
+* The alarm invariant (plan §1.4): every committed actionable mutation carries a newer durable
+* maintenance generation and a committed alarm. Stable externally-driven waits may be
+* nonterminal without retaining an alarm; their resolving mutation advances the generation and
+* restores the alarm atomically.
 */
 /** The Durable Object alarm API failed; surfaces on host entry points as a typed refusal. */
 var DurableAlarmError = class extends Schema.TaggedError()("DurableAlarmError", {
@@ -207,7 +206,6 @@ var DurableAlarmService = class DurableAlarmService extends Context.Service()("@
 		* on top of the already-committed pre-armed alarm.
 		*/
 		const runningPasses = yield* Ref.make(0);
-		const wakeDeferred = yield* Ref.make(false);
 		const scheduled = Effect.tryPromise({
 			try: () => ctx.storage.getAlarm(),
 			catch: alarmFailure("get alarm")
@@ -218,14 +216,8 @@ var DurableAlarmService = class DurableAlarmService extends Context.Service()("@
 		});
 		const ensureScheduledBy = (epochMillis) => scheduled.pipe(Effect.flatMap((existing) => Option.isSome(existing) && existing.value <= epochMillis ? Effect.void : scheduleAt(epochMillis)));
 		const armNow = Clock.currentTimeMillis.pipe(Effect.flatMap((now) => ensureScheduledBy(now)));
-		const scheduleNow = Ref.get(runningPasses).pipe(Effect.flatMap((passes) => passes > 0 ? Ref.set(wakeDeferred, true) : armNow));
-		/**
-		* Flush after the LAST concurrent pass: the re-arm lands at the very end of the alarm
-		* handler, where a superseding cancellation only re-delivers to the already-idempotent
-		* pass. Runs inside `Effect.ensuring`, so flush failures are logged, never raised.
-		*/
-		const flushDeferredWake = Ref.get(runningPasses).pipe(Effect.flatMap((passes) => passes > 0 ? Effect.void : Ref.getAndSet(wakeDeferred, false).pipe(Effect.flatMap((wanted) => wanted ? armNow : Effect.void))), Effect.catch((error) => Effect.logWarning("DurableAlarmService: deferred wake flush failed", error)));
-		const withWakesDeferred = (body) => Ref.update(runningPasses, (passes) => passes + 1).pipe(Effect.andThen(body), Effect.ensuring(Ref.update(runningPasses, (passes) => passes - 1).pipe(Effect.andThen(flushDeferredWake))));
+		const scheduleNow = Ref.get(runningPasses).pipe(Effect.flatMap((passes) => passes > 0 ? Effect.void : armNow));
+		const withWakesDeferred = (body) => Ref.update(runningPasses, (passes) => passes + 1).pipe(Effect.andThen(body), Effect.ensuring(Ref.update(runningPasses, (passes) => passes - 1)));
 		const cancel = Effect.tryPromise({
 			try: () => ctx.storage.deleteAlarm(),
 			catch: alarmFailure("delete alarm")
@@ -242,35 +234,78 @@ var DurableAlarmService = class DurableAlarmService extends Context.Service()("@
 };
 /** What one maintenance pass did — auditable evidence mirroring `NodeDurableHost`'s report. */
 var MaintenancePassReport = class extends Schema.Class("@effect-agent/platform-cloudflare/MaintenancePassReport")({
+	/** `caught-up` is generation-only; `actionable` ran recovery and one bounded drain. */
+	phase: Schema.Literals(["caught-up", "actionable"]),
 	/** Recovery decisions executed (or deferred) BEFORE any new claim in this pass. */
 	recovered: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
 	/** Settlements the drain pass finalized. */
 	settled: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
 	/** Submissions still nonterminal after the pass (suspended/unknown lanes stay honest). */
 	nonterminal: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-	/** `rearmed` while nonterminal work remains, `cleared` once everything settled. */
+	/** `rearmed` for dirty/autonomous work, `cleared` for stable waits or settlement. */
 	alarm: Schema.Literals(["rearmed", "cleared"])
 }) {};
+/** Test-only fault authority; production uses the inert layer. */
+var ConversationMaintenanceFailpoint = class extends Context.Service()("@effect-agent/platform-cloudflare/ConversationMaintenanceFailpoint") {
+	static layer = Layer.succeed(this)({ hit: () => Effect.void });
+};
+const MaintenanceGeneration = Schema.BigIntFromString.check(Schema.isGreaterThanOrEqualToBigInt(0n));
+/** Versioned, platform-private maintenance state stored through Durable Object KV. */
+var ConversationMaintenanceState = class extends Schema.Class("@effect-agent/platform-cloudflare/ConversationMaintenanceState")({
+	schemaVersion: Schema.Literal(1),
+	dirty: MaintenanceGeneration,
+	processed: MaintenanceGeneration,
+	nonterminal: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+}) {};
+const MAINTENANCE_STATE_KEY = "effect-agent:conversation-maintenance:v1";
+const decodeMaintenanceState = Schema.decodeUnknownSync(ConversationMaintenanceState);
+const encodeMaintenanceState = Schema.encodeSync(ConversationMaintenanceState);
+const initialMaintenanceState = () => ConversationMaintenanceState.make({
+	schemaVersion: 1,
+	dirty: 1n,
+	processed: 0n,
+	nonterminal: 0
+});
+const readMaintenanceState = async (transaction) => {
+	const encoded = await transaction.get(MAINTENANCE_STATE_KEY);
+	return encoded === void 0 ? {
+		state: initialMaintenanceState(),
+		initialized: false
+	} : {
+		state: decodeMaintenanceState(encoded),
+		initialized: true
+	};
+};
+const ensureTransactionAlarmBy = async (transaction, deadline) => {
+	const scheduled = await transaction.getAlarm();
+	if (scheduled === null || scheduled > deadline) await transaction.setAlarm(deadline);
+};
+const stableExternalWait = (snapshot, reports) => {
+	switch (snapshot.state) {
+		case "suspended":
+		case "unknown":
+		case "joined": return true;
+		case "admitted": return reports.get(snapshot.submissionId)?.decision._tag === "AwaitParentEstablishment";
+		case "input-applied":
+		case "joining":
+		case "ready":
+		case "running":
+		case "settled":
+		case "terminalizing": return false;
+	}
+};
 /**
-* The idempotent maintenance pass and the alarm-invariant helpers (plan §1.4, D-P6-1/2).
-*
-* `pass` = pre-arm → `runRecovery` → `processConversationResolved` → re-arm-or-clear:
+* Incremental, quiescent maintenance over a durable dirty/processed generation (issue #93).
 *
-* 1. **Pre-arm**: the alarm is re-armed at `now + wakeScanInterval` BEFORE any work, so an
-*    eviction (or thrown failure → workerd alarm retry) at any point of the pass leaves a
-*    committed alarm and the fresh incarnation converges without an incoming request.
-* 2. **Reconcile before new work** (exit gate): every pass classifies and repairs every
-*    nonterminal Submission before the drain claims anything; the pure classifier and the
-*    repair executors are idempotent, so at-least-once alarm delivery re-runs them safely.
-* 3. **Drain**: one bounded `processConversationResolved` pass over this Object's lane — the
-*    D-P6-1 shape; no infinite `runResolvedWorker` loop ever pins the Object.
-* 4. **Re-arm policy**: nonterminal work re-arms at `now + min(backoff-with-jitter,
-*    wakeScanInterval)` — the scan interval bounds every wait (lease expiry of a dead
-*    incarnation included, since claims retry each pass) and the backoff (reset on progress,
-*    grown otherwise) keeps stuck lanes from busy-spinning; all settled clears the slot.
+* `pass` = generation snapshot/pre-arm → recovery → bounded drain → generation acknowledgement:
 *
-* Every step is a durability-protocol step that already tolerates re-execution, which is
-* what makes double-fired alarms harmless (the alarm.test.ts gate).
+* 1. One storage transaction reads dirty/processed and re-arms before work. A caught-up forced
+*    alarm takes an O(1) path without recovery, ledger scans, or canonical-history reads.
+* 2. Recovery still strictly precedes a new claim, and one bounded drain advances the lane.
+* 3. The final transaction acknowledges only the generation observed at pass start. A racing
+*    mutation therefore remains `dirty > processed` and retains its atomically-established alarm.
+* 4. Stable external waits acknowledge and clear. Autonomous retry, indeterminate, and lease
+*    recovery states leave their generation dirty and retain bounded backoff rearming.
 */
 var ConversationMaintenance = class ConversationMaintenance extends Context.Service()("@effect-agent/platform-cloudflare/ConversationMaintenance") {
 	static layer = Layer.effect(ConversationMaintenance)(Effect.gen(function* () {
@@ -280,13 +315,76 @@ var ConversationMaintenance = class ConversationMaintenance extends Context.Serv
 		const alarm = yield* DurableAlarmService;
 		const config = yield* CloudflareDurableRuntimeConfig;
 		const identity = yield* ConversationObjectIdentity;
+		const { ctx } = yield* DurableObjectContext;
+		const failpoint = yield* ConversationMaintenanceFailpoint;
 		/**
 		* Consecutive no-progress passes — an in-memory CACHE, not state: a fresh incarnation
 		* restarts at zero and merely re-arms sooner than a long-lived one would have.
 		*/
 		const stalls = yield* Ref.make(0);
-		const preArm = Clock.currentTimeMillis.pipe(Effect.flatMap((now) => alarm.ensureScheduledBy(now + config.wakeScanInterval)));
-		const countNonterminal = Stream.runCollect(ledger.scanNonterminal).pipe(Effect.map((snapshots) => snapshots.length));
+		/**
+		* Incarnation-local mutation count guarded with the generation transactions below. It is
+		* deliberately not durable: after eviction every begun mutation has stopped, while its
+		* pre-armed dirty generation remains durable for recovery. The short gate never spans the
+		* caller's mutation or cross-Object I/O.
+		*/
+		const activeMutations = yield* Ref.make(0);
+		const generationGate = yield* Semaphore.make(1);
+		const maintenancePassGate = yield* Semaphore.make(1);
+		const minimumAlarmDelay = Math.max(1, Math.ceil(config.alarmBackoffBase / 2));
+		const runTransaction = (operation, transaction) => Effect.tryPromise({
+			try: transaction,
+			catch: alarmFailure(operation)
+		});
+		const beginMutation = Effect.fn("ConversationMaintenance.beginMutation")(function* () {
+			yield* failpoint.hit("maintenance:dirty:before");
+			const now = yield* Clock.currentTimeMillis;
+			yield* runTransaction("advance maintenance generation", () => ctx.storage.transaction(async (transaction) => {
+				const { state } = await readMaintenanceState(transaction);
+				const next = ConversationMaintenanceState.make({
+					...state,
+					dirty: state.dirty + 1n
+				});
+				await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(next));
+				await ensureTransactionAlarmBy(transaction, now + minimumAlarmDelay);
+			}));
+			yield* failpoint.hit("maintenance:dirty:after");
+			yield* Ref.update(activeMutations, (active) => active + 1);
+		});
+		const endMutation = generationGate.withPermit(Ref.update(activeMutations, (active) => Math.max(0, active - 1)));
+		const withMutation = (body) => Effect.acquireUseRelease(generationGate.withPermit(beginMutation()), () => failpoint.hit("maintenance:mutation:armed").pipe(Effect.andThen(body), Effect.tap(() => failpoint.hit("maintenance:mutation:finished"))), () => endMutation);
+		const ensureAlarm = Effect.fn("ConversationMaintenance.ensureAlarm")(function* () {
+			yield* failpoint.hit("maintenance:ensure:before");
+			const now = yield* Clock.currentTimeMillis;
+			yield* runTransaction("ensure maintenance alarm", () => ctx.storage.transaction(async (transaction) => {
+				const { state, initialized } = await readMaintenanceState(transaction);
+				if (!initialized) await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(state));
+				if (state.dirty > state.processed) await ensureTransactionAlarmBy(transaction, now + config.wakeScanInterval);
+			}));
+			yield* failpoint.hit("maintenance:ensure:after");
+		});
+		const beginPass = Effect.fn("ConversationMaintenance.beginPass")(function* () {
+			yield* failpoint.hit("maintenance:begin:before");
+			const now = yield* Clock.currentTimeMillis;
+			const result = yield* runTransaction("begin maintenance pass", () => ctx.storage.transaction(async (transaction) => {
+				const { state, initialized } = await readMaintenanceState(transaction);
+				if (!initialized) await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(state));
+				if (state.processed >= state.dirty) {
+					await transaction.deleteAlarm();
+					return {
+						_tag: "CaughtUp",
+						nonterminal: state.nonterminal
+					};
+				}
+				await ensureTransactionAlarmBy(transaction, now + minimumAlarmDelay);
+				return {
+					_tag: "Actionable",
+					generation: state.dirty
+				};
+			}));
+			yield* failpoint.hit("maintenance:begin:after");
+			return result;
+		});
 		const rearmDelay = Effect.fn("ConversationMaintenance.rearmDelay")(function* (progressed) {
 			const priorStalls = yield* Ref.getAndUpdate(stalls, (count) => progressed ? 0 : count + 1);
 			if (progressed) return config.alarmBackoffBase;
@@ -297,49 +395,73 @@ var ConversationMaintenance = class ConversationMaintenance extends Context.Serv
 			return Math.min(jittered, config.wakeScanInterval);
 		});
 		const pass = Effect.fn("ConversationMaintenance.pass")(function* () {
-			yield* preArm;
+			const annotate = (report) => Effect.annotateCurrentSpan({
+				phase: report.phase,
+				recovered: report.recovered,
+				settled: report.settled,
+				nonterminal: report.nonterminal,
+				alarm: report.alarm
+			}).pipe(Effect.as(report));
+			const started = yield* generationGate.withPermit(Effect.gen(function* () {
+				const activeAtStart = yield* Ref.get(activeMutations);
+				return {
+					...yield* beginPass(),
+					activeAtStart
+				};
+			}));
+			if (started._tag === "CaughtUp") return yield* annotate(MaintenancePassReport.make({
+				phase: "caught-up",
+				recovered: 0,
+				settled: 0,
+				nonterminal: started.nonterminal,
+				alarm: "cleared"
+			}));
 			const recovered = yield* runtime.runRecovery;
 			const settlements = yield* runtime.processConversationResolved(identity.conversationId).pipe(Effect.provideService(AgentBindingResolver, resolver));
-			const nonterminal = yield* countNonterminal;
-			if (nonterminal === 0) {
-				yield* alarm.cancel;
-				yield* Ref.set(stalls, 0);
-				const appeared = yield* countNonterminal;
-				if (appeared > 0) {
-					yield* preArm;
-					return MaintenancePassReport.make({
-						recovered: recovered.length,
-						settled: settlements.length,
-						nonterminal: appeared,
-						alarm: "rearmed"
-					});
-				}
-				return MaintenancePassReport.make({
-					recovered: recovered.length,
-					settled: settlements.length,
-					nonterminal,
-					alarm: "cleared"
-				});
-			}
+			const remaining = yield* Stream.runCollect(ledger.scanNonterminal);
+			const reports = new Map(recovered.map((report) => [report.submissionId, report]));
+			const autonomous = remaining.some((snapshot) => !stableExternalWait(snapshot, reports));
 			const progressed = settlements.length > 0 || recovered.some((report) => report.disposition === "repaired");
-			const delay = yield* rearmDelay(progressed);
+			const delay = autonomous ? yield* rearmDelay(progressed) : 0;
 			const now = yield* Clock.currentTimeMillis;
-			yield* alarm.ensureScheduledBy(now + delay);
-			return MaintenancePassReport.make({
+			yield* failpoint.hit("maintenance:finish:before");
+			const alarmDisposition = yield* generationGate.withPermit(Effect.gen(function* () {
+				const active = yield* Ref.get(activeMutations);
+				return yield* runTransaction("finish maintenance pass", () => ctx.storage.transaction(async (transaction) => {
+					const { state } = await readMaintenanceState(transaction);
+					const processed = autonomous || started.activeAtStart > 0 || active > 0 ? state.processed : state.processed > started.generation ? state.processed : started.generation;
+					const next = ConversationMaintenanceState.make({
+						...state,
+						processed,
+						nonterminal: remaining.length
+					});
+					await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(next));
+					if (autonomous) {
+						await transaction.setAlarm(now + delay);
+						return "rearmed";
+					}
+					if (started.activeAtStart > 0 || active > 0 || next.dirty > next.processed) {
+						await ensureTransactionAlarmBy(transaction, now + config.wakeScanInterval);
+						return "rearmed";
+					}
+					await transaction.deleteAlarm();
+					return "cleared";
+				}));
+			}));
+			yield* failpoint.hit("maintenance:finish:after");
+			if (alarmDisposition === "cleared") yield* Ref.set(stalls, 0);
+			return yield* annotate(MaintenancePassReport.make({
+				phase: "actionable",
 				recovered: recovered.length,
 				settled: settlements.length,
-				nonterminal,
-				alarm: "rearmed"
-			});
-		});
-		const ensureAlarm = Effect.fn("ConversationMaintenance.ensureAlarm")(function* () {
-			if ((yield* countNonterminal) === 0) return;
-			yield* preArm;
+				nonterminal: remaining.length,
+				alarm: alarmDisposition
+			}));
 		});
 		return ConversationMaintenance.of({
-			pass: alarm.withWakesDeferred(pass()),
+			pass: alarm.withWakesDeferred(maintenancePassGate.withPermit(pass())),
 			ensureAlarm: ensureAlarm(),
-			preArm
+			withMutation
 		});
 	}));
 };
@@ -375,8 +497,9 @@ const cloudflareWakeSchedulerLayer = Layer.effect(WakeScheduler)(Effect.gen(func
 	const identity = yield* ConversationObjectIdentity;
 	const { namespace } = yield* ConversationObjectNamespace;
 	const hints = yield* PubSub.sliding(WAKE_BUFFER_CAPACITY);
+	const progress = yield* makeWakeSubscriptionHub;
 	yield* Effect.addFinalizer(() => PubSub.shutdown(hints));
-	const notifyLocal = (conversationId) => PubSub.publish(hints, conversationId).pipe(Effect.andThen(alarm.scheduleNow), Effect.catch((error) => Effect.logWarning("CloudflareWakeScheduler: local alarm wake failed", error)), Effect.asVoid);
+	const notifyLocal = (conversationId) => progress.notify(conversationId).pipe(Effect.andThen(PubSub.publish(hints, conversationId)), Effect.andThen(alarm.scheduleNow), Effect.catch((error) => Effect.logWarning("CloudflareWakeScheduler: local alarm wake failed", error)), Effect.asVoid);
 	const notifyRemote = (conversationId) => Effect.tryPromise({
 		try: () => namespace.get(namespace.idFromName(conversationId)).wake(),
 		catch: (cause) => RemoteWakeDropped.make({
@@ -387,10 +510,76 @@ const cloudflareWakeSchedulerLayer = Layer.effect(WakeScheduler)(Effect.gen(func
 	}).pipe(Effect.catch((error) => Effect.logWarning(`CloudflareWakeScheduler: remote wake of ${conversationId} dropped`, error)), Effect.asVoid);
 	return WakeScheduler.of({
 		notify: (conversationId) => conversationId === identity.conversationId ? notifyLocal(conversationId) : notifyRemote(conversationId),
+		subscribe: progress.subscribe,
 		wakes: Stream.fromPubSub(hints)
 	});
 }));
 //#endregion
+//#region src/progress-wait.ts
+/** Cancellation tombstones are bounded hints, never durable authority. */
+const MAX_CANCELLATION_TOMBSTONES = 1024;
+/**
+* Per-incarnation cancellation registry for long-lived progress RPCs. The public runtime owns
+* the actual wake registration; this host-only registry lets an interrupted Worker Effect ask
+* the Object to interrupt its scoped wait before the Worker execution context itself ends.
+*/
+var ProgressWaitRegistry = class ProgressWaitRegistry extends Context.Service()("@effect-agent/platform-cloudflare/ProgressWaitRegistry") {
+	static layer = Layer.effect(ProgressWaitRegistry, Effect.gen(function* () {
+		const registrations = yield* Ref.make(/* @__PURE__ */ new Map());
+		const remove = (waiterId, deferred) => Ref.update(registrations, (current) => {
+			const existing = current.get(waiterId);
+			if (existing === void 0 || existing === "cancelled" || !existing.has(deferred)) return current;
+			const next = new Map(current);
+			const active = new Set(existing);
+			active.delete(deferred);
+			if (active.size === 0) next.delete(waiterId);
+			else next.set(waiterId, active);
+			return next;
+		});
+		const subscribe = Effect.fn("ProgressWaitRegistry.subscribe")((waiterId) => Effect.gen(function* () {
+			const deferred = yield* Deferred.make();
+			yield* Effect.addFinalizer(() => remove(waiterId, deferred));
+			return {
+				cancelled: yield* Ref.modify(registrations, (current) => {
+					const existing = current.get(waiterId);
+					const next = new Map(current);
+					if (existing === "cancelled") return [true, current];
+					const active = new Set(existing ?? []);
+					active.add(deferred);
+					next.set(waiterId, active);
+					return [false, next];
+				}),
+				deferred
+			};
+		}).pipe(Effect.map(({ cancelled, deferred }) => cancelled ? Effect.void : Deferred.await(deferred))));
+		const cancel = Effect.fn("ProgressWaitRegistry.cancel")(function* (waiterId) {
+			const waiters = yield* Ref.modify(registrations, (current) => {
+				const existing = current.get(waiterId);
+				const next = new Map(current);
+				if (existing === void 0) {
+					next.set(waiterId, "cancelled");
+					let tombstones = 0;
+					for (const registration of next.values()) if (registration === "cancelled") tombstones += 1;
+					if (tombstones > MAX_CANCELLATION_TOMBSTONES) for (const [id, registration] of next) {
+						if (registration !== "cancelled") continue;
+						next.delete(id);
+						break;
+					}
+					return [[], next];
+				}
+				if (existing === "cancelled") return [[], current];
+				next.delete(waiterId);
+				return [[...existing], next];
+			});
+			yield* Effect.forEach(waiters, (waiter) => Deferred.succeed(waiter, void 0), { discard: true });
+		});
+		return ProgressWaitRegistry.of({
+			subscribe,
+			cancel
+		});
+	}));
+};
+//#endregion
 //#region src/transport.ts
 /**
 * `ConversationPortTransport` over native Durable Object JS RPC (decision D-P6-3): one
@@ -519,15 +708,17 @@ var CloudflareDurableRuntime = class {
 				abortPollInterval: Duration.millis(config.abortPollInterval)
 			}));
 			const runtimeFailpointLayer = options.runtimeFailpoint === void 0 ? DurableRuntimeFailpoint.layer : Layer.succeed(DurableRuntimeFailpoint)({ hit: options.runtimeFailpoint(ctx) });
+			const maintenanceFailpointLayer = options.maintenanceFailpoint === void 0 ? ConversationMaintenanceFailpoint.layer : Layer.succeed(ConversationMaintenanceFailpoint)({ hit: options.maintenanceFailpoint(ctx) });
 			const reconcilerLayer = options.toolReconciler ?? ToolReconciler.uncertain;
+			const authorizerLayer = options.operationAuthorizer === void 0 ? Layer.empty : operationAuthorizerLayer(options.operationAuthorizer);
 			const bindingResolverLayer = Layer.effect(AgentBindingResolver)(Effect.map(resolveBindings(options.bindings, {
 				ctx,
 				env,
 				conversationId,
 				producerId
 			}), (bindings) => AgentBindingResolver.fromBindings(bindings)));
-			const base = Layer.mergeAll(identityLayer, cloudflareConfigLayer, DurableAlarmService.layer);
-			const runtimeStack = DurableAgentRuntime.layer.pipe(Layer.provideMerge(routedPorts), Layer.provideMerge(cloudflareWakeSchedulerLayer), Layer.provideMerge(runtimeConfigLayer), Layer.provideMerge(bindingResolverLayer), Layer.provide(Layer.mergeAll(runtimeFailpointLayer, reconcilerLayer, BrowserCrypto.layer)), Layer.provideMerge(base));
+			const base = Layer.mergeAll(identityLayer, cloudflareConfigLayer, DurableAlarmService.layer, maintenanceFailpointLayer, ProgressWaitRegistry.layer);
+			const runtimeStack = DurableAgentRuntime.layer.pipe(Layer.provideMerge(routedPorts), Layer.provideMerge(cloudflareWakeSchedulerLayer), Layer.provideMerge(runtimeConfigLayer), Layer.provideMerge(bindingResolverLayer), Layer.provide(Layer.mergeAll(runtimeFailpointLayer, reconcilerLayer, authorizerLayer, BrowserCrypto.layer)), Layer.provideMerge(base));
 			return Layer.mergeAll(runtimeStack, ConversationMaintenance.layer.pipe(Layer.provide(runtimeStack)), portsEndpointLayer);
 		}));
 	}
@@ -556,7 +747,11 @@ var HostProtocolError = class extends Schema.TaggedError()("HostProtocolError",
 var ConversationClientError = class extends Schema.TaggedError()("ConversationClientError", {
 	conversationId: Schema.String,
 	message: Schema.String,
-	cause: Schema.optionalKey(Schema.Defect())
+	cause: Schema.optionalKey(Schema.Defect()),
+	/** Cloudflare's own classification for a failure safe to retry with a fresh stub. */
+	retryable: Schema.optionalKey(Schema.Boolean),
+	/** Cloudflare overloads are surfaced immediately instead of adding retry pressure. */
+	overloaded: Schema.optionalKey(Schema.Boolean)
 }) {};
 /**
 * One durable submission, input ALREADY encoded by the caller through the Agent Binding's
@@ -576,6 +771,13 @@ var ObservePageRequest = class extends Schema.Class("@effect-agent/platform-clou
 	afterSequence: Schema.optionalKey(CanonicalSequence),
 	limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1024))
 }) {};
+/** One event-driven wait for canonical progress strictly after this sequence. */
+var AwaitProgressRequest = class extends Schema.Class("@effect-agent/platform-cloudflare/AwaitProgressRequest")({
+	afterSequence: CanonicalSequence,
+	waiterId: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256))
+}) {};
+/** Best-effort cancellation of one in-flight progress RPC. */
+var CancelProgressRequest = class extends Schema.Class("@effect-agent/platform-cloudflare/CancelProgressRequest")({ waiterId: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256)) }) {};
 /**
 * Every typed failure a host entry point can produce, plus the protocol's own errors. Same
 * closed-union discipline as the WP2 `PortFailure`: members re-decode to the SAME tagged
@@ -598,11 +800,15 @@ const HostFailure = Schema.Union([
 	DurableRuntimeFailpointError,
 	AdmissionLimitExceeded,
 	DurableAlarmError,
+	OperationDenied,
 	HostProtocolError
 ]);
 var SubmitSucceeded = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/SubmitSucceeded")("SubmitSucceeded", { receipt: Receipt }) {};
 var SettlementReached = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/SettlementReached")("SettlementReached", { settlement: Settlement }) {};
 var ObservedPage = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ObservedPage")("ObservedPage", { records: Schema.Array(CanonicalRecordEnvelope).check(Schema.isMaxLength(1024)) }) {};
+/** A record was already committed or an incarnation-local hint says the caller should re-read. */
+var ProgressObserved = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ProgressObserved")("ProgressObserved", {}) {};
+var ProgressCancelled = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ProgressCancelled")("ProgressCancelled", {}) {};
 var AbortRecorded = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/AbortRecorded")("AbortRecorded", { intent: AbortIntent }) {};
 var ApprovalRecorded = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ApprovalRecorded")("ApprovalRecorded", { intent: ApprovalDecisionIntent }) {};
 var UnknownResolutionRecorded = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/UnknownResolutionRecorded")("UnknownResolutionRecorded", { intent: UnknownResolutionIntent }) {};
@@ -613,6 +819,8 @@ const HostResponse = Schema.Union([
 	SubmitSucceeded,
 	SettlementReached,
 	ObservedPage,
+	ProgressObserved,
+	ProgressCancelled,
 	AbortRecorded,
 	ApprovalRecorded,
 	UnknownResolutionRecorded,
@@ -624,6 +832,10 @@ const decodeReceipt = Schema.decodeUnknownEffect(Receipt);
 const encodeReceipt = Schema.encodeEffect(Receipt);
 const decodeObservePageRequest = Schema.decodeUnknownEffect(ObservePageRequest);
 const encodeObservePageRequest = Schema.encodeEffect(ObservePageRequest);
+const decodeAwaitProgressRequest = Schema.decodeUnknownEffect(AwaitProgressRequest);
+const encodeAwaitProgressRequest = Schema.encodeEffect(AwaitProgressRequest);
+const decodeCancelProgressRequest = Schema.decodeUnknownEffect(CancelProgressRequest);
+const encodeCancelProgressRequest = Schema.encodeEffect(CancelProgressRequest);
 const decodeAbortCommand = Schema.decodeUnknownEffect(AbortCommand);
 const encodeAbortCommand = Schema.encodeEffect(AbortCommand);
 const decodeApprovalDecisionCommand = Schema.decodeUnknownEffect(ApprovalDecisionCommand);
@@ -654,8 +866,10 @@ const AWAIT_FAILURE_TAGS = /* @__PURE__ */ new Set([
 const OBSERVE_FAILURE_TAGS = /* @__PURE__ */ new Set([
 	"ConversationStoreError",
 	"ConversationNotMaterialized",
+	"OperationDenied",
 	"HostProtocolError"
 ]);
+const PROGRESS_FAILURE_TAGS = OBSERVE_FAILURE_TAGS;
 const ABORT_FAILURE_TAGS = /* @__PURE__ */ new Set([
 	"LedgerError",
 	"SettlementConflict",
@@ -668,6 +882,7 @@ const APPROVAL_FAILURE_TAGS = /* @__PURE__ */ new Set([
 	"LedgerError",
 	"SettlementConflict",
 	"ApprovalConflict",
+	"OperationDenied",
 	"DurableAlarmError",
 	"HostProtocolError"
 ]);
@@ -677,6 +892,7 @@ const UNKNOWN_FAILURE_TAGS = /* @__PURE__ */ new Set([
 	"UnknownResolutionConflict",
 	"JoinedToHost",
 	"DurableRuntimeFailpointError",
+	"OperationDenied",
 	"DurableAlarmError",
 	"HostProtocolError"
 ]);
@@ -695,12 +911,27 @@ const narrowFailure = (tags) => (failure) => tags.has(failure._tag);
 var CloudflareConversationClient = class CloudflareConversationClient extends Context.Service()("@effect-agent/platform-cloudflare/CloudflareConversationClient") {
 	static layer = Layer.effect(CloudflareConversationClient)(Effect.gen(function* () {
 		const { namespace } = yield* ConversationObjectNamespace;
+		const crypto = yield* Crypto.Crypto;
+		const platformSignals = (cause) => {
+			let retryable;
+			let overloaded;
+			if (typeof cause === "object" && cause !== null) {
+				if ("retryable" in cause && typeof cause.retryable === "boolean") retryable = cause.retryable;
+				if ("overloaded" in cause && typeof cause.overloaded === "boolean") overloaded = cause.overloaded;
+				if (retryable === void 0 && "durableObjectReset" in cause && cause.durableObjectReset === true) retryable = true;
+			}
+			return {
+				...retryable === void 0 ? {} : { retryable },
+				...overloaded === void 0 ? {} : { overloaded }
+			};
+		};
 		const call = (conversationId, operation, invoke) => Effect.tryPromise({
 			try: () => invoke(namespace.get(namespace.idFromName(conversationId))),
 			catch: (cause) => ConversationClientError.make({
 				conversationId,
 				message: boundHostDiagnostic(`${operation} did not reach the Conversation Object: ${cause instanceof Error ? cause.message : String(cause)}`),
-				cause
+				cause,
+				...platformSignals(cause)
 			})
 		}).pipe(Effect.flatMap((raw) => decodeHostResponse(raw).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`The ${operation} answer could not be decoded: ${error.message}`) })))), Effect.withSpan("CloudflareConversationClient.call", { attributes: {
 			conversationId,
@@ -726,6 +957,7 @@ var CloudflareConversationClient = class CloudflareConversationClient extends Co
 			const response = yield* call(conversationId, "observePage", (stub) => stub.observePage(encoded));
 			return (yield* expect(conversationId, "observePage", "ObservedPage", OBSERVE_FAILURE_TAGS)(response)).records;
 		});
+		const cancelProgress = (conversationId, waiterId) => encodeCancelProgressRequest(CancelProgressRequest.make({ waiterId })).pipe(Effect.mapError(() => void 0), Effect.flatMap((encoded) => call(conversationId, "cancelProgress", (stub) => stub.cancelProgressEncoded(encoded))), Effect.asVoid, Effect.ignore);
 		return CloudflareConversationClient.of({
 			submit: (agent, input, options) => Effect.gen(function* () {
 				const encodedInput = yield* Schema.encodeEffect(agent.definition.input)(input).pipe(Effect.mapError((cause) => AgentInputError.make({ message: `Unable to encode Agent input: ${cause.message}` })));
@@ -746,6 +978,16 @@ var CloudflareConversationClient = class CloudflareConversationClient extends Co
 				const response = yield* call(receipt.conversationId, "awaitSettlement", (stub) => stub.awaitSettlementEncoded(encoded));
 				return (yield* expect(receipt.conversationId, "awaitSettlement", "SettlementReached", AWAIT_FAILURE_TAGS)(response)).settlement;
 			}),
+			awaitProgress: (conversationId, afterSequence) => Effect.gen(function* () {
+				const waiterId = yield* crypto.randomUUIDv4.pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`awaitProgress cancellation identity generation failed: ${error.message}`) })));
+				const request = AwaitProgressRequest.make({
+					afterSequence,
+					waiterId
+				});
+				const encoded = yield* encodeAwaitProgressRequest(request).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`awaitProgress request encode failed: ${error.message}`) })));
+				const attempt = (retry) => call(conversationId, "awaitProgress", (stub) => stub.awaitProgressEncoded(encoded)).pipe(Effect.flatMap(expect(conversationId, "awaitProgress", "ProgressObserved", PROGRESS_FAILURE_TAGS)), Effect.asVoid, Effect.catchTag("ConversationClientError", (error) => error.retryable === true && error.overloaded !== true && retry < 5 ? Effect.sleep(Duration.millis(10 * 2 ** retry)).pipe(Effect.andThen(attempt(retry + 1))) : Effect.fail(error)));
+				yield* attempt(0).pipe(Effect.onInterrupt(() => cancelProgress(conversationId, waiterId)));
+			}),
 			readPage,
 			readAll: (conversationId) => Effect.gen(function* () {
 				const all = [];
@@ -862,26 +1104,39 @@ const submitEndpoint = (encoded) => decodeSubmitRequest(encoded).pipe(Effect.map
 	const maintenance = yield* ConversationMaintenance;
 	const runtime = yield* DurableAgentRuntime;
 	yield* gateAdmissionLimits(request);
-	yield* maintenance.preArm;
-	const receipt = yield* runtime.submit(passthroughSubmitAgent(request.agentId), request.inputPayload, {
+	const receipt = yield* maintenance.withMutation(runtime.submit(passthroughSubmitAgent(request.agentId), request.inputPayload, {
 		conversationId: identity.conversationId,
 		principal: request.principal,
 		idempotencyKey: request.idempotencyKey,
 		definitions: request.definitions
-	});
+	}));
 	return SubmitSucceeded.make({ receipt });
 })), respond, Effect.flatMap(encodeResponse));
 const awaitSettlementEndpoint = (encoded) => decodeReceipt(encoded).pipe(Effect.mapError(protocolFailure("The receipt could not be decoded")), Effect.flatMap((receipt) => Effect.gen(function* () {
 	const settlement = yield* (yield* DurableAgentRuntime).awaitSettlement(receipt);
 	return SettlementReached.make({ settlement });
 })), respond, Effect.flatMap(encodeResponse));
+const awaitProgressEndpoint = (encoded) => decodeAwaitProgressRequest(encoded).pipe(Effect.mapError(protocolFailure("The progress request could not be decoded")), Effect.flatMap((request) => Effect.gen(function* () {
+	const identity = yield* ConversationObjectIdentity;
+	const runtime = yield* DurableAgentRuntime;
+	const registry = yield* ProgressWaitRegistry;
+	yield* Effect.scoped(Effect.gen(function* () {
+		const cancelled = yield* registry.subscribe(request.waiterId);
+		yield* Effect.raceFirst(runtime.awaitProgress(identity.conversationId, request.afterSequence), cancelled);
+	}));
+	return ProgressObserved.make();
+})), respond, Effect.flatMap(encodeResponse));
+const cancelProgressEndpoint = (encoded) => decodeCancelProgressRequest(encoded).pipe(Effect.mapError(protocolFailure("The progress cancellation could not be decoded")), Effect.flatMap((request) => Effect.gen(function* () {
+	yield* (yield* ProgressWaitRegistry).cancel(request.waiterId);
+	return ProgressCancelled.make();
+})), respond, Effect.flatMap(encodeResponse));
 const observePageEndpoint = (encoded) => decodeObservePageRequest(encoded).pipe(Effect.mapError(protocolFailure("The observe request could not be decoded")), Effect.flatMap((request) => Effect.gen(function* () {
 	const identity = yield* ConversationObjectIdentity;
 	const store = yield* ConversationStore;
 	yield* (yield* OperationAuthorizer).authorize(OperationAuthorizationRequest.make({
 		operation: "observe",
 		conversationId: identity.conversationId
-	})).pipe(Effect.catchTag("OperationDenied", deniedToProtocolFailure));
+	}));
 	const records = yield* Stream.runCollect(store.read(ConversationRead.make({
 		conversationId: identity.conversationId,
 		...request.afterSequence === void 0 ? {} : { afterSequence: request.afterSequence },
@@ -892,30 +1147,19 @@ const observePageEndpoint = (encoded) => decodeObservePageRequest(encoded).pipe(
 const abortEndpoint = (encoded) => decodeAbortCommand(encoded).pipe(Effect.mapError(protocolFailure("The abort command could not be decoded")), Effect.flatMap((command) => Effect.gen(function* () {
 	const maintenance = yield* ConversationMaintenance;
 	const runtime = yield* DurableAgentRuntime;
-	yield* maintenance.preArm;
-	const intent = yield* runtime.abort(command);
+	const intent = yield* maintenance.withMutation(runtime.abort(command));
 	return AbortRecorded.make({ intent });
 })), respond, Effect.flatMap(encodeResponse));
-/**
-* The pre-P7 host protocol's failure union does not carry `OperationDenied` (the Worker client
-* predates the authorizer). This assembly always runs the default possession authorizer — no
-* `CloudflareDurableRuntimeOptions` authorizer lever exists yet — so a denial here is
-* unreachable today; if one ever surfaces it degrades to the protocol failure instead of an
-* out-of-contract throw. The four P7 admin entry points below carry `OperationDenied` typed.
-*/
-const deniedToProtocolFailure = (denied) => Effect.fail(HostProtocolError.make({ message: boundHostDiagnostic(`The ${denied.operation} operation was denied: ${denied.reason}`) }));
 const resolveApprovalEndpoint = (encoded) => decodeApprovalDecisionCommand(encoded).pipe(Effect.mapError(protocolFailure("The approval command could not be decoded")), Effect.flatMap((command) => Effect.gen(function* () {
 	const maintenance = yield* ConversationMaintenance;
 	const runtime = yield* DurableAgentRuntime;
-	yield* maintenance.preArm;
-	const intent = yield* runtime.resolveApproval(command).pipe(Effect.catchTag("OperationDenied", deniedToProtocolFailure));
+	const intent = yield* maintenance.withMutation(runtime.resolveApproval(command));
 	return ApprovalRecorded.make({ intent });
 })), respond, Effect.flatMap(encodeResponse));
 const resolveUnknownEndpoint = (encoded) => decodeUnknownResolutionCommand(encoded).pipe(Effect.mapError(protocolFailure("The resolution command could not be decoded")), Effect.flatMap((command) => Effect.gen(function* () {
 	const maintenance = yield* ConversationMaintenance;
 	const runtime = yield* DurableAgentRuntime;
-	yield* maintenance.preArm;
-	const intent = yield* runtime.resolveUnknown(command).pipe(Effect.catchTag("OperationDenied", deniedToProtocolFailure));
+	const intent = yield* maintenance.withMutation(runtime.resolveUnknown(command));
 	return UnknownResolutionRecorded.make({ intent });
 })), respond, Effect.flatMap(encodeResponse));
 /** Explain one Submission (`submissionId` present) or every nonterminal lane member. */
@@ -983,8 +1227,7 @@ const verifyEndpoint = (encoded) => decodeAdminVerifyRequest(encoded).pipe(Effec
 const retryEndpoint = (encoded) => decodeRetryCommand(encoded).pipe(Effect.mapError(protocolFailure("The retry command could not be decoded")), Effect.flatMap((command) => Effect.gen(function* () {
 	const maintenance = yield* ConversationMaintenance;
 	const runtime = yield* DurableAgentRuntime;
-	yield* maintenance.preArm;
-	const report = yield* runtime.retry(command);
+	const report = yield* maintenance.withMutation(runtime.retry(command));
 	return RetryExecuted.make({ report });
 })), respondAdmin, Effect.flatMap(encodeAdminResponseTotal));
 const obligationsEndpoint = (encoded) => decodeObligationThresholds(encoded).pipe(Effect.mapError(protocolFailure("The obligation thresholds could not be decoded")), Effect.flatMap((thresholds) => Effect.gen(function* () {
@@ -992,25 +1235,26 @@ const obligationsEndpoint = (encoded) => decodeObligationThresholds(encoded).pip
 	return ObligationsScanned.make({ report });
 })), respondAdmin, Effect.flatMap(encodeAdminResponseTotal));
 /**
-* Owner-side `portCall`: pre-arm before a mutating envelope (a routed admission committed by
-* THIS Object must already carry the alarm that will finish it), execute on the LOCAL facets
-* (never the routed decorators), then arm an immediate alarm so the mutated lane is
-* processed promptly. Protocol anomalies answer `PortFailed(PortProtocolError)`.
+* Owner-side `portCall`: wrap a mutating envelope in the same pre-armed generation protocol as
+* public RPC (a routed mutation committed by THIS Object must already carry the alarm that will
+* finish it), execute on the LOCAL facets (never the routed decorators), then arm an immediate
+* alarm so the mutated lane is processed promptly. Protocol anomalies answer
+* `PortFailed(PortProtocolError)`.
 */
 const portCallEndpoint = (encoded) => Effect.gen(function* () {
 	const ports = yield* ConversationObjectPorts;
 	const maintenance = yield* ConversationMaintenance;
 	const alarm = yield* DurableAlarmService;
 	const mutating = isMutatingPortRequest(encoded);
-	if (mutating) {
-		if ((yield* maintenance.preArm.pipe(Effect.exit))._tag === "Failure") return encodedPortProtocolFailure("The owner Object could not arm its maintenance alarm before the mutation.");
-	}
-	const response = yield* ports.handle(encoded);
+	const handled = yield* (mutating ? maintenance.withMutation(ports.handle(encoded)) : ports.handle(encoded)).pipe(Effect.exit);
+	if (handled._tag === "Failure") return encodedPortProtocolFailure("The owner Object could not arm its maintenance alarm before the mutation.");
+	const response = handled.value;
 	if (mutating) yield* alarm.scheduleNow.pipe(Effect.catch((error) => Effect.logWarning("ConversationObject.portCall: immediate re-arm failed", error)));
 	return response;
 });
 const wakeEndpoint = Effect.gen(function* () {
-	yield* (yield* DurableAlarmService).scheduleNow.pipe(Effect.catch((error) => Effect.logWarning("ConversationObject.wake dropped", error)));
+	const identity = yield* ConversationObjectIdentity;
+	yield* (yield* WakeScheduler).notify(identity.conversationId);
 });
 const alarmEndpoint = Effect.gen(function* () {
 	yield* (yield* ConversationMaintenance).pass;
@@ -1059,6 +1303,8 @@ const makeConversationObjectClass = (options, observability) => {
 	const rpc = {
 		submitEncoded: (encoded) => submitEndpoint(encoded),
 		awaitSettlementEncoded: (encoded) => awaitSettlementEndpoint(encoded),
+		awaitProgressEncoded: (encoded) => awaitProgressEndpoint(encoded),
+		cancelProgressEncoded: (encoded) => cancelProgressEndpoint(encoded),
 		observePage: (encoded) => observePageEndpoint(encoded),
 		abortEncoded: (encoded) => abortEndpoint(encoded),
 		resolveApprovalEncoded: (encoded) => resolveApprovalEndpoint(encoded),
@@ -1711,6 +1957,6 @@ const classifyWorkerFailure = (cause, maxWallTime) => {
 /** Layer building the Dynamic Worker `CodeExecutor` from resolved bindings. */
 const dynamicWorkerCodeExecutorLayer = (options) => Layer.succeed(CodeExecutor)(CodeExecutor.of({ execute: makeExecute(options) }));
 //#endregion
-export { AbortRecorded, AdminExplainRequest, AdminFailed, AdminFailure, AdminResponse, AdminVerifyRequest, AdmissionLimitExceeded, ApprovalRecorded, CLOUDFLARE_DATABASE_CAP_BYTES, CLOUDFLARE_RUNTIME_DEFAULTS, CloudflareAdmissionLimitsValue, CloudflareBindingError, CloudflareConversationClient, CloudflareDurableRuntime, CloudflareDurableRuntimeConfig, CloudflareDurableRuntimeConfigValue, CloudflarePlatformConfigError, CodeModeHostEntrypoint, ConversationClientError, ConversationMaintenance, ConversationObjectIdentity, ConversationObjectNamespace, ConversationObjectPorts, DEFAULT_MAX_DATABASE_BYTES, DurableAlarmError, DurableAlarmService, DurableObjectContext, ExplainedRecovery, HostFailed, HostFailure, HostProtocolError, HostResponse, MaintenancePassReport, ObligationsScanned, ObservePageRequest, ObservedPage, RetryExecuted, SettlementReached, SubmitRequest, SubmitSucceeded, UnknownResolutionRecorded, VerifiedIntegrity, boundHostDiagnostic, cloudflareWakeSchedulerLayer, conversationNamespaceFromEnv, conversationNamespaceLayer, conversationPortTransportLayer, decodeAbortCommand, decodeAdminExplainRequest, decodeAdminResponse, decodeAdminVerifyRequest, decodeApprovalDecisionCommand, decodeHostResponse, decodeObligationThresholds, decodeObservePageRequest, decodeReceipt, decodeRetryCommand, decodeSubmitRequest, decodeUnknownResolutionCommand, dynamicWorkerCodeExecutorLayer, dynamicWorkerImplementation, encodeAbortCommand, encodeAdminResponse, encodeApprovalDecisionCommand, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand, makeConversationObjectClass };
+export { AbortRecorded, AdminExplainRequest, AdminFailed, AdminFailure, AdminResponse, AdminVerifyRequest, AdmissionLimitExceeded, ApprovalRecorded, AwaitProgressRequest, CLOUDFLARE_DATABASE_CAP_BYTES, CLOUDFLARE_RUNTIME_DEFAULTS, CancelProgressRequest, CloudflareAdmissionLimitsValue, CloudflareBindingError, CloudflareConversationClient, CloudflareDurableRuntime, CloudflareDurableRuntimeConfig, CloudflareDurableRuntimeConfigValue, CloudflarePlatformConfigError, CodeModeHostEntrypoint, ConversationClientError, ConversationMaintenance, ConversationMaintenanceFailpoint, ConversationObjectIdentity, ConversationObjectNamespace, ConversationObjectPorts, DEFAULT_MAX_DATABASE_BYTES, DurableAlarmError, DurableAlarmService, DurableObjectContext, ExplainedRecovery, HostFailed, HostFailure, HostProtocolError, HostResponse, MaintenancePassReport, ObligationsScanned, ObservePageRequest, ObservedPage, ProgressCancelled, ProgressObserved, ProgressWaitRegistry, RetryExecuted, SettlementReached, SubmitRequest, SubmitSucceeded, UnknownResolutionRecorded, VerifiedIntegrity, boundHostDiagnostic, cloudflareWakeSchedulerLayer, conversationNamespaceFromEnv, conversationNamespaceLayer, conversationPortTransportLayer, decodeAbortCommand, decodeAdminExplainRequest, decodeAdminResponse, decodeAdminVerifyRequest, decodeApprovalDecisionCommand, decodeAwaitProgressRequest, decodeCancelProgressRequest, decodeHostResponse, decodeObligationThresholds, decodeObservePageRequest, decodeReceipt, decodeRetryCommand, decodeSubmitRequest, decodeUnknownResolutionCommand, dynamicWorkerCodeExecutorLayer, dynamicWorkerImplementation, encodeAbortCommand, encodeAdminResponse, encodeApprovalDecisionCommand, encodeAwaitProgressRequest, encodeCancelProgressRequest, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand, makeConversationObjectClass };
 
 //# sourceMappingURL=index.mjs.map