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

package/src/Alarm.ts

@@ -734,6 +734,25 @@ interface NativeDispatch {
   scanRevision?: number;
 }
 
+/** Observe already-owned waves without creating one waiter fiber for each wave. */
+const awaitAnyCompletion = Effect.fnUntraced(function* (
+  fibers: ReadonlyArray<Fiber.Fiber<unknown, MaintenancePassFailure>>,
+  revision: number,
+) {
+  const mutations = yield* ThreadMutationGate;
+
+  return yield* Effect.acquireUseRelease(
+    Effect.sync<Array<() => void>>(() => []),
+    (observers) =>
+      Effect.callback<"completed" | "scan">((resume) => {
+        observers.push(mutations.observeChange(revision, () => resume(Effect.succeed("scan"))));
+        for (const fiber of fibers)
+          observers.push(fiber.addObserver(() => resume(Effect.succeed("completed"))));
+      }),
+    (observers) => Effect.sync(() => observers.forEach((remove) => remove())),
+  );
+});
+
 /** Post-native delivery shares a finite connection budget across independent host lanes. */
 const afterNativeDispatchConcurrency = 2;
 
@@ -914,6 +933,8 @@ export class ThreadMutationGate extends Context.Service<
     readonly activeLanes: Effect.Effect<ReadonlySet<string>>;
     readonly revision: Effect.Effect<number>;
     readonly awaitChange: (revision: number) => Effect.Effect<void>;
+    /** Register an incarnation-local observer; its caller must detach it on completion. */
+    readonly observeChange: (revision: number, notify: () => void) => () => void;
     readonly withSnapshot: <A, E, R>(
       body: (active: number) => Effect.Effect<A, E, R>,
     ) => Effect.Effect<A, E, R>;
@@ -934,14 +955,27 @@ export class ThreadMutationGate extends Context.Service<
       const activeLanes = new Map<string, number>();
       const generationGate = yield* Semaphore.make(1);
       let revision = 0;
-      let changed = yield* Deferred.make<void>();
+      const listeners = new Set<() => void>();
+
+      const observeChange = (observed: number, listener: () => void): (() => void) => {
+        if (observed !== revision) {
+          listener();
+
+          return () => {};
+        }
+        listeners.add(listener);
 
-      const notify = Effect.gen(function* () {
-        const previous = changed;
+        return () => {
+          listeners.delete(listener);
+        };
+      };
 
-        changed = yield* Deferred.make<void>();
+      const notify = Effect.sync(() => {
         revision++;
-        yield* Deferred.succeed(previous, undefined);
+        const pending = [...listeners];
+
+        listeners.clear();
+        for (const listener of pending) listener();
       });
 
       const minimumAlarmDelay = Math.max(1, Math.ceil(config.alarmBackoffBase / 2));
@@ -1182,8 +1216,13 @@ export class ThreadMutationGate extends Context.Service<
         recordProgress,
         activeLanes: Effect.sync(() => new Set(activeLanes.keys())),
         revision: Effect.sync(() => revision),
+        observeChange,
         awaitChange: (observed) =>
-          Effect.suspend(() => (observed === revision ? Deferred.await(changed) : Effect.void)),
+          Effect.callback((resume) => {
+            const remove = observeChange(observed, () => resume(Effect.void));
+
+            return Effect.sync(remove);
+          }),
         withSnapshot: (body) =>
           generationGate.withPermit(Effect.flatMap(Ref.get(activeMutations), body)),
       });
@@ -1259,6 +1298,7 @@ export class ThreadMaintenance extends Context.Service<
       const runtime = yield* DurableAgentRuntime;
       const recoveryConfig = yield* DurableRuntimeConfig;
       const ledger = yield* SubmissionLedger;
+      const listNonterminal = ledger.listNonterminal ?? Stream.runCollect(ledger.scanNonterminal);
       const wakes = yield* WakeScheduler;
       const hints = yield* DurableAlarmService;
       const alarms = yield* ThreadMaintenanceAlarm;
