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

package/dist/runtime/suspension-handler.js

@@ -1,14 +1,16 @@
-import { EntityConflictError, FatalError, HookNotFoundError, PreconditionFailedError, RunExpiredError, WorkflowWorldError, } from '@workflow/errors';
-import { AttributeValidationError, SPEC_VERSION_CURRENT, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_COMPRESSION, } from '@workflow/world';
+import { EntityConflictError, FatalError, HookNotFoundError, PreconditionFailedError, RunExpiredError, SerializationError, WorkflowWorldError, } from '@workflow/errors';
+import { AttributeValidationError, SPEC_VERSION_CURRENT, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_COMPRESSION, SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, } from '@workflow/world';
 import { isRetryableWorldError } from '../classify-error.js';
 import { importKey } from '../encryption.js';
 import { runtimeLogger } from '../logger.js';
-import { dehydrateStepArguments } from '../serialization.js';
+import { dehydrateStepArguments, dehydrateStepError, } from '../serialization.js';
 import * as Attribute from '../telemetry/semantic-conventions.js';
 import { getAbortStreamIdFromToken } from '../util.js';
-import { getMaxInlineSteps, isResilientStepDispatchEnabled, MAX_RESILIENT_STEP_INPUT_BYTES, } from './constants.js';
-import { absorbSkippedSlotReport, queueMessage, slotSnapshotParams, stepDispatchIdempotencyKey, } from './helpers.js';
+import { COMPUTE_INSTANCE_ID } from './compute-instance.js';
+import { getMaxInlineSteps, isBatchTransitionsEnabled, isResilientStepDispatchEnabled, MAX_BATCH_FANOUT_EVENTS, MAX_RESILIENT_STEP_INPUT_BYTES, } from './constants.js';
+import { absorbSkippedSlotReport, maxEventSlot, queueMessage, slotSnapshotParams, stepDispatchIdempotencyKey, } from './helpers.js';
 import { ReplayRecoveryReporter } from './replay-recovery-reporter.js';
+import { unserializableStepInputPlaceholder } from './unserializable-step.js';
 async function createHookEvent({ runId, hookEvent, queueItem, requestId, createEvent, }) {
     try {
         const result = await createEvent(hookEvent, {
@@ -59,14 +61,14 @@ async function createHookEvent({ runId, hookEvent, queueItem, requestId, createE
 }
 /**
  * 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 async function handleSuspension({ suspension, world, run, span, requestId, eventLog, runReadyBarrier, replayRecoveryReporter, stepDispatch, }) {
+export async function handleSuspension({ suspension, world, run, span, requestId, eventLog, runReadyBarrier, replayRecoveryReporter, stepDispatch, ownerMessageId, allowDeferredBatchWork, }) {
     const runId = run.runId;
     // Turbo mode: hold every world write below until the backgrounded
     // `run_started` has *settled*, so we never write a step/hook/wait event for a
@@ -82,7 +84,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                 await runReadyBarrier;
             }
             catch {
-                // intentional: ordering barrier only — see above.
+                // intentional: ordering barrier only, see above.
             }
         }
     };
@@ -94,8 +96,8 @@ export async function handleSuspension({ suspension, world, run, span, requestId
      * in flight. That matters for a 412: the caller reacts by reloading the event
      * log and restarting the replay, so a sibling create that lands after the
      * rejection escaped commits an event whose correlation id came from the
-     * abandoned replay's seeded sequence — an event the fresh replay never
-     * produces — and it races the restart's reload while doing so. Settling first
+     * abandoned replay's seeded sequence (an event the fresh replay never
+     * produces), and it races the restart's reload while doing so. Settling first
      * makes this phase's write set final before the caller acts on the failure.
      * It mirrors the runtime's inline step claim, which settles the in-flight
      * step executions before escalating a 412.
@@ -122,7 +124,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
     // Adds the optimistic-concurrency guard when the caller supplied a loaded
     // event log; without one it creates directly (callers with no replay
     // snapshot, e.g. tests). A stale (412) rejection propagates to the caller,
-    // which restarts the replay from a corrected log — it is not retried here,
+    // which restarts the replay from a corrected log. It is not retried here,
     // because the event's correlation id was minted by *this* replay's seeded
     // sequence, so re-committing it against a corrected log would persist an
     // event no correct replay produces.
@@ -138,8 +140,8 @@ export async function handleSuspension({ suspension, world, run, span, requestId
         });
         // Bump-and-report: the write landed above the slot it asked for, so the
         // report holds the events it was decided without. Absorbing here rather
-        // than at each call site means the rest of this phase's writes — which read
-        // the same array to build their own snapshot — ask for a slot above them,
+        // than at each call site means the rest of this phase's writes (which read
+        // the same array to build their own snapshot) ask for a slot above them,
         // and the replay that resumes from this log sees them without a reload.
         const report = absorbSkippedSlotReport(log.events, result);
         reportedEvents += report.added;
@@ -170,15 +172,15 @@ export async function handleSuspension({ suspension, world, run, span, requestId
     // Group hook items that need work by token, preserving queue-insertion
     // (workflow code) order within each token. Operations on one token must
     // apply in code order: a dispose() of an earlier hook releases the token
-    // before a later same-token hook's creation is validated — otherwise the
+    // before a later same-token hook's creation is validated (otherwise the
     // new hook records a spurious hook_conflict against the run's own
-    // disposed hook — while a hook created and disposed within the same
+    // disposed hook), while a hook created and disposed within the same
     // suspension is still created before it is disposed. Different tokens
     // have no claim interaction, so token groups are processed in parallel.
     const hookItemsByToken = new Map();
     for (const item of allHookItems) {
         if (item.hasCreatedEvent && !item.disposed) {
-            continue; // already committed and still live — nothing to do
+            continue; // already committed and still live: nothing to do
         }
         const group = hookItemsByToken.get(item.token);
         if (group) {
@@ -207,7 +209,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
         }
         catch (err) {
             if (EntityConflictError.is(err)) {
-                // Hook was already disposed by a concurrent invocation — safe to skip
+                // Hook was already disposed by a concurrent invocation, safe to skip
                 runtimeLogger.info('Hook already disposed, skipping duplicate disposal', {
                     workflowRunId: runId,
                     correlationId: queueItem.correlationId,
@@ -235,7 +237,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
         }
     }
     // Process hooks first to prevent race conditions with webhook receivers.
-    // Track any hook conflicts that occur — these are returned to the caller
+    // Track any hook conflicts that occur: these are returned to the caller
     // so the V2 handler can re-invoke immediately.
     let hasHookConflict = false;
     let hasAwaitedHookCreation = false;
@@ -283,7 +285,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
         }));
         hookCreationMs = Date.now() - hookPhaseStart;
     }
-    // Process abort requests — resume the hook with abort payload and write stream packet
+    // Process abort requests: resume the hook with abort payload and write stream packet
     const hooksNeedingAbort = allHookItems.filter((item) => item.abortRequested && !item.disposed);
     if (hooksNeedingAbort.length > 0) {
         await ensureRunReady();
@@ -314,7 +316,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                     await world.streams.close(runId, streamName);
                 }
                 catch {
-                    // Best-effort stream write — hook event provides the durable fallback
+                    // Best-effort stream write: hook event provides the durable fallback
                     runtimeLogger.debug('Failed to write abort stream packet, hook event will provide fallback', {
                         workflowRunId: runId,
                         correlationId: queueItem.correlationId,
@@ -336,7 +338,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
         }));
     }
     // Create step events for steps that don't have them yet.
-    // Unlike V1, we do NOT queue step messages from here — the caller
+    // Unlike V1, we do NOT queue step messages from here: the caller
     // decides which steps to execute inline vs. queue to background.
     // Wait events are also created in parallel below.
     const stepsNeedingCreation = new Set(stepItems
@@ -344,13 +346,116 @@ export async function handleSuspension({ suspension, world, run, span, requestId
         .map((queueItem) => queueItem.correlationId));
     // Correlation IDs for which THIS suspension call actually wrote the
     // step_created event. Populated by the ops below after a successful
-    // events.create — used by the caller to claim ownership and avoid
+    // events.create, used by the caller to claim ownership and avoid
     // racing with concurrent handlers on step execution.
     const createdStepCorrelationIds = new Set();
+    // Correlation IDs of steps finalized as failed because their arguments
+    // refused to serialize: see finalizeUnserializableStep below.
+    const failedStepCorrelationIds = new Set();
+    /**
+     * A step whose arguments fail to serialize is deterministic: every replay
+     * re-derives the same unserializable value, so redelivering the
+     * orchestrator message can never succeed. Instead of rejecting the whole
+     * suspension (which fails the run from the outside, where no user code can
+     * observe it), treat it exactly like a step-body failure: write
+     * `step_created` with a placeholder input (every World requires the step
+     * entity to exist before a terminal step event, and the real input is
+     * precisely what refused to serialize) followed by `step_failed` carrying
+     * the SerializationError. The next replay rejects the step's promise with
+     * it, so a try/catch around the step call observes the error; uncaught, it
+     * propagates out of the workflow body and fails the run as a USER_ERROR,
+     * without burning queue redeliveries either way.
+     */
+    const finalizeUnserializableStep = async (queueItem, error) => {
+        runtimeLogger.warn('Step arguments failed to serialize; failing the step so the ' +
+            'workflow can observe the error', {
+            workflowRunId: runId,
+            correlationId: queueItem.correlationId,
+            stepName: queueItem.stepName,
+            error: error.message,
+        });
+        await ensureRunReady();
+        // Marker placeholder (not empty args): byte-identical-to-zero-args would
+        // make `workflow inspect steps` show "no arguments" for the one step
+        // whose entire problem was its arguments.
+        const placeholderInput = (await dehydrateStepArguments(unserializableStepInputPlaceholder(), runId, encryptionKey, suspension.globalThis, false, compression));
+        try {
+            await createGuarded({
+                eventType: 'step_created',
+                specVersion: SPEC_VERSION_CURRENT,
+                correlationId: queueItem.correlationId,
+                eventData: {
+                    stepName: queueItem.stepName,
+                    workflowName: run.workflowName,
+                    input: placeholderInput,
+                },
+            }, { requestId });
+        }
+        catch (createErr) {
+            if (EntityConflictError.is(createErr)) {
+                // A concurrent handler already created the step: the failure is
+                // deterministic, so it is racing toward the same step_failed below.
+                runtimeLogger.info('Step already exists, continuing', {
+                    workflowRunId: runId,
+                    correlationId: queueItem.correlationId,
+                    message: createErr.message,
+                });
+            }
+            else if (RunExpiredError.is(createErr)) {
+                // Run already finished: nothing to observe the failure.
+                return;
+            }
+            else {
+                throw createErr;
+            }
+        }
+        try {
+            await createGuarded({
+                eventType: 'step_failed',
+                specVersion: SPEC_VERSION_CURRENT,
+                correlationId: queueItem.correlationId,
+                eventData: {
+                    stepName: queueItem.stepName,
+                    // The error itself is a plain WorkflowError (name, message with
+                    // framed hint, cause chain), serializable even though the step
+                    // input was not. Error detection is realm-independent
+                    // (types.isNativeError), so the host-created error serializes
+                    // the same under either global; the VM global is passed for
+                    // consistency with every other dehydration in this file and so
+                    // any VM-realm values guest code threw into the cause chain
+                    // (getters/proxies executed during the failed dehydration) are
+                    // detected by the realm-sensitive reducers.
+                    error: await dehydrateStepError(error, runId, encryptionKey, [], suspension.globalThis, compression),
+                },
+            }, { requestId });
+        }
+        catch (failErr) {
+            if (EntityConflictError.is(failErr) || RunExpiredError.is(failErr)) {
+                // Step already terminal (a concurrent handler wrote the same
+                // deterministic failure) or the run already finished.
+                runtimeLogger.info('Tried failing step, but step or run has already finished.', {
+                    workflowRunId: runId,
+                    correlationId: queueItem.correlationId,
+                    message: failErr.message,
+                });
+            }
+            else {
+                throw failErr;
+            }
+        }
+        failedStepCorrelationIds.add(queueItem.correlationId);
+        // Release the inline slot bookkeeping: the step never runs, so it must
+        // not appear in the rebuilt `lazyInlineSteps`. (Its slot in the first-N
+        // selection and in `inlinePairFoldEligible`'s arithmetic was consumed
+        // before dehydration could reveal the failure, inherent to selecting
+        // before serializing, and bounded to one wasted slot on a pass that
+        // ends in a forced replay anyway.)
+        lazyInlineCorrelationIds.delete(queueItem.correlationId);
+    };
     // Serialization always runs through the one ordinary path below, so the
     // durable bytes cannot depend on retention. What retention needs to know is
     // whether that serialization *executed* workflow code (getters, proxy
-    // traps, custom serializers) — side effects a cold replay would not
+    // traps, custom serializers): side effects a cold replay would not
     // repeat, since a replay skips dehydration for already-recorded steps.
     // The hardened serializer records exactly that into this sink (see
     // ../serialization/hardened.ts); when any input in the batch records an
@@ -364,9 +469,9 @@ export async function handleSuspension({ suspension, world, run, span, requestId
     // (saving a round-trip per step). We never defer when a `hook.getConflict()`
     // awaiter is present, because in that case the caller executes nothing inline
     // (it re-invokes immediately to resolve the awaiter), so deferring would
-    // leave the steps uncreated and unqueued. We pick the first N uncreated steps
-    // — matching the caller's inline-candidate selection — and dehydrate their
-    // input here so executeStep can ship it as the step_started payload.
+    // leave the steps uncreated and unqueued. We pick the first N uncreated
+    // steps (matching the caller's inline-candidate selection) and dehydrate
+    // their input here so executeStep can ship it as the step_started payload.
     const lazyInlineCorrelationIds = new Set(hasAwaitedHookCreation === false
         ? stepItems
             .filter((item) => stepsNeedingCreation.has(item.correlationId))
@@ -386,13 +491,13 @@ export async function handleSuspension({ suspension, world, run, span, requestId
     // Resilient step dispatch eligibility, shared by every step op below (the
     // per-step input-size check is applied inside the op). All must hold:
     //
-    //  - The caller provided a dispatch target (`stepDispatch`) — terminal
+    //  - The caller provided a dispatch target (`stepDispatch`): terminal
     //    drains and other create-only callers never queue.
     //  - The feature is enabled (`WORKFLOW_RESILIENT_STEP_DISPATCH` opt-in).
     //    It is off by default because the publish races the create's verdict,
     //    and a create can come back refused: as a duplicate the replay should
-    //    stop pursuing, or — on a World that would rather refuse a stale write
-    //    than report what it missed — as a 412. Either way the queue message
+    //    stop pursuing, or (on a World that would rather refuse a stale write
+    //    than report what it missed) as a 412. Either way the queue message
     //    carrying the payload is already out, and the consumer can materialize a
     //    step whose create was refused. Nothing orders that verdict before the
     //    consumer's redelivery re-ensure, so no backend-side revocation
@@ -405,6 +510,51 @@ export async function handleSuspension({ suspension, world, run, span, requestId
     const resilientDispatchEligible = stepDispatch !== undefined &&
         isResilientStepDispatchEnabled() &&
         (run.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT;
+    // Batched fan-out: fold this suspension's step_created + wait_created
+    // writes into one `events.createBatch` call (one durable write, per-event
+    // outcomes) instead of one write per event. Engages only for a CLEAN
+    // fan-out (no attribute writes, no hook writes, no resilient dispatch
+    // whose creates are each paired with a queue publish) on a World that
+    // implements the optional method and a run whose events are slot-numbered.
+    // Everything outside the gate keeps the single-event path byte-for-byte.
+    const batchFanoutEligible = isBatchTransitionsEnabled() &&
+        typeof world.events.createBatch === 'function' &&
+        (run.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_SLOT_IDENTITY &&
+        !resilientDispatchEligible &&
+        allHookItems.length === 0 &&
+        attributeItems.length === 0;
+    /**
+     * The fold's collection, in scheduling order (steps in stepItems order,
+     * then waits). Step entries are enqueued by their prep promises (input
+     * dehydration runs concurrently, so entries are ordered by `order`, not by
+     * completion); the single flush op below awaits every prep, sorts, and
+     * commits the whole set through `createBatch`.
+     */
+    const batchQueue = [];
+    const batchPreps = [];
+    // Pre-claimed inline pairs: fold each lazy-inline step's deferred
+    // `step_created` (carrying its input) AND its `step_started` claim (bare,
+    // ownership-stamped) into the batch, so the whole fan-out (the inline
+    // steps' claims included) commits in the one durable write and the caller
+    // starts the bodies straight off that commit instead of posting one claim
+    // per inline step. The lone-inline case (nothing else to batch with) is
+    // excluded: a pair-only batch costs the same round trip as the single lazy
+    // claim while giving up the optimistic claim/body overlap and the
+    // bump-and-report that `createGuarded` provides, so it stays on the lazy
+    // path. Requires the caller's `ownerMessageId`: the started row must
+    // stamp ownership exactly like the lazy claim it replaces (and a caller
+    // that does not inline-execute never provides one).
+    const uncreatedWaitCount = waitItems.filter((item) => !item.hasCreatedEvent).length;
+    const inlinePairFoldEligible = batchFanoutEligible &&
+        ownerMessageId !== undefined &&
+        lazyInlineCorrelationIds.size > 0 &&
+        (lazyInlineCorrelationIds.size >= 2 ||
+            stepsNeedingCreation.size -
+                lazyInlineCorrelationIds.size +
+                uncreatedWaitCount >=
+                1);
+    const inlineClaims = new Map();
+    let batchCommittedSlotCeiling;
     // The trace carrier for resilient step dispatches, resolved at most once per
     // suspension (the per-step ops run concurrently and share it).
     let stepDispatchTraceCarrier;
@@ -415,24 +565,61 @@ export async function handleSuspension({ suspension, world, run, span, requestId
     };
     // Producer-side resilient recovery count for the suspension span attribute.
     let resilientDispatchRecovered = 0;
-    // Steps: create step_created events (no queuing — V2 returns pending steps
-    // to caller — EXCEPT on the resilient dispatch path, which parallelizes the
+    // Steps: create step_created events (no queuing, V2 returns pending steps
+    // to caller, EXCEPT on the resilient dispatch path, which parallelizes the
     // create with the step's queue publish and reports it in
     // `queuedStepCorrelationIds`).
+    let batchOrderCounter = 0;
     for (const queueItem of stepItems) {
         if (stepsNeedingCreation.has(queueItem.correlationId)) {
-            ops.push((async () => {
+            // Deterministic position in the batched fold (assigned in stepItems
+            // order, before the concurrent dehydration runs). A pair-folded inline
+            // step occupies two consecutive positions (created row then started
+            // row), which the flush keeps adjacent and never splits across chunks,
+            // so a World can fold them into one born-running create.
+            const pairFolded = inlinePairFoldEligible &&
+                lazyInlineCorrelationIds.has(queueItem.correlationId);
+            const stepOrder = batchOrderCounter;
+            batchOrderCounter += pairFolded ? 2 : 1;
+            const stepOp = (async () => {
                 // Per-step sink, merged below: the dehydrate wrapper emits span
                 // attributes from the sink it is handed, so sharing one across
                 // steps would re-emit (and misattribute) earlier steps' entries.
                 const stepGuestCode = { executions: [] };
-                const dehydratedInput = await dehydrateStepArguments({
-                    args: queueItem.args,
-                    closureVars: queueItem.closureVars,
-                    thisVal: queueItem.thisVal,
-                }, runId, encryptionKey, suspension.globalThis, false, compression, stepGuestCode);
+                let dehydratedInput;
+                try {
+                    dehydratedInput = await dehydrateStepArguments({
+                        args: queueItem.args,
+                        closureVars: queueItem.closureVars,
+                        thisVal: queueItem.thisVal,
+                    }, runId, encryptionKey, suspension.globalThis, false, compression, stepGuestCode);
+                }
+                catch (err) {
+                    // The sink records executions as they happen, so guest code that
+                    // ran before the failure still counts against retention.
+                    guestCodeStats.executions.push(...stepGuestCode.executions);
+                    if (!SerializationError.is(err)) {
+                        // e.g. RuntimeDecryptionError: an SDK fault, not a user value
+                        // problem. Keep its identity (RUNTIME_ERROR) and current
+                        // fail-the-suspension behavior.
+                        throw err;
+                    }
+                    if (!stepDispatch) {
+                        // No dispatch target means no replay will observe a
+                        // finalization: this is the terminal drain (or a create-only
+                        // test caller). The run is already completing/failing, so
+                        // writing step_created + step_failed here would leave e.g. a
+                        // COMPLETED run carrying a failed step nothing can ever
+                        // observe, reading as a bug from the dashboard. Rethrow
+                        // instead; the drain's own catch swallows it, preserving its
+                        // pre-existing behavior (no rows for the unawaited step).
+                        throw err;
+                    }
+                    await finalizeUnserializableStep(queueItem, err);
+                    return;
+                }
                 guestCodeStats.executions.push(...stepGuestCode.executions);
-                // Deferred (lazy) inline step: skip the step_created write — the
+                // Deferred (lazy) inline step: skip the step_created write; the
                 // caller's inline executeStep will send a lazy step_started carrying
                 // this input, and the world creates the step (entity + synthetic
                 // step_created event) atomically. We do NOT add it to
@@ -444,6 +631,44 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                         stepName: queueItem.stepName,
                         dehydratedInput: dehydratedInput,
                     });
+                    if (pairFolded) {
+                        // Enqueue the pair the deferral would otherwise leave to the
+                        // caller's lazy `step_started`: the created row carries the
+                        // input (payloads ride creates in a batch), the started row is
+                        // bare and stamps this invocation's ownership, the same claim
+                        // shape the lazy start would have sent, settled by the batch.
+                        batchQueue.push({
+                            order: stepOrder,
+                            kind: 'inline-created',
+                            correlationId: queueItem.correlationId,
+                            event: {
+                                eventType: 'step_created',
+                                specVersion: SPEC_VERSION_CURRENT,
+                                correlationId: queueItem.correlationId,
+                                eventData: {
+                                    stepName: queueItem.stepName,
+                                    workflowName: run.workflowName,
+                                    input: dehydratedInput,
+                                },
+                            },
+                        });
+                        batchQueue.push({
+                            order: stepOrder + 1,
+                            kind: 'inline-started',
+                            correlationId: queueItem.correlationId,
+                            event: {
+                                eventType: 'step_started',
+                                specVersion: SPEC_VERSION_CURRENT,
+                                correlationId: queueItem.correlationId,
+                                eventData: {
+                                    stepName: queueItem.stepName,
+                                    // Checked by inlinePairFoldEligible; spread keeps the
+                                    // narrow-through-closure problem away from the type.
+                                    ...(ownerMessageId !== undefined ? { ownerMessageId } : {}),
+                                },
+                            },
+                        });
+                    }
                     return;
                 }
                 const stepEvent = {
@@ -457,7 +682,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                     },
                 };
                 // Resilient step dispatch: fire the step_created write and the
-                // step-execution queue publish in parallel — the message carries the
+                // step-execution queue publish in parallel: the message carries the
                 // same serialized input (`stepInput`) so the consumer can
                 // idempotently re-ensure the event if the direct write failed
                 // transiently. Mirrors the resilient start (`runInput`) and
@@ -481,10 +706,10 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                             stepInput: { input: dehydratedInput },
                         }, 
                         // Same key as the caller's dispatch pass and any concurrent
-                        // handler's — redundant publishes for this step dedupe. The
+                        // handler's, so redundant publishes for this step dedupe. The
                         // key is step-identity-scoped so a revoked message for a
                         // reassigned correlation id cannot absorb the corrected
-                        // schedule's dispatch — see stepDispatchIdempotencyKey.
+                        // schedule's dispatch: see stepDispatchIdempotencyKey.
                         {
                             idempotencyKey: stepDispatchIdempotencyKey(queueItem.correlationId, queueItem.stepName),
                         }),
@@ -493,7 +718,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                     // the message the step would rely on the create alone, and if the
                     // create ALSO failed there would be no durable record at all.
                     // Propagating redelivers the orchestrator message, which
-                    // re-creates the (idempotent) step_created and re-dispatches —
+                    // re-creates the (idempotent) step_created and re-dispatches,
                     // the same recovery as the sequential path.
                     if (queueResult.status === 'rejected') {
                         throw queueResult.reason;
@@ -502,7 +727,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                     if (createResult.status === 'rejected') {
                         const err = createResult.reason;
                         if (EntityConflictError.is(err)) {
-                            // Concurrent handler wrote it first — same as the sequential
+                            // Concurrent handler wrote it first, same as the sequential
                             // path. The step message is already out; a duplicate publish
                             // by that handler dedupes on the shared idempotency key.
                             runtimeLogger.info('Step already exists, continuing', {
@@ -513,8 +738,8 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                         }
                         else if (isRetryableWorldError(err)) {
                             // Resilient: the write failed transiently (429 / 5xx /
-                            // transport) but the step message — carrying the same
-                            // serialized input — was published, so the consumer
+                            // transport) but the step message (carrying the same
+                            // serialized input) was published, so the consumer
                             // idempotently re-ensures the step_created before executing.
                             resilientDispatchRecovered++;
                             runtimeLogger.warn('Step creation event write failed, but the step was ' +
@@ -535,6 +760,19 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                     }
                     return;
                 }
+                if (batchFanoutEligible) {
+                    // Fold into the batch instead of writing here. The enclosing
+                    // promise joins `batchPreps` (see the loop below), so the flush
+                    // op cannot run before this step's input finished dehydrating.
+                    batchQueue.push({
+                        order: stepOrder,
+                        kind: 'step',
+                        correlationId: queueItem.correlationId,
+                        stepName: queueItem.stepName,
+                        event: stepEvent,
+                    });
+                    return;
+                }
                 try {
                     await ensureRunReady();
                     await createGuarded(stepEvent, { requestId });
@@ -552,21 +790,41 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                         throw err;
                     }
                 }
-            })());
+            })();
+            ops.push(stepOp);
+            if (batchFanoutEligible) {
+                // The flush op waits for every prep before committing; a prep that
+                // rejected already surfaces through `ops`, so the flush's own wait
+                // swallows it and commits whatever was successfully enqueued,
+                // preserving today's per-op independence.
+                batchPreps.push(stepOp.catch(() => { }));
+            }
         }
     }
     // Create wait events (same as V1)
     for (const queueItem of waitItems) {
         if (!queueItem.hasCreatedEvent) {
-            ops.push((async () => {
-                const waitEvent = {
-                    eventType: 'wait_created',
-                    specVersion: SPEC_VERSION_CURRENT,
+            const waitEvent = {
+                eventType: 'wait_created',
+                specVersion: SPEC_VERSION_CURRENT,
+                correlationId: queueItem.correlationId,
+                eventData: {
+                    resumeAt: queueItem.resumeAt,
+                },
+            };
+            if (batchFanoutEligible) {
+                // Waits need no dehydration, so they enqueue synchronously, after
+                // every step's order slot, preserving steps-then-waits scheduling
+                // order in the log.
+                batchQueue.push({
+                    order: batchOrderCounter++,
+                    kind: 'wait',
                     correlationId: queueItem.correlationId,
-                    eventData: {
-                        resumeAt: queueItem.resumeAt,
-                    },
-                };
+                    event: waitEvent,
+                });
+                continue;
+            }
+            ops.push((async () => {
                 try {
                     await ensureRunReady();
                     await createGuarded(waitEvent, { requestId });
@@ -586,6 +844,362 @@ export async function handleSuspension({ suspension, world, run, span, requestId
             })());
         }
     }
+    // The batched fold's flush: the clean fan-out commits through
+    // `createBatch` in chunks of MAX_BATCH_FANOUT_EVENTS, all chunks IN
+    // FLIGHT CONCURRENTLY. Slot assignment is the server's, so parallel
+    // chunks race for slot ranges exactly like the pre-fold path's parallel
+    // single writes did; entity conditions, not commit order, carry
+    // correctness (sibling fan-out events have no cross-order the replay
+    // depends on; it matches by correlation id). Each event reports the
+    // outcome its own single create would have had: a 409 is the same
+    // already-exists tolerance as the single path, anything else fails the
+    // delivery the way a single-path rejection would.
+    //
+    // Latency shape: only the chunk carrying the pre-claimed inline pairs
+    // gates the handler's return (the caller starts bodies off its claims).
+    // Every other chunk's commit (and every chunk's step-message publishes,
+    // which fire the moment ITS creates are durable) rides
+    // `deferredBatchWork` when the caller opted in, joined before ack. A slow
+    // sibling chunk therefore delays neither the inline bodies nor another
+    // chunk's queue messages, while publish-after-create still holds per
+    // step: a step's message is only ever sent after the chunk carrying its
+    // create has committed.
+    let deferredBatchWork;
+    if (batchFanoutEligible) {
+        ops.push((async () => {
+            // Preps that rejected already surface through their own `ops`
+            // entries; the fold commits whatever was successfully enqueued,
+            // preserving today's per-op independence.
+            await Promise.all(batchPreps);
+            if (batchQueue.length === 0) {
+                return;
+            }
+            const entries = [...batchQueue].sort((a, b) => a.order - b.order);
+            await ensureRunReady();
+            // A batch of ONE gains nothing over the single write (same round
+            // trip) and loses the slot-snapshot params + bump-and-report that
+            // createGuarded provides, so a lone eager event takes the ordinary
+            // single path, with the same conflict tolerance and ownership
+            // bookkeeping it would have had without the fold.
+            if (entries.length === 1) {
+                const [entry] = entries;
+                try {
+                    await createGuarded(entry.event, { requestId });
+                    if (entry.kind === 'step') {
+                        createdStepCorrelationIds.add(entry.correlationId);
+                    }
+                }
+                catch (err) {
+                    if (EntityConflictError.is(err)) {
+                        runtimeLogger.info(entry.kind === 'step'
+                            ? 'Step already exists, continuing'
+                            : 'Wait already exists, continuing', {
+                            workflowRunId: runId,
+                            correlationId: entry.correlationId,
+                            message: err.message,
+                        });
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                return;
+            }
+            // Seed for the foreign-interleaving diagnostic below. With chunks
+            // committing in parallel there is no per-chunk "expected next slot";
+            // the whole fold's committed span is compared against the seed
+            // once every chunk has settled: committed slots are dense per the
+            // World's invariant, so any excess of (max committed slot − seed +
+            // 1) over the fold's own committed count is events OTHER writers
+            // landed in between.
+            const expectedFirstSlot = eventLog
+                ? (maxEventSlot(eventLog.events) ?? 0) + 1
+                : undefined;
+            // Pair-aware chunking: a pre-claimed pair's two rows must land in
+            // the same createBatch call (adjacent, so a World can fold them
+            // into one born-running create) and never straddle a chunk
+            // boundary, which would turn the started row into a standalone
+            // claim racing its own create's commit.
+            const chunks = [];
+            {
+                let current = [];
+                for (let index = 0; index < entries.length; index++) {
+                    const entry = entries[index];
+                    const next = entries[index + 1];
+                    const pairLead = entry.kind === 'inline-created' &&
+                        next?.kind === 'inline-started' &&
+                        next.correlationId === entry.correlationId;
+                    const take = pairLead ? 2 : 1;
+                    if (current.length > 0 &&
+                        current.length + take > MAX_BATCH_FANOUT_EVENTS) {
+                        chunks.push(current);
+                        current = [];
+                    }
+                    current.push(entry);
+                    if (pairLead) {
+                        current.push(next);
+                        index++;
+                    }
+                }
+                if (current.length > 0)
+                    chunks.push(current);
+            }
+            // Steps whose queue messages THIS FLUSH will publish (the eager
+            // creates), recorded before any chunk settles so the caller's
+            // dispatch pass (which runs off the handler's return) skips them.
+            // The sends are guaranteed-or-failed by the trailing work the
+            // caller joins before acking, so "will be published by this flush"
+            // and "already published" are equivalent from the caller's side.
+            const publishEagerSteps = stepDispatch !== undefined;
+            if (publishEagerSteps) {
+                for (const entry of entries) {
+                    if (entry.kind === 'step') {
+                        queuedStepCorrelationIds.add(entry.correlationId);
+                    }
+                }
+            }
+            // Tallies for the foreign-interleaving diagnostic, folded across
+            // the concurrent chunks and read once all of them settled.
+            let committedCount = 0;
+            let maxCommittedSlot;
+            const commitChunk = async (chunk) => {
+                // Anchors for the pre-claimed steps' telemetry: the POST instant
+                // is the claim's "start POST sent" (RSFS's end), the return is the
+                // claim's completion (TTR's T6), the same two instants the lazy
+                // claim's own POST would have produced.
+                const batchPostSentAtMs = Date.now();
+                // biome-ignore lint/style/noNonNullAssertion: batchFanoutEligible implies presence
+                const { results } = await world.events.createBatch(runId, chunk.map((entry) => ({
+                    event: entry.event,
+                    // The started row is the step's executing claim, so it carries
+                    // the compute-instance attribution the single claim sends via
+                    // CreateEventParams.
+                    ...(entry.kind === 'inline-started'
+                        ? { computeInstanceId: COMPUTE_INSTANCE_ID }
+                        : {}),
+                })), 
+                // Per-write request attribution, same as the single path's
+                // createGuarded(…, { requestId }).
+                { requestId });
+                const claimCompletedAtMs = Date.now();
+                for (const [index, item] of results.entries()) {
+                    const entry = chunk[index];
+                    if (item.error === undefined) {
+                        if (entry.kind === 'step') {
+                            createdStepCorrelationIds.add(entry.correlationId);
+                        }
+                        else if (entry.kind === 'inline-started') {
+                            // The pair committed: this invocation owns the step and the
+                            // caller runs the body with no claim of its own. The
+                            // readback entity is authoritative where present; a World
+                            // that omitted it gets the same locally synthesized running
+                            // attempt-1 the optimistic path executes against. Either
+                            // way the input is re-attached locally: batch responses
+                            // return refs lazily, and the body's hydration wants the
+                            // exact bytes the pair's created row carried. (The created
+                            // row's success is deliberately NOT membership in
+                            // createdStepCorrelationIds: for inline steps ownership is
+                            // the started row's verdict, and the caller's dispatch pass
+                            // skips inline correlation ids regardless.)
+                            const dehydrated = lazyInlineByCorrelationId.get(entry.correlationId);
+                            if (dehydrated === undefined) {
+                                // Unreachable: the same prep op that enqueued the pair set
+                                // this entry, and the flush awaited every prep above.
+                                //
+                                // Not free if it ever fires, though: the pair is already
+                                // durable here, so this throws with the step claimed and
+                                // its body never run. The delivery fails, and redelivery
+                                // recovers it through owned-recovery (the step carries this
+                                // message's ownership stamp) rather than the request just
+                                // failing cleanly.
+                                throw new WorkflowWorldError(`no dehydrated input for pre-claimed step ${entry.correlationId}`, { status: 500 });
+                            }
+                            const now = new Date();
+                            const startedStep = item.step?.startedAt
+                                ? { ...item.step, startedAt: item.step.startedAt }
+                                : {
+                                    runId,
+                                    stepId: entry.correlationId,
+                                    stepName: dehydrated.stepName,
+                                    status: 'running',
+                                    attempt: 1,
+                                    createdAt: now,
+                                    updatedAt: now,
+                                    startedAt: now,
+                                };
+                            inlineClaims.set(entry.correlationId, {
+                                owned: true,
+                                step: {
+                                    ...startedStep,
+                                    input: dehydrated.dehydratedInput,
+                                },
+                                batchPostSentAtMs,
+                                claimCompletedAtMs,
+                            });
+                        }
+                        continue;
+                    }
+                    if (item.status === 409) {
+                        if (entry.kind === 'inline-created' ||
+                            entry.kind === 'inline-started') {
+                            // The pair lost its atomic create-claim: a concurrent writer
+                            // already owns this step (an earlier delivery's create, or a
+                            // racing handler's claim). Recorded as a lost claim: the
+                            // caller's executeStep returns `skipped` without running the
+                            // body, the same outcome as losing the lazy claim. A World
+                            // that folds the pair reports the 409 on both rows (set
+                            // twice, harmless); one that evaluates rows independently
+                            // has the started row (processed second) decide, which is
+                            // exactly the single path's semantics (create lost + claim
+                            // won still runs the body; create won + claim lost skips).
+                            inlineClaims.set(entry.correlationId, { owned: false });
+                            runtimeLogger.info('Inline step pre-claim lost, continuing', {
+                                workflowRunId: runId,
+                                correlationId: entry.correlationId,
+                                message: item.message,
+                            });
+                            continue;
+                        }
+                        // Same tolerance as the single path's EntityConflictError: a
+                        // concurrent or earlier delivery already created it.
+                        runtimeLogger.info(entry.kind === 'step'
+                            ? 'Step already exists, continuing'
+                            : 'Wait already exists, continuing', {
+                            workflowRunId: runId,
+                            correlationId: entry.correlationId,
+                            message: item.message,
+                        });
+                        continue;
+                    }
+                    throw new WorkflowWorldError(`batched ${entry.event.eventType} for ${entry.correlationId} ` +
+                        `failed: ${item.error}: ${item.message}`, { status: item.status });
+                }
+                // Highest slot this chunk committed: the ceiling the caller folds
+                // into the inline executions' slot snapshot (see
+                // SuspensionHandlerResult.batchCommittedSlotCeiling) and one input
+                // of the interleaving diagnostic.
+                const chunkMaxSlot = maxEventSlot(results.flatMap((item) => item.error === undefined && item.event ? [item.event] : []));
+                if (chunkMaxSlot !== undefined &&
+                    (batchCommittedSlotCeiling === undefined ||
+                        chunkMaxSlot > batchCommittedSlotCeiling)) {
+                    batchCommittedSlotCeiling = chunkMaxSlot;
+                }
+                committedCount += results.filter((item) => item.error === undefined).length;
+                if (chunkMaxSlot !== undefined &&
+                    (maxCommittedSlot === undefined || chunkMaxSlot > maxCommittedSlot)) {
+                    maxCommittedSlot = chunkMaxSlot;
+                }
+            };
+            // Publish the chunk's eager steps' queue messages the moment ITS
+            // creates are durable, the per-chunk half of publish-after-create.
+            // Same message shape and step-identity-scoped idempotency key as the
+            // caller's dispatch pass, so anything double-published dedupes.
+            const publishChunkSteps = async (chunk) => {
+                if (!publishEagerSteps)
+                    return;
+                const stepEntries = chunk.filter((entry) => entry.kind === 'step');
+                if (stepEntries.length === 0)
+                    return;
+                const traceCarrier = await getStepDispatchTraceCarrier();
+                await Promise.all(stepEntries.map((entry) => queueMessage(world, 
+                // biome-ignore lint/style/noNonNullAssertion: publishEagerSteps implies presence
+                stepDispatch.queueName, {
+                    runId,
+                    stepId: entry.correlationId,
+                    // biome-ignore lint/style/noNonNullAssertion: set on every 'step' entry at enqueue
+                    stepName: entry.stepName,
+                    traceCarrier,
+                    requestedAt: new Date(),
+                }, {
+                    idempotencyKey: stepDispatchIdempotencyKey(entry.correlationId, 
+                    // biome-ignore lint/style/noNonNullAssertion: set on every 'step' entry at enqueue
+                    entry.stepName),
+                })));
+            };
+            // Launch every chunk's POST now; chain each chunk's publishes on its
+            // OWN commit. A chunk whose commit rejected keeps its messages
+            // unsent (the rejection fails the delivery; redelivery re-creates
+            // and re-dispatches, deduped by the idempotency keys).
+            const commits = chunks.map((chunk) => commitChunk(chunk));
+            const publishes = chunks.map(async (chunk, index) => {
+                await commits[index];
+                await publishChunkSteps(chunk);
+            });
+            const trailing = (async () => {
+                // Let every sibling settle before surfacing the first failure: a
+                // chunk that committed must still get its publishes out even when
+                // another chunk failed, and the caller acks only after this
+                // resolves.
+                const settled = await Promise.allSettled([...commits, ...publishes]);
+                // Foreign-interleaving visibility: the batch endpoint has no
+                // bump-and-report, so events other writers landed between the
+                // snapshot and these commits pushed the fold to higher slots
+                // WITHOUT handing us the skipped events. Same accepted exposure
+                // as a dropped truncated report on the single path: the local
+                // log stays a strict prefix and the next reload observes them.
+                // Logged so a bump is diagnosable rather than silent.
+                if (expectedFirstSlot !== undefined &&
+                    maxCommittedSlot !== undefined) {
+                    const interleaved = maxCommittedSlot - expectedFirstSlot + 1 - committedCount;
+                    if (interleaved > 0) {
+                        runtimeLogger.debug('Batched fan-out committed above snapshot', {
+                            workflowRunId: runId,
+                            expectedFirstSlot,
+                            maxCommittedSlot,
+                            committedCount,
+                            interleaved,
+                        });
+                    }
+                }
+                const failure = settled.find((outcome) => outcome.status === 'rejected');
+                if (failure)
+                    throw failure.reason;
+            })();
+            // EVERY chunk carrying pairs gates the return, not just the first:
+            // a pair whose commit the caller has not seen yields no
+            // `inlineClaims` entry, so the caller falls back to a lazy
+            // `step_started` that would race this same fold's still-in-flight
+            // pair for the same step. Today pairs always land in one chunk
+            // (they sort first, and two rows per inline step fit inside one
+            // chunk, pinned by constants.test.ts), so this is at most one
+            // commit; the filter is what keeps the property true if either cap
+            // moves.
+            const pairCommits = chunks.flatMap((chunk, index) => chunk.some((entry) => entry.kind === 'inline-started')
+                ? [commits[index]]
+                : []);
+            if (allowDeferredBatchWork) {
+                // The trailing work is the caller's to join before ack. Attach a
+                // handler now so a rejection that races that join (or a foreground
+                // failure that prevents the caller from ever reaching it) is never
+                // an unhandledRejection; awaiting the promise still observes it.
+                trailing.catch(() => { });
+                deferredBatchWork = trailing;
+                // Only the pair chunks gate the return: their claims are what the
+                // caller starts the inline bodies from. With no pairs there is
+                // nothing the caller's post-return work reads from the commits,
+                // so nothing gates.
+                if (pairCommits.length > 0) {
+                    try {
+                        await Promise.all(pairCommits);
+                    }
+                    catch (err) {
+                        // A pair chunk failed, so this phase's write set is NOT the
+                        // caller's to join any more: `deferredBatchWork` never
+                        // reaches it once handleSuspension throws. Settle the rest
+                        // before the rejection escapes, for the reason `settlePhase`
+                        // gives: a sibling create landing after the throw commits an
+                        // event from the abandoned replay's seeded sequence and races
+                        // the caller's restart reload while doing so.
+                        await trailing.catch(() => { });
+                        throw err;
+                    }
+                }
+            }
+            else {
+                await trailing;
+            }
+        })());
+    }
     for (const queueItem of attributeItems) {
         ops.push((async () => {
             try {
@@ -593,7 +1207,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                 // Guarded like every other suspension write: an attr_set is a
                 // replay-derived event with a correlation id from this replay's
                 // seeded sequence, so it must not land on a log the replay never
-                // saw. Rejecting it is cheap — a run with attribute events already
+                // saw. Rejecting it is cheap: a run with attribute events already
                 // forces an in-process replay, so the restart costs the replay it
                 // was going to do anyway.
                 await createGuarded({
@@ -618,7 +1232,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                     });
                 }
                 else if (isWorldValidationFailure(err)) {
-                    // Deterministic validation rejection from the World — e.g. the
+                    // Deterministic validation rejection from the World, e.g. the
                     // cumulative per-run attribute cap, which only the World can
                     // check against the run's existing attributes. Redelivering the
                     // orchestrator message replays the workflow into the exact same
@@ -682,6 +1296,9 @@ export async function handleSuspension({ suspension, world, run, span, requestId
         ...Attribute.WorkflowStepsCreated(stepItems.length),
         ...Attribute.WorkflowHooksCreated(hooksNeedingCreation.length),
         ...Attribute.WorkflowWaitsCreated(waitItems.length),
+        ...(failedStepCorrelationIds.size > 0
+            ? Attribute.WorkflowStepsFailedSerialization(failedStepCorrelationIds.size)
+            : {}),
         ...(resilientDispatchRecovered > 0
             ? Attribute.StepResilientDispatchRecovered(resilientDispatchRecovered)
             : {}),
@@ -689,8 +1306,12 @@ export async function handleSuspension({ suspension, world, run, span, requestId
     return {
         pendingSteps: stepItems,
         createdStepCorrelationIds,
+        failedStepCorrelationIds,
         queuedStepCorrelationIds,
         lazyInlineSteps,
+        inlineClaims,
+        batchCommittedSlotCeiling,
+        deferredBatchWork,
         // On hook conflict the caller re-invokes immediately and never reads
         // the wait timeout, so don't report one.
         waitTimeout: hasHookConflict ? undefined : soonestWait,
@@ -720,4 +1341,4 @@ function isWorldValidationFailure(err) {
     }
     return WorkflowWorldError.is(err) && err.status === 400;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"suspension-handler.js","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Span } from '@opentelemetry/api';\nimport {\n  EntityConflictError,\n  FatalError,\n  HookNotFoundError,\n  PreconditionFailedError,\n  RunExpiredError,\n  WorkflowWorldError,\n} from '@workflow/errors';\nimport {\n  AttributeValidationError,\n  type CreateEventParams,\n  type CreateEventRequest,\n  type EventResult,\n  type SerializedData,\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT,\n  SPEC_VERSION_SUPPORTS_COMPRESSION,\n  type TraceCarrier,\n  type ValidQueueName,\n  type WorkflowRun,\n  type World,\n} from '@workflow/world';\nimport { isRetryableWorldError } from '../classify-error.js';\nimport { importKey } from '../encryption.js';\nimport type {\n  AttributeInvocationQueueItem,\n  HookInvocationQueueItem,\n  StepInvocationQueueItem,\n  WaitInvocationQueueItem,\n  WorkflowSuspension,\n} from '../global.js';\nimport { runtimeLogger } from '../logger.js';\nimport type { GuestCodeStats } from '../serialization/hardened.js';\nimport { dehydrateStepArguments } from '../serialization.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { getAbortStreamIdFromToken } from '../util.js';\nimport {\n  getMaxInlineSteps,\n  isResilientStepDispatchEnabled,\n  MAX_RESILIENT_STEP_INPUT_BYTES,\n} from './constants.js';\nimport {\n  absorbSkippedSlotReport,\n  type EventCreator,\n  type LoadedEventLog,\n  queueMessage,\n  slotSnapshotParams,\n  stepDispatchIdempotencyKey,\n} from './helpers.js';\nimport { ReplayRecoveryReporter } from './replay-recovery-reporter.js';\n\nexport interface SuspensionHandlerParams {\n  suspension: WorkflowSuspension;\n  world: World;\n  run: WorkflowRun;\n  span?: Span;\n  requestId?: string;\n  /**\n   * The runtime's loaded event log. Every event creation this suspension makes\n   * names the position it was derived from, so a backend that has recorded\n   * events the replay did not see can report them back on the write — or, if\n   * it would rather refuse than report, reject it with a 412. A rejection is\n   * not retried here: the event's correlation id was minted by *this* replay's\n   * seeded sequence, so re-committing it against a corrected log would persist\n   * an event no correct replay produces. The caller restarts the replay\n   * instead.\n   */\n  eventLog?: LoadedEventLog;\n  /**\n   * Turbo mode only: a promise that resolves once the backgrounded\n   * `run_started` has landed (the run exists). When present, every world write\n   * this suspension performs (`hook_created`, `wait_created`, eager overflow\n   * `step_created`, …) is gated on it so the write never races ahead of the\n   * run's creation. The pure inline hot path defers all of its steps and writes\n   * nothing here, so it never awaits this barrier. `undefined` outside turbo,\n   * where `run_started` was already awaited up front.\n   */\n  runReadyBarrier?: Promise<unknown>;\n  /** One-shot telemetry reporter, activated only after replay has recovered. */\n  replayRecoveryReporter?: ReplayRecoveryReporter;\n  /**\n   * Resilient step dispatch: when provided (and the per-step eligibility gates\n   * pass — see the step ops below), each newly created non-inline step's\n   * `step_created` write is parallelized with its step-execution queue\n   * publish, and the queue message carries the serialized step input\n   * (`stepInput`) so the consumer can idempotently re-ensure the event if the\n   * direct write failed transiently. Steps queued this way are reported in\n   * {@link SuspensionHandlerResult.queuedStepCorrelationIds} so the caller\n   * skips them in its own dispatch pass. Omitted by callers that must not\n   * queue (terminal drain, tests) — creates then behave exactly as before.\n   */\n  stepDispatch?: {\n    /** The unified workflow queue this run's step messages are published to. */\n    queueName: ValidQueueName;\n    /**\n     * Lazily resolves the trace carrier to stamp on the step messages.\n     * Called at most once per suspension (memoized here).\n     */\n    getTraceCarrier: () => Promise<TraceCarrier>;\n  };\n}\n\n/**\n * Result of handling a suspension. Returns pending step items so the caller\n * can decide which to execute inline vs queue to background.\n */\nexport interface SuspensionHandlerResult {\n  /** Pending step items with events created but NOT queued */\n  pendingSteps: StepInvocationQueueItem[];\n  /**\n   * Correlation IDs for which this suspension call actually wrote the\n   * step_created event (as opposed to catching EntityConflictError because\n   * a concurrent handler wrote it first). Only the handler that wrote the\n   * step_created event should queue / inline-execute the step — this\n   * guarantees a single owner per step, even when multiple handlers race\n   * into the same batch boundary.\n   */\n  createdStepCorrelationIds: Set<string>;\n  /**\n   * Correlation IDs of steps this suspension call already published\n   * step-execution queue messages for, via resilient step dispatch (the\n   * `step_created` write parallelized with a `stepInput`-carrying queue\n   * publish). The caller MUST NOT dispatch these again — the message is\n   * already out (a duplicate would be deduped by its idempotency key, but\n   * costs a wasted round-trip). Empty when {@link SuspensionHandlerParams.stepDispatch}\n   * was not provided or no step was eligible.\n   */\n  queuedStepCorrelationIds: Set<string>;\n  /**\n   * How many events this phase's writes reported back as occupying slots they\n   * skipped over, already merged into the caller's `eventLog.events`. Nonzero\n   * means the array was reordered to restore slot order, so any index the\n   * caller cached into it (payload prewarm scan position) is stale.\n   */\n  reportedEventCount: number;\n  /**\n   * The steps whose `step_created` writes were intentionally deferred so the\n   * caller can run them inline via lazy `step_started` events (which create\n   * the step on the fly), saving one world round-trip per inline step. Up to\n   * `getMaxInlineSteps()` steps are deferred; the caller runs them inline in\n   * parallel and queues the rest. Empty when no step was deferred (nothing\n   * pending, or a `hook.getConflict()` awaiter is present so nothing is\n   * executed inline). The caller passes each `dehydratedInput` straight to\n   * `executeStep`, which sends it as the `step_started` payload. The atomic\n   * create-claim inside each `step_started` is the exactly-one-owner gate that\n   * the standalone `step_created` provided before: the loser of the race gets\n   * `EntityConflictError` → `skipped` and does not run the body.\n   */\n  lazyInlineSteps: Array<{\n    correlationId: string;\n    stepName: string;\n    dehydratedInput: SerializedData;\n  }>;\n  /**\n   * The soonest pending wait, if any: seconds until it elapses and the\n   * correlationId of the wait that produced that timeout. The\n   * correlationId seeds the idempotency key for the wait-continuation\n   * queue message so that repeated suspension passes over the same\n   * pending wait collapse into a single delayed continuation.\n   */\n  waitTimeout?: { seconds: number; correlationId: string };\n  /** Whether a hook conflict was detected (should re-invoke immediately) */\n  hasHookConflict: boolean;\n  /** Whether a `hook.getConflict()` awaiter needs the workflow to continue immediately */\n  hasAwaitedHookCreation: boolean;\n  /** Whether native workflow attribute events were written for replay. */\n  hasAttributeEvents: boolean;\n  /**\n   * Whether this suspension created any hook (`hook_created`) events. Unlike\n   * `hasHookConflict` / `hasAwaitedHookCreation`, this is true even for a plain\n   * fire-and-forget hook with no conflict and no awaiter. Turbo mode uses it to\n   * detect \"a hook was created this suspension\" and stop forcing optimistic\n   * inline start (a hook introduces later resume invocations that could race).\n   */\n  hasHookEvents: boolean;\n  /**\n   * Wall-clock ms spent committing this suspension's `hook_created` events\n   * (0 when it created none). The caller accumulates this across iterations\n   * and subtracts it from the TTFS latency measurement, so time spent\n   * durably creating the user's hooks doesn't count as runtime overhead.\n   */\n  hookCreationMs: number;\n  /**\n   * Whether serializing this suspension's new step inputs was passive (did\n   * not execute workflow-owned code such as getters, proxy traps, or custom\n   * serializers). `false` means the retained VM may have diverged from what\n   * a cold replay would compute, so the caller must demote to replay.\n   */\n  retainedStepInputsSafe: boolean;\n}\n\nasync function createHookEvent({\n  runId,\n  hookEvent,\n  queueItem,\n  requestId,\n  createEvent,\n}: {\n  runId: string;\n  hookEvent: CreateEventRequest;\n  queueItem: HookInvocationQueueItem;\n  requestId?: string;\n  createEvent: (\n    data: CreateEventRequest,\n    params?: CreateEventParams\n  ) => Promise<EventResult>;\n}): Promise<{\n  hasHookConflict: boolean;\n  hasAwaitedHookCreation: boolean;\n}> {\n  try {\n    const result = await createEvent(hookEvent, {\n      requestId,\n    });\n\n    // Check if the world returned a hook_conflict event instead of hook_created.\n    // The hook_conflict event is stored in the event log and will be replayed\n    // on the next workflow invocation, causing the hook's promise to reject.\n    if (result.event?.eventType === 'hook_conflict') {\n      return {\n        hasHookConflict: true,\n        hasAwaitedHookCreation: false,\n      };\n    }\n\n    return {\n      hasHookConflict: false,\n      hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true,\n    };\n  } catch (err) {\n    if (EntityConflictError.is(err)) {\n      runtimeLogger.info('Hook already exists, continuing', {\n        workflowRunId: runId,\n        message: err.message,\n      });\n      return {\n        hasHookConflict: false,\n        hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true,\n      };\n    }\n\n    if (RunExpiredError.is(err)) {\n      runtimeLogger.info('Workflow run already completed, skipping hook', {\n        workflowRunId: runId,\n        message: err.message,\n      });\n      return {\n        hasHookConflict: false,\n        hasAwaitedHookCreation: false,\n      };\n    }\n\n    if (isWorldValidationFailure(err)) {\n      const fatal = new FatalError(\n        `createHook failed World validation: ${\n          err instanceof Error ? err.message : String(err)\n        }`\n      );\n      fatal.cause = err;\n      throw fatal;\n    }\n\n    throw err;\n  }\n}\n\n/**\n * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).\n * Creates events for all operations but does NOT queue step messages — returns the pending\n * steps so the caller can decide which to execute inline vs queue to background.\n *\n * Processing order:\n * 1. Hooks are processed first to prevent race conditions with webhook receivers\n * 2. Step events and wait events are created in parallel\n */\nexport async function handleSuspension({\n  suspension,\n  world,\n  run,\n  span,\n  requestId,\n  eventLog,\n  runReadyBarrier,\n  replayRecoveryReporter,\n  stepDispatch,\n}: SuspensionHandlerParams): Promise<SuspensionHandlerResult> {\n  const runId = run.runId;\n\n  // Turbo mode: hold every world write below until the backgrounded\n  // `run_started` has *settled*, so we never write a step/hook/wait event for a\n  // run that does not exist yet. A no-op outside turbo (barrier undefined) and\n  // on the pure inline hot path, which defers all steps and writes nothing.\n  // Awaiting the same (usually already-settled) promise more than once is cheap.\n  // A barrier rejection is swallowed for ordering only: if `run_started` truly\n  // failed the run does not exist, so the subsequent write surfaces the real\n  // error (run not found / gone) and the message redelivers.\n  const ensureRunReady = async (): Promise<void> => {\n    if (runReadyBarrier) {\n      try {\n        await runReadyBarrier;\n      } catch {\n        // intentional: ordering barrier only — see above.\n      }\n    }\n  };\n\n  /**\n   * Await every operation in a suspension phase before letting a failure\n   * escape, preferring a stale-snapshot (412) rejection when one occurred.\n   *\n   * `Promise.all` rejects as soon as one operation does and leaves its siblings\n   * in flight. That matters for a 412: the caller reacts by reloading the event\n   * log and restarting the replay, so a sibling create that lands after the\n   * rejection escaped commits an event whose correlation id came from the\n   * abandoned replay's seeded sequence — an event the fresh replay never\n   * produces — and it races the restart's reload while doing so. Settling first\n   * makes this phase's write set final before the caller acts on the failure.\n   * It mirrors the runtime's inline step claim, which settles the in-flight\n   * step executions before escalating a 412.\n   *\n   * A 412 is preferred over any other rejection in the same phase because it\n   * has a defined, cheap recovery (replay from a corrected log) while the\n   * others do not. A deterministic failure such as an attribute-validation\n   * `FatalError` recurs on the restart and fails the run then, at the cost of\n   * one extra replay.\n   */\n  const settlePhase = async (ops: Promise<unknown>[]): Promise<void> => {\n    const reasons = (await Promise.allSettled(ops))\n      .filter((r): r is PromiseRejectedResult => r.status === 'rejected')\n      .map((r) => r.reason);\n    if (reasons.length === 0) return;\n    throw reasons.find((r) => PreconditionFailedError.is(r)) ?? reasons[0];\n  };\n\n  // Every suspension write carries replay-recovery telemetry on the first one\n  // that commits after replay recovered. All suspension events are\n  // non-run_created events on this run's `runId`.\n  const reporter = replayRecoveryReporter ?? ReplayRecoveryReporter.inert();\n  const createEvent = (data: CreateEventRequest, params?: CreateEventParams) =>\n    reporter.withEventCreate(params, (p) =>\n      world.events.create(runId, data, p)\n    );\n  // Adds the optimistic-concurrency guard when the caller supplied a loaded\n  // event log; without one it creates directly (callers with no replay\n  // snapshot, e.g. tests). A stale (412) rejection propagates to the caller,\n  // which restarts the replay from a corrected log — it is not retried here,\n  // because the event's correlation id was minted by *this* replay's seeded\n  // sequence, so re-committing it against a corrected log would persist an\n  // event no correct replay produces.\n  let reportedEvents = 0;\n  const createGuarded: EventCreator = async (data, params) => {\n    if (!eventLog) {\n      return createEvent(data, params);\n    }\n    const log = eventLog;\n    const result = await createEvent(data, {\n      ...params,\n      ...slotSnapshotParams(log.events),\n    });\n    // Bump-and-report: the write landed above the slot it asked for, so the\n    // report holds the events it was decided without. Absorbing here rather\n    // than at each call site means the rest of this phase's writes — which read\n    // the same array to build their own snapshot — ask for a slot above them,\n    // and the replay that resumes from this log sees them without a reload.\n    const report = absorbSkippedSlotReport(log.events, result);\n    reportedEvents += report.added;\n    if (report.truncated) {\n      runtimeLogger.debug('Dropped a truncated skipped-slot report', {\n        workflowRunId: runId,\n        eventType: data.eventType,\n        eventId: result.event?.eventId,\n        offered: report.offered,\n      });\n    } else if (report.added > 0) {\n      runtimeLogger.debug('Suspension write skipped occupied slots', {\n        workflowRunId: runId,\n        eventType: data.eventType,\n        eventId: result.event?.eventId,\n        reported: report.added,\n      });\n    }\n    return result;\n  };\n  // Separate queue items by type\n  const stepItems = suspension.steps.filter(\n    (item): item is StepInvocationQueueItem => item.type === 'step'\n  );\n  const allHookItems = suspension.steps.filter(\n    (item): item is HookInvocationQueueItem => item.type === 'hook'\n  );\n  const waitItems = suspension.steps.filter(\n    (item): item is WaitInvocationQueueItem => item.type === 'wait'\n  );\n  const attributeItems = suspension.steps.filter(\n    (item): item is AttributeInvocationQueueItem => item.type === 'attribute'\n  );\n\n  const hooksNeedingCreation = allHookItems.filter(\n    (item) => !item.hasCreatedEvent\n  );\n\n  // Group hook items that need work by token, preserving queue-insertion\n  // (workflow code) order within each token. Operations on one token must\n  // apply in code order: a dispose() of an earlier hook releases the token\n  // before a later same-token hook's creation is validated — otherwise the\n  // new hook records a spurious hook_conflict against the run's own\n  // disposed hook — while a hook created and disposed within the same\n  // suspension is still created before it is disposed. Different tokens\n  // have no claim interaction, so token groups are processed in parallel.\n  const hookItemsByToken = new Map<string, HookInvocationQueueItem[]>();\n  for (const item of allHookItems) {\n    if (item.hasCreatedEvent && !item.disposed) {\n      continue; // already committed and still live — nothing to do\n    }\n    const group = hookItemsByToken.get(item.token);\n    if (group) {\n      group.push(item);\n    } else {\n      hookItemsByToken.set(item.token, [item]);\n    }\n  }\n\n  // Resolve encryption key for this run\n  const rawKey = await world.getEncryptionKeyForRun?.(run);\n  const encryptionKey = rawKey ? await importKey(rawKey) : undefined;\n\n  // Gate payload compression on the run's specVersion.\n  const compression =\n    (run.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION;\n\n  async function disposeHook(\n    queueItem: HookInvocationQueueItem\n  ): Promise<void> {\n    const hookDisposedEvent: CreateEventRequest = {\n      eventType: 'hook_disposed' as const,\n      specVersion: SPEC_VERSION_CURRENT,\n      correlationId: queueItem.correlationId,\n      eventData: {\n        token: queueItem.token,\n      },\n    };\n    try {\n      await createGuarded(hookDisposedEvent, { requestId });\n    } catch (err) {\n      if (EntityConflictError.is(err)) {\n        // Hook was already disposed by a concurrent invocation — safe to skip\n        runtimeLogger.info(\n          'Hook already disposed, skipping duplicate disposal',\n          {\n            workflowRunId: runId,\n            correlationId: queueItem.correlationId,\n            message: err.message,\n          }\n        );\n      } else if (RunExpiredError.is(err)) {\n        runtimeLogger.info(\n          'Workflow run already completed, skipping hook disposal',\n          {\n            workflowRunId: runId,\n            correlationId: queueItem.correlationId,\n            message: err.message,\n          }\n        );\n      } else if (HookNotFoundError.is(err)) {\n        // Hook may have already been disposed or never created\n        runtimeLogger.info('Hook not found for disposal, continuing', {\n          workflowRunId: runId,\n          correlationId: queueItem.correlationId,\n          message: err.message,\n        });\n      } else {\n        throw err;\n      }\n    }\n  }\n\n  // Process hooks first to prevent race conditions with webhook receivers.\n  // Track any hook conflicts that occur — these are returned to the caller\n  // so the V2 handler can re-invoke immediately.\n  let hasHookConflict = false;\n  let hasAwaitedHookCreation = false;\n  let hookCreationMs = 0;\n\n  if (hookItemsByToken.size > 0) {\n    const hookPhaseStart = Date.now();\n    await ensureRunReady();\n    await settlePhase(\n      [...hookItemsByToken.values()].map(async (items) => {\n        for (const queueItem of items) {\n          let creationConflicted = false;\n\n          if (!queueItem.hasCreatedEvent) {\n            const hookMetadata: SerializedData | undefined =\n              typeof queueItem.metadata === 'undefined'\n                ? undefined\n                : ((await dehydrateStepArguments(\n                    queueItem.metadata,\n                    runId,\n                    encryptionKey,\n                    suspension.globalThis,\n                    false,\n                    compression\n                  )) as SerializedData);\n            const hookEvent: CreateEventRequest = {\n              eventType: 'hook_created' as const,\n              specVersion: SPEC_VERSION_CURRENT,\n              correlationId: queueItem.correlationId,\n              eventData: {\n                token: queueItem.token,\n                tokenRetentionUntil: queueItem.tokenRetentionUntil,\n                metadata: hookMetadata,\n                isWebhook: queueItem.isWebhook ?? false,\n                ...(queueItem.isSystem && { isSystem: true }),\n              },\n            };\n            const result = await createHookEvent({\n              runId,\n              hookEvent,\n              queueItem,\n              requestId,\n              createEvent: createGuarded,\n            });\n            hasHookConflict ||= result.hasHookConflict;\n            hasAwaitedHookCreation ||= result.hasAwaitedHookCreation;\n            creationConflicted = result.hasHookConflict;\n          }\n\n          // Dispose after creation for hooks born and disposed within this\n          // batch. A hook whose creation conflicted was never created, so\n          // there is nothing to dispose.\n          if (queueItem.disposed && !creationConflicted) {\n            await disposeHook(queueItem);\n          }\n        }\n      })\n    );\n    hookCreationMs = Date.now() - hookPhaseStart;\n  }\n\n  // Process abort requests — resume the hook with abort payload and write stream packet\n  const hooksNeedingAbort = allHookItems.filter(\n    (item) => item.abortRequested && !item.disposed\n  );\n\n  if (hooksNeedingAbort.length > 0) {\n    await ensureRunReady();\n    await settlePhase(\n      hooksNeedingAbort.map(async (queueItem) => {\n        try {\n          // Dehydrate the abort payload for storage\n          const abortPayload = await dehydrateStepArguments(\n            { aborted: true, reason: queueItem.abortReason },\n            runId,\n            encryptionKey,\n            suspension.globalThis,\n            false,\n            compression\n          );\n\n          // Create hook_received event with abort payload\n          await createGuarded({\n            eventType: 'hook_received' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              token: queueItem.token,\n              payload: abortPayload,\n            },\n          });\n\n          // Write stream cancellation packet for real-time step propagation.\n          // Reuse the same dehydrated payload as the hook event so the reason\n          // round-trips through `dehydrateStepArguments` / `hydrateStepArguments`\n          // (handles DOMException, custom errors, encryption, etc.) instead of\n          // bare JSON.stringify which loses type information and drops undefined.\n          // streamName is set on the queue item at controller construction time\n          // (see workflow/abort-controller.ts).\n          try {\n            const streamName = getAbortStreamIdFromToken(queueItem.token);\n            await world.streams.write(\n              runId,\n              streamName,\n              abortPayload as Uint8Array\n            );\n            await world.streams.close(runId, streamName);\n          } catch {\n            // Best-effort stream write — hook event provides the durable fallback\n            runtimeLogger.debug(\n              'Failed to write abort stream packet, hook event will provide fallback',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n              }\n            );\n          }\n        } catch (err) {\n          if (EntityConflictError.is(err) || RunExpiredError.is(err)) {\n            runtimeLogger.info(\n              'Workflow run already completed, skipping abort',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else {\n            throw err;\n          }\n        }\n      })\n    );\n  }\n\n  // Create step events for steps that don't have them yet.\n  // Unlike V1, we do NOT queue step messages from here — the caller\n  // decides which steps to execute inline vs. queue to background.\n  // Wait events are also created in parallel below.\n  const stepsNeedingCreation = new Set(\n    stepItems\n      .filter((queueItem) => !queueItem.hasCreatedEvent)\n      .map((queueItem) => queueItem.correlationId)\n  );\n\n  // Correlation IDs for which THIS suspension call actually wrote the\n  // step_created event. Populated by the ops below after a successful\n  // events.create — used by the caller to claim ownership and avoid\n  // racing with concurrent handlers on step execution.\n  const createdStepCorrelationIds = new Set<string>();\n\n  // Serialization always runs through the one ordinary path below, so the\n  // durable bytes cannot depend on retention. What retention needs to know is\n  // whether that serialization *executed* workflow code (getters, proxy\n  // traps, custom serializers) — side effects a cold replay would not\n  // repeat, since a replay skips dehydration for already-recorded steps.\n  // The hardened serializer records exactly that into this sink (see\n  // ../serialization/hardened.ts); when any input in the batch records an\n  // execution, the caller demotes the session so the side effects land in a\n  // VM that is about to be discarded, exactly like the pre-retention\n  // runtime.\n  const guestCodeStats: GuestCodeStats = { executions: [] };\n\n  // Lazy inline start: defer the step_created write for up to\n  // `getMaxInlineSteps()` steps the caller will run inline (in parallel). Each\n  // step is created on the fly by the lazy `step_started` executeStep sends\n  // (saving a round-trip per step). We never defer when a `hook.getConflict()`\n  // awaiter is present, because in that case the caller executes nothing inline\n  // (it re-invokes immediately to resolve the awaiter), so deferring would\n  // leave the steps uncreated and unqueued. We pick the first N uncreated steps\n  // — matching the caller's inline-candidate selection — and dehydrate their\n  // input here so executeStep can ship it as the step_started payload.\n  const lazyInlineCorrelationIds = new Set<string>(\n    hasAwaitedHookCreation === false\n      ? stepItems\n          .filter((item) => stepsNeedingCreation.has(item.correlationId))\n          .slice(0, getMaxInlineSteps())\n          .map((item) => item.correlationId)\n      : []\n  );\n  // Collected by correlationId because the per-step ops below run concurrently\n  // and settle out of order. We rebuild the array in deterministic\n  // `lazyInlineCorrelationIds` order (the ordered slice above) after the ops\n  // settle, so the inline batch order is stable regardless of dehydration timing.\n  const lazyInlineByCorrelationId = new Map<\n    string,\n    SuspensionHandlerResult['lazyInlineSteps'][number]\n  >();\n\n  const ops: Promise<void>[] = [];\n\n  // Correlation IDs of steps whose step-execution queue message was already\n  // published by the resilient-dispatch ops below (alongside the step_created\n  // write). Reported to the caller so its dispatch pass skips them.\n  const queuedStepCorrelationIds = new Set<string>();\n\n  // Resilient step dispatch eligibility, shared by every step op below (the\n  // per-step input-size check is applied inside the op). All must hold:\n  //\n  //  - The caller provided a dispatch target (`stepDispatch`) — terminal\n  //    drains and other create-only callers never queue.\n  //  - The feature is enabled (`WORKFLOW_RESILIENT_STEP_DISPATCH` opt-in).\n  //    It is off by default because the publish races the create's verdict,\n  //    and a create can come back refused: as a duplicate the replay should\n  //    stop pursuing, or — on a World that would rather refuse a stale write\n  //    than report what it missed — as a 412. Either way the queue message\n  //    carrying the payload is already out, and the consumer can materialize a\n  //    step whose create was refused. Nothing orders that verdict before the\n  //    consumer's redelivery re-ensure, so no backend-side revocation\n  //    bookkeeping can close the window: a best-effort marker that fails open\n  //    cannot carry a correctness property. The sequential path is the only\n  //    thing that gives the message a happens-after edge over the verdict.\n  //  - The run's queue transport preserves binary payloads (CBOR,\n  //    specVersion >= 3): `stepInput.input` is the serialized (possibly\n  //    encrypted) input bytes, which the JSON transport would mangle.\n  const resilientDispatchEligible =\n    stepDispatch !== undefined &&\n    isResilientStepDispatchEnabled() &&\n    (run.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT;\n\n  // The trace carrier for resilient step dispatches, resolved at most once per\n  // suspension (the per-step ops run concurrently and share it).\n  let stepDispatchTraceCarrier: Promise<TraceCarrier> | undefined;\n  const getStepDispatchTraceCarrier = (): Promise<TraceCarrier> => {\n    stepDispatchTraceCarrier ??=\n      stepDispatch?.getTraceCarrier() ?? Promise.resolve({});\n    return stepDispatchTraceCarrier;\n  };\n\n  // Producer-side resilient recovery count for the suspension span attribute.\n  let resilientDispatchRecovered = 0;\n\n  // Steps: create step_created events (no queuing — V2 returns pending steps\n  // to caller — EXCEPT on the resilient dispatch path, which parallelizes the\n  // create with the step's queue publish and reports it in\n  // `queuedStepCorrelationIds`).\n  for (const queueItem of stepItems) {\n    if (stepsNeedingCreation.has(queueItem.correlationId)) {\n      ops.push(\n        (async () => {\n          // Per-step sink, merged below: the dehydrate wrapper emits span\n          // attributes from the sink it is handed, so sharing one across\n          // steps would re-emit (and misattribute) earlier steps' entries.\n          const stepGuestCode: GuestCodeStats = { executions: [] };\n          const dehydratedInput = await dehydrateStepArguments(\n            {\n              args: queueItem.args,\n              closureVars: queueItem.closureVars,\n              thisVal: queueItem.thisVal,\n            },\n            runId,\n            encryptionKey,\n            suspension.globalThis,\n            false,\n            compression,\n            stepGuestCode\n          );\n          guestCodeStats.executions.push(...stepGuestCode.executions);\n          // Deferred (lazy) inline step: skip the step_created write — the\n          // caller's inline executeStep will send a lazy step_started carrying\n          // this input, and the world creates the step (entity + synthetic\n          // step_created event) atomically. We do NOT add it to\n          // createdStepCorrelationIds; ownership is decided by that lazy\n          // step_started's atomic create-claim instead.\n          if (lazyInlineCorrelationIds.has(queueItem.correlationId)) {\n            lazyInlineByCorrelationId.set(queueItem.correlationId, {\n              correlationId: queueItem.correlationId,\n              stepName: queueItem.stepName,\n              dehydratedInput: dehydratedInput as SerializedData,\n            });\n            return;\n          }\n          const stepEvent: CreateEventRequest = {\n            eventType: 'step_created' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              stepName: queueItem.stepName,\n              workflowName: run.workflowName,\n              input: dehydratedInput as SerializedData,\n            },\n          };\n\n          // Resilient step dispatch: fire the step_created write and the\n          // step-execution queue publish in parallel — the message carries the\n          // same serialized input (`stepInput`) so the consumer can\n          // idempotently re-ensure the event if the direct write failed\n          // transiently. Mirrors the resilient start (`runInput`) and\n          // resilient hook resume (`hookInput`) patterns. Only for inputs the\n          // queue message can safely carry (binary, under the VQS size cap).\n          if (\n            resilientDispatchEligible &&\n            dehydratedInput instanceof Uint8Array &&\n            dehydratedInput.byteLength <= MAX_RESILIENT_STEP_INPUT_BYTES\n          ) {\n            await ensureRunReady();\n            const traceCarrier = await getStepDispatchTraceCarrier();\n            const [createResult, queueResult] = await Promise.allSettled([\n              createGuarded(stepEvent, { requestId }),\n              queueMessage(\n                world,\n                // biome-ignore lint/style/noNonNullAssertion: implied by resilientDispatchEligible\n                stepDispatch!.queueName,\n                {\n                  runId,\n                  stepId: queueItem.correlationId,\n                  stepName: queueItem.stepName,\n                  traceCarrier,\n                  requestedAt: new Date(),\n                  stepInput: { input: dehydratedInput },\n                },\n                // Same key as the caller's dispatch pass and any concurrent\n                // handler's — redundant publishes for this step dedupe. The\n                // key is step-identity-scoped so a revoked message for a\n                // reassigned correlation id cannot absorb the corrected\n                // schedule's dispatch — see stepDispatchIdempotencyKey.\n                {\n                  idempotencyKey: stepDispatchIdempotencyKey(\n                    queueItem.correlationId,\n                    queueItem.stepName\n                  ),\n                }\n              ),\n            ]);\n            // Queue failure is always fatal for this suspension pass: without\n            // the message the step would rely on the create alone, and if the\n            // create ALSO failed there would be no durable record at all.\n            // Propagating redelivers the orchestrator message, which\n            // re-creates the (idempotent) step_created and re-dispatches —\n            // the same recovery as the sequential path.\n            if (queueResult.status === 'rejected') {\n              throw queueResult.reason;\n            }\n            queuedStepCorrelationIds.add(queueItem.correlationId);\n            if (createResult.status === 'rejected') {\n              const err = createResult.reason;\n              if (EntityConflictError.is(err)) {\n                // Concurrent handler wrote it first — same as the sequential\n                // path. The step message is already out; a duplicate publish\n                // by that handler dedupes on the shared idempotency key.\n                runtimeLogger.info('Step already exists, continuing', {\n                  workflowRunId: runId,\n                  correlationId: queueItem.correlationId,\n                  message: err.message,\n                });\n              } else if (isRetryableWorldError(err)) {\n                // Resilient: the write failed transiently (429 / 5xx /\n                // transport) but the step message — carrying the same\n                // serialized input — was published, so the consumer\n                // idempotently re-ensures the step_created before executing.\n                resilientDispatchRecovered++;\n                runtimeLogger.warn(\n                  'Step creation event write failed, but the step was ' +\n                    'dispatched via the queue. The step_created event will ' +\n                    'be ensured by the queue consumer.',\n                  {\n                    workflowRunId: runId,\n                    correlationId: queueItem.correlationId,\n                    stepName: queueItem.stepName,\n                    error: err instanceof Error ? err.message : String(err),\n                  }\n                );\n              } else {\n                throw err;\n              }\n            } else {\n              createdStepCorrelationIds.add(queueItem.correlationId);\n            }\n            return;\n          }\n\n          try {\n            await ensureRunReady();\n            await createGuarded(stepEvent, { requestId });\n            createdStepCorrelationIds.add(queueItem.correlationId);\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info('Step already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else {\n              throw err;\n            }\n          }\n        })()\n      );\n    }\n  }\n\n  // Create wait events (same as V1)\n  for (const queueItem of waitItems) {\n    if (!queueItem.hasCreatedEvent) {\n      ops.push(\n        (async () => {\n          const waitEvent: CreateEventRequest = {\n            eventType: 'wait_created' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              resumeAt: queueItem.resumeAt,\n            },\n          };\n          try {\n            await ensureRunReady();\n            await createGuarded(waitEvent, { requestId });\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info('Wait already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else {\n              throw err;\n            }\n          }\n        })()\n      );\n    }\n  }\n\n  for (const queueItem of attributeItems) {\n    ops.push(\n      (async () => {\n        try {\n          await ensureRunReady();\n          // Guarded like every other suspension write: an attr_set is a\n          // replay-derived event with a correlation id from this replay's\n          // seeded sequence, so it must not land on a log the replay never\n          // saw. Rejecting it is cheap — a run with attribute events already\n          // forces an in-process replay, so the restart costs the replay it\n          // was going to do anyway.\n          await createGuarded(\n            {\n              eventType: 'attr_set',\n              specVersion: SPEC_VERSION_CURRENT,\n              correlationId: queueItem.correlationId,\n              eventData: {\n                changes: queueItem.changes,\n                writer: { type: 'workflow' },\n                ...(queueItem.allowReservedAttributes\n                  ? { allowReservedAttributes: true }\n                  : {}),\n              },\n            },\n            { requestId }\n          );\n        } catch (err) {\n          if (EntityConflictError.is(err)) {\n            runtimeLogger.info(\n              'Workflow attribute event already exists, continuing',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else if (isWorldValidationFailure(err)) {\n            // Deterministic validation rejection from the World — e.g. the\n            // cumulative per-run attribute cap, which only the World can\n            // check against the run's existing attributes. Redelivering the\n            // orchestrator message replays the workflow into the exact same\n            // write and the exact same rejection, so retrying can never\n            // succeed. Surface it as a FatalError so the caller fails the\n            // run with a clear error instead of wedging it in redelivery.\n            const fatal = new FatalError(\n              `setAttributes failed World validation: ${\n                err instanceof Error ? err.message : String(err)\n              }`\n            );\n            fatal.cause = err;\n            throw fatal;\n          } else {\n            throw err;\n          }\n        }\n      })()\n    );\n  }\n\n  // Await the step_created / wait_created event creates before returning.\n  // The caller (workflowEntrypoint) only enqueues the step-dispatch queue\n  // messages AFTER handleSuspension resolves, and the queue handler acks\n  // the orchestrator message only after the caller resolves. So the step_created\n  // events must be durable here, and the dispatch sends must complete in the caller,\n  // all before ack. If the process crashes before this resolves, the orchestrator\n  // message is not acked and VQS redelivers, re-creates the (idempotent)\n  // step_created and re-dispatches, and recovers the run instead of orphaning it.\n  await settlePhase(ops);\n\n  // The step-input dehydrations above have settled, so the sink is final.\n  const retainedStepInputsSafe = guestCodeStats.executions.length === 0;\n  if (!retainedStepInputsSafe) {\n    runtimeLogger.debug(\n      'Serializing step inputs executed workflow code; falling back to replay instead of retaining the VM',\n      {\n        workflowRunId: runId,\n        executions: guestCodeStats.executions\n          .slice(0, 5)\n          .map((e) => (e.detail ? `${e.kind}(${e.detail})` : e.kind)),\n      }\n    );\n  }\n\n  // Rebuild the inline batch in deterministic order. `lazyInlineCorrelationIds`\n  // is a Set seeded from the ordered first-N slice, so iterating it preserves\n  // stepItems order; every id in it was set by the lazy branch above.\n  const lazyInlineSteps: SuspensionHandlerResult['lazyInlineSteps'] = [];\n  for (const correlationId of lazyInlineCorrelationIds) {\n    const lazyStep = lazyInlineByCorrelationId.get(correlationId);\n    if (lazyStep) lazyInlineSteps.push(lazyStep);\n  }\n\n  // Find the soonest pending wait (minimum timeout)\n  const now = Date.now();\n  let soonestWait: { seconds: number; correlationId: string } | undefined;\n  for (const queueItem of waitItems) {\n    const resumeAtMs = queueItem.resumeAt.getTime();\n    const delayMs = Math.max(1000, resumeAtMs - now);\n    const timeoutSeconds = Math.ceil(delayMs / 1000);\n    if (!soonestWait || timeoutSeconds < soonestWait.seconds) {\n      soonestWait = {\n        seconds: timeoutSeconds,\n        correlationId: queueItem.correlationId,\n      };\n    }\n  }\n\n  span?.setAttributes({\n    ...Attribute.WorkflowRunStatus('workflow_suspended'),\n    ...Attribute.WorkflowStepsCreated(stepItems.length),\n    ...Attribute.WorkflowHooksCreated(hooksNeedingCreation.length),\n    ...Attribute.WorkflowWaitsCreated(waitItems.length),\n    ...(resilientDispatchRecovered > 0\n      ? Attribute.StepResilientDispatchRecovered(resilientDispatchRecovered)\n      : {}),\n  });\n\n  return {\n    pendingSteps: stepItems,\n    createdStepCorrelationIds,\n    queuedStepCorrelationIds,\n    lazyInlineSteps,\n    // On hook conflict the caller re-invokes immediately and never reads\n    // the wait timeout, so don't report one.\n    waitTimeout: hasHookConflict ? undefined : soonestWait,\n    hasHookConflict,\n    hasAwaitedHookCreation,\n    hasAttributeEvents: attributeItems.length > 0,\n    hasHookEvents: hooksNeedingCreation.length > 0,\n    hookCreationMs,\n    retainedStepInputsSafe,\n    reportedEventCount: reportedEvents,\n  };\n}\n\n/**\n * Whether an `events.create` rejection is deterministic World validation\n * rather than a transient/storage error. Local Worlds\n * (world-local, world-postgres) throw `AttributeValidationError` directly;\n * remote Worlds surface the equivalent server-side rejection as a\n * `WorkflowWorldError` with HTTP status 400. The name check covers\n * `AttributeValidationError` instances from a different copy of\n * `@workflow/world` than the one this package resolved.\n */\nfunction isWorldValidationFailure(err: unknown): boolean {\n  if (err instanceof AttributeValidationError) return true;\n  if (err instanceof Error && err.name === 'AttributeValidationError') {\n    return true;\n  }\n  return WorkflowWorldError.is(err) && err.status === 400;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"suspension-handler.js","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Span } from '@opentelemetry/api';\nimport {\n  EntityConflictError,\n  FatalError,\n  HookNotFoundError,\n  PreconditionFailedError,\n  RunExpiredError,\n  SerializationError,\n  WorkflowWorldError,\n} from '@workflow/errors';\nimport {\n  AttributeValidationError,\n  type CreateEventParams,\n  type CreateEventRequest,\n  type EventResult,\n  type SerializedData,\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT,\n  SPEC_VERSION_SUPPORTS_COMPRESSION,\n  SPEC_VERSION_SUPPORTS_SLOT_IDENTITY,\n  type StartedStep,\n  type TraceCarrier,\n  type ValidQueueName,\n  type WorkflowRun,\n  type World,\n} from '@workflow/world';\nimport { isRetryableWorldError } from '../classify-error.js';\nimport { importKey } from '../encryption.js';\nimport type {\n  AttributeInvocationQueueItem,\n  HookInvocationQueueItem,\n  StepInvocationQueueItem,\n  WaitInvocationQueueItem,\n  WorkflowSuspension,\n} from '../global.js';\nimport { runtimeLogger } from '../logger.js';\nimport type { GuestCodeStats } from '../serialization/hardened.js';\nimport {\n  dehydrateStepArguments,\n  dehydrateStepError,\n} from '../serialization.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { getAbortStreamIdFromToken } from '../util.js';\nimport { COMPUTE_INSTANCE_ID } from './compute-instance.js';\nimport {\n  getMaxInlineSteps,\n  isBatchTransitionsEnabled,\n  isResilientStepDispatchEnabled,\n  MAX_BATCH_FANOUT_EVENTS,\n  MAX_RESILIENT_STEP_INPUT_BYTES,\n} from './constants.js';\nimport {\n  absorbSkippedSlotReport,\n  type EventCreator,\n  type LoadedEventLog,\n  maxEventSlot,\n  queueMessage,\n  slotSnapshotParams,\n  stepDispatchIdempotencyKey,\n} from './helpers.js';\nimport { ReplayRecoveryReporter } from './replay-recovery-reporter.js';\nimport type { PreclaimedInlineStart } from './step-executor.js';\nimport { unserializableStepInputPlaceholder } from './unserializable-step.js';\n\nexport interface SuspensionHandlerParams {\n  suspension: WorkflowSuspension;\n  world: World;\n  run: WorkflowRun;\n  span?: Span;\n  requestId?: string;\n  /**\n   * The runtime's loaded event log. Every event creation this suspension makes\n   * names the position it was derived from, so a backend that has recorded\n   * events the replay did not see can report them back on the write, or, if\n   * it would rather refuse than report, reject it with a 412. A rejection is\n   * not retried here: the event's correlation id was minted by *this* replay's\n   * seeded sequence, so re-committing it against a corrected log would persist\n   * an event no correct replay produces. The caller restarts the replay\n   * instead.\n   */\n  eventLog?: LoadedEventLog;\n  /**\n   * Turbo mode only: a promise that resolves once the backgrounded\n   * `run_started` has landed (the run exists). When present, every world write\n   * this suspension performs (`hook_created`, `wait_created`, eager overflow\n   * `step_created`, …) is gated on it so the write never races ahead of the\n   * run's creation. The pure inline hot path defers all of its steps and writes\n   * nothing here, so it never awaits this barrier. `undefined` outside turbo,\n   * where `run_started` was already awaited up front.\n   */\n  runReadyBarrier?: Promise<unknown>;\n  /** One-shot telemetry reporter, activated only after replay has recovered. */\n  replayRecoveryReporter?: ReplayRecoveryReporter;\n  /**\n   * Resilient step dispatch: when provided (and the per-step eligibility gates\n   * pass, see the step ops below), each newly created non-inline step's\n   * `step_created` write is parallelized with its step-execution queue\n   * publish, and the queue message carries the serialized step input\n   * (`stepInput`) so the consumer can idempotently re-ensure the event if the\n   * direct write failed transiently. Steps queued this way are reported in\n   * {@link SuspensionHandlerResult.queuedStepCorrelationIds} so the caller\n   * skips them in its own dispatch pass. Omitted by callers that must not\n   * queue (terminal drain, tests); creates then behave exactly as before.\n   */\n  stepDispatch?: {\n    /** The unified workflow queue this run's step messages are published to. */\n    queueName: ValidQueueName;\n    /**\n     * Lazily resolves the trace carrier to stamp on the step messages.\n     * Called at most once per suspension (memoized here).\n     */\n    getTraceCarrier: () => Promise<TraceCarrier>;\n  };\n  /**\n   * Inline step ownership: the queue message ID of the invocation this\n   * suspension runs in (the queue handler's meta). When present AND the\n   * batched fan-out engages, the lazy-inline steps' deferred writes are\n   * folded into the batch as `step_created` + `step_started` pairs (the\n   * started row stamped with this ID, exactly like the lazy claim it\n   * replaces), pre-claiming the steps the caller is about to run inline. See\n   * {@link SuspensionHandlerResult.inlineClaims}. Callers that never\n   * inline-execute (terminal drain) omit it, keeping their lazy steps on the\n   * plain deferred path.\n   */\n  ownerMessageId?: string;\n  /**\n   * Lets the batched fan-out return before every chunk has committed: only\n   * the chunk carrying the pre-claimed inline pairs gates the handler's\n   * return (its claims are what the caller starts bodies from), while the\n   * trailing chunks' commits (and every chunk's in-flush step-message\n   * publishes) ride {@link SuspensionHandlerResult.deferredBatchWork}. A\n   * caller that opts in MUST await that promise before acking its delivery:\n   * the durability contract (\"every create durable before ack\") moves from\n   * the handler's return to that join, and nothing else re-drives a lost\n   * trailing chunk. Callers that don't opt in (terminal drain, default)\n   * keep the everything-durable-at-return behavior.\n   */\n  allowDeferredBatchWork?: boolean;\n}\n\n/**\n * Result of handling a suspension. Returns pending step items so the caller\n * can decide which to execute inline vs queue to background.\n */\nexport interface SuspensionHandlerResult {\n  /** Pending step items with events created but NOT queued */\n  pendingSteps: StepInvocationQueueItem[];\n  /**\n   * Correlation IDs for which this suspension call actually wrote the\n   * step_created event (as opposed to catching EntityConflictError because\n   * a concurrent handler wrote it first). Only the handler that wrote the\n   * step_created event should queue / inline-execute the step; this\n   * guarantees a single owner per step, even when multiple handlers race\n   * into the same batch boundary.\n   */\n  createdStepCorrelationIds: Set<string>;\n  /**\n   * Correlation IDs of steps whose arguments failed to serialize. Each was\n   * finalized here as `step_created` (with a placeholder input; the real\n   * input is precisely what refused to serialize) followed by `step_failed`\n   * carrying the SerializationError, so the next replay rejects the step's\n   * promise and a try/catch around the step call observes the error,\n   * exactly like a step-body failure. No step-execution message is\n   * dispatched for these, so the caller MUST force an in-process replay:\n   * when the failed step was the only pending work, nothing else will ever\n   * re-invoke the run to observe the terminal event.\n   */\n  failedStepCorrelationIds: Set<string>;\n  /**\n   * Correlation IDs of steps this suspension call already published\n   * step-execution queue messages for, via resilient step dispatch (the\n   * `step_created` write parallelized with a `stepInput`-carrying queue\n   * publish). The caller MUST NOT dispatch these again: the message is\n   * already out (a duplicate would be deduped by its idempotency key, but\n   * costs a wasted round-trip). Empty when {@link SuspensionHandlerParams.stepDispatch}\n   * was not provided or no step was eligible.\n   */\n  queuedStepCorrelationIds: Set<string>;\n  /**\n   * How many events this phase's writes reported back as occupying slots they\n   * skipped over, already merged into the caller's `eventLog.events`. Nonzero\n   * means the array was reordered to restore slot order, so any index the\n   * caller cached into it (payload prewarm scan position) is stale.\n   */\n  reportedEventCount: number;\n  /**\n   * The steps whose `step_created` writes were intentionally deferred so the\n   * caller can run them inline via lazy `step_started` events (which create\n   * the step on the fly), saving one world round-trip per inline step. Up to\n   * `getMaxInlineSteps()` steps are deferred; the caller runs them inline in\n   * parallel and queues the rest. Empty when no step was deferred (nothing\n   * pending, or a `hook.getConflict()` awaiter is present so nothing is\n   * executed inline). The caller passes each `dehydratedInput` straight to\n   * `executeStep`, which sends it as the `step_started` payload. The atomic\n   * create-claim inside each `step_started` is the exactly-one-owner gate that\n   * the standalone `step_created` provided before: the loser of the race gets\n   * `EntityConflictError` → `skipped` and does not run the body.\n   */\n  lazyInlineSteps: Array<{\n    correlationId: string;\n    stepName: string;\n    dehydratedInput: SerializedData;\n  }>;\n  /**\n   * Pre-claimed inline starts, by correlation id: the per-step verdicts of\n   * the `step_created` + `step_started` pairs the batched fan-out committed\n   * for the lazy-inline steps. A step with an entry here is passed to\n   * `executeStep` as `preclaimedStart` INSTEAD of `lazyStepInput`: its\n   * input already rode the pair, and the claim is settled: `owned: true`\n   * carries the started attempt-1 entity (input re-attached) so the body\n   * runs straight off the batch commit with no start write of its own;\n   * `owned: false` lost the pair's atomic create-claim to a concurrent\n   * writer, and executeStep returns `skipped` without running the body,\n   * the same outcome as losing the lazy claim. Empty whenever the fold did\n   * not engage (batching off, no `ownerMessageId`, or the lone-inline case,\n   * which keeps the optimistic lazy path and its claim/body overlap).\n   *\n   * Crash window: the pair commits before the caller runs the body, so a\n   * crash between them leaves a started step stamped with this message's\n   * ID. Redelivery of the same message re-executes it via the owned-recovery\n   * path, the exact machinery the lazy claim's crash window already uses.\n   */\n  inlineClaims: Map<string, PreclaimedInlineStart>;\n  /**\n   * The highest slot the batched fan-out committed, when it ran. The batch's\n   * own events are not in the caller's loaded log (the next reload picks\n   * them up), so the caller folds this ceiling into the slot snapshot it\n   * hands the inline executions; otherwise every inline terminal write\n   * would name a pre-batch position and be answered with a skipped-slot\n   * report echoing the events this suspension just wrote. Under\n   * {@link SuspensionHandlerParams.allowDeferredBatchWork} this covers the\n   * chunks that had committed by the handler's return (always the pair\n   * chunk); a trailing chunk that commits later is echoed back on the\n   * terminal writes like any foreign event: reports the executor reads for\n   * position and discards.\n   *\n   * So the echo is only fully suppressed for a SINGLE-chunk fold. On a\n   * multi-chunk fan-out the bodies start off the pair chunk while trailing\n   * chunks are still in flight, and an inline terminal write issued in that\n   * window still names a position below them and still draws a report for\n   * their events. Bounded (trailing chunks only, large fan-outs only) and\n   * self-correcting on the next reload, and recorded so a report seen there\n   * reads as expected rather than as a bug.\n   */\n  batchCommittedSlotCeiling?: number;\n  /**\n   * The batched fan-out's deferred work, present only when the caller opted\n   * in via {@link SuspensionHandlerParams.allowDeferredBatchWork} and\n   * trailing work exists: the commits of every chunk except the pair chunk,\n   * plus every chunk's step-message publishes (each chained on ITS OWN\n   * chunk's commit, so publish-after-create holds per step). The caller\n   * MUST await it before acking: a rejection here is a failed suspension\n   * write and fails the delivery exactly as it would have at the handler's\n   * return. Steps whose messages this work publishes are already in\n   * {@link queuedStepCorrelationIds} at return time.\n   */\n  deferredBatchWork?: Promise<void>;\n  /**\n   * The soonest pending wait, if any: seconds until it elapses and the\n   * correlationId of the wait that produced that timeout. The\n   * correlationId seeds the idempotency key for the wait-continuation\n   * queue message so that repeated suspension passes over the same\n   * pending wait collapse into a single delayed continuation.\n   */\n  waitTimeout?: { seconds: number; correlationId: string };\n  /** Whether a hook conflict was detected (should re-invoke immediately) */\n  hasHookConflict: boolean;\n  /** Whether a `hook.getConflict()` awaiter needs the workflow to continue immediately */\n  hasAwaitedHookCreation: boolean;\n  /** Whether native workflow attribute events were written for replay. */\n  hasAttributeEvents: boolean;\n  /**\n   * Whether this suspension created any hook (`hook_created`) events. Unlike\n   * `hasHookConflict` / `hasAwaitedHookCreation`, this is true even for a plain\n   * fire-and-forget hook with no conflict and no awaiter. Turbo mode uses it to\n   * detect \"a hook was created this suspension\" and stop forcing optimistic\n   * inline start (a hook introduces later resume invocations that could race).\n   */\n  hasHookEvents: boolean;\n  /**\n   * Wall-clock ms spent committing this suspension's `hook_created` events\n   * (0 when it created none). The caller accumulates this across iterations\n   * and subtracts it from the TTFS latency measurement, so time spent\n   * durably creating the user's hooks doesn't count as runtime overhead.\n   */\n  hookCreationMs: number;\n  /**\n   * Whether serializing this suspension's new step inputs was passive (did\n   * not execute workflow-owned code such as getters, proxy traps, or custom\n   * serializers). `false` means the retained VM may have diverged from what\n   * a cold replay would compute, so the caller must demote to replay.\n   */\n  retainedStepInputsSafe: boolean;\n}\n\nasync function createHookEvent({\n  runId,\n  hookEvent,\n  queueItem,\n  requestId,\n  createEvent,\n}: {\n  runId: string;\n  hookEvent: CreateEventRequest;\n  queueItem: HookInvocationQueueItem;\n  requestId?: string;\n  createEvent: (\n    data: CreateEventRequest,\n    params?: CreateEventParams\n  ) => Promise<EventResult>;\n}): Promise<{\n  hasHookConflict: boolean;\n  hasAwaitedHookCreation: boolean;\n}> {\n  try {\n    const result = await createEvent(hookEvent, {\n      requestId,\n    });\n\n    // Check if the world returned a hook_conflict event instead of hook_created.\n    // The hook_conflict event is stored in the event log and will be replayed\n    // on the next workflow invocation, causing the hook's promise to reject.\n    if (result.event?.eventType === 'hook_conflict') {\n      return {\n        hasHookConflict: true,\n        hasAwaitedHookCreation: false,\n      };\n    }\n\n    return {\n      hasHookConflict: false,\n      hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true,\n    };\n  } catch (err) {\n    if (EntityConflictError.is(err)) {\n      runtimeLogger.info('Hook already exists, continuing', {\n        workflowRunId: runId,\n        message: err.message,\n      });\n      return {\n        hasHookConflict: false,\n        hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true,\n      };\n    }\n\n    if (RunExpiredError.is(err)) {\n      runtimeLogger.info('Workflow run already completed, skipping hook', {\n        workflowRunId: runId,\n        message: err.message,\n      });\n      return {\n        hasHookConflict: false,\n        hasAwaitedHookCreation: false,\n      };\n    }\n\n    if (isWorldValidationFailure(err)) {\n      const fatal = new FatalError(\n        `createHook failed World validation: ${\n          err instanceof Error ? err.message : String(err)\n        }`\n      );\n      fatal.cause = err;\n      throw fatal;\n    }\n\n    throw err;\n  }\n}\n\n/**\n * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).\n * Creates events for all operations but does NOT queue step messages; returns the pending\n * steps so the caller can decide which to execute inline vs queue to background.\n *\n * Processing order:\n * 1. Hooks are processed first to prevent race conditions with webhook receivers\n * 2. Step events and wait events are created in parallel\n */\nexport async function handleSuspension({\n  suspension,\n  world,\n  run,\n  span,\n  requestId,\n  eventLog,\n  runReadyBarrier,\n  replayRecoveryReporter,\n  stepDispatch,\n  ownerMessageId,\n  allowDeferredBatchWork,\n}: SuspensionHandlerParams): Promise<SuspensionHandlerResult> {\n  const runId = run.runId;\n\n  // Turbo mode: hold every world write below until the backgrounded\n  // `run_started` has *settled*, so we never write a step/hook/wait event for a\n  // run that does not exist yet. A no-op outside turbo (barrier undefined) and\n  // on the pure inline hot path, which defers all steps and writes nothing.\n  // Awaiting the same (usually already-settled) promise more than once is cheap.\n  // A barrier rejection is swallowed for ordering only: if `run_started` truly\n  // failed the run does not exist, so the subsequent write surfaces the real\n  // error (run not found / gone) and the message redelivers.\n  const ensureRunReady = async (): Promise<void> => {\n    if (runReadyBarrier) {\n      try {\n        await runReadyBarrier;\n      } catch {\n        // intentional: ordering barrier only, see above.\n      }\n    }\n  };\n\n  /**\n   * Await every operation in a suspension phase before letting a failure\n   * escape, preferring a stale-snapshot (412) rejection when one occurred.\n   *\n   * `Promise.all` rejects as soon as one operation does and leaves its siblings\n   * in flight. That matters for a 412: the caller reacts by reloading the event\n   * log and restarting the replay, so a sibling create that lands after the\n   * rejection escaped commits an event whose correlation id came from the\n   * abandoned replay's seeded sequence (an event the fresh replay never\n   * produces), and it races the restart's reload while doing so. Settling first\n   * makes this phase's write set final before the caller acts on the failure.\n   * It mirrors the runtime's inline step claim, which settles the in-flight\n   * step executions before escalating a 412.\n   *\n   * A 412 is preferred over any other rejection in the same phase because it\n   * has a defined, cheap recovery (replay from a corrected log) while the\n   * others do not. A deterministic failure such as an attribute-validation\n   * `FatalError` recurs on the restart and fails the run then, at the cost of\n   * one extra replay.\n   */\n  const settlePhase = async (ops: Promise<unknown>[]): Promise<void> => {\n    const reasons = (await Promise.allSettled(ops))\n      .filter((r): r is PromiseRejectedResult => r.status === 'rejected')\n      .map((r) => r.reason);\n    if (reasons.length === 0) return;\n    throw reasons.find((r) => PreconditionFailedError.is(r)) ?? reasons[0];\n  };\n\n  // Every suspension write carries replay-recovery telemetry on the first one\n  // that commits after replay recovered. All suspension events are\n  // non-run_created events on this run's `runId`.\n  const reporter = replayRecoveryReporter ?? ReplayRecoveryReporter.inert();\n  const createEvent = (data: CreateEventRequest, params?: CreateEventParams) =>\n    reporter.withEventCreate(params, (p) =>\n      world.events.create(runId, data, p)\n    );\n  // Adds the optimistic-concurrency guard when the caller supplied a loaded\n  // event log; without one it creates directly (callers with no replay\n  // snapshot, e.g. tests). A stale (412) rejection propagates to the caller,\n  // which restarts the replay from a corrected log. It is not retried here,\n  // because the event's correlation id was minted by *this* replay's seeded\n  // sequence, so re-committing it against a corrected log would persist an\n  // event no correct replay produces.\n  let reportedEvents = 0;\n  const createGuarded: EventCreator = async (data, params) => {\n    if (!eventLog) {\n      return createEvent(data, params);\n    }\n    const log = eventLog;\n    const result = await createEvent(data, {\n      ...params,\n      ...slotSnapshotParams(log.events),\n    });\n    // Bump-and-report: the write landed above the slot it asked for, so the\n    // report holds the events it was decided without. Absorbing here rather\n    // than at each call site means the rest of this phase's writes (which read\n    // the same array to build their own snapshot) ask for a slot above them,\n    // and the replay that resumes from this log sees them without a reload.\n    const report = absorbSkippedSlotReport(log.events, result);\n    reportedEvents += report.added;\n    if (report.truncated) {\n      runtimeLogger.debug('Dropped a truncated skipped-slot report', {\n        workflowRunId: runId,\n        eventType: data.eventType,\n        eventId: result.event?.eventId,\n        offered: report.offered,\n      });\n    } else if (report.added > 0) {\n      runtimeLogger.debug('Suspension write skipped occupied slots', {\n        workflowRunId: runId,\n        eventType: data.eventType,\n        eventId: result.event?.eventId,\n        reported: report.added,\n      });\n    }\n    return result;\n  };\n  // Separate queue items by type\n  const stepItems = suspension.steps.filter(\n    (item): item is StepInvocationQueueItem => item.type === 'step'\n  );\n  const allHookItems = suspension.steps.filter(\n    (item): item is HookInvocationQueueItem => item.type === 'hook'\n  );\n  const waitItems = suspension.steps.filter(\n    (item): item is WaitInvocationQueueItem => item.type === 'wait'\n  );\n  const attributeItems = suspension.steps.filter(\n    (item): item is AttributeInvocationQueueItem => item.type === 'attribute'\n  );\n\n  const hooksNeedingCreation = allHookItems.filter(\n    (item) => !item.hasCreatedEvent\n  );\n\n  // Group hook items that need work by token, preserving queue-insertion\n  // (workflow code) order within each token. Operations on one token must\n  // apply in code order: a dispose() of an earlier hook releases the token\n  // before a later same-token hook's creation is validated (otherwise the\n  // new hook records a spurious hook_conflict against the run's own\n  // disposed hook), while a hook created and disposed within the same\n  // suspension is still created before it is disposed. Different tokens\n  // have no claim interaction, so token groups are processed in parallel.\n  const hookItemsByToken = new Map<string, HookInvocationQueueItem[]>();\n  for (const item of allHookItems) {\n    if (item.hasCreatedEvent && !item.disposed) {\n      continue; // already committed and still live: nothing to do\n    }\n    const group = hookItemsByToken.get(item.token);\n    if (group) {\n      group.push(item);\n    } else {\n      hookItemsByToken.set(item.token, [item]);\n    }\n  }\n\n  // Resolve encryption key for this run\n  const rawKey = await world.getEncryptionKeyForRun?.(run);\n  const encryptionKey = rawKey ? await importKey(rawKey) : undefined;\n\n  // Gate payload compression on the run's specVersion.\n  const compression =\n    (run.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION;\n\n  async function disposeHook(\n    queueItem: HookInvocationQueueItem\n  ): Promise<void> {\n    const hookDisposedEvent: CreateEventRequest = {\n      eventType: 'hook_disposed' as const,\n      specVersion: SPEC_VERSION_CURRENT,\n      correlationId: queueItem.correlationId,\n      eventData: {\n        token: queueItem.token,\n      },\n    };\n    try {\n      await createGuarded(hookDisposedEvent, { requestId });\n    } catch (err) {\n      if (EntityConflictError.is(err)) {\n        // Hook was already disposed by a concurrent invocation, safe to skip\n        runtimeLogger.info(\n          'Hook already disposed, skipping duplicate disposal',\n          {\n            workflowRunId: runId,\n            correlationId: queueItem.correlationId,\n            message: err.message,\n          }\n        );\n      } else if (RunExpiredError.is(err)) {\n        runtimeLogger.info(\n          'Workflow run already completed, skipping hook disposal',\n          {\n            workflowRunId: runId,\n            correlationId: queueItem.correlationId,\n            message: err.message,\n          }\n        );\n      } else if (HookNotFoundError.is(err)) {\n        // Hook may have already been disposed or never created\n        runtimeLogger.info('Hook not found for disposal, continuing', {\n          workflowRunId: runId,\n          correlationId: queueItem.correlationId,\n          message: err.message,\n        });\n      } else {\n        throw err;\n      }\n    }\n  }\n\n  // Process hooks first to prevent race conditions with webhook receivers.\n  // Track any hook conflicts that occur: these are returned to the caller\n  // so the V2 handler can re-invoke immediately.\n  let hasHookConflict = false;\n  let hasAwaitedHookCreation = false;\n  let hookCreationMs = 0;\n\n  if (hookItemsByToken.size > 0) {\n    const hookPhaseStart = Date.now();\n    await ensureRunReady();\n    await settlePhase(\n      [...hookItemsByToken.values()].map(async (items) => {\n        for (const queueItem of items) {\n          let creationConflicted = false;\n\n          if (!queueItem.hasCreatedEvent) {\n            const hookMetadata: SerializedData | undefined =\n              typeof queueItem.metadata === 'undefined'\n                ? undefined\n                : ((await dehydrateStepArguments(\n                    queueItem.metadata,\n                    runId,\n                    encryptionKey,\n                    suspension.globalThis,\n                    false,\n                    compression\n                  )) as SerializedData);\n            const hookEvent: CreateEventRequest = {\n              eventType: 'hook_created' as const,\n              specVersion: SPEC_VERSION_CURRENT,\n              correlationId: queueItem.correlationId,\n              eventData: {\n                token: queueItem.token,\n                tokenRetentionUntil: queueItem.tokenRetentionUntil,\n                metadata: hookMetadata,\n                isWebhook: queueItem.isWebhook ?? false,\n                ...(queueItem.isSystem && { isSystem: true }),\n              },\n            };\n            const result = await createHookEvent({\n              runId,\n              hookEvent,\n              queueItem,\n              requestId,\n              createEvent: createGuarded,\n            });\n            hasHookConflict ||= result.hasHookConflict;\n            hasAwaitedHookCreation ||= result.hasAwaitedHookCreation;\n            creationConflicted = result.hasHookConflict;\n          }\n\n          // Dispose after creation for hooks born and disposed within this\n          // batch. A hook whose creation conflicted was never created, so\n          // there is nothing to dispose.\n          if (queueItem.disposed && !creationConflicted) {\n            await disposeHook(queueItem);\n          }\n        }\n      })\n    );\n    hookCreationMs = Date.now() - hookPhaseStart;\n  }\n\n  // Process abort requests: resume the hook with abort payload and write stream packet\n  const hooksNeedingAbort = allHookItems.filter(\n    (item) => item.abortRequested && !item.disposed\n  );\n\n  if (hooksNeedingAbort.length > 0) {\n    await ensureRunReady();\n    await settlePhase(\n      hooksNeedingAbort.map(async (queueItem) => {\n        try {\n          // Dehydrate the abort payload for storage\n          const abortPayload = await dehydrateStepArguments(\n            { aborted: true, reason: queueItem.abortReason },\n            runId,\n            encryptionKey,\n            suspension.globalThis,\n            false,\n            compression\n          );\n\n          // Create hook_received event with abort payload\n          await createGuarded({\n            eventType: 'hook_received' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              token: queueItem.token,\n              payload: abortPayload,\n            },\n          });\n\n          // Write stream cancellation packet for real-time step propagation.\n          // Reuse the same dehydrated payload as the hook event so the reason\n          // round-trips through `dehydrateStepArguments` / `hydrateStepArguments`\n          // (handles DOMException, custom errors, encryption, etc.) instead of\n          // bare JSON.stringify which loses type information and drops undefined.\n          // streamName is set on the queue item at controller construction time\n          // (see workflow/abort-controller.ts).\n          try {\n            const streamName = getAbortStreamIdFromToken(queueItem.token);\n            await world.streams.write(\n              runId,\n              streamName,\n              abortPayload as Uint8Array\n            );\n            await world.streams.close(runId, streamName);\n          } catch {\n            // Best-effort stream write: hook event provides the durable fallback\n            runtimeLogger.debug(\n              'Failed to write abort stream packet, hook event will provide fallback',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n              }\n            );\n          }\n        } catch (err) {\n          if (EntityConflictError.is(err) || RunExpiredError.is(err)) {\n            runtimeLogger.info(\n              'Workflow run already completed, skipping abort',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else {\n            throw err;\n          }\n        }\n      })\n    );\n  }\n\n  // Create step events for steps that don't have them yet.\n  // Unlike V1, we do NOT queue step messages from here: the caller\n  // decides which steps to execute inline vs. queue to background.\n  // Wait events are also created in parallel below.\n  const stepsNeedingCreation = new Set(\n    stepItems\n      .filter((queueItem) => !queueItem.hasCreatedEvent)\n      .map((queueItem) => queueItem.correlationId)\n  );\n\n  // Correlation IDs for which THIS suspension call actually wrote the\n  // step_created event. Populated by the ops below after a successful\n  // events.create, used by the caller to claim ownership and avoid\n  // racing with concurrent handlers on step execution.\n  const createdStepCorrelationIds = new Set<string>();\n\n  // Correlation IDs of steps finalized as failed because their arguments\n  // refused to serialize: see finalizeUnserializableStep below.\n  const failedStepCorrelationIds = new Set<string>();\n\n  /**\n   * A step whose arguments fail to serialize is deterministic: every replay\n   * re-derives the same unserializable value, so redelivering the\n   * orchestrator message can never succeed. Instead of rejecting the whole\n   * suspension (which fails the run from the outside, where no user code can\n   * observe it), treat it exactly like a step-body failure: write\n   * `step_created` with a placeholder input (every World requires the step\n   * entity to exist before a terminal step event, and the real input is\n   * precisely what refused to serialize) followed by `step_failed` carrying\n   * the SerializationError. The next replay rejects the step's promise with\n   * it, so a try/catch around the step call observes the error; uncaught, it\n   * propagates out of the workflow body and fails the run as a USER_ERROR,\n   * without burning queue redeliveries either way.\n   */\n  const finalizeUnserializableStep = async (\n    queueItem: StepInvocationQueueItem,\n    error: SerializationError\n  ): Promise<void> => {\n    runtimeLogger.warn(\n      'Step arguments failed to serialize; failing the step so the ' +\n        'workflow can observe the error',\n      {\n        workflowRunId: runId,\n        correlationId: queueItem.correlationId,\n        stepName: queueItem.stepName,\n        error: error.message,\n      }\n    );\n    await ensureRunReady();\n    // Marker placeholder (not empty args): byte-identical-to-zero-args would\n    // make `workflow inspect steps` show \"no arguments\" for the one step\n    // whose entire problem was its arguments.\n    const placeholderInput = (await dehydrateStepArguments(\n      unserializableStepInputPlaceholder(),\n      runId,\n      encryptionKey,\n      suspension.globalThis,\n      false,\n      compression\n    )) as SerializedData;\n    try {\n      await createGuarded(\n        {\n          eventType: 'step_created' as const,\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: queueItem.correlationId,\n          eventData: {\n            stepName: queueItem.stepName,\n            workflowName: run.workflowName,\n            input: placeholderInput,\n          },\n        },\n        { requestId }\n      );\n    } catch (createErr) {\n      if (EntityConflictError.is(createErr)) {\n        // A concurrent handler already created the step: the failure is\n        // deterministic, so it is racing toward the same step_failed below.\n        runtimeLogger.info('Step already exists, continuing', {\n          workflowRunId: runId,\n          correlationId: queueItem.correlationId,\n          message: createErr.message,\n        });\n      } else if (RunExpiredError.is(createErr)) {\n        // Run already finished: nothing to observe the failure.\n        return;\n      } else {\n        throw createErr;\n      }\n    }\n    try {\n      await createGuarded(\n        {\n          eventType: 'step_failed' as const,\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: queueItem.correlationId,\n          eventData: {\n            stepName: queueItem.stepName,\n            // The error itself is a plain WorkflowError (name, message with\n            // framed hint, cause chain), serializable even though the step\n            // input was not. Error detection is realm-independent\n            // (types.isNativeError), so the host-created error serializes\n            // the same under either global; the VM global is passed for\n            // consistency with every other dehydration in this file and so\n            // any VM-realm values guest code threw into the cause chain\n            // (getters/proxies executed during the failed dehydration) are\n            // detected by the realm-sensitive reducers.\n            error: await dehydrateStepError(\n              error,\n              runId,\n              encryptionKey,\n              [],\n              suspension.globalThis,\n              compression\n            ),\n          },\n        },\n        { requestId }\n      );\n    } catch (failErr) {\n      if (EntityConflictError.is(failErr) || RunExpiredError.is(failErr)) {\n        // Step already terminal (a concurrent handler wrote the same\n        // deterministic failure) or the run already finished.\n        runtimeLogger.info(\n          'Tried failing step, but step or run has already finished.',\n          {\n            workflowRunId: runId,\n            correlationId: queueItem.correlationId,\n            message: failErr.message,\n          }\n        );\n      } else {\n        throw failErr;\n      }\n    }\n    failedStepCorrelationIds.add(queueItem.correlationId);\n    // Release the inline slot bookkeeping: the step never runs, so it must\n    // not appear in the rebuilt `lazyInlineSteps`. (Its slot in the first-N\n    // selection and in `inlinePairFoldEligible`'s arithmetic was consumed\n    // before dehydration could reveal the failure, inherent to selecting\n    // before serializing, and bounded to one wasted slot on a pass that\n    // ends in a forced replay anyway.)\n    lazyInlineCorrelationIds.delete(queueItem.correlationId);\n  };\n\n  // Serialization always runs through the one ordinary path below, so the\n  // durable bytes cannot depend on retention. What retention needs to know is\n  // whether that serialization *executed* workflow code (getters, proxy\n  // traps, custom serializers): side effects a cold replay would not\n  // repeat, since a replay skips dehydration for already-recorded steps.\n  // The hardened serializer records exactly that into this sink (see\n  // ../serialization/hardened.ts); when any input in the batch records an\n  // execution, the caller demotes the session so the side effects land in a\n  // VM that is about to be discarded, exactly like the pre-retention\n  // runtime.\n  const guestCodeStats: GuestCodeStats = { executions: [] };\n\n  // Lazy inline start: defer the step_created write for up to\n  // `getMaxInlineSteps()` steps the caller will run inline (in parallel). Each\n  // step is created on the fly by the lazy `step_started` executeStep sends\n  // (saving a round-trip per step). We never defer when a `hook.getConflict()`\n  // awaiter is present, because in that case the caller executes nothing inline\n  // (it re-invokes immediately to resolve the awaiter), so deferring would\n  // leave the steps uncreated and unqueued. We pick the first N uncreated\n  // steps (matching the caller's inline-candidate selection) and dehydrate\n  // their input here so executeStep can ship it as the step_started payload.\n  const lazyInlineCorrelationIds = new Set<string>(\n    hasAwaitedHookCreation === false\n      ? stepItems\n          .filter((item) => stepsNeedingCreation.has(item.correlationId))\n          .slice(0, getMaxInlineSteps())\n          .map((item) => item.correlationId)\n      : []\n  );\n  // Collected by correlationId because the per-step ops below run concurrently\n  // and settle out of order. We rebuild the array in deterministic\n  // `lazyInlineCorrelationIds` order (the ordered slice above) after the ops\n  // settle, so the inline batch order is stable regardless of dehydration timing.\n  const lazyInlineByCorrelationId = new Map<\n    string,\n    SuspensionHandlerResult['lazyInlineSteps'][number]\n  >();\n\n  const ops: Promise<void>[] = [];\n\n  // Correlation IDs of steps whose step-execution queue message was already\n  // published by the resilient-dispatch ops below (alongside the step_created\n  // write). Reported to the caller so its dispatch pass skips them.\n  const queuedStepCorrelationIds = new Set<string>();\n\n  // Resilient step dispatch eligibility, shared by every step op below (the\n  // per-step input-size check is applied inside the op). All must hold:\n  //\n  //  - The caller provided a dispatch target (`stepDispatch`): terminal\n  //    drains and other create-only callers never queue.\n  //  - The feature is enabled (`WORKFLOW_RESILIENT_STEP_DISPATCH` opt-in).\n  //    It is off by default because the publish races the create's verdict,\n  //    and a create can come back refused: as a duplicate the replay should\n  //    stop pursuing, or (on a World that would rather refuse a stale write\n  //    than report what it missed) as a 412. Either way the queue message\n  //    carrying the payload is already out, and the consumer can materialize a\n  //    step whose create was refused. Nothing orders that verdict before the\n  //    consumer's redelivery re-ensure, so no backend-side revocation\n  //    bookkeeping can close the window: a best-effort marker that fails open\n  //    cannot carry a correctness property. The sequential path is the only\n  //    thing that gives the message a happens-after edge over the verdict.\n  //  - The run's queue transport preserves binary payloads (CBOR,\n  //    specVersion >= 3): `stepInput.input` is the serialized (possibly\n  //    encrypted) input bytes, which the JSON transport would mangle.\n  const resilientDispatchEligible =\n    stepDispatch !== undefined &&\n    isResilientStepDispatchEnabled() &&\n    (run.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT;\n\n  // Batched fan-out: fold this suspension's step_created + wait_created\n  // writes into one `events.createBatch` call (one durable write, per-event\n  // outcomes) instead of one write per event. Engages only for a CLEAN\n  // fan-out (no attribute writes, no hook writes, no resilient dispatch\n  // whose creates are each paired with a queue publish) on a World that\n  // implements the optional method and a run whose events are slot-numbered.\n  // Everything outside the gate keeps the single-event path byte-for-byte.\n  const batchFanoutEligible =\n    isBatchTransitionsEnabled() &&\n    typeof world.events.createBatch === 'function' &&\n    (run.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_SLOT_IDENTITY &&\n    !resilientDispatchEligible &&\n    allHookItems.length === 0 &&\n    attributeItems.length === 0;\n  /**\n   * The fold's collection, in scheduling order (steps in stepItems order,\n   * then waits). Step entries are enqueued by their prep promises (input\n   * dehydration runs concurrently, so entries are ordered by `order`, not by\n   * completion); the single flush op below awaits every prep, sorts, and\n   * commits the whole set through `createBatch`.\n   */\n  const batchQueue: {\n    order: number;\n    kind: 'step' | 'wait' | 'inline-created' | 'inline-started';\n    correlationId: string;\n    /** The step's name, set on step-carrying kinds (the in-flush publishes\n     *  and the dispatch idempotency key need it). */\n    stepName?: string;\n    event: CreateEventRequest;\n  }[] = [];\n  const batchPreps: Promise<void>[] = [];\n\n  // Pre-claimed inline pairs: fold each lazy-inline step's deferred\n  // `step_created` (carrying its input) AND its `step_started` claim (bare,\n  // ownership-stamped) into the batch, so the whole fan-out (the inline\n  // steps' claims included) commits in the one durable write and the caller\n  // starts the bodies straight off that commit instead of posting one claim\n  // per inline step. The lone-inline case (nothing else to batch with) is\n  // excluded: a pair-only batch costs the same round trip as the single lazy\n  // claim while giving up the optimistic claim/body overlap and the\n  // bump-and-report that `createGuarded` provides, so it stays on the lazy\n  // path. Requires the caller's `ownerMessageId`: the started row must\n  // stamp ownership exactly like the lazy claim it replaces (and a caller\n  // that does not inline-execute never provides one).\n  const uncreatedWaitCount = waitItems.filter(\n    (item) => !item.hasCreatedEvent\n  ).length;\n  const inlinePairFoldEligible =\n    batchFanoutEligible &&\n    ownerMessageId !== undefined &&\n    lazyInlineCorrelationIds.size > 0 &&\n    (lazyInlineCorrelationIds.size >= 2 ||\n      stepsNeedingCreation.size -\n        lazyInlineCorrelationIds.size +\n        uncreatedWaitCount >=\n        1);\n  const inlineClaims: SuspensionHandlerResult['inlineClaims'] = new Map();\n  let batchCommittedSlotCeiling: number | undefined;\n\n  // The trace carrier for resilient step dispatches, resolved at most once per\n  // suspension (the per-step ops run concurrently and share it).\n  let stepDispatchTraceCarrier: Promise<TraceCarrier> | undefined;\n  const getStepDispatchTraceCarrier = (): Promise<TraceCarrier> => {\n    stepDispatchTraceCarrier ??=\n      stepDispatch?.getTraceCarrier() ?? Promise.resolve({});\n    return stepDispatchTraceCarrier;\n  };\n\n  // Producer-side resilient recovery count for the suspension span attribute.\n  let resilientDispatchRecovered = 0;\n\n  // Steps: create step_created events (no queuing, V2 returns pending steps\n  // to caller, EXCEPT on the resilient dispatch path, which parallelizes the\n  // create with the step's queue publish and reports it in\n  // `queuedStepCorrelationIds`).\n  let batchOrderCounter = 0;\n  for (const queueItem of stepItems) {\n    if (stepsNeedingCreation.has(queueItem.correlationId)) {\n      // Deterministic position in the batched fold (assigned in stepItems\n      // order, before the concurrent dehydration runs). A pair-folded inline\n      // step occupies two consecutive positions (created row then started\n      // row), which the flush keeps adjacent and never splits across chunks,\n      // so a World can fold them into one born-running create.\n      const pairFolded =\n        inlinePairFoldEligible &&\n        lazyInlineCorrelationIds.has(queueItem.correlationId);\n      const stepOrder = batchOrderCounter;\n      batchOrderCounter += pairFolded ? 2 : 1;\n      const stepOp = (async () => {\n        // Per-step sink, merged below: the dehydrate wrapper emits span\n        // attributes from the sink it is handed, so sharing one across\n        // steps would re-emit (and misattribute) earlier steps' entries.\n        const stepGuestCode: GuestCodeStats = { executions: [] };\n        let dehydratedInput: Uint8Array | unknown;\n        try {\n          dehydratedInput = await dehydrateStepArguments(\n            {\n              args: queueItem.args,\n              closureVars: queueItem.closureVars,\n              thisVal: queueItem.thisVal,\n            },\n            runId,\n            encryptionKey,\n            suspension.globalThis,\n            false,\n            compression,\n            stepGuestCode\n          );\n        } catch (err) {\n          // The sink records executions as they happen, so guest code that\n          // ran before the failure still counts against retention.\n          guestCodeStats.executions.push(...stepGuestCode.executions);\n          if (!SerializationError.is(err)) {\n            // e.g. RuntimeDecryptionError: an SDK fault, not a user value\n            // problem. Keep its identity (RUNTIME_ERROR) and current\n            // fail-the-suspension behavior.\n            throw err;\n          }\n          if (!stepDispatch) {\n            // No dispatch target means no replay will observe a\n            // finalization: this is the terminal drain (or a create-only\n            // test caller). The run is already completing/failing, so\n            // writing step_created + step_failed here would leave e.g. a\n            // COMPLETED run carrying a failed step nothing can ever\n            // observe, reading as a bug from the dashboard. Rethrow\n            // instead; the drain's own catch swallows it, preserving its\n            // pre-existing behavior (no rows for the unawaited step).\n            throw err;\n          }\n          await finalizeUnserializableStep(queueItem, err);\n          return;\n        }\n        guestCodeStats.executions.push(...stepGuestCode.executions);\n        // Deferred (lazy) inline step: skip the step_created write; the\n        // caller's inline executeStep will send a lazy step_started carrying\n        // this input, and the world creates the step (entity + synthetic\n        // step_created event) atomically. We do NOT add it to\n        // createdStepCorrelationIds; ownership is decided by that lazy\n        // step_started's atomic create-claim instead.\n        if (lazyInlineCorrelationIds.has(queueItem.correlationId)) {\n          lazyInlineByCorrelationId.set(queueItem.correlationId, {\n            correlationId: queueItem.correlationId,\n            stepName: queueItem.stepName,\n            dehydratedInput: dehydratedInput as SerializedData,\n          });\n          if (pairFolded) {\n            // Enqueue the pair the deferral would otherwise leave to the\n            // caller's lazy `step_started`: the created row carries the\n            // input (payloads ride creates in a batch), the started row is\n            // bare and stamps this invocation's ownership, the same claim\n            // shape the lazy start would have sent, settled by the batch.\n            batchQueue.push({\n              order: stepOrder,\n              kind: 'inline-created',\n              correlationId: queueItem.correlationId,\n              event: {\n                eventType: 'step_created',\n                specVersion: SPEC_VERSION_CURRENT,\n                correlationId: queueItem.correlationId,\n                eventData: {\n                  stepName: queueItem.stepName,\n                  workflowName: run.workflowName,\n                  input: dehydratedInput as SerializedData,\n                },\n              },\n            });\n            batchQueue.push({\n              order: stepOrder + 1,\n              kind: 'inline-started',\n              correlationId: queueItem.correlationId,\n              event: {\n                eventType: 'step_started',\n                specVersion: SPEC_VERSION_CURRENT,\n                correlationId: queueItem.correlationId,\n                eventData: {\n                  stepName: queueItem.stepName,\n                  // Checked by inlinePairFoldEligible; spread keeps the\n                  // narrow-through-closure problem away from the type.\n                  ...(ownerMessageId !== undefined ? { ownerMessageId } : {}),\n                },\n              },\n            });\n          }\n          return;\n        }\n        const stepEvent: CreateEventRequest = {\n          eventType: 'step_created' as const,\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: queueItem.correlationId,\n          eventData: {\n            stepName: queueItem.stepName,\n            workflowName: run.workflowName,\n            input: dehydratedInput as SerializedData,\n          },\n        };\n\n        // Resilient step dispatch: fire the step_created write and the\n        // step-execution queue publish in parallel: the message carries the\n        // same serialized input (`stepInput`) so the consumer can\n        // idempotently re-ensure the event if the direct write failed\n        // transiently. Mirrors the resilient start (`runInput`) and\n        // resilient hook resume (`hookInput`) patterns. Only for inputs the\n        // queue message can safely carry (binary, under the VQS size cap).\n        if (\n          resilientDispatchEligible &&\n          dehydratedInput instanceof Uint8Array &&\n          dehydratedInput.byteLength <= MAX_RESILIENT_STEP_INPUT_BYTES\n        ) {\n          await ensureRunReady();\n          const traceCarrier = await getStepDispatchTraceCarrier();\n          const [createResult, queueResult] = await Promise.allSettled([\n            createGuarded(stepEvent, { requestId }),\n            queueMessage(\n              world,\n              // biome-ignore lint/style/noNonNullAssertion: implied by resilientDispatchEligible\n              stepDispatch!.queueName,\n              {\n                runId,\n                stepId: queueItem.correlationId,\n                stepName: queueItem.stepName,\n                traceCarrier,\n                requestedAt: new Date(),\n                stepInput: { input: dehydratedInput },\n              },\n              // Same key as the caller's dispatch pass and any concurrent\n              // handler's, so redundant publishes for this step dedupe. The\n              // key is step-identity-scoped so a revoked message for a\n              // reassigned correlation id cannot absorb the corrected\n              // schedule's dispatch: see stepDispatchIdempotencyKey.\n              {\n                idempotencyKey: stepDispatchIdempotencyKey(\n                  queueItem.correlationId,\n                  queueItem.stepName\n                ),\n              }\n            ),\n          ]);\n          // Queue failure is always fatal for this suspension pass: without\n          // the message the step would rely on the create alone, and if the\n          // create ALSO failed there would be no durable record at all.\n          // Propagating redelivers the orchestrator message, which\n          // re-creates the (idempotent) step_created and re-dispatches,\n          // the same recovery as the sequential path.\n          if (queueResult.status === 'rejected') {\n            throw queueResult.reason;\n          }\n          queuedStepCorrelationIds.add(queueItem.correlationId);\n          if (createResult.status === 'rejected') {\n            const err = createResult.reason;\n            if (EntityConflictError.is(err)) {\n              // Concurrent handler wrote it first, same as the sequential\n              // path. The step message is already out; a duplicate publish\n              // by that handler dedupes on the shared idempotency key.\n              runtimeLogger.info('Step already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else if (isRetryableWorldError(err)) {\n              // Resilient: the write failed transiently (429 / 5xx /\n              // transport) but the step message (carrying the same\n              // serialized input) was published, so the consumer\n              // idempotently re-ensures the step_created before executing.\n              resilientDispatchRecovered++;\n              runtimeLogger.warn(\n                'Step creation event write failed, but the step was ' +\n                  'dispatched via the queue. The step_created event will ' +\n                  'be ensured by the queue consumer.',\n                {\n                  workflowRunId: runId,\n                  correlationId: queueItem.correlationId,\n                  stepName: queueItem.stepName,\n                  error: err instanceof Error ? err.message : String(err),\n                }\n              );\n            } else {\n              throw err;\n            }\n          } else {\n            createdStepCorrelationIds.add(queueItem.correlationId);\n          }\n          return;\n        }\n\n        if (batchFanoutEligible) {\n          // Fold into the batch instead of writing here. The enclosing\n          // promise joins `batchPreps` (see the loop below), so the flush\n          // op cannot run before this step's input finished dehydrating.\n          batchQueue.push({\n            order: stepOrder,\n            kind: 'step',\n            correlationId: queueItem.correlationId,\n            stepName: queueItem.stepName,\n            event: stepEvent,\n          });\n          return;\n        }\n\n        try {\n          await ensureRunReady();\n          await createGuarded(stepEvent, { requestId });\n          createdStepCorrelationIds.add(queueItem.correlationId);\n        } catch (err) {\n          if (EntityConflictError.is(err)) {\n            runtimeLogger.info('Step already exists, continuing', {\n              workflowRunId: runId,\n              correlationId: queueItem.correlationId,\n              message: err.message,\n            });\n          } else {\n            throw err;\n          }\n        }\n      })();\n      ops.push(stepOp);\n      if (batchFanoutEligible) {\n        // The flush op waits for every prep before committing; a prep that\n        // rejected already surfaces through `ops`, so the flush's own wait\n        // swallows it and commits whatever was successfully enqueued,\n        // preserving today's per-op independence.\n        batchPreps.push(stepOp.catch(() => {}));\n      }\n    }\n  }\n\n  // Create wait events (same as V1)\n  for (const queueItem of waitItems) {\n    if (!queueItem.hasCreatedEvent) {\n      const waitEvent: CreateEventRequest = {\n        eventType: 'wait_created' as const,\n        specVersion: SPEC_VERSION_CURRENT,\n        correlationId: queueItem.correlationId,\n        eventData: {\n          resumeAt: queueItem.resumeAt,\n        },\n      };\n      if (batchFanoutEligible) {\n        // Waits need no dehydration, so they enqueue synchronously, after\n        // every step's order slot, preserving steps-then-waits scheduling\n        // order in the log.\n        batchQueue.push({\n          order: batchOrderCounter++,\n          kind: 'wait',\n          correlationId: queueItem.correlationId,\n          event: waitEvent,\n        });\n        continue;\n      }\n      ops.push(\n        (async () => {\n          try {\n            await ensureRunReady();\n            await createGuarded(waitEvent, { requestId });\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info('Wait already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else {\n              throw err;\n            }\n          }\n        })()\n      );\n    }\n  }\n\n  // The batched fold's flush: the clean fan-out commits through\n  // `createBatch` in chunks of MAX_BATCH_FANOUT_EVENTS, all chunks IN\n  // FLIGHT CONCURRENTLY. Slot assignment is the server's, so parallel\n  // chunks race for slot ranges exactly like the pre-fold path's parallel\n  // single writes did; entity conditions, not commit order, carry\n  // correctness (sibling fan-out events have no cross-order the replay\n  // depends on; it matches by correlation id). Each event reports the\n  // outcome its own single create would have had: a 409 is the same\n  // already-exists tolerance as the single path, anything else fails the\n  // delivery the way a single-path rejection would.\n  //\n  // Latency shape: only the chunk carrying the pre-claimed inline pairs\n  // gates the handler's return (the caller starts bodies off its claims).\n  // Every other chunk's commit (and every chunk's step-message publishes,\n  // which fire the moment ITS creates are durable) rides\n  // `deferredBatchWork` when the caller opted in, joined before ack. A slow\n  // sibling chunk therefore delays neither the inline bodies nor another\n  // chunk's queue messages, while publish-after-create still holds per\n  // step: a step's message is only ever sent after the chunk carrying its\n  // create has committed.\n  let deferredBatchWork: Promise<void> | undefined;\n  if (batchFanoutEligible) {\n    ops.push(\n      (async () => {\n        // Preps that rejected already surface through their own `ops`\n        // entries; the fold commits whatever was successfully enqueued,\n        // preserving today's per-op independence.\n        await Promise.all(batchPreps);\n        if (batchQueue.length === 0) {\n          return;\n        }\n        const entries = [...batchQueue].sort((a, b) => a.order - b.order);\n        await ensureRunReady();\n        // A batch of ONE gains nothing over the single write (same round\n        // trip) and loses the slot-snapshot params + bump-and-report that\n        // createGuarded provides, so a lone eager event takes the ordinary\n        // single path, with the same conflict tolerance and ownership\n        // bookkeeping it would have had without the fold.\n        if (entries.length === 1) {\n          const [entry] = entries;\n          try {\n            await createGuarded(entry.event, { requestId });\n            if (entry.kind === 'step') {\n              createdStepCorrelationIds.add(entry.correlationId);\n            }\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info(\n                entry.kind === 'step'\n                  ? 'Step already exists, continuing'\n                  : 'Wait already exists, continuing',\n                {\n                  workflowRunId: runId,\n                  correlationId: entry.correlationId,\n                  message: err.message,\n                }\n              );\n            } else {\n              throw err;\n            }\n          }\n          return;\n        }\n        // Seed for the foreign-interleaving diagnostic below. With chunks\n        // committing in parallel there is no per-chunk \"expected next slot\";\n        // the whole fold's committed span is compared against the seed\n        // once every chunk has settled: committed slots are dense per the\n        // World's invariant, so any excess of (max committed slot − seed +\n        // 1) over the fold's own committed count is events OTHER writers\n        // landed in between.\n        const expectedFirstSlot = eventLog\n          ? (maxEventSlot(eventLog.events) ?? 0) + 1\n          : undefined;\n        // Pair-aware chunking: a pre-claimed pair's two rows must land in\n        // the same createBatch call (adjacent, so a World can fold them\n        // into one born-running create) and never straddle a chunk\n        // boundary, which would turn the started row into a standalone\n        // claim racing its own create's commit.\n        const chunks: (typeof entries)[] = [];\n        {\n          let current: typeof entries = [];\n          for (let index = 0; index < entries.length; index++) {\n            const entry = entries[index];\n            const next = entries[index + 1];\n            const pairLead =\n              entry.kind === 'inline-created' &&\n              next?.kind === 'inline-started' &&\n              next.correlationId === entry.correlationId;\n            const take = pairLead ? 2 : 1;\n            if (\n              current.length > 0 &&\n              current.length + take > MAX_BATCH_FANOUT_EVENTS\n            ) {\n              chunks.push(current);\n              current = [];\n            }\n            current.push(entry);\n            if (pairLead) {\n              current.push(next);\n              index++;\n            }\n          }\n          if (current.length > 0) chunks.push(current);\n        }\n        // Steps whose queue messages THIS FLUSH will publish (the eager\n        // creates), recorded before any chunk settles so the caller's\n        // dispatch pass (which runs off the handler's return) skips them.\n        // The sends are guaranteed-or-failed by the trailing work the\n        // caller joins before acking, so \"will be published by this flush\"\n        // and \"already published\" are equivalent from the caller's side.\n        const publishEagerSteps = stepDispatch !== undefined;\n        if (publishEagerSteps) {\n          for (const entry of entries) {\n            if (entry.kind === 'step') {\n              queuedStepCorrelationIds.add(entry.correlationId);\n            }\n          }\n        }\n\n        // Tallies for the foreign-interleaving diagnostic, folded across\n        // the concurrent chunks and read once all of them settled.\n        let committedCount = 0;\n        let maxCommittedSlot: number | undefined;\n\n        const commitChunk = async (chunk: typeof entries): Promise<void> => {\n          // Anchors for the pre-claimed steps' telemetry: the POST instant\n          // is the claim's \"start POST sent\" (RSFS's end), the return is the\n          // claim's completion (TTR's T6), the same two instants the lazy\n          // claim's own POST would have produced.\n          const batchPostSentAtMs = Date.now();\n          // biome-ignore lint/style/noNonNullAssertion: batchFanoutEligible implies presence\n          const { results } = await world.events.createBatch!(\n            runId,\n            chunk.map((entry) => ({\n              event: entry.event,\n              // The started row is the step's executing claim, so it carries\n              // the compute-instance attribution the single claim sends via\n              // CreateEventParams.\n              ...(entry.kind === 'inline-started'\n                ? { computeInstanceId: COMPUTE_INSTANCE_ID }\n                : {}),\n            })),\n            // Per-write request attribution, same as the single path's\n            // createGuarded(…, { requestId }).\n            { requestId }\n          );\n          const claimCompletedAtMs = Date.now();\n          for (const [index, item] of results.entries()) {\n            const entry = chunk[index];\n            if (item.error === undefined) {\n              if (entry.kind === 'step') {\n                createdStepCorrelationIds.add(entry.correlationId);\n              } else if (entry.kind === 'inline-started') {\n                // The pair committed: this invocation owns the step and the\n                // caller runs the body with no claim of its own. The\n                // readback entity is authoritative where present; a World\n                // that omitted it gets the same locally synthesized running\n                // attempt-1 the optimistic path executes against. Either\n                // way the input is re-attached locally: batch responses\n                // return refs lazily, and the body's hydration wants the\n                // exact bytes the pair's created row carried. (The created\n                // row's success is deliberately NOT membership in\n                // createdStepCorrelationIds: for inline steps ownership is\n                // the started row's verdict, and the caller's dispatch pass\n                // skips inline correlation ids regardless.)\n                const dehydrated = lazyInlineByCorrelationId.get(\n                  entry.correlationId\n                );\n                if (dehydrated === undefined) {\n                  // Unreachable: the same prep op that enqueued the pair set\n                  // this entry, and the flush awaited every prep above.\n                  //\n                  // Not free if it ever fires, though: the pair is already\n                  // durable here, so this throws with the step claimed and\n                  // its body never run. The delivery fails, and redelivery\n                  // recovers it through owned-recovery (the step carries this\n                  // message's ownership stamp) rather than the request just\n                  // failing cleanly.\n                  throw new WorkflowWorldError(\n                    `no dehydrated input for pre-claimed step ${entry.correlationId}`,\n                    { status: 500 }\n                  );\n                }\n                const now = new Date();\n                const startedStep: StartedStep = item.step?.startedAt\n                  ? { ...item.step, startedAt: item.step.startedAt }\n                  : {\n                      runId,\n                      stepId: entry.correlationId,\n                      stepName: dehydrated.stepName,\n                      status: 'running',\n                      attempt: 1,\n                      createdAt: now,\n                      updatedAt: now,\n                      startedAt: now,\n                    };\n                inlineClaims.set(entry.correlationId, {\n                  owned: true,\n                  step: {\n                    ...startedStep,\n                    input: dehydrated.dehydratedInput,\n                  },\n                  batchPostSentAtMs,\n                  claimCompletedAtMs,\n                });\n              }\n              continue;\n            }\n            if (item.status === 409) {\n              if (\n                entry.kind === 'inline-created' ||\n                entry.kind === 'inline-started'\n              ) {\n                // The pair lost its atomic create-claim: a concurrent writer\n                // already owns this step (an earlier delivery's create, or a\n                // racing handler's claim). Recorded as a lost claim: the\n                // caller's executeStep returns `skipped` without running the\n                // body, the same outcome as losing the lazy claim. A World\n                // that folds the pair reports the 409 on both rows (set\n                // twice, harmless); one that evaluates rows independently\n                // has the started row (processed second) decide, which is\n                // exactly the single path's semantics (create lost + claim\n                // won still runs the body; create won + claim lost skips).\n                inlineClaims.set(entry.correlationId, { owned: false });\n                runtimeLogger.info('Inline step pre-claim lost, continuing', {\n                  workflowRunId: runId,\n                  correlationId: entry.correlationId,\n                  message: item.message,\n                });\n                continue;\n              }\n              // Same tolerance as the single path's EntityConflictError: a\n              // concurrent or earlier delivery already created it.\n              runtimeLogger.info(\n                entry.kind === 'step'\n                  ? 'Step already exists, continuing'\n                  : 'Wait already exists, continuing',\n                {\n                  workflowRunId: runId,\n                  correlationId: entry.correlationId,\n                  message: item.message,\n                }\n              );\n              continue;\n            }\n            throw new WorkflowWorldError(\n              `batched ${entry.event.eventType} for ${entry.correlationId} ` +\n                `failed: ${item.error}: ${item.message}`,\n              { status: item.status }\n            );\n          }\n          // Highest slot this chunk committed: the ceiling the caller folds\n          // into the inline executions' slot snapshot (see\n          // SuspensionHandlerResult.batchCommittedSlotCeiling) and one input\n          // of the interleaving diagnostic.\n          const chunkMaxSlot = maxEventSlot(\n            results.flatMap((item) =>\n              item.error === undefined && item.event ? [item.event] : []\n            )\n          );\n          if (\n            chunkMaxSlot !== undefined &&\n            (batchCommittedSlotCeiling === undefined ||\n              chunkMaxSlot > batchCommittedSlotCeiling)\n          ) {\n            batchCommittedSlotCeiling = chunkMaxSlot;\n          }\n          committedCount += results.filter(\n            (item) => item.error === undefined\n          ).length;\n          if (\n            chunkMaxSlot !== undefined &&\n            (maxCommittedSlot === undefined || chunkMaxSlot > maxCommittedSlot)\n          ) {\n            maxCommittedSlot = chunkMaxSlot;\n          }\n        };\n\n        // Publish the chunk's eager steps' queue messages the moment ITS\n        // creates are durable, the per-chunk half of publish-after-create.\n        // Same message shape and step-identity-scoped idempotency key as the\n        // caller's dispatch pass, so anything double-published dedupes.\n        const publishChunkSteps = async (\n          chunk: typeof entries\n        ): Promise<void> => {\n          if (!publishEagerSteps) return;\n          const stepEntries = chunk.filter((entry) => entry.kind === 'step');\n          if (stepEntries.length === 0) return;\n          const traceCarrier = await getStepDispatchTraceCarrier();\n          await Promise.all(\n            stepEntries.map((entry) =>\n              queueMessage(\n                world,\n                // biome-ignore lint/style/noNonNullAssertion: publishEagerSteps implies presence\n                stepDispatch!.queueName,\n                {\n                  runId,\n                  stepId: entry.correlationId,\n                  // biome-ignore lint/style/noNonNullAssertion: set on every 'step' entry at enqueue\n                  stepName: entry.stepName!,\n                  traceCarrier,\n                  requestedAt: new Date(),\n                },\n                {\n                  idempotencyKey: stepDispatchIdempotencyKey(\n                    entry.correlationId,\n                    // biome-ignore lint/style/noNonNullAssertion: set on every 'step' entry at enqueue\n                    entry.stepName!\n                  ),\n                }\n              )\n            )\n          );\n        };\n\n        // Launch every chunk's POST now; chain each chunk's publishes on its\n        // OWN commit. A chunk whose commit rejected keeps its messages\n        // unsent (the rejection fails the delivery; redelivery re-creates\n        // and re-dispatches, deduped by the idempotency keys).\n        const commits = chunks.map((chunk) => commitChunk(chunk));\n        const publishes = chunks.map(async (chunk, index) => {\n          await commits[index];\n          await publishChunkSteps(chunk);\n        });\n\n        const trailing = (async () => {\n          // Let every sibling settle before surfacing the first failure: a\n          // chunk that committed must still get its publishes out even when\n          // another chunk failed, and the caller acks only after this\n          // resolves.\n          const settled = await Promise.allSettled([...commits, ...publishes]);\n          // Foreign-interleaving visibility: the batch endpoint has no\n          // bump-and-report, so events other writers landed between the\n          // snapshot and these commits pushed the fold to higher slots\n          // WITHOUT handing us the skipped events. Same accepted exposure\n          // as a dropped truncated report on the single path: the local\n          // log stays a strict prefix and the next reload observes them.\n          // Logged so a bump is diagnosable rather than silent.\n          if (\n            expectedFirstSlot !== undefined &&\n            maxCommittedSlot !== undefined\n          ) {\n            const interleaved =\n              maxCommittedSlot - expectedFirstSlot + 1 - committedCount;\n            if (interleaved > 0) {\n              runtimeLogger.debug('Batched fan-out committed above snapshot', {\n                workflowRunId: runId,\n                expectedFirstSlot,\n                maxCommittedSlot,\n                committedCount,\n                interleaved,\n              });\n            }\n          }\n          const failure = settled.find(\n            (outcome): outcome is PromiseRejectedResult =>\n              outcome.status === 'rejected'\n          );\n          if (failure) throw failure.reason;\n        })();\n\n        // EVERY chunk carrying pairs gates the return, not just the first:\n        // a pair whose commit the caller has not seen yields no\n        // `inlineClaims` entry, so the caller falls back to a lazy\n        // `step_started` that would race this same fold's still-in-flight\n        // pair for the same step. Today pairs always land in one chunk\n        // (they sort first, and two rows per inline step fit inside one\n        // chunk, pinned by constants.test.ts), so this is at most one\n        // commit; the filter is what keeps the property true if either cap\n        // moves.\n        const pairCommits = chunks.flatMap((chunk, index) =>\n          chunk.some((entry) => entry.kind === 'inline-started')\n            ? [commits[index]]\n            : []\n        );\n        if (allowDeferredBatchWork) {\n          // The trailing work is the caller's to join before ack. Attach a\n          // handler now so a rejection that races that join (or a foreground\n          // failure that prevents the caller from ever reaching it) is never\n          // an unhandledRejection; awaiting the promise still observes it.\n          trailing.catch(() => {});\n          deferredBatchWork = trailing;\n          // Only the pair chunks gate the return: their claims are what the\n          // caller starts the inline bodies from. With no pairs there is\n          // nothing the caller's post-return work reads from the commits,\n          // so nothing gates.\n          if (pairCommits.length > 0) {\n            try {\n              await Promise.all(pairCommits);\n            } catch (err) {\n              // A pair chunk failed, so this phase's write set is NOT the\n              // caller's to join any more: `deferredBatchWork` never\n              // reaches it once handleSuspension throws. Settle the rest\n              // before the rejection escapes, for the reason `settlePhase`\n              // gives: a sibling create landing after the throw commits an\n              // event from the abandoned replay's seeded sequence and races\n              // the caller's restart reload while doing so.\n              await trailing.catch(() => {});\n              throw err;\n            }\n          }\n        } else {\n          await trailing;\n        }\n      })()\n    );\n  }\n\n  for (const queueItem of attributeItems) {\n    ops.push(\n      (async () => {\n        try {\n          await ensureRunReady();\n          // Guarded like every other suspension write: an attr_set is a\n          // replay-derived event with a correlation id from this replay's\n          // seeded sequence, so it must not land on a log the replay never\n          // saw. Rejecting it is cheap: a run with attribute events already\n          // forces an in-process replay, so the restart costs the replay it\n          // was going to do anyway.\n          await createGuarded(\n            {\n              eventType: 'attr_set',\n              specVersion: SPEC_VERSION_CURRENT,\n              correlationId: queueItem.correlationId,\n              eventData: {\n                changes: queueItem.changes,\n                writer: { type: 'workflow' },\n                ...(queueItem.allowReservedAttributes\n                  ? { allowReservedAttributes: true }\n                  : {}),\n              },\n            },\n            { requestId }\n          );\n        } catch (err) {\n          if (EntityConflictError.is(err)) {\n            runtimeLogger.info(\n              'Workflow attribute event already exists, continuing',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else if (isWorldValidationFailure(err)) {\n            // Deterministic validation rejection from the World, e.g. the\n            // cumulative per-run attribute cap, which only the World can\n            // check against the run's existing attributes. Redelivering the\n            // orchestrator message replays the workflow into the exact same\n            // write and the exact same rejection, so retrying can never\n            // succeed. Surface it as a FatalError so the caller fails the\n            // run with a clear error instead of wedging it in redelivery.\n            const fatal = new FatalError(\n              `setAttributes failed World validation: ${\n                err instanceof Error ? err.message : String(err)\n              }`\n            );\n            fatal.cause = err;\n            throw fatal;\n          } else {\n            throw err;\n          }\n        }\n      })()\n    );\n  }\n\n  // Await the step_created / wait_created event creates before returning.\n  // The caller (workflowEntrypoint) only enqueues the step-dispatch queue\n  // messages AFTER handleSuspension resolves, and the queue handler acks\n  // the orchestrator message only after the caller resolves. So the step_created\n  // events must be durable here, and the dispatch sends must complete in the caller,\n  // all before ack. If the process crashes before this resolves, the orchestrator\n  // message is not acked and VQS redelivers, re-creates the (idempotent)\n  // step_created and re-dispatches, and recovers the run instead of orphaning it.\n  await settlePhase(ops);\n\n  // The step-input dehydrations above have settled, so the sink is final.\n  const retainedStepInputsSafe = guestCodeStats.executions.length === 0;\n  if (!retainedStepInputsSafe) {\n    runtimeLogger.debug(\n      'Serializing step inputs executed workflow code; falling back to replay instead of retaining the VM',\n      {\n        workflowRunId: runId,\n        executions: guestCodeStats.executions\n          .slice(0, 5)\n          .map((e) => (e.detail ? `${e.kind}(${e.detail})` : e.kind)),\n      }\n    );\n  }\n\n  // Rebuild the inline batch in deterministic order. `lazyInlineCorrelationIds`\n  // is a Set seeded from the ordered first-N slice, so iterating it preserves\n  // stepItems order; every id in it was set by the lazy branch above.\n  const lazyInlineSteps: SuspensionHandlerResult['lazyInlineSteps'] = [];\n  for (const correlationId of lazyInlineCorrelationIds) {\n    const lazyStep = lazyInlineByCorrelationId.get(correlationId);\n    if (lazyStep) lazyInlineSteps.push(lazyStep);\n  }\n\n  // Find the soonest pending wait (minimum timeout)\n  const now = Date.now();\n  let soonestWait: { seconds: number; correlationId: string } | undefined;\n  for (const queueItem of waitItems) {\n    const resumeAtMs = queueItem.resumeAt.getTime();\n    const delayMs = Math.max(1000, resumeAtMs - now);\n    const timeoutSeconds = Math.ceil(delayMs / 1000);\n    if (!soonestWait || timeoutSeconds < soonestWait.seconds) {\n      soonestWait = {\n        seconds: timeoutSeconds,\n        correlationId: queueItem.correlationId,\n      };\n    }\n  }\n\n  span?.setAttributes({\n    ...Attribute.WorkflowRunStatus('workflow_suspended'),\n    ...Attribute.WorkflowStepsCreated(stepItems.length),\n    ...Attribute.WorkflowHooksCreated(hooksNeedingCreation.length),\n    ...Attribute.WorkflowWaitsCreated(waitItems.length),\n    ...(failedStepCorrelationIds.size > 0\n      ? Attribute.WorkflowStepsFailedSerialization(\n          failedStepCorrelationIds.size\n        )\n      : {}),\n    ...(resilientDispatchRecovered > 0\n      ? Attribute.StepResilientDispatchRecovered(resilientDispatchRecovered)\n      : {}),\n  });\n\n  return {\n    pendingSteps: stepItems,\n    createdStepCorrelationIds,\n    failedStepCorrelationIds,\n    queuedStepCorrelationIds,\n    lazyInlineSteps,\n    inlineClaims,\n    batchCommittedSlotCeiling,\n    deferredBatchWork,\n    // On hook conflict the caller re-invokes immediately and never reads\n    // the wait timeout, so don't report one.\n    waitTimeout: hasHookConflict ? undefined : soonestWait,\n    hasHookConflict,\n    hasAwaitedHookCreation,\n    hasAttributeEvents: attributeItems.length > 0,\n    hasHookEvents: hooksNeedingCreation.length > 0,\n    hookCreationMs,\n    retainedStepInputsSafe,\n    reportedEventCount: reportedEvents,\n  };\n}\n\n/**\n * Whether an `events.create` rejection is deterministic World validation\n * rather than a transient/storage error. Local Worlds\n * (world-local, world-postgres) throw `AttributeValidationError` directly;\n * remote Worlds surface the equivalent server-side rejection as a\n * `WorkflowWorldError` with HTTP status 400. The name check covers\n * `AttributeValidationError` instances from a different copy of\n * `@workflow/world` than the one this package resolved.\n */\nfunction isWorldValidationFailure(err: unknown): boolean {\n  if (err instanceof AttributeValidationError) return true;\n  if (err instanceof Error && err.name === 'AttributeValidationError') {\n    return true;\n  }\n  return WorkflowWorldError.is(err) && err.status === 400;\n}\n"]}