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

package/dist/runtime.js

@@ -1,17 +1,20 @@
-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 { describeError } from './describe-error.js';
 import { WorkflowSuspension } from './global.js';
 import { runtimeLogger } from './logger.js';
 import { MAX_QUEUE_DELIVERIES, REPLAY_TIMEOUT_MAX_RETRIES, REPLAY_TIMEOUT_MS, } from './runtime/constants.js';
-import { getAllWorkflowRunEvents, getQueueOverhead, handleHealthCheckMessage, parseHealthCheckPayload, withHealthCheck, } from './runtime/helpers.js';
+import { getQueueOverhead, getWorkflowQueueName, handleHealthCheckMessage, loadWorkflowRunEvents, memoizeEncryptionKey, parseHealthCheckPayload, queueMessage, withHealthCheck, } from './runtime/helpers.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 +24,24 @@ 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 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.
  *
- * @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.
+ * 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 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 +52,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,14 +86,15 @@ 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;
@@ -93,32 +107,46 @@ export function workflowEntrypoint(workflowCode) {
         let replayTimeout;
         if (process.env.VERCEL_URL !== undefined) {
             replayTimeout = setTimeout(async () => {
-                runtimeLogger.error('Workflow replay exceeded timeout', {
-                    workflowRunId: runId,
-                    timeoutMs: REPLAY_TIMEOUT_MS,
-                    attempt: metadata.attempt,
-                    maxRetries: REPLAY_TIMEOUT_MAX_RETRIES,
-                });
                 // Allow a few retries before permanently failing the run.
                 // On early attempts, just exit so the queue retries the message.
                 if (metadata.attempt <= REPLAY_TIMEOUT_MAX_RETRIES) {
+                    runLogger.warn('Workflow replay exceeded timeout but will be re-attempted (attempt < maxRetries)', {
+                        timeoutMs: REPLAY_TIMEOUT_MS,
+                        attempt: metadata.attempt,
+                        maxRetries: REPLAY_TIMEOUT_MAX_RETRIES,
+                    });
                     process.exit(1);
                 }
+                const replayTimeoutDescription = describeError(undefined, RUN_ERROR_CODES.REPLAY_TIMEOUT);
+                runLogger.error('Workflow replay exceeded timeout and max retries exceeded. Failing the run', {
+                    timeoutMs: REPLAY_TIMEOUT_MS,
+                    attempt: metadata.attempt,
+                    maxRetries: REPLAY_TIMEOUT_MAX_RETRIES,
+                    errorCode: replayTimeoutDescription.errorCode,
+                    errorAttribution: replayTimeoutDescription.attribution,
+                });
                 try {
                     const world = await getWorld();
+                    const getEncryptionKey = memoizeEncryptionKey(world, runId);
+                    const timeoutErr = new FatalError(`Workflow replay exceeded maximum duration (${REPLAY_TIMEOUT_MS / 1000}s) after ${metadata.attempt} attempts`);
                     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) after ${metadata.attempt} attempts`,
-                            },
+                            error: await dehydrateRunError(timeoutErr, runId, await getEncryptionKey()),
                             errorCode: RUN_ERROR_CODES.REPLAY_TIMEOUT,
                         },
                     }, { requestId });
                 }
-                catch {
-                    // Best effort — process exits regardless
+                catch (err) {
+                    // Best effort — process exits regardless. Surface why so
+                    // operators can diagnose repeat timeouts against the backend.
+                    runLogger.warn('Unable to mark run as failed. The queue will continue to retry', {
+                        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,
+                    });
                 }
                 // Note that this also prevents the runtime from acking the queue message,
                 // so the queue will call back once, after which a 410 will get it to exit early.
@@ -126,262 +154,634 @@ export function workflowEntrypoint(workflowCode) {
             }, REPLAY_TIMEOUT_MS);
             replayTimeout.unref();
         }
-        // Invoke user workflow within the propagated trace context and baggage
         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}"`);
+                    // 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) {
+                        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;
                         }
-                        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;
+                        const bgStartedAt = bgRun.startedAt
+                            ? +bgRun.startedAt
+                            : Date.now();
+                        const stepResult = await executeStep({
+                            world,
+                            workflowRunId: runId,
+                            workflowName,
+                            workflowStartedAt: bgStartedAt,
+                            stepId: incomingStepId,
+                            stepName: incomingStepName,
+                        });
+                        if (stepResult.type === 'retry') {
+                            return { timeoutSeconds: stepResult.timeoutSeconds };
                         }
-                        if (!workflowRun.startedAt) {
-                            throw new WorkflowRuntimeError(`Workflow run "${runId}" has no "startedAt" timestamp`);
+                        if (stepResult.type === 'throttled') {
+                            return { timeoutSeconds: stepResult.timeoutSeconds };
                         }
-                    }
-                    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 });
+                        // 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;
                         }