@@ -1280,6 +1320,8 @@ export class ThreadMaintenance extends Context.Service<
       const messages = yield* ThreadMessageDelivery;
       const host = yield* ThreadHostMaintenance;
       const framework = yield* ThreadNativeMaintenance;
+      const placement = yield* Effect.serviceOption(ThreadObjectPlacement);
+      const nativeThread = Option.isSome(placement) ? placement.value.threadId : undefined;
 
       const nativeDispatchConcurrency = () => (framework.singleThreadRuntime === runtime ? 1 : 2);
 
@@ -1564,9 +1606,7 @@ export class ThreadMaintenance extends Context.Service<
         const now = yield* Clock.currentTimeMillis;
 
         // Fault-only discovery uses control state even when retained payloads cannot decode.
-        const submissions =
-          current ??
-          (result.blocked.length === 0 ? [] : yield* Stream.runCollect(ledger.scanNonterminal));
+        const submissions = current ?? (result.blocked.length === 0 ? [] : yield* listNonterminal);
 
         yield* failpoint.hit("maintenance:recovery-status:before");
 
@@ -1681,7 +1721,11 @@ export class ThreadMaintenance extends Context.Service<
 
         do {
           const result = yield* runtime
-            .runRecovery({ threadId, ...(cursor === undefined ? {} : { cursor }) })
+            .runRecovery({
+              threadId,
+              deferUnclaimedAdmissions: true,
+              ...(cursor === undefined ? {} : { cursor }),
+            })
             .pipe(Effect.provideService(CurrentNativeSource, true));
 
           // Persist each bounded pass before a claim; eviction resumes past consumed metadata.
@@ -2124,19 +2168,31 @@ export class ThreadMaintenance extends Context.Service<
 
             return {
               scannedGeneration: state.dirty,
-              afterWorkThread: state.lastRecoveredThreadId,
+              // Single-Thread placement would immediately wrap past its own cursor.
+              afterWorkThread:
+                framework.singleThreadRuntime === runtime &&
+                state.lastRecoveredThreadId === nativeThread
+                  ? undefined
+                  : state.lastRecoveredThreadId,
             };
           },
         );
 
-        const current = yield* Stream.runCollect(ledger.scanNonterminal);
-
-        let workOwners = yield* runtime
-          .discoverWorkThreads({
-            limit: 32,
-            ...(afterWorkThread === undefined ? {} : { afterThreadId: afterWorkThread }),
-          })
-          .pipe(Effect.provideService(CurrentNativeSource, true));
+        const current = yield* listNonterminal;
+
+        // A current admission proves this native placement is materialized. Empty Objects
+        // still discover retained canonical obligations without inventing a recovery owner.
+        let workOwners =
+          framework.singleThreadRuntime === runtime &&
+          nativeThread !== undefined &&
+          current.some((submission) => submission.threadId === nativeThread)
+            ? { threadIds: [nativeThread], afterThreadId: undefined }
+            : yield* runtime
+                .discoverWorkThreads({
+                  limit: 32,
+                  ...(afterWorkThread === undefined ? {} : { afterThreadId: afterWorkThread }),
+                })
+                .pipe(Effect.provideService(CurrentNativeSource, true));
 
         if (workOwners.threadIds.length === 0 && afterWorkThread !== undefined)
           workOwners = yield* runtime
@@ -2398,7 +2454,7 @@ export class ThreadMaintenance extends Context.Service<
           };
         }
 
-        const remaining = yield* Stream.runCollect(ledger.scanNonterminal);
+        const remaining = yield* listNonterminal;
         const waitingHeads = new Map<ThreadId, boolean>();
 
         // Selected recovery must finish before its generation can be acknowledged: terminal
