@effect-agent/platform-cloudflare 0.1.0-beta.15 → 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, 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 } 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";
@@ -497,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({
@@ -509,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
@@ -643,14 +710,15 @@ var CloudflareDurableRuntime = class {
 			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, maintenanceFailpointLayer);
-			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);
 		}));
 	}
@@ -679,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
@@ -699,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
@@ -721,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 }) {};
@@ -736,6 +819,8 @@ const HostResponse = Schema.Union([
 	SubmitSucceeded,
 	SettlementReached,
 	ObservedPage,
+	ProgressObserved,
+	ProgressCancelled,
 	AbortRecorded,
 	ApprovalRecorded,
 	UnknownResolutionRecorded,
@@ -747,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);
@@ -777,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",
@@ -791,6 +882,7 @@ const APPROVAL_FAILURE_TAGS = /* @__PURE__ */ new Set([
 	"LedgerError",
 	"SettlementConflict",
 	"ApprovalConflict",
+	"OperationDenied",
 	"DurableAlarmError",
 	"HostProtocolError"
 ]);
@@ -800,6 +892,7 @@ const UNKNOWN_FAILURE_TAGS = /* @__PURE__ */ new Set([
 	"UnknownResolutionConflict",
 	"JoinedToHost",
 	"DurableRuntimeFailpointError",
+	"OperationDenied",
 	"DurableAlarmError",
 	"HostProtocolError"
 ]);
@@ -818,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,
@@ -849,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}` })));
@@ -869,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 = [];
@@ -997,13 +1116,27 @@ const awaitSettlementEndpoint = (encoded) => decodeReceipt(encoded).pipe(Effect.
 	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 },
@@ -1017,24 +1150,16 @@ const abortEndpoint = (encoded) => decodeAbortCommand(encoded).pipe(Effect.mapEr
 	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;
-	const intent = yield* maintenance.withMutation(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;
-	const intent = yield* maintenance.withMutation(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. */
@@ -1128,7 +1253,8 @@ const portCallEndpoint = (encoded) => Effect.gen(function* () {
 	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;
@@ -1177,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),
@@ -1829,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, ConversationMaintenanceFailpoint, 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