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

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

@@ -1,6 +1,7 @@
 import type { Span } from '@opentelemetry/api';
 import { type SerializedData, type TraceCarrier, type ValidQueueName, type WorkflowRun, type World } from '@workflow/world';
 import type { StepInvocationQueueItem, WorkflowSuspension } from '../global.js';
+import { type GuestCodeExecution } from '../serialization/hardened.js';
 import { type LoadedEventLog } from './helpers.js';
 import { ReplayRecoveryReporter } from './replay-recovery-reporter.js';
 import type { PreclaimedInlineStart } from './step-executor.js';
@@ -13,7 +14,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 +36,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 +58,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 +70,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 +91,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 +147,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 +160,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 +181,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 +191,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.
@@ -216,17 +229,18 @@ export interface SuspensionHandlerResult {
      * durably creating the user's hooks doesn't count as runtime overhead.
      */
     hookCreationMs: number;
-    /**
-     * Whether serializing this suspension's new step inputs was passive (did
-     * not execute workflow-owned code such as getters, proxy traps, or custom
-     * serializers). `false` means the retained VM may have diverged from what
-     * a cold replay would compute, so the caller must demote to replay.
-     */
-    retainedStepInputsSafe: boolean;
+    /** Exact number of workflow-code executions observed during serialization. */
+    serializationBlockerCount: number;
+    /** Bounded sample used only for retention diagnostics. */
+    serializationBlockers: SuspensionSerializationBlocker[];
+}
+export interface SuspensionSerializationBlocker extends GuestCodeExecution {
+    source: 'step_input' | 'hook_metadata' | 'hook_abort';
+    correlationId: string;
 }
 /**
  * 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":"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"}