@@ -2565,12 +2621,22 @@ export class ThreadMaintenance extends Context.Service<
         dispatchUntil: DateTime.Utc,
         observed: MaintenanceObservation,
       ) {
+        const leanSelection =
+          framework.singleThreadRuntime === runtime &&
+          publication === emptyPublication &&
+          host.lanes.length === 0 &&
+          framework.lanes.length === 0;
+
         // Subscribe before the first snapshot. Durable enrollment recovers eviction;
         // producer completion and wake hints make work visible during this incarnation.
-        const notified = (yield* Stream.toPull(wakes.wakes)).pipe(
-          Effect.asVoid,
-          Effect.catch(() => Effect.never),
-        );
+        // Native source mutations already notify the revision waiter below. A replacement
+        // or shared runtime keeps the generic wake stream; hints confer no authority.
+        const notified = leanSelection
+          ? Effect.never
+          : (yield* Stream.toPull(wakes.wakes)).pipe(
+              Effect.asVoid,
+              Effect.catch(() => Effect.never),
+            );
 
         // A wake may observe temporary backoff while this event's recovery is still running.
         // Its completion must retain the original actionable observation for acknowledgement.
@@ -2622,56 +2688,8 @@ export class ThreadMaintenance extends Context.Service<
           discoveryPending: false,
         };
 
-        const recoveryFiber = yield* fork(
-          Effect.gen(function* () {
-            for (const threadId of yield* Deferred.await(recovery.queue)) {
-              yield* failpoint.hit("maintenance:select:before");
-              yield* runTransaction("select old recovery lane", () =>
-                dueQueue.transaction(async (transaction) => {
-                  const { state } = await readMaintenanceState(transaction);
-
-                  await transaction.put(
-                    MAINTENANCE_STATE_KEY,
-                    encodeMaintenanceState(
-                      ThreadMaintenanceState.make({
-                        ...state,
-                        lastRecoveredThreadId: threadId,
-                      }),
-                    ),
-                  );
-                }),
-              );
-              yield* failpoint.hit("maintenance:select:after");
-              yield* recoverThread(threadId, recovery);
-              recovery.pending.delete(threadId);
-              if (!recovery.faults.has(threadId)) yield* wakes.notify(threadId);
-            }
-          }),
-        );
-
-        // Backfill is one disposable wave; native and host work keep their own opportunities.
-        const backfill = yield* fork(
-          Effect.gen(function* () {
-            if ((yield* mutations.activeLanes).has(DueQueue.Projection)) return;
-            const row = (yield* queueSnapshot).find((row) => row.id === DueQueue.Projection);
-
-            if (
-              row?.dueAt === null ||
-              row === undefined ||
-              row.dueAt > (yield* Clock.currentTimeMillis)
-            )
-              return;
-
-            return yield* runQueued(
-              row,
-              projection.drain.pipe(Effect.andThen(projection.pendingDeadline)),
-              observed,
-            ).pipe(Effect.timeoutOption(config.projectionDispatchTimeoutMillis));
-          }),
-        );
-
-        let backfillObserved = false;
-        let recoveryObserved = false;
+        let recoveryFiber: Fiber.Fiber<void, MaintenancePassFailure> | undefined;
+        let backfill: Fiber.Fiber<void, DurableAlarmError | ThreadProjectionError> | undefined;
 
         const dispatch: NativeDispatch = {
           scope: auxiliaryScope,
@@ -2683,18 +2701,79 @@ export class ThreadMaintenance extends Context.Service<
           needsCheckpoint: false,
         };
 
-        let native: Fiber.Fiber<NativePassResult, MaintenancePassFailure> | undefined = yield* fork(
-          advance(started, yieldAfter, observed, recovery, dispatch),
-        );
+        // Selection is bounded local work, not an independently owned wave. It opens
+        // actual Attempt scopes, then returns; empty lanes create no fibers.
+        let native: Fiber.Fiber<NativePassResult, MaintenancePassFailure> | undefined;
+        let result: NativePassResult;
+        let backlog: ReadonlyArray<ThreadId> | undefined;
 
