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

package/src/client.ts

@@ -18,6 +18,7 @@ import {
   IdempotencyKey,
   JoinedToHost,
   LedgerError,
+  OperationDenied,
   PersistedJson,
   Principal,
   Receipt,
@@ -29,7 +30,7 @@ import {
   type DurableSubmitAgent,
   type DurableSubmitOptions,
 } from "@effect-agent/session";
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Crypto, Duration, Effect, Layer, Schema } from "effect";
 
 import { DurableAlarmError } from "./alarm.ts";
 import { ConversationObjectNamespace, type ConversationObjectRpc } from "./bindings.ts";
@@ -73,6 +74,10 @@ export class ConversationClientError extends Schema.TaggedError<ConversationClie
     conversationId: Schema.String,
     message: Schema.String,
     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),
   },
 ) {}
 
@@ -104,6 +109,21 @@ export class ObservePageRequest extends Schema.Class<ObservePageRequest>(
   limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1_024)),
 }) {}
 
+/** One event-driven wait for canonical progress strictly after this sequence. */
+export class AwaitProgressRequest extends Schema.Class<AwaitProgressRequest>(
+  "@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. */
+export class CancelProgressRequest extends Schema.Class<CancelProgressRequest>(
+  "@effect-agent/platform-cloudflare/CancelProgressRequest",
+)({
+  waiterId: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256)),
+}) {}
+
 // ---------------------------------------------------------------------------
 // Responses
 // ---------------------------------------------------------------------------
@@ -130,6 +150,7 @@ export const HostFailure = Schema.Union([
   DurableRuntimeFailpointError,
   AdmissionLimitExceeded,
   DurableAlarmError,
+  OperationDenied,
   HostProtocolError,
 ]);
 export type HostFailure = typeof HostFailure.Type;
@@ -152,6 +173,15 @@ export class ObservedPage extends Schema.TaggedClass<ObservedPage>(
   records: Schema.Array(CanonicalRecordEnvelope).check(Schema.isMaxLength(1_024)),
 }) {}
 
