@dudousxd/nestjs-durable-core 0.40.0 → 0.41.0

package/dist/index.d.cts

@@ -574,6 +574,15 @@ interface SignalWaiter {
     token: string;
     runId: string;
     seq: number;
+    /**
+     * The parallel-fan group this waiter belongs to, carried from the awaiting command so the resolving
+     * `signal:<token>` checkpoint (notably `signal:child:<id>` for an awaited child run) can be tagged
+     * with it. A worker's `ctx.gather_children`/`ctx.all` fan-out stamps every `startChild` with the same
+     * group; without threading it through the waiter, the child-await checkpoint comes out untagged and the
+     * dashboard renders the fan as a sequential chain instead of one parallel group. Undefined for an
+     * ordinary (non-fan) signal/child await.
+     */
+    parallelGroup?: string | undefined;
 }
 /** A unit of work dispatched to a remote worker. This is the documented wire payload. */
 interface RemoteTask {
@@ -674,13 +683,17 @@ interface HistoryEvent {
 }
 /** A decision the workflow function produced at a `seq` that was not yet in history. */
 type WorkflowCommand = 
-/** `ctx.call(remoteStep, input)` — dispatch a remote step and await it. */
+/** `ctx.call(remoteStep, input)` — dispatch a remote step and await it. A worker's
+ *  `ctx.gather_calls([...])` fan-out tags every dispatched call with the same `parallelGroup` so the
+ *  dashboard renders the remote steps as one parallel fan (parity with the gathered `recordStep` /
+ *  `startChild` tags). Undefined for a lone sequential `ctx.call`. */
 {
     kind: 'call';
     seq: number;
     name: string;
     group: string;
     input: unknown;
+    parallelGroup?: string;
 }
 /** `ctx.step(name, body)` — a LOCAL step the worker already ran this turn; the engine persists its
  *  result so replay returns it instead of re-running (durability for side-effectful work).

package/dist/index.d.ts

@@ -574,6 +574,15 @@ interface SignalWaiter {
     token: string;
     runId: string;
     seq: number;
+    /**
+     * The parallel-fan group this waiter belongs to, carried from the awaiting command so the resolving
+     * `signal:<token>` checkpoint (notably `signal:child:<id>` for an awaited child run) can be tagged
+     * with it. A worker's `ctx.gather_children`/`ctx.all` fan-out stamps every `startChild` with the same
+     * group; without threading it through the waiter, the child-await checkpoint comes out untagged and the
+     * dashboard renders the fan as a sequential chain instead of one parallel group. Undefined for an
+     * ordinary (non-fan) signal/child await.
+     */
+    parallelGroup?: string | undefined;
 }
 /** A unit of work dispatched to a remote worker. This is the documented wire payload. */
 interface RemoteTask {
@@ -674,13 +683,17 @@ interface HistoryEvent {
 }
 /** A decision the workflow function produced at a `seq` that was not yet in history. */
 type WorkflowCommand = 
-/** `ctx.call(remoteStep, input)` — dispatch a remote step and await it. */
+/** `ctx.call(remoteStep, input)` — dispatch a remote step and await it. A worker's
+ *  `ctx.gather_calls([...])` fan-out tags every dispatched call with the same `parallelGroup` so the
+ *  dashboard renders the remote steps as one parallel fan (parity with the gathered `recordStep` /
+ *  `startChild` tags). Undefined for a lone sequential `ctx.call`. */
 {
     kind: 'call';
     seq: number;
     name: string;
     group: string;
     input: unknown;
+    parallelGroup?: string;
 }
 /** `ctx.step(name, body)` — a LOCAL step the worker already ran this turn; the engine persists its
  *  result so replay returns it instead of re-running (durability for side-effectful work).

package/dist/index.js

@@ -1208,7 +1208,8 @@ function createWorkflowCtx(host, runId, compensations, workflow = "") {
       await store.putSignalWaiter({
         token: `child:${childId}`,
         runId,
-        seq
+        seq,
+        parallelGroup: group
       });
       if (!await store.getRun(childId)) host.startChild(name, inputs[i], childId);
       if (!cp) {
@@ -2283,7 +2284,12 @@ var WorkflowEngine = class {
       seq: waiter.seq,
       name: `signal:${token}`,
       kind: "signal",
-      output: payload
+      output: payload,
+      // Carry the awaiting command's fan group (set when a `ctx.gather_children`/`ctx.all` fan-out
+      // registered this waiter) onto the resolving `signal:child:<id>` checkpoint, so the dashboard
+      // groups the child fan-out vertically instead of rendering it as a sequential chain. Undefined
+      // for an ordinary (non-fan) signal/child await.
+      parallelGroup: waiter.parallelGroup
     }));
     return this.resume(waiter.runId).catch((err) => {
       if (err instanceof NamespaceMismatch) return null;
@@ -2984,6 +2990,7 @@ var WorkflowEngine = class {
           error: cmd.error
         });
       } else if (cmd.kind === "call") {
+        if (await this.store.getCheckpoint(run.id, cmd.seq)) continue;
         await this.store.saveCheckpoint(stepCheckpoint({
           runId: run.id,
           seq: cmd.seq,
@@ -2995,7 +3002,11 @@ var WorkflowEngine = class {
           workerGroup: cmd.group,
           enqueuedAt: at,
           startedAt: at,
-          finishedAt: at
+          finishedAt: at,
+          // A `ctx.gather_calls([...])` fan-out stamps every dispatched `call` in the fan with the
+          // same group, so the dashboard renders the remote steps as one parallel fan (parity with
+          // the gathered `recordStep`/`startChild` tags). Undefined for a lone sequential `ctx.call`.
+          parallelGroup: cmd.parallelGroup
         }));
         await this.pool.dispatch({
           runId: run.id,
@@ -3053,7 +3064,12 @@ var WorkflowEngine = class {
         await this.store.putSignalWaiter({
           token: `child:${childId}`,
           runId: run.id,
-          seq: cmd.seq
+          seq: cmd.seq,
+          // A `ctx.gather_children`/`ctx.all` fan-out stamps every `startChild` in the fan with the same
+          // group. Thread it onto the waiter so the child's terminal `signal:child:<id>` checkpoint
+          // (written by engine.signal when the child notifies the parent) carries the group and the
+          // dashboard renders the fan as one parallel group. Undefined for a lone (non-fan) child.
+          parallelGroup: cmd.parallelGroup
         });
         if (!await this.store.getRun(childId)) {
           queueMicrotask(() => void this.start(cmd.workflow, cmd.input, childId).catch(() => void 0));