@workflow/core 5.0.0-beta.5 → 5.0.0-beta.51

package/dist/runtime/suspension-handler.js

@@ -1,135 +1,386 @@
-import { waitUntil } from '@vercel/functions';
-import { EntityConflictError, HookNotFoundError, RunExpiredError, } from '@workflow/errors';
-import { SPEC_VERSION_CURRENT, } 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 { getAbortStreamIdFromToken } from '../util.js';
+import { GUEST_CODE_EXECUTION_SAMPLE_LIMIT, } from '../serialization/hardened.js';
+import { dehydrateStepArguments, dehydrateStepError, } from '../serialization.js';
 import * as Attribute from '../telemetry/semantic-conventions.js';
+import { getAbortStreamIdFromToken } from '../util.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, appendEventLog, maxEventSlot, queueMessage, queueMessages, runDispatchContext, 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, sinceCursor, createEvent, }) {
+    try {
+        const result = await createEvent(hookEvent, {
+            requestId,
+            ...(sinceCursor === undefined ? {} : { sinceCursor }),
+        });
+        // Check if the world returned a hook_conflict event instead of hook_created.
+        // The hook_conflict event is stored in the event log and is what the next
+        // pass consumes to settle the hook's awaiters — rejecting a payload await,
+        // resolving a `hook.getConflict()` with the conflicting run. An inline
+        // delta asked for above carries it just as it would have carried the
+        // hook_created, so the caller can advance over it without a re-invocation.
+        if (result.event?.eventType === 'hook_conflict') {
+            return {
+                hasHookConflict: true,
+                hasAwaitedHookCreation: false,
+            };
+        }
+        return {
+            hasHookConflict: false,
+            hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true,
+        };
+    }
+    catch (err) {
+        if (EntityConflictError.is(err)) {
+            runtimeLogger.info('Hook already exists, continuing', {
+                workflowRunId: runId,
+                message: err.message,
+            });
+            return {
+                hasHookConflict: false,
+                hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true,
+            };
+        }
+        if (RunExpiredError.is(err)) {
+            runtimeLogger.info('Workflow run already completed, skipping hook', {
+                workflowRunId: runId,
+                message: err.message,
+            });
+            return {
+                hasHookConflict: false,
+                hasAwaitedHookCreation: false,
+            };
+        }
+        if (isWorldValidationFailure(err)) {
+            const fatal = new FatalError(`createHook failed World validation: ${err instanceof Error ? err.message : String(err)}`);
+            fatal.cause = err;
+            throw fatal;
+        }
+        throw err;
+    }
+}
 /**
  * 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, }) {
+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
+    // run that does not exist yet. A no-op outside turbo (barrier undefined) and
+    // on the pure inline hot path, which defers all steps and writes nothing.
+    // Awaiting the same (usually already-settled) promise more than once is cheap.
+    // A barrier rejection is swallowed for ordering only: if `run_started` truly
+    // failed the run does not exist, so the subsequent write surfaces the real
+    // error (run not found / gone) and the message redelivers.
+    const ensureRunReady = async () => {
+        if (runReadyBarrier) {
+            try {
+                await runReadyBarrier;
+            }
+            catch {
+                // intentional: ordering barrier only, see above.
+            }
+        }
+    };
+    /**
+     * Await every operation in a suspension phase before letting a failure
+     * escape, preferring a stale-snapshot (412) rejection when one occurred.
+     *
+     * `Promise.all` rejects as soon as one operation does and leaves its siblings
+     * 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
+     * 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.
+     *
+     * A 412 is preferred over any other rejection in the same phase because it
+     * has a defined, cheap recovery (replay from a corrected log) while the
+     * others do not. A deterministic failure such as an attribute-validation
+     * `FatalError` recurs on the restart and fails the run then, at the cost of
+     * one extra replay.
+     */
+    const settlePhase = async (ops) => {
+        const reasons = (await Promise.allSettled(ops))
+            .filter((r) => r.status === 'rejected')
+            .map((r) => r.reason);
+        if (reasons.length === 0)
+            return;
+        throw reasons.find((r) => PreconditionFailedError.is(r)) ?? reasons[0];
+    };
+    // Every suspension write carries replay-recovery telemetry on the first one
+    // that commits after replay recovered. All suspension events are
+    // non-run_created events on this run's `runId`.
+    const reporter = replayRecoveryReporter ?? ReplayRecoveryReporter.inert();
+    const createEvent = (data, params) => reporter.withEventCreate(params, (p) => world.events.create(runId, data, p));
+    // 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,
+    // 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.
+    let reportedEvents = 0;
+    // Writes this suspension issued, and whether one of them handed back a
+    // complete inline delta that was folded into the caller's log. Together they
+    // answer `eventLogCarriedForward`: the delta covers the log up to the write
+    // that returned it, so it accounts for every event this suspension committed
+    // only if that write was the only one.
+    let guardedWrites = 0;
+    let deltaAbsorbed = false;
+    const createGuarded = async (data, params) => {
+        guardedWrites++;
+        if (!eventLog) {
+            return createEvent(data, params);
+        }
+        const log = eventLog;
+        const result = await createEvent(data, {
+            ...params,
+            ...slotSnapshotParams(log.events),
+        });
+        // An inline delta this call asked for (`sinceCursor`) is everything the
+        // log gained since that cursor, this write included, so it is folded onto
+        // the tail and carries the cursor with it — unlike a skipped-slot report,
+        // which is a window strictly below the write and has to be sorted back
+        // into place. A World returns one or the other, never both (the delta is a
+        // strict superset), so the two are handled apart rather than merged.
+        //
+        // Declining is always safe — an unabsorbed delta is one the next read
+        // returns — so the guards match the replay loop's `absorbCreateDelta`: a
+        // truncated page (`hasMore`) is dropped whole rather than advancing the
+        // cursor past events it did not carry, and the log must still be where the
+        // request was computed from, since appending does not re-sort.
+        if (typeof params?.sinceCursor === 'string') {
+            if (log.cursor === params.sinceCursor &&
+                result.events !== undefined &&
+                result.hasMore !== true) {
+                appendEventLog(log, { events: result.events, cursor: result.cursor });
+                deltaAbsorbed = true;
+            }
+            return result;
+        }
+        // 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,
+        // and the replay that resumes from this log sees them without a reload.
+        const report = absorbSkippedSlotReport(log.events, result);
+        reportedEvents += report.added;
+        if (report.truncated) {
+            runtimeLogger.debug('Dropped a truncated skipped-slot report', {
+                workflowRunId: runId,
+                eventType: data.eventType,
+                eventId: result.event?.eventId,
+                offered: report.offered,
+            });
+        }
+        else if (report.added > 0) {
+            runtimeLogger.debug('Suspension write skipped occupied slots', {
+                workflowRunId: runId,
+                eventType: data.eventType,
+                eventId: result.event?.eventId,
+                reported: report.added,
+            });
+        }
+        return result;
+    };
     // Separate queue items by type
-    const stepItems = suspension.steps.filter((item) => item.type === 'step');
-    const allHookItems = suspension.steps.filter((item) => item.type === 'hook');
-    const waitItems = suspension.steps.filter((item) => item.type === 'wait');
-    // Split hooks by what actions they need
+    const stepItems = suspension.items.filter((item) => item.type === 'step');
+    const allHookItems = suspension.items.filter((item) => item.type === 'hook');
+    const waitItems = suspension.items.filter((item) => item.type === 'wait');
+    const attributeItems = suspension.items.filter((item) => item.type === 'attribute');
     const hooksNeedingCreation = allHookItems.filter((item) => !item.hasCreatedEvent);
