@workflow/core 5.0.0-beta.43 → 5.0.0-beta.44

package/dist/runtime/suspension-handler.d.ts

@@ -13,7 +13,7 @@ export interface SuspensionHandlerParams {
     /**
      * The runtime's loaded event log. Every event creation this suspension makes
      * names the position it was derived from, so a backend that has recorded
-     * events the replay did not see can report them back on the write — or, if
+     * events the replay did not see can report them back on the write, or, if
      * it would rather refuse than report, reject it with a 412. A rejection is
      * not retried here: the event's correlation id was minted by *this* replay's
      * seeded sequence, so re-committing it against a corrected log would persist
@@ -35,14 +35,14 @@ export interface SuspensionHandlerParams {
     replayRecoveryReporter?: ReplayRecoveryReporter;
     /**
      * Resilient step dispatch: when provided (and the per-step eligibility gates
-     * pass — see the step ops below), each newly created non-inline step's
+     * pass, see the step ops below), each newly created non-inline step's
      * `step_created` write is parallelized with its step-execution queue
      * publish, and the queue message carries the serialized step input
      * (`stepInput`) so the consumer can idempotently re-ensure the event if the
      * direct write failed transiently. Steps queued this way are reported in
      * {@link SuspensionHandlerResult.queuedStepCorrelationIds} so the caller
      * skips them in its own dispatch pass. Omitted by callers that must not
-     * queue (terminal drain, tests) — creates then behave exactly as before.
+     * queue (terminal drain, tests); creates then behave exactly as before.
      */
     stepDispatch?: {
         /** The unified workflow queue this run's step messages are published to. */
@@ -57,9 +57,9 @@ export interface SuspensionHandlerParams {
      * Inline step ownership: the queue message ID of the invocation this
      * suspension runs in (the queue handler's meta). When present AND the
      * batched fan-out engages, the lazy-inline steps' deferred writes are
-     * folded into the batch as `step_created` + `step_started` pairs — the
+     * folded into the batch as `step_created` + `step_started` pairs (the
      * started row stamped with this ID, exactly like the lazy claim it
-     * replaces — pre-claiming the steps the caller is about to run inline. See
+     * replaces), pre-claiming the steps the caller is about to run inline. See
      * {@link SuspensionHandlerResult.inlineClaims}. Callers that never
      * inline-execute (terminal drain) omit it, keeping their lazy steps on the
      * plain deferred path.
@@ -69,8 +69,8 @@ export interface SuspensionHandlerParams {
      * Lets the batched fan-out return before every chunk has committed: only
      * the chunk carrying the pre-claimed inline pairs gates the handler's
      * return (its claims are what the caller starts bodies from), while the
-     * trailing chunks' commits — and every chunk's in-flush step-message
-     * publishes — ride {@link SuspensionHandlerResult.deferredBatchWork}. A
+     * trailing chunks' commits (and every chunk's in-flush step-message
+     * publishes) ride {@link SuspensionHandlerResult.deferredBatchWork}. A
      * caller that opts in MUST await that promise before acking its delivery:
      * the durability contract ("every create durable before ack") moves from
      * the handler's return to that join, and nothing else re-drives a lost
@@ -90,16 +90,28 @@ export interface SuspensionHandlerResult {
      * Correlation IDs for which this suspension call actually wrote the
      * step_created event (as opposed to catching EntityConflictError because
      * a concurrent handler wrote it first). Only the handler that wrote the
-     * step_created event should queue / inline-execute the step — this
+     * step_created event should queue / inline-execute the step; this
      * guarantees a single owner per step, even when multiple handlers race
      * into the same batch boundary.
      */
     createdStepCorrelationIds: Set<string>;
+    /**
+     * Correlation IDs of steps whose arguments failed to serialize. Each was
+     * finalized here as `step_created` (with a placeholder input; the real
+     * input is precisely what refused to serialize) followed by `step_failed`
+     * carrying the SerializationError, so the next replay rejects the step's
+     * promise and a try/catch around the step call observes the error,
+     * exactly like a step-body failure. No step-execution message is
+     * dispatched for these, so the caller MUST force an in-process replay:
+     * when the failed step was the only pending work, nothing else will ever
+     * re-invoke the run to observe the terminal event.
+     */
+    failedStepCorrelationIds: Set<string>;
     /**
      * Correlation IDs of steps this suspension call already published
      * step-execution queue messages for, via resilient step dispatch (the
      * `step_created` write parallelized with a `stepInput`-carrying queue
-     * publish). The caller MUST NOT dispatch these again — the message is
+     * publish). The caller MUST NOT dispatch these again: the message is
      * already out (a duplicate would be deduped by its idempotency key, but
      * costs a wasted round-trip). Empty when {@link SuspensionHandlerParams.stepDispatch}
      * was not provided or no step was eligible.
@@ -134,12 +146,12 @@ export interface SuspensionHandlerResult {
      * Pre-claimed inline starts, by correlation id: the per-step verdicts of
      * the `step_created` + `step_started` pairs the batched fan-out committed
      * for the lazy-inline steps. A step with an entry here is passed to
-     * `executeStep` as `preclaimedStart` INSTEAD of `lazyStepInput` — its
+     * `executeStep` as `preclaimedStart` INSTEAD of `lazyStepInput`: its
      * input already rode the pair, and the claim is settled: `owned: true`
      * carries the started attempt-1 entity (input re-attached) so the body
      * runs straight off the batch commit with no start write of its own;
      * `owned: false` lost the pair's atomic create-claim to a concurrent
-     * writer, and executeStep returns `skipped` without running the body —
+     * writer, and executeStep returns `skipped` without running the body,
      * the same outcome as losing the lazy claim. Empty whenever the fold did
      * not engage (batching off, no `ownerMessageId`, or the lone-inline case,
      * which keeps the optimistic lazy path and its claim/body overlap).
@@ -147,20 +159,20 @@ export interface SuspensionHandlerResult {
      * Crash window: the pair commits before the caller runs the body, so a
      * crash between them leaves a started step stamped with this message's
      * ID. Redelivery of the same message re-executes it via the owned-recovery
-     * path — the exact machinery the lazy claim's crash window already uses.
+     * path, the exact machinery the lazy claim's crash window already uses.
      */
     inlineClaims: Map<string, PreclaimedInlineStart>;
     /**
      * The highest slot the batched fan-out committed, when it ran. The batch's
      * own events are not in the caller's loaded log (the next reload picks
      * them up), so the caller folds this ceiling into the slot snapshot it
-     * hands the inline executions — otherwise every inline terminal write
+     * hands the inline executions; otherwise every inline terminal write
      * would name a pre-batch position and be answered with a skipped-slot
      * report echoing the events this suspension just wrote. Under
      * {@link SuspensionHandlerParams.allowDeferredBatchWork} this covers the
      * chunks that had committed by the handler's return (always the pair
      * chunk); a trailing chunk that commits later is echoed back on the
-     * terminal writes like any foreign event — reports the executor reads for
+     * terminal writes like any foreign event: reports the executor reads for
      * position and discards.
      *
      * So the echo is only fully suppressed for a SINGLE-chunk fold. On a
@@ -168,7 +180,7 @@ export interface SuspensionHandlerResult {
      * chunks are still in flight, and an inline terminal write issued in that
      * window still names a position below them and still draws a report for
      * their events. Bounded (trailing chunks only, large fan-outs only) and
-     * self-correcting on the next reload — recorded so a report seen there
+     * self-correcting on the next reload, and recorded so a report seen there
      * reads as expected rather than as a bug.
      */
     batchCommittedSlotCeiling?: number;
@@ -178,7 +190,7 @@ export interface SuspensionHandlerResult {
      * trailing work exists: the commits of every chunk except the pair chunk,
      * plus every chunk's step-message publishes (each chained on ITS OWN
      * chunk's commit, so publish-after-create holds per step). The caller
-     * MUST await it before acking — a rejection here is a failed suspension
+     * MUST await it before acking: a rejection here is a failed suspension
      * write and fails the delivery exactly as it would have at the handler's
      * return. Steps whose messages this work publishes are already in
      * {@link queuedStepCorrelationIds} at return time.
@@ -226,7 +238,7 @@ export interface SuspensionHandlerResult {
 }
 /**
  * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).
- * Creates events for all operations but does NOT queue step messages — returns the pending
+ * Creates events for all operations but does NOT queue step messages; returns the pending
  * steps so the caller can decide which to execute inline vs queue to background.
  *
  * Processing order:

package/dist/runtime/suspension-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suspension-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"suspension-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAU/C,OAAO,EAKL,KAAK,cAAc,EAMnB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,KAAK,EACX,MAAM,iBAAiB,CAAC;AAGzB,OAAO,KAAK,EAGV,uBAAuB,EAEvB,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAiBtB,OAAO,EAGL,KAAK,cAAc,EAKpB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAGhE,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,WAAW,CAAC;IACjB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,8EAA8E;IAC9E,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD;;;;;;;;;;OAUG;IACH,YAAY,CAAC,EAAE;QACb,4EAA4E;QAC5E,SAAS,EAAE,cAAc,CAAC;QAC1B;;;WAGG;QACH,eAAe,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,CAAC;KAC9C,CAAC;IACF;;;;;;;;;;OAUG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;;;;;;OAWG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,4DAA4D;IAC5D,YAAY,EAAE,uBAAuB,EAAE,CAAC;IACxC;;;;;;;OAOG;IACH,yBAAyB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvC;;;;;;;;;;OAUG;IACH,wBAAwB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtC;;;;;;;;OAQG;IACH,wBAAwB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtC;;;;;OAKG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;;;;;;;;;OAYG;IACH,eAAe,EAAE,KAAK,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,QAAQ,EAAE,MAAM,CAAC;QACjB,eAAe,EAAE,cAAc,CAAC;KACjC,CAAC,CAAC;IACH;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;IACjD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC;;;;;;;;;;OAUG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC;;;;;;OAMG;IACH,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;IACzD,0EAA0E;IAC1E,eAAe,EAAE,OAAO,CAAC;IACzB,wFAAwF;IACxF,sBAAsB,EAAE,OAAO,CAAC;IAChC,wEAAwE;IACxE,kBAAkB,EAAE,OAAO,CAAC;IAC5B;;;;;;OAMG;IACH,aAAa,EAAE,OAAO,CAAC;IACvB;;;;;OAKG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,sBAAsB,EAAE,OAAO,CAAC;CACjC;AA6ED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,EACV,KAAK,EACL,GAAG,EACH,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,eAAe,EACf,sBAAsB,EACtB,YAAY,EACZ,cAAc,EACd,sBAAsB,GACvB,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAq7C5D"}