@adonis-agora/durable 0.55.1 → 0.56.1

package/dist/src/engine.js

@@ -116,6 +116,12 @@ const isTerminalRun = (status) => TERMINAL_RUN_STATUSES.includes(status);
 const COMPENSATION_SEQ_BASE = -2;
 /** How many checkpoint writes / dispatches a step fan sends at once. */
 const STEP_FAN_CHUNK = 200;
+/**
+ * Most steps of a fan one write-then-dispatch round of {@link WorkflowEngine.sendStepFan} carries.
+ * Workers start on a round's steps while the next round's checkpoints are written, instead of
+ * waiting for every checkpoint of a wide fan to commit.
+ */
+const STEP_FAN_SEND_ROUND = 2000;
 /** The default {@link WorkflowEngineDeps.timerBatchSize}. */
 const DEFAULT_TIMER_BATCH = 500;
 /** {@link WorkflowEngine.sweepBufferedSignals}: rows read per page. */
@@ -6441,11 +6447,27 @@ export class WorkflowEngine {
             return true;
         return cp.wakeAt != null && this.clock() < cp.wakeAt;
     }
+    /** Write a round of a step fan's checkpoints: one call where the store batches, else chunked. */
+    async saveFanCheckpoints(checkpoints) {
+        if (this.store.saveCheckpoints) {
+            await this.store.saveCheckpoints(checkpoints);
+            return;
+        }
+        for (let at = 0; at < checkpoints.length; at += STEP_FAN_CHUNK) {
+            await Promise.all(checkpoints.slice(at, at + STEP_FAN_CHUNK).map((cp) => this.store.saveCheckpoint(cp)));
+        }
+    }
     /**
-     * Write the `pending` checkpoints of a step fan's new steps, then dispatch them: one
-     * {@link StateStore.saveCheckpoints} call and one {@link TransportPool.dispatchMany} for the batch,
-     * where the store and transport have them. With the lost-dispatch self-heal on, each step is
-     * written with its lease already stamped, and the lease is returned for the run to park on.
+     * Write the `pending` checkpoints of a step fan's new steps and dispatch them, in rounds of
+     * {@link STEP_FAN_SEND_ROUND}: a round's steps are dispatched once its checkpoints commit, while the
+     * next round's are written. One {@link StateStore.saveCheckpoints} call and one
+     * {@link TransportPool.dispatchMany} per round, where the store and transport have them. With the
+     * lost-dispatch self-heal on, each step is written with its lease already stamped, and the lease is
+     * returned for the run to park on.
+     *
+     * No result can wake the run before every round is written: the run is `running` under this
+     * turn's lease until the turn suspends. A send cut short leaves the unwritten steps without a
+     * checkpoint, and the replay sends them once the written ones settle.
      */
     async sendStepFan(runId, positions, step, inputs, batch, group, opts, runNamespace) {
         const token = stepGroup(step, runNamespace);
@@ -6477,28 +6499,34 @@ export class WorkflowEngine {
                 ...(lease !== undefined ? { wakeAt: lease } : {}),
             };
         });
-        if (this.store.saveCheckpoints) {
-            await this.store.saveCheckpoints(checkpoints);
-        }
-        else {
-            for (let at = 0; at < checkpoints.length; at += STEP_FAN_CHUNK) {
-                await Promise.all(checkpoints.slice(at, at + STEP_FAN_CHUNK).map((cp) => this.store.saveCheckpoint(cp)));
-            }
-        }
         const traceparent = this.traceparent?.();
         const context = this.context?.();
-        await this.pool.dispatchMany(checkpoints.map((cp) => ({
-            runId,
-            seq: cp.seq,
-            name: step.name,
-            stepId: cp.stepId,
-            group: token,
-            input: cp.input,
-            traceparent,
-            context,
-            priority: opts.admission?.priority,
-            attempt: 1,
-        })), opts.transport);
+        const dispatches = [];
+        try {
+            for (let from = 0; from < checkpoints.length; from += STEP_FAN_SEND_ROUND) {
+                const round = checkpoints.slice(from, from + STEP_FAN_SEND_ROUND);
+                await this.saveFanCheckpoints(round);
+                const dispatch = this.pool.dispatchMany(round.map((cp) => ({
+                    runId,
+                    seq: cp.seq,
+                    name: step.name,
+                    stepId: cp.stepId,
+                    group: token,
+                    input: cp.input,
+                    traceparent,
+                    context,
+                    priority: opts.admission?.priority,
+                    attempt: 1,
+                })), opts.transport);
+                // Awaited below; a rejection is not left unhandled while the next round is written.
+                dispatch.catch(() => { });
+                dispatches.push(dispatch);
+            }
+        }
+        finally {
+            await Promise.allSettled(dispatches);
+        }
+        await Promise.all(dispatches);
         for (const cp of checkpoints) {
             this.emit({ type: 'step.started', runId, seq: cp.seq, name: step.name, kind: 'remote' });
         }