-    const hooksNeedingDisposal = allHookItems.filter((item) => item.disposed);
+    // 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
+    // new hook records a spurious hook_conflict against the run's own
+    // 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
+        }
+        const group = hookItemsByToken.get(item.token);
+        if (group) {
+            group.push(item);
+        }
+        else {
+            hookItemsByToken.set(item.token, [item]);
+        }
+    }
     // Resolve encryption key for this run
     const rawKey = await world.getEncryptionKeyForRun?.(run);
     const encryptionKey = rawKey ? await importKey(rawKey) : undefined;
-    // Build and process hook_created events (same as V1)
-    const hookEvents = await Promise.all(hooksNeedingCreation.map(async (queueItem) => {
-        const hookMetadata = typeof queueItem.metadata === 'undefined'
-            ? undefined
-            : (await dehydrateStepArguments(queueItem.metadata, runId, encryptionKey, suspension.globalThis));
-        return {
-            eventType: 'hook_created',
+    // Gate payload compression on the run's specVersion.
+    const compression = (run.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION;
+    let serializationBlockerCount = 0;
+    const serializationBlockers = [];
+    async function dehydrateInput(value, context) {
+        const stats = { executions: [] };
+        try {
+            return (await dehydrateStepArguments(value, runId, encryptionKey, suspension.globalThis, false, compression, stats));
+        }
+        finally {
+            serializationBlockerCount +=
+                stats.totalExecutions ?? stats.executions.length;
+            serializationBlockers.push(...stats.executions
+                .slice(0, GUEST_CODE_EXECUTION_SAMPLE_LIMIT - serializationBlockers.length)
+                .map((execution) => ({ ...context, ...execution })));
+        }
+    }
+    async function disposeHook(queueItem) {
+        const hookDisposedEvent = {
+            eventType: 'hook_disposed',
             specVersion: SPEC_VERSION_CURRENT,
             correlationId: queueItem.correlationId,
             eventData: {
                 token: queueItem.token,
-                metadata: hookMetadata,
-                isWebhook: queueItem.isWebhook ?? false,
-                ...(queueItem.isSystem && { isSystem: true }),
             },
         };
-    }));
-    // Process hooks first to prevent race conditions with webhook receivers.
-    // All hook creations run in parallel.
-    // Track any hook conflicts that occur — these are returned to the caller
-    // so the V2 handler can re-invoke immediately.
-    let hasHookConflict = false;
-    if (hookEvents.length > 0) {
-        await Promise.all(hookEvents.map(async (hookEvent) => {
-            try {
-                const result = await world.events.create(runId, hookEvent, {
-                    requestId,
+        try {
+            await createGuarded(hookDisposedEvent, { requestId });
+        }
+        catch (err) {
+            if (EntityConflictError.is(err)) {
+                // Hook was already disposed by a concurrent invocation, safe to skip
+                runtimeLogger.info('Hook already disposed, skipping duplicate disposal', {
+                    workflowRunId: runId,
+                    correlationId: queueItem.correlationId,
+                    message: err.message,
                 });
-                // Check if the world returned a hook_conflict event instead of hook_created.
-                // The hook_conflict event is stored in the event log and will be replayed
-                // on the next workflow invocation, causing the hook's promise to reject.
-                // Note: hook events always create an event (legacy runs throw, not return undefined)
-                if (result.event.eventType === 'hook_conflict') {
-                    hasHookConflict = true;
-                }
             }
-            catch (err) {
-                if (EntityConflictError.is(err) || RunExpiredError.is(err)) {
-                    runtimeLogger.info('Workflow run already completed, skipping hook', {
-                        workflowRunId: runId,
-                        message: err.message,
-                    });
-                }
-                else {
-                    throw err;
-                }
+            else if (RunExpiredError.is(err)) {
+                runtimeLogger.info('Workflow run already completed, skipping hook disposal', {
+                    workflowRunId: runId,
+                    correlationId: queueItem.correlationId,
+                    message: err.message,
+                });
             }
-        }));
-    }
-    // Process hook disposals — these release hook tokens for reuse by other workflows.
-    if (hooksNeedingDisposal.length > 0) {
-        await Promise.all(hooksNeedingDisposal.map(async (queueItem) => {
-            const hookDisposedEvent = {
-                eventType: 'hook_disposed',
-                specVersion: SPEC_VERSION_CURRENT,
-                correlationId: queueItem.correlationId,
-            };
-            try {
-                await world.events.create(runId, hookDisposedEvent, { requestId });
+            else if (HookNotFoundError.is(err)) {
+                // Hook may have already been disposed or never created
+                runtimeLogger.info('Hook not found for disposal, continuing', {
+                    workflowRunId: runId,
+                    correlationId: queueItem.correlationId,
+                    message: err.message,
+                });
             }
-            catch (err) {
-                if (EntityConflictError.is(err)) {
-                    // Hook was already disposed by a concurrent invocation — safe to skip
-                    runtimeLogger.info('Hook already disposed, skipping duplicate disposal', {
-                        workflowRunId: runId,
-                        correlationId: queueItem.correlationId,
-                        message: err.message,
-                    });
-                }
-                else if (RunExpiredError.is(err)) {
-                    runtimeLogger.info('Workflow run already completed, skipping hook disposal', {
-                        workflowRunId: runId,
-                        correlationId: queueItem.correlationId,
-                        message: err.message,
-                    });
-                }
-                else if (HookNotFoundError.is(err)) {
-                    // Hook may have already been disposed or never created
-                    runtimeLogger.info('Hook not found for disposal, continuing', {
-                        workflowRunId: runId,
+            else {
+                throw err;
+            }
+        }
+    }
+    // Process hooks first to prevent race conditions with webhook receivers.
+    // Track any hook conflicts that occur — these are returned to the caller so
+    // it can advance the workflow over the committed `hook_conflict` before
+    // anything else this suspension scheduled runs.
+    const hookConflictCorrelationIds = [];
+    const awaitedHookCorrelationIds = [];
+    let hookCreationMs = 0;
+    // Ask the hook create for the event-log delta since the cursor the caller's
+    // log was read at. The hook's awaiters are settled by the event this write
+    // commits and by nothing else — a `hook_created` for a clean registration,
+    // a `hook_conflict` when the token was already claimed — so the caller can
+    // continue the workflow in its own process on either outcome, but only over
+    // a log that holds that event, and this write is the one request that can
+    // hand it back together with anything another writer landed in the meantime.
+    // Optional by contract: a World that ignores `sinceCursor` returns no delta
+    // and the caller reads instead.
+    //
+    // Asked for on the single-hook suspension only. Two creates issued from one
+    // snapshot each diff against the same cursor, and only the first delta back
+    // can be folded in (the cursor moves with it), so the log would end up short
+    // of the other's event with nothing to say so.
+    const hookDeltaCursor = hooksNeedingCreation.length === 1 && typeof eventLog?.cursor === 'string'
+        ? eventLog.cursor
+        : undefined;
+    if (hookItemsByToken.size > 0) {
+        const hookPhaseStart = Date.now();
+        await ensureRunReady();
+        await settlePhase([...hookItemsByToken.values()].map(async (items) => {
+            for (const queueItem of items) {
+                let creationConflicted = false;
+                if (!queueItem.hasCreatedEvent) {
+                    const hookMetadata = typeof queueItem.metadata === 'undefined'
+                        ? undefined
+                        : await dehydrateInput(queueItem.metadata, {
+                            source: 'hook_metadata',
+                            correlationId: queueItem.correlationId,
+                        });
+                    const hookEvent = {
+                        eventType: 'hook_created',
+                        specVersion: SPEC_VERSION_CURRENT,
                         correlationId: queueItem.correlationId,
-                        message: err.message,
+                        eventData: {
+                            token: queueItem.token,
+                            tokenRetentionUntil: queueItem.tokenRetentionUntil,
+                            metadata: hookMetadata,
+                            isWebhook: queueItem.isWebhook ?? false,
+                            ...(queueItem.isSystem && { isSystem: true }),
+                        },
+                    };
+                    const result = await createHookEvent({
+                        runId,
+                        hookEvent,
+                        queueItem,
+                        requestId,
+                        sinceCursor: hookDeltaCursor,
+                        createEvent: createGuarded,
                     });
+                    if (result.hasHookConflict) {
+                        hookConflictCorrelationIds.push(queueItem.correlationId);
+                    }
+                    if (result.hasAwaitedHookCreation) {
+                        awaitedHookCorrelationIds.push(queueItem.correlationId);
+                    }
+                    creationConflicted = result.hasHookConflict;
                 }
-                else {
-                    throw err;
+                // Dispose after creation for hooks born and disposed within this
+                // batch. A hook whose creation conflicted was never created, so
+                // there is nothing to dispose.
+                if (queueItem.disposed && !creationConflicted) {
+                    await disposeHook(queueItem);
                 }
             }
         }));
+        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 Promise.all(hooksNeedingAbort.map(async (queueItem) => {
+        await ensureRunReady();
+        await settlePhase(hooksNeedingAbort.map(async (queueItem) => {
             try {
                 // Dehydrate the abort payload for storage
-                const abortPayload = await dehydrateStepArguments({ aborted: true, reason: queueItem.abortReason }, runId, encryptionKey, suspension.globalThis);
+                const abortPayload = await dehydrateInput({
+                    aborted: true,
+                    reason: queueItem.abortReason,
+                }, {
+                    source: 'hook_abort',
+                    correlationId: queueItem.correlationId,
+                });
                 // Create hook_received event with abort payload
-                await world.events.create(runId, {
+                await createGuarded({
                     eventType: 'hook_received',
                     specVersion: SPEC_VERSION_CURRENT,
                     correlationId: queueItem.correlationId,
                     eventData: {
+                        token: queueItem.token,
                         payload: abortPayload,
                     },
                 });
@@ -146,7 +397,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,
@@ -168,7 +419,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
@@ -176,30 +427,422 @@ 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 count 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);
+    };
+    // Lazy inline start: defer the step_created write for up to
+    // `getMaxInlineSteps()` steps the caller will run inline (in parallel). Each
+    // step is created on the fly by the lazy `step_started` executeStep sends
+    // (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 continues the workflow to resolve the awaiter instead), 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.
+    const lazyInlineCorrelationIds = new Set(awaitedHookCorrelationIds.length === 0
+        ? stepItems
+            .filter((item) => stepsNeedingCreation.has(item.correlationId))
+            .slice(0, getMaxInlineSteps())
+            .map((item) => item.correlationId)
+        : []);
+    // Collected by correlationId because the per-step ops below run concurrently
+    // and settle out of order. We rebuild the array in deterministic
+    // `lazyInlineCorrelationIds` order (the ordered slice above) after the ops
+    // settle, so the inline batch order is stable regardless of dehydration timing.
+    const lazyInlineByCorrelationId = new Map();
     const ops = [];
-    // Steps: create step_created events (no queuing — V2 returns pending steps to caller)
+    // Correlation IDs of steps whose step-execution queue message was already
+    // published by the resilient-dispatch ops below (alongside the step_created
+    // write). Reported to the caller so its dispatch pass skips them.
+    const queuedStepCorrelationIds = new Set();
+    // 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
+    //    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
+    //    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
+    //    bookkeeping can close the window: a best-effort marker that fails open
+    //    cannot carry a correctness property. The sequential path is the only
+    //    thing that gives the message a happens-after edge over the verdict.
+    //  - The run's queue transport preserves binary payloads (CBOR,
+    //    specVersion >= 3): `stepInput.input` is the serialized (possibly
+    //    encrypted) input bytes, which the JSON transport would mangle.
+    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 inline steps' claims commit in
+    // one durable write (the pair chunk, see the flush below) and the caller
+    // starts the bodies straight off that commit instead of posting one claim
+    // per inline step. Requires TWO or more inline steps, and nothing else:
+    // the pairs commit in a chunk of their own, so plain creates alongside
+    // them share no round trip with the pairs and cannot make a lone pair
+    // worth folding. A lone inline step is better served by the lazy
+    // `step_started`: one row instead of two, optimistic-start capable (the
+    // claim overlaps the body), with the slot-snapshot params and
+    // bump-and-report `createGuarded` provides, all of which a pair-only
+    // batch of one pair gives up for the same round trip. Two or more inline
+    // steps become ONE pair chunk instead of N parallel lazy claims, which is
+    // the saving. A lone inline step alongside eager creates therefore takes
+    // the lazy path while the creates still batch. Also 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 inlinePairFoldEligible = batchFanoutEligible &&
+        ownerMessageId !== undefined &&
+        lazyInlineCorrelationIds.size >= 2;
+    const inlineClaims = new Map();
+    // The trace carrier for resilient step dispatches, resolved at most once per
+    // suspension (the per-step ops run concurrently and share it).
+    let stepDispatchTraceCarrier;
+    const getStepDispatchTraceCarrier = () => {
+        stepDispatchTraceCarrier ??=
+            stepDispatch?.getTraceCarrier() ?? Promise.resolve({});
+        return stepDispatchTraceCarrier;
+    };
+    // 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
+    // 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 () => {
-                const dehydratedInput = await dehydrateStepArguments({
-                    args: queueItem.args,
-                    closureVars: queueItem.closureVars,
-                    thisVal: queueItem.thisVal,
-                }, runId, encryptionKey, suspension.globalThis);
+            // 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, never splits across chunks,
+            // and commits in a pair-only chunk ahead of the plain creates, 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 () => {
+                let dehydratedInput;
+                try {
+                    dehydratedInput = await dehydrateInput({
+                        args: queueItem.args,
+                        closureVars: queueItem.closureVars,
+                        thisVal: queueItem.thisVal,
+                    }, {
+                        source: 'step_input',
+                        correlationId: queueItem.correlationId,
+                    });
+                }
+                catch (err) {
+                    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;
+                }
+                // 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
+                // createdStepCorrelationIds; ownership is decided by that lazy
+                // step_started's atomic create-claim instead.
+                if (lazyInlineCorrelationIds.has(queueItem.correlationId)) {
+                    lazyInlineByCorrelationId.set(queueItem.correlationId, {
+                        correlationId: queueItem.correlationId,
+                        stepName: queueItem.stepName,
+                        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 = {
                     eventType: 'step_created',
                     specVersion: SPEC_VERSION_CURRENT,
                     correlationId: queueItem.correlationId,
                     eventData: {
                         stepName: queueItem.stepName,
+                        workflowName: run.workflowName,
                         input: dehydratedInput,
                     },
                 };
+                // Resilient step dispatch: fire the step_created write and 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
+                // resilient hook resume (`hookInput`) patterns. Only for inputs the
+                // queue message can safely carry (binary, under the VQS size cap).
+                if (resilientDispatchEligible &&
+                    dehydratedInput instanceof Uint8Array &&
+                    dehydratedInput.byteLength <= MAX_RESILIENT_STEP_INPUT_BYTES) {
+                    await ensureRunReady();
+                    const traceCarrier = await getStepDispatchTraceCarrier();
+                    const [createResult, queueResult] = await Promise.allSettled([
+                        createGuarded(stepEvent, { requestId }),
+                        queueMessage(world, 
+                        // biome-ignore lint/style/noNonNullAssertion: implied by resilientDispatchEligible
+                        stepDispatch.queueName, {
+                            runId,
+                            stepId: queueItem.correlationId,
+                            stepName: queueItem.stepName,
+                            traceCarrier,
+                            requestedAt: new Date(),
+                            stepInput: { input: dehydratedInput },
+                            runContext: runDispatchContext(run),
+                        }, 
+                        // Same key as the caller's dispatch pass and any concurrent
+                        // 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.
+                        {
+                            idempotencyKey: stepDispatchIdempotencyKey(queueItem.correlationId, queueItem.stepName),
+                        }),
+                    ]);
+                    // Queue failure is always fatal for this suspension pass: without
+                    // 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,
+                    // the same recovery as the sequential path.
+                    if (queueResult.status === 'rejected') {
+                        throw queueResult.reason;
+                    }
+                    queuedStepCorrelationIds.add(queueItem.correlationId);
+                    if (createResult.status === 'rejected') {
+                        const err = createResult.reason;
+                        if (EntityConflictError.is(err)) {
+                            // 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', {
+                                workflowRunId: runId,
+                                correlationId: queueItem.correlationId,
+                                message: err.message,
+                            });
+                        }
+                        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
+                            // idempotently re-ensures the step_created before executing.
+                            resilientDispatchRecovered++;
+                            runtimeLogger.warn('Step creation event write failed, but the step was ' +
+                                'dispatched via the queue. The step_created event will ' +
+                                'be ensured by the queue consumer.', {
+                                workflowRunId: runId,
+                                correlationId: queueItem.correlationId,
+                                stepName: queueItem.stepName,
+                                error: err instanceof Error ? err.message : String(err),
+                            });
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
+                    else {
+                        createdStepCorrelationIds.add(queueItem.correlationId);
+                    }
+                    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 world.events.create(runId, stepEvent, { requestId });
+                    await ensureRunReady();
+                    await createGuarded(stepEvent, { requestId });
                     createdStepCorrelationIds.add(queueItem.correlationId);
                 }
                 catch (err) {
@@ -214,23 +857,44 @@ 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 world.events.create(runId, waitEvent, { requestId });
+                    await ensureRunReady();
+                    await createGuarded(waitEvent, { requestId });
                 }
                 catch (err) {
                     if (EntityConflictError.is(err)) {
@@ -247,33 +911,548 @@ export async function handleSuspension({ suspension, world, run, span, requestId
             })());
         }
     }
-    waitUntil(Promise.all(ops).catch((opErr) => {
-        const isAbortError = opErr?.name === 'AbortError' || opErr?.name === 'ResponseAborted';
-        if (!isAbortError)
-            throw opErr;
-    }));
-    await Promise.all(ops);
-    // Calculate minimum timeout from waits
+    // 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),
+    // and that chunk carries NOTHING else, so its commit is as small as the
+    // inline slice (see the chunking below).
+    // 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();
+            // The ordinary single path for a lone plain entry: 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 is written the way it would have
+            // been without the fold, with the same conflict tolerance and
+            // ownership bookkeeping. Used when the whole fold is one entry
+            // (below) and when the plain partition beside the pairs is one
+            // entry (the chunking further down). Beside a pair chunk it commits
+            // concurrently with the handler's return, like a trailing chunk; the
+            // inline bodies do not depend on it (executor writes carry no slot
+            // snapshot, so there is no position for it to move).
+            const commitSingle = async (entry) => {
+                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;
+                    }
+                }
+            };
+            if (entries.length === 1) {
+                await commitSingle(entries[0]);
+                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. Two rules:
+            //
+            // 1. 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.
+            // 2. The pairs commit in chunk(s) of THEIR OWN, ahead of the plain
+            //    `step`/`wait` creates, which fill the subsequent chunks. The
+            //    pair chunk is the one commit the inline bodies wait for (see
+            //    `pairCommits` below), and on the Vercel backend its latency
+            //    scales with the transaction's item count: measured on 32-branch
+            //    fan-outs, batches of <=8 events commit in ~56 ms p50 server-side
+            //    where batches of 24-32 events take ~110 ms. Padding the pair
+            //    chunk with plain creates up to the cap therefore held the
+            //    bodies for the plain creates' commit, which nothing else
+            //    needed: a plain create gates only its own queue publish, and
+            //    that fires off whichever sibling chunk carries it. Splitting
+            //    them keeps the pair chunk small (two rows per inline step) and
+            //    lets the plain creates commit concurrently beside it.
+            const chunkEntries = (list) => {
+                const out = [];
+                let current = [];
+                for (let index = 0; index < list.length; index++) {
+                    const entry = list[index];
+                    const next = list[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) {
+                        out.push(current);
+                        current = [];
+                    }
+                    current.push(entry);
+                    if (pairLead) {
+                        current.push(next);
+                        index++;
+                    }
+                }
+                if (current.length > 0)
+                    out.push(current);
+                return out;
+            };
+            // Both partitions keep `entries`' order, so a pair's two rows
+            // (consecutive `order` values, enqueued together) stay adjacent in
+            // the pair partition.
+            const isPairRow = (entry) => entry.kind === 'inline-created' || entry.kind === 'inline-started';
+            const pairChunks = chunkEntries(entries.filter((entry) => isPairRow(entry)));
+            const plainEntries = entries.filter((entry) => !isPairRow(entry));
+            // A plain partition of exactly ONE entry is the batch-of-one case
+            // again, now that the pairs no longer share its chunk: it takes the
+            // single path (`commitSingle`) rather than a one-row createBatch,
+            // and is carried as a one-entry chunk so the per-chunk publish and
+            // settle machinery below treats it like any sibling. (A one-row
+            // remainder of a LARGER plain partition still batches: it is the
+            // pre-split behavior, unchanged here.)
+            const plainChunks = plainEntries.length === 1
+                ? [plainEntries]
+                : chunkEntries(plainEntries);
+            const singleChunk = plainEntries.length === 1 ? plainChunks[0] : undefined;
+            const chunks = [...pairChunks, ...plainChunks];
+            // 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: one input of the interleaving
+                // diagnostic.
+                const chunkMaxSlot = maxEventSlot(results.flatMap((item) => item.error === undefined && item.event ? [item.event] : []));
+                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();
+                // One batched publish per chunk instead of one round trip per step.
+                // The publishes are the fan-out's serialization point: they ride the
+                // shared 8-connection HTTP/1.1 agent (see `getQueueDispatcher` in
+                // world-vercel), and the caller awaits all of them before running
+                // the first inline step body, so N round trips land directly on
+                // time-to-first-step. `queueMessages` falls back to concurrent
+                // single sends on a World with no batch support.
+                await queueMessages(world, 
+                // biome-ignore lint/style/noNonNullAssertion: publishEagerSteps implies presence
+                stepDispatch.queueName, stepEntries.map((entry) => ({
+                    message: {
+                        runId,
+                        stepId: entry.correlationId,
+                        // biome-ignore lint/style/noNonNullAssertion: set on every 'step' entry at enqueue
+                        stepName: entry.stepName,
+                        traceCarrier,
+                        requestedAt: new Date(),
+                        runContext: runDispatchContext(run),
+                    },
+                    opts: {
+                        idempotencyKey: stepDispatchIdempotencyKey(entry.correlationId, 
+                        // biome-ignore lint/style/noNonNullAssertion: set on every 'step' entry at enqueue
+                        entry.stepName),
+                    },
+                })));
+            };
+            // Launch every chunk's POST now (the lone plain entry's guarded
+            // single create included); chain each chunk's publishes on its OWN
+            // commit, so publish-after-create holds for the single too. 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) => chunk === singleChunk ? commitSingle(chunk[0]) : 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. The pairs occupy their own leading
+            // chunk(s), and today that is exactly ONE chunk (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 {
+                await ensureRunReady();
+                // 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
+                // forces an in-process replay, so the restart costs the replay it
+                // was going to do anyway.
+                await createGuarded({
+                    eventType: 'attr_set',
+                    specVersion: SPEC_VERSION_CURRENT,
+                    correlationId: queueItem.correlationId,
+                    eventData: {
+                        changes: queueItem.changes,
+                        writer: { type: 'workflow' },
+                        ...(queueItem.allowReservedAttributes
+                            ? { allowReservedAttributes: true }
+                            : {}),
+                    },
+                }, { requestId });
+            }
+            catch (err) {
+                if (EntityConflictError.is(err)) {
+                    runtimeLogger.info('Workflow attribute event already exists, continuing', {
+                        workflowRunId: runId,
+                        correlationId: queueItem.correlationId,
+                        message: err.message,
+                    });
+                }
+                else if (isWorldValidationFailure(err)) {
+                    // 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
+                    // write and the exact same rejection, so retrying can never
+                    // succeed. Surface it as a FatalError so the caller fails the
+                    // run with a clear error instead of wedging it in redelivery.
+                    const fatal = new FatalError(`setAttributes failed World validation: ${err instanceof Error ? err.message : String(err)}`);
+                    fatal.cause = err;
+                    throw fatal;
+                }
+                else {
+                    throw err;
+                }
+            }
+        })());
+    }
+    // Await the step_created / wait_created event creates before returning.
+    // The caller (workflowEntrypoint) only enqueues the step-dispatch queue
+    // messages AFTER handleSuspension resolves, and the queue handler acks
+    // the orchestrator message only after the caller resolves. So the step_created
+    // events must be durable here, and the dispatch sends must complete in the caller,
+    // all before ack. If the process crashes before this resolves, the orchestrator
+    // message is not acked and VQS redelivers, re-creates the (idempotent)
+    // step_created and re-dispatches, and recovers the run instead of orphaning it.
+    await settlePhase(ops);
+    // Rebuild the inline batch in deterministic order. `lazyInlineCorrelationIds`
+    // is a Set seeded from the ordered first-N slice, so iterating it preserves
+    // stepItems order; every id in it was set by the lazy branch above.
+    const lazyInlineSteps = [];
+    for (const correlationId of lazyInlineCorrelationIds) {
+        const lazyStep = lazyInlineByCorrelationId.get(correlationId);
+        if (lazyStep)
+            lazyInlineSteps.push(lazyStep);
+    }
+    // Find the soonest pending wait (minimum timeout)
     const now = Date.now();
-    const minTimeoutSeconds = waitItems.reduce((min, queueItem) => {
+    let soonestWait;
+    for (const queueItem of waitItems) {
         const resumeAtMs = queueItem.resumeAt.getTime();
         const delayMs = Math.max(1000, resumeAtMs - now);
         const timeoutSeconds = Math.ceil(delayMs / 1000);
-        if (min === null)
-            return timeoutSeconds;
-        return Math.min(min, timeoutSeconds);
-    }, null);
+        if (!soonestWait || timeoutSeconds < soonestWait.seconds) {
+            soonestWait = {
+                seconds: timeoutSeconds,
+                correlationId: queueItem.correlationId,
+            };
+        }
+    }
     span?.setAttributes({
         ...Attribute.WorkflowRunStatus('workflow_suspended'),
         ...Attribute.WorkflowStepsCreated(stepItems.length),
         ...Attribute.WorkflowHooksCreated(hooksNeedingCreation.length),
         ...Attribute.WorkflowWaitsCreated(waitItems.length),
+        ...(failedStepCorrelationIds.size > 0
+            ? Attribute.WorkflowStepsFailedSerialization(failedStepCorrelationIds.size)
+            : {}),
+        ...(resilientDispatchRecovered > 0
+            ? Attribute.StepResilientDispatchRecovered(resilientDispatchRecovered)
+            : {}),
     });
     return {
         pendingSteps: stepItems,
         createdStepCorrelationIds,
-        timeoutSeconds: hasHookConflict ? 0 : (minTimeoutSeconds ?? undefined),
-        hasHookConflict,
+        failedStepCorrelationIds,
+        queuedStepCorrelationIds,
+        lazyInlineSteps,
+        inlineClaims,
+        deferredBatchWork,
+        // On hook conflict the caller advances the workflow over the conflict
+        // before scheduling anything and never reads the wait timeout, so don't
+        // report one. The next pass, which sees the conflict settled, reports it.
+        waitTimeout: hookConflictCorrelationIds.length > 0 ? undefined : soonestWait,
+        hasHookConflict: hookConflictCorrelationIds.length > 0,
+        hookConflictCorrelationIds,
+        hasAwaitedHookCreation: awaitedHookCorrelationIds.length > 0,
+        awaitedHookCorrelationIds,
+        // The delta accounts for the whole log only if the write that returned it
+        // was this suspension's only one — anything written after it landed above
+        // the delta and is missing from the caller's log.
+        eventLogCarriedForward: deltaAbsorbed && guardedWrites === 1,
+        hasAttributeEvents: attributeItems.length > 0,
+        hasHookEvents: hooksNeedingCreation.length > 0,
+        hookCreationMs,
+        serializationBlockerCount,
+        serializationBlockers,
+        reportedEventCount: reportedEvents,
     };
 }
-//# 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 { waitUntil } from '@vercel/functions';\nimport {\n  EntityConflictError,\n  HookNotFoundError,\n  RunExpiredError,\n} from '@workflow/errors';\nimport {\n  type CreateEventRequest,\n  type SerializedData,\n  SPEC_VERSION_CURRENT,\n  type WorkflowRun,\n  type World,\n} from '@workflow/world';\nimport { importKey } from '../encryption.js';\nimport type {\n  HookInvocationQueueItem,\n  StepInvocationQueueItem,\n  WaitInvocationQueueItem,\n  WorkflowSuspension,\n} from '../global.js';\nimport { runtimeLogger } from '../logger.js';\nimport { dehydrateStepArguments } from '../serialization.js';\nimport { getAbortStreamIdFromToken } from '../util.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\n\nexport interface SuspensionHandlerParams {\n  suspension: WorkflowSuspension;\n  world: World;\n  run: WorkflowRun;\n  span?: Span;\n  requestId?: string;\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  /** Timeout from waits, if any */\n  timeoutSeconds?: number;\n  /** Whether a hook conflict was detected (should re-invoke immediately) */\n  hasHookConflict: boolean;\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}: SuspensionHandlerParams): Promise<SuspensionHandlerResult> {\n  const runId = run.runId;\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\n  // Split hooks by what actions they need\n  const hooksNeedingCreation = allHookItems.filter(\n    (item) => !item.hasCreatedEvent\n  );\n  const hooksNeedingDisposal = allHookItems.filter((item) => item.disposed);\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  // Build and process hook_created events (same as V1)\n  const hookEvents: CreateEventRequest[] = await Promise.all(\n    hooksNeedingCreation.map(async (queueItem) => {\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            )) as SerializedData);\n      return {\n        eventType: 'hook_created' as const,\n        specVersion: SPEC_VERSION_CURRENT,\n        correlationId: queueItem.correlationId,\n        eventData: {\n          token: queueItem.token,\n          metadata: hookMetadata,\n          isWebhook: queueItem.isWebhook ?? false,\n          ...(queueItem.isSystem && { isSystem: true }),\n        },\n      };\n    })\n  );\n\n  // Process hooks first to prevent race conditions with webhook receivers.\n  // All hook creations run in parallel.\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\n  if (hookEvents.length > 0) {\n    await Promise.all(\n      hookEvents.map(async (hookEvent) => {\n        try {\n          const result = await world.events.create(runId, hookEvent, {\n            requestId,\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          // Note: hook events always create an event (legacy runs throw, not return undefined)\n          if (result.event!.eventType === 'hook_conflict') {\n            hasHookConflict = true;\n          }\n        } catch (err) {\n          if (EntityConflictError.is(err) || RunExpiredError.is(err)) {\n            runtimeLogger.info(\n              'Workflow run already completed, skipping hook',\n              {\n                workflowRunId: runId,\n                message: err.message,\n              }\n            );\n          } else {\n            throw err;\n          }\n        }\n      })\n    );\n  }\n\n  // Process hook disposals — these release hook tokens for reuse by other workflows.\n  if (hooksNeedingDisposal.length > 0) {\n    await Promise.all(\n      hooksNeedingDisposal.map(async (queueItem) => {\n        const hookDisposedEvent: CreateEventRequest = {\n          eventType: 'hook_disposed' as const,\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: queueItem.correlationId,\n        };\n        try {\n          await world.events.create(runId, 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  }\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 Promise.all(\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          );\n\n          // Create hook_received event with abort payload\n          await world.events.create(runId, {\n            eventType: 'hook_received' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\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  const ops: Promise<void>[] = [];\n\n  // Steps: create step_created events (no queuing — V2 returns pending steps to caller)\n  for (const queueItem of stepItems) {\n    if (stepsNeedingCreation.has(queueItem.correlationId)) {\n      ops.push(\n        (async () => {\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          );\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              input: dehydratedInput as SerializedData,\n            },\n          };\n          try {\n            await world.events.create(runId, 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 world.events.create(runId, 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  waitUntil(\n    Promise.all(ops).catch((opErr) => {\n      const isAbortError =\n        opErr?.name === 'AbortError' || opErr?.name === 'ResponseAborted';\n      if (!isAbortError) throw opErr;\n    })\n  );\n  await Promise.all(ops);\n\n  // Calculate minimum timeout from waits\n  const now = Date.now();\n  const minTimeoutSeconds = waitItems.reduce<number | null>(\n    (min, queueItem) => {\n      const resumeAtMs = queueItem.resumeAt.getTime();\n      const delayMs = Math.max(1000, resumeAtMs - now);\n      const timeoutSeconds = Math.ceil(delayMs / 1000);\n      if (min === null) return timeoutSeconds;\n      return Math.min(min, timeoutSeconds);\n    },\n    null\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  });\n\n  return {\n    pendingSteps: stepItems,\n    createdStepCorrelationIds,\n    timeoutSeconds: hasHookConflict ? 0 : (minTimeoutSeconds ?? undefined),\n    hasHookConflict,\n  };\n}\n"]}
+/**
+ * Whether an `events.create` rejection is deterministic World validation
+ * rather than a transient/storage error. Local Worlds
+ * (world-local, world-postgres) throw `AttributeValidationError` directly;
+ * remote Worlds surface the equivalent server-side rejection as a
+ * `WorkflowWorldError` with HTTP status 400. The name check covers
+ * `AttributeValidationError` instances from a different copy of
+ * `@workflow/world` than the one this package resolved.
+ */
+function isWorldValidationFailure(err) {
+    if (err instanceof AttributeValidationError)
+        return true;
+    if (err instanceof Error && err.name === 'AttributeValidationError') {
+        return true;
+    }
+    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  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 {\n  GUEST_CODE_EXECUTION_SAMPLE_LIMIT,\n  type GuestCodeExecution,\n  type GuestCodeStats,\n} 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  appendEventLog,\n  type EventCreator,\n  type LoadedEventLog,\n  maxEventSlot,\n  queueMessage,\n  queueMessages,\n  runDispatchContext,\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   * Extended in place by what those writes report back — the events on slots\n   * they skipped over, and (on the hook create) the inline delta since its\n   * cursor. Whether the log is complete afterwards is answered by\n   * {@link SuspensionHandlerResult.eventLogCarriedForward}.\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 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  /**\n   * Whether a hook create committed a `hook_conflict` — the token was already\n   * claimed, so this run's hook was never created and the workflow must\n   * observe the conflict before anything else this suspension scheduled runs.\n   * The caller answers it by advancing the workflow over the committed event.\n   */\n  hasHookConflict: boolean;\n  /** Whether a `hook.getConflict()` awaiter needs the workflow to continue immediately */\n  hasAwaitedHookCreation: boolean;\n  /**\n   * Correlation ids of the hooks this suspension committed a `hook_created`\n   * for while a `hook.getConflict()` awaiter was waiting on it — the events\n   * that resolve those awaiters on the next pass. Empty exactly when\n   * {@link hasAwaitedHookCreation} is false.\n   *\n   * Reported by id, not just counted, so a caller that continues in this\n   * process can tell a continuation that got somewhere from one that is\n   * repeating: a workflow may create one awaited hook after another, and each\n   * new id is a pass that made progress, while the same id coming back means\n   * the pass ran over a log that still did not hold its event and continuing\n   * again cannot change that.\n   */\n  awaitedHookCorrelationIds: string[];\n  /**\n   * Correlation ids of the hooks whose create committed a `hook_conflict`.\n   * Empty exactly when {@link hasHookConflict} is false.\n   *\n   * By id for the same reason as {@link awaitedHookCorrelationIds}, and\n   * against the same hazard: a conflict is resolved by the `hook_conflict`\n   * this suspension committed, and until the workflow observes it the hook\n   * stays in the invocations queue and the next pass writes the create again.\n   * A fresh id is progress; the same id coming back is a pass that ran over a\n   * log which still did not hold the event, so continuing again cannot change\n   * that.\n   */\n  hookConflictCorrelationIds: string[];\n  /**\n   * Whether the caller's `eventLog` now holds every event this suspension\n   * committed, so a caller that continues in this process can replay — or\n   * resume a retained VM — straight off it with no read.\n   *\n   * True only when the hook create's inline delta came back complete and was\n   * folded in (see `hookDeltaCursor` below), and nothing else in this\n   * suspension wrote an event. False whenever a read is needed first: no\n   * delta was asked for or returned, it was truncated, or a step / wait /\n   * attribute / abort write landed above it and is therefore not in it.\n   *\n   * Indifferent to which event the create committed: the delta is the slice\n   * of the log after the caller's cursor either way, so it carries a\n   * `hook_conflict` exactly as it carries a `hook_created`.\n   */\n  eventLogCarriedForward: 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  /** Exact number of workflow-code executions observed during serialization. */\n  serializationBlockerCount: number;\n  /** Bounded sample used only for retention diagnostics. */\n  serializationBlockers: SuspensionSerializationBlocker[];\n}\n\nexport interface SuspensionSerializationBlocker extends GuestCodeExecution {\n  source: 'step_input' | 'hook_metadata' | 'hook_abort';\n  correlationId: string;\n}\n\nasync function createHookEvent({\n  runId,\n  hookEvent,\n  queueItem,\n  requestId,\n  sinceCursor,\n  createEvent,\n}: {\n  runId: string;\n  hookEvent: CreateEventRequest;\n  queueItem: HookInvocationQueueItem;\n  requestId?: string;\n  /**\n   * Cursor to ask the World for the event-log delta against, or undefined to\n   * not ask. See `hookDeltaCursor` in {@link handleSuspension} for when it is\n   * set and why it is at most one write per suspension.\n   */\n  sinceCursor?: 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      ...(sinceCursor === undefined ? {} : { sinceCursor }),\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 is what the next\n    // pass consumes to settle the hook's awaiters — rejecting a payload await,\n    // resolving a `hook.getConflict()` with the conflicting run. An inline\n    // delta asked for above carries it just as it would have carried the\n    // hook_created, so the caller can advance over it without a re-invocation.\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  // Writes this suspension issued, and whether one of them handed back a\n  // complete inline delta that was folded into the caller's log. Together they\n  // answer `eventLogCarriedForward`: the delta covers the log up to the write\n  // that returned it, so it accounts for every event this suspension committed\n  // only if that write was the only one.\n  let guardedWrites = 0;\n  let deltaAbsorbed = false;\n  const createGuarded: EventCreator = async (data, params) => {\n    guardedWrites++;\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    // An inline delta this call asked for (`sinceCursor`) is everything the\n    // log gained since that cursor, this write included, so it is folded onto\n    // the tail and carries the cursor with it — unlike a skipped-slot report,\n    // which is a window strictly below the write and has to be sorted back\n    // into place. A World returns one or the other, never both (the delta is a\n    // strict superset), so the two are handled apart rather than merged.\n    //\n    // Declining is always safe — an unabsorbed delta is one the next read\n    // returns — so the guards match the replay loop's `absorbCreateDelta`: a\n    // truncated page (`hasMore`) is dropped whole rather than advancing the\n    // cursor past events it did not carry, and the log must still be where the\n    // request was computed from, since appending does not re-sort.\n    if (typeof params?.sinceCursor === 'string') {\n      if (\n        log.cursor === params.sinceCursor &&\n        result.events !== undefined &&\n        result.hasMore !== true\n      ) {\n        appendEventLog(log, { events: result.events, cursor: result.cursor });\n        deltaAbsorbed = true;\n      }\n      return result;\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.items.filter(\n    (item): item is StepInvocationQueueItem => item.type === 'step'\n  );\n  const allHookItems = suspension.items.filter(\n    (item): item is HookInvocationQueueItem => item.type === 'hook'\n  );\n  const waitItems = suspension.items.filter(\n    (item): item is WaitInvocationQueueItem => item.type === 'wait'\n  );\n  const attributeItems = suspension.items.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  let serializationBlockerCount = 0;\n  const serializationBlockers: SuspensionSerializationBlocker[] = [];\n  async function dehydrateInput(\n    value: unknown,\n    context: Pick<SuspensionSerializationBlocker, 'source' | 'correlationId'>\n  ): Promise<SerializedData> {\n    const stats: GuestCodeStats = { executions: [] };\n    try {\n      return (await dehydrateStepArguments(\n        value,\n        runId,\n        encryptionKey,\n        suspension.globalThis,\n        false,\n        compression,\n        stats\n      )) as SerializedData;\n    } finally {\n      serializationBlockerCount +=\n        stats.totalExecutions ?? stats.executions.length;\n      serializationBlockers.push(\n        ...stats.executions\n          .slice(\n            0,\n            GUEST_CODE_EXECUTION_SAMPLE_LIMIT - serializationBlockers.length\n          )\n          .map((execution) => ({ ...context, ...execution }))\n      );\n    }\n  }\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 so\n  // it can advance the workflow over the committed `hook_conflict` before\n  // anything else this suspension scheduled runs.\n  const hookConflictCorrelationIds: string[] = [];\n  const awaitedHookCorrelationIds: string[] = [];\n  let hookCreationMs = 0;\n\n  // Ask the hook create for the event-log delta since the cursor the caller's\n  // log was read at. The hook's awaiters are settled by the event this write\n  // commits and by nothing else — a `hook_created` for a clean registration,\n  // a `hook_conflict` when the token was already claimed — so the caller can\n  // continue the workflow in its own process on either outcome, but only over\n  // a log that holds that event, and this write is the one request that can\n  // hand it back together with anything another writer landed in the meantime.\n  // Optional by contract: a World that ignores `sinceCursor` returns no delta\n  // and the caller reads instead.\n  //\n  // Asked for on the single-hook suspension only. Two creates issued from one\n  // snapshot each diff against the same cursor, and only the first delta back\n  // can be folded in (the cursor moves with it), so the log would end up short\n  // of the other's event with nothing to say so.\n  const hookDeltaCursor =\n    hooksNeedingCreation.length === 1 && typeof eventLog?.cursor === 'string'\n      ? eventLog.cursor\n      : undefined;\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 =\n              typeof queueItem.metadata === 'undefined'\n                ? undefined\n                : await dehydrateInput(queueItem.metadata, {\n                    source: 'hook_metadata',\n                    correlationId: queueItem.correlationId,\n                  });\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              sinceCursor: hookDeltaCursor,\n              createEvent: createGuarded,\n            });\n            if (result.hasHookConflict) {\n              hookConflictCorrelationIds.push(queueItem.correlationId);\n            }\n            if (result.hasAwaitedHookCreation) {\n              awaitedHookCorrelationIds.push(queueItem.correlationId);\n            }\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 dehydrateInput(\n            {\n              aborted: true,\n              reason: queueItem.abortReason,\n            },\n            {\n              source: 'hook_abort',\n              correlationId: queueItem.correlationId,\n            }\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 count 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  // 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 continues the workflow to resolve the awaiter instead), so deferring\n  // would 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    awaitedHookCorrelationIds.length === 0\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 inline steps' claims commit in\n  // one durable write (the pair chunk, see the flush below) and the caller\n  // starts the bodies straight off that commit instead of posting one claim\n  // per inline step. Requires TWO or more inline steps, and nothing else:\n  // the pairs commit in a chunk of their own, so plain creates alongside\n  // them share no round trip with the pairs and cannot make a lone pair\n  // worth folding. A lone inline step is better served by the lazy\n  // `step_started`: one row instead of two, optimistic-start capable (the\n  // claim overlaps the body), with the slot-snapshot params and\n  // bump-and-report `createGuarded` provides, all of which a pair-only\n  // batch of one pair gives up for the same round trip. Two or more inline\n  // steps become ONE pair chunk instead of N parallel lazy claims, which is\n  // the saving. A lone inline step alongside eager creates therefore takes\n  // the lazy path while the creates still batch. Also requires the caller's\n  // `ownerMessageId`: the started row must stamp ownership exactly like the\n  // lazy claim it replaces (and a caller that does not inline-execute never\n  // provides one).\n  const inlinePairFoldEligible =\n    batchFanoutEligible &&\n    ownerMessageId !== undefined &&\n    lazyInlineCorrelationIds.size >= 2;\n  const inlineClaims: SuspensionHandlerResult['inlineClaims'] = new Map();\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, never splits across chunks,\n      // and commits in a pair-only chunk ahead of the plain creates, so a\n      // 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        let dehydratedInput: SerializedData;\n        try {\n          dehydratedInput = await dehydrateInput(\n            {\n              args: queueItem.args,\n              closureVars: queueItem.closureVars,\n              thisVal: queueItem.thisVal,\n            },\n            {\n              source: 'step_input',\n              correlationId: queueItem.correlationId,\n            }\n          );\n        } catch (err) {\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        // 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,\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                runContext: runDispatchContext(run),\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  // and that chunk carries NOTHING else, so its commit is as small as the\n  // inline slice (see the chunking below).\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        // The ordinary single path for a lone plain entry: a batch of ONE\n        // gains nothing over the single write (same round trip) and loses\n        // the slot-snapshot params + bump-and-report that createGuarded\n        // provides, so a lone eager event is written the way it would have\n        // been without the fold, with the same conflict tolerance and\n        // ownership bookkeeping. Used when the whole fold is one entry\n        // (below) and when the plain partition beside the pairs is one\n        // entry (the chunking further down). Beside a pair chunk it commits\n        // concurrently with the handler's return, like a trailing chunk; the\n        // inline bodies do not depend on it (executor writes carry no slot\n        // snapshot, so there is no position for it to move).\n        const commitSingle = async (\n          entry: (typeof entries)[number]\n        ): Promise<void> => {\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        };\n        if (entries.length === 1) {\n          await commitSingle(entries[0]);\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. Two rules:\n        //\n        // 1. A pre-claimed pair's two rows must land in the same createBatch\n        //    call (adjacent, so a World can fold them into one born-running\n        //    create) and never straddle a chunk boundary, which would turn\n        //    the started row into a standalone claim racing its own\n        //    create's commit.\n        // 2. The pairs commit in chunk(s) of THEIR OWN, ahead of the plain\n        //    `step`/`wait` creates, which fill the subsequent chunks. The\n        //    pair chunk is the one commit the inline bodies wait for (see\n        //    `pairCommits` below), and on the Vercel backend its latency\n        //    scales with the transaction's item count: measured on 32-branch\n        //    fan-outs, batches of <=8 events commit in ~56 ms p50 server-side\n        //    where batches of 24-32 events take ~110 ms. Padding the pair\n        //    chunk with plain creates up to the cap therefore held the\n        //    bodies for the plain creates' commit, which nothing else\n        //    needed: a plain create gates only its own queue publish, and\n        //    that fires off whichever sibling chunk carries it. Splitting\n        //    them keeps the pair chunk small (two rows per inline step) and\n        //    lets the plain creates commit concurrently beside it.\n        const chunkEntries = (list: typeof entries): (typeof entries)[] => {\n          const out: (typeof entries)[] = [];\n          let current: typeof entries = [];\n          for (let index = 0; index < list.length; index++) {\n            const entry = list[index];\n            const next = list[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              out.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) out.push(current);\n          return out;\n        };\n        // Both partitions keep `entries`' order, so a pair's two rows\n        // (consecutive `order` values, enqueued together) stay adjacent in\n        // the pair partition.\n        const isPairRow = (entry: (typeof entries)[number]): boolean =>\n          entry.kind === 'inline-created' || entry.kind === 'inline-started';\n        const pairChunks = chunkEntries(\n          entries.filter((entry) => isPairRow(entry))\n        );\n        const plainEntries = entries.filter((entry) => !isPairRow(entry));\n        // A plain partition of exactly ONE entry is the batch-of-one case\n        // again, now that the pairs no longer share its chunk: it takes the\n        // single path (`commitSingle`) rather than a one-row createBatch,\n        // and is carried as a one-entry chunk so the per-chunk publish and\n        // settle machinery below treats it like any sibling. (A one-row\n        // remainder of a LARGER plain partition still batches: it is the\n        // pre-split behavior, unchanged here.)\n        const plainChunks =\n          plainEntries.length === 1\n            ? [plainEntries]\n            : chunkEntries(plainEntries);\n        const singleChunk =\n          plainEntries.length === 1 ? plainChunks[0] : undefined;\n        const chunks: (typeof entries)[] = [...pairChunks, ...plainChunks];\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: one input of the interleaving\n          // diagnostic.\n          const chunkMaxSlot = maxEventSlot(\n            results.flatMap((item) =>\n              item.error === undefined && item.event ? [item.event] : []\n            )\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          // One batched publish per chunk instead of one round trip per step.\n          // The publishes are the fan-out's serialization point: they ride the\n          // shared 8-connection HTTP/1.1 agent (see `getQueueDispatcher` in\n          // world-vercel), and the caller awaits all of them before running\n          // the first inline step body, so N round trips land directly on\n          // time-to-first-step. `queueMessages` falls back to concurrent\n          // single sends on a World with no batch support.\n          await queueMessages(\n            world,\n            // biome-ignore lint/style/noNonNullAssertion: publishEagerSteps implies presence\n            stepDispatch!.queueName,\n            stepEntries.map((entry) => ({\n              message: {\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                runContext: runDispatchContext(run),\n              },\n              opts: {\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        // Launch every chunk's POST now (the lone plain entry's guarded\n        // single create included); chain each chunk's publishes on its OWN\n        // commit, so publish-after-create holds for the single too. A chunk\n        // whose commit rejected keeps its messages unsent (the rejection\n        // fails the delivery; redelivery re-creates and re-dispatches,\n        // deduped by the idempotency keys).\n        const commits = chunks.map((chunk) =>\n          chunk === singleChunk ? commitSingle(chunk[0]) : commitChunk(chunk)\n        );\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. The pairs occupy their own leading\n        // chunk(s), and today that is exactly ONE chunk (two rows per\n        // inline step fit inside one chunk, pinned by constants.test.ts),\n        // so this is at most one commit; the filter is what keeps the\n        // property true if either cap 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  // 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    deferredBatchWork,\n    // On hook conflict the caller advances the workflow over the conflict\n    // before scheduling anything and never reads the wait timeout, so don't\n    // report one. The next pass, which sees the conflict settled, reports it.\n    waitTimeout:\n      hookConflictCorrelationIds.length > 0 ? undefined : soonestWait,\n    hasHookConflict: hookConflictCorrelationIds.length > 0,\n    hookConflictCorrelationIds,\n    hasAwaitedHookCreation: awaitedHookCorrelationIds.length > 0,\n    awaitedHookCorrelationIds,\n    // The delta accounts for the whole log only if the write that returned it\n    // was this suspension's only one — anything written after it landed above\n    // the delta and is missing from the caller's log.\n    eventLogCarriedForward: deltaAbsorbed && guardedWrites === 1,\n    hasAttributeEvents: attributeItems.length > 0,\n    hasHookEvents: hooksNeedingCreation.length > 0,\n    hookCreationMs,\n    serializationBlockerCount,\n    serializationBlockers,\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"]}