-                        else if (err instanceof WorkflowRuntimeError) {
-                            runtimeLogger.error('Fatal runtime error during workflow setup', { workflowRunId: runId, error: err.message });
-                            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 });
+                        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);
+                                }
                             }
-                            catch (failErr) {
-                                if (EntityConflictError.is(failErr) ||
-                                    RunExpiredError.is(failErr)) {
-                                    return;
+                            let hasPendingSteps = false;
+                            for (const id of stepCreatedIds) {
+                                if (!stepTerminalIds.has(id)) {
+                                    hasPendingSteps = true;
+                                    break;
                                 }
-                                throw failErr;
                             }
-                            return;
+                            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;
+                            }
+                            // 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 {
-                            throw err;
+                            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) {
+                                preloadedEvents = result.events;
+                            }
+                            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,
-                                });
-                                continue;
+                            // 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 });
+                                try {
+                                    const getEncryptionKey = memoizeEncryptionKey(world, runId);
+                                    await world.events.create(runId, {
+                                        eventType: 'run_failed',
+                                        specVersion: SPEC_VERSION_CURRENT,
+                                        eventData: {
+                                            error: await dehydrateRunError(err, runId, await getEncryptionKey()),
+                                            errorCode: RUN_ERROR_CODES.RUNTIME_ERROR,
+                                        },
+                                    }, { requestId });
+                                }
+                                catch (failErr) {
+                                    if (EntityConflictError.is(failErr) ||
+                                        RunExpiredError.is(failErr)) {
+                                        return;
+                                    }
+                                    throw failErr;
+                                }
+                                return;
+                            }
+                            else {
+                                throw err;
                             }
-                            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);
-                        }
-                        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);
+                    } // 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++;
+                        // 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;
+                                    // No cursor from preloaded events — next iteration
+                                    // will fall through to the full reload path below.
+                                }
+                                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
+                                // pushed events manually (see the wait_completed
+                                // write loop below) without advancing the 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,
-                                eventData: {
-                                    error: {
-                                        message: errorMessage,
-                                        stack: errorStack,
-                                    },
-                                    errorCode,
-                                },
-                            }, { requestId });
+                                correlationId: e.correlationId,
+                            }));
+                            for (const waitEvent of waitsToComplete) {
+                                try {
+                                    const result = await world.events.create(runId, waitEvent, { requestId });
+                                    events.push(result.event);
+                                }
+                                catch (err) {
+                                    if (EntityConflictError.is(err)) {
+                                        runtimeLogger.info('Wait already completed, skipping', {
+                                            workflowRunId: runId,
+                                            correlationId: waitEvent.correlationId,
+                                        });
+                                        continue;
+                                    }
+                                    throw err;
+                                }
+                            }
+                            // 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,
+                                    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
+                                const stepResult = await executeStep({
+                                    world,
                                     workflowRunId: runId,
-                                    message: failErr.message,
+                                    workflowName,
+                                    workflowStartedAt,
+                                    stepId: inlineStep.correlationId,
+                                    stepName: inlineStep.stepName,
                                 });
