@dudousxd/nestjs-durable-core 0.85.1 → 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
@@ -7102,7 +7118,11 @@ declare function scheduleRunIdAt(s: ScheduledWorkflow, nowMs: number): string;
  * Start each schedule's current-window run. The run id is the time bucket (a fixed-interval index,
  * or the cron fire time) and `engine.start` is idempotent, so firing this on an interval — or
  * racing two instances on the same tick — starts **each window exactly once**. Wire it to a
- * `setInterval`, the durable timer poller, or `@nestjs/schedule`. Returns the run ids this call
+ * `setInterval`, the durable timer poller, or `@nestjs/schedule`.
+ *
+ * Pass the SAME `engine` object on every call: which windows already fired, and the jittered fire
+ * time of each deferred window, are remembered per engine object. A fresh wrapper per call would
+ * redraw a deferred window's fire time on every tick, so it might never fire. Returns the run ids this call
  * started: a window that already has a run is not started or returned again, and once this process
  * has seen a window's run exist, later calls in that window skip it without a store read. A
  * jittered window is deferred to a later call, never slept on.

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
@@ -7102,7 +7118,11 @@ declare function scheduleRunIdAt(s: ScheduledWorkflow, nowMs: number): string;
  * Start each schedule's current-window run. The run id is the time bucket (a fixed-interval index,
  * or the cron fire time) and `engine.start` is idempotent, so firing this on an interval — or
  * racing two instances on the same tick — starts **each window exactly once**. Wire it to a
- * `setInterval`, the durable timer poller, or `@nestjs/schedule`. Returns the run ids this call
+ * `setInterval`, the durable timer poller, or `@nestjs/schedule`.
+ *
+ * Pass the SAME `engine` object on every call: which windows already fired, and the jittered fire
+ * time of each deferred window, are remembered per engine object. A fresh wrapper per call would
+ * redraw a deferred window's fire time on every tick, so it might never fire. Returns the run ids this call
  * started: a window that already has a run is not started or returned again, and once this process
  * has seen a window's run exist, later calls in that window skip it without a store read. A
  * jittered window is deferred to a later call, never slept on.

package/dist/index.js

@@ -2532,6 +2532,7 @@ async function runSchedules(engine, schedules, nowMs, opts) {
         if (prev && (prev.status === "running" || prev.status === "suspended")) continue;
       }
     }
+    if (!(s.jitter && s.jitter > 0)) jitterFireAt.get(engine)?.delete(s.key);
     const firing = s.jitter && s.jitter > 0 ? jitterDue(engine, s, candidates, nowMs, random) : candidates;
     if (firing.length === 0) continue;
     for (const runId of firing) {
@@ -3823,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,
@@ -3833,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}`,
@@ -4451,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) {
@@ -7637,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,
@@ -7650,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