@workflow/core 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/runtime/suspension-handler.js

@@ -1,128 +1,294 @@
-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, WorkflowWorldError, } from '@workflow/errors';
+import { AttributeValidationError, SPEC_VERSION_CURRENT, SPEC_VERSION_SUPPORTS_COMPRESSION, } from '@workflow/world';
 import { importKey } from '../encryption.js';
 import { runtimeLogger } from '../logger.js';
 import { dehydrateStepArguments } from '../serialization.js';
 import * as Attribute from '../telemetry/semantic-conventions.js';
-import { serializeTraceCarrier } from '../telemetry.js';
-import { queueMessage } from './helpers.js';
-/**
- * Extracts W3C trace context headers from a trace carrier for HTTP propagation.
- * Returns an object with `traceparent` and optionally `tracestate` headers.
- */
-function extractTraceHeaders(traceCarrier) {
-    const headers = {};
-    if (traceCarrier.traceparent) {
-        headers.traceparent = traceCarrier.traceparent;
+import { getAbortStreamIdFromToken } from '../util.js';
+import { getMaxInlineSteps } from './constants.js';
+import { preconditionSnapshotParams, } from './helpers.js';
+import { ReplayRecoveryReporter } from './replay-recovery-reporter.js';
+async function createHookEvent({ runId, hookEvent, queueItem, requestId, createEvent, }) {
+    try {
+        const result = await createEvent(hookEvent, {
+            requestId,
+        });
+        // 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.
+        if (result.event?.eventType === 'hook_conflict') {
+            return {
+                hasHookConflict: true,
+                hasAwaitedHookCreation: false,
+            };
+        }
+        return {
+            hasHookConflict: false,
+            hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true,
+        };
     }
-    if (traceCarrier.tracestate) {
-        headers.tracestate = traceCarrier.tracestate;
+    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,
+            };
+        }
+        throw err;
     }
-    return headers;
 }
 /**
  * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).
- * Uses an event-sourced architecture where entities (steps, hooks) are created atomically
- * with their corresponding events via events.create().
+ * 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. Steps and waits are processed in parallel after hooks complete
+ * 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, }) {
     const runId = run.runId;
-    const workflowName = run.workflowName;
-    const workflowStartedAt = run.startedAt ? +run.startedAt : Date.now();
+    // 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.
+    const createGuarded = (data, params) => eventLog
+        ? createEvent(data, {
+            ...params,
+            ...preconditionSnapshotParams(eventLog.events, eventLog.cursor),
+        })
+        : createEvent(data, params);
     // 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 attributeItems = suspension.steps.filter((item) => item.type === 'attribute');
     const hooksNeedingCreation = allHookItems.filter((item) => !item.hasCreatedEvent);
-    // Hooks needing disposal: any disposed hook (including those needing creation first)
-    // Hooks are created before disposal in the processing order below
-    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 hook_created events (World will atomically create hook entities)
-    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;
+    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,
             },
         };
-    }));
-    // Process hooks first to prevent race conditions with webhook receivers
-    // All hook creations run in parallel
-    // Track any hook conflicts that occur - these will be handled by re-enqueueing the workflow
-    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 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,
+                    correlationId: queueItem.correlationId,
+                    message: err.message,
+                });
+            }
+            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 the V2 handler can re-invoke immediately.
+    let hasHookConflict = false;
+    let hasAwaitedHookCreation = false;
+    let hookCreationMs = 0;
+    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 dehydrateStepArguments(queueItem.metadata, runId, encryptionKey, suspension.globalThis, false, compression));
+                    const hookEvent = {
+                        eventType: 'hook_created',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        correlationId: queueItem.correlationId,
+                        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,
+                        createEvent: createGuarded,
                     });
+                    hasHookConflict ||= result.hasHookConflict;
+                    hasAwaitedHookCreation ||= result.hasAwaitedHookCreation;
+                    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 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,
-            };
+    // Process abort requests — resume the hook with abort payload and write stream packet
+    const hooksNeedingAbort = allHookItems.filter((item) => item.abortRequested && !item.disposed);
+    if (hooksNeedingAbort.length > 0) {
+        await ensureRunReady();
+        await settlePhase(hooksNeedingAbort.map(async (queueItem) => {
             try {
-                await world.events.create(runId, 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,
-                    });
+                // Dehydrate the abort payload for storage
+                const abortPayload = await dehydrateStepArguments({ aborted: true, reason: queueItem.abortReason }, runId, encryptionKey, suspension.globalThis, false, compression);
+                // Create hook_received event with abort payload
+                await createGuarded({
+                    eventType: 'hook_received',
+                    specVersion: SPEC_VERSION_CURRENT,
+                    correlationId: queueItem.correlationId,
+                    eventData: {
+                        token: queueItem.token,
+                        payload: abortPayload,
+                    },
+                });
+                // Write stream cancellation packet for real-time step propagation.
+                // Reuse the same dehydrated payload as the hook event so the reason
+                // round-trips through `dehydrateStepArguments` / `hydrateStepArguments`
+                // (handles DOMException, custom errors, encryption, etc.) instead of
+                // bare JSON.stringify which loses type information and drops undefined.
+                // streamName is set on the queue item at controller construction time
+                // (see workflow/abort-controller.ts).
+                try {
+                    const streamName = getAbortStreamIdFromToken(queueItem.token);
+                    await world.streams.write(runId, streamName, abortPayload);
+                    await world.streams.close(runId, streamName);
                 }
-                else if (RunExpiredError.is(err)) {
-                    runtimeLogger.info('Workflow run already completed, skipping hook disposal', {
+                catch {
+                    // 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,
-                        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', {
+            }
+            catch (err) {
+                if (EntityConflictError.is(err) || RunExpiredError.is(err)) {
+                    runtimeLogger.info('Workflow run already completed, skipping abort', {
                         workflowRunId: runId,
                         correlationId: queueItem.correlationId,
                         message: err.message,
@@ -134,35 +300,92 @@ export async function handleSuspension({ suspension, world, run, span, requestId
             }
         }));
     }
-    // Build a map of stepId -> step event for steps that need creation
+    // Create step events for steps that don't have them yet.
+    // 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
         .filter((queueItem) => !queueItem.hasCreatedEvent)
         .map((queueItem) => queueItem.correlationId));
-    // Process steps and waits in parallel
-    // Each step: create event (if needed) -> queue message
-    // Each wait: create event (if needed)
+    // 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
+    // racing with concurrent handlers on step execution.
+    const createdStepCorrelationIds = new Set();
+    // Serialization always runs through the one ordinary path below, so the
+    // durable bytes cannot depend on retention. What retention needs to know is
+    // whether that serialization *executed* workflow code (getters, proxy
+    // traps, custom serializers) — side effects a cold replay would not
+    // repeat, since a replay skips dehydration for already-recorded steps.
+    // The hardened serializer records exactly that into this sink (see
+    // ../serialization/hardened.ts); when any input in the batch records an
+    // execution, the caller demotes the session so the side effects land in a
+    // VM that is about to be discarded, exactly like the pre-retention
+    // runtime.
+    const guestCodeStats = { executions: [] };
+    // 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 re-invokes immediately to resolve the awaiter), so deferring would
+    // leave the steps uncreated and unqueued. We pick the first N uncreated steps
+    // — matching the caller's inline-candidate selection — and dehydrate their
+    // input here so executeStep can ship it as the step_started payload.
+    const lazyInlineCorrelationIds = new Set(hasAwaitedHookCreation === false
+        ? 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 event then queue message, all in parallel
+    // Steps: create step_created events (no queuing — V2 returns pending steps to caller)
     for (const queueItem of stepItems) {
-        ops.push((async () => {
-            // Create step event if not already created
-            if (stepsNeedingCreation.has(queueItem.correlationId)) {
+        if (stepsNeedingCreation.has(queueItem.correlationId)) {
+            ops.push((async () => {
+                // Per-step sink, merged below: the dehydrate wrapper emits span
+                // attributes from the sink it is handed, so sharing one across
+                // steps would re-emit (and misattribute) earlier steps' entries.
+                const stepGuestCode = { executions: [] };
                 const dehydratedInput = await dehydrateStepArguments({
                     args: queueItem.args,
                     closureVars: queueItem.closureVars,
                     thisVal: queueItem.thisVal,
-                }, runId, encryptionKey, suspension.globalThis);
+                }, runId, encryptionKey, suspension.globalThis, false, compression, stepGuestCode);
+                guestCodeStats.executions.push(...stepGuestCode.executions);
+                // 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: dehydratedInput,
+                    });
+                    return;
+                }
                 const stepEvent = {
                     eventType: 'step_created',
                     specVersion: SPEC_VERSION_CURRENT,
                     correlationId: queueItem.correlationId,
                     eventData: {
                         stepName: queueItem.stepName,
+                        workflowName: run.workflowName,
                         input: dehydratedInput,
                     },
                 };
                 try {
-                    await world.events.create(runId, stepEvent, { requestId });
+                    await ensureRunReady();
+                    await createGuarded(stepEvent, { requestId });
+                    createdStepCorrelationIds.add(queueItem.correlationId);
                 }
                 catch (err) {
                     if (EntityConflictError.is(err)) {
@@ -176,28 +399,10 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                         throw err;
                     }
                 }
-            }
-            // Queue step execution message
-            // Serialize trace context once and include in both payload and headers
-            // Payload: for manual context restoration in step handler
-            // Headers: for automatic trace propagation by Vercel's infrastructure
-            const traceCarrier = await serializeTraceCarrier();
-            await queueMessage(world, `__wkf_step_${queueItem.stepName}`, {
-                workflowName,
-                workflowRunId: runId,
-                workflowStartedAt,
-                stepId: queueItem.correlationId,
-                traceCarrier,
-                requestedAt: new Date(),
-            }, {
-                idempotencyKey: queueItem.correlationId,
-                headers: {
-                    ...extractTraceHeaders(traceCarrier),
-                },
-            });
-        })());
+            })());
+        }
     }
-    // Waits: create events in parallel (no queueing needed for waits)
+    // Create wait events (same as V1)
     for (const queueItem of waitItems) {
         if (!queueItem.hasCreatedEvent) {
             ops.push((async () => {
@@ -210,7 +415,8 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                     },
                 };
                 try {
-                    await world.events.create(runId, waitEvent, { requestId });
+                    await ensureRunReady();
+                    await createGuarded(waitEvent, { requestId });
                 }
                 catch (err) {
                     if (EntityConflictError.is(err)) {
@@ -227,40 +433,133 @@ export async function handleSuspension({ suspension, world, run, span, requestId
             })());
         }
     }
-    // Wait for all step and wait operations to complete
-    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
+    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 (isAttributeValidationFailure(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);
+    // The step-input dehydrations above have settled, so the sink is final.
+    const retainedStepInputsSafe = guestCodeStats.executions.length === 0;
+    if (!retainedStepInputsSafe) {
+        runtimeLogger.debug('Serializing step inputs executed workflow code; falling back to replay instead of retaining the VM', {
+            workflowRunId: runId,
+            executions: guestCodeStats.executions
+                .slice(0, 5)
+                .map((e) => (e.detail ? `${e.kind}(${e.detail})` : e.kind)),
+        });
+    }
+    // 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),
     });
-    // If any hook conflicts occurred, re-enqueue the workflow immediately
-    // On the next iteration, the hook consumer will see the hook_conflict event
-    // and reject the promise with a WorkflowRuntimeError
-    // We do this after processing all other operations (steps, waits) to ensure
-    // they are recorded in the event log before the re-execution
-    if (hasHookConflict) {
-        return { timeoutSeconds: 0 };
-    }
-    if (minTimeoutSeconds !== null) {
-        return { timeoutSeconds: minTimeoutSeconds };
+    return {
+        pendingSteps: stepItems,
+        createdStepCorrelationIds,
+        lazyInlineSteps,
+        // On hook conflict the caller re-invokes immediately and never reads
+        // the wait timeout, so don't report one.
+        waitTimeout: hasHookConflict ? undefined : soonestWait,
+        hasHookConflict,
+        hasAwaitedHookCreation,
+        hasAttributeEvents: attributeItems.length > 0,
+        hasHookEvents: hooksNeedingCreation.length > 0,
+        hookCreationMs,
+        retainedStepInputsSafe,
+    };
+}
+/**
+ * Whether an `events.create` rejection is a deterministic attribute
+ * validation failure 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 isAttributeValidationFailure(err) {
+    if (err instanceof AttributeValidationError)
+        return true;
+    if (err instanceof Error && err.name === 'AttributeValidationError') {
+        return true;
     }
-    return {};
+    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 { 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 * as Attribute from '../telemetry/semantic-conventions.js';\nimport { serializeTraceCarrier } from '../telemetry.js';\nimport { queueMessage } from './helpers.js';\n\n/**\n * Extracts W3C trace context headers from a trace carrier for HTTP propagation.\n * Returns an object with `traceparent` and optionally `tracestate` headers.\n */\nfunction extractTraceHeaders(\n  traceCarrier: Record<string, string>\n): Record<string, string> {\n  const headers: Record<string, string> = {};\n  if (traceCarrier.traceparent) {\n    headers.traceparent = traceCarrier.traceparent;\n  }\n  if (traceCarrier.tracestate) {\n    headers.tracestate = traceCarrier.tracestate;\n  }\n  return headers;\n}\n\nexport interface SuspensionHandlerParams {\n  suspension: WorkflowSuspension;\n  world: World;\n  run: WorkflowRun;\n  span?: Span;\n  requestId?: string;\n}\n\nexport interface SuspensionHandlerResult {\n  timeoutSeconds?: number;\n}\n\n/**\n * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).\n * Uses an event-sourced architecture where entities (steps, hooks) are created atomically\n * with their corresponding events via events.create().\n *\n * Processing order:\n * 1. Hooks are processed first to prevent race conditions with webhook receivers\n * 2. Steps and waits are processed in parallel after hooks complete\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  const workflowName = run.workflowName;\n  const workflowStartedAt = run.startedAt ? +run.startedAt : Date.now();\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  // Hooks needing disposal: any disposed hook (including those needing creation first)\n  // Hooks are created before disposal in the processing order below\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 hook_created events (World will atomically create hook entities)\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        },\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 will be handled by re-enqueueing the workflow\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  // Build a map of stepId -> step event for steps that need creation\n  const stepsNeedingCreation = new Set(\n    stepItems\n      .filter((queueItem) => !queueItem.hasCreatedEvent)\n      .map((queueItem) => queueItem.correlationId)\n  );\n\n  // Process steps and waits in parallel\n  // Each step: create event (if needed) -> queue message\n  // Each wait: create event (if needed)\n  const ops: Promise<void>[] = [];\n\n  // Steps: create event then queue message, all in parallel\n  for (const queueItem of stepItems) {\n    ops.push(\n      (async () => {\n        // Create step event if not already created\n        if (stepsNeedingCreation.has(queueItem.correlationId)) {\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          } 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        // Queue step execution message\n        // Serialize trace context once and include in both payload and headers\n        // Payload: for manual context restoration in step handler\n        // Headers: for automatic trace propagation by Vercel's infrastructure\n        const traceCarrier = await serializeTraceCarrier();\n        await queueMessage(\n          world,\n          `__wkf_step_${queueItem.stepName}`,\n          {\n            workflowName,\n            workflowRunId: runId,\n            workflowStartedAt,\n            stepId: queueItem.correlationId,\n            traceCarrier,\n            requestedAt: new Date(),\n          },\n          {\n            idempotencyKey: queueItem.correlationId,\n            headers: {\n              ...extractTraceHeaders(traceCarrier),\n            },\n          }\n        );\n      })()\n    );\n  }\n\n  // Waits: create events in parallel (no queueing needed for waits)\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  // Wait for all step and wait operations to complete\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  // If any hook conflicts occurred, re-enqueue the workflow immediately\n  // On the next iteration, the hook consumer will see the hook_conflict event\n  // and reject the promise with a WorkflowRuntimeError\n  // We do this after processing all other operations (steps, waits) to ensure\n  // they are recorded in the event log before the re-execution\n  if (hasHookConflict) {\n    return { timeoutSeconds: 0 };\n  }\n\n  if (minTimeoutSeconds !== null) {\n    return { timeoutSeconds: minTimeoutSeconds };\n  }\n\n  return {};\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"suspension-handler.js","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Span } from '@opentelemetry/api';\nimport {\n  EntityConflictError,\n  FatalError,\n  HookNotFoundError,\n  PreconditionFailedError,\n  RunExpiredError,\n  WorkflowWorldError,\n} from '@workflow/errors';\nimport {\n  AttributeValidationError,\n  type CreateEventRequest,\n  type SerializedData,\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_SUPPORTS_COMPRESSION,\n  type WorkflowRun,\n  type World,\n} from '@workflow/world';\nimport { importKey } from '../encryption.js';\nimport type {\n  AttributeInvocationQueueItem,\n  HookInvocationQueueItem,\n  StepInvocationQueueItem,\n  WaitInvocationQueueItem,\n  WorkflowSuspension,\n} from '../global.js';\nimport { runtimeLogger } from '../logger.js';\nimport type { GuestCodeStats } from '../serialization/hardened.js';\nimport { dehydrateStepArguments } from '../serialization.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { getAbortStreamIdFromToken } from '../util.js';\nimport { getMaxInlineSteps } from './constants.js';\nimport {\n  type EventCreator,\n  type LoadedEventLog,\n  preconditionSnapshotParams,\n} from './helpers.js';\nimport { ReplayRecoveryReporter } from './replay-recovery-reporter.js';\n\nexport interface SuspensionHandlerParams {\n  suspension: WorkflowSuspension;\n  world: World;\n  run: WorkflowRun;\n  span?: Span;\n  requestId?: string;\n  /**\n   * The runtime's loaded event log. Every event creation this suspension makes\n   * is sent with the precondition snapshot derived from it, so a backend that\n   * has recorded an event the replay did not see rejects the write with a 412\n   * instead of accepting a divergent event. The rejection is not retried here:\n   * the event's correlation id was minted by *this* replay's seeded sequence,\n   * so re-committing it against a corrected log would persist an event no\n   * correct replay produces. The caller restarts the replay instead.\n   */\n  eventLog?: LoadedEventLog;\n  /**\n   * Turbo mode only: a promise that resolves once the backgrounded\n   * `run_started` has landed (the run exists). When present, every world write\n   * this suspension performs (`hook_created`, `wait_created`, eager overflow\n   * `step_created`, …) is gated on it so the write never races ahead of the\n   * run's creation. The pure inline hot path defers all of its steps and writes\n   * nothing here, so it never awaits this barrier. `undefined` outside turbo,\n   * where `run_started` was already awaited up front.\n   */\n  runReadyBarrier?: Promise<unknown>;\n  /** One-shot telemetry reporter, activated only after replay has recovered. */\n  replayRecoveryReporter?: ReplayRecoveryReporter;\n}\n\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   * The steps whose `step_created` writes were intentionally deferred so the\n   * caller can run them inline via lazy `step_started` events (which create\n   * the step on the fly), saving one world round-trip per inline step. Up to\n   * `getMaxInlineSteps()` steps are deferred; the caller runs them inline in\n   * parallel and queues the rest. Empty when no step was deferred (nothing\n   * pending, or a `hook.getConflict()` awaiter is present so nothing is\n   * executed inline). The caller passes each `dehydratedInput` straight to\n   * `executeStep`, which sends it as the `step_started` payload. The atomic\n   * create-claim inside each `step_started` is the exactly-one-owner gate that\n   * the standalone `step_created` provided before: the loser of the race gets\n   * `EntityConflictError` → `skipped` and does not run the body.\n   */\n  lazyInlineSteps: Array<{\n    correlationId: string;\n    stepName: string;\n    dehydratedInput: SerializedData;\n  }>;\n  /**\n   * The soonest pending wait, if any: seconds until it elapses and the\n   * correlationId of the wait that produced that timeout. The\n   * correlationId seeds the idempotency key for the wait-continuation\n   * queue message so that repeated suspension passes over the same\n   * pending wait collapse into a single delayed continuation.\n   */\n  waitTimeout?: { seconds: number; correlationId: string };\n  /** Whether a hook conflict was detected (should re-invoke immediately) */\n  hasHookConflict: boolean;\n  /** Whether a `hook.getConflict()` awaiter needs the workflow to continue immediately */\n  hasAwaitedHookCreation: boolean;\n  /** Whether native workflow attribute events were written for replay. */\n  hasAttributeEvents: boolean;\n  /**\n   * Whether this suspension created any hook (`hook_created`) events. Unlike\n   * `hasHookConflict` / `hasAwaitedHookCreation`, this is true even for a plain\n   * fire-and-forget hook with no conflict and no awaiter. Turbo mode uses it to\n   * detect \"a hook was created this suspension\" and stop forcing optimistic\n   * inline start (a hook introduces later resume invocations that could race).\n   */\n  hasHookEvents: boolean;\n  /**\n   * Wall-clock ms spent committing this suspension's `hook_created` events\n   * (0 when it created none). The caller accumulates this across iterations\n   * and subtracts it from the TTFS latency measurement, so time spent\n   * durably creating the user's hooks doesn't count as runtime overhead.\n   */\n  hookCreationMs: number;\n  /**\n   * Whether serializing this suspension's new step inputs was passive (did\n   * not execute workflow-owned code such as getters, proxy traps, or custom\n   * serializers). `false` means the retained VM may have diverged from what\n   * a cold replay would compute, so the caller must demote to replay.\n   */\n  retainedStepInputsSafe: boolean;\n}\n\nasync function createHookEvent({\n  runId,\n  hookEvent,\n  queueItem,\n  requestId,\n  createEvent,\n}: {\n  runId: string;\n  hookEvent: CreateEventRequest;\n  queueItem: HookInvocationQueueItem;\n  requestId?: string;\n  createEvent: EventCreator;\n}): Promise<{\n  hasHookConflict: boolean;\n  hasAwaitedHookCreation: boolean;\n}> {\n  try {\n    const result = await createEvent(hookEvent, {\n      requestId,\n    });\n\n    // Check if the world returned a hook_conflict event instead of hook_created.\n    // The hook_conflict event is stored in the event log and will be replayed\n    // on the next workflow invocation, causing the hook's promise to reject.\n    if (result.event?.eventType === 'hook_conflict') {\n      return {\n        hasHookConflict: true,\n        hasAwaitedHookCreation: false,\n      };\n    }\n\n    return {\n      hasHookConflict: false,\n      hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true,\n    };\n  } catch (err) {\n    if (EntityConflictError.is(err)) {\n      runtimeLogger.info('Hook already exists, continuing', {\n        workflowRunId: runId,\n        message: err.message,\n      });\n      return {\n        hasHookConflict: false,\n        hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true,\n      };\n    }\n\n    if (RunExpiredError.is(err)) {\n      runtimeLogger.info('Workflow run already completed, skipping hook', {\n        workflowRunId: runId,\n        message: err.message,\n      });\n      return {\n        hasHookConflict: false,\n        hasAwaitedHookCreation: false,\n      };\n    }\n\n    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}: 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: EventCreator = (data, params) =>\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  const createGuarded: EventCreator = (data, params) =>\n    eventLog\n      ? createEvent(data, {\n          ...params,\n          ...preconditionSnapshotParams(eventLog.events, eventLog.cursor),\n        })\n      : createEvent(data, params);\n  // Separate queue items by type\n  const stepItems = suspension.steps.filter(\n    (item): item is StepInvocationQueueItem => item.type === 'step'\n  );\n  const allHookItems = suspension.steps.filter(\n    (item): item is HookInvocationQueueItem => item.type === 'hook'\n  );\n  const waitItems = suspension.steps.filter(\n    (item): item is WaitInvocationQueueItem => item.type === 'wait'\n  );\n  const attributeItems = suspension.steps.filter(\n    (item): item is AttributeInvocationQueueItem => item.type === 'attribute'\n  );\n\n  const hooksNeedingCreation = allHookItems.filter(\n    (item) => !item.hasCreatedEvent\n  );\n\n  // Group hook items that need work by token, preserving queue-insertion\n  // (workflow code) order within each token. Operations on one token must\n  // apply in code order: a dispose() of an earlier hook releases the token\n  // before a later same-token hook's creation is validated — otherwise the\n  // new hook records a spurious hook_conflict against the run's own\n  // disposed hook — while a hook created and disposed within the same\n  // suspension is still created before it is disposed. Different tokens\n  // have no claim interaction, so token groups are processed in parallel.\n  const hookItemsByToken = new Map<string, HookInvocationQueueItem[]>();\n  for (const item of allHookItems) {\n    if (item.hasCreatedEvent && !item.disposed) {\n      continue; // already committed and still live — nothing to do\n    }\n    const group = hookItemsByToken.get(item.token);\n    if (group) {\n      group.push(item);\n    } else {\n      hookItemsByToken.set(item.token, [item]);\n    }\n  }\n\n  // Resolve encryption key for this run\n  const rawKey = await world.getEncryptionKeyForRun?.(run);\n  const encryptionKey = rawKey ? await importKey(rawKey) : undefined;\n\n  // Gate payload compression on the run's specVersion.\n  const compression =\n    (run.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION;\n\n  async function disposeHook(\n    queueItem: HookInvocationQueueItem\n  ): Promise<void> {\n    const hookDisposedEvent: CreateEventRequest = {\n      eventType: 'hook_disposed' as const,\n      specVersion: SPEC_VERSION_CURRENT,\n      correlationId: queueItem.correlationId,\n      eventData: {\n        token: queueItem.token,\n      },\n    };\n    try {\n      await createGuarded(hookDisposedEvent, { requestId });\n    } catch (err) {\n      if (EntityConflictError.is(err)) {\n        // Hook was already disposed by a concurrent invocation — safe to skip\n        runtimeLogger.info(\n          'Hook already disposed, skipping duplicate disposal',\n          {\n            workflowRunId: runId,\n            correlationId: queueItem.correlationId,\n            message: err.message,\n          }\n        );\n      } else if (RunExpiredError.is(err)) {\n        runtimeLogger.info(\n          'Workflow run already completed, skipping hook disposal',\n          {\n            workflowRunId: runId,\n            correlationId: queueItem.correlationId,\n            message: err.message,\n          }\n        );\n      } else if (HookNotFoundError.is(err)) {\n        // Hook may have already been disposed or never created\n        runtimeLogger.info('Hook not found for disposal, continuing', {\n          workflowRunId: runId,\n          correlationId: queueItem.correlationId,\n          message: err.message,\n        });\n      } else {\n        throw err;\n      }\n    }\n  }\n\n  // Process hooks first to prevent race conditions with webhook receivers.\n  // Track any hook conflicts that occur — these are returned to the caller\n  // so the V2 handler can re-invoke immediately.\n  let hasHookConflict = false;\n  let hasAwaitedHookCreation = false;\n  let hookCreationMs = 0;\n\n  if (hookItemsByToken.size > 0) {\n    const hookPhaseStart = Date.now();\n    await ensureRunReady();\n    await settlePhase(\n      [...hookItemsByToken.values()].map(async (items) => {\n        for (const queueItem of items) {\n          let creationConflicted = false;\n\n          if (!queueItem.hasCreatedEvent) {\n            const hookMetadata: SerializedData | undefined =\n              typeof queueItem.metadata === 'undefined'\n                ? undefined\n                : ((await dehydrateStepArguments(\n                    queueItem.metadata,\n                    runId,\n                    encryptionKey,\n                    suspension.globalThis,\n                    false,\n                    compression\n                  )) as SerializedData);\n            const hookEvent: CreateEventRequest = {\n              eventType: 'hook_created' as const,\n              specVersion: SPEC_VERSION_CURRENT,\n              correlationId: queueItem.correlationId,\n              eventData: {\n                token: queueItem.token,\n                tokenRetentionUntil: queueItem.tokenRetentionUntil,\n                metadata: hookMetadata,\n                isWebhook: queueItem.isWebhook ?? false,\n                ...(queueItem.isSystem && { isSystem: true }),\n              },\n            };\n            const result = await createHookEvent({\n              runId,\n              hookEvent,\n              queueItem,\n              requestId,\n              createEvent: createGuarded,\n            });\n            hasHookConflict ||= result.hasHookConflict;\n            hasAwaitedHookCreation ||= result.hasAwaitedHookCreation;\n            creationConflicted = result.hasHookConflict;\n          }\n\n          // Dispose after creation for hooks born and disposed within this\n          // batch. A hook whose creation conflicted was never created, so\n          // there is nothing to dispose.\n          if (queueItem.disposed && !creationConflicted) {\n            await disposeHook(queueItem);\n          }\n        }\n      })\n    );\n    hookCreationMs = Date.now() - hookPhaseStart;\n  }\n\n  // Process abort requests — resume the hook with abort payload and write stream packet\n  const hooksNeedingAbort = allHookItems.filter(\n    (item) => item.abortRequested && !item.disposed\n  );\n\n  if (hooksNeedingAbort.length > 0) {\n    await ensureRunReady();\n    await settlePhase(\n      hooksNeedingAbort.map(async (queueItem) => {\n        try {\n          // Dehydrate the abort payload for storage\n          const abortPayload = await dehydrateStepArguments(\n            { aborted: true, reason: queueItem.abortReason },\n            runId,\n            encryptionKey,\n            suspension.globalThis,\n            false,\n            compression\n          );\n\n          // Create hook_received event with abort payload\n          await createGuarded({\n            eventType: 'hook_received' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              token: queueItem.token,\n              payload: abortPayload,\n            },\n          });\n\n          // Write stream cancellation packet for real-time step propagation.\n          // Reuse the same dehydrated payload as the hook event so the reason\n          // round-trips through `dehydrateStepArguments` / `hydrateStepArguments`\n          // (handles DOMException, custom errors, encryption, etc.) instead of\n          // bare JSON.stringify which loses type information and drops undefined.\n          // streamName is set on the queue item at controller construction time\n          // (see workflow/abort-controller.ts).\n          try {\n            const streamName = getAbortStreamIdFromToken(queueItem.token);\n            await world.streams.write(\n              runId,\n              streamName,\n              abortPayload as Uint8Array\n            );\n            await world.streams.close(runId, streamName);\n          } catch {\n            // Best-effort stream write — hook event provides the durable fallback\n            runtimeLogger.debug(\n              'Failed to write abort stream packet, hook event will provide fallback',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n              }\n            );\n          }\n        } catch (err) {\n          if (EntityConflictError.is(err) || RunExpiredError.is(err)) {\n            runtimeLogger.info(\n              'Workflow run already completed, skipping abort',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else {\n            throw err;\n          }\n        }\n      })\n    );\n  }\n\n  // Create step events for steps that don't have them yet.\n  // Unlike V1, we do NOT queue step messages from here — the caller\n  // decides which steps to execute inline vs. queue to background.\n  // Wait events are also created in parallel below.\n  const stepsNeedingCreation = new Set(\n    stepItems\n      .filter((queueItem) => !queueItem.hasCreatedEvent)\n      .map((queueItem) => queueItem.correlationId)\n  );\n\n  // Correlation IDs for which THIS suspension call actually wrote the\n  // step_created event. Populated by the ops below after a successful\n  // events.create — used by the caller to claim ownership and avoid\n  // racing with concurrent handlers on step execution.\n  const createdStepCorrelationIds = new Set<string>();\n\n  // Serialization always runs through the one ordinary path below, so the\n  // durable bytes cannot depend on retention. What retention needs to know is\n  // whether that serialization *executed* workflow code (getters, proxy\n  // traps, custom serializers) — side effects a cold replay would not\n  // repeat, since a replay skips dehydration for already-recorded steps.\n  // The hardened serializer records exactly that into this sink (see\n  // ../serialization/hardened.ts); when any input in the batch records an\n  // execution, the caller demotes the session so the side effects land in a\n  // VM that is about to be discarded, exactly like the pre-retention\n  // runtime.\n  const guestCodeStats: GuestCodeStats = { executions: [] };\n\n  // Lazy inline start: defer the step_created write for up to\n  // `getMaxInlineSteps()` steps the caller will run inline (in parallel). Each\n  // step is created on the fly by the lazy `step_started` executeStep sends\n  // (saving a round-trip per step). We never defer when a `hook.getConflict()`\n  // awaiter is present, because in that case the caller executes nothing inline\n  // (it re-invokes immediately to resolve the awaiter), so deferring would\n  // leave the steps uncreated and unqueued. We pick the first N uncreated steps\n  // — matching the caller's inline-candidate selection — and dehydrate their\n  // input here so executeStep can ship it as the step_started payload.\n  const lazyInlineCorrelationIds = new Set<string>(\n    hasAwaitedHookCreation === false\n      ? stepItems\n          .filter((item) => stepsNeedingCreation.has(item.correlationId))\n          .slice(0, getMaxInlineSteps())\n          .map((item) => item.correlationId)\n      : []\n  );\n  // Collected by correlationId because the per-step ops below run concurrently\n  // and settle out of order. We rebuild the array in deterministic\n  // `lazyInlineCorrelationIds` order (the ordered slice above) after the ops\n  // settle, so the inline batch order is stable regardless of dehydration timing.\n  const lazyInlineByCorrelationId = new Map<\n    string,\n    SuspensionHandlerResult['lazyInlineSteps'][number]\n  >();\n\n  const ops: Promise<void>[] = [];\n\n  // 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          // Per-step sink, merged below: the dehydrate wrapper emits span\n          // attributes from the sink it is handed, so sharing one across\n          // steps would re-emit (and misattribute) earlier steps' entries.\n          const stepGuestCode: GuestCodeStats = { executions: [] };\n          const dehydratedInput = await dehydrateStepArguments(\n            {\n              args: queueItem.args,\n              closureVars: queueItem.closureVars,\n              thisVal: queueItem.thisVal,\n            },\n            runId,\n            encryptionKey,\n            suspension.globalThis,\n            false,\n            compression,\n            stepGuestCode\n          );\n          guestCodeStats.executions.push(...stepGuestCode.executions);\n          // Deferred (lazy) inline step: skip the step_created write — the\n          // caller's inline executeStep will send a lazy step_started carrying\n          // this input, and the world creates the step (entity + synthetic\n          // step_created event) atomically. We do NOT add it to\n          // createdStepCorrelationIds; ownership is decided by that lazy\n          // step_started's atomic create-claim instead.\n          if (lazyInlineCorrelationIds.has(queueItem.correlationId)) {\n            lazyInlineByCorrelationId.set(queueItem.correlationId, {\n              correlationId: queueItem.correlationId,\n              stepName: queueItem.stepName,\n              dehydratedInput: dehydratedInput as SerializedData,\n            });\n            return;\n          }\n          const stepEvent: CreateEventRequest = {\n            eventType: 'step_created' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              stepName: queueItem.stepName,\n              workflowName: run.workflowName,\n              input: dehydratedInput as SerializedData,\n            },\n          };\n          try {\n            await ensureRunReady();\n            await createGuarded(stepEvent, { requestId });\n            createdStepCorrelationIds.add(queueItem.correlationId);\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info('Step already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else {\n              throw err;\n            }\n          }\n        })()\n      );\n    }\n  }\n\n  // Create wait events (same as V1)\n  for (const queueItem of waitItems) {\n    if (!queueItem.hasCreatedEvent) {\n      ops.push(\n        (async () => {\n          const waitEvent: CreateEventRequest = {\n            eventType: 'wait_created' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              resumeAt: queueItem.resumeAt,\n            },\n          };\n          try {\n            await ensureRunReady();\n            await createGuarded(waitEvent, { requestId });\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info('Wait already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else {\n              throw err;\n            }\n          }\n        })()\n      );\n    }\n  }\n\n  for (const queueItem of attributeItems) {\n    ops.push(\n      (async () => {\n        try {\n          await ensureRunReady();\n          // Guarded like every other suspension write: an attr_set is a\n          // replay-derived event with a correlation id from this replay's\n          // seeded sequence, so it must not land on a log the replay never\n          // saw. Rejecting it is cheap — a run with attribute events already\n          // forces an in-process replay, so the restart costs the replay it\n          // was going to do anyway.\n          await createGuarded(\n            {\n              eventType: 'attr_set',\n              specVersion: SPEC_VERSION_CURRENT,\n              correlationId: queueItem.correlationId,\n              eventData: {\n                changes: queueItem.changes,\n                writer: { type: 'workflow' },\n                ...(queueItem.allowReservedAttributes\n                  ? { allowReservedAttributes: true }\n                  : {}),\n              },\n            },\n            { requestId }\n          );\n        } catch (err) {\n          if (EntityConflictError.is(err)) {\n            runtimeLogger.info(\n              'Workflow attribute event already exists, continuing',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else if (isAttributeValidationFailure(err)) {\n            // Deterministic validation rejection from the World — e.g. the\n            // cumulative per-run attribute cap, which only the World can\n            // check against the run's existing attributes. Redelivering the\n            // orchestrator message replays the workflow into the exact same\n            // write and the exact same rejection, so retrying can never\n            // succeed. Surface it as a FatalError so the caller fails the\n            // run with a clear error instead of wedging it in redelivery.\n            const fatal = new FatalError(\n              `setAttributes failed World validation: ${\n                err instanceof Error ? err.message : String(err)\n              }`\n            );\n            fatal.cause = err;\n            throw fatal;\n          } else {\n            throw err;\n          }\n        }\n      })()\n    );\n  }\n\n  // Await the step_created / wait_created event creates before returning.\n  // The caller (workflowEntrypoint) only enqueues the step-dispatch queue\n  // messages AFTER handleSuspension resolves, and the queue handler acks\n  // the orchestrator message only after the caller resolves. So the step_created\n  // events must be durable here, and the dispatch sends must complete in the caller,\n  // all before ack. If the process crashes before this resolves, the orchestrator\n  // message is not acked and VQS redelivers, re-creates the (idempotent)\n  // step_created and re-dispatches, and recovers the run instead of orphaning it.\n  await settlePhase(ops);\n\n  // The step-input dehydrations above have settled, so the sink is final.\n  const retainedStepInputsSafe = guestCodeStats.executions.length === 0;\n  if (!retainedStepInputsSafe) {\n    runtimeLogger.debug(\n      'Serializing step inputs executed workflow code; falling back to replay instead of retaining the VM',\n      {\n        workflowRunId: runId,\n        executions: guestCodeStats.executions\n          .slice(0, 5)\n          .map((e) => (e.detail ? `${e.kind}(${e.detail})` : e.kind)),\n      }\n    );\n  }\n\n  // Rebuild the inline batch in deterministic order. `lazyInlineCorrelationIds`\n  // is a Set seeded from the ordered first-N slice, so iterating it preserves\n  // stepItems order; every id in it was set by the lazy branch above.\n  const lazyInlineSteps: SuspensionHandlerResult['lazyInlineSteps'] = [];\n  for (const correlationId of lazyInlineCorrelationIds) {\n    const lazyStep = lazyInlineByCorrelationId.get(correlationId);\n    if (lazyStep) lazyInlineSteps.push(lazyStep);\n  }\n\n  // Find the soonest pending wait (minimum timeout)\n  const now = Date.now();\n  let soonestWait: { seconds: number; correlationId: string } | undefined;\n  for (const queueItem of waitItems) {\n    const resumeAtMs = queueItem.resumeAt.getTime();\n    const delayMs = Math.max(1000, resumeAtMs - now);\n    const timeoutSeconds = Math.ceil(delayMs / 1000);\n    if (!soonestWait || timeoutSeconds < soonestWait.seconds) {\n      soonestWait = {\n        seconds: timeoutSeconds,\n        correlationId: queueItem.correlationId,\n      };\n    }\n  }\n\n  span?.setAttributes({\n    ...Attribute.WorkflowRunStatus('workflow_suspended'),\n    ...Attribute.WorkflowStepsCreated(stepItems.length),\n    ...Attribute.WorkflowHooksCreated(hooksNeedingCreation.length),\n    ...Attribute.WorkflowWaitsCreated(waitItems.length),\n  });\n\n  return {\n    pendingSteps: stepItems,\n    createdStepCorrelationIds,\n    lazyInlineSteps,\n    // On hook conflict the caller re-invokes immediately and never reads\n    // the wait timeout, so don't report one.\n    waitTimeout: hasHookConflict ? undefined : soonestWait,\n    hasHookConflict,\n    hasAwaitedHookCreation,\n    hasAttributeEvents: attributeItems.length > 0,\n    hasHookEvents: hooksNeedingCreation.length > 0,\n    hookCreationMs,\n    retainedStepInputsSafe,\n  };\n}\n\n/**\n * Whether an `events.create` rejection is a deterministic attribute\n * validation failure 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 isAttributeValidationFailure(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"]}