@dudousxd/nestjs-durable-core 0.75.2 → 0.76.1

package/dist/index.cjs

@@ -3867,6 +3867,12 @@ var WorkflowEngine = class {
   * {@link redriveSettledSteps}).
   */
   awaitedRemoteSteps = /* @__PURE__ */ new Map();
+  /**
+  * When THIS instance settled a remote step from its result, by `runId:seq`. That result's resume
+  * runs here, and `execute` lets it into a lease this instance holds, so its wake is never the
+  * dropped one {@link redriveSettledSteps} recovers. Pruned by age (see {@link noteSettledHere}).
+  */
+  settledHere = /* @__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. */
@@ -4341,7 +4347,18 @@ var WorkflowEngine = class {
       createdAt: now,
       updatedAt: now
     };
-    await this.store.createRun(run);
+    try {
+      await this.store.createRun(run);
+    } catch (err) {
+      const winner = await this.store.getRun(runId).catch(() => null);
+      if (!winner) throw err;
+      return {
+        runId,
+        status: winner.status,
+        output: winner.output,
+        error: winner.error
+      };
+    }
     await this.runDispatcher.dispatch(runId);
     if (this.controlPlane) {
       void this.controlPlane.publishControl({
@@ -5283,6 +5300,16 @@ var WorkflowEngine = class {
     for (const seq of seqs) {
       const cp = await this.store.getCheckpoint(runId, seq);
       if (cp && (cp.status === "completed" || cp.status === "failed")) {
+        if (this.settledHere.has(`${runId}:${seq}`)) return;
+        const nowMs = this.clock();
+        if (!await this.store.tryLockRun(runId, this.instanceId, nowMs + this.leaseMs, nowMs)) {
+          return;
+        }
+        const run = await this.store.getRun(runId);
+        if (run?.status !== "suspended") {
+          await this.store.releaseRunLock(runId);
+          return;
+        }
         await this.resumeImplicit(runId);
         return;
       }
@@ -7254,10 +7281,12 @@ var WorkflowEngine = class {
       if (this.remoteRedispatchMs == null) throw new WorkflowSuspended();
       if (existing.wakeAt == null) {
         const wakeAt = this.clock() + this.remoteRedispatchMs;
-        await this.store.saveCheckpoint({
+        if (!await this.savePendingCheckpoint({
           ...existing,
           wakeAt
-        });
+        })) {
+          return this.callRemote(runId, seq, step, input, queue, transport, void 0, admission, routing);
+        }
         throw new WorkflowSuspended(wakeAt);
       }
       if (this.clock() < existing.wakeAt) throw new WorkflowSuspended(existing.wakeAt);
@@ -7270,7 +7299,7 @@ var WorkflowEngine = class {
       const reAttempt = existing.attempts + 1;
       const nextDeadline = this.clock() + this.remoteRedispatchMs;
       const reEnqueuedAt = /* @__PURE__ */ new Date();
-      await this.store.saveCheckpoint({
+      const claimed = await this.savePendingCheckpoint({
         ...existing,
         attempts: reAttempt,
         wakeAt: nextDeadline,
@@ -7284,6 +7313,9 @@ var WorkflowEngine = class {
           lostStepEvent(this.clock(), reAttempt, "redispatched")
         ]
       });
+      if (!claimed) {
+        return this.callRemote(runId, seq, step, input, queue, transport, void 0, admission, routing);
+      }
       await this.dispatchRemoteTask({
         runId,
         seq,
@@ -7374,6 +7406,21 @@ var WorkflowEngine = class {
     this.awaitedRemoteSteps.get(runId)?.add(seq);
     throw new WorkflowSuspended();
   }
+  /** Remember a step settled here, forgetting entries older than a lease so the map stays small. */
+  noteSettledHere(key) {
+    const now = this.clock();
+    this.settledHere.set(key, now);
+    if (this.settledHere.size < 1024) return;
+    for (const [k, at] of this.settledHere) {
+      if (now - at > this.leaseMs) this.settledHere.delete(k);
+    }
+  }
+  /** {@link StateStore.saveCheckpointIfPending}, or a plain save on a store without it. */
+  async savePendingCheckpoint(checkpoint) {
+    if (this.store.saveCheckpointIfPending) return this.store.saveCheckpointIfPending(checkpoint);
+    await this.store.saveCheckpoint(checkpoint);
+    return true;
+  }
   /** Enqueue a remote step task to its worker group via the transport pool. Shared by the initial
   *  dispatch, the opt-in self-heal re-dispatch (see `remoteRedispatchMs`), and the explicit
   *  {@link redispatchPending}. Carries the current trace/context so a re-dispatch is traceable. */
@@ -7404,7 +7451,7 @@ var WorkflowEngine = class {
     if (run && (run.status === "cancelled" || run.status === "completed")) return;
     const finishedAt = /* @__PURE__ */ new Date();
     const startedAt = result.startedAt ? new Date(result.startedAt) : cp.startedAt;
-    await this.store.saveCheckpoint({
+    const claimed = await this.savePendingCheckpoint({
       ...cp,
       status: result.status,
       output: result.status === "completed" ? result.output : cp.output,
@@ -7413,6 +7460,8 @@ var WorkflowEngine = class {
       startedAt,
       finishedAt
     });
+    if (!claimed) return;
+    this.noteSettledHere(`${result.runId}:${result.seq}`);
     this.emit({
       type: result.status === "completed" ? "step.completed" : "step.failed",
       runId: result.runId,
@@ -7805,6 +7854,9 @@ var CodecStateStore = class {
   /** Forwarded verbatim (deletes touch no payload). Bound only when the inner store has it, so the
   *  engine's per-run fallback still kicks in through the wrapper. */
   deleteRuns;
+  /** Encodes like {@link saveCheckpoint}. Bound only when the inner store has it, so the engine's
+  *  plain-save fallback still kicks in through the wrapper. */
+  saveCheckpointIfPending;
   /** Forwarded verbatim — retention selects by status/updatedAt/scope, never by payload. Bound only
   *  when the inner store prunes, so the retention poller still sees (and warns about) its absence. */
   pruneTerminalRuns;
@@ -7832,6 +7884,8 @@ var CodecStateStore = class {
     if (inner.tryAdmitSingleton) this.tryAdmitSingleton = inner.tryAdmitSingleton.bind(inner);
     const deleteRuns = inner.deleteRuns;
     if (deleteRuns) this.deleteRuns = (ids) => deleteRuns.call(inner, ids);
+    const saveIfPending = inner.saveCheckpointIfPending;
+    if (saveIfPending) this.saveCheckpointIfPending = (cp) => saveIfPending.call(inner, this.encCp(cp));
     const prune = inner.pruneTerminalRuns;
     if (prune) this.pruneTerminalRuns = (policy, now, limit) => prune.call(inner, policy, now, limit);
     const count = inner.countRuns;
@@ -8395,6 +8449,14 @@ var InMemoryStateStore = class {
       ...checkpoint
     });
   }
+  async saveCheckpointIfPending(checkpoint) {
+    const key = this.key(checkpoint.runId, checkpoint.seq);
+    if (this.checkpoints.get(key)?.status !== "pending") return false;
+    this.checkpoints.set(key, {
+      ...checkpoint
+    });
+    return true;
+  }
   async listIncompleteRuns(namespace) {
     return [
       ...this.runs.values()