@dudousxd/nestjs-durable-core 0.33.0 → 0.34.0

package/dist/index.cjs

@@ -1502,6 +1502,7 @@ var WorkflowEngine = class {
   instanceId;
   leaseMs;
   maxRecoveryAttempts;
+  remoteAdvanceSilenceMs;
   webhookUrl;
   traceparent;
   context;
@@ -1526,7 +1527,9 @@ var WorkflowEngine = class {
   accumulators;
   /** In-flight remote steps awaiting a worker result, keyed by stepId. */
   pending = /* @__PURE__ */ new Map();
-  /** Per-step "reset the liveness timer" callbacks, called when a heartbeat arrives. */
+  /** "Reset the liveness timer" callbacks keyed by the beat's target — a stepId (in-flight remote step)
+  *  or a runId (in-flight remote workflow turn) — invoked when a matching heartbeat arrives. The two id
+  *  shapes don't collide in practice: a stepId is `${runId}:${seq}`, a run key is the bare runId. */
   heartbeatResets = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
   /** Step interceptors (onion middleware around real local-step execution), first = outermost. */
@@ -1565,6 +1568,7 @@ var WorkflowEngine = class {
     this.instanceId = deps.instanceId ?? globalThis.crypto.randomUUID();
     this.leaseMs = deps.leaseMs ?? 3e4;
     this.maxRecoveryAttempts = deps.maxRecoveryAttempts;
+    this.remoteAdvanceSilenceMs = deps.remoteAdvanceSilenceMs;
     this.webhookUrl = deps.webhookUrl;
     this.traceparent = deps.traceparent;
     this.context = deps.context;
@@ -1601,9 +1605,11 @@ var WorkflowEngine = class {
         }
         await this.completeRemoteResult(result);
       },
-      // A heartbeat for an in-flight long step resets its liveness window (see callRemote).
+      // A heartbeat resets the liveness window for whatever it targets: an in-flight long STEP (keyed
+      // by stepId, see callRemote) or — when stepId is absent — the in-flight workflow TURN (keyed by
+      // runId, see runRemoteExecution's heartbeat-rearmed advance).
       async (beat) => {
-        this.heartbeatResets.get(beat.stepId)?.();
+        this.heartbeatResets.get(beat.stepId ?? beat.runId)?.();
       },
       // A remote workflow worker streams each local step's lifecycle (running → completed/failed) so
       // it's checkpointed live, not all-at-once when the long turn ends.
@@ -2695,7 +2701,9 @@ var WorkflowEngine = class {
     const history = await this.remoteHistory(run.id);
     let decision;
     try {
-      decision = await remote.executor.advance(run, history);
+      const silenceMs = this.remoteAdvanceSilenceMs;
+      const advance = remote.executor.advance(run, history);
+      decision = silenceMs != null ? await this.awaitWithLivenessDeadline(run.id, advance, silenceMs, () => new RemoteWorkflowTimeout(run.id, silenceMs)) : await advance;
     } catch (err) {
       if (err instanceof RemoteWorkflowTimeout) {
         await this.store.releaseRunLock(run.id);
@@ -3356,11 +3364,13 @@ var WorkflowEngine = class {
     }
   }
   /**
-  * Await a remote result, but reject with `RemoteStepTimeout` if neither the result nor a heartbeat
-  * arrives within `timeoutMs`. Each heartbeat (delivered via `transport.onHeartbeat`) rearms the
-  * window, so a worker that keeps beating stays alive past `timeoutMs`.
+  * Await `resultPromise`, but reject with `onTimeout()` if neither it settles nor a heartbeat for `id`
+  * arrives within `timeoutMs`. Each heartbeat (delivered via `transport.onHeartbeat`, looked up in
+  * `heartbeatResets` by `id`) REARMS the window, so a worker that keeps beating stays alive past
+  * `timeoutMs`. Shared by the remote-STEP liveness (keyed by stepId) and the remote-WORKFLOW advance
+  * liveness (keyed by runId); the caller supplies the timeout error and any extra cleanup via `onTimeout`.
   */
-  awaitWithHeartbeat(id, resultPromise, timeoutMs) {
+  awaitWithLivenessDeadline(id, resultPromise, timeoutMs, onTimeout) {
     return new Promise((resolve, reject) => {
       let timer;
       const cleanup = /* @__PURE__ */ __name(() => {
@@ -3370,8 +3380,7 @@ var WorkflowEngine = class {
       const arm = /* @__PURE__ */ __name(() => {
         timer = setTimeout(() => {
           cleanup();
-          this.pending.delete(id);
-          reject(new RemoteStepTimeout(id, timeoutMs));
+          reject(onTimeout());
         }, timeoutMs);
         timer.unref?.();
       }, "arm");
@@ -3389,6 +3398,14 @@ var WorkflowEngine = class {
       });
     });
   }
+  /** Remote-STEP liveness: await a worker result, timing out (with the step's pending-map cleanup) to
+  *  `RemoteStepTimeout` if it neither lands nor beats within `timeoutMs`. See {@link awaitWithLivenessDeadline}. */
+  awaitWithHeartbeat(id, resultPromise, timeoutMs) {
+    return this.awaitWithLivenessDeadline(id, resultPromise, timeoutMs, () => {
+      this.pending.delete(id);
+      return new RemoteStepTimeout(id, timeoutMs);
+    });
+  }
 };
 var RemoteStepError = class extends Error {
   static {
@@ -4154,6 +4171,7 @@ var InMemoryTransport = class {
   }
   handlers = /* @__PURE__ */ new Map();
   resultHandler;
+  heartbeatHandler;
   stepEventHandler;
   controlHandlers = /* @__PURE__ */ new Set();
   /** Register a fake worker handler for a step name. */
@@ -4168,7 +4186,12 @@ var InMemoryTransport = class {
   onResult(handler) {
     this.resultHandler = handler;
   }
-  onHeartbeat(_handler) {
+  onHeartbeat(handler) {
+    this.heartbeatHandler = handler;
+  }
+  /** Test hook: deliver a liveness heartbeat to the engine, as a real broker would on its channel. */
+  async emitHeartbeat(beat) {
+    await this.heartbeatHandler?.(beat);
   }
   /** Workflow step lifecycle: deliver to the engine's handler (async, mirroring a real broker). */
   async dispatchStepEvent(event) {