@dudousxd/nestjs-durable-core 0.85.2 → 0.85.3

package/dist/index.d.cts

@@ -5704,6 +5704,22 @@ declare class WorkflowEngine {
     private markStarted;
     private singletonWaitResult;
     private execute;
+    /**
+     * Keep a wake that found `runId`'s lease held by a turn executing elsewhere, durably, so that turn
+     * runs again once it ends instead of suspending on a snapshot that predates what the wake brought
+     * (a signal, a child's completion). The request is a buffered signal on a token no workflow waits
+     * on; the holder takes it after it releases the lease ({@link honorWakeRequests}).
+     *
+     * Written first and looked at second, against a holder that releases first and looks second:
+     * whichever look runs last sees the other side's write. So when the run is no longer executing by
+     * the time this re-reads it, the holder may have looked already, and this side takes the request
+     * and wakes the run itself once the lease is free.
+     */
+    private requestWakeAfterTurn;
+    /** After a turn that suspended released its lease: run again if a wake was kept for it. */
+    private honorWakeRequests;
+    /** Take every wake request kept for `runId`; true when there was one. */
+    private takeWakeRequests;
     /**
      * A wake that found the run leased by another instance is dropped, and normally that is fine: the
      * holder's turn either sees what the wake wrote, or re-checks once it releases the lease

package/dist/index.d.ts

@@ -5704,6 +5704,22 @@ declare class WorkflowEngine {
     private markStarted;
     private singletonWaitResult;
     private execute;
+    /**
+     * Keep a wake that found `runId`'s lease held by a turn executing elsewhere, durably, so that turn
+     * runs again once it ends instead of suspending on a snapshot that predates what the wake brought
+     * (a signal, a child's completion). The request is a buffered signal on a token no workflow waits
+     * on; the holder takes it after it releases the lease ({@link honorWakeRequests}).
+     *
+     * Written first and looked at second, against a holder that releases first and looks second:
+     * whichever look runs last sees the other side's write. So when the run is no longer executing by
+     * the time this re-reads it, the holder may have looked already, and this side takes the request
+     * and wakes the run itself once the lease is free.
+     */
+    private requestWakeAfterTurn;
+    /** After a turn that suspended released its lease: run again if a wake was kept for it. */
+    private honorWakeRequests;
+    /** Take every wake request kept for `runId`; true when there was one. */
+    private takeWakeRequests;
     /**
      * A wake that found the run leased by another instance is dropped, and normally that is fine: the
      * holder's turn either sees what the wake wrote, or re-checks once it releases the lease

package/dist/index.js

@@ -3824,7 +3824,6 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
       }));
       return unwrapCompletion(buffered.payload, `child "${id}"`);
     }
-    if (!await store.getRun(id)) host.startChild(workflowName(workflow2), input, id, priority, version);
     if (!existing) {
       await writeCheckpoint(instantCheckpoint({
         runId,
@@ -3834,6 +3833,7 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
         status: "running"
       }));
     }
+    if (!await store.getRun(id)) host.startChild(workflowName(workflow2), input, id, priority, version);
     throw new WorkflowSuspended(void 0, fanJoin([
       {
         waiterPrefix: `child:${id}`,
@@ -4452,6 +4452,7 @@ function deferred() {
 __name(deferred, "deferred");
 var pendingStateKey = /* @__PURE__ */ __name((at) => String(new Date(at).getTime()), "pendingStateKey");
 var freshPendingKey = /* @__PURE__ */ __name(() => `${Date.now()}-${globalThis.crypto.randomUUID().slice(0, 8)}`, "freshPendingKey");
+var wakeRequestToken = /* @__PURE__ */ __name((runId) => `durable:wake-after-turn:${runId}`, "wakeRequestToken");
 var CHILD_SIGNAL_PREFIX = "signal:child:";
 var DELIVER_CHUNK = 50;
 function childCompletion(child) {
@@ -7638,6 +7639,7 @@ var WorkflowEngine = class {
     const lockNow = this.clock();
     if (run.lockedBy !== this.instanceId || (run.lockedUntil ?? 0) <= lockNow) {
       if (!await this.store.tryLockRun(run.id, this.instanceId, lockNow + this.leaseMs, lockNow)) {
+        if (!this.leaseRetries.has(run.id)) this.inBackground(this.requestWakeAfterTurn(run.id));
         this.recheckAfterLease(run.id, run.lockedUntil);
         return {
           runId: run.id,
@@ -7651,12 +7653,52 @@ var WorkflowEngine = class {
       if (registered?.singleton && (result.status === "completed" || result.status === "failed" || result.status === "cancelled" || result.status === "dead")) {
         void this.singletons.wakeNext(run).catch(() => void 0);
       }
+      if (result.status === "suspended") this.inBackground(this.honorWakeRequests(run.id));
+      else if (TERMINAL_RUN_STATUSES.includes(result.status)) {
+        this.inBackground(this.takeWakeRequests(run.id));
+      }
       return result;
     } finally {
       held.stop();
     }
   }
   /**
+  * Keep a wake that found `runId`'s lease held by a turn executing elsewhere, durably, so that turn
+  * runs again once it ends instead of suspending on a snapshot that predates what the wake brought
+  * (a signal, a child's completion). The request is a buffered signal on a token no workflow waits
+  * on; the holder takes it after it releases the lease ({@link honorWakeRequests}).
+  *
+  * Written first and looked at second, against a holder that releases first and looks second:
+  * whichever look runs last sees the other side's write. So when the run is no longer executing by
+  * the time this re-reads it, the holder may have looked already, and this side takes the request
+  * and wakes the run itself once the lease is free.
+  */
+  async requestWakeAfterTurn(runId) {
+    await this.store.bufferSignal(wakeRequestToken(runId), null);
+    const run = await this.store.getRun(runId);
+    if (run?.status === "running") return;
+    if (!run) {
+      await this.takeWakeRequests(runId);
+      return;
+    }
+    if (!await this.takeWakeRequests(runId)) return;
+    if (TERMINAL_RUN_STATUSES.includes(run.status)) return;
+    this.recheckAfterLease(runId, run.lockedUntil);
+  }
+  /** After a turn that suspended released its lease: run again if a wake was kept for it. */
+  async honorWakeRequests(runId) {
+    if (!await this.takeWakeRequests(runId)) return;
+    await this.wake(runId).catch((err) => {
+      if (!(err instanceof NamespaceMismatch)) throw err;
+    });
+  }
+  /** Take every wake request kept for `runId`; true when there was one. */
+  async takeWakeRequests(runId) {
+    let taken = false;
+    while (await this.store.takeBufferedSignal(wakeRequestToken(runId))) taken = true;
+    return taken;
+  }
+  /**
   * A wake that found the run leased by another instance is dropped, and normally that is fine: the
   * holder's turn either sees what the wake wrote, or re-checks once it releases the lease
   * ({@link redriveSettledSteps}, {@link redriveSettledChildren}). Not if the holder goes down first