+/** A record was already committed or an incarnation-local hint says the caller should re-read. */
+export class ProgressObserved extends Schema.TaggedClass<ProgressObserved>(
+  "@effect-agent/platform-cloudflare/ProgressObserved",
+)("ProgressObserved", {}) {}
+
+export class ProgressCancelled extends Schema.TaggedClass<ProgressCancelled>(
+  "@effect-agent/platform-cloudflare/ProgressCancelled",
+)("ProgressCancelled", {}) {}
+
 export class AbortRecorded extends Schema.TaggedClass<AbortRecorded>(
   "@effect-agent/platform-cloudflare/AbortRecorded",
 )("AbortRecorded", {
@@ -182,6 +212,8 @@ export const HostResponse = Schema.Union([
   SubmitSucceeded,
   SettlementReached,
   ObservedPage,
+  ProgressObserved,
+  ProgressCancelled,
   AbortRecorded,
   ApprovalRecorded,
   UnknownResolutionRecorded,
@@ -199,6 +231,10 @@ export const decodeReceipt = Schema.decodeUnknownEffect(Receipt);
 export const encodeReceipt = Schema.encodeEffect(Receipt);
 export const decodeObservePageRequest = Schema.decodeUnknownEffect(ObservePageRequest);
 export const encodeObservePageRequest = Schema.encodeEffect(ObservePageRequest);
+export const decodeAwaitProgressRequest = Schema.decodeUnknownEffect(AwaitProgressRequest);
+export const encodeAwaitProgressRequest = Schema.encodeEffect(AwaitProgressRequest);
+export const decodeCancelProgressRequest = Schema.decodeUnknownEffect(CancelProgressRequest);
+export const encodeCancelProgressRequest = Schema.encodeEffect(CancelProgressRequest);
 export const decodeAbortCommand = Schema.decodeUnknownEffect(AbortCommand);
 export const encodeAbortCommand = Schema.encodeEffect(AbortCommand);
 export const decodeApprovalDecisionCommand = Schema.decodeUnknownEffect(ApprovalDecisionCommand);
@@ -237,6 +273,14 @@ export type ClientAwaitFailure =
 export type ClientObserveFailure =
   | ConversationStoreError
   | ConversationNotMaterialized
+  | OperationDenied
+  | HostProtocolError
+  | ConversationClientError;
+
+export type ClientProgressFailure =
+  | ConversationStoreError
+  | ConversationNotMaterialized
+  | OperationDenied
   | HostProtocolError
   | ConversationClientError;
 
@@ -253,6 +297,7 @@ export type ClientApprovalFailure =
   | LedgerError
   | SettlementConflict
   | ApprovalConflict
+  | OperationDenied
   | DurableAlarmError
   | HostProtocolError
   | ConversationClientError;
@@ -263,6 +308,7 @@ export type ClientUnknownFailure =
   | UnknownResolutionConflict
   | JoinedToHost
   | DurableRuntimeFailpointError
+  | OperationDenied
   | DurableAlarmError
   | HostProtocolError
   | ConversationClientError;
@@ -289,8 +335,10 @@ const AWAIT_FAILURE_TAGS: ReadonlySet<string> = new Set([
 const OBSERVE_FAILURE_TAGS: ReadonlySet<string> = new Set([
   "ConversationStoreError",
   "ConversationNotMaterialized",
+  "OperationDenied",
   "HostProtocolError",
 ]);
+const PROGRESS_FAILURE_TAGS = OBSERVE_FAILURE_TAGS;
 const ABORT_FAILURE_TAGS: ReadonlySet<string> = new Set([
   "LedgerError",
   "SettlementConflict",
@@ -303,6 +351,7 @@ const APPROVAL_FAILURE_TAGS: ReadonlySet<string> = new Set([
   "LedgerError",
   "SettlementConflict",
   "ApprovalConflict",
+  "OperationDenied",
   "DurableAlarmError",
   "HostProtocolError",
 ]);
@@ -312,6 +361,7 @@ const UNKNOWN_FAILURE_TAGS: ReadonlySet<string> = new Set([
   "UnknownResolutionConflict",
   "JoinedToHost",
   "DurableRuntimeFailpointError",
+  "OperationDenied",
   "DurableAlarmError",
   "HostProtocolError",
 ]);
@@ -351,6 +401,14 @@ export class CloudflareConversationClient extends Context.Service<
     ) => Effect.Effect<Receipt, ClientSubmitFailure, InputSchema["EncodingServices"]>;
     /** Wake-hinted, poll-guaranteed settlement wait executed inside the owning Object. */
     readonly awaitSettlement: (receipt: Receipt) => Effect.Effect<Settlement, ClientAwaitFailure>;
+    /**
+     * Wait without polling until progress after `afterSequence` is already durable or hinted.
+     * The result is deliberately void: canonical records remain authoritative and must be read.
+     */
+    readonly awaitProgress: (
+      conversationId: ConversationId,
+      afterSequence: CanonicalSequence,
+    ) => Effect.Effect<void, ClientProgressFailure>;
     /** One bounded page of canonical records. */
     readonly readPage: (
       conversationId: ConversationId,
@@ -389,10 +447,37 @@ export class CloudflareConversationClient extends Context.Service<
   static readonly layer: Layer.Layer<
     CloudflareConversationClient,
     never,
-    ConversationObjectNamespace
+    ConversationObjectNamespace | Crypto.Crypto
   > = Layer.effect(CloudflareConversationClient)(
     Effect.gen(function* () {
       const { namespace } = yield* ConversationObjectNamespace;
+      const crypto = yield* Crypto.Crypto;
+
+      const platformSignals = (cause: unknown) => {
+        let retryable: boolean | undefined;
+        let overloaded: boolean | undefined;
+        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;
+          }
+          // Miniflare's faithful `ctx.abort()` signal predates the public `retryable` field.
+          // Treat only its explicit reset marker as the same idempotent-retry classification.
+          if (
+            retryable === undefined &&
+            "durableObjectReset" in cause &&
+            cause.durableObjectReset === true
+          ) {
+            retryable = true;
+          }
+        }
+        return {
+          ...(retryable === undefined ? {} : { retryable }),
+          ...(overloaded === undefined ? {} : { overloaded }),
+        };
+      };
 
       const call = (
         conversationId: string,
@@ -410,6 +495,7 @@ export class CloudflareConversationClient extends Context.Service<
                 }`,
               ),
               cause,
+              ...platformSignals(cause),
             }),
         }).pipe(
           Effect.flatMap((raw) =>
@@ -488,6 +574,19 @@ export class CloudflareConversationClient extends Context.Service<
           return page.records;
         });
 
+      const cancelProgress = (
+        conversationId: ConversationId,
+        waiterId: string,
+      ): Effect.Effect<void> =>
+        encodeCancelProgressRequest(CancelProgressRequest.make({ waiterId })).pipe(
+          Effect.mapError(() => undefined),
+          Effect.flatMap((encoded) =>
+            call(conversationId, "cancelProgress", (stub) => stub.cancelProgressEncoded(encoded)),
+          ),
+          Effect.asVoid,
+          Effect.ignore,
+        );
+
       return CloudflareConversationClient.of({
         submit: <InputSchema extends Schema.Top>(
           agent: DurableSubmitAgent<InputSchema>,
@@ -558,6 +657,55 @@ export class CloudflareConversationClient extends Context.Service<
             return settled.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: number): Effect.Effect<void, ClientProgressFailure> =>
+              call(conversationId, "awaitProgress", (stub) =>
+                stub.awaitProgressEncoded(encoded),
+              ).pipe(
+                Effect.flatMap(
+                  expect<ProgressObserved, ClientProgressFailure & HostFailure>(
+                    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) =>

package/src/conversation-object.ts

@@ -27,6 +27,7 @@ import {
   SettlementConflict,
   SubmissionLedger,
   SubmissionLookupByKey,
+  WakeScheduler,
   type DurableSubmitAgent,
 } from "@effect-agent/session";
 import type { DurableObject as CloudflareDurableObject } from "cloudflare:workers";
@@ -56,11 +57,15 @@ import {
   HostFailed,
   HostProtocolError,
   ObservedPage,
+  ProgressObserved,
+  ProgressCancelled,
   SettlementReached,
   SubmitSucceeded,
   UnknownResolutionRecorded,
   boundHostDiagnostic,
   decodeAbortCommand,
+  decodeAwaitProgressRequest,
+  decodeCancelProgressRequest,
   decodeApprovalDecisionCommand,
   decodeObservePageRequest,
   decodeReceipt,
@@ -78,6 +83,7 @@ import {
   type CloudflareDurableRuntimeOptions,
   type CloudflareDurableRuntimeServices,
 } from "./layers.ts";
+import { ProgressWaitRegistry } from "./progress-wait.ts";
 
 /**
  * `makeConversationObjectClass(options, observability?)` — the Conversation Durable Object
@@ -246,17 +252,15 @@ const submitEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpoin
         const maintenance = yield* ConversationMaintenance;
         const runtime = yield* DurableAgentRuntime;
         yield* gateAdmissionLimits(request);
-        // Alarm invariant: the alarm commits BEFORE the admission it will finish (D-P6-2).
-        yield* maintenance.preArm;
-        const receipt = yield* runtime.submit(
-          passthroughSubmitAgent(request.agentId),
-          request.inputPayload,
-          {
+        // Alarm invariant: the generation + alarm commit BEFORE the admission, and maintenance
+        // cannot acknowledge that generation until this mutation leaves its public RPC seam.
+        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 });
       }),
@@ -281,6 +285,46 @@ const awaitSettlementEndpoint = (
     Effect.flatMap(encodeResponse),
   );
 
+const awaitProgressEndpoint = (encoded: unknown): Effect.Effect<unknown, never, EndpointServices> =>
+  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: unknown,
+): Effect.Effect<unknown, never, EndpointServices> =>
+  decodeCancelProgressRequest(encoded).pipe(
+    Effect.mapError(protocolFailure("The progress cancellation could not be decoded")),
+    Effect.flatMap((request) =>
+      Effect.gen(function* () {
+        const registry = yield* ProgressWaitRegistry;
+        yield* registry.cancel(request.waiterId);
+        return ProgressCancelled.make();
+      }),
+    ),
+    respond,
+    Effect.flatMap(encodeResponse),
+  );
+
 const observePageEndpoint = (encoded: unknown): Effect.Effect<unknown, never, EndpointServices> =>
   decodeObservePageRequest(encoded).pipe(
     Effect.mapError(protocolFailure("The observe request could not be decoded")),
@@ -291,14 +335,12 @@ const observePageEndpoint = (encoded: unknown): Effect.Effect<unknown, never, En
         // The same fail-closed authorization seam the runtime's `observe` consults (P7 WP1);
         // the default reference preserves the possession behavior.
         const authorizer = yield* OperationAuthorizer;
-        yield* authorizer
-          .authorize(
-            OperationAuthorizationRequest.make({
-              operation: "observe",
-              conversationId: identity.conversationId,
-            }),
-          )
-          .pipe(Effect.catchTag("OperationDenied", deniedToProtocolFailure));
+        yield* authorizer.authorize(
+          OperationAuthorizationRequest.make({
+            operation: "observe",
+            conversationId: identity.conversationId,
+          }),
+        );
         const records = yield* Stream.runCollect(
           store.read(
             ConversationRead.make({
@@ -324,8 +366,7 @@ const abortEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpoint
       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 });
       }),
     ),
@@ -333,24 +374,6 @@ const abortEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpoint
     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: OperationDenied,
-): Effect.Effect<never, HostProtocolError> =>
-  Effect.fail(
-    HostProtocolError.make({
-      message: boundHostDiagnostic(
-        `The ${denied.operation} operation was denied: ${denied.reason}`,
-      ),
-    }),
-  );
-
 const resolveApprovalEndpoint = (
   encoded: unknown,
 ): Effect.Effect<unknown, never, EndpointServices> =>
@@ -360,10 +383,7 @@ const resolveApprovalEndpoint = (
       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 });
       }),
     ),
@@ -380,10 +400,7 @@ const resolveUnknownEndpoint = (
       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 });
       }),
     ),
@@ -541,10 +558,8 @@ const retryEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpoint
       Effect.gen(function* () {
         const maintenance = yield* ConversationMaintenance;
         const runtime = yield* DurableAgentRuntime;
-        // Alarm invariant: retry may repair durable state, so the alarm that will finish the
-        // lane commits BEFORE the mutation (D-P6-2), exactly like abort.
-        yield* maintenance.preArm;
-        const report = yield* runtime.retry(command);
+        // Retry may repair durable state, so its generation + alarm commit before the mutation.
+        const report = yield* maintenance.withMutation(runtime.retry(command));
         return RetryExecuted.make({ report });
       }),
     ),
@@ -567,10 +582,11 @@ const obligationsEndpoint = (encoded: unknown): Effect.Effect<unknown, never, En
   );
 
 /**
- * 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: unknown): Effect.Effect<unknown, never, EndpointServices> =>
   Effect.gen(function* () {
@@ -578,16 +594,17 @@ const portCallEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpo
     const maintenance = yield* ConversationMaintenance;
     const alarm = yield* DurableAlarmService;
     const mutating = isMutatingPortRequest(encoded);
-    if (mutating) {
-      const preArmed = yield* maintenance.preArm.pipe(Effect.exit);
-      if (preArmed._tag === "Failure") {
-        // Without the committed alarm the invariant cannot be promised; refuse the mutation.
-        return encodedPortProtocolFailure(
-          "The owner Object could not arm its maintenance alarm before the mutation.",
-        );
-      }
+    const handled = yield* (
+      mutating ? maintenance.withMutation(ports.handle(encoded)) : ports.handle(encoded)
+    ).pipe(Effect.exit);
+    if (handled._tag === "Failure") {
+      // Without the committed generation/alarm the invariant cannot be promised; refuse before
+      // the port mutation runs. `ports.handle` itself is total, so this is the maintenance error.
+      return encodedPortProtocolFailure(
+        "The owner Object could not arm its maintenance alarm before the mutation.",
+      );
     }
-    const response = yield* ports.handle(encoded);
+    const response = handled.value;
     if (mutating) {
       // Prompt processing hint; the pre-armed alarm already guarantees convergence.
       yield* alarm.scheduleNow.pipe(
@@ -600,19 +617,18 @@ const portCallEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpo
   });
 
 const wakeEndpoint: Effect.Effect<void, never, EndpointServices> = Effect.gen(function* () {
-  const alarm = yield* DurableAlarmService;
-  // Wake hints are droppable by contract: a failed alarm write is logged and swallowed; the
-  // sender's own alarm/scan pairing (or this Object's next entry point) restores liveness.
-  yield* alarm.scheduleNow.pipe(
-    Effect.catch((error) => Effect.logWarning("ConversationObject.wake dropped", error)),
-  );
+  const identity = yield* ConversationObjectIdentity;
+  const wake = yield* WakeScheduler;
+  // Route the remote hint through this incarnation's scheduler so scoped progress waiters and
+  // the alarm receive the same hint. Delivery remains droppable; canonical storage is authority.
+  yield* wake.notify(identity.conversationId);
 });
 
 const alarmEndpoint: Effect.Effect<void, MaintenancePassFailure, EndpointServices> = Effect.gen(
   function* () {
     const maintenance = yield* ConversationMaintenance;
     // Typed pass failures propagate: the rejected promise makes workerd retry the alarm
-    // (at-least-once delivery), and the pass's own pre-arm keeps the slot committed meanwhile.
+    // (at-least-once delivery), and the dirty generation retains a committed slot meanwhile.
     yield* maintenance.pass;
   },
 );
@@ -660,6 +676,8 @@ const effectCfPlatformLayer = (
 export interface ConversationObjectInstance extends CloudflareDurableObject {
   submitEncoded(encoded: unknown): Promise<unknown>;
   awaitSettlementEncoded(encoded: unknown): Promise<unknown>;
+  awaitProgressEncoded(encoded: unknown): Promise<unknown>;
+  cancelProgressEncoded(encoded: unknown): Promise<unknown>;
   observePage(encoded: unknown): Promise<unknown>;
   abortEncoded(encoded: unknown): Promise<unknown>;
   resolveApprovalEncoded(encoded: unknown): Promise<unknown>;
@@ -728,6 +746,8 @@ export const makeConversationObjectClass = <EventLayerError = never, EventServic
   const rpc = {
     submitEncoded: (encoded: unknown) => submitEndpoint(encoded),
     awaitSettlementEncoded: (encoded: unknown) => awaitSettlementEndpoint(encoded),
+    awaitProgressEncoded: (encoded: unknown) => awaitProgressEndpoint(encoded),
+    cancelProgressEncoded: (encoded: unknown) => cancelProgressEndpoint(encoded),
     observePage: (encoded: unknown) => observePageEndpoint(encoded),
     abortEncoded: (encoded: unknown) => abortEndpoint(encoded),
     resolveApprovalEncoded: (encoded: unknown) => resolveApprovalEndpoint(encoded),

package/src/index.ts

@@ -6,8 +6,9 @@
  * `makeConversationObjectClass` builds the class applications export from their Worker,
  * `CloudflareDurableRuntime.layer` assembles the coordinator over the storage-cloudflare
  * adapters and the WP2 cross-Object routing, `DurableAlarmService`/`ConversationMaintenance`
- * multiplex every cadence into the Object's single alarm slot (nonterminal work implies a
- * committed alarm, so eviction recovers without an incoming request), and
+ * multiplex every cadence into the Object's single alarm slot (dirty or autonomously
+ * actionable work retains a committed alarm; stable external waits quiesce until their next
+ * durably pre-armed mutation), and
  * `CloudflareConversationClient` is the Worker-side ingress. Platform bindings enter ONLY
  * through the `bindings.ts` Layers (DEPLOY-010). This is the only workspace package allowed
  * to import the `cloudflare:workers` runtime module.
@@ -16,6 +17,7 @@ export * from "./bindings.ts";
 export * from "./config.ts";
 export * from "./alarm.ts";
 export * from "./wake-scheduler.ts";
+export * from "./progress-wait.ts";
 export * from "./transport.ts";
 export * from "./layers.ts";
 export * from "./conversation-object.ts";