-        let result: NativePassResult = {
-          phase: "caught-up",
-          nonterminal: started.nonterminal,
-          nextAttemptAt: undefined,
-        };
+        if (leanSelection) {
+          result = yield* advance(started, yieldAfter, observed, recovery, dispatch);
+          recovery.started = true;
+          yield* Deferred.succeed(recovery.queue, []);
+          backlog = yield* Deferred.await(recovery.queue);
+        } else {
+          // Required publication and arbitrary host lanes keep independent opportunities
+          // while selection is suspended in an application callback.
+          native = yield* fork(advance(started, yieldAfter, observed, recovery, dispatch));
+          result = {
+            phase: "caught-up",
+            nonterminal: started.nonterminal,
+            nextAttemptAt: undefined,
+          };
+        }
+
+        if (backlog === undefined || backlog.length > 0) {
+          recoveryFiber = yield* fork(
+            Effect.gen(function* () {
+              for (const threadId of backlog ?? (yield* Deferred.await(recovery.queue))) {
+                yield* failpoint.hit("maintenance:select:before");
+                yield* runTransaction("select old recovery lane", () =>
+                  dueQueue.transaction(async (transaction) => {
+                    const { state } = await readMaintenanceState(transaction);
+
+                    await transaction.put(
+                      MAINTENANCE_STATE_KEY,
+                      encodeMaintenanceState(
+                        ThreadMaintenanceState.make({
+                          ...state,
+                          lastRecoveredThreadId: threadId,
+                        }),
+                      ),
+                    );
+                  }),
+                );
+                yield* failpoint.hit("maintenance:select:after");
+                yield* recoverThread(threadId, recovery);
+                recovery.pending.delete(threadId);
+                if (!recovery.faults.has(threadId)) yield* wakes.notify(threadId);
+              }
+            }),
+          );
+        }
+        const projectionRow = (yield* queueSnapshot).find((row) => row.id === DueQueue.Projection);
+
+        if (
+          projectionRow !== undefined &&
+          projectionRow.dueAt !== null &&
+          projectionRow.dueAt <= (yield* Clock.currentTimeMillis) &&
+          !(yield* mutations.activeLanes).has(DueQueue.Projection)
+        ) {
+          backfill = yield* fork(
+            runQueued(
+              projectionRow,
+              projection.drain.pipe(Effect.andThen(projection.pendingDeadline)),
+              observed,
+            ).pipe(Effect.timeoutOption(config.projectionDispatchTimeoutMillis), Effect.asVoid),
+          );
+        }
 
         let phase = result.phase;
-        let nativeCheck = false;
+
+        let nativeCheck =
+          result.dispatched === true && dispatch.active.size < nativeDispatchConcurrency();
+
+        observed.nativeOnly = dispatch.active.size > 0;
         const until = DateTime.toEpochMillis(yieldAfter);
         const dispatchEnd = DateTime.toEpochMillis(dispatchUntil);
 
@@ -2725,19 +2804,17 @@ export class ThreadMaintenance extends Context.Service<
             if (exit.value === 0) dispatch.deferred.add(threadId);
             nativeCheck = true;
           }
