@dudousxd/nestjs-durable-core 0.69.0 → 0.69.1

package/dist/index.cjs

@@ -4030,6 +4030,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 [];
@@ -4037,8 +4046,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;
   }