@dudousxd/nestjs-durable-core 0.28.2 → 0.29.1

package/dist/index.d.cts

@@ -472,8 +472,9 @@ type WorkflowCommand =
 interface WorkflowDecision {
     taskId: string;
     runId: string;
-    /** `continue` = produced `commands` and is blocked on an await; otherwise the run settles. */
-    status: 'continue' | 'completed' | 'failed';
+    /** `continue` = produced `commands` and is blocked on an await; otherwise the run settles.
+     *  `cancelled` = the worker bailed at an op boundary because the run was cancelled mid-turn. */
+    status: 'continue' | 'completed' | 'failed' | 'cancelled';
     /** New durable ops the replay produced this turn (status === 'continue'), ordered by seq. */
     commands: WorkflowCommand[];
     /** Final workflow output (status === 'completed'). */
@@ -1231,6 +1232,8 @@ declare class WorkflowEngine {
     private readonly trackStepStart;
     /** Where a freshly-started run executes — in-process by default (see {@link RunDispatcher}). */
     private readonly runDispatcher;
+    /** Per-key serialization for singleton workflows (admission, back-pressure, notify-on-release). */
+    private readonly singletons;
     /** Every registered workflow, keyed by `name@version` — so old versions stay runnable. */
     private readonly workflows;
     /** The newest registered version per workflow name — used to `start` new runs. */
@@ -1551,21 +1554,6 @@ declare class WorkflowEngine {
     private completeStep;
     /** Checkpoint a step that failed terminally, so the failure point is visible (not just the run). */
     private failStep;
-    /**
-     * Whether `run` may run now under its singleton key: it's among the `limit` oldest in-flight runs
-     * (running or suspended) sharing the key, by `(createdAt, id)` order. A consistent store gives every
-     * instance the same ordering, so admission is race-free + FIFO.
-     */
-    private admitSingleton;
-    /**
-     * Notify-on-release: a singleton run just settled (freeing a slot), so wake the gated waiters that
-     * can now be admitted — immediately, instead of letting them sleep until their ~1s retry timer.
-     * Dispatches up to `limit` of the oldest gated (`suspended` + same singleton tag) waiters by
-     * `(createdAt, id)`; each re-checks admission in `runExecution` and runs only if it actually wins a
-     * slot, so this never breaks the FIFO + race-free guarantees (the durable timer remains the
-     * cross-instance / crash fallback — this just removes the poll latency on the happy path).
-     */
-    private wakeNextSingletons;
     private execute;
     /**
      * Advance a remote (cross-SDK) workflow one turn: hand its history to the executor (which dispatches
@@ -1573,6 +1561,14 @@ declare class WorkflowEngine {
      * {@link runExecution}'s settle/suspend; the lease is held by {@link execute}. The result that lands
      * us back here (a remote step finished, a timer fired) goes through `resume` like any TS workflow.
      */
+    /**
+     * Apply a terminal/suspended transition once: persist the new run status, emit the matching
+     * lifecycle event, and (on completion/failure) wake a waiting parent. Both the TS and remote
+     * executors funnel their completed/failed/suspended outcomes through here so a status update can
+     * never drift from its event or `notifyParent` call. Does NOT touch the run lock — each executor
+     * keeps its own lease handling (the TS executor's `finally`, the remote path's caller).
+     */
+    private settleRun;
     private runRemoteExecution;
     /** The run's resolved durable ops as replay inputs: completed/failed steps + elapsed timers. */
     private remoteHistory;

package/dist/index.d.ts

@@ -472,8 +472,9 @@ type WorkflowCommand =
 interface WorkflowDecision {
     taskId: string;
     runId: string;
-    /** `continue` = produced `commands` and is blocked on an await; otherwise the run settles. */
-    status: 'continue' | 'completed' | 'failed';
+    /** `continue` = produced `commands` and is blocked on an await; otherwise the run settles.
+     *  `cancelled` = the worker bailed at an op boundary because the run was cancelled mid-turn. */
+    status: 'continue' | 'completed' | 'failed' | 'cancelled';
     /** New durable ops the replay produced this turn (status === 'continue'), ordered by seq. */
     commands: WorkflowCommand[];
     /** Final workflow output (status === 'completed'). */
@@ -1231,6 +1232,8 @@ declare class WorkflowEngine {
     private readonly trackStepStart;
     /** Where a freshly-started run executes — in-process by default (see {@link RunDispatcher}). */
     private readonly runDispatcher;
+    /** Per-key serialization for singleton workflows (admission, back-pressure, notify-on-release). */
+    private readonly singletons;
     /** Every registered workflow, keyed by `name@version` — so old versions stay runnable. */
     private readonly workflows;
     /** The newest registered version per workflow name — used to `start` new runs. */
@@ -1551,21 +1554,6 @@ declare class WorkflowEngine {
     private completeStep;
     /** Checkpoint a step that failed terminally, so the failure point is visible (not just the run). */
     private failStep;
-    /**
-     * Whether `run` may run now under its singleton key: it's among the `limit` oldest in-flight runs
-     * (running or suspended) sharing the key, by `(createdAt, id)` order. A consistent store gives every
-     * instance the same ordering, so admission is race-free + FIFO.
-     */
-    private admitSingleton;
-    /**
-     * Notify-on-release: a singleton run just settled (freeing a slot), so wake the gated waiters that
-     * can now be admitted — immediately, instead of letting them sleep until their ~1s retry timer.
-     * Dispatches up to `limit` of the oldest gated (`suspended` + same singleton tag) waiters by
-     * `(createdAt, id)`; each re-checks admission in `runExecution` and runs only if it actually wins a
-     * slot, so this never breaks the FIFO + race-free guarantees (the durable timer remains the
-     * cross-instance / crash fallback — this just removes the poll latency on the happy path).
-     */
-    private wakeNextSingletons;
     private execute;
     /**
      * Advance a remote (cross-SDK) workflow one turn: hand its history to the executor (which dispatches
@@ -1573,6 +1561,14 @@ declare class WorkflowEngine {
      * {@link runExecution}'s settle/suspend; the lease is held by {@link execute}. The result that lands
      * us back here (a remote step finished, a timer fired) goes through `resume` like any TS workflow.
      */
+    /**
+     * Apply a terminal/suspended transition once: persist the new run status, emit the matching
+     * lifecycle event, and (on completion/failure) wake a waiting parent. Both the TS and remote
+     * executors funnel their completed/failed/suspended outcomes through here so a status update can
+     * never drift from its event or `notifyParent` call. Does NOT touch the run lock — each executor
+     * keeps its own lease handling (the TS executor's `finally`, the remote path's caller).
+     */
+    private settleRun;
     private runRemoteExecution;
     /** The run's resolved durable ops as replay inputs: completed/failed steps + elapsed timers. */
     private remoteHistory;