+                                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
+                                // 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,
+                                });
+                                // 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;
+                                    }
+                                    throw failErr;
+                                }
                                 span?.setAttributes({
+                                    ...Attribute.WorkflowRunStatus('failed'),
                                     ...Attribute.WorkflowErrorCode(errorCode),
                                     ...Attribute.WorkflowErrorName(errorName),
                                     ...Attribute.WorkflowErrorMessage(errorMessage),
@@ -389,48 +789,8 @@ 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(() => {
@@ -447,7 +807,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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","sourcesContent":["import {\n  EntityConflictError,\n  RUN_ERROR_CODES,\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} from '@workflow/world';\nimport { classifyRunError } from './classify-error.js';\nimport { importKey } from './encryption.js';\nimport { WorkflowSuspension } from './global.js';\nimport { runtimeLogger } from './logger.js';\nimport {\n  MAX_QUEUE_DELIVERIES,\n  REPLAY_TIMEOUT_MAX_RETRIES,\n  REPLAY_TIMEOUT_MS,\n} from './runtime/constants.js';\nimport {\n  getAllWorkflowRunEvents,\n  getQueueOverhead,\n  handleHealthCheckMessage,\n  parseHealthCheckPayload,\n  withHealthCheck,\n} from './runtime/helpers.js';\nimport { handleSuspension } from './runtime/suspension-handler.js';\nimport {\n  getWorld,\n  getWorldHandlers,\n  type WorldHandlers,\n} from './runtime/world.js';\nimport { remapErrorStack } from './source-map.js';\nimport * as Attribute from './telemetry/semantic-conventions.js';\nimport {\n  linkToCurrentContext,\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';\nexport { stepEntrypoint } from './runtime/step-handler.js';\nexport {\n  createWorld,\n  getWorld,\n  getWorldHandlers,\n  setWorld,\n} from './runtime/world.js';\n\n/**\n * Function that creates a single route which handles any workflow execution\n * request and routes to the appropriate workflow function.\n *\n * @param workflowCode - The workflow bundle code containing all the workflow\n * functions at the top level.\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 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          runInput,\n        } = WorkflowInvokePayloadSchema.parse(message_);\n        const { requestId } = metadata;\n        // Extract the workflow name from the topic name\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        // At this point, we want to do the minimal amount of work (no fetching\n        // of the workflow events, etc. We simply attempt to mark the run as failed\n        // and if that fails, the message is still consumed but with adequate logging\n        // that an error occurred preventing us from failing the run.\n        if (metadata.attempt > MAX_QUEUE_DELIVERIES) {\n          runtimeLogger.error(\n            `Workflow handler exceeded max deliveries (${metadata.attempt}/${MAX_QUEUE_DELIVERIES})`,\n            { workflowRunId: runId, workflowName, attempt: metadata.attempt }\n          );\n          try {\n            const world = await getWorld();\n            await world.events.create(\n              runId,\n              {\n                eventType: 'run_failed',\n                specVersion: SPEC_VERSION_CURRENT,\n                eventData: {\n                  error: {\n                    message: `Workflow exceeded maximum queue deliveries (${metadata.attempt}/${MAX_QUEUE_DELIVERIES})`,\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            runtimeLogger.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                workflowRunId: runId,\n                error: err instanceof Error ? err.message : String(err),\n                attempt: metadata.attempt,\n              }\n            );\n          }\n          return;\n        }\n\n        const spanLinks = await linkToCurrentContext();\n\n        // --- Replay timeout guard ---\n        // If the replay takes longer than the timeout, fail the run and exit.\n        // This must be lower than the function's maxDuration to ensure\n        // the failure is recorded before the platform kills the function.\n        let replayTimeout: NodeJS.Timeout | undefined;\n        if (process.env.VERCEL_URL !== undefined) {\n          replayTimeout = setTimeout(async () => {\n            runtimeLogger.error('Workflow replay exceeded timeout', {\n              workflowRunId: runId,\n              timeoutMs: REPLAY_TIMEOUT_MS,\n              attempt: metadata.attempt,\n              maxRetries: REPLAY_TIMEOUT_MAX_RETRIES,\n            });\n\n            // Allow a few retries before permanently failing the run.\n            // On early attempts, just exit so the queue retries the message.\n            if (metadata.attempt <= REPLAY_TIMEOUT_MAX_RETRIES) {\n              process.exit(1);\n            }\n\n            try {\n              const world = await getWorld();\n              await world.events.create(\n                runId,\n                {\n                  eventType: 'run_failed',\n                  specVersion: SPEC_VERSION_CURRENT,\n                  eventData: {\n                    error: {\n                      message: `Workflow replay exceeded maximum duration (${REPLAY_TIMEOUT_MS / 1000}s) after ${metadata.attempt} attempts`,\n                    },\n                    errorCode: RUN_ERROR_CODES.REPLAY_TIMEOUT,\n                  },\n                },\n                { requestId }\n              );\n            } catch {\n              // Best effort — process exits regardless\n            }\n            // Note that this also prevents the runtime from acking the queue message,\n            // so the queue will call back once, after which a 410 will get it to exit early.\n            process.exit(1);\n          }, REPLAY_TIMEOUT_MS);\n          replayTimeout.unref();\n        }\n\n        // Invoke user workflow within the propagated trace context and baggage\n        return await withTraceContext(traceContext, async () => {\n          // Set workflow context as baggage for automatic propagation\n          return await withWorkflowBaggage(\n            { workflowRunId: runId, workflowName },\n            async () => {\n              const world = await getWorld();\n              return trace(\n                `WORKFLOW ${workflowName}`,\n                { links: spanLinks },\n                async (span) => {\n                  span?.setAttributes({\n                    ...Attribute.WorkflowName(workflowName),\n                    ...Attribute.WorkflowOperation('execute'),\n                    // Standard OTEL messaging conventions\n                    ...Attribute.MessagingSystem('vercel-queue'),\n                    ...Attribute.MessagingDestinationName(metadata.queueName),\n                    ...Attribute.MessagingMessageId(metadata.messageId),\n                    ...Attribute.MessagingOperationType('process'),\n                    ...getQueueOverhead({ requestedAt }),\n                  });\n\n                  // TODO: validate `workflowName` exists before consuming message?\n\n                  span?.setAttributes({\n                    ...Attribute.WorkflowRunId(runId),\n                    ...Attribute.WorkflowTracePropagated(!!traceContext),\n                  });\n\n                  let workflowStartedAt = -1;\n                  let workflowRun: WorkflowRun | undefined;\n                  // Pre-loaded events from the run_started response.\n                  // When present, we skip the events.list call to reduce TTFB.\n                  let preloadedEvents: Event[] | undefined;\n\n                  // --- Infrastructure: prepare the run state ---\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                  // Network/server errors propagate to the queue handler for retry.\n                  // WorkflowRuntimeError (data integrity issues) are fatal and\n                  // produce run_failed since retrying won't fix them.\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 (result.events && result.events.length > 0) {\n                      preloadedEvents = result.events;\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 if (err instanceof WorkflowRuntimeError) {\n                      runtimeLogger.error(\n                        'Fatal runtime error during workflow setup',\n                        { workflowRunId: runId, error: err.message }\n                      );\n                      try {\n                        await world.events.create(\n                          runId,\n                          {\n                            eventType: 'run_failed',\n                            specVersion: SPEC_VERSION_CURRENT,\n                            eventData: {\n                              error: {\n                                message: err.message,\n                                stack: err.stack,\n                              },\n                              errorCode: RUN_ERROR_CODES.RUNTIME_ERROR,\n                            },\n                          },\n                          { requestId }\n                        );\n                      } catch (failErr) {\n                        if (\n                          EntityConflictError.is(failErr) ||\n                          RunExpiredError.is(failErr)\n                        ) {\n                          return;\n                        }\n                        throw failErr;\n                      }\n                      return;\n                    } else {\n                      throw err;\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\n                  // Load all events into memory before running.\n                  // If we got pre-loaded events from the run_started response,\n                  // skip the events.list round-trip to reduce TTFB.\n                  const events =\n                    preloadedEvents ??\n                    (await getAllWorkflowRunEvents(workflowRun.runId));\n\n                  // Check for any elapsed waits and create wait_completed events\n                  const now = Date.now();\n\n                  // Pre-compute completed correlation IDs for O(n) lookup instead of O(n²)\n                  const completedWaitIds = new Set(\n                    events\n                      .filter((e) => e.eventType === 'wait_completed')\n                      .map((e) => e.correlationId)\n                  );\n\n                  // Collect all waits that need completion\n                  const waitsToComplete = events\n                    .filter(\n                      (e): e is typeof e & { 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                    }));\n\n                  // Create all wait_completed events\n                  for (const waitEvent of waitsToComplete) {\n                    try {\n                      const result = await world.events.create(\n                        runId,\n                        waitEvent,\n                        {\n                          requestId,\n                        }\n                      );\n                      // Add the event to the events array so the workflow can see it\n                      events.push(result.event!);\n                    } catch (err) {\n                      if (EntityConflictError.is(err)) {\n                        runtimeLogger.info('Wait already completed, skipping', {\n                          workflowRunId: runId,\n                          correlationId: waitEvent.correlationId,\n                        });\n                        continue;\n                      }\n                      throw err;\n                    }\n                  }\n\n                  // Resolve the encryption key for this run's deployment\n                  const rawKey =\n                    await world.getEncryptionKeyForRun?.(workflowRun);\n                  const encryptionKey = rawKey\n                    ? await importKey(rawKey)\n                    : undefined;\n\n                  // --- User code execution ---\n                  // Only errors from runWorkflow() (user workflow code) should\n                  // produce run_failed. Infrastructure errors (network, server)\n                  // must propagate to the queue handler for automatic retry.\n                  let workflowResult: unknown;\n                  try {\n                    workflowResult = await trace(\n                      'workflow.replay',\n                      {},\n                      async (replaySpan) => {\n                        replaySpan?.setAttributes({\n                          ...Attribute.WorkflowEventsCount(events.length),\n                        });\n                        return await runWorkflow(\n                          workflowCode,\n                          workflowRun,\n                          events,\n                          encryptionKey\n                        );\n                      }\n                    );\n                  } catch (err) {\n                    // WorkflowSuspension is normal control flow — not an error\n                    if (WorkflowSuspension.is(err)) {\n                      const suspensionMessage = buildWorkflowSuspensionMessage(\n                        runId,\n                        err.stepCount,\n                        err.hookCount,\n                        err.waitCount\n                      );\n                      if (suspensionMessage) {\n                        runtimeLogger.debug(suspensionMessage);\n                      }\n\n                      const result = await handleSuspension({\n                        suspension: err,\n                        world,\n                        run: workflowRun,\n                        span,\n                        requestId,\n                      });\n\n                      if (result.timeoutSeconds !== undefined) {\n                        return { timeoutSeconds: result.timeoutSeconds };\n                      }\n\n                      // Suspension handled, no further work needed\n                      return;\n                    }\n\n                    // This is a user code error or a WorkflowRuntimeError\n                    // (e.g., corrupted event log). Fail the workflow run.\n\n                    // Record exception for OTEL error tracking\n                    if (err instanceof Error) {\n                      span?.recordException?.(err);\n                    }\n\n                    const normalizedError = await normalizeUnknownError(err);\n                    const errorName = normalizedError.name || getErrorName(err);\n                    const errorMessage = normalizedError.message;\n                    let errorStack =\n                      normalizedError.stack || getErrorStack(err);\n\n                    // Remap error stack using source maps to show original source locations\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 an\n                    // internal issue (corrupted event log, missing data);\n                    // everything else is a user code error.\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                    // Fail the workflow run via event (event-sourced architecture)\n                    try {\n                      await world.events.create(\n                        runId,\n                        {\n                          eventType: 'run_failed',\n                          specVersion: SPEC_VERSION_CURRENT,\n                          eventData: {\n                            error: {\n                              message: errorMessage,\n                              stack: errorStack,\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                        span?.setAttributes({\n                          ...Attribute.WorkflowErrorCode(errorCode),\n                          ...Attribute.WorkflowErrorName(errorName),\n                          ...Attribute.WorkflowErrorMessage(errorMessage),\n                          ...Attribute.ErrorType(errorName),\n                        });\n                        return;\n                      } else {\n                        throw failErr;\n                      }\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                  // --- Infrastructure: complete the run ---\n                  // This is outside the user-code try/catch so that failures\n                  // here (e.g., network errors) propagate to the queue handler.\n                  try {\n                    await world.events.create(\n                      runId,\n                      {\n                        eventType: 'run_completed',\n                        specVersion: SPEC_VERSION_CURRENT,\n                        eventData: {\n                          output: workflowResult,\n                        },\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                        {\n                          workflowRunId: runId,\n                          message: err.message,\n                        }\n                      );\n                      return;\n                    } else {\n                      throw err;\n                    }\n                  }\n\n                  span?.setAttributes({\n                    ...Attribute.WorkflowRunStatus('completed'),\n                    ...Attribute.WorkflowEventsCount(events.length),\n                  });\n                }\n              ); // End trace\n            }\n          ); // End withWorkflowBaggage\n        }).finally(() => {\n          if (replayTimeout) {\n            clearTimeout(replayTimeout);\n          }\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\n// this is a no-op placeholder as the client is\n// expecting this to be present but we aren't actually using it\nexport function runStep() {}\n"]}
+//# 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  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} from '@workflow/world';\nimport { classifyRunError } from './classify-error.js';\nimport { describeError } from './describe-error.js';\nimport { WorkflowSuspension } from './global.js';\nimport { runtimeLogger } from './logger.js';\nimport {\n  MAX_QUEUE_DELIVERIES,\n  REPLAY_TIMEOUT_MAX_RETRIES,\n  REPLAY_TIMEOUT_MS,\n} 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 { 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\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 timeout guard ---\n        // If the replay takes longer than the timeout, fail the run and exit.\n        // This must be lower than the function's maxDuration to ensure\n        // the failure is recorded before the platform kills the function.\n        let replayTimeout: NodeJS.Timeout | undefined;\n        if (process.env.VERCEL_URL !== undefined) {\n          replayTimeout = setTimeout(async () => {\n            // Allow a few retries before permanently failing the run.\n            // On early attempts, just exit so the queue retries the message.\n            if (metadata.attempt <= REPLAY_TIMEOUT_MAX_RETRIES) {\n              runLogger.warn(\n                'Workflow replay exceeded timeout but will be re-attempted (attempt < maxRetries)',\n                {\n                  timeoutMs: REPLAY_TIMEOUT_MS,\n                  attempt: metadata.attempt,\n                  maxRetries: REPLAY_TIMEOUT_MAX_RETRIES,\n                }\n              );\n              process.exit(1);\n            }\n\n            const replayTimeoutDescription = describeError(\n              undefined,\n              RUN_ERROR_CODES.REPLAY_TIMEOUT\n            );\n            runLogger.error(\n              'Workflow replay exceeded timeout and max retries exceeded. Failing the run',\n              {\n                timeoutMs: REPLAY_TIMEOUT_MS,\n                attempt: metadata.attempt,\n                maxRetries: REPLAY_TIMEOUT_MAX_RETRIES,\n                errorCode: replayTimeoutDescription.errorCode,\n                errorAttribution: replayTimeoutDescription.attribution,\n              }\n            );\n\n            try {\n              const world = await getWorld();\n              const getEncryptionKey = memoizeEncryptionKey(world, runId);\n              const timeoutErr = new FatalError(\n                `Workflow replay exceeded maximum duration (${REPLAY_TIMEOUT_MS / 1000}s) after ${metadata.attempt} attempts`\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                      timeoutErr,\n                      runId,\n                      await getEncryptionKey()\n                    ),\n                    errorCode: RUN_ERROR_CODES.REPLAY_TIMEOUT,\n                  },\n                },\n                { requestId }\n              );\n            } catch (err) {\n              // Best effort — process exits regardless. Surface why so\n              // operators can diagnose repeat timeouts against the backend.\n              runLogger.warn(\n                'Unable to mark run as failed. The queue will continue to retry',\n                {\n                  attempt: metadata.attempt,\n                  errorName: err instanceof Error ? err.name : 'UnknownError',\n                  errorMessage:\n                    err instanceof Error ? err.message : String(err),\n                  errorStack: err instanceof Error ? err.stack : undefined,\n                }\n              );\n            }\n            // Note that this also prevents the runtime from acking the queue message,\n            // so the queue will call back once, after which a 410 will get it to exit early.\n            process.exit(1);\n          }, REPLAY_TIMEOUT_MS);\n          replayTimeout.unref();\n        }\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\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                    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                    const stepResult = await executeStep({\n                      world,\n                      workflowRunId: runId,\n                      workflowName,\n                      workflowStartedAt: bgStartedAt,\n                      stepId: incomingStepId,\n                      stepName: incomingStepName,\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                  }\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 (result.events && result.events.length > 0) {\n                        preloadedEvents = result.events;\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 if (err instanceof WorkflowRuntimeError) {\n                        runtimeLogger.error(\n                          'Fatal runtime error during workflow setup',\n                          { workflowRunId: runId, error: err.message }\n                        );\n                        try {\n                          const getEncryptionKey = memoizeEncryptionKey(\n                            world,\n                            runId\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.RUNTIME_ERROR,\n                              },\n                            },\n                            { requestId }\n                          );\n                        } catch (failErr) {\n                          if (\n                            EntityConflictError.is(failErr) ||\n                            RunExpiredError.is(failErr)\n                          ) {\n                            return;\n                          }\n                          throw failErr;\n                        }\n                        return;\n                      } else {\n                        throw err;\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                    // 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                          // No cursor from preloaded events — next iteration\n                          // will fall through to the full reload path below.\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                        // pushed events manually (see the wait_completed\n                        // write loop below) without advancing the cursor,\n                        // so an incremental fetch can return events we\n                        // already have 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                          (e): e is typeof e & { 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                        }));\n\n                      for (const waitEvent of waitsToComplete) {\n                        try {\n                          const result = await world.events.create(\n                            runId,\n                            waitEvent,\n                            { requestId }\n                          );\n                          events.push(result.event!);\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                      // 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\n                        const stepResult = await executeStep({\n                          world,\n                          workflowRunId: runId,\n                          workflowName,\n                          workflowStartedAt,\n                          stepId: inlineStep.correlationId,\n                          stepName: inlineStep.stepName,\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 an\n                        // internal issue (corrupted event log, missing data);\n                        // everything else is a user code error.\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                          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        }).finally(() => {\n          if (replayTimeout) {\n            clearTimeout(replayTimeout);\n          }\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"]}