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

package/dist/runtime/step-single-flight.js

@@ -1,3 +1,4 @@
+import { globalSingleton } from '@workflow/utils';
 import { runtimeLogger } from '../logger.js';
 /**
  * In-process single-flight for step body execution, keyed by
@@ -8,7 +9,7 @@ import { runtimeLogger } from '../logger.js';
  * *death proof* only on platforms with a bounded invocation lifetime. On
  * worlds without an invocation kill bound (world-local's single process,
  * self-hosted deployments) a delayed backstop can fire while the owning
- * execution is still mid-body — in the same process. This map absorbs that
+ * execution is still mid-body, in the same process. This map absorbs that
  * race: the loser awaits the winner's settlement and then acks WITHOUT
  * executing. On Vercel Fluid compute it also absorbs same-instance races
  * between an owner redelivery and a backstop.
@@ -17,32 +18,37 @@ import { runtimeLogger } from '../logger.js';
  * after an early ack would consume the loser's queue message while the
  * winner's outcome is still unknown, potentially orphaning the step with no
  * message left to drive it. Awaiting settlement first keeps the at-least-once
- * envelope intact — if the loser's own invocation hits its deadline while
+ * envelope intact: if the loser's own invocation hits its deadline while
  * waiting, its message redelivers and re-checks, degrading gracefully to
  * polling.
  *
  * Cross-instance duplicates (two separate processes racing the same step)
- * are out of scope here — that is what the ownership lease bounds on
+ * are out of scope here; that is what the ownership lease bounds on
  * platforms where it is a death proof, and the documented residual risk on
  * multi-instance self-hosted worlds (mitigate by raising
  * `WORKFLOW_INLINE_OWNERSHIP_LEASE_SECONDS`).
  */
-const inFlightSteps = new Map();
+// On `globalThis` (see `globalSingleton`), not module scope: a per-copy map is
+// not single-flight. Two invocations reaching this module through different
+// bundler layers would each believe they were the only one in the process and
+// both run the step body, degrading in-process dedup to the cross-process
+// residual the doc above scopes out.
+const singleFlight = globalSingleton('@workflow/core//stepSingleFlight', 1, () => ({ inFlight: new Map() }));
 /**
  * Run `execute` unless an execution for the same run + step correlation ID is
  * already in flight in this process. The winner's result is returned to the
  * winner; a loser awaits the winner's settlement (success OR failure) and
  * then returns `{ type: 'skipped' }` so its caller acks without running the
- * body. A winner failure is not propagated to the loser — the winner's own
+ * body. A winner failure is not propagated to the loser: the winner's own
  * queue message redelivers and drives the retry, so exactly one message
  * keeps owning the outcome.
  */
 export async function runStepSingleFlight(runId, correlationId, execute) {
     const key = `${runId}:${correlationId}`;
-    const existing = inFlightSteps.get(key);
+    const existing = singleFlight.inFlight.get(key);
     if (existing) {
         // warn (always printed, unlike debug/info): the single-flight is
-        // absorbing what would have been a duplicate execution — typically a
+        // absorbing what would have been a duplicate execution, typically a
         // delayed backstop or retry message landing in the same process while
         // the owner is still mid-body. Rare by design; a burst of these means
         // leases are expiring under live executions (raise
@@ -53,17 +59,17 @@ export async function runStepSingleFlight(runId, correlationId, execute) {
         }
         catch {
             // The winner failed (typically a transient world error). Its own queue
-            // message redelivers and retries; this loser still just skips.
+            // message redelivers and retries; this loser still skips.
         }
         return { type: 'skipped' };
     }
     const promise = execute();
-    inFlightSteps.set(key, promise);
+    singleFlight.inFlight.set(key, promise);
     try {
         return await promise;
     }
     finally {
-        inFlightSteps.delete(key);
+        singleFlight.inFlight.delete(key);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,6 +3,7 @@ import { type SerializedData, type TraceCarrier, type ValidQueueName, type Workf
 import type { StepInvocationQueueItem, WorkflowSuspension } from '../global.js';
 import { type LoadedEventLog } from './helpers.js';
 import { ReplayRecoveryReporter } from './replay-recovery-reporter.js';
+import type { PreclaimedInlineStart } from './step-executor.js';
 export interface SuspensionHandlerParams {
     suspension: WorkflowSuspension;
     world: World;
@@ -12,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
@@ -34,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. */
@@ -52,6 +53,31 @@ export interface SuspensionHandlerParams {
          */
         getTraceCarrier: () => Promise<TraceCarrier>;
     };
+    /**
+     * 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
+     * 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
+     * {@link SuspensionHandlerResult.inlineClaims}. Callers that never
+     * inline-execute (terminal drain) omit it, keeping their lazy steps on the
+     * plain deferred path.
+     */
+    ownerMessageId?: string;
+    /**
+     * 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
+     * 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
+     * trailing chunk. Callers that don't opt in (terminal drain, default)
+     * keep the everything-durable-at-return behavior.
+     */
+    allowDeferredBatchWork?: boolean;
 }
 /**
  * Result of handling a suspension. Returns pending step items so the caller
@@ -64,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.
@@ -104,6 +142,60 @@ export interface SuspensionHandlerResult {
         stepName: string;
         dehydratedInput: SerializedData;
     }>;
+    /**
+     * 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
+     * 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,
+     * 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).
+     *
+     * 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.
+     */
+    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
+     * 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
+     * position and discards.
+     *
+     * So the echo is only fully suppressed for a SINGLE-chunk fold. On a
+     * multi-chunk fan-out the bodies start off the pair chunk while trailing
+     * 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, and recorded so a report seen there
+     * reads as expected rather than as a bug.
+     */
+    batchCommittedSlotCeiling?: number;
+    /**
+     * The batched fan-out's deferred work, present only when the caller opted
+     * in via {@link SuspensionHandlerParams.allowDeferredBatchWork} and
+     * 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
+     * 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.
+     */
+    deferredBatchWork?: Promise<void>;
     /**
      * The soonest pending wait, if any: seconds until it elapses and the
      * correlationId of the wait that produced that timeout. The
@@ -146,12 +238,12 @@ 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:
  * 1. Hooks are processed first to prevent race conditions with webhook receivers
  * 2. Step events and wait events are created in parallel
  */
-export declare function handleSuspension({ suspension, world, run, span, requestId, eventLog, runReadyBarrier, replayRecoveryReporter, stepDispatch, }: SuspensionHandlerParams): Promise<SuspensionHandlerResult>;
+export declare function handleSuspension({ suspension, world, run, span, requestId, eventLog, runReadyBarrier, replayRecoveryReporter, stepDispatch, ownerMessageId, allowDeferredBatchWork, }: SuspensionHandlerParams): Promise<SuspensionHandlerResult>;
 //# sourceMappingURL=suspension-handler.d.ts.map

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":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAS/C,OAAO,EAKL,KAAK,cAAc,EAInB,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;AAWtB,OAAO,EAGL,KAAK,cAAc,EAIpB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAEvE,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;CACH;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;;;;;;;;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;;;;;;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,GACb,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CA6uB5D"}
+{"version":3,"file":"suspension-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"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"}