@dudousxd/nestjs-durable-core 0.75.0 → 0.75.2

package/dist/index.d.cts

@@ -3790,6 +3790,12 @@ declare class WorkflowEngine {
     private readonly updateValidators;
     /** Runs being cancelled WITH saga compensation — see `cancel({ compensate: true })`. */
     private readonly cancelRequested;
+    /**
+     * Seqs of the dispatched remote steps a turn suspended on, by run, while that turn executes on
+     * THIS instance — so the turn can re-check them once its lease is released (see
+     * {@link redriveSettledSteps}).
+     */
+    private readonly awaitedRemoteSteps;
     /** Flow-control admission backend for remote steps (see {@link registerQueue}). */
     private readonly admission;
     /** Runs on THIS instance blocked on admission, by queue — woken early on a freed-slot signal. */
@@ -3801,6 +3807,8 @@ declare class WorkflowEngine {
     private draining;
     /** Wait already spent on this shutdown before `drain()` (see `beginDrain`). */
     private drainSpentMs;
+    /** Re-arms the deadline of every `drain()` currently waiting, when more wait is reported. */
+    private readonly drainRearms;
     constructor(deps: WorkflowEngineDeps);
     /**
      * Register a **durable entity** (a virtual object): a keyed actor whose `handlers` run **serialized
@@ -4298,6 +4306,16 @@ declare class WorkflowEngine {
      * itself. Only re-drives for a group with no waiter left whose checkpoints are all settled, which
      * the next turn is then guaranteed to see — so it cannot loop.
      */
+    /**
+     * Re-drive a run that just suspended on dispatched remote steps which, by now, have a result.
+     *
+     * Same race as {@link redriveSettledChildren}, for `ctx.step`: a result landing while the turn
+     * that dispatched it still holds the lease has its wake dropped by {@link execute}, and the turn
+     * then suspends with nothing left to wake it before the step's redispatch deadline. Called after
+     * the lease is released, so any later result wakes the run itself; it only re-drives for a
+     * checkpoint that is already settled, which the next turn replays past — so it cannot loop.
+     */
+    private redriveSettledSteps;
     private redriveSettledChildren;
     /**
      * Deliver an external signal to the run waiting on `token`, resume it with `payload`, and return

package/dist/index.d.ts

@@ -3790,6 +3790,12 @@ declare class WorkflowEngine {
     private readonly updateValidators;
     /** Runs being cancelled WITH saga compensation — see `cancel({ compensate: true })`. */
     private readonly cancelRequested;
+    /**
+     * Seqs of the dispatched remote steps a turn suspended on, by run, while that turn executes on
+     * THIS instance — so the turn can re-check them once its lease is released (see
+     * {@link redriveSettledSteps}).
+     */
+    private readonly awaitedRemoteSteps;
     /** Flow-control admission backend for remote steps (see {@link registerQueue}). */
     private readonly admission;
     /** Runs on THIS instance blocked on admission, by queue — woken early on a freed-slot signal. */
@@ -3801,6 +3807,8 @@ declare class WorkflowEngine {
     private draining;
     /** Wait already spent on this shutdown before `drain()` (see `beginDrain`). */
     private drainSpentMs;
+    /** Re-arms the deadline of every `drain()` currently waiting, when more wait is reported. */
+    private readonly drainRearms;
     constructor(deps: WorkflowEngineDeps);
     /**
      * Register a **durable entity** (a virtual object): a keyed actor whose `handlers` run **serialized
@@ -4298,6 +4306,16 @@ declare class WorkflowEngine {
      * itself. Only re-drives for a group with no waiter left whose checkpoints are all settled, which
      * the next turn is then guaranteed to see — so it cannot loop.
      */
+    /**
+     * Re-drive a run that just suspended on dispatched remote steps which, by now, have a result.
+     *
+     * Same race as {@link redriveSettledChildren}, for `ctx.step`: a result landing while the turn
+     * that dispatched it still holds the lease has its wake dropped by {@link execute}, and the turn
+     * then suspends with nothing left to wake it before the step's redispatch deadline. Called after
+     * the lease is released, so any later result wakes the run itself; it only re-drives for a
+     * checkpoint that is already settled, which the next turn replays past — so it cannot loop.
+     */
+    private redriveSettledSteps;
     private redriveSettledChildren;
     /**
      * Deliver an external signal to the run waiting on `token`, resume it with `payload`, and return

package/dist/index.js

@@ -3698,6 +3698,12 @@ var WorkflowEngine = class {
   updateValidators = /* @__PURE__ */ new Map();
   /** Runs being cancelled WITH saga compensation — see `cancel({ compensate: true })`. */
   cancelRequested = /* @__PURE__ */ new Set();
+  /**
+  * Seqs of the dispatched remote steps a turn suspended on, by run, while that turn executes on
+  * THIS instance — so the turn can re-check them once its lease is released (see
+  * {@link redriveSettledSteps}).
+  */
+  awaitedRemoteSteps = /* @__PURE__ */ new Map();
   /** Flow-control admission backend for remote steps (see {@link registerQueue}). */
   admission;
   /** Runs on THIS instance blocked on admission, by queue — woken early on a freed-slot signal. */
@@ -3709,6 +3715,8 @@ var WorkflowEngine = class {
   draining = false;
   /** Wait already spent on this shutdown before `drain()` (see `beginDrain`). */
   drainSpentMs = 0;
+  /** Re-arms the deadline of every `drain()` currently waiting, when more wait is reported. */
+  drainRearms = /* @__PURE__ */ new Set();
   constructor(deps) {
     this.store = deps.store;
     this.pool = new TransportPool(deps.transports ?? (deps.transport ? [
@@ -4394,7 +4402,10 @@ var WorkflowEngine = class {
   */
   beginDrain(spentMs = 0) {
     this.draining = true;
-    this.drainSpentMs += Math.max(0, spentMs);
+    if (Number.isFinite(spentMs) && spentMs > 0) {
+      this.drainSpentMs += spentMs;
+      for (const rearm of this.drainRearms) rearm();
+    }
   }
   /**
   * Graceful shutdown: stop picking up new runs (recovery/timer become no-ops) and wait for
@@ -4407,18 +4418,32 @@ var WorkflowEngine = class {
   */
   async drain(timeoutMs = 1e4) {
     this.beginDrain();
-    const budget = Math.max(0, timeoutMs - this.drainSpentMs);
     if (this.inflight.size === 0) return;
+    const start = Date.now();
+    let rearm = /* @__PURE__ */ __name(() => {
+    }, "rearm");
+    let timeout;
     const timer = new Promise((resolve) => {
-      const t = setTimeout(resolve, budget);
-      t.unref?.();
+      rearm = /* @__PURE__ */ __name(() => {
+        clearTimeout(timeout);
+        const remaining = Math.max(0, start + timeoutMs - this.drainSpentMs - Date.now());
+        timeout = setTimeout(resolve, remaining);
+        timeout.unref?.();
+      }, "rearm");
+      rearm();
     });
-    await Promise.race([
-      Promise.allSettled([
-        ...this.inflight
-      ]),
-      timer
-    ]);
+    this.drainRearms.add(rearm);
+    try {
+      await Promise.race([
+        Promise.allSettled([
+          ...this.inflight
+        ]),
+        timer
+      ]);
+    } finally {
+      this.drainRearms.delete(rearm);
+      clearTimeout(timeout);
+    }
   }
   /**
   * Cancel in-flight runs that have outlived their workflow's `executionTimeout`. Call it from the
@@ -5082,6 +5107,24 @@ var WorkflowEngine = class {
   * itself. Only re-drives for a group with no waiter left whose checkpoints are all settled, which
   * the next turn is then guaranteed to see — so it cannot loop.
   */
+  /**
+  * Re-drive a run that just suspended on dispatched remote steps which, by now, have a result.
+  *
+  * Same race as {@link redriveSettledChildren}, for `ctx.step`: a result landing while the turn
+  * that dispatched it still holds the lease has its wake dropped by {@link execute}, and the turn
+  * then suspends with nothing left to wake it before the step's redispatch deadline. Called after
+  * the lease is released, so any later result wakes the run itself; it only re-drives for a
+  * checkpoint that is already settled, which the next turn replays past — so it cannot loop.
+  */
+  async redriveSettledSteps(runId, seqs) {
+    for (const seq of seqs) {
+      const cp = await this.store.getCheckpoint(runId, seq);
+      if (cp && (cp.status === "completed" || cp.status === "failed")) {
+        await this.resumeImplicit(runId);
+        return;
+      }
+    }
+  }
   async redriveSettledChildren(runId, fan) {
     if (!this.store.hasSignalWaiter) return;
     for (const wait of fan.waits) {
@@ -6536,6 +6579,9 @@ var WorkflowEngine = class {
     const replay = /* @__PURE__ */ new Map();
     for (const cp of snapshot) replay.set(cp.seq, cp);
     let suspendedOnFan;
+    let suspendedOnSteps = false;
+    const awaitedSteps = /* @__PURE__ */ new Set();
+    this.awaitedRemoteSteps.set(run.id, awaitedSteps);
     const ctx = createWorkflowCtx(this.ctxHostFor(replay, run.namespace), run.id, compensations, run.workflow, registered?.searchAttributesSchema);
     try {
       const output = await runInWorkflowCtx(ctx, () => fn(ctx, run.input));
@@ -6592,6 +6638,7 @@ var WorkflowEngine = class {
           wakeAt: err.wakeAt
         });
         suspendedOnFan = err.fan;
+        suspendedOnSteps = suspended.status === "suspended";
         return suspended;
       }
       if (this.cancelRequested.has(run.id)) {
@@ -6611,10 +6658,16 @@ var WorkflowEngine = class {
         error: error2
       });
     } finally {
+      if (this.awaitedRemoteSteps.get(run.id) === awaitedSteps) {
+        this.awaitedRemoteSteps.delete(run.id);
+      }
       await this.store.releaseRunLock(run.id);
       if (suspendedOnFan) {
         void this.redriveSettledChildren(run.id, suspendedOnFan).catch(() => void 0);
       }
+      if (suspendedOnSteps && awaitedSteps.size > 0) {
+        void this.redriveSettledSteps(run.id, awaitedSteps).catch(() => void 0);
+      }
     }
   }
   /**
@@ -7034,6 +7087,7 @@ var WorkflowEngine = class {
     if (this.pool.size === 0) throw new Error("remote steps require a Transport");
     if (step.timeoutMs) return this.callRemoteInMemory(runId, seq, step, input, transport, group);
     if (existing?.status === "pending") {
+      this.awaitedRemoteSteps.get(runId)?.add(seq);
       if (this.remoteRedispatchMs == null) throw new WorkflowSuspended();
       if (existing.wakeAt == null) {
         const wakeAt = this.clock() + this.remoteRedispatchMs;
@@ -7154,6 +7208,7 @@ var WorkflowEngine = class {
       name: step.name,
       kind: "remote"
     });
+    this.awaitedRemoteSteps.get(runId)?.add(seq);
     throw new WorkflowSuspended();
   }
   /** Enqueue a remote step task to its worker group via the transport pool. Shared by the initial