@dudousxd/nestjs-durable-core 0.70.1 → 0.70.2

package/dist/index.d.cts

@@ -4004,6 +4004,24 @@ declare class WorkflowEngine {
      * — the caller has already ensured this is the decision for the currently-awaited turn.
      */
     private applyDecision;
+    /**
+     * Re-drive a run whose turn was computed from a history OLDER than the store's.
+     *
+     * A turn replays against a SNAPSHOT, and an op can settle while its decision is in flight. The
+     * canonical case is a remote `gather_calls` fan-out whose last call lands during the decision's
+     * lease window: `completeRemoteResult` -> `resume` -> `execute` finds the lease held and returns
+     * silently, so that call's wake is spent with nothing to show for it, and the decision then parks
+     * the run on a `call` that is already complete. Nothing would ever wake it again — only the
+     * `reconcileMs` orphan sweep, minutes later.
+     *
+     * The tell is precise: the turn (re)declared a blocking op whose checkpoint is already settled. A
+     * turn with an up-to-date history never does that, because a settled op is in its history and the
+     * replay skips it. That also makes this convergent — the re-driven turn sees the op resolved and
+     * cannot re-declare it, so one lost wake costs exactly one extra turn, never a loop.
+     *
+     * Scheduled off the current stack so it runs after the caller released the run lease.
+     */
+    private redriveIfTurnSawStaleHistory;
     /** The run's resolved durable ops as replay inputs: completed/failed steps + elapsed timers. */
     private remoteHistory;
     /** Apply a turn's commands: persist recorded local steps, dispatch remote calls, schedule timers.

package/dist/index.d.ts

@@ -4004,6 +4004,24 @@ declare class WorkflowEngine {
      * — the caller has already ensured this is the decision for the currently-awaited turn.
      */
     private applyDecision;
+    /**
+     * Re-drive a run whose turn was computed from a history OLDER than the store's.
+     *
+     * A turn replays against a SNAPSHOT, and an op can settle while its decision is in flight. The
+     * canonical case is a remote `gather_calls` fan-out whose last call lands during the decision's
+     * lease window: `completeRemoteResult` -> `resume` -> `execute` finds the lease held and returns
+     * silently, so that call's wake is spent with nothing to show for it, and the decision then parks
+     * the run on a `call` that is already complete. Nothing would ever wake it again — only the
+     * `reconcileMs` orphan sweep, minutes later.
+     *
+     * The tell is precise: the turn (re)declared a blocking op whose checkpoint is already settled. A
+     * turn with an up-to-date history never does that, because a settled op is in its history and the
+     * replay skips it. That also makes this convergent — the re-driven turn sees the op resolved and
+     * cannot re-declare it, so one lost wake costs exactly one extra turn, never a loop.
+     *
+     * Scheduled off the current stack so it runs after the caller released the run lease.
+     */
+    private redriveIfTurnSawStaleHistory;
     /** The run's resolved durable ops as replay inputs: completed/failed steps + elapsed timers. */
     private remoteHistory;
     /** Apply a turn's commands: persist recorded local steps, dispatch remote calls, schedule timers.

package/dist/index.js

@@ -4836,10 +4836,42 @@ var WorkflowEngine = class {
       };
     }
     const wakeAt = await this.applyCommands(run, decision.commands);
-    return this.settleRun(run, {
+    const suspended = await this.settleRun(run, {
       kind: "suspended",
       wakeAt
     });
+    await this.redriveIfTurnSawStaleHistory(run.id, decision.commands);
+    return suspended;
+  }
+  /**
+  * Re-drive a run whose turn was computed from a history OLDER than the store's.
+  *
+  * A turn replays against a SNAPSHOT, and an op can settle while its decision is in flight. The
+  * canonical case is a remote `gather_calls` fan-out whose last call lands during the decision's
+  * lease window: `completeRemoteResult` -> `resume` -> `execute` finds the lease held and returns
+  * silently, so that call's wake is spent with nothing to show for it, and the decision then parks
+  * the run on a `call` that is already complete. Nothing would ever wake it again — only the
+  * `reconcileMs` orphan sweep, minutes later.
+  *
+  * The tell is precise: the turn (re)declared a blocking op whose checkpoint is already settled. A
+  * turn with an up-to-date history never does that, because a settled op is in its history and the
+  * replay skips it. That also makes this convergent — the re-driven turn sees the op resolved and
+  * cannot re-declare it, so one lost wake costs exactly one extra turn, never a loop.
+  *
+  * Scheduled off the current stack so it runs after the caller released the run lease.
+  */
+  async redriveIfTurnSawStaleHistory(runId, commands) {
+    const blocking = commands.filter((cmd) => cmd.kind === "call" || cmd.kind === "startChild" || cmd.kind === "waitSignal");
+    if (blocking.length === 0) return;
+    for (const cmd of blocking) {
+      const checkpoint = await this.store.getCheckpoint(runId, cmd.seq);
+      if (checkpoint && checkpoint.status !== "pending") {
+        setTimeout(() => {
+          void this.resume(runId).catch(() => void 0);
+        }, 0).unref?.();
+        return;
+      }
+    }
   }
   /** The run's resolved durable ops as replay inputs: completed/failed steps + elapsed timers. */
   async remoteHistory(runId) {