-          if (!recoveryObserved && recoveryFiber.pollUnsafe() !== undefined) {
+          if (recoveryFiber?.pollUnsafe() !== undefined) {
             yield* Fiber.join(recoveryFiber);
-            recoveryObserved = true;
+            recoveryFiber = undefined;
             dispatch.scanGeneration = undefined;
             nativeCheck ||= recovery.needsCheckpoint;
           }
-          if (!backfillObserved) {
-            const exit = backfill.pollUnsafe();
+          const backfillExit = backfill?.pollUnsafe();
 
-            if (exit !== undefined) {
-              backfillObserved = true;
-              if (Exit.isFailure(exit)) failure ??= exit.cause;
-            }
+          if (backfillExit !== undefined) {
+            backfill = undefined;
+            if (Exit.isFailure(backfillExit)) failure ??= backfillExit.cause;
           }
           for (const lane of lanes) {
             const exit = lane.fiber?.pollUnsafe();
@@ -2844,9 +2921,9 @@ export class ThreadMaintenance extends Context.Service<
           if (
             native === undefined &&
             dispatch.active.size === 0 &&
-            recoveryObserved &&
+            recoveryFiber === undefined &&
             !recovery.needsCheckpoint &&
-            backfillObserved &&
+            backfill === undefined &&
             delivery === undefined &&
             lanes.every((lane) => lane.fiber === undefined)
           )
@@ -2859,7 +2936,9 @@ export class ThreadMaintenance extends Context.Service<
           ) {
             nativeCheck = false;
             const nativeCheckpoint = dispatch.needsCheckpoint && dispatch.active.size === 0;
-            const checkpoint = (recoveryObserved && recovery.needsCheckpoint) || nativeCheckpoint;
+
+            const checkpoint =
+              (recoveryFiber === undefined && recovery.needsCheckpoint) || nativeCheckpoint;
 
             if (checkpoint) recovery.needsCheckpoint = false;
             // Keep this opportunity's reservations across beginNative's storage awaits.
@@ -2894,26 +2973,39 @@ export class ThreadMaintenance extends Context.Service<
           );
 
           const completing = [
-            ...(native === undefined ? [] : [native]),
+            native,
             ...dispatch.active.values(),
-            ...(recoveryObserved ? [] : [recoveryFiber]),
-            ...(backfillObserved ? [] : [backfill]),
-            ...(delivery === undefined ? [] : [delivery]),
-            ...lanes.flatMap((lane) => (lane.fiber === undefined ? [] : [lane.fiber])),
-          ];
-
-          const ready = yield* Effect.raceAllFirst([
-            ...completing.map((fiber) =>
-              Fiber.await<unknown, MaintenancePassFailure>(fiber).pipe(
-                Effect.as("completed" as const),
-              ),
-            ),
-            Effect.raceAllFirst([
-              notified,
-              mutations.awaitChange(queueRevision),
-              Effect.sleep(Math.max(0, next - now)),
-            ]).pipe(Effect.as("scan" as const)),
-          ]);
+            recoveryFiber,
+            backfill,
+            delivery,
+            ...lanes.map((lane) => lane.fiber),
+          ].filter((fiber) => fiber !== undefined);
+
+          const changed = awaitAnyCompletion(completing, queueRevision);
+
+          // An occupied native-only slot cannot admit another Attempt. With no auxiliary
+          // wake before yield, the timer would only switch to joining that same Attempt.
+          // Incoming work still wakes this callback; all new waves recheck the deadline.
+          const joiningNative =
+            leanSelection &&
+            native === undefined &&
+            dispatch.active.size === 1 &&
+            completing.length === 1 &&
+            !queued.some(
+              (row) =>
+                row.id !== DueQueue.Native &&
+                row.dueAt !== null &&
+                row.dueAt > now &&
+                row.dueAt < until,
+            );
+
+          const ready = yield* joiningNative
+            ? changed
+            : Effect.raceAllFirst([
+                changed,
+                ...(leanSelection ? [] : [notified.pipe(Effect.as("scan" as const))]),
+                Effect.sleep(Math.max(0, next - now)).pipe(Effect.as("scan" as const)),
+              ]);
 
           if (ready === "scan") {
             nativeCheck = true;
@@ -2939,9 +3031,10 @@ export class ThreadMaintenance extends Context.Service<
         for (const fiber of [
           recoveryFiber,
           backfill,
-          ...(delivery === undefined ? [] : [delivery]),
-          ...lanes.flatMap((lane) => (lane.fiber === undefined ? [] : [lane.fiber])),
+          delivery,
+          ...lanes.map((lane) => lane.fiber),
         ]) {
+          if (fiber === undefined) continue;
           // Await exits without failing fast: every admitted wave owns its original
           // bounded allowance and cleanup even if another wave has already failed.
           const exit = yield* Fiber.await<unknown, MaintenancePassFailure>(fiber);
@@ -2964,7 +3057,9 @@ export class ThreadMaintenance extends Context.Service<
         observed: MaintenanceObservation,
       ): Effect.fn.Return<MaintenancePassReport, MaintenancePassFailure, Scope.Scope> {
         const concurrent = yield* Effect.exit(
-          Effect.scoped(dispatch(yieldAfter, dispatchUntil, observed)),
+          Effect.scoped(dispatch(yieldAfter, dispatchUntil, observed)).pipe(
+            Effect.provideService(ThreadMutationGate, mutations),
+          ),
         );
 
         // Closing the concurrent scope first releases every native Attempt and its resources.

package/src/CloudflareThreadClient.ts

@@ -386,13 +386,14 @@ const liveTextProtocolFailure = () =>
     message: "Provisional text is incomplete or invalid; discard drafts and read canonical records",
   });
 
+const decodeLiveTextFrame = Schema.decodeUnknownSync(Schema.fromJsonString(LiveTextFrame));
+
 const decodeLiveText = (
   threadId: ThreadId,
   source: ReadableStream<unknown>,
 ): Stream.Stream<LiveTextFrame, HostProtocolError | ThreadClientError> =>
   Stream.suspend(() => {
     const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
-    const decode = Schema.decodeUnknownSync(Schema.fromJsonString(LiveTextFrame));
     let pending = "";
     let pendingBytes = 0;
     let expected = 0;
@@ -488,7 +489,7 @@ const decodeLiveText = (
             if (newline < 0) break;
 
             const frame = yield* Effect.try({
-              try: () => decode(pending),
+              try: () => decodeLiveTextFrame(pending),
               catch: liveTextProtocolFailure,
             });
 

package/src/ThreadObject.ts

@@ -351,16 +351,17 @@ const gateAdmissionLimits = Effect.fnUntraced(function* (
     );
   }
 
-  const nonterminal = yield* ledger.scanNonterminal.pipe(
-    Stream.filter((submission) => submission.threadId === threadId),
-    Stream.runCollect,
+  const queueDepth = yield* Stream.runFold(
+    ledger.scanNonterminal,
+    () => 0,
+    (depth, submission) => depth + (submission.threadId === threadId ? 1 : 0),
   );
 
-  if (nonterminal.length >= config.limits.maxQueueDepthPerLane) {
+  if (queueDepth >= config.limits.maxQueueDepthPerLane) {
     return yield* refuseFresh(
       AdmissionLimitExceeded.make({
         limit: "queue-depth",
-        actual: nonterminal.length,
+        actual: queueDepth,
         maximum: config.limits.maxQueueDepthPerLane,
       }),
     );
@@ -1186,31 +1187,25 @@ const effectCfPlatformLayer = (
   DurableObjectContext | ThreadObjectNamespace,
   CloudflareBindingError,
   EffectCfDurableObjectState.DurableObjectState | WorkerEnvironment
-> => {
-  const context = Layer.effect(DurableObjectContext)(
+> =>
+  Layer.effectContext(
     Effect.gen(function* () {
       const state = yield* EffectCfDurableObjectState.DurableObjectState;
       const env = yield* WorkerEnvironment;
-
-      return DurableObjectContext.of({ ctx: state.raw, env });
-    }),
-  );
-
-  const namespace = Layer.effect(ThreadObjectNamespace)(
-    Effect.gen(function* () {
-      const env = yield* WorkerEnvironment;
       const binding = yield* threadNamespaceFromEnv(env, namespaceBinding);
 
-      return ThreadObjectNamespace.of({
-        get: (threadId) => binding.get(binding.idFromName(threadId)),
-        ...(rpcTracing === true ? { rpcTracing: namespaceBinding } : {}),
-      });
+      return Context.make(DurableObjectContext, { ctx: state.raw, env }).pipe(
+        Context.add(
+          ThreadObjectNamespace,
+          ThreadObjectNamespace.of({
+            get: (threadId) => binding.get(binding.idFromName(threadId)),
+            ...(rpcTracing === true ? { rpcTracing: namespaceBinding } : {}),
+          }),
+        ),
+      );
     }),
   );
 
-  return Layer.merge(context, namespace);
-};
-
 /** The public endpoints and effect-cf invocation hook of one Thread Object instance. */
 export interface Instance<EventServices = never> extends InstanceType<
   EffectCfDurableObject.DurableObjectClass<