@workflow/core 5.0.0-beta.1 → 5.0.0-beta.10

package/dist/runtime.js

@@ -1,17 +1,21 @@
-import { EntityConflictError, RUN_ERROR_CODES, RunExpiredError, WorkflowRuntimeError, } from '@workflow/errors';
+import { types } from 'node:util';
+import { EntityConflictError, FatalError, RUN_ERROR_CODES, RunExpiredError, WorkflowRuntimeError, } from '@workflow/errors';
 import { parseWorkflowName } from '@workflow/utils/parse-name';
 import { SPEC_VERSION_CURRENT, WorkflowInvokePayloadSchema, } from '@workflow/world';
-import { classifyRunError } from './classify-error.js';
-import { importKey } from './encryption.js';
+import { classifyRunError, isWorldContractError } from './classify-error.js';
+import { describeError } from './describe-error.js';
 import { WorkflowSuspension } from './global.js';
 import { runtimeLogger } from './logger.js';
-import { MAX_QUEUE_DELIVERIES, REPLAY_TIMEOUT_MS, } from './runtime/constants.js';
-import { getAllWorkflowRunEvents, getQueueOverhead, handleHealthCheckMessage, parseHealthCheckPayload, withHealthCheck, } from './runtime/helpers.js';
+import { MAX_QUEUE_DELIVERIES } from './runtime/constants.js';
+import { getQueueOverhead, getWorkflowQueueName, handleHealthCheckMessage, loadWorkflowRunEvents, memoizeEncryptionKey, parseHealthCheckPayload, queueMessage, withHealthCheck, } from './runtime/helpers.js';
+import { handleReplayBudgetExhausted, ReplayBudget, } from './runtime/replay-budget.js';
+import { executeStep } from './runtime/step-executor.js';
 import { handleSuspension } from './runtime/suspension-handler.js';
 import { getWorld, getWorldHandlers, } from './runtime/world.js';
+import { dehydrateRunError } from './serialization.js';
 import { remapErrorStack } from './source-map.js';
 import * as Attribute from './telemetry/semantic-conventions.js';
-import { linkToCurrentContext, trace, withTraceContext, withWorkflowBaggage, } from './telemetry.js';
+import { linkToCurrentContext, serializeTraceCarrier, trace, withTraceContext, withWorkflowBaggage, } from './telemetry.js';
 import { getErrorName, getErrorStack, normalizeUnknownError } from './types.js';
 import { buildWorkflowSuspensionMessage } from './util.js';
 import { runWorkflow } from './workflow.js';
@@ -21,17 +25,65 @@ export { getHookByToken, resumeHook, resumeWebhook, } from './runtime/resume-hoo
 export { getRun, Run, } from './runtime/run.js';
 export { cancelRun, listStreams, readStream, recreateRunFromExisting, reenqueueRun, wakeUpRun, } from './runtime/runs.js';
 export { start, } from './runtime/start.js';
-export { stepEntrypoint } from './runtime/step-handler.js';
+// V2: stepEntrypoint is no longer re-exported — the combined handler
+// (workflowEntrypoint) executes steps inline. Removing the re-export
+// prevents Turbopack from tracing step-handler.js → get-port.js
+// filesystem operations into the flow route bundle.
 export { createWorld, getWorld, getWorldHandlers, setWorld, } from './runtime/world.js';
+function getWorkflowSetupErrorCode(err) {
+    if (WorkflowRuntimeError.is(err)) {
+        return RUN_ERROR_CODES.RUNTIME_ERROR;
+    }
+    if (isWorldContractError(err)) {
+        return RUN_ERROR_CODES.WORLD_CONTRACT_ERROR;
+    }
+    return null;
+}
+async function recordFatalRunError({ world, workflowRun, runId, requestId, err, errorCode, logMessage, }) {
+    runtimeLogger.error(logMessage, {
+        workflowRunId: runId,
+        errorCode,
+        error: err instanceof Error ? err.message : String(err),
+    });
+    try {
+        const getEncryptionKey = memoizeEncryptionKey(world, workflowRun ?? runId);
+        await world.events.create(runId, {
+            eventType: 'run_failed',
+            specVersion: SPEC_VERSION_CURRENT,
+            eventData: {
+                error: await dehydrateRunError(err, runId, await getEncryptionKey()),
+                errorCode,
+            },
+        }, { requestId });
+    }
+    catch (failErr) {
+        if (EntityConflictError.is(failErr) || RunExpiredError.is(failErr)) {
+            return;
+        }
+        if (isWorldContractError(failErr)) {
+            runtimeLogger.error('Fatal world contract error while recording workflow failure', {
+                workflowRunId: runId,
+                errorCode: RUN_ERROR_CODES.WORLD_CONTRACT_ERROR,
+                error: failErr instanceof Error ? failErr.message : String(failErr),
+            });
+            return;
+        }
+        throw failErr;
+    }
+}
 /**
- * Function that creates a single route which handles any workflow execution
- * request and routes to the appropriate workflow function.
+ * Creates a single route which handles workflow execution requests,
+ * executing steps inline when possible to reduce function invocations
+ * and queue overhead.
+ *
+ * The handler loops: replay workflow → execute step inline → replay → ...
+ * until the workflow completes, times out, or encounters non-step suspensions.
  *
- * @param workflowCode - The workflow bundle code containing all the workflow
- * functions at the top level.
- * @returns A function that can be used as a Vercel API route.
+ * @param workflowCode - The workflow bundle code containing all workflow functions
+ * @returns A function that can be used as a Vercel API route
  */
 export function workflowEntrypoint(workflowCode) {
+    const NO_INLINE_REPLAY_AFTER_MS = Number(process.env.WORKFLOW_V2_TIMEOUT_MS) || 120_000;
     const handler = (worldHandlers) => worldHandlers.createQueueHandler('__wkf_workflow_', async (message_, metadata) => {
         // Check if this is a health check message
         // NOTE: Health check messages are intentionally unauthenticated for monitoring purposes.
@@ -42,28 +94,31 @@ export function workflowEntrypoint(workflowCode) {
             await handleHealthCheckMessage(healthCheck, 'workflow', worldHandlers.specVersion);
             return;
         }
-        const { runId, traceCarrier: traceContext, requestedAt, runInput, } = WorkflowInvokePayloadSchema.parse(message_);
+        const { runId, traceCarrier: traceContext, requestedAt, stepId: incomingStepId, stepName: incomingStepName, runInput, } = WorkflowInvokePayloadSchema.parse(message_);
         const { requestId } = metadata;
-        // Extract the workflow name from the topic name
         const workflowName = metadata.queueName.slice('__wkf_workflow_'.length);
         // --- Max delivery check ---
         // Enforce max delivery limit before any infrastructure calls.
         // This prevents runaway workflows from consuming infinite queue deliveries.
-        // At this point, we want to do the minimal amount of work (no fetching
-        // of the workflow events, etc. We simply attempt to mark the run as failed
-        // and if that fails, the message is still consumed but with adequate logging
-        // that an error occurred preventing us from failing the run.
+        // Scoped logger for this run — attaches runId/workflowName to every
+        // log line and child loggers below, so callers don't repeat it.
+        const runLogger = runtimeLogger.forRun(runId, workflowName);
         if (metadata.attempt > MAX_QUEUE_DELIVERIES) {
-            runtimeLogger.error(`Workflow handler exceeded max deliveries (${metadata.attempt}/${MAX_QUEUE_DELIVERIES})`, { workflowRunId: runId, workflowName, attempt: metadata.attempt });
+            const maxDeliveriesDescription = describeError(undefined, RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED);
+            runLogger.error(`Workflow handler exceeded max deliveries (${metadata.attempt}/${MAX_QUEUE_DELIVERIES})`, {
+                attempt: metadata.attempt,
+                errorCode: maxDeliveriesDescription.errorCode,
+                errorAttribution: maxDeliveriesDescription.attribution,
+            });
             try {
                 const world = await getWorld();
+                const getEncryptionKey = memoizeEncryptionKey(world, runId);
+                const err = new FatalError(`Workflow exceeded maximum queue deliveries (${metadata.attempt}/${MAX_QUEUE_DELIVERIES})`);
                 await world.events.create(runId, {
                     eventType: 'run_failed',
                     specVersion: SPEC_VERSION_CURRENT,
                     eventData: {
-                        error: {
-                            message: `Workflow exceeded maximum queue deliveries (${metadata.attempt}/${MAX_QUEUE_DELIVERIES})`,
-                        },
+                        error: await dehydrateRunError(err, runId, await getEncryptionKey()),
                         errorCode: RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED,
                     },
                 }, { requestId });
@@ -73,308 +128,778 @@ export function workflowEntrypoint(workflowCode) {
                     // Run already finished, consume the message silently
                     return;
                 }
-                runtimeLogger.error(`Failed to mark run as failed after ${metadata.attempt} delivery attempts. ` +
+                runLogger.error(`Failed to mark run as failed after ${metadata.attempt} delivery attempts. ` +
                     `A persistent error is preventing the run from being terminated. ` +
                     `The run will remain in its current state until manually resolved. ` +
                     `This is most likely due to a persistent outage of the workflow backend ` +
                     `or a bug in the workflow runtime and should be reported to the Workflow team.`, {
-                    workflowRunId: runId,
-                    error: err instanceof Error ? err.message : String(err),
                     attempt: metadata.attempt,
+                    errorName: err instanceof Error ? err.name : 'UnknownError',
+                    errorMessage: err instanceof Error ? err.message : String(err),
+                    errorStack: err instanceof Error ? err.stack : undefined,
                 });
             }
             return;
         }
         const spanLinks = await linkToCurrentContext();
-        // --- Replay timeout guard ---
-        // If the replay takes longer than the timeout, fail the run and exit.
-        // This must be lower than the function's maxDuration to ensure
-        // the failure is recorded before the platform kills the function.
-        let replayTimeout;
-        if (process.env.VERCEL_URL !== undefined) {
-            replayTimeout = setTimeout(async () => {
-                runtimeLogger.error('Workflow replay exceeded timeout', {
-                    workflowRunId: runId,
-                    timeoutMs: REPLAY_TIMEOUT_MS,
-                });
-                try {
-                    const world = await getWorld();
-                    await world.events.create(runId, {
-                        eventType: 'run_failed',
-                        specVersion: SPEC_VERSION_CURRENT,
-                        eventData: {
-                            error: {
-                                message: `Workflow replay exceeded maximum duration (${REPLAY_TIMEOUT_MS / 1000}s)`,
-                            },
-                            errorCode: RUN_ERROR_CODES.REPLAY_TIMEOUT,
-                        },
-                    }, { requestId });
-                }
-                catch {
-                    // Best effort — process exits regardless
-                }
-                // Note that this also prevents the runtime to acking the queue message,
-                // so the queue will call back once, after which a 410 will get it to exit early.
-                process.exit(1);
-            }, REPLAY_TIMEOUT_MS);
-            replayTimeout.unref();
-        }
-        // Invoke user workflow within the propagated trace context and baggage
+        // --- Replay budget bookkeeping ---
+        // The replay budget bounds the *non-step* portion of a single
+        // handler invocation: deterministic event-log replay, workflow-VM
+        // execution between step boundaries, suspension handling, queue
+        // round-trips, etc. Inline step bodies (`"use step"` functions
+        // invoked via `executeStep`) are intentionally excluded — they are
+        // bounded by the platform's function `maxDuration` and the
+        // `NO_INLINE_REPLAY_AFTER_MS` early-return guard below.
+        //
+        // The budget is checked at loop boundaries (top of each `while`
+        // iteration). Note this is *less responsive* than the old
+        // `setTimeout`-based approach: a single pathological `runWorkflow`
+        // call processing a huge event log can overshoot the budget by up
+        // to one iteration before bailing. In practice the headroom built
+        // into `MAX_REPLAY_TIMEOUT_MS` (and the platform `maxDuration`
+        // SIGTERM as ultimate backstop) gives us slack — the previous
+        // `setTimeout` approach also relied on the platform kill as the
+        // hard backstop. Do *not* "fix" this by adding a `setInterval`;
+        // it would risk the same bug we just removed (bounding step
+        // bodies).
+        //
+        // Earlier versions (pre-#2009 fix) used a single `setTimeout`
+        // that also bounded step bodies, which broke any workflow with a
+        // single step longer than the budget.
+        const replayBudget = new ReplayBudget();
         return await withTraceContext(traceContext, async () => {
-            // Set workflow context as baggage for automatic propagation
             return await withWorkflowBaggage({ workflowRunId: runId, workflowName }, async () => {
                 const world = await getWorld();
-                return trace(`WORKFLOW ${workflowName}`, { links: spanLinks }, async (span) => {
+                return trace(`WORKFLOW_V2 ${workflowName}`, { links: spanLinks }, async (span) => {
                     span?.setAttributes({
                         ...Attribute.WorkflowName(workflowName),
-                        ...Attribute.WorkflowOperation('execute'),
-                        // Standard OTEL messaging conventions
+                        ...Attribute.WorkflowOperation('execute_v2'),
                         ...Attribute.MessagingSystem('vercel-queue'),
                         ...Attribute.MessagingDestinationName(metadata.queueName),
                         ...Attribute.MessagingMessageId(metadata.messageId),
                         ...Attribute.MessagingOperationType('process'),
                         ...getQueueOverhead({ requestedAt }),
-                    });
-                    // TODO: validate `workflowName` exists before consuming message?
-                    span?.setAttributes({
                         ...Attribute.WorkflowRunId(runId),
                         ...Attribute.WorkflowTracePropagated(!!traceContext),
                     });
-                    let workflowStartedAt = -1;
+                    const invocationStartTime = Date.now();
+                    let loopIteration = 0;
+                    // Event cache: keep loaded events in memory across loop iterations.
+                    // On the first iteration we do a full load; on subsequent iterations
+                    // we fetch only events created after the last known cursor.
+                    let cachedEvents = null;
+                    let eventsCursor = null;
+                    // Shared state: set by either the background step path
+                    // or the run_started setup below.
                     let workflowRun;
-                    // Pre-loaded events from the run_started response.
-                    // When present, we skip the events.list call to reduce TTFB.
+                    let workflowStartedAt = -1;
                     let preloadedEvents;
-                    // --- Infrastructure: prepare the run state ---
-                    // Always call run_started directly — this both transitions
-                    // the run to 'running' AND returns the run entity, saving
-                    // a separate runs.get round-trip.
-                    // Contract: events.create('run_started') must be idempotent
-                    // for runs already in 'running' status (return the run
-                    // without error), not just for pending → running transitions.
-                    // Network/server errors propagate to the queue handler for retry.
-                    // WorkflowRuntimeError (data integrity issues) are fatal and
-                    // produce run_failed since retrying won't fix them.
-                    try {
-                        const result = await world.events.create(runId, {
-                            eventType: 'run_started',
-                            // Use the spec version from the original start() call
-                            // when available, so the resilient start path creates
-                            // the run with the correct version (not always current).
-                            specVersion: runInput?.specVersion ?? SPEC_VERSION_CURRENT,
-                            // Pass run input from queue so the server can
-                            // create the run if run_created was missed.
-                            // Uint8Array values survive the queue natively
-                            // (CBOR on world-vercel, JSON reviver on world-local).
-                            ...(runInput
-                                ? {
-                                    eventData: {
-                                        input: runInput.input,
-                                        deploymentId: runInput.deploymentId,
-                                        workflowName: runInput.workflowName,
-                                        executionContext: runInput.executionContext,
-                                    },
-                                }
-                                : {}),
-                        }, { requestId });
-                        if (!result.run) {
-                            throw new WorkflowRuntimeError(`Event creation for 'run_started' did not return the run entity for run "${runId}"`);
-                        }
-                        workflowRun = result.run;
-                        // If the response includes events, use them to skip
-                        // the initial events.list call and reduce TTFB.
-                        if (result.events && result.events.length > 0) {
-                            preloadedEvents = result.events;
-                        }
-                        if (!workflowRun.startedAt) {
-                            throw new WorkflowRuntimeError(`Workflow run "${runId}" has no "startedAt" timestamp`);
-                        }
-                    }
-                    catch (err) {
-                        // Run was concurrently completed/failed/cancelled
-                        if (EntityConflictError.is(err) ||
-                            RunExpiredError.is(err)) {
-                            // EntityConflictError: run was concurrently
-                            // completed/failed/cancelled during setup.
-                            // RunExpiredError: run already in terminal state.
-                            // In both cases, skip processing this message.
-                            runtimeLogger.info('Run already finished during setup, skipping', { workflowRunId: runId, message: err.message });
-                            return;
-                        }
-                        else if (err instanceof WorkflowRuntimeError) {
-                            runtimeLogger.error('Fatal runtime error during workflow setup', { workflowRunId: runId, error: err.message });
+                    let preloadedEventsCursor;
+                    // If incoming message has a stepId, this is a background step
+                    // execution. Execute the step, then check if all parallel steps
+                    // from the batch are done. If so, replay inline (saving a queue
+                    // roundtrip). If not, return — the last handler to complete
+                    // will pick up the replay.
+                    if (incomingStepId && incomingStepName) {
+                        try {
+                            const bgRun = await world.runs.get(runId);
+                            if (bgRun.status !== 'running') {
+                                runtimeLogger.debug('Run already finished, skipping background step', { workflowRunId: runId, status: bgRun.status });
+                                return;
+                            }
+                            const bgStartedAt = bgRun.startedAt
+                                ? +bgRun.startedAt
+                                : Date.now();
+                            // Pause the replay budget while the step body runs —
+                            // step duration is bounded by the platform's function
+                            // maxDuration, not by the replay timeout. See the
+                            // ReplayBudget docs for the contract.
+                            replayBudget.pause();
+                            let stepResult;
                             try {
-                                await world.events.create(runId, {
-                                    eventType: 'run_failed',
-                                    specVersion: SPEC_VERSION_CURRENT,
-                                    eventData: {
-                                        error: {
-                                            message: err.message,
-                                            stack: err.stack,
-                                        },
-                                        errorCode: RUN_ERROR_CODES.RUNTIME_ERROR,
-                                    },
-                                }, { requestId });
+                                stepResult = await executeStep({
+                                    world,
+                                    workflowRunId: runId,
+                                    workflowName,
+                                    workflowStartedAt: bgStartedAt,
+                                    stepId: incomingStepId,
+                                    stepName: incomingStepName,
+                                });
+                            }
+                            finally {
+                                replayBudget.resume();
+                            }
+                            if (stepResult.type === 'retry') {
+                                return { timeoutSeconds: stepResult.timeoutSeconds };
+                            }
+                            if (stepResult.type === 'throttled') {
+                                return { timeoutSeconds: stepResult.timeoutSeconds };
+                            }
+                            // If step had pending ops (stream writes), break and let
+                            // waitUntil flush them — can't continue inline.
+                            if (stepResult.type === 'completed' &&
+                                stepResult.hasPendingOps) {
+                                await queueMessage(world, getWorkflowQueueName(workflowName), {
+                                    runId,
+                                    traceCarrier: await serializeTraceCarrier(),
+                                    requestedAt: new Date(),
+                                });
+                                return;
                             }
-                            catch (failErr) {
-                                if (EntityConflictError.is(failErr) ||
-                                    RunExpiredError.is(failErr)) {
+                            if (stepResult.type === 'completed' ||
+                                stepResult.type === 'failed' ||
+                                stepResult.type === 'skipped') {
+                                // Load events to check if all parallel steps are done.
+                                // Use cursor-based loading so the main loop can continue
+                                // incrementally from here.
+                                const loaded = await loadWorkflowRunEvents(runId);
+                                cachedEvents = loaded.events;
+                                eventsCursor = loaded.cursor;
+                                // Check for pending steps: any step_created without
+                                // a matching step_completed or step_failed.
+                                const stepCreatedIds = new Set();
+                                const stepTerminalIds = new Set();
+                                for (const e of cachedEvents) {
+                                    if (e.eventType === 'step_created') {
+                                        stepCreatedIds.add(e.correlationId);
+                                    }
+                                    else if (e.eventType === 'step_completed' ||
+                                        e.eventType === 'step_failed') {
+                                        stepTerminalIds.add(e.correlationId);
+                                    }
+                                }
+                                let hasPendingSteps = false;
+                                for (const id of stepCreatedIds) {
+                                    if (!stepTerminalIds.has(id)) {
+                                        hasPendingSteps = true;
+                                        break;
+                                    }
+                                }
+                                if (hasPendingSteps) {
+                                    // Other steps still in progress. Return without
+                                    // queuing — the last handler to complete will see
+                                    // all steps done and replay inline.
+                                    runtimeLogger.debug('Background step done but other steps pending, returning', { workflowRunId: runId });
                                     return;
                                 }
-                                throw failErr;
+                                // All steps done — fall through to the main replay loop.
+                                // Set up shared state so the loop can continue.
+                                runtimeLogger.debug('All parallel steps done, replaying inline after background step', { workflowRunId: runId });
+                                workflowRun = bgRun;
+                                workflowStartedAt = bgStartedAt;
+                                // cachedEvents and eventsCursor already set from load above
+                            }
+                            else {
+                                return;
                             }
-                            return;
                         }
-                        else {
-                            throw err;
+                        catch (err) {
+                            const errorCode = getWorkflowSetupErrorCode(err);
+                            if (!errorCode) {
+                                throw err;
+                            }
+                            await recordFatalRunError({
+                                world,
+                                workflowRun,
+                                runId,
+                                requestId,
+                                err,
+                                errorCode,
+                                logMessage: 'Fatal error while preparing background workflow step',
+                            });
+                            return;
                         }
                     }
-                    workflowStartedAt = +workflowRun.startedAt;
-                    span?.setAttributes({
-                        ...Attribute.WorkflowRunStatus(workflowRun.status),
-                        ...Attribute.WorkflowStartedAt(workflowStartedAt),
-                    });
-                    if (workflowRun.status !== 'running') {
-                        // Workflow has already completed or failed, so we can skip it
-                        runtimeLogger.info('Workflow already completed or failed, skipping', {
-                            workflowRunId: runId,
-                            status: workflowRun.status,
-                        });
-                        // TODO: for `cancel`, we actually want to propagate a WorkflowCancelled event
-                        // inside the workflow context so the user can gracefully exit. this is SIGTERM
-                        // TODO: furthermore, there should be a timeout or a way to force cancel SIGKILL
-                        // so that we actually exit here without replaying the workflow at all, in the case
-                        // the replaying the workflow is itself failing.
-                        return;
-                    }
-                    // Load all events into memory before running.
-                    // If we got pre-loaded events from the run_started response,
-                    // skip the events.list round-trip to reduce TTFB.
-                    const events = preloadedEvents ??
-                        (await getAllWorkflowRunEvents(workflowRun.runId));
-                    // Check for any elapsed waits and create wait_completed events
-                    const now = Date.now();
-                    // Pre-compute completed correlation IDs for O(n) lookup instead of O(n²)
-                    const completedWaitIds = new Set(events
-                        .filter((e) => e.eventType === 'wait_completed')
-                        .map((e) => e.correlationId));
-                    // Collect all waits that need completion
-                    const waitsToComplete = events
-                        .filter((e) => e.eventType === 'wait_created' &&
-                        e.correlationId !== undefined &&
-                        !completedWaitIds.has(e.correlationId) &&
-                        now >= e.eventData.resumeAt.getTime())
-                        .map((e) => ({
-                        eventType: 'wait_completed',
-                        specVersion: SPEC_VERSION_CURRENT,
-                        correlationId: e.correlationId,
-                    }));
-                    // Create all wait_completed events
-                    for (const waitEvent of waitsToComplete) {
+                    // --- Infrastructure: prepare the run state ---
+                    // Skip if workflowRun was already set by the background
+                    // step path (inline replay after all parallel steps done).
+                    if (!workflowRun) {
+                        // Always call run_started directly — this both transitions
+                        // the run to 'running' AND returns the run entity, saving
+                        // a separate runs.get round-trip.
+                        // Contract: events.create('run_started') must be idempotent
+                        // for runs already in 'running' status (return the run
+                        // without error), not just for pending → running transitions.
                         try {
-                            const result = await world.events.create(runId, waitEvent, {
-                                requestId,
-                            });
-                            // Add the event to the events array so the workflow can see it
-                            events.push(result.event);
+                            const result = await world.events.create(runId, {
+                                eventType: 'run_started',
+                                // Use the spec version from the original start() call
+                                // when available, so the resilient start path creates
+                                // the run with the correct version (not always current).
+                                specVersion: runInput?.specVersion ?? SPEC_VERSION_CURRENT,
+                                // Pass run input from queue so the server can
+                                // create the run if run_created was missed.
+                                // Uint8Array values survive the queue natively
+                                // (CBOR on world-vercel, JSON reviver on world-local).
+                                ...(runInput
+                                    ? {
+                                        eventData: {
+                                            input: runInput.input,
+                                            deploymentId: runInput.deploymentId,
+                                            workflowName: runInput.workflowName,
+                                            executionContext: runInput.executionContext,
+                                        },
+                                    }
+                                    : {}),
+                            }, { requestId });
+                            if (!result.run) {
+                                throw new WorkflowRuntimeError(`Event creation for 'run_started' did not return the run entity for run "${runId}"`);
+                            }
+                            workflowRun = result.run;
+                            // If the response includes events, use them to skip
+                            // the initial events.list call and reduce TTFB.
+                            if (result.events &&
+                                result.events.length > 0 &&
+                                result.hasMore !== true) {
+                                preloadedEvents = result.events;
+                                preloadedEventsCursor = result.cursor;
+                            }
+                            if (!workflowRun.startedAt) {
+                                throw new WorkflowRuntimeError(`Workflow run "${runId}" has no "startedAt" timestamp`);
+                            }
                         }
                         catch (err) {
-                            if (EntityConflictError.is(err)) {
-                                runtimeLogger.info('Wait already completed, skipping', {
-                                    workflowRunId: runId,
-                                    correlationId: waitEvent.correlationId,
+                            // Run was concurrently completed/failed/cancelled
+                            if (EntityConflictError.is(err) ||
+                                RunExpiredError.is(err)) {
+                                // EntityConflictError: run was concurrently
+                                // completed/failed/cancelled during setup.
+                                // RunExpiredError: run already in terminal state.
+                                // In both cases, skip processing this message.
+                                runtimeLogger.info('Run already finished during setup, skipping', { workflowRunId: runId, message: err.message });
+                                return;
+                            }
+                            else {
+                                const errorCode = getWorkflowSetupErrorCode(err);
+                                if (!errorCode) {
+                                    throw err;
+                                }
+                                await recordFatalRunError({
+                                    world,
+                                    workflowRun,
+                                    runId,
+                                    requestId,
+                                    err,
+                                    errorCode,
+                                    logMessage: 'Fatal runtime error during workflow setup',
                                 });
-                                continue;
+                                return;
                             }
-                            throw err;
                         }
-                    }
-                    // Resolve the encryption key for this run's deployment
-                    const rawKey = await world.getEncryptionKeyForRun?.(workflowRun);
-                    const encryptionKey = rawKey
-                        ? await importKey(rawKey)
-                        : undefined;
-                    // --- User code execution ---
-                    // Only errors from runWorkflow() (user workflow code) should
-                    // produce run_failed. Infrastructure errors (network, server)
-                    // must propagate to the queue handler for automatic retry.
-                    let workflowResult;
-                    try {
-                        workflowResult = await trace('workflow.replay', {}, async (replaySpan) => {
-                            replaySpan?.setAttributes({
-                                ...Attribute.WorkflowEventsCount(events.length),
-                            });
-                            return await runWorkflow(workflowCode, workflowRun, events, encryptionKey);
+                        workflowStartedAt = +workflowRun.startedAt;
+                        span?.setAttributes({
+                            ...Attribute.WorkflowRunStatus(workflowRun.status),
+                            ...Attribute.WorkflowStartedAt(workflowStartedAt),
                         });
-                    }
-                    catch (err) {
-                        // WorkflowSuspension is normal control flow — not an error
-                        if (WorkflowSuspension.is(err)) {
-                            const suspensionMessage = buildWorkflowSuspensionMessage(runId, err.stepCount, err.hookCount, err.waitCount);
-                            if (suspensionMessage) {
-                                runtimeLogger.debug(suspensionMessage);
-                            }
-                            const result = await handleSuspension({
-                                suspension: err,
-                                world,
-                                run: workflowRun,
-                                span,
-                                requestId,
+                        if (workflowRun.status !== 'running') {
+                            // Workflow has already completed or failed, so we can skip it
+                            runtimeLogger.info('Workflow already completed or failed, skipping', {
+                                workflowRunId: runId,
+                                status: workflowRun.status,
                             });
-                            if (result.timeoutSeconds !== undefined) {
-                                return { timeoutSeconds: result.timeoutSeconds };
-                            }
-                            // Suspension handled, no further work needed
+                            // TODO: for `cancel`, we actually want to propagate a WorkflowCancelled event
+                            // inside the workflow context so the user can gracefully exit. this is SIGTERM
+                            // TODO: furthermore, there should be a timeout or a way to force cancel SIGKILL
+                            // so that we actually exit here without replaying the workflow at all, in the case
+                            // the replaying the workflow is itself failing.
                             return;
                         }
-                        // This is a user code error or a WorkflowRuntimeError
-                        // (e.g., corrupted event log). Fail the workflow run.
-                        // Record exception for OTEL error tracking
-                        if (err instanceof Error) {
-                            span?.recordException?.(err);
+                    } // end if (!workflowRun)
+                    // Resolve the encryption key for this run's deployment.
+                    // Used eagerly here since both runWorkflow (input
+                    // hydration / hook payload decryption) and the run_failed
+                    // dehydrate path below need it. Memoized accessor: first
+                    // call triggers the actual fetch / HKDF derivation,
+                    // subsequent calls await the cached promise.
+                    const getEncryptionKey = memoizeEncryptionKey(world, workflowRun);
+                    const encryptionKey = await getEncryptionKey();
+                    // Main replay loop
+                    // biome-ignore lint/correctness/noConstantCondition: intentional loop
+                    while (true) {
+                        loopIteration++;
+                        // Replay-budget check: bail out (retry or fail) if
+                        // non-step time within this invocation has exceeded
+                        // the configured budget. Step bodies are excluded
+                        // because replayBudget.pause()/resume() bracket every
+                        // `executeStep` call.
+                        if (replayBudget.isExhausted()) {
+                            await handleReplayBudgetExhausted({
+                                runId,
+                                workflowName,
+                                requestId,
+                                attempt: metadata.attempt,
+                                limitMs: replayBudget.configuredLimitMs,
+                            });
+                            // On Vercel, handleReplayBudgetExhausted always
+                            // exits the process. On local dev it returns; we
+                            // fall through and the request ends normally
+                            // (run_failed has been written best-effort).
+                            return;
                         }
-                        const normalizedError = await normalizeUnknownError(err);
-                        const errorName = normalizedError.name || getErrorName(err);
-                        const errorMessage = normalizedError.message;
-                        let errorStack = normalizedError.stack || getErrorStack(err);
-                        // Remap error stack using source maps to show original source locations
-                        if (errorStack) {
-                            const parsedName = parseWorkflowName(workflowName);
-                            const filename = parsedName?.moduleSpecifier || workflowName;
-                            errorStack = remapErrorStack(errorStack, filename, workflowCode);
+                        // Check timeout before replay
+                        if (Date.now() - invocationStartTime >=
+                            NO_INLINE_REPLAY_AFTER_MS) {
+                            runtimeLogger.info('V2 timeout reached, re-scheduling workflow', {
+                                workflowRunId: runId,
+                                loopIteration,
+                                elapsedMs: Date.now() - invocationStartTime,
+                            });
+                            await queueMessage(world, getWorkflowQueueName(workflowName), {
+                                runId,
+                                traceCarrier: await serializeTraceCarrier(),
+                                requestedAt: new Date(),
+                            });
+                            return;
                         }
-                        // Classify the error: WorkflowRuntimeError indicates an
-                        // internal issue (corrupted event log, missing data);
-                        // everything else is a user code error.
-                        const errorCode = classifyRunError(err);
-                        runtimeLogger.error('Error while running workflow', {
-                            workflowRunId: runId,
-                            errorCode,
-                            errorName,
-                            errorStack,
-                        });
-                        // Fail the workflow run via event (event-sourced architecture)
+                        let replayStart = 0;
                         try {
-                            await world.events.create(runId, {
-                                eventType: 'run_failed',
+                            // Load events — use cached events with incremental fetch on subsequent iterations.
+                            // The server always returns a cursor when there are events (even on the
+                            // final page), so we can reliably use it for incremental loading.
+                            let events;
+                            if (cachedEvents === null) {
+                                // First iteration: use preloaded events if available,
+                                // otherwise do a full load with cursor.
+                                if (preloadedEvents) {
+                                    events = preloadedEvents;
+                                    eventsCursor = preloadedEventsCursor ?? null;
+                                }
+                                else {
+                                    const loaded = await loadWorkflowRunEvents(runId);
+                                    events = loaded.events;
+                                    eventsCursor = loaded.cursor;
+                                }
+                            }
+                            else if (eventsCursor) {
+                                // Subsequent iteration: fetch only new events since last cursor
+                                const loaded = await loadWorkflowRunEvents(runId, eventsCursor);
+                                // Dedupe by eventId: a previous iteration may have
+                                // appended a refreshed wait-completion delta before
+                                // the next loop observes the advanced cursor, so an
+                                // incremental fetch can return events we already have
+                                // locally.
+                                if (loaded.events.length > 0) {
+                                    const existingIds = new Set(cachedEvents.map((e) => e.eventId));
+                                    for (const e of loaded.events) {
+                                        if (!existingIds.has(e.eventId)) {
+                                            cachedEvents.push(e);
+                                        }
+                                    }
+                                }
+                                eventsCursor = loaded.cursor ?? eventsCursor;
+                                events = cachedEvents;
+                            }
+                            else if (preloadedEvents) {
+                                // Iteration 2 after iteration 1 used preloaded events
+                                // (which don't carry a cursor). Do a full load now to
+                                // pick up any events written since the preloaded set
+                                // and obtain a cursor for subsequent incremental
+                                // loads. This is the expected path, not a bug.
+                                runtimeLogger.debug('No cursor after preloaded-events first iteration; doing full reload to pick up cursor.', { workflowRunId: runId });
+                                const loaded = await loadWorkflowRunEvents(runId);
+                                cachedEvents = loaded.events;
+                                eventsCursor = loaded.cursor;
+                                events = cachedEvents;
+                            }
+                            else {
+                                // No cursor available despite having cached events
+                                // and no preloaded-events explanation. All World
+                                // implementations are required to return a cursor
+                                // when there are events, so this signals a bug in
+                                // the World. Fall back to a full reload to avoid
+                                // stale data.
+                                runtimeLogger.warn('Event cursor missing after initial load — falling back to full reload. ' +
+                                    'This indicates a bug in the World implementation.', { workflowRunId: runId });
+                                const loaded = await loadWorkflowRunEvents(runId);
+                                cachedEvents = loaded.events;
+                                eventsCursor = loaded.cursor;
+                                events = cachedEvents;
+                            }
+                            // Detect concurrent completion via the event log: if
+                            // any other handler wrote a terminal run event, exit
+                            // before doing replay work. The run entity's status is
+                            // derived from these events, so checking the log here
+                            // gives us the same signal as a runs.get() round-trip
+                            // without the extra request per loop iteration.
+                            // Terminal run events are always last by construction
+                            // (no event creation succeeds against a terminal run),
+                            // but scan the full array for defense-in-depth: a
+                            // World/backend ordering bug shouldn't make us miss
+                            // an actual termination signal.
+                            const terminalRunEvent = events.find((e) => e.eventType === 'run_completed' ||
+                                e.eventType === 'run_failed' ||
+                                e.eventType === 'run_cancelled');
+                            if (terminalRunEvent) {
+                                runtimeLogger.debug('Run completed by concurrent handler, exiting', {
+                                    workflowRunId: runId,
+                                    eventType: terminalRunEvent.eventType,
+                                });
+                                return;
+                            }
+                            // Complete elapsed waits
+                            const now = Date.now();
+                            const completedWaitIds = new Set(events
+                                .filter((e) => e.eventType === 'wait_completed')
+                                .map((e) => e.correlationId));
+                            const waitsToComplete = events
+                                .filter((e) => e.eventType === 'wait_created' &&
+                                e.correlationId !== undefined &&
+                                !completedWaitIds.has(e.correlationId) &&
+                                now >= e.eventData.resumeAt.getTime())
+                                .map((e) => ({
+                                eventType: 'wait_completed',
                                 specVersion: SPEC_VERSION_CURRENT,
+                                correlationId: e.correlationId,
                                 eventData: {
-                                    error: {
-                                        message: errorMessage,
-                                        stack: errorStack,
-                                    },
-                                    errorCode,
+                                    resumeAt: e.eventData.resumeAt,
                                 },
-                            }, { requestId });
+                            }));
+                            for (const waitEvent of waitsToComplete) {
+                                try {
+                                    await world.events.create(runId, waitEvent, {
+                                        requestId,
+                                    });
+                                }
+                                catch (err) {
+                                    if (EntityConflictError.is(err)) {
+                                        runtimeLogger.info('Wait already completed, skipping', {
+                                            workflowRunId: runId,
+                                            correlationId: waitEvent.correlationId,
+                                        });
+                                        continue;
+                                    }
+                                    throw err;
+                                }
+                            }
+                            if (waitsToComplete.length > 0) {
+                                // The event list above may be stale by the time an
+                                // elapsed wait is committed. Load only events after
+                                // the original snapshot cursor so concurrent durable
+                                // events, such as hook_received, keep their ordering
+                                // relative to wait_completed. Fall back to a full
+                                // reload for older worlds that cannot give us a stable
+                                // cursor, or if the cursor delta does not include the
+                                // wait completion this handler just attempted.
+                                if (eventsCursor) {
+                                    const loaded = await loadWorkflowRunEvents(runId, eventsCursor);
+                                    const completedWaitIdsAfterCursor = new Set(loaded.events
+                                        .filter((e) => e.eventType === 'wait_completed')
+                                        .map((e) => e.correlationId));
+                                    const sawAllWaitCompletions = waitsToComplete.every((waitEvent) => completedWaitIdsAfterCursor.has(waitEvent.correlationId));
+                                    if (sawAllWaitCompletions) {
+                                        const existingIds = new Set(events.map((e) => e.eventId));
+                                        for (const event of loaded.events) {
+                                            if (!existingIds.has(event.eventId)) {
+                                                events.push(event);
+                                            }
+                                        }
+                                        eventsCursor = loaded.cursor ?? eventsCursor;
+                                    }
+                                    else {
+                                        const loaded = await loadWorkflowRunEvents(runId);
+                                        events = loaded.events;
+                                        eventsCursor = loaded.cursor;
+                                    }
+                                }
+                                else {
+                                    const loaded = await loadWorkflowRunEvents(runId);
+                                    events = loaded.events;
+                                    eventsCursor = loaded.cursor;
+                                }
+                            }
+                            // Update cache reference (may have been set for first time)
+                            cachedEvents = events;
+                            // Replay workflow
+                            runtimeLogger.debug('Starting workflow replay', {
+                                workflowRunId: runId,
+                                loopIteration,
+                                eventCount: events.length,
+                            });
+                            replayStart = Date.now();
+                            const result = await runWorkflow(workflowCode, workflowRun, events, encryptionKey);
+                            runtimeLogger.debug('Workflow replay completed', {
+                                workflowRunId: runId,
+                                loopIteration,
+                                replayMs: Date.now() - replayStart,
+                            });
+                            // Workflow completed
+                            try {
+                                await world.events.create(runId, {
+                                    eventType: 'run_completed',
+                                    specVersion: SPEC_VERSION_CURRENT,
+                                    eventData: { output: result },
+                                }, { requestId });
+                            }
+                            catch (err) {
+                                if (EntityConflictError.is(err) ||
+                                    RunExpiredError.is(err)) {
+                                    runtimeLogger.info('Tried completing workflow run, but run has already finished.', { workflowRunId: runId, message: err.message });
+                                    return;
+                                }
+                                throw err;
+                            }
+                            span?.setAttributes({
+                                ...Attribute.WorkflowRunStatus('completed'),
+                            });
+                            return;
                         }
-                        catch (failErr) {
-                            if (EntityConflictError.is(failErr) ||
-                                RunExpiredError.is(failErr)) {
-                                runtimeLogger.info('Tried failing workflow run, but run has already finished.', {
+                        catch (err) {
+                            if (WorkflowSuspension.is(err)) {
+                                runtimeLogger.debug('Workflow suspended', {
                                     workflowRunId: runId,
-                                    message: failErr.message,
+                                    loopIteration,
+                                    replayMs: Date.now() - replayStart,
+                                    steps: err.stepCount,
+                                    hooks: err.hookCount,
+                                    waits: err.waitCount,
                                 });
+                                const suspensionMessage = buildWorkflowSuspensionMessage(err.stepCount, err.hookCount, err.waitCount);
+                                if (suspensionMessage) {
+                                    runtimeLogger.debug(suspensionMessage);
+                                }
+                                // V2: handle suspension without queuing steps
+                                const suspensionStart = Date.now();
+                                const suspensionResult = await handleSuspension({
+                                    suspension: err,
+                                    world,
+                                    run: workflowRun,
+                                    span,
+                                    requestId,
+                                });
+                                runtimeLogger.debug('Suspension handled', {
+                                    workflowRunId: runId,
+                                    suspensionMs: Date.now() - suspensionStart,
+                                    pendingSteps: suspensionResult.pendingSteps.length,
+                                    timeoutSeconds: suspensionResult.timeoutSeconds,
+                                    hasHookConflict: suspensionResult.hasHookConflict,
+                                });
+                                // Hook conflict: break loop, re-invoke via queue
+                                if (suspensionResult.hasHookConflict) {
+                                    return { timeoutSeconds: 0 };
+                                }
+                                const pendingSteps = suspensionResult.pendingSteps;
+                                if (pendingSteps.length === 0) {
+                                    // No steps — only waits/hooks
+                                    if (suspensionResult.timeoutSeconds !== undefined) {
+                                        return {
+                                            timeoutSeconds: suspensionResult.timeoutSeconds,
+                                        };
+                                    }
+                                    return;
+                                }
+                                // Inline execution is gated on ownership: only the
+                                // handler that actually wrote the step_created event
+                                // may run the step body inline. The world-level
+                                // step_created is atomic per-correlationId, so
+                                // exactly one handler owns each step — concurrent
+                                // handlers can't race on step execution.
+                                const ownedPendingSteps = pendingSteps.filter((s) => suspensionResult.createdStepCorrelationIds.has(s.correlationId));
+                                // Pick one owned step to execute inline (if any).
+                                // The rest of the pending steps are queued below.
+                                //
+                                // Skip inline execution entirely when the suspension
+                                // also has a pending wait (sleep): an inline `await
+                                // executeStep(...)` blocks the handler for the full
+                                // step duration, so the wait timer never has a chance
+                                // to fire on time. That defeats `Promise.race(step,
+                                // sleep)` semantics — if the sleep is shorter than
+                                // the step, replay still picks the step because
+                                // wait_completed is only created on the *next* loop
+                                // iteration, which doesn't run until the step
+                                // finishes. Queueing every step in this case lets
+                                // the wait timeout drive a continuation in parallel,
+                                // matching V1's behavior where each step ran in a
+                                // separate function invocation.
+                                const inlineStep = suspensionResult.timeoutSeconds === undefined
+                                    ? ownedPendingSteps[0]
+                                    : undefined;
+                                // Queue every pending step except the one we're
+                                // executing inline. This mirrors V1's unconditional
+                                // enqueue-with-idempotency pattern and is what makes
+                                // crash recovery work: if a prior handler wrote
+                                // step_created events but crashed before enqueuing,
+                                // a later handler (e.g., from flow-message
+                                // redelivery or reenqueueActiveRuns) will enqueue
+                                // the orphaned steps. In the happy path with a
+                                // single owner, concurrent handlers' queue attempts
+                                // dedupe on correlationId. Skipping the inline step
+                                // avoids a queue handler racing against our own
+                                // inline executor.
+                                for (const step of pendingSteps) {
+                                    if (inlineStep &&
+                                        step.correlationId === inlineStep.correlationId) {
+                                        continue;
+                                    }
+                                    const traceCarrier = await serializeTraceCarrier();
+                                    await queueMessage(world, getWorkflowQueueName(workflowName), {
+                                        runId,
+                                        stepId: step.correlationId,
+                                        stepName: step.stepName,
+                                        traceCarrier,
+                                        requestedAt: new Date(),
+                                    }, {
+                                        idempotencyKey: step.correlationId,
+                                    });
+                                }
+                                // Nothing to execute inline — we already queued all
+                                // pending steps above, exit and let the queue drive.
+                                if (!inlineStep) {
+                                    if (suspensionResult.timeoutSeconds !== undefined) {
+                                        return {
+                                            timeoutSeconds: suspensionResult.timeoutSeconds,
+                                        };
+                                    }
+                                    return;
+                                }
+                                // Execute inline step. Pause the replay budget
+                                // for the duration of the step body — step
+                                // duration is bounded by the platform's function
+                                // maxDuration, not by the replay timeout. Without
+                                // this the replay-budget check at the top of the
+                                // next loop iteration would (incorrectly) charge
+                                // the step body against the budget.
+                                replayBudget.pause();
+                                let stepResult;
+                                try {
+                                    stepResult = await executeStep({
+                                        world,
+                                        workflowRunId: runId,
+                                        workflowName,
+                                        workflowStartedAt,
+                                        stepId: inlineStep.correlationId,
+                                        stepName: inlineStep.stepName,
+                                    });
+                                }
+                                finally {
+                                    replayBudget.resume();
+                                }
+                                if (stepResult.type === 'retry') {
+                                    // Step needs retry — queue self with stepId for retry
+                                    const traceCarrier = await serializeTraceCarrier();
+                                    await queueMessage(world, getWorkflowQueueName(workflowName), {
+                                        runId,
+                                        stepId: inlineStep.correlationId,
+                                        stepName: inlineStep.stepName,
+                                        traceCarrier,
+                                        requestedAt: new Date(),
+                                    }, {
+                                        delaySeconds: stepResult.timeoutSeconds,
+                                    });
+                                    // If there are also waits, return their timeout
+                                    if (suspensionResult.timeoutSeconds !== undefined) {
+                                        return {
+                                            timeoutSeconds: suspensionResult.timeoutSeconds,
+                                        };
+                                    }
+                                    return;
+                                }
+                                if (stepResult.type === 'throttled') {
+                                    return {
+                                        timeoutSeconds: stepResult.timeoutSeconds,
+                                    };
+                                }
+                                // Step completed or failed — loop back to replay
+                                // (gone/skipped also loop back since the workflow
+                                // will see the completed/failed event on replay)
+                                // If the step had pending background ops (e.g., stream
+                                // writes to S3), break the loop and return so waitUntil
+                                // can flush them. This matches V1 behavior where each
+                                // step ran in a separate function invocation. Without
+                                // this, the inline loop continues and the stream data
+                                // may not reach S3 before the test tries to read it.
+                                if (stepResult.type === 'completed' &&
+                                    stepResult.hasPendingOps) {
+                                    runtimeLogger.debug('Breaking loop: step has pending ops', {
+                                        workflowRunId: runId,
+                                        loopIteration,
+                                        stepName: inlineStep.stepName,
+                                    });
+                                    await queueMessage(world, getWorkflowQueueName(workflowName), {
+                                        runId,
+                                        traceCarrier: await serializeTraceCarrier(),
+                                        requestedAt: new Date(),
+                                    });
+                                    return;
+                                }
+                                if (suspensionResult.timeoutSeconds !== undefined &&
+                                    pendingSteps.length === 1) {
+                                    // Only 1 step and there's also waits/hooks,
+                                    // step is done, but we need the wait timeout
+                                    // Loop back to replay which will re-evaluate
+                                }
+                            }
+                            else {
+                                // User code error from runWorkflow — create run_failed.
+                                if (err instanceof Error) {
+                                    span?.recordException?.(err);
+                                }
+                                const normalizedError = await normalizeUnknownError(err);
+                                const errorName = normalizedError.name || getErrorName(err);
+                                const errorMessage = normalizedError.message;
+                                let errorStack = normalizedError.stack || getErrorStack(err);
+                                if (errorStack) {
+                                    const parsedName = parseWorkflowName(workflowName);
+                                    const filename = parsedName?.moduleSpecifier || workflowName;
+                                    errorStack = remapErrorStack(errorStack, filename, workflowCode);
+                                }
+                                // Classify the error: WorkflowRuntimeError indicates
+                                // an SDK/runtime issue, and selected subclasses use
+                                // more specific codes for backend tracking.
+                                const errorCode = classifyRunError(err);
+                                runtimeLogger.error('Error while running workflow', {
+                                    workflowRunId: runId,
+                                    errorCode,
+                                    errorName,
+                                    errorStack,
+                                });
+                                // Apply the source-map-remapped stack to the thrown
+                                // value so that the serialized error preserves it
+                                // for consumers. `types.isNativeError()` is used
+                                // instead of `err instanceof Error` because the
+                                // workflow runs in a separate VM realm — its Error
+                                // class is distinct from the host's, so `instanceof
+                                // Error` is `false` for VM-thrown errors. The V8
+                                // type tag works across realms.
+                                if (types.isNativeError(err) && errorStack) {
+                                    err.stack = errorStack;
+                                }
+                                // Fail the workflow run via event (event-sourced).
+                                // Serialize the original thrown value so its full
+                                // type identity and custom properties round-trip
+                                // through the event log.
+                                try {
+                                    await world.events.create(runId, {
+                                        eventType: 'run_failed',
+                                        specVersion: SPEC_VERSION_CURRENT,
+                                        eventData: {
+                                            error: await dehydrateRunError(err, runId, encryptionKey),
+                                            errorCode,
+                                        },
+                                    }, { requestId });
+                                }
+                                catch (failErr) {
+                                    if (EntityConflictError.is(failErr) ||
+                                        RunExpiredError.is(failErr)) {
+                                        runtimeLogger.info('Tried failing workflow run, but run has already finished.', {
+                                            workflowRunId: runId,
+                                            message: failErr.message,
+                                        });
+                                        return;
+                                    }
+                                    if (isWorldContractError(failErr)) {
+                                        runtimeLogger.error('Fatal world contract error while recording workflow failure', {
+                                            workflowRunId: runId,
+                                            errorCode: RUN_ERROR_CODES.WORLD_CONTRACT_ERROR,
+                                            error: failErr instanceof Error
+                                                ? failErr.message
+                                                : String(failErr),
+                                        });
+                                        return;
+                                    }
+                                    throw failErr;
+                                }
                                 span?.setAttributes({
+                                    ...Attribute.WorkflowRunStatus('failed'),
                                     ...Attribute.WorkflowErrorCode(errorCode),
                                     ...Attribute.WorkflowErrorName(errorName),
                                     ...Attribute.WorkflowErrorMessage(errorMessage),
@@ -382,54 +907,10 @@ export function workflowEntrypoint(workflowCode) {
                                 });
                                 return;
                             }
-                            else {
-                                throw failErr;
-                            }
-                        }
-                        span?.setAttributes({
-                            ...Attribute.WorkflowRunStatus('failed'),
-                            ...Attribute.WorkflowErrorCode(errorCode),
-                            ...Attribute.WorkflowErrorName(errorName),
-                            ...Attribute.WorkflowErrorMessage(errorMessage),
-                            ...Attribute.ErrorType(errorName),
-                        });
-                        return;
-                    }
-                    // --- Infrastructure: complete the run ---
-                    // This is outside the user-code try/catch so that failures
-                    // here (e.g., network errors) propagate to the queue handler.
-                    try {
-                        await world.events.create(runId, {
-                            eventType: 'run_completed',
-                            specVersion: SPEC_VERSION_CURRENT,
-                            eventData: {
-                                output: workflowResult,
-                            },
-                        }, { requestId });
-                    }
-                    catch (err) {
-                        if (EntityConflictError.is(err) ||
-                            RunExpiredError.is(err)) {
-                            runtimeLogger.info('Tried completing workflow run, but run has already finished.', {
-                                workflowRunId: runId,
-                                message: err.message,
-                            });
-                            return;
                         }
-                        else {
-                            throw err;
-                        }
-                    }
-                    span?.setAttributes({
-                        ...Attribute.WorkflowRunStatus('completed'),
-                        ...Attribute.WorkflowEventsCount(events.length),
-                    });
+                    } // End while loop
                 }); // End trace
             }); // End withWorkflowBaggage
-        }).finally(() => {
-            if (replayTimeout) {
-                clearTimeout(replayTimeout);
-            }
         }); // End withTraceContext
     });
     let cachedHandler;
@@ -440,7 +921,4 @@ export function workflowEntrypoint(workflowCode) {
         return cachedHandler(req);
     });
 }
-// this is a no-op placeholder as the client is
-// expecting this to be present but we aren't actually using it
-export function runStep() { }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["import { types } from 'node:util';\nimport {\n  EntityConflictError,\n  FatalError,\n  RUN_ERROR_CODES,\n  type RunErrorCode,\n  RunExpiredError,\n  WorkflowRuntimeError,\n} from '@workflow/errors';\nimport { parseWorkflowName } from '@workflow/utils/parse-name';\nimport {\n  type Event,\n  SPEC_VERSION_CURRENT,\n  WorkflowInvokePayloadSchema,\n  type WorkflowRun,\n  type World,\n} from '@workflow/world';\nimport { classifyRunError, isWorldContractError } from './classify-error.js';\nimport { describeError } from './describe-error.js';\nimport { WorkflowSuspension } from './global.js';\nimport { runtimeLogger } from './logger.js';\nimport { MAX_QUEUE_DELIVERIES } from './runtime/constants.js';\nimport {\n  getQueueOverhead,\n  getWorkflowQueueName,\n  handleHealthCheckMessage,\n  loadWorkflowRunEvents,\n  memoizeEncryptionKey,\n  parseHealthCheckPayload,\n  queueMessage,\n  withHealthCheck,\n} from './runtime/helpers.js';\nimport {\n  handleReplayBudgetExhausted,\n  ReplayBudget,\n} from './runtime/replay-budget.js';\nimport { executeStep } from './runtime/step-executor.js';\nimport { handleSuspension } from './runtime/suspension-handler.js';\nimport {\n  getWorld,\n  getWorldHandlers,\n  type WorldHandlers,\n} from './runtime/world.js';\nimport { dehydrateRunError } from './serialization.js';\nimport { remapErrorStack } from './source-map.js';\nimport * as Attribute from './telemetry/semantic-conventions.js';\nimport {\n  linkToCurrentContext,\n  serializeTraceCarrier,\n  trace,\n  withTraceContext,\n  withWorkflowBaggage,\n} from './telemetry.js';\nimport { getErrorName, getErrorStack, normalizeUnknownError } from './types.js';\nimport { buildWorkflowSuspensionMessage } from './util.js';\nimport { runWorkflow } from './workflow.js';\n\nexport type { Event, WorkflowRun };\nexport { WorkflowSuspension } from './global.js';\nexport {\n  type HealthCheckEndpoint,\n  type HealthCheckOptions,\n  type HealthCheckResult,\n  healthCheck,\n} from './runtime/helpers.js';\nexport {\n  getHookByToken,\n  resumeHook,\n  resumeWebhook,\n} from './runtime/resume-hook.js';\nexport {\n  getRun,\n  Run,\n  type WorkflowReadableStream,\n  type WorkflowReadableStreamOptions,\n} from './runtime/run.js';\nexport {\n  cancelRun,\n  listStreams,\n  type ReadStreamOptions,\n  type RecreateRunOptions,\n  readStream,\n  recreateRunFromExisting,\n  reenqueueRun,\n  type StopSleepOptions,\n  type StopSleepResult,\n  wakeUpRun,\n} from './runtime/runs.js';\nexport {\n  type StartOptions,\n  type StartOptionsBase,\n  type StartOptionsWithDeploymentId,\n  type StartOptionsWithoutDeploymentId,\n  start,\n} from './runtime/start.js';\n// V2: stepEntrypoint is no longer re-exported — the combined handler\n// (workflowEntrypoint) executes steps inline. Removing the re-export\n// prevents Turbopack from tracing step-handler.js → get-port.js\n// filesystem operations into the flow route bundle.\nexport {\n  createWorld,\n  getWorld,\n  getWorldHandlers,\n  setWorld,\n} from './runtime/world.js';\n\nfunction getWorkflowSetupErrorCode(err: unknown): RunErrorCode | null {\n  if (WorkflowRuntimeError.is(err)) {\n    return RUN_ERROR_CODES.RUNTIME_ERROR;\n  }\n\n  if (isWorldContractError(err)) {\n    return RUN_ERROR_CODES.WORLD_CONTRACT_ERROR;\n  }\n\n  return null;\n}\n\nasync function recordFatalRunError({\n  world,\n  workflowRun,\n  runId,\n  requestId,\n  err,\n  errorCode,\n  logMessage,\n}: {\n  world: World;\n  workflowRun: WorkflowRun | undefined;\n  runId: string;\n  requestId: string | undefined;\n  err: unknown;\n  errorCode: RunErrorCode;\n  logMessage: string;\n}) {\n  runtimeLogger.error(logMessage, {\n    workflowRunId: runId,\n    errorCode,\n    error: err instanceof Error ? err.message : String(err),\n  });\n\n  try {\n    const getEncryptionKey = memoizeEncryptionKey(world, workflowRun ?? runId);\n    await world.events.create(\n      runId,\n      {\n        eventType: 'run_failed',\n        specVersion: SPEC_VERSION_CURRENT,\n        eventData: {\n          error: await dehydrateRunError(err, runId, await getEncryptionKey()),\n          errorCode,\n        },\n      },\n      { requestId }\n    );\n  } catch (failErr) {\n    if (EntityConflictError.is(failErr) || RunExpiredError.is(failErr)) {\n      return;\n    }\n    if (isWorldContractError(failErr)) {\n      runtimeLogger.error(\n        'Fatal world contract error while recording workflow failure',\n        {\n          workflowRunId: runId,\n          errorCode: RUN_ERROR_CODES.WORLD_CONTRACT_ERROR,\n          error: failErr instanceof Error ? failErr.message : String(failErr),\n        }\n      );\n      return;\n    }\n    throw failErr;\n  }\n}\n\n/**\n * Creates a single route which handles workflow execution requests,\n * executing steps inline when possible to reduce function invocations\n * and queue overhead.\n *\n * The handler loops: replay workflow → execute step inline → replay → ...\n * until the workflow completes, times out, or encounters non-step suspensions.\n *\n * @param workflowCode - The workflow bundle code containing all workflow functions\n * @returns A function that can be used as a Vercel API route\n */\nexport function workflowEntrypoint(\n  workflowCode: string\n): (req: Request) => Promise<Response> {\n  const NO_INLINE_REPLAY_AFTER_MS =\n    Number(process.env.WORKFLOW_V2_TIMEOUT_MS) || 120_000;\n\n  const handler = (worldHandlers: WorldHandlers) =>\n    worldHandlers.createQueueHandler(\n      '__wkf_workflow_',\n      async (message_, metadata) => {\n        // Check if this is a health check message\n        // NOTE: Health check messages are intentionally unauthenticated for monitoring purposes.\n        // They only write a simple status response to a stream and do not expose sensitive data.\n        // The stream name includes a unique correlationId that must be known by the caller.\n        const healthCheck = parseHealthCheckPayload(message_);\n        if (healthCheck) {\n          await handleHealthCheckMessage(\n            healthCheck,\n            'workflow',\n            worldHandlers.specVersion\n          );\n          return;\n        }\n\n        const {\n          runId,\n          traceCarrier: traceContext,\n          requestedAt,\n          stepId: incomingStepId,\n          stepName: incomingStepName,\n          runInput,\n        } = WorkflowInvokePayloadSchema.parse(message_);\n        const { requestId } = metadata;\n        const workflowName = metadata.queueName.slice('__wkf_workflow_'.length);\n\n        // --- Max delivery check ---\n        // Enforce max delivery limit before any infrastructure calls.\n        // This prevents runaway workflows from consuming infinite queue deliveries.\n        // Scoped logger for this run — attaches runId/workflowName to every\n        // log line and child loggers below, so callers don't repeat it.\n        const runLogger = runtimeLogger.forRun(runId, workflowName);\n\n        if (metadata.attempt > MAX_QUEUE_DELIVERIES) {\n          const maxDeliveriesDescription = describeError(\n            undefined,\n            RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED\n          );\n          runLogger.error(\n            `Workflow handler exceeded max deliveries (${metadata.attempt}/${MAX_QUEUE_DELIVERIES})`,\n            {\n              attempt: metadata.attempt,\n              errorCode: maxDeliveriesDescription.errorCode,\n              errorAttribution: maxDeliveriesDescription.attribution,\n            }\n          );\n          try {\n            const world = await getWorld();\n            const getEncryptionKey = memoizeEncryptionKey(world, runId);\n            const err = new FatalError(\n              `Workflow exceeded maximum queue deliveries (${metadata.attempt}/${MAX_QUEUE_DELIVERIES})`\n            );\n            await world.events.create(\n              runId,\n              {\n                eventType: 'run_failed',\n                specVersion: SPEC_VERSION_CURRENT,\n                eventData: {\n                  error: await dehydrateRunError(\n                    err,\n                    runId,\n                    await getEncryptionKey()\n                  ),\n                  errorCode: RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED,\n                },\n              },\n              { requestId }\n            );\n          } catch (err) {\n            if (EntityConflictError.is(err) || RunExpiredError.is(err)) {\n              // Run already finished, consume the message silently\n              return;\n            }\n            runLogger.error(\n              `Failed to mark run as failed after ${metadata.attempt} delivery attempts. ` +\n                `A persistent error is preventing the run from being terminated. ` +\n                `The run will remain in its current state until manually resolved. ` +\n                `This is most likely due to a persistent outage of the workflow backend ` +\n                `or a bug in the workflow runtime and should be reported to the Workflow team.`,\n              {\n                attempt: metadata.attempt,\n                errorName: err instanceof Error ? err.name : 'UnknownError',\n                errorMessage: err instanceof Error ? err.message : String(err),\n                errorStack: err instanceof Error ? err.stack : undefined,\n              }\n            );\n          }\n          return;\n        }\n\n        const spanLinks = await linkToCurrentContext();\n\n        // --- Replay budget bookkeeping ---\n        // The replay budget bounds the *non-step* portion of a single\n        // handler invocation: deterministic event-log replay, workflow-VM\n        // execution between step boundaries, suspension handling, queue\n        // round-trips, etc. Inline step bodies (`\"use step\"` functions\n        // invoked via `executeStep`) are intentionally excluded — they are\n        // bounded by the platform's function `maxDuration` and the\n        // `NO_INLINE_REPLAY_AFTER_MS` early-return guard below.\n        //\n        // The budget is checked at loop boundaries (top of each `while`\n        // iteration). Note this is *less responsive* than the old\n        // `setTimeout`-based approach: a single pathological `runWorkflow`\n        // call processing a huge event log can overshoot the budget by up\n        // to one iteration before bailing. In practice the headroom built\n        // into `MAX_REPLAY_TIMEOUT_MS` (and the platform `maxDuration`\n        // SIGTERM as ultimate backstop) gives us slack — the previous\n        // `setTimeout` approach also relied on the platform kill as the\n        // hard backstop. Do *not* \"fix\" this by adding a `setInterval`;\n        // it would risk the same bug we just removed (bounding step\n        // bodies).\n        //\n        // Earlier versions (pre-#2009 fix) used a single `setTimeout`\n        // that also bounded step bodies, which broke any workflow with a\n        // single step longer than the budget.\n        const replayBudget = new ReplayBudget();\n\n        return await withTraceContext(traceContext, async () => {\n          return await withWorkflowBaggage(\n            { workflowRunId: runId, workflowName },\n            async () => {\n              const world = await getWorld();\n              return trace(\n                `WORKFLOW_V2 ${workflowName}`,\n                { links: spanLinks },\n                async (span) => {\n                  span?.setAttributes({\n                    ...Attribute.WorkflowName(workflowName),\n                    ...Attribute.WorkflowOperation('execute_v2'),\n                    ...Attribute.MessagingSystem('vercel-queue'),\n                    ...Attribute.MessagingDestinationName(metadata.queueName),\n                    ...Attribute.MessagingMessageId(metadata.messageId),\n                    ...Attribute.MessagingOperationType('process'),\n                    ...getQueueOverhead({ requestedAt }),\n                    ...Attribute.WorkflowRunId(runId),\n                    ...Attribute.WorkflowTracePropagated(!!traceContext),\n                  });\n\n                  const invocationStartTime = Date.now();\n                  let loopIteration = 0;\n\n                  // Event cache: keep loaded events in memory across loop iterations.\n                  // On the first iteration we do a full load; on subsequent iterations\n                  // we fetch only events created after the last known cursor.\n                  let cachedEvents: Event[] | null = null;\n                  let eventsCursor: string | null = null;\n\n                  // Shared state: set by either the background step path\n                  // or the run_started setup below.\n                  let workflowRun: WorkflowRun | undefined;\n                  let workflowStartedAt = -1;\n                  let preloadedEvents: Event[] | undefined;\n                  let preloadedEventsCursor: string | null | undefined;\n\n                  // If incoming message has a stepId, this is a background step\n                  // execution. Execute the step, then check if all parallel steps\n                  // from the batch are done. If so, replay inline (saving a queue\n                  // roundtrip). If not, return — the last handler to complete\n                  // will pick up the replay.\n                  if (incomingStepId && incomingStepName) {\n                    try {\n                      const bgRun = await world.runs.get(runId);\n                      if (bgRun.status !== 'running') {\n                        runtimeLogger.debug(\n                          'Run already finished, skipping background step',\n                          { workflowRunId: runId, status: bgRun.status }\n                        );\n                        return;\n                      }\n                      const bgStartedAt = bgRun.startedAt\n                        ? +bgRun.startedAt\n                        : Date.now();\n                      // Pause the replay budget while the step body runs —\n                      // step duration is bounded by the platform's function\n                      // maxDuration, not by the replay timeout. See the\n                      // ReplayBudget docs for the contract.\n                      replayBudget.pause();\n                      let stepResult: Awaited<ReturnType<typeof executeStep>>;\n                      try {\n                        stepResult = await executeStep({\n                          world,\n                          workflowRunId: runId,\n                          workflowName,\n                          workflowStartedAt: bgStartedAt,\n                          stepId: incomingStepId,\n                          stepName: incomingStepName,\n                        });\n                      } finally {\n                        replayBudget.resume();\n                      }\n                      if (stepResult.type === 'retry') {\n                        return { timeoutSeconds: stepResult.timeoutSeconds };\n                      }\n                      if (stepResult.type === 'throttled') {\n                        return { timeoutSeconds: stepResult.timeoutSeconds };\n                      }\n\n                      // If step had pending ops (stream writes), break and let\n                      // waitUntil flush them — can't continue inline.\n                      if (\n                        stepResult.type === 'completed' &&\n                        stepResult.hasPendingOps\n                      ) {\n                        await queueMessage(\n                          world,\n                          getWorkflowQueueName(workflowName),\n                          {\n                            runId,\n                            traceCarrier: await serializeTraceCarrier(),\n                            requestedAt: new Date(),\n                          }\n                        );\n                        return;\n                      }\n\n                      if (\n                        stepResult.type === 'completed' ||\n                        stepResult.type === 'failed' ||\n                        stepResult.type === 'skipped'\n                      ) {\n                        // Load events to check if all parallel steps are done.\n                        // Use cursor-based loading so the main loop can continue\n                        // incrementally from here.\n                        const loaded = await loadWorkflowRunEvents(runId);\n                        cachedEvents = loaded.events;\n                        eventsCursor = loaded.cursor;\n\n                        // Check for pending steps: any step_created without\n                        // a matching step_completed or step_failed.\n                        const stepCreatedIds = new Set<string | undefined>();\n                        const stepTerminalIds = new Set<string | undefined>();\n                        for (const e of cachedEvents) {\n                          if (e.eventType === 'step_created') {\n                            stepCreatedIds.add(e.correlationId);\n                          } else if (\n                            e.eventType === 'step_completed' ||\n                            e.eventType === 'step_failed'\n                          ) {\n                            stepTerminalIds.add(e.correlationId);\n                          }\n                        }\n                        let hasPendingSteps = false;\n                        for (const id of stepCreatedIds) {\n                          if (!stepTerminalIds.has(id)) {\n                            hasPendingSteps = true;\n                            break;\n                          }\n                        }\n\n                        if (hasPendingSteps) {\n                          // Other steps still in progress. Return without\n                          // queuing — the last handler to complete will see\n                          // all steps done and replay inline.\n                          runtimeLogger.debug(\n                            'Background step done but other steps pending, returning',\n                            { workflowRunId: runId }\n                          );\n                          return;\n                        }\n\n                        // All steps done — fall through to the main replay loop.\n                        // Set up shared state so the loop can continue.\n                        runtimeLogger.debug(\n                          'All parallel steps done, replaying inline after background step',\n                          { workflowRunId: runId }\n                        );\n                        workflowRun = bgRun;\n                        workflowStartedAt = bgStartedAt;\n                        // cachedEvents and eventsCursor already set from load above\n                      } else {\n                        return;\n                      }\n                    } catch (err) {\n                      const errorCode = getWorkflowSetupErrorCode(err);\n                      if (!errorCode) {\n                        throw err;\n                      }\n                      await recordFatalRunError({\n                        world,\n                        workflowRun,\n                        runId,\n                        requestId,\n                        err,\n                        errorCode,\n                        logMessage:\n                          'Fatal error while preparing background workflow step',\n                      });\n                      return;\n                    }\n                  }\n\n                  // --- Infrastructure: prepare the run state ---\n                  // Skip if workflowRun was already set by the background\n                  // step path (inline replay after all parallel steps done).\n                  if (!workflowRun) {\n                    // Always call run_started directly — this both transitions\n                    // the run to 'running' AND returns the run entity, saving\n                    // a separate runs.get round-trip.\n                    // Contract: events.create('run_started') must be idempotent\n                    // for runs already in 'running' status (return the run\n                    // without error), not just for pending → running transitions.\n                    try {\n                      const result = await world.events.create(\n                        runId,\n                        {\n                          eventType: 'run_started',\n                          // Use the spec version from the original start() call\n                          // when available, so the resilient start path creates\n                          // the run with the correct version (not always current).\n                          specVersion:\n                            runInput?.specVersion ?? SPEC_VERSION_CURRENT,\n                          // Pass run input from queue so the server can\n                          // create the run if run_created was missed.\n                          // Uint8Array values survive the queue natively\n                          // (CBOR on world-vercel, JSON reviver on world-local).\n                          ...(runInput\n                            ? {\n                                eventData: {\n                                  input: runInput.input,\n                                  deploymentId: runInput.deploymentId,\n                                  workflowName: runInput.workflowName,\n                                  executionContext: runInput.executionContext,\n                                },\n                              }\n                            : {}),\n                        },\n                        { requestId }\n                      );\n                      if (!result.run) {\n                        throw new WorkflowRuntimeError(\n                          `Event creation for 'run_started' did not return the run entity for run \"${runId}\"`\n                        );\n                      }\n                      workflowRun = result.run;\n\n                      // If the response includes events, use them to skip\n                      // the initial events.list call and reduce TTFB.\n                      if (\n                        result.events &&\n                        result.events.length > 0 &&\n                        result.hasMore !== true\n                      ) {\n                        preloadedEvents = result.events;\n                        preloadedEventsCursor = result.cursor;\n                      }\n\n                      if (!workflowRun.startedAt) {\n                        throw new WorkflowRuntimeError(\n                          `Workflow run \"${runId}\" has no \"startedAt\" timestamp`\n                        );\n                      }\n                    } catch (err) {\n                      // Run was concurrently completed/failed/cancelled\n                      if (\n                        EntityConflictError.is(err) ||\n                        RunExpiredError.is(err)\n                      ) {\n                        // EntityConflictError: run was concurrently\n                        // completed/failed/cancelled during setup.\n                        // RunExpiredError: run already in terminal state.\n                        // In both cases, skip processing this message.\n                        runtimeLogger.info(\n                          'Run already finished during setup, skipping',\n                          { workflowRunId: runId, message: err.message }\n                        );\n                        return;\n                      } else {\n                        const errorCode = getWorkflowSetupErrorCode(err);\n                        if (!errorCode) {\n                          throw err;\n                        }\n                        await recordFatalRunError({\n                          world,\n                          workflowRun,\n                          runId,\n                          requestId,\n                          err,\n                          errorCode,\n                          logMessage:\n                            'Fatal runtime error during workflow setup',\n                        });\n                        return;\n                      }\n                    }\n\n                    workflowStartedAt = +workflowRun.startedAt;\n\n                    span?.setAttributes({\n                      ...Attribute.WorkflowRunStatus(workflowRun.status),\n                      ...Attribute.WorkflowStartedAt(workflowStartedAt),\n                    });\n\n                    if (workflowRun.status !== 'running') {\n                      // Workflow has already completed or failed, so we can skip it\n                      runtimeLogger.info(\n                        'Workflow already completed or failed, skipping',\n                        {\n                          workflowRunId: runId,\n                          status: workflowRun.status,\n                        }\n                      );\n\n                      // TODO: for `cancel`, we actually want to propagate a WorkflowCancelled event\n                      // inside the workflow context so the user can gracefully exit. this is SIGTERM\n                      // TODO: furthermore, there should be a timeout or a way to force cancel SIGKILL\n                      // so that we actually exit here without replaying the workflow at all, in the case\n                      // the replaying the workflow is itself failing.\n\n                      return;\n                    }\n                  } // end if (!workflowRun)\n\n                  // Resolve the encryption key for this run's deployment.\n                  // Used eagerly here since both runWorkflow (input\n                  // hydration / hook payload decryption) and the run_failed\n                  // dehydrate path below need it. Memoized accessor: first\n                  // call triggers the actual fetch / HKDF derivation,\n                  // subsequent calls await the cached promise.\n                  const getEncryptionKey = memoizeEncryptionKey(\n                    world,\n                    workflowRun\n                  );\n                  const encryptionKey = await getEncryptionKey();\n\n                  // Main replay loop\n                  // biome-ignore lint/correctness/noConstantCondition: intentional loop\n                  while (true) {\n                    loopIteration++;\n\n                    // Replay-budget check: bail out (retry or fail) if\n                    // non-step time within this invocation has exceeded\n                    // the configured budget. Step bodies are excluded\n                    // because replayBudget.pause()/resume() bracket every\n                    // `executeStep` call.\n                    if (replayBudget.isExhausted()) {\n                      await handleReplayBudgetExhausted({\n                        runId,\n                        workflowName,\n                        requestId,\n                        attempt: metadata.attempt,\n                        limitMs: replayBudget.configuredLimitMs,\n                      });\n                      // On Vercel, handleReplayBudgetExhausted always\n                      // exits the process. On local dev it returns; we\n                      // fall through and the request ends normally\n                      // (run_failed has been written best-effort).\n                      return;\n                    }\n\n                    // Check timeout before replay\n                    if (\n                      Date.now() - invocationStartTime >=\n                      NO_INLINE_REPLAY_AFTER_MS\n                    ) {\n                      runtimeLogger.info(\n                        'V2 timeout reached, re-scheduling workflow',\n                        {\n                          workflowRunId: runId,\n                          loopIteration,\n                          elapsedMs: Date.now() - invocationStartTime,\n                        }\n                      );\n                      await queueMessage(\n                        world,\n                        getWorkflowQueueName(workflowName),\n                        {\n                          runId,\n                          traceCarrier: await serializeTraceCarrier(),\n                          requestedAt: new Date(),\n                        }\n                      );\n                      return;\n                    }\n\n                    let replayStart = 0;\n                    try {\n                      // Load events — use cached events with incremental fetch on subsequent iterations.\n                      // The server always returns a cursor when there are events (even on the\n                      // final page), so we can reliably use it for incremental loading.\n                      let events: Event[];\n                      if (cachedEvents === null) {\n                        // First iteration: use preloaded events if available,\n                        // otherwise do a full load with cursor.\n                        if (preloadedEvents) {\n                          events = preloadedEvents;\n                          eventsCursor = preloadedEventsCursor ?? null;\n                        } else {\n                          const loaded = await loadWorkflowRunEvents(runId);\n                          events = loaded.events;\n                          eventsCursor = loaded.cursor;\n                        }\n                      } else if (eventsCursor) {\n                        // Subsequent iteration: fetch only new events since last cursor\n                        const loaded = await loadWorkflowRunEvents(\n                          runId,\n                          eventsCursor\n                        );\n                        // Dedupe by eventId: a previous iteration may have\n                        // appended a refreshed wait-completion delta before\n                        // the next loop observes the advanced cursor, so an\n                        // incremental fetch can return events we already have\n                        // locally.\n                        if (loaded.events.length > 0) {\n                          const existingIds = new Set(\n                            cachedEvents.map((e) => e.eventId)\n                          );\n                          for (const e of loaded.events) {\n                            if (!existingIds.has(e.eventId)) {\n                              cachedEvents.push(e);\n                            }\n                          }\n                        }\n                        eventsCursor = loaded.cursor ?? eventsCursor;\n                        events = cachedEvents;\n                      } else if (preloadedEvents) {\n                        // Iteration 2 after iteration 1 used preloaded events\n                        // (which don't carry a cursor). Do a full load now to\n                        // pick up any events written since the preloaded set\n                        // and obtain a cursor for subsequent incremental\n                        // loads. This is the expected path, not a bug.\n                        runtimeLogger.debug(\n                          'No cursor after preloaded-events first iteration; doing full reload to pick up cursor.',\n                          { workflowRunId: runId }\n                        );\n                        const loaded = await loadWorkflowRunEvents(runId);\n                        cachedEvents = loaded.events;\n                        eventsCursor = loaded.cursor;\n                        events = cachedEvents;\n                      } else {\n                        // No cursor available despite having cached events\n                        // and no preloaded-events explanation. All World\n                        // implementations are required to return a cursor\n                        // when there are events, so this signals a bug in\n                        // the World. Fall back to a full reload to avoid\n                        // stale data.\n                        runtimeLogger.warn(\n                          'Event cursor missing after initial load — falling back to full reload. ' +\n                            'This indicates a bug in the World implementation.',\n                          { workflowRunId: runId }\n                        );\n                        const loaded = await loadWorkflowRunEvents(runId);\n                        cachedEvents = loaded.events;\n                        eventsCursor = loaded.cursor;\n                        events = cachedEvents;\n                      }\n\n                      // Detect concurrent completion via the event log: if\n                      // any other handler wrote a terminal run event, exit\n                      // before doing replay work. The run entity's status is\n                      // derived from these events, so checking the log here\n                      // gives us the same signal as a runs.get() round-trip\n                      // without the extra request per loop iteration.\n                      // Terminal run events are always last by construction\n                      // (no event creation succeeds against a terminal run),\n                      // but scan the full array for defense-in-depth: a\n                      // World/backend ordering bug shouldn't make us miss\n                      // an actual termination signal.\n                      const terminalRunEvent = events.find(\n                        (e) =>\n                          e.eventType === 'run_completed' ||\n                          e.eventType === 'run_failed' ||\n                          e.eventType === 'run_cancelled'\n                      );\n                      if (terminalRunEvent) {\n                        runtimeLogger.debug(\n                          'Run completed by concurrent handler, exiting',\n                          {\n                            workflowRunId: runId,\n                            eventType: terminalRunEvent.eventType,\n                          }\n                        );\n                        return;\n                      }\n\n                      // Complete elapsed waits\n                      const now = Date.now();\n                      const completedWaitIds = new Set(\n                        events\n                          .filter((e) => e.eventType === 'wait_completed')\n                          .map((e) => e.correlationId)\n                      );\n                      const waitsToComplete = events\n                        .filter(\n                          (\n                            e\n                          ): e is Extract<\n                            Event,\n                            { eventType: 'wait_created' }\n                          > & { correlationId: string } =>\n                            e.eventType === 'wait_created' &&\n                            e.correlationId !== undefined &&\n                            !completedWaitIds.has(e.correlationId) &&\n                            now >= (e.eventData.resumeAt as Date).getTime()\n                        )\n                        .map((e) => ({\n                          eventType: 'wait_completed' as const,\n                          specVersion: SPEC_VERSION_CURRENT,\n                          correlationId: e.correlationId,\n                          eventData: {\n                            resumeAt: e.eventData.resumeAt,\n                          },\n                        }));\n\n                      for (const waitEvent of waitsToComplete) {\n                        try {\n                          await world.events.create(runId, waitEvent, {\n                            requestId,\n                          });\n                        } catch (err) {\n                          if (EntityConflictError.is(err)) {\n                            runtimeLogger.info(\n                              'Wait already completed, skipping',\n                              {\n                                workflowRunId: runId,\n                                correlationId: waitEvent.correlationId,\n                              }\n                            );\n                            continue;\n                          }\n                          throw err;\n                        }\n                      }\n\n                      if (waitsToComplete.length > 0) {\n                        // The event list above may be stale by the time an\n                        // elapsed wait is committed. Load only events after\n                        // the original snapshot cursor so concurrent durable\n                        // events, such as hook_received, keep their ordering\n                        // relative to wait_completed. Fall back to a full\n                        // reload for older worlds that cannot give us a stable\n                        // cursor, or if the cursor delta does not include the\n                        // wait completion this handler just attempted.\n                        if (eventsCursor) {\n                          const loaded = await loadWorkflowRunEvents(\n                            runId,\n                            eventsCursor\n                          );\n                          const completedWaitIdsAfterCursor = new Set(\n                            loaded.events\n                              .filter((e) => e.eventType === 'wait_completed')\n                              .map((e) => e.correlationId)\n                          );\n                          const sawAllWaitCompletions = waitsToComplete.every(\n                            (waitEvent) =>\n                              completedWaitIdsAfterCursor.has(\n                                waitEvent.correlationId\n                              )\n                          );\n\n                          if (sawAllWaitCompletions) {\n                            const existingIds = new Set(\n                              events.map((e) => e.eventId)\n                            );\n                            for (const event of loaded.events) {\n                              if (!existingIds.has(event.eventId)) {\n                                events.push(event);\n                              }\n                            }\n                            eventsCursor = loaded.cursor ?? eventsCursor;\n                          } else {\n                            const loaded = await loadWorkflowRunEvents(runId);\n                            events = loaded.events;\n                            eventsCursor = loaded.cursor;\n                          }\n                        } else {\n                          const loaded = await loadWorkflowRunEvents(runId);\n                          events = loaded.events;\n                          eventsCursor = loaded.cursor;\n                        }\n                      }\n\n                      // Update cache reference (may have been set for first time)\n                      cachedEvents = events;\n\n                      // Replay workflow\n                      runtimeLogger.debug('Starting workflow replay', {\n                        workflowRunId: runId,\n                        loopIteration,\n                        eventCount: events.length,\n                      });\n                      replayStart = Date.now();\n                      const result = await runWorkflow(\n                        workflowCode,\n                        workflowRun,\n                        events,\n                        encryptionKey\n                      );\n                      runtimeLogger.debug('Workflow replay completed', {\n                        workflowRunId: runId,\n                        loopIteration,\n                        replayMs: Date.now() - replayStart,\n                      });\n\n                      // Workflow completed\n                      try {\n                        await world.events.create(\n                          runId,\n                          {\n                            eventType: 'run_completed',\n                            specVersion: SPEC_VERSION_CURRENT,\n                            eventData: { output: result },\n                          },\n                          { requestId }\n                        );\n                      } catch (err) {\n                        if (\n                          EntityConflictError.is(err) ||\n                          RunExpiredError.is(err)\n                        ) {\n                          runtimeLogger.info(\n                            'Tried completing workflow run, but run has already finished.',\n                            { workflowRunId: runId, message: err.message }\n                          );\n                          return;\n                        }\n                        throw err;\n                      }\n\n                      span?.setAttributes({\n                        ...Attribute.WorkflowRunStatus('completed'),\n                      });\n                      return;\n                    } catch (err) {\n                      if (WorkflowSuspension.is(err)) {\n                        runtimeLogger.debug('Workflow suspended', {\n                          workflowRunId: runId,\n                          loopIteration,\n                          replayMs: Date.now() - replayStart,\n                          steps: err.stepCount,\n                          hooks: err.hookCount,\n                          waits: err.waitCount,\n                        });\n                        const suspensionMessage =\n                          buildWorkflowSuspensionMessage(\n                            err.stepCount,\n                            err.hookCount,\n                            err.waitCount\n                          );\n                        if (suspensionMessage) {\n                          runtimeLogger.debug(suspensionMessage);\n                        }\n\n                        // V2: handle suspension without queuing steps\n                        const suspensionStart = Date.now();\n                        const suspensionResult = await handleSuspension({\n                          suspension: err,\n                          world,\n                          run: workflowRun,\n                          span,\n                          requestId,\n                        });\n                        runtimeLogger.debug('Suspension handled', {\n                          workflowRunId: runId,\n                          suspensionMs: Date.now() - suspensionStart,\n                          pendingSteps: suspensionResult.pendingSteps.length,\n                          timeoutSeconds: suspensionResult.timeoutSeconds,\n                          hasHookConflict: suspensionResult.hasHookConflict,\n                        });\n\n                        // Hook conflict: break loop, re-invoke via queue\n                        if (suspensionResult.hasHookConflict) {\n                          return { timeoutSeconds: 0 };\n                        }\n\n                        const pendingSteps = suspensionResult.pendingSteps;\n\n                        if (pendingSteps.length === 0) {\n                          // No steps — only waits/hooks\n                          if (suspensionResult.timeoutSeconds !== undefined) {\n                            return {\n                              timeoutSeconds: suspensionResult.timeoutSeconds,\n                            };\n                          }\n                          return;\n                        }\n\n                        // Inline execution is gated on ownership: only the\n                        // handler that actually wrote the step_created event\n                        // may run the step body inline. The world-level\n                        // step_created is atomic per-correlationId, so\n                        // exactly one handler owns each step — concurrent\n                        // handlers can't race on step execution.\n                        const ownedPendingSteps = pendingSteps.filter((s) =>\n                          suspensionResult.createdStepCorrelationIds.has(\n                            s.correlationId\n                          )\n                        );\n\n                        // Pick one owned step to execute inline (if any).\n                        // The rest of the pending steps are queued below.\n                        //\n                        // Skip inline execution entirely when the suspension\n                        // also has a pending wait (sleep): an inline `await\n                        // executeStep(...)` blocks the handler for the full\n                        // step duration, so the wait timer never has a chance\n                        // to fire on time. That defeats `Promise.race(step,\n                        // sleep)` semantics — if the sleep is shorter than\n                        // the step, replay still picks the step because\n                        // wait_completed is only created on the *next* loop\n                        // iteration, which doesn't run until the step\n                        // finishes. Queueing every step in this case lets\n                        // the wait timeout drive a continuation in parallel,\n                        // matching V1's behavior where each step ran in a\n                        // separate function invocation.\n                        const inlineStep:\n                          | (typeof pendingSteps)[number]\n                          | undefined =\n                          suspensionResult.timeoutSeconds === undefined\n                            ? ownedPendingSteps[0]\n                            : undefined;\n\n                        // Queue every pending step except the one we're\n                        // executing inline. This mirrors V1's unconditional\n                        // enqueue-with-idempotency pattern and is what makes\n                        // crash recovery work: if a prior handler wrote\n                        // step_created events but crashed before enqueuing,\n                        // a later handler (e.g., from flow-message\n                        // redelivery or reenqueueActiveRuns) will enqueue\n                        // the orphaned steps. In the happy path with a\n                        // single owner, concurrent handlers' queue attempts\n                        // dedupe on correlationId. Skipping the inline step\n                        // avoids a queue handler racing against our own\n                        // inline executor.\n                        for (const step of pendingSteps) {\n                          if (\n                            inlineStep &&\n                            step.correlationId === inlineStep.correlationId\n                          ) {\n                            continue;\n                          }\n                          const traceCarrier = await serializeTraceCarrier();\n                          await queueMessage(\n                            world,\n                            getWorkflowQueueName(workflowName),\n                            {\n                              runId,\n                              stepId: step.correlationId,\n                              stepName: step.stepName,\n                              traceCarrier,\n                              requestedAt: new Date(),\n                            },\n                            {\n                              idempotencyKey: step.correlationId,\n                            }\n                          );\n                        }\n\n                        // Nothing to execute inline — we already queued all\n                        // pending steps above, exit and let the queue drive.\n                        if (!inlineStep) {\n                          if (suspensionResult.timeoutSeconds !== undefined) {\n                            return {\n                              timeoutSeconds: suspensionResult.timeoutSeconds,\n                            };\n                          }\n                          return;\n                        }\n\n                        // Execute inline step. Pause the replay budget\n                        // for the duration of the step body — step\n                        // duration is bounded by the platform's function\n                        // maxDuration, not by the replay timeout. Without\n                        // this the replay-budget check at the top of the\n                        // next loop iteration would (incorrectly) charge\n                        // the step body against the budget.\n                        replayBudget.pause();\n                        let stepResult: Awaited<ReturnType<typeof executeStep>>;\n                        try {\n                          stepResult = await executeStep({\n                            world,\n                            workflowRunId: runId,\n                            workflowName,\n                            workflowStartedAt,\n                            stepId: inlineStep.correlationId,\n                            stepName: inlineStep.stepName,\n                          });\n                        } finally {\n                          replayBudget.resume();\n                        }\n\n                        if (stepResult.type === 'retry') {\n                          // Step needs retry — queue self with stepId for retry\n                          const traceCarrier = await serializeTraceCarrier();\n                          await queueMessage(\n                            world,\n                            getWorkflowQueueName(workflowName),\n                            {\n                              runId,\n                              stepId: inlineStep.correlationId,\n                              stepName: inlineStep.stepName,\n                              traceCarrier,\n                              requestedAt: new Date(),\n                            },\n                            {\n                              delaySeconds: stepResult.timeoutSeconds,\n                            }\n                          );\n                          // If there are also waits, return their timeout\n                          if (suspensionResult.timeoutSeconds !== undefined) {\n                            return {\n                              timeoutSeconds: suspensionResult.timeoutSeconds,\n                            };\n                          }\n                          return;\n                        }\n\n                        if (stepResult.type === 'throttled') {\n                          return {\n                            timeoutSeconds: stepResult.timeoutSeconds,\n                          };\n                        }\n\n                        // Step completed or failed — loop back to replay\n                        // (gone/skipped also loop back since the workflow\n                        // will see the completed/failed event on replay)\n\n                        // If the step had pending background ops (e.g., stream\n                        // writes to S3), break the loop and return so waitUntil\n                        // can flush them. This matches V1 behavior where each\n                        // step ran in a separate function invocation. Without\n                        // this, the inline loop continues and the stream data\n                        // may not reach S3 before the test tries to read it.\n                        if (\n                          stepResult.type === 'completed' &&\n                          stepResult.hasPendingOps\n                        ) {\n                          runtimeLogger.debug(\n                            'Breaking loop: step has pending ops',\n                            {\n                              workflowRunId: runId,\n                              loopIteration,\n                              stepName: inlineStep.stepName,\n                            }\n                          );\n                          await queueMessage(\n                            world,\n                            getWorkflowQueueName(workflowName),\n                            {\n                              runId,\n                              traceCarrier: await serializeTraceCarrier(),\n                              requestedAt: new Date(),\n                            }\n                          );\n                          return;\n                        }\n\n                        if (\n                          suspensionResult.timeoutSeconds !== undefined &&\n                          pendingSteps.length === 1\n                        ) {\n                          // Only 1 step and there's also waits/hooks,\n                          // step is done, but we need the wait timeout\n                          // Loop back to replay which will re-evaluate\n                        }\n                      } else {\n                        // User code error from runWorkflow — create run_failed.\n                        if (err instanceof Error) {\n                          span?.recordException?.(err);\n                        }\n\n                        const normalizedError =\n                          await normalizeUnknownError(err);\n                        const errorName =\n                          normalizedError.name || getErrorName(err);\n                        const errorMessage = normalizedError.message;\n                        let errorStack =\n                          normalizedError.stack || getErrorStack(err);\n\n                        if (errorStack) {\n                          const parsedName = parseWorkflowName(workflowName);\n                          const filename =\n                            parsedName?.moduleSpecifier || workflowName;\n                          errorStack = remapErrorStack(\n                            errorStack,\n                            filename,\n                            workflowCode\n                          );\n                        }\n\n                        // Classify the error: WorkflowRuntimeError indicates\n                        // an SDK/runtime issue, and selected subclasses use\n                        // more specific codes for backend tracking.\n                        const errorCode = classifyRunError(err);\n\n                        runtimeLogger.error('Error while running workflow', {\n                          workflowRunId: runId,\n                          errorCode,\n                          errorName,\n                          errorStack,\n                        });\n\n                        // Apply the source-map-remapped stack to the thrown\n                        // value so that the serialized error preserves it\n                        // for consumers. `types.isNativeError()` is used\n                        // instead of `err instanceof Error` because the\n                        // workflow runs in a separate VM realm — its Error\n                        // class is distinct from the host's, so `instanceof\n                        // Error` is `false` for VM-thrown errors. The V8\n                        // type tag works across realms.\n                        if (types.isNativeError(err) && errorStack) {\n                          (err as Error).stack = errorStack;\n                        }\n\n                        // Fail the workflow run via event (event-sourced).\n                        // Serialize the original thrown value so its full\n                        // type identity and custom properties round-trip\n                        // through the event log.\n                        try {\n                          await world.events.create(\n                            runId,\n                            {\n                              eventType: 'run_failed',\n                              specVersion: SPEC_VERSION_CURRENT,\n                              eventData: {\n                                error: await dehydrateRunError(\n                                  err,\n                                  runId,\n                                  encryptionKey\n                                ),\n                                errorCode,\n                              },\n                            },\n                            { requestId }\n                          );\n                        } catch (failErr) {\n                          if (\n                            EntityConflictError.is(failErr) ||\n                            RunExpiredError.is(failErr)\n                          ) {\n                            runtimeLogger.info(\n                              'Tried failing workflow run, but run has already finished.',\n                              {\n                                workflowRunId: runId,\n                                message: failErr.message,\n                              }\n                            );\n                            return;\n                          }\n                          if (isWorldContractError(failErr)) {\n                            runtimeLogger.error(\n                              'Fatal world contract error while recording workflow failure',\n                              {\n                                workflowRunId: runId,\n                                errorCode: RUN_ERROR_CODES.WORLD_CONTRACT_ERROR,\n                                error:\n                                  failErr instanceof Error\n                                    ? failErr.message\n                                    : String(failErr),\n                              }\n                            );\n                            return;\n                          }\n                          throw failErr;\n                        }\n\n                        span?.setAttributes({\n                          ...Attribute.WorkflowRunStatus('failed'),\n                          ...Attribute.WorkflowErrorCode(errorCode),\n                          ...Attribute.WorkflowErrorName(errorName),\n                          ...Attribute.WorkflowErrorMessage(errorMessage),\n                          ...Attribute.ErrorType(errorName),\n                        });\n                        return;\n                      }\n                    }\n                  } // End while loop\n                }\n              ); // End trace\n            }\n          ); // End withWorkflowBaggage\n        }); // End withTraceContext\n      }\n    );\n\n  let cachedHandler: ((req: Request) => Promise<Response>) | undefined;\n  return withHealthCheck(async (req) => {\n    if (!cachedHandler) {\n      cachedHandler = handler(await getWorldHandlers());\n    }\n    return cachedHandler(req);\n  });\n}\n"]}