@dudousxd/nestjs-durable-core 0.69.0 → 0.69.1

package/dist/index.d.cts

@@ -3692,6 +3692,15 @@ declare class WorkflowEngine {
     /**
      * Resume each run only if this instance can acquire its recovery lease — so when several
      * replicas recover or poll at once, each run is picked up by exactly one of them.
+     *
+     * A run this instance cannot resume is SKIPPED, not allowed to abort the batch. The canonical
+     * case is skew protection: mid-rolling-deploy a pod leases a run whose workflow it does not have
+     * and `resume` throws by design — but the rest of the batch is runs it can drive perfectly well,
+     * and every caller here is a recovery sweep. Letting the first such run end the loop means one
+     * row stops recovery for the whole deployment, and (since the callers are pollers) sends the
+     * rejection into a lifecycle hook. Skipping leaves the run locked only until its lease expires,
+     * for a pod that does have the workflow — which is exactly what the skew-protection error asks
+     * for. Same posture as `publishEvent`'s per-subscriber isolation.
      */
     private resumeLeased;
     /**

package/dist/index.d.ts

@@ -3692,6 +3692,15 @@ declare class WorkflowEngine {
     /**
      * Resume each run only if this instance can acquire its recovery lease — so when several
      * replicas recover or poll at once, each run is picked up by exactly one of them.
+     *
+     * A run this instance cannot resume is SKIPPED, not allowed to abort the batch. The canonical
+     * case is skew protection: mid-rolling-deploy a pod leases a run whose workflow it does not have
+     * and `resume` throws by design — but the rest of the batch is runs it can drive perfectly well,
+     * and every caller here is a recovery sweep. Letting the first such run end the loop means one
+     * row stops recovery for the whole deployment, and (since the callers are pollers) sends the
+     * rejection into a lifecycle hook. Skipping leaves the run locked only until its lease expires,
+     * for a pod that does have the workflow — which is exactly what the skew-protection error asks
+     * for. Same posture as `publishEvent`'s per-subscriber isolation.
      */
     private resumeLeased;
     /**

package/dist/index.js

@@ -3889,6 +3889,15 @@ var WorkflowEngine = class {
   /**
   * Resume each run only if this instance can acquire its recovery lease — so when several
   * replicas recover or poll at once, each run is picked up by exactly one of them.
+  *
+  * A run this instance cannot resume is SKIPPED, not allowed to abort the batch. The canonical
+  * case is skew protection: mid-rolling-deploy a pod leases a run whose workflow it does not have
+  * and `resume` throws by design — but the rest of the batch is runs it can drive perfectly well,
+  * and every caller here is a recovery sweep. Letting the first such run end the loop means one
+  * row stops recovery for the whole deployment, and (since the callers are pollers) sends the
+  * rejection into a lifecycle hook. Skipping leaves the run locked only until its lease expires,
+  * for a pod that does have the workflow — which is exactly what the skew-protection error asks
+  * for. Same posture as `publishEvent`'s per-subscriber isolation.
   */
   async resumeLeased(runs, nowMs = this.clock(), onLocked) {
     if (this.draining) return [];
@@ -3896,8 +3905,12 @@ var WorkflowEngine = class {
     for (const run of runs) {
       const acquired = await this.store.tryLockRun(run.id, this.instanceId, nowMs + this.leaseMs, nowMs);
       if (!acquired) continue;
-      const settled = onLocked ? await onLocked(run) : void 0;
-      results.push(settled ?? await this.resume(run.id));
+      try {
+        const settled = onLocked ? await onLocked(run) : void 0;
+        results.push(settled ?? await this.resume(run.id));
+      } catch (error2) {
+        console.error(`[nestjs-durable] could not resume run ${run.id} (${run.workflow}@${run.workflowVersion}); leaving it for another instance:`, error2);
+      }
     }
     return results;
   }