@dudousxd/nestjs-durable-core 0.33.0 → 0.34.0

package/dist/index.d.cts

@@ -577,7 +577,13 @@ interface StepResult {
 interface Heartbeat {
     runId: string;
     seq: number;
-    stepId: string;
+    /**
+     * The in-flight step this beat keeps alive. ABSENT for a RUN-scoped (workflow-turn) heartbeat: a
+     * worker replaying a long workflow turn beats for its `runId` so the engine rearms the run's
+     * `advance` deadline (see `WorkflowEngineDeps.remoteAdvanceSilenceMs`). The engine then keys the
+     * liveness reset by `runId` instead of `stepId`.
+     */
+    stepId?: string | undefined;
     group: string;
 }
 /** engine → workflow worker: advance this run one turn by replaying the function against `history`. */
@@ -1291,6 +1297,18 @@ interface WorkflowEngineDeps {
      * Omit for unlimited (the default — recovery always retries).
      */
     maxRecoveryAttempts?: number | undefined;
+    /**
+     * Opt-in liveness deadline (ms) for a remote workflow `advance`. If the worker neither returns a
+     * decision NOR sends a run-scoped {@link Heartbeat} within this window, the engine presumes it dead:
+     * it rejects the advance with {@link RemoteWorkflowTimeout}, releases the lease, and lets recovery
+     * re-drive (replaying completed steps from history). Each beat REARMS the window, so a worker still
+     * legitimately replaying a long turn (it keeps beating) is never re-driven — closing the duplicate-
+     * side-effect hazard a fixed {@link RemoteWorkflowExecutor} `timeoutMs` cannot avoid. Omit (default)
+     * for the prior unbounded await — byte-identical behavior when unset. If a `RemoteWorkflowExecutor` is
+     * ALSO constructed with its own `timeoutMs`, the shorter of the two deadlines wins; prefer setting only
+     * one (this rearmed window for heartbeat-aware workers, or the fixed `timeoutMs` otherwise).
+     */
+    remoteAdvanceSilenceMs?: number | undefined;
     /**
      * Build the public callback URL for a `ctx.webhook()` token (e.g.
      * ``(t) => `https://api.example.com/durable/webhooks/${t}` ``). Populates
@@ -1364,6 +1382,7 @@ declare class WorkflowEngine {
     private readonly instanceId;
     private readonly leaseMs;
     private readonly maxRecoveryAttempts?;
+    private readonly remoteAdvanceSilenceMs?;
     private readonly webhookUrl?;
     private readonly traceparent?;
     private readonly context?;
@@ -1388,7 +1407,9 @@ declare class WorkflowEngine {
     private readonly accumulators;
     /** In-flight remote steps awaiting a worker result, keyed by stepId. */
     private readonly pending;
-    /** 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. */
     private readonly heartbeatResets;
     private readonly listeners;
     /** Step interceptors (onion middleware around real local-step execution), first = outermost. */
@@ -1785,10 +1806,15 @@ declare class WorkflowEngine {
     /** In-memory await path for a remote step with a liveness `timeoutMs` (re-dispatch on timeout). */
     private callRemoteInMemory;
     /**
-     * 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`.
      */
+    private awaitWithLivenessDeadline;
+    /** 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}. */
     private awaitWithHeartbeat;
 }
 /** Raised inside the workflow when a remote worker reports a step failure. */
@@ -2301,13 +2327,16 @@ declare class InMemoryStateStore implements StateStore {
 declare class InMemoryTransport implements Transport, ControlPlane {
     private readonly handlers;
     private resultHandler?;
+    private heartbeatHandler?;
     private stepEventHandler?;
     private readonly controlHandlers;
     /** Register a fake worker handler for a step name. */
     handle(name: string, fn: StepHandler): void;
     dispatch(task: RemoteTask): Promise<void>;
     onResult(handler: (result: StepResult) => Promise<void>): void;
-    onHeartbeat(_handler: (beat: Heartbeat) => Promise<void>): void;
+    onHeartbeat(handler: (beat: Heartbeat) => Promise<void>): void;
+    /** Test hook: deliver a liveness heartbeat to the engine, as a real broker would on its channel. */
+    emitHeartbeat(beat: Heartbeat): Promise<void>;
     /** Workflow step lifecycle: deliver to the engine's handler (async, mirroring a real broker). */
     dispatchStepEvent(event: WorkflowStepEvent): Promise<void>;
     onStepEvent(handler: (event: WorkflowStepEvent) => Promise<void>): void;

package/dist/index.d.ts

@@ -577,7 +577,13 @@ interface StepResult {
 interface Heartbeat {
     runId: string;
     seq: number;
-    stepId: string;
+    /**
+     * The in-flight step this beat keeps alive. ABSENT for a RUN-scoped (workflow-turn) heartbeat: a
+     * worker replaying a long workflow turn beats for its `runId` so the engine rearms the run's
+     * `advance` deadline (see `WorkflowEngineDeps.remoteAdvanceSilenceMs`). The engine then keys the
+     * liveness reset by `runId` instead of `stepId`.
+     */
+    stepId?: string | undefined;
     group: string;
 }
 /** engine → workflow worker: advance this run one turn by replaying the function against `history`. */
@@ -1291,6 +1297,18 @@ interface WorkflowEngineDeps {
      * Omit for unlimited (the default — recovery always retries).
      */
     maxRecoveryAttempts?: number | undefined;
+    /**
+     * Opt-in liveness deadline (ms) for a remote workflow `advance`. If the worker neither returns a
+     * decision NOR sends a run-scoped {@link Heartbeat} within this window, the engine presumes it dead:
+     * it rejects the advance with {@link RemoteWorkflowTimeout}, releases the lease, and lets recovery
+     * re-drive (replaying completed steps from history). Each beat REARMS the window, so a worker still
+     * legitimately replaying a long turn (it keeps beating) is never re-driven — closing the duplicate-
+     * side-effect hazard a fixed {@link RemoteWorkflowExecutor} `timeoutMs` cannot avoid. Omit (default)
+     * for the prior unbounded await — byte-identical behavior when unset. If a `RemoteWorkflowExecutor` is
+     * ALSO constructed with its own `timeoutMs`, the shorter of the two deadlines wins; prefer setting only
+     * one (this rearmed window for heartbeat-aware workers, or the fixed `timeoutMs` otherwise).
+     */
+    remoteAdvanceSilenceMs?: number | undefined;
     /**
      * Build the public callback URL for a `ctx.webhook()` token (e.g.
      * ``(t) => `https://api.example.com/durable/webhooks/${t}` ``). Populates
@@ -1364,6 +1382,7 @@ declare class WorkflowEngine {
     private readonly instanceId;
     private readonly leaseMs;
     private readonly maxRecoveryAttempts?;
+    private readonly remoteAdvanceSilenceMs?;
     private readonly webhookUrl?;
     private readonly traceparent?;
     private readonly context?;
@@ -1388,7 +1407,9 @@ declare class WorkflowEngine {
     private readonly accumulators;
     /** In-flight remote steps awaiting a worker result, keyed by stepId. */
     private readonly pending;
-    /** 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. */
     private readonly heartbeatResets;
     private readonly listeners;
     /** Step interceptors (onion middleware around real local-step execution), first = outermost. */
@@ -1785,10 +1806,15 @@ declare class WorkflowEngine {
     /** In-memory await path for a remote step with a liveness `timeoutMs` (re-dispatch on timeout). */
     private callRemoteInMemory;
     /**
-     * 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`.
      */
+    private awaitWithLivenessDeadline;
+    /** 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}. */
     private awaitWithHeartbeat;
 }
 /** Raised inside the workflow when a remote worker reports a step failure. */
@@ -2301,13 +2327,16 @@ declare class InMemoryStateStore implements StateStore {
 declare class InMemoryTransport implements Transport, ControlPlane {
     private readonly handlers;
     private resultHandler?;
+    private heartbeatHandler?;
     private stepEventHandler?;
     private readonly controlHandlers;
     /** Register a fake worker handler for a step name. */
     handle(name: string, fn: StepHandler): void;
     dispatch(task: RemoteTask): Promise<void>;
     onResult(handler: (result: StepResult) => Promise<void>): void;
-    onHeartbeat(_handler: (beat: Heartbeat) => Promise<void>): void;
+    onHeartbeat(handler: (beat: Heartbeat) => Promise<void>): void;
+    /** Test hook: deliver a liveness heartbeat to the engine, as a real broker would on its channel. */
+    emitHeartbeat(beat: Heartbeat): Promise<void>;
     /** Workflow step lifecycle: deliver to the engine's handler (async, mirroring a real broker). */
     dispatchStepEvent(event: WorkflowStepEvent): Promise<void>;
     onStepEvent(handler: (event: WorkflowStepEvent) => Promise<void>): void;

package/dist/index.js

@@ -1431,6 +1431,7 @@ var WorkflowEngine = class {
   instanceId;
   leaseMs;
   maxRecoveryAttempts;
+  remoteAdvanceSilenceMs;
   webhookUrl;
   traceparent;
   context;
@@ -1455,7 +1456,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. */
@@ -1494,6 +1497,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;
@@ -1530,9 +1534,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.
@@ -2624,7 +2630,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);
@@ -3285,11 +3293,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(() => {
@@ -3299,8 +3309,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");
@@ -3318,6 +3327,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 {
@@ -4083,6 +4100,7 @@ var InMemoryTransport = class {
   }
   handlers = /* @__PURE__ */ new Map();
   resultHandler;
+  heartbeatHandler;
   stepEventHandler;
   controlHandlers = /* @__PURE__ */ new Set();
   /** Register a fake worker handler for a step name. */
@@ -4097,7 +4115,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) {