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

package/dist/workflow.js

@@ -1,51 +1,56 @@
-import { runInContext } from 'node:vm';
-import { ERROR_SLUGS, WorkflowNotRegisteredError, WorkflowRuntimeError, } from '@workflow/errors';
-import { withResolvers } from '@workflow/utils';
-import { getPortLazy } from './runtime/get-port-lazy.js';
+import { ERROR_SLUGS, ReplayDivergenceError, WorkflowNotRegisteredError, WorkflowRuntimeError, } from '@workflow/errors';
+import { createWorkflowBaseUrl, withResolvers, } from '@workflow/utils';
 import { parseWorkflowName } from '@workflow/utils/parse-name';
+import { SPEC_VERSION_SUPPORTS_COMPRESSION } from '@workflow/world/spec-version';
 import * as nanoid from 'nanoid';
 import { monotonicFactory } from 'ulid';
 import { EventConsumerResult, EventsConsumer } from './events-consumer.js';
 import { ENOTSUP, WorkflowSuspension } from './global.js';
 import { runtimeLogger } from './logger.js';
+import { isDeliveryIdle } from './private.js';
+import { describeDivergenceContext } from './replay-divergence.js';
+import { ReplayPayloadCache } from './replay-payload-cache.js';
+import { getPortLazy } from './runtime/get-port-lazy.js';
+import { runIdCreatedAt } from './runtime/run-id-time.js';
 import { handleSuspension } from './runtime/suspension-handler.js';
 import { getWorld } from './runtime/world.js';
 import { dehydrateWorkflowReturnValue, hydrateWorkflowArguments, } from './serialization.js';
 import { createUseStep } from './step.js';
-import { BODY_INIT_SYMBOL, STABLE_ULID, WORKFLOW_CREATE_HOOK, WORKFLOW_GET_STREAM_ID, WORKFLOW_SLEEP, WORKFLOW_USE_STEP, } from './symbols.js';
+import { BODY_INIT_SYMBOL, STABLE_ULID, WORKFLOW_CREATE_HOOK, WORKFLOW_GET_STREAM_ID, WORKFLOW_SET_ATTRIBUTES, WORKFLOW_SLEEP, WORKFLOW_USE_STEP, } from './symbols.js';
 import * as Attribute from './telemetry/semantic-conventions.js';
-import { trace } from './telemetry.js';
+import { applyWorkflowSuspensionToSpan, createRefreshableTraceContext, startTraceSpan, trace, } from './telemetry.js';
 import { getWorkflowRunStreamId } from './util.js';
 import { createContext } from './vm/index.js';
-import { WORKFLOW_CONTEXT_SYMBOL } from './workflow/get-workflow-metadata.js';
+import { getCachedWorkflowScript } from './vm/script-cache.js';
 import { createAbortSignalStatics, createCreateAbortController, } from './workflow/abort-controller.js';
+import { createSetAttributes } from './workflow/attribute-dispatcher.js';
+import { WORKFLOW_CONTEXT_SYMBOL } from './workflow/get-workflow-metadata.js';
 import { createCreateHook } from './workflow/hook.js';
 import { createSleep } from './workflow/sleep.js';
 /**
  * Drain pending queue items at workflow completion (success or failure).
  *
- * Treats end-of-run like a final suspension: any operation the workflow code
- * spawned but didn't `await` — abort hook resumes, hook creations/disposals,
- * sleep waits, step queueings — gets committed to the event log via the
- * suspension handler before the run is marked terminal.
+ * Treats completion as a final suspension so unawaited hook, wait, and
+ * attribute operations are recorded before the run becomes terminal. This
+ * also lets a final `controller.abort()` reach in-flight steps.
  *
- * This matches normal JS semantics where `setTimeout(fn, ...)` etc. continue
- * running after the surrounding function returns. Most importantly, it ensures
- * `controller.abort()` called as the last statement of a workflow actually
- * propagates to in-flight steps on other compute instances — without this,
- * the abort hook is created but never resumed and the cancellation never
- * reaches the running step.
+ * It records `*_created` and native attribute events, but never executes step
+ * bodies: `step_started` is rejected after the run becomes terminal. A
+ * fire-and-forget step therefore needs a later suspension to be scheduled.
  *
- * Drain failures are swallowed: the workflow's own outcome (the user's return
- * value or thrown error) is the source of truth; secondary cleanup that fails
- * shouldn't change the run's terminal state.
+ * Drain failures do not change the workflow's terminal outcome.
+ */
+async function drainPendingQueueItems(runId, pendingQueue, vmGlobalThis, workflowRun, outcome, 
+/**
+ * In turbo mode, gates final `*_created` writes on backgrounded
+ * `run_started`. Undefined when `run_started` is awaited.
  */
-async function drainPendingQueueItems(runId, pendingQueue, vmGlobalThis, workflowRun, outcome) {
+runReadyBarrier) {
     if (pendingQueue.size === 0)
         return;
     // Implicitly dispose any abort hooks (system hooks) that are still alive at
     // workflow completion so they don't leak rows in the hooks table for the
-    // run's lifetime. Skip hooks that already have an abort in flight — those
+    // run's lifetime. Skip hooks that already have an abort in flight; those
     // will emit hook_received via the abort processing path. User hooks
     // (isSystem !== true) are intentionally left alone: their lifetime is
     // managed by the user's code, not the runtime.
@@ -64,6 +69,7 @@ async function drainPendingQueueItems(runId, pendingQueue, vmGlobalThis, workflo
             suspension: synthesized,
             world,
             run: workflowRun,
+            runReadyBarrier,
         });
     }
     catch (err) {
@@ -73,221 +79,451 @@ async function drainPendingQueueItems(runId, pendingQueue, vmGlobalThis, workflo
         });
     }
 }
-export async function runWorkflow(workflowCode, workflowRun, events, encryptionKey) {
-    return trace(`workflow.run ${workflowRun.workflowName}`, async (span) => {
+/**
+ * Compile the workflow bundle before its run snapshot is available.
+ *
+ * Compilation depends only on the route's bundle string and the workflow name
+ * persisted on the run, not the event log or VM context. The runtime starts
+ * this promise while `run_started` loads the replay snapshot, then evaluates
+ * the scripts only after it has created the fresh context.
+ */
+export function compileWorkflowBundle(workflowCode, workflowName) {
+    const parsedName = parseWorkflowName(workflowName);
+    const filename = parsedName?.moduleSpecifier || workflowName;
+    const workflowLookupCode = `globalThis.__private_workflows?.get(${JSON.stringify(workflowName)})`;
+    return trace('workflow.bundle.compile', async (span) => {
+        const bundle = getCachedWorkflowScript(workflowCode, filename);
+        const lookup = getCachedWorkflowScript(workflowLookupCode, filename);
+        span?.setAttributes({
+            // This attribute intentionally describes the workflow bundle. The tiny
+            // lookup script may miss when another workflow from the same source file
+            // runs, but that does not mean V8 recompiled the application bundle.
+            ...Attribute.WorkflowBundleCompileCacheHit(bundle.cacheHit),
+        });
+        return {
+            bundleScript: bundle.script,
+            workflowLookupScript: lookup.script,
+        };
+    });
+}
+/** Cold-start: build a fresh VM session and replay it over `events`. */
+export function replayWorkflow(options) {
+    return traceExecution('replay', options.workflowRun, options.events, async (span) => {
+        const { session, execution } = await createWorkflowSession(options);
+        span?.setAttributes({
+            ...Attribute.WorkflowArgumentsCount(session.argumentCount),
+        });
+        return recordResult(await execution, span);
+    });
+}
+/** Warm-start: advance a retained session by appending events. */
+export function resumeWorkflow(session, events) {
+    return traceExecution('retained', session.workflowRun, events, async (span) => {
+        span?.setAttributes({
+            ...Attribute.WorkflowArgumentsCount(session.argumentCount),
+        });
+        const result = await session.resume(events);
+        return result.type === 'replay' ? result : recordResult(result, span);
+    });
+}
+function traceExecution(mode, workflowRun, events, fn) {
+    return trace(`workflow.run ${workflowRun.workflowName}`, (span) => {
         span?.setAttributes({
             ...Attribute.WorkflowName(workflowRun.workflowName),
             ...Attribute.WorkflowRunId(workflowRun.runId),
             ...Attribute.WorkflowRunStatus(workflowRun.status),
             ...Attribute.WorkflowEventsCount(events.length),
+            ...Attribute.WorkflowExecutionMode(mode),
         });
-        const startedAt = workflowRun.startedAt;
-        if (!startedAt) {
-            throw new WorkflowRuntimeError(`Workflow run "${workflowRun.runId}" has no "startedAt" timestamp (should not happen)`);
-        }
-        // Get the port before creating VM context to avoid async operations
-        // affecting the deterministic timestamp
-        const isVercel = process.env.VERCEL_URL !== undefined;
-        // Load getPort lazily to prevent Turbopack from tracing get-port's
-        // fs ops (readdir, readFile) into the flow route bundle.
-        // Uses globalThis.__wkf_getPort as a lazy-initialized cache to avoid
-        // bundler static analysis while staying compatible with CJS/ESM/VM.
-        const port = isVercel ? undefined : await getPortLazy();
-        const { context, globalThis: vmGlobalThis, updateTimestamp, } = createContext({
-            seed: `${workflowRun.runId}:${workflowRun.workflowName}:${+startedAt}`,
-            fixedTimestamp: +startedAt,
-        });
-        const workflowDiscontinuation = withResolvers();
-        const ulid = monotonicFactory(() => vmGlobalThis.Math.random());
-        const generateNanoid = nanoid.customRandom(nanoid.urlAlphabet, 21, (size) => new Uint8Array(size).map(() => 256 * vmGlobalThis.Math.random()));
-        // Create a mutable holder for the promise queue so the EventsConsumer
-        // can access the current queue state via a getter. The queue is mutated
-        // by step/hook/sleep callbacks as events are processed.
-        const promiseQueueHolder = { current: Promise.resolve() };
-        const eventsConsumer = new EventsConsumer(events, {
-            onUnconsumedEvent: (event) => {
-                workflowDiscontinuation.reject(new WorkflowRuntimeError(`Unconsumed event in event log: eventType=${event.eventType}, correlationId=${event.correlationId}, eventId=${event.eventId}. This indicates a corrupted or invalid event log.`, { slug: ERROR_SLUGS.CORRUPTED_EVENT_LOG }));
-            },
-            getPromiseQueue: () => promiseQueueHolder.current,
+        return fn(span);
+    });
+}
+function recordResult(result, span) {
+    if (result.type === 'completed') {
+        span?.setAttributes({
+            ...Attribute.WorkflowResultType(result.resultType),
         });
-        const workflowContext = {
-            runId: workflowRun.runId,
-            encryptionKey,
-            globalThis: vmGlobalThis,
-            onWorkflowError: workflowDiscontinuation.reject,
-            eventsConsumer,
-            generateUlid: () => ulid(+startedAt),
-            generateNanoid,
-            invocationsQueue: new Map(),
-            // Use getter/setter so the EventsConsumer's getPromiseQueue() always
-            // sees the latest queue state as it's mutated by step/hook/sleep callbacks.
-            get promiseQueue() {
-                return promiseQueueHolder.current;
-            },
-            set promiseQueue(value) {
-                promiseQueueHolder.current = value;
-            },
-            pendingDeliveries: 0,
-        };
-        // Subscribe to the events log to update the timestamp in the vm context
-        workflowContext.eventsConsumer.subscribe((event) => {
-            const createdAt = event?.createdAt;
-            if (createdAt) {
-                updateTimestamp(+createdAt);
-            }
-            // Never consume events - this is only a passive subscriber
+    }
+    else if (span) {
+        applyWorkflowSuspensionToSpan(result.suspension, span);
+        // Events this pass walked past unclaimed and is still holding. Ordinary on
+        // a suspension: an out-of-band delivery that landed ahead of the code that
+        // reads it waits for the pass that reaches that code, and failing here
+        // would fail exactly the runs that tolerance exists for. The case that is
+        // not ordinary (the same event still held pass after pass) is a shape
+        // across these spans, which is why the eventId is on each one and no pass
+        // tries to rule on it alone.
+        if (result.parked) {
+            span.setAttributes({
+                ...Attribute.WorkflowParkedEventsCount(result.parked.count),
+                ...Attribute.WorkflowParkedEventId(result.parked.eventId),
+                ...Attribute.WorkflowParkedEventType(result.parked.eventType),
+            });
+        }
+    }
+    return result;
+}
+/**
+ * Single-shot replay: execute the workflow over `events` and either return
+ * its output or throw its suspension. Kept for the extensive existing test
+ * suites; production code goes through `replayWorkflow`/`resumeWorkflow`.
+ */
+export async function runWorkflow(workflowCode, workflowRun, events, encryptionKey, 
+/**
+ * Optional per-run cache for replay payload preparation and immutable final
+ * values. Owned by the inline execution loop for this invocation.
+ */
+replayPayloadCache = new ReplayPayloadCache(encryptionKey), 
+/**
+ * Turbo mode only: resolves once the backgrounded `run_started` has landed.
+ * Threaded into the end-of-run drain so fire-and-forget `*_created` writes
+ * committed at workflow completion order after the run's creation. Undefined
+ * outside turbo, where `run_started` is awaited up front.
+ */
+runReadyBarrier, 
+/**
+ * Features supported by the World executing this workflow. Missing
+ * capabilities are treated as unsupported.
+ */
+worldCapabilities) {
+    const result = await replayWorkflow({
+        workflowCode,
+        workflowRun,
+        events,
+        encryptionKey,
+        replayPayloadCache,
+        runReadyBarrier,
+        worldCapabilities,
+    });
+    if (result.type === 'suspended')
+        throw result.suspension;
+    return result.output;
+}
+async function createWorkflowSession(options) {
+    const vmTrace = await startTraceSpan('workflow.vm.create_context');
+    return createWorkflowSessionInner(options, vmTrace.end).catch((error) => {
+        vmTrace.fail(error);
+        throw error;
+    });
+}
+async function createWorkflowSessionInner({ workflowCode, workflowRun, events, encryptionKey, replayPayloadCache, compiledWorkflowScripts, runReadyBarrier, worldCapabilities, }, endVmTrace) {
+    const startedAt = workflowRun.startedAt;
+    if (!startedAt) {
+        throw new WorkflowRuntimeError(`Workflow run "${workflowRun.runId}" has no "startedAt" timestamp (should not happen)`);
+    }
+    // Seed and initial clock must be available before I/O and remain stable on
+    // replay. After the first event, EventsConsumer advances the VM clock from
+    // each event's `createdAt`.
+    const fixedTimestamp = runIdCreatedAt(workflowRun.runId) ?? +workflowRun.createdAt;
+    // Truthiness, not presence: `vercel env pull` writes `VERCEL_URL=""` into
+    // `.env.local`, and a framework that loads that file locally would otherwise
+    // put us on the Vercel branch with nothing to build a host from, making
+    // `https://` the base URL of every run.
+    const isVercel = Boolean(process.env.VERCEL_URL);
+    // Load getPort lazily to prevent Turbopack from tracing get-port's
+    // fs ops (readdir, readFile) into the flow route bundle. The resolved
+    // port is cached per process (see get-port-lazy.ts), so this is cheap
+    // on replays after the first.
+    const workflowBaseUrl = createWorkflowBaseUrl(isVercel
+        ? `https://${process.env.VERCEL_URL}`
+        : `http://localhost:${(await getPortLazy()) ?? 3000}`);
+    // Include both node:vm's context creation and the host-side sandbox wiring
+    // below. Most of the bootstrap lives in this function (EventsConsumer,
+    // workflow globals, Web API shims), so tracing createContext() alone would
+    // materially under-report VM startup.
+    const { context, globalThis: vmGlobalThis, updateTimestamp, } = createContext({
+        seed: `${workflowRun.runId}:${workflowRun.workflowName}:${workflowRun.deploymentId}`,
+        fixedTimestamp,
+    });
+    const initialInterruption = withResolvers();
+    let state = {
+        type: 'running',
+        interruption: initialInterruption,
+    };
+    const onWorkflowError = (error) => {
+        switch (state.type) {
+            case 'running': {
+                const { interruption } = state;
+                state = WorkflowSuspension.is(error)
+                    ? { type: 'suspended', suspension: error }
+                    : { type: 'replay' };
+                // Step, hook, wait, and attribute consumers can schedule the same
+                // suspension. The first signal advances the generation so the rest
+                // no-op.
+                workflowContext.suspensionGeneration++;
+                interruption.reject(error);
+                return;
+            }
+            case 'suspended':
+                // Same-boundary duplicates were staled by the generation bump above,
+                // so anything landing here is out-of-band or a divergence. Fall back
+                // to replay rather than resuming a potentially inconsistent session.
+                state = { type: 'replay' };
+                return;
+            case 'replay':
+            case 'completed':
+                return;
+        }
+        state;
+    };
+    const ulid = monotonicFactory(() => vmGlobalThis.Math.random());
+    // Correlation IDs must be replay-stable. `startedAt` differs between a turbo
+    // delivery and a later server-backed replay, so use fixedTimestamp.
+    // The draw counter is the progress metric for `quiesceEarlierCascades`
+    // (WORKFLOW_LOG_ORDER_DRAWS): a quiet turn is one that drew nothing. It
+    // counts EVERY draw from this sequence. This same function is installed as
+    // the `STABLE_ULID` global below, which serialization draws stream ids
+    // from during dehydration. This is deliberate because quiescence must also
+    // wait out serialization-driven draws, and counting extra draws only extends
+    // the wait (see the termination note on `quiesceEarlierCascades`).
+    let mintCount = 0;
+    const generateUlid = () => {
+        mintCount += 1;
+        return ulid(fixedTimestamp);
+    };
+    const generateNanoid = nanoid.customRandom(nanoid.urlAlphabet, 21, (size) => new Uint8Array(size).map(() => 256 * vmGlobalThis.Math.random()));
+    // Create a mutable holder for the promise queue so the EventsConsumer
+    // can access the current queue state via a getter. The queue is mutated
+    // by step/hook/sleep callbacks as events are processed.
+    const promiseQueueHolder = { current: Promise.resolve() };
+    // Same reason as the queue holder: the consumer is built before the context
+    // whose delivery state it has to read. Idle until the context exists, which
+    // is before any delivery can be registered against it.
+    const deliveryIdleHolder = { current: () => true };
+    // The VM clock only ever moves forward. Consumption order is log order for
+    // everything whose order the replay decides, but an event the consumer
+    // parked is delivered after the walk has already passed events written after
+    // it, and letting its `createdAt` set the clock would make `Date.now()` go
+    // backwards inside a single replay.
+    let clock = fixedTimestamp;
+    const eventsConsumer = new EventsConsumer(events, {
+        onConsumedEvent: (event) => {
+            const at = +event.createdAt;
+            if (at > clock) {
+                clock = at;
+                updateTimestamp(at);
+            }
+        },
+        onUnconsumedEvent: (event) => {
+            // `workflowContext` is assigned below, before any event can be offered,
+            // so it is always populated by the time this fires. The appended detail
+            // names the pending invocation that holds this event's ordinal (the
+            // usual reason nobody can consume it) and where the walk stands.
+            onWorkflowError(new ReplayDivergenceError(`Replay could not consume event: eventType=${event.eventType}, correlationId=${event.correlationId}, eventId=${event.eventId}. ${describeDivergenceContext(event, workflowContext.invocationsQueue, eventsConsumer)}`, { eventId: event.eventId }));
+        },
+        // Both branches log at `debug`, so neither reaches the console unless
+        // `DEBUG` matches. A duplicate is a permanent feature of the log: every
+        // later replay re-reads it and lands here again, so anything the logger
+        // prints unconditionally would print once per replay for the life of the
+        // run. There is also nothing to act on. Ignoring the event is the correct
+        // outcome, not a degraded one, and no user change makes the straggler go
+        // away. What the levels are for is diagnosis after the fact, which is
+        // exactly what `DEBUG=workflow:runtime:debug` is for.
+        onDuplicateEvent: (event, firstEventType) => {
+            const details = {
+                workflowRunId: workflowRun.runId,
+                eventId: event.eventId,
+                eventType: event.eventType,
+                firstEventType,
+                correlationId: event.correlationId,
+            };
+            if (firstEventType !== event.eventType) {
+                // Two writers reached opposite conclusions about one entity: a
+                // `step_failed` behind a `step_completed`, or the reverse. Ignoring it
+                // is still correct and still deterministic (replay reads the first one
+                // at the same position every time), but unlike a re-commit of the same
+                // outcome there is no reading of this where both writers were right,
+                // so the discarded outcome gets its own message.
+                runtimeLogger.debug('Ignoring inert event that decides an already-decided outcome differently', details);
+                return;
+            }
+            // The first event of this class decided the outcome at a lower log
+            // position and replay reads that one. Recorded because a straggler is
+            // still evidence of two replays writing for the same entity, which is
+            // worth seeing when diagnosing a run.
+            runtimeLogger.debug('Ignoring inert event that repeats a class already in the event log', details);
+        },
+        getPromiseQueue: () => promiseQueueHolder.current,
+        isDeliveryIdle: () => deliveryIdleHolder.current(),
+    });
+    const workflowContext = {
+        runId: workflowRun.runId,
+        encryptionKey,
+        worldCapabilities,
+        globalThis: vmGlobalThis,
+        onWorkflowError,
+        eventsConsumer,
+        generateUlid,
+        generateNanoid,
+        get mintCount() {
+            return mintCount;
+        },
+        invocationsQueue: new Map(),
+        // Use getter/setter so the EventsConsumer's getPromiseQueue() always
+        // sees the latest queue state as it's mutated by step/hook/sleep callbacks.
+        get promiseQueue() {
+            return promiseQueueHolder.current;
+        },
+        set promiseQueue(value) {
+            promiseQueueHolder.current = value;
+        },
+        pendingDeliveries: 0,
+        suspensionGeneration: 0,
+        pendingDeliveryBarriers: new Map(),
+        replayPayloadCache,
+    };
+    deliveryIdleHolder.current = () => isDeliveryIdle(workflowContext);
+    // Consume run lifecycle events - these are structural events that don't
+    // need special handling in the workflow, but must be consumed to advance
+    // past them in the event log
+    let consumedRunStarted = false;
+    workflowContext.eventsConsumer.subscribe((event) => {
+        if (!event) {
             return EventConsumerResult.NotConsumed;
-        });
-        // Consume run lifecycle events - these are structural events that don't
-        // need special handling in the workflow, but must be consumed to advance
-        // past them in the event log
-        workflowContext.eventsConsumer.subscribe((event) => {
-            if (!event) {
+        }
+        // Consume run_created - every run has exactly one
+        if (event.eventType === 'run_created') {
+            return EventConsumerResult.Consumed;
+        }
+        // Consume the first run_started. Two replays can each write one (the
+        // create is idempotent for a run already running, which makes the write
+        // safe, not single-shot); the first is the one the replay observes, and
+        // the consumer skips the rest rather than advancing the workflow clock
+        // twice.
+        if (event.eventType === 'run_started') {
+            if (consumedRunStarted) {
                 return EventConsumerResult.NotConsumed;
             }
-            // Consume run_created - every run has exactly one
-            if (event.eventType === 'run_created') {
-                return EventConsumerResult.Consumed;
-            }
-            // Consume run_started - every run has exactly one
-            if (event.eventType === 'run_started') {
-                return EventConsumerResult.Consumed;
-            }
-            return EventConsumerResult.NotConsumed;
+            consumedRunStarted = true;
+            return EventConsumerResult.Consumed;
+        }
+        // Attribute writes performed from a step have no workflow-body call to
+        // consume them during replay; they are already reflected in the run
+        // snapshot and remain structural until a read API is introduced.
+        if (event.eventType === 'attr_set' &&
+            event.eventData.writer.type === 'step') {
+            return EventConsumerResult.Consumed;
+        }
+        return EventConsumerResult.NotConsumed;
+    });
+    const useStep = createUseStep(workflowContext);
+    const createHook = createCreateHook(workflowContext);
+    const sleep = createSleep(workflowContext);
+    const setAttributes = createSetAttributes(workflowContext);
+    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
+    vmGlobalThis[WORKFLOW_USE_STEP] = useStep;
+    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
+    vmGlobalThis[WORKFLOW_SET_ATTRIBUTES] = setAttributes;
+    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
+    vmGlobalThis[WORKFLOW_CREATE_HOOK] = createHook;
+    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
+    vmGlobalThis[WORKFLOW_SLEEP] = sleep;
+    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
+    vmGlobalThis[WORKFLOW_GET_STREAM_ID] = (namespace) => getWorkflowRunStreamId(workflowRun.runId, namespace);
+    // For the workflow VM, we store the context in a symbol on the `globalThis` object
+    const ctx = {
+        workflowName: workflowRun.workflowName,
+        workflowRunId: workflowRun.runId,
+        workflowStartedAt: new vmGlobalThis.Date(+startedAt),
+        url: workflowBaseUrl,
+        features: { encryption: !!encryptionKey },
+    };
+    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
+    vmGlobalThis[WORKFLOW_CONTEXT_SYMBOL] = ctx;
+    // Serialization mints stream ids through this symbol, and calls it with no
+    // seed time. `monotonicFactory` returns `encodeTime(lastTime)` on its
+    // increment branch, so one such call latches the *host* wall clock into
+    // `lastTime`, and every id the run mints afterwards carries that timestamp
+    // instead of `fixedTimestamp`, a value that differs on every replay. Binding
+    // the seed time here keeps the whole run on one replay-stable clock.
+    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
+    vmGlobalThis[STABLE_ULID] = generateUlid;
+    // Workflow code must import the deterministic `fetch` step from `workflow`.
+    vmGlobalThis.fetch = () => {
+        throw new vmGlobalThis.Error(`Global "fetch" is unavailable in workflow functions. Use the "fetch" step function from "workflow" to make HTTP requests.\n\nLearn more: https://workflow-sdk.dev/err/${ERROR_SLUGS.FETCH_IN_WORKFLOW_FUNCTION}`);
+    };
+    // Override timeout/interval functions to throw helpful errors
+    // These are not supported in workflow functions because they rely on
+    // asynchronous scheduling which breaks deterministic replay
+    const timeoutErrorMessage = 'Timeout functions like "setTimeout" and "setInterval" are not supported in workflow functions. Use the "sleep" function from "workflow" for time-based delays.';
+    vmGlobalThis.setTimeout = () => {
+        throw new WorkflowRuntimeError(timeoutErrorMessage, {
+            slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,
         });
-        const useStep = createUseStep(workflowContext);
-        const createHook = createCreateHook(workflowContext);
-        const sleep = createSleep(workflowContext);
-        // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
-        vmGlobalThis[WORKFLOW_USE_STEP] = useStep;
-        // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
-        vmGlobalThis[WORKFLOW_CREATE_HOOK] = createHook;
-        // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
-        vmGlobalThis[WORKFLOW_SLEEP] = sleep;
-        // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
-        vmGlobalThis[WORKFLOW_GET_STREAM_ID] = (namespace) => getWorkflowRunStreamId(workflowRun.runId, namespace);
-        // TODO: there should be a getUrl method on the world interface itself. This
-        // solution only works for vercel + local worlds.
-        const url = isVercel
-            ? `https://${process.env.VERCEL_URL}`
-            : `http://localhost:${port ?? 3000}`;
-        // For the workflow VM, we store the context in a symbol on the `globalThis` object
-        const ctx = {
-            workflowName: workflowRun.workflowName,
-            workflowRunId: workflowRun.runId,
-            workflowStartedAt: new vmGlobalThis.Date(+startedAt),
-            url,
-            features: { encryption: !!encryptionKey },
-        };
-        // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
-        vmGlobalThis[WORKFLOW_CONTEXT_SYMBOL] = ctx;
-        // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
-        vmGlobalThis[STABLE_ULID] = ulid;
-        // NOTE: Will have a config override to use the custom fetch step.
-        //       For now `fetch` must be explicitly imported from `workflow`.
-        vmGlobalThis.fetch = () => {
-            throw new vmGlobalThis.Error(`Global "fetch" is unavailable in workflow functions. Use the "fetch" step function from "workflow" to make HTTP requests.\n\nLearn more: https://workflow-sdk.dev/err/${ERROR_SLUGS.FETCH_IN_WORKFLOW_FUNCTION}`);
-        };
-        // Override timeout/interval functions to throw helpful errors
-        // These are not supported in workflow functions because they rely on
-        // asynchronous scheduling which breaks deterministic replay
-        const timeoutErrorMessage = 'Timeout functions like "setTimeout" and "setInterval" are not supported in workflow functions. Use the "sleep" function from "workflow" for time-based delays.';
-        vmGlobalThis.setTimeout = () => {
-            throw new WorkflowRuntimeError(timeoutErrorMessage, {
-                slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,
-            });
-        };
-        vmGlobalThis.setInterval = () => {
-            throw new WorkflowRuntimeError(timeoutErrorMessage, {
-                slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,
-            });
-        };
-        vmGlobalThis.clearTimeout = () => {
-            throw new WorkflowRuntimeError(timeoutErrorMessage, {
-                slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,
-            });
-        };
-        vmGlobalThis.clearInterval = () => {
-            throw new WorkflowRuntimeError(timeoutErrorMessage, {
-                slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,
-            });
-        };
-        vmGlobalThis.setImmediate = () => {
-            throw new WorkflowRuntimeError(timeoutErrorMessage, {
-                slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,
-            });
-        };
-        vmGlobalThis.clearImmediate = () => {
-            throw new WorkflowRuntimeError(timeoutErrorMessage, {
-                slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,
-            });
-        };
-        // `AbortController` and `AbortSignal` in the workflow VM are hook-backed
-        // for deterministic replay. The controller's abort() queues a hook resumption,
-        // and signal.aborted is updated when the hook event is processed during replay.
-        vmGlobalThis.AbortController =
-            createCreateAbortController(workflowContext);
-        const abortSignalStatics = createAbortSignalStatics();
-        vmGlobalThis.AbortSignal = {
-            abort: abortSignalStatics.abort,
-            any: abortSignalStatics.any,
-            timeout: abortSignalStatics.timeout,
-        };
-        // `Request` and `Response` are special built-in classes that invoke steps
-        // for the `json()`, `text()` and `arrayBuffer()` instance methods
-        class Request {
-            cache;
-            credentials;
-            destination;
-            headers;
-            integrity;
-            method;
-            mode;
-            redirect;
-            referrer;
-            referrerPolicy;
-            url;
-            keepalive;
-            signal;
-            duplex;
-            body;
-            constructor(input, init) {
-                // Handle URL input
-                if (typeof input === 'string' || input instanceof vmGlobalThis.URL) {
-                    const urlString = String(input);
-                    // Validate URL format
-                    try {
-                        new vmGlobalThis.URL(urlString);
-                        this.url = urlString;
-                    }
-                    catch (cause) {
-                        throw new TypeError(`Failed to parse URL from ${urlString}`, {
-                            cause,
-                        });
-                    }
+    };
+    vmGlobalThis.setInterval = () => {
+        throw new WorkflowRuntimeError(timeoutErrorMessage, {
+            slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,
+        });
+    };
+    vmGlobalThis.clearTimeout = () => {
+        throw new WorkflowRuntimeError(timeoutErrorMessage, {
+            slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,
+        });
+    };
+    vmGlobalThis.clearInterval = () => {
+        throw new WorkflowRuntimeError(timeoutErrorMessage, {
+            slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,
+        });
+    };
+    vmGlobalThis.setImmediate = () => {
+        throw new WorkflowRuntimeError(timeoutErrorMessage, {
+            slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,
+        });
+    };
+    vmGlobalThis.clearImmediate = () => {
+        throw new WorkflowRuntimeError(timeoutErrorMessage, {
+            slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,
+        });
+    };
+    // `AbortController` and `AbortSignal` in the workflow VM are hook-backed
+    // for deterministic replay. The controller's abort() queues a hook resumption,
+    // and signal.aborted is updated when the hook event is processed during replay.
+    vmGlobalThis.AbortController =
+        createCreateAbortController(workflowContext);
+    const abortSignalStatics = createAbortSignalStatics();
+    vmGlobalThis.AbortSignal = {
+        abort: abortSignalStatics.abort,
+        any: abortSignalStatics.any,
+        timeout: abortSignalStatics.timeout,
+    };
+    // `Request` and `Response` are special built-in classes that invoke steps
+    // for the `json()`, `text()` and `arrayBuffer()` instance methods
+    class Request {
+        cache;
+        credentials;
+        destination;
+        headers;
+        integrity;
+        method;
+        mode;
+        redirect;
+        referrer;
+        referrerPolicy;
+        url;
+        keepalive;
+        signal;
+        duplex;
+        body;
+        constructor(input, init) {
+            // Handle URL input
+            if (typeof input === 'string' || input instanceof vmGlobalThis.URL) {
+                const urlString = String(input);
+                // Validate URL format
+                try {
+                    new vmGlobalThis.URL(urlString);
+                    this.url = urlString;
+                }
+                catch (cause) {
+                    throw new TypeError(`Failed to parse URL from ${urlString}`, {
+                        cause,
+                    });
                 }
-                else {
-                    // Input is a Request object - clone its properties
-                    this.url = input.url;
-                    if (!init) {
-                        this.method = input.method;
-                        this.headers = new vmGlobalThis.Headers(input.headers);
-                        this.body = input.body;
-                        this.mode = input.mode;
-                        this.credentials = input.credentials;
-                        this.cache = input.cache;
-                        this.redirect = input.redirect;
-                        this.referrer = input.referrer;
-                        this.referrerPolicy = input.referrerPolicy;
-                        this.integrity = input.integrity;
-                        this.keepalive = input.keepalive;
-                        this.signal = input.signal;
-                        this.duplex = input.duplex;
-                        this.destination = input.destination;
-                        return;
-                    }
-                    // If init is provided, merge: use source properties, then override with init
-                    // Copy all properties from the source Request first
+            }
+            else {
+                // Input is a Request object - clone its properties
+                this.url = input.url;
+                if (!init) {
                     this.method = input.method;
                     this.headers = new vmGlobalThis.Headers(input.headers);
                     this.body = input.body;
@@ -302,354 +538,457 @@ export async function runWorkflow(workflowCode, workflowRun, events, encryptionK
                     this.signal = input.signal;
                     this.duplex = input.duplex;
                     this.destination = input.destination;
+                    return;
                 }
-                // Override with init options if provided
-                // Set method
-                if (init?.method) {
-                    this.method = init.method.toUpperCase();
-                }
-                else if (typeof this.method !== 'string') {
-                    // Fallback to default for string input case
-                    this.method = 'GET';
-                }
-                // Set headers
-                if (init?.headers) {
-                    this.headers = new vmGlobalThis.Headers(init.headers);
-                }
-                else if (typeof input === 'string' ||
-                    input instanceof vmGlobalThis.URL) {
-                    // For string/URL input, create empty headers
-                    this.headers = new vmGlobalThis.Headers();
-                }
-                // Set other properties with init values or defaults
-                if (init?.mode !== undefined) {
-                    this.mode = init.mode;
-                }
-                else if (typeof this.mode !== 'string') {
-                    this.mode = 'cors';
-                }
-                if (init?.credentials !== undefined) {
-                    this.credentials = init.credentials;
-                }
-                else if (typeof this.credentials !== 'string') {
-                    this.credentials = 'same-origin';
-                }
-                // `any` cast here because @types/node v22 does not yet have `cache`
-                if (init?.cache !== undefined) {
-                    this.cache = init.cache;
-                }
-                else if (typeof this.cache !== 'string') {
-                    this.cache = 'default';
-                }
-                if (init?.redirect !== undefined) {
-                    this.redirect = init.redirect;
-                }
-                else if (typeof this.redirect !== 'string') {
-                    this.redirect = 'follow';
-                }
-                if (init?.referrer !== undefined) {
-                    this.referrer = init.referrer;
-                }
-                else if (typeof this.referrer !== 'string') {
-                    this.referrer = 'about:client';
-                }
-                if (init?.referrerPolicy !== undefined) {
-                    this.referrerPolicy = init.referrerPolicy;
-                }
-                else if (typeof this.referrerPolicy !== 'string') {
-                    this.referrerPolicy = '';
-                }
-                if (init?.integrity !== undefined) {
-                    this.integrity = init.integrity;
-                }
-                else if (typeof this.integrity !== 'string') {
-                    this.integrity = '';
-                }
-                if (init?.keepalive !== undefined) {
-                    this.keepalive = init.keepalive;
-                }
-                else if (typeof this.keepalive !== 'boolean') {
-                    this.keepalive = false;
-                }
-                if (init?.signal !== undefined) {
-                    // @ts-expect-error - AbortSignal stub
-                    this.signal = init.signal;
-                }
-                else if (!this.signal) {
-                    // @ts-expect-error - AbortSignal stub
-                    this.signal = { aborted: false };
-                }
-                if (!this.duplex) {
-                    this.duplex = 'half';
-                }
-                if (!this.destination) {
-                    this.destination = 'document';
-                }
-                const body = init?.body;
-                // Validate that GET/HEAD methods don't have a body
-                if (body !== null &&
-                    body !== undefined &&
-                    (this.method === 'GET' || this.method === 'HEAD')) {
-                    throw new TypeError(`Request with GET/HEAD method cannot have body.`);
-                }
-                // Store the original BodyInit for serialization
-                if (body !== null && body !== undefined) {
-                    // Create a "fake" ReadableStream that stores the original body
-                    // This avoids doing async work during workflow replay
-                    this.body = Object.create(vmGlobalThis.ReadableStream.prototype, {
-                        [BODY_INIT_SYMBOL]: {
-                            value: body,
-                            writable: false,
-                        },
-                    });
-                }
-                else {
-                    this.body = null;
-                }
+                // If init is provided, merge: use source properties, then override with init
+                // Copy all properties from the source Request first
+                this.method = input.method;
+                this.headers = new vmGlobalThis.Headers(input.headers);
+                this.body = input.body;
+                this.mode = input.mode;
+                this.credentials = input.credentials;
+                this.cache = input.cache;
+                this.redirect = input.redirect;
+                this.referrer = input.referrer;
+                this.referrerPolicy = input.referrerPolicy;
+                this.integrity = input.integrity;
+                this.keepalive = input.keepalive;
+                this.signal = input.signal;
+                this.duplex = input.duplex;
+                this.destination = input.destination;
+            }
+            // Override with init options if provided
+            // Set method
+            if (init?.method) {
+                this.method = init.method.toUpperCase();
+            }
+            else if (typeof this.method !== 'string') {
+                // Fallback to default for string input case
+                this.method = 'GET';
+            }
+            // Set headers
+            if (init?.headers) {
+                this.headers = new vmGlobalThis.Headers(init.headers);
+            }
+            else if (typeof input === 'string' ||
+                input instanceof vmGlobalThis.URL) {
+                // For string/URL input, create empty headers
+                this.headers = new vmGlobalThis.Headers();
+            }
+            // Set other properties with init values or defaults
+            if (init?.mode !== undefined) {
+                this.mode = init.mode;
+            }
+            else if (typeof this.mode !== 'string') {
+                this.mode = 'cors';
+            }
+            if (init?.credentials !== undefined) {
+                this.credentials = init.credentials;
+            }
+            else if (typeof this.credentials !== 'string') {
+                this.credentials = 'same-origin';
+            }
+            // `any` cast here because @types/node v22 does not yet have `cache`
+            if (init?.cache !== undefined) {
+                this.cache = init.cache;
+            }
+            else if (typeof this.cache !== 'string') {
+                this.cache = 'default';
+            }
+            if (init?.redirect !== undefined) {
+                this.redirect = init.redirect;
+            }
+            else if (typeof this.redirect !== 'string') {
+                this.redirect = 'follow';
+            }
+            if (init?.referrer !== undefined) {
+                this.referrer = init.referrer;
+            }
+            else if (typeof this.referrer !== 'string') {
+                this.referrer = 'about:client';
+            }
+            if (init?.referrerPolicy !== undefined) {
+                this.referrerPolicy = init.referrerPolicy;
+            }
+            else if (typeof this.referrerPolicy !== 'string') {
+                this.referrerPolicy = '';
+            }
+            if (init?.integrity !== undefined) {
+                this.integrity = init.integrity;
+            }
+            else if (typeof this.integrity !== 'string') {
+                this.integrity = '';
+            }
+            if (init?.keepalive !== undefined) {
+                this.keepalive = init.keepalive;
+            }
+            else if (typeof this.keepalive !== 'boolean') {
+                this.keepalive = false;
+            }
+            if (init?.signal !== undefined) {
+                // @ts-expect-error - AbortSignal stub
+                this.signal = init.signal;
+            }
+            else if (!this.signal) {
+                // @ts-expect-error - AbortSignal stub
+                this.signal = { aborted: false };
+            }
+            if (!this.duplex) {
+                this.duplex = 'half';
+            }
+            if (!this.destination) {
+                this.destination = 'document';
+            }
+            const body = init?.body;
+            // Validate that GET/HEAD methods don't have a body
+            if (body !== null &&
+                body !== undefined &&
+                (this.method === 'GET' || this.method === 'HEAD')) {
+                throw new TypeError(`Request with GET/HEAD method cannot have body.`);
             }
-            clone() {
-                ENOTSUP();
-            }
-            get bodyUsed() {
-                return false;
-            }
-            // TODO: implement these
-            blob;
-            formData;
-            arrayBuffer;
-            json;
-            text;
-            async bytes() {
-                return new Uint8Array(await this.arrayBuffer());
-            }
-        }
-        vmGlobalThis.Request = Request;
-        Object.defineProperties(Request.prototype, {
-            arrayBuffer: {
-                value: useStep('__builtin_response_array_buffer'),
-                writable: true,
-                configurable: true,
-            },
-            json: {
-                value: useStep('__builtin_response_json'),
-                writable: true,
-                configurable: true,
-            },
-            text: {
-                value: useStep('__builtin_response_text'),
-                writable: true,
-                configurable: true,
-            },
-        });
-        class Response {
-            type;
-            url;
-            status;
-            statusText;
-            body;
-            headers;
-            redirected;
-            constructor(body, init) {
-                this.status = init?.status ?? 200;
-                this.statusText = init?.statusText ?? '';
-                this.headers = new vmGlobalThis.Headers(init?.headers);
-                this.type = 'default';
-                this.url = '';
-                this.redirected = false;
-                // Validate that null-body status codes don't have a body
-                // Per HTTP spec: 204 (No Content), 205 (Reset Content), and 304 (Not Modified)
-                if (body !== null &&
-                    body !== undefined &&
-                    (this.status === 204 || this.status === 205 || this.status === 304)) {
-                    throw new TypeError(`Response constructor: Invalid response status code ${this.status}`);
-                }
-                // Store the original BodyInit for serialization
-                if (body !== null && body !== undefined) {
-                    // Create a "fake" ReadableStream that stores the original body
-                    // This avoids doing async work during workflow replay
-                    this.body = Object.create(vmGlobalThis.ReadableStream.prototype, {
-                        [BODY_INIT_SYMBOL]: {
-                            value: body,
-                            writable: false,
-                        },
-                    });
-                }
-                else {
-                    this.body = null;
-                }
-            }
-            // TODO: implement these
-            clone;
-            blob;
-            formData;
-            get ok() {
-                return this.status >= 200 && this.status < 300;
-            }
-            get bodyUsed() {
-                return false;
-            }
-            arrayBuffer;
-            json;
-            text;
-            async bytes() {
-                return new Uint8Array(await this.arrayBuffer());
-            }
-            static json(data, init) {
-                const body = JSON.stringify(data);
-                const headers = new vmGlobalThis.Headers(init?.headers);
-                if (!headers.has('content-type')) {
-                    headers.set('content-type', 'application/json');
-                }
-                return new Response(body, { ...init, headers });
-            }
-            static error() {
-                ENOTSUP();
-            }
-            static redirect(url, status = 302) {
-                // Validate status code - only specific redirect codes are allowed
-                if (![301, 302, 303, 307, 308].includes(status)) {
-                    throw new RangeError(`Invalid redirect status code: ${status}. Must be one of: 301, 302, 303, 307, 308`);
-                }
-                // Create response with Location header
-                const headers = new vmGlobalThis.Headers();
-                headers.set('Location', String(url));
-                const response = Object.create(Response.prototype);
-                response.status = status;
-                response.statusText = '';
-                response.headers = headers;
-                response.body = null;
-                response.type = 'default';
-                response.url = '';
-                response.redirected = false;
-                return response;
-            }
-        }
-        vmGlobalThis.Response = Response;
-        Object.defineProperties(Response.prototype, {
-            arrayBuffer: {
-                value: useStep('__builtin_response_array_buffer'),
-                writable: true,
-                configurable: true,
-            },
-            json: {
-                value: useStep('__builtin_response_json'),
-                writable: true,
-                configurable: true,
-            },
-            text: {
-                value: useStep('__builtin_response_text'),
-                writable: true,
-                configurable: true,
-            },
-        });
-        class ReadableStream {
-            constructor() {
-                ENOTSUP();
-            }
-            get locked() {
-                return false;
+            // Store the original BodyInit for serialization
+            if (body !== null && body !== undefined) {
+                // Create a "fake" ReadableStream that stores the original body
+                // This avoids doing async work during workflow replay
+                this.body = Object.create(vmGlobalThis.ReadableStream.prototype, {
+                    [BODY_INIT_SYMBOL]: {
+                        value: body,
+                        writable: false,
+                    },
+                });
             }
-            cancel() {
-                ENOTSUP();
-            }
-            getReader() {
-                ENOTSUP();
-            }
-            pipeThrough() {
-                ENOTSUP();
-            }
-            pipeTo() {
-                ENOTSUP();
-            }
-            tee() {
-                ENOTSUP();
-            }
-            values() {
-                ENOTSUP();
-            }
-            static from() {
-                ENOTSUP();
-            }
-            [Symbol.asyncIterator]() {
-                ENOTSUP();
+            else {
+                this.body = null;
             }
         }
-        vmGlobalThis.ReadableStream = ReadableStream;
-        class WritableStream {
-            constructor() {
-                ENOTSUP();
-            }
-            get locked() {
-                return false;
-            }
-            abort() {
-                ENOTSUP();
-            }
-            close() {
-                ENOTSUP();
-            }
-            getWriter() {
-                ENOTSUP();
+        clone() {
+            ENOTSUP();
+        }
+        get bodyUsed() {
+            return false;
+        }
+        // TODO: implement these
+        blob;
+        formData;
+        arrayBuffer;
+        json;
+        text;
+        async bytes() {
+            return new Uint8Array(await this.arrayBuffer());
+        }
+    }
+    vmGlobalThis.Request = Request;
+    Object.defineProperties(Request.prototype, {
+        arrayBuffer: {
+            value: useStep('__builtin_response_array_buffer'),
+            writable: true,
+            configurable: true,
+        },
+        json: {
+            value: useStep('__builtin_response_json'),
+            writable: true,
+            configurable: true,
+        },
+        text: {
+            value: useStep('__builtin_response_text'),
+            writable: true,
+            configurable: true,
+        },
+    });
+    class Response {
+        type;
+        url;
+        status;
+        statusText;
+        body;
+        headers;
+        redirected;
+        constructor(body, init) {
+            this.status = init?.status ?? 200;
+            this.statusText = init?.statusText ?? '';
+            this.headers = new vmGlobalThis.Headers(init?.headers);
+            this.type = 'default';
+            this.url = '';
+            this.redirected = false;
+            // Validate that null-body status codes don't have a body
+            // Per HTTP spec: 204 (No Content), 205 (Reset Content), and 304 (Not Modified)
+            if (body !== null &&
+                body !== undefined &&
+                (this.status === 204 || this.status === 205 || this.status === 304)) {
+                throw new TypeError(`Response constructor: Invalid response status code ${this.status}`);
+            }
+            // Store the original BodyInit for serialization
+            if (body !== null && body !== undefined) {
+                // Create a "fake" ReadableStream that stores the original body
+                // This avoids doing async work during workflow replay
+                this.body = Object.create(vmGlobalThis.ReadableStream.prototype, {
+                    [BODY_INIT_SYMBOL]: {
+                        value: body,
+                        writable: false,
+                    },
+                });
+            }
+            else {
+                this.body = null;
             }
         }
-        vmGlobalThis.WritableStream = WritableStream;
-        class TransformStream {
-            readable;
-            writable;
-            constructor() {
-                ENOTSUP();
+        // TODO: implement these
+        clone;
+        blob;
+        formData;
+        get ok() {
+            return this.status >= 200 && this.status < 300;
+        }
+        get bodyUsed() {
+            return false;
+        }
+        arrayBuffer;
+        json;
+        text;
+        async bytes() {
+            return new Uint8Array(await this.arrayBuffer());
+        }
+        static json(data, init) {
+            const body = JSON.stringify(data);
+            const headers = new vmGlobalThis.Headers(init?.headers);
+            if (!headers.has('content-type')) {
+                headers.set('content-type', 'application/json');
             }
+            return new Response(body, { ...init, headers });
         }
-        vmGlobalThis.TransformStream = TransformStream;
-        // Eventually we'll probably want to provide our own `console` object,
-        // but for now we'll just expose the global one.
-        vmGlobalThis.console = globalThis.console;
-        // HACK: propagate symbol needed for AI gateway usage
-        const SYMBOL_FOR_REQ_CONTEXT = Symbol.for('@vercel/request-context');
-        // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
-        vmGlobalThis[SYMBOL_FOR_REQ_CONTEXT] = globalThis[SYMBOL_FOR_REQ_CONTEXT];
-        // Get a reference to the user-defined workflow function.
-        // The filename parameter ensures stack traces show a meaningful name
-        // (e.g., "example/workflows/99_e2e.ts") instead of "evalmachine.<anonymous>".
-        const parsedName = parseWorkflowName(workflowRun.workflowName);
-        const filename = parsedName?.moduleSpecifier || workflowRun.workflowName;
-        const workflowFn = runInContext(`${workflowCode}; globalThis.__private_workflows?.get(${JSON.stringify(workflowRun.workflowName)})`, context, { filename });
-        if (typeof workflowFn !== 'function') {
-            throw new WorkflowNotRegisteredError(workflowRun.workflowName);
+        static error() {
+            ENOTSUP();
         }
-        // Chain workflow argument hydration onto the promiseQueue so that the
-        // unconsumed event check (which waits for the queue to drain) doesn't
-        // fire during the async gap between run_started consumption and the
-        // workflow function subscribing its first step callbacks.
-        let args = [];
-        workflowContext.promiseQueue = workflowContext.promiseQueue.then(async () => {
-            args = await hydrateWorkflowArguments(workflowRun.input, workflowRun.runId, encryptionKey, vmGlobalThis);
-        });
-        await workflowContext.promiseQueue;
-        span?.setAttributes({
-            ...Attribute.WorkflowArgumentsCount(args.length),
+        static redirect(url, status = 302) {
+            // Validate status code - only specific redirect codes are allowed
+            if (![301, 302, 303, 307, 308].includes(status)) {
+                throw new RangeError(`Invalid redirect status code: ${status}. Must be one of: 301, 302, 303, 307, 308`);
+            }
+            // Create response with Location header
+            const headers = new vmGlobalThis.Headers();
+            headers.set('Location', String(url));
+            const response = Object.create(Response.prototype);
+            response.status = status;
+            response.statusText = '';
+            response.headers = headers;
+            response.body = null;
+            response.type = 'default';
+            response.url = '';
+            response.redirected = false;
+            return response;
+        }
+    }
+    vmGlobalThis.Response = Response;
+    Object.defineProperties(Response.prototype, {
+        arrayBuffer: {
+            value: useStep('__builtin_response_array_buffer'),
+            writable: true,
+            configurable: true,
+        },
+        json: {
+            value: useStep('__builtin_response_json'),
+            writable: true,
+            configurable: true,
+        },
+        text: {
+            value: useStep('__builtin_response_text'),
+            writable: true,
+            configurable: true,
+        },
+    });
+    class ReadableStream {
+        constructor() {
+            ENOTSUP();
+        }
+        get locked() {
+            return false;
+        }
+        cancel() {
+            ENOTSUP();
+        }
+        getReader() {
+            ENOTSUP();
+        }
+        pipeThrough() {
+            ENOTSUP();
+        }
+        pipeTo() {
+            ENOTSUP();
+        }
+        tee() {
+            ENOTSUP();
+        }
+        values() {
+            ENOTSUP();
+        }
+        static from() {
+            ENOTSUP();
+        }
+        [Symbol.asyncIterator]() {
+            ENOTSUP();
+        }
+    }
+    vmGlobalThis.ReadableStream = ReadableStream;
+    class WritableStream {
+        constructor() {
+            ENOTSUP();
+        }
+        get locked() {
+            return false;
+        }
+        abort() {
+            ENOTSUP();
+        }
+        close() {
+            ENOTSUP();
+        }
+        getWriter() {
+            ENOTSUP();
+        }
+    }
+    vmGlobalThis.WritableStream = WritableStream;
+    class TransformStream {
+        readable;
+        writable;
+        constructor() {
+            ENOTSUP();
+        }
+    }
+    vmGlobalThis.TransformStream = TransformStream;
+    vmGlobalThis.console = globalThis.console;
+    // Expose the request-context symbol required by AI Gateway.
+    const SYMBOL_FOR_REQ_CONTEXT = Symbol.for('@vercel/request-context');
+    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
+    vmGlobalThis[SYMBOL_FOR_REQ_CONTEXT] = globalThis[SYMBOL_FOR_REQ_CONTEXT];
+    endVmTrace();
+    // Reuse compiled scripts by `(code, filename)`: compilation is deterministic
+    // and the filename preserves workflow source attribution in stack traces.
+    // The bundle registers workflows on `globalThis.__private_workflows`.
+    const { bundleScript, workflowLookupScript } = compiledWorkflowScripts ??
+        (await compileWorkflowBundle(workflowCode, workflowRun.workflowName));
+    const workflowFn = await trace('workflow.bundle.evaluate', async () => {
+        bundleScript.runInContext(context);
+        return workflowLookupScript.runInContext(context);
+    });
+    if (typeof workflowFn !== 'function') {
+        throw new WorkflowNotRegisteredError(workflowRun.workflowName);
+    }
+    // Chain workflow argument hydration onto the promiseQueue so that the
+    // unconsumed event check (which waits for the queue to drain) doesn't
+    // fire during the async gap between run_started consumption and the
+    // workflow function subscribing its first step callbacks.
+    let args = [];
+    workflowContext.promiseQueue = workflowContext.promiseQueue.then(async () => {
+        // Include any residual payload preparation plus VM-local deserialization
+        // in the blocking boundary.
+        args = await trace('workflow.input.hydrate', async () => {
+            const prepared = await replayPayloadCache.prepareWorkflowInput(workflowRun);
+            return hydrateWorkflowArguments(workflowRun.input, workflowRun.runId, encryptionKey, vmGlobalThis, {}, prepared);
         });
-        // Invoke user workflow
+    });
+    await workflowContext.promiseQueue;
+    const failWorkflow = async (error) => {
+        // Control-flow signals are handled by the runtime and do not mean the
+        // workflow has terminally failed. `onWorkflowError` usually already moved
+        // the state machine, but a divergence can also arrive via a step
+        // promise's direct rejection (bypassing `onWorkflowError`); demote so
+        // every control-flow path converges on `replay` and a later resume falls
+        // back instead of throwing.
+        if (WorkflowSuspension.is(error) || ReplayDivergenceError.is(error)) {
+            if (state.type === 'running')
+                state = { type: 'replay' };
+            throw error;
+        }
+        state = { type: 'completed' };
+        await drainPendingQueueItems(workflowRun.runId, workflowContext.invocationsQueue, vmGlobalThis, workflowRun, 'failed', runReadyBarrier);
+        throw error;
+    };
+    const waitForExecution = async (workflowBody, interruption) => {
+        let result;
         try {
-            const result = await Promise.race([
-                workflowFn(...args),
-                workflowDiscontinuation.promise,
-            ]);
-            const dehydrated = await dehydrateWorkflowReturnValue(result, workflowRun.runId, encryptionKey, vmGlobalThis);
-            span?.setAttributes({
-                ...Attribute.WorkflowResultType(typeof result),
-            });
-            await drainPendingQueueItems(workflowRun.runId, workflowContext.invocationsQueue, vmGlobalThis, workflowRun, 'completed');
-            return dehydrated;
+            result = await Promise.race([workflowBody, interruption.promise]);
         }
-        catch (err) {
-            // Let WorkflowSuspension propagate — handled separately by the runtime
-            if (WorkflowSuspension.is(err)) {
-                throw err;
-            }
-            await drainPendingQueueItems(workflowRun.runId, workflowContext.invocationsQueue, vmGlobalThis, workflowRun, 'failed');
-            throw err;
+        catch (error) {
+            if (state.type === 'suspended' && error === state.suspension) {
+                return {
+                    type: 'suspended',
+                    suspension: state.suspension,
+                    session,
+                    // A suspension is not a settling point: the consumer for something
+                    // held may well be registered by the replay that follows this one.
+                    // So it is carried out for the span instead of being judged here.
+                    parked: eventsConsumer.parkedSummary,
+                };
+            }
+            return failWorkflow(error);
         }
-    });
+        state = { type: 'completed' };
+        // The consumer walks past events whose type carries no ordering claim and
+        // holds them for a consumer it expects a later `subscribe()` to register.
+        // The workflow function returning is the point where that expectation is
+        // settled: nothing more will subscribe, so anything still held was never
+        // anyone's, and completing here would drop it silently.
+        const stranded = eventsConsumer.strandedEvent;
+        if (stranded) {
+            return failWorkflow(new ReplayDivergenceError(`Replay finished without consuming event: eventType=${stranded.eventType}, correlationId=${stranded.correlationId}, eventId=${stranded.eventId}. ${describeDivergenceContext(stranded, workflowContext.invocationsQueue, eventsConsumer)}`, { eventId: stranded.eventId }));
+        }
+        try {
+            const output = await dehydrateWorkflowReturnValue(result, workflowRun.runId, encryptionKey, vmGlobalThis, false, 
+            // Only compression-capable runs (spec >= 5) may write compressed
+            // payloads. The serializer uses zstd when supported and may use gzip.
+            (workflowRun.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION);
+            await drainPendingQueueItems(workflowRun.runId, workflowContext.invocationsQueue, vmGlobalThis, workflowRun, 'completed', runReadyBarrier);
+            return { type: 'completed', output, resultType: typeof result };
+        }
+        catch (error) {
+            return failWorkflow(error);
+        }
+    };
+    const workflowTraceContext = await createRefreshableTraceContext();
+    const replayTrace = await startTraceSpan('workflow.replay.execute');
+    const workflowBody = workflowTraceContext.run(async () => workflowFn(...args));
+    const session = {
+        workflowRun,
+        argumentCount: args.length,
+        async resume(nextEvents) {
+            switch (state.type) {
+                case 'suspended': {
+                    // The full O(known events) prefix compare is required: the runtime
+                    // usually grows one array in place, but its wait-completion and
+                    // stale-reload paths REPLACE the array with a fresh full fetch, so
+                    // a rewritten prefix is a real input, not paranoia. The compares
+                    // are cheap string equality and dwarfed by the replay they avoid.
+                    const knownEvents = eventsConsumer.events;
+                    const isStrictExtension = nextEvents.length > knownEvents.length &&
+                        knownEvents.every((event, index) => event.eventId === nextEvents[index].eventId);
+                    if (!isStrictExtension) {
+                        state = { type: 'replay' };
+                        return { type: 'replay' };
+                    }
+                    const interruption = withResolvers();
+                    state = { type: 'running', interruption };
+                    workflowContext.suspensionGeneration++;
+                    workflowTraceContext.refresh();
+                    eventsConsumer.append(nextEvents.slice(knownEvents.length));
+                    return waitForExecution(workflowBody, interruption);
+                }
+                case 'replay':
+                    return { type: 'replay' };
+                case 'completed':
+                case 'running':
+                    throw new WorkflowRuntimeError(`Cannot resume ${state.type} workflow "${workflowRun.runId}"`);
+            }
+            state;
+        },
+    };
+    // The replay span measures the user function without becoming its ambient
+    // context. The workflow promise stays pending across retained resumes, so an
+    // active replay span here would remain captured after that span has ended.
+    const execution = waitForExecution(workflowBody, initialInterruption);
+    void execution.then(replayTrace.end, replayTrace.fail);
+    return {
+        session,
+        execution,
+    };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow.js","sourceRoot":"","sources":["../src/workflow.ts"],"names":[],"mappings":"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","sourcesContent":["import { runInContext } from 'node:vm';\nimport {\n  ERROR_SLUGS,\n  WorkflowNotRegisteredError,\n  WorkflowRuntimeError,\n} from '@workflow/errors';\nimport { withResolvers } from '@workflow/utils';\nimport { getPortLazy } from './runtime/get-port-lazy.js';\nimport { parseWorkflowName } from '@workflow/utils/parse-name';\nimport type { Event, WorkflowRun } from '@workflow/world';\nimport * as nanoid from 'nanoid';\nimport { monotonicFactory } from 'ulid';\nimport type { CryptoKey } from './encryption.js';\nimport { EventConsumerResult, EventsConsumer } from './events-consumer.js';\nimport type { QueueItem } from './global.js';\nimport { ENOTSUP, WorkflowSuspension } from './global.js';\nimport { runtimeLogger } from './logger.js';\nimport { handleSuspension } from './runtime/suspension-handler.js';\nimport { getWorld } from './runtime/world.js';\nimport type { WorkflowOrchestratorContext } from './private.js';\nimport {\n  dehydrateWorkflowReturnValue,\n  hydrateWorkflowArguments,\n} from './serialization.js';\nimport { createUseStep } from './step.js';\nimport {\n  BODY_INIT_SYMBOL,\n  STABLE_ULID,\n  WORKFLOW_CREATE_HOOK,\n  WORKFLOW_GET_STREAM_ID,\n  WORKFLOW_SLEEP,\n  WORKFLOW_USE_STEP,\n} from './symbols.js';\nimport * as Attribute from './telemetry/semantic-conventions.js';\nimport { trace } from './telemetry.js';\nimport { getWorkflowRunStreamId } from './util.js';\nimport { createContext } from './vm/index.js';\nimport type { WorkflowMetadata } from './workflow/get-workflow-metadata.js';\nimport { WORKFLOW_CONTEXT_SYMBOL } from './workflow/get-workflow-metadata.js';\nimport {\n  createAbortSignalStatics,\n  createCreateAbortController,\n} from './workflow/abort-controller.js';\nimport { createCreateHook } from './workflow/hook.js';\nimport { createSleep } from './workflow/sleep.js';\n\n/**\n * Drain pending queue items at workflow completion (success or failure).\n *\n * Treats end-of-run like a final suspension: any operation the workflow code\n * spawned but didn't `await` — abort hook resumes, hook creations/disposals,\n * sleep waits, step queueings — gets committed to the event log via the\n * suspension handler before the run is marked terminal.\n *\n * This matches normal JS semantics where `setTimeout(fn, ...)` etc. continue\n * running after the surrounding function returns. Most importantly, it ensures\n * `controller.abort()` called as the last statement of a workflow actually\n * propagates to in-flight steps on other compute instances — without this,\n * the abort hook is created but never resumed and the cancellation never\n * reaches the running step.\n *\n * Drain failures are swallowed: the workflow's own outcome (the user's return\n * value or thrown error) is the source of truth; secondary cleanup that fails\n * shouldn't change the run's terminal state.\n */\nasync function drainPendingQueueItems(\n  runId: string,\n  pendingQueue: Map<string, QueueItem>,\n  vmGlobalThis: typeof globalThis,\n  workflowRun: WorkflowRun,\n  outcome: 'completed' | 'failed'\n): Promise<void> {\n  if (pendingQueue.size === 0) return;\n  // Implicitly dispose any abort hooks (system hooks) that are still alive at\n  // workflow completion so they don't leak rows in the hooks table for the\n  // run's lifetime. Skip hooks that already have an abort in flight — those\n  // will emit hook_received via the abort processing path. User hooks\n  // (isSystem !== true) are intentionally left alone: their lifetime is\n  // managed by the user's code, not the runtime.\n  for (const item of pendingQueue.values()) {\n    if (\n      item.type === 'hook' &&\n      item.isSystem &&\n      !item.disposed &&\n      !item.abortRequested\n    ) {\n      item.disposed = true;\n    }\n  }\n  try {\n    const world = await getWorld();\n    const synthesized = new WorkflowSuspension(pendingQueue, vmGlobalThis);\n    await handleSuspension({\n      suspension: synthesized,\n      world,\n      run: workflowRun,\n    });\n  } catch (err) {\n    runtimeLogger.warn(\n      `Failed to drain pending queue items for ${outcome} workflow run`,\n      {\n        workflowRunId: runId,\n        message: err instanceof Error ? err.message : String(err),\n      }\n    );\n  }\n}\n\nexport async function runWorkflow(\n  workflowCode: string,\n  workflowRun: WorkflowRun,\n  events: Event[],\n  encryptionKey: CryptoKey | undefined\n): Promise<Uint8Array | unknown> {\n  return trace(`workflow.run ${workflowRun.workflowName}`, async (span) => {\n    span?.setAttributes({\n      ...Attribute.WorkflowName(workflowRun.workflowName),\n      ...Attribute.WorkflowRunId(workflowRun.runId),\n      ...Attribute.WorkflowRunStatus(workflowRun.status),\n      ...Attribute.WorkflowEventsCount(events.length),\n    });\n\n    const startedAt = workflowRun.startedAt;\n    if (!startedAt) {\n      throw new WorkflowRuntimeError(\n        `Workflow run \"${workflowRun.runId}\" has no \"startedAt\" timestamp (should not happen)`\n      );\n    }\n\n    // Get the port before creating VM context to avoid async operations\n    // affecting the deterministic timestamp\n    const isVercel = process.env.VERCEL_URL !== undefined;\n    // Load getPort lazily to prevent Turbopack from tracing get-port's\n    // fs ops (readdir, readFile) into the flow route bundle.\n    // Uses globalThis.__wkf_getPort as a lazy-initialized cache to avoid\n    // bundler static analysis while staying compatible with CJS/ESM/VM.\n    const port = isVercel ? undefined : await getPortLazy();\n\n    const {\n      context,\n      globalThis: vmGlobalThis,\n      updateTimestamp,\n    } = createContext({\n      seed: `${workflowRun.runId}:${workflowRun.workflowName}:${+startedAt}`,\n      fixedTimestamp: +startedAt,\n    });\n\n    const workflowDiscontinuation = withResolvers<void>();\n\n    const ulid = monotonicFactory(() => vmGlobalThis.Math.random());\n    const generateNanoid = nanoid.customRandom(nanoid.urlAlphabet, 21, (size) =>\n      new Uint8Array(size).map(() => 256 * vmGlobalThis.Math.random())\n    );\n\n    // Create a mutable holder for the promise queue so the EventsConsumer\n    // can access the current queue state via a getter. The queue is mutated\n    // by step/hook/sleep callbacks as events are processed.\n    const promiseQueueHolder = { current: Promise.resolve() };\n\n    const eventsConsumer = new EventsConsumer(events, {\n      onUnconsumedEvent: (event) => {\n        workflowDiscontinuation.reject(\n          new WorkflowRuntimeError(\n            `Unconsumed event in event log: eventType=${event.eventType}, correlationId=${event.correlationId}, eventId=${event.eventId}. This indicates a corrupted or invalid event log.`,\n            { slug: ERROR_SLUGS.CORRUPTED_EVENT_LOG }\n          )\n        );\n      },\n      getPromiseQueue: () => promiseQueueHolder.current,\n    });\n\n    const workflowContext: WorkflowOrchestratorContext = {\n      runId: workflowRun.runId,\n      encryptionKey,\n      globalThis: vmGlobalThis,\n      onWorkflowError: workflowDiscontinuation.reject,\n      eventsConsumer,\n      generateUlid: () => ulid(+startedAt),\n      generateNanoid,\n      invocationsQueue: new Map(),\n      // Use getter/setter so the EventsConsumer's getPromiseQueue() always\n      // sees the latest queue state as it's mutated by step/hook/sleep callbacks.\n      get promiseQueue() {\n        return promiseQueueHolder.current;\n      },\n      set promiseQueue(value: Promise<void>) {\n        promiseQueueHolder.current = value;\n      },\n      pendingDeliveries: 0,\n    };\n\n    // Subscribe to the events log to update the timestamp in the vm context\n    workflowContext.eventsConsumer.subscribe((event) => {\n      const createdAt = event?.createdAt;\n      if (createdAt) {\n        updateTimestamp(+createdAt);\n      }\n      // Never consume events - this is only a passive subscriber\n      return EventConsumerResult.NotConsumed;\n    });\n\n    // Consume run lifecycle events - these are structural events that don't\n    // need special handling in the workflow, but must be consumed to advance\n    // past them in the event log\n    workflowContext.eventsConsumer.subscribe((event) => {\n      if (!event) {\n        return EventConsumerResult.NotConsumed;\n      }\n\n      // Consume run_created - every run has exactly one\n      if (event.eventType === 'run_created') {\n        return EventConsumerResult.Consumed;\n      }\n\n      // Consume run_started - every run has exactly one\n      if (event.eventType === 'run_started') {\n        return EventConsumerResult.Consumed;\n      }\n\n      return EventConsumerResult.NotConsumed;\n    });\n\n    const useStep = createUseStep(workflowContext);\n    const createHook = createCreateHook(workflowContext);\n    const sleep = createSleep(workflowContext);\n\n    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n    vmGlobalThis[WORKFLOW_USE_STEP] = useStep;\n    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n    vmGlobalThis[WORKFLOW_CREATE_HOOK] = createHook;\n    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n    vmGlobalThis[WORKFLOW_SLEEP] = sleep;\n    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n    vmGlobalThis[WORKFLOW_GET_STREAM_ID] = (namespace?: string) =>\n      getWorkflowRunStreamId(workflowRun.runId, namespace);\n\n    // TODO: there should be a getUrl method on the world interface itself. This\n    // solution only works for vercel + local worlds.\n    const url = isVercel\n      ? `https://${process.env.VERCEL_URL}`\n      : `http://localhost:${port ?? 3000}`;\n\n    // For the workflow VM, we store the context in a symbol on the `globalThis` object\n    const ctx: WorkflowMetadata = {\n      workflowName: workflowRun.workflowName,\n      workflowRunId: workflowRun.runId,\n      workflowStartedAt: new vmGlobalThis.Date(+startedAt),\n      url,\n      features: { encryption: !!encryptionKey },\n    };\n\n    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n    vmGlobalThis[WORKFLOW_CONTEXT_SYMBOL] = ctx;\n    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n    vmGlobalThis[STABLE_ULID] = ulid;\n\n    // NOTE: Will have a config override to use the custom fetch step.\n    //       For now `fetch` must be explicitly imported from `workflow`.\n    vmGlobalThis.fetch = () => {\n      throw new vmGlobalThis.Error(\n        `Global \"fetch\" is unavailable in workflow functions. Use the \"fetch\" step function from \"workflow\" to make HTTP requests.\\n\\nLearn more: https://workflow-sdk.dev/err/${ERROR_SLUGS.FETCH_IN_WORKFLOW_FUNCTION}`\n      );\n    };\n\n    // Override timeout/interval functions to throw helpful errors\n    // These are not supported in workflow functions because they rely on\n    // asynchronous scheduling which breaks deterministic replay\n    const timeoutErrorMessage =\n      'Timeout functions like \"setTimeout\" and \"setInterval\" are not supported in workflow functions. Use the \"sleep\" function from \"workflow\" for time-based delays.';\n\n    (vmGlobalThis as any).setTimeout = () => {\n      throw new WorkflowRuntimeError(timeoutErrorMessage, {\n        slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,\n      });\n    };\n    (vmGlobalThis as any).setInterval = () => {\n      throw new WorkflowRuntimeError(timeoutErrorMessage, {\n        slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,\n      });\n    };\n    (vmGlobalThis as any).clearTimeout = () => {\n      throw new WorkflowRuntimeError(timeoutErrorMessage, {\n        slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,\n      });\n    };\n    (vmGlobalThis as any).clearInterval = () => {\n      throw new WorkflowRuntimeError(timeoutErrorMessage, {\n        slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,\n      });\n    };\n    (vmGlobalThis as any).setImmediate = () => {\n      throw new WorkflowRuntimeError(timeoutErrorMessage, {\n        slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,\n      });\n    };\n    (vmGlobalThis as any).clearImmediate = () => {\n      throw new WorkflowRuntimeError(timeoutErrorMessage, {\n        slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,\n      });\n    };\n\n    // `AbortController` and `AbortSignal` in the workflow VM are hook-backed\n    // for deterministic replay. The controller's abort() queues a hook resumption,\n    // and signal.aborted is updated when the hook event is processed during replay.\n    (vmGlobalThis as any).AbortController =\n      createCreateAbortController(workflowContext);\n    const abortSignalStatics = createAbortSignalStatics();\n    (vmGlobalThis as any).AbortSignal = {\n      abort: abortSignalStatics.abort,\n      any: abortSignalStatics.any,\n      timeout: abortSignalStatics.timeout,\n    };\n\n    // `Request` and `Response` are special built-in classes that invoke steps\n    // for the `json()`, `text()` and `arrayBuffer()` instance methods\n    class Request implements globalThis.Request {\n      cache!: globalThis.Request['cache'];\n      credentials!: globalThis.Request['credentials'];\n      destination!: globalThis.Request['destination'];\n      headers!: Headers;\n      integrity!: string;\n      method!: string;\n      mode!: globalThis.Request['mode'];\n      redirect!: globalThis.Request['redirect'];\n      referrer!: string;\n      referrerPolicy!: globalThis.Request['referrerPolicy'];\n      url!: string;\n      keepalive!: boolean;\n      signal!: AbortSignal;\n      duplex!: 'half';\n      body!: ReadableStream<any> | null;\n\n      constructor(input: any, init?: RequestInit) {\n        // Handle URL input\n        if (typeof input === 'string' || input instanceof vmGlobalThis.URL) {\n          const urlString = String(input);\n          // Validate URL format\n          try {\n            new vmGlobalThis.URL(urlString);\n            this.url = urlString;\n          } catch (cause) {\n            throw new TypeError(`Failed to parse URL from ${urlString}`, {\n              cause,\n            });\n          }\n        } else {\n          // Input is a Request object - clone its properties\n          this.url = input.url;\n          if (!init) {\n            this.method = input.method;\n            this.headers = new vmGlobalThis.Headers(input.headers);\n            this.body = input.body;\n            this.mode = input.mode;\n            this.credentials = input.credentials;\n            this.cache = input.cache;\n            this.redirect = input.redirect;\n            this.referrer = input.referrer;\n            this.referrerPolicy = input.referrerPolicy;\n            this.integrity = input.integrity;\n            this.keepalive = input.keepalive;\n            this.signal = input.signal;\n            this.duplex = input.duplex;\n            this.destination = input.destination;\n            return;\n          }\n          // If init is provided, merge: use source properties, then override with init\n          // Copy all properties from the source Request first\n          this.method = input.method;\n          this.headers = new vmGlobalThis.Headers(input.headers);\n          this.body = input.body;\n          this.mode = input.mode;\n          this.credentials = input.credentials;\n          this.cache = input.cache;\n          this.redirect = input.redirect;\n          this.referrer = input.referrer;\n          this.referrerPolicy = input.referrerPolicy;\n          this.integrity = input.integrity;\n          this.keepalive = input.keepalive;\n          this.signal = input.signal;\n          this.duplex = input.duplex;\n          this.destination = input.destination;\n        }\n\n        // Override with init options if provided\n        // Set method\n        if (init?.method) {\n          this.method = init.method.toUpperCase();\n        } else if (typeof this.method !== 'string') {\n          // Fallback to default for string input case\n          this.method = 'GET';\n        }\n\n        // Set headers\n        if (init?.headers) {\n          this.headers = new vmGlobalThis.Headers(init.headers);\n        } else if (\n          typeof input === 'string' ||\n          input instanceof vmGlobalThis.URL\n        ) {\n          // For string/URL input, create empty headers\n          this.headers = new vmGlobalThis.Headers();\n        }\n\n        // Set other properties with init values or defaults\n        if (init?.mode !== undefined) {\n          this.mode = init.mode;\n        } else if (typeof this.mode !== 'string') {\n          this.mode = 'cors';\n        }\n\n        if (init?.credentials !== undefined) {\n          this.credentials = init.credentials;\n        } else if (typeof this.credentials !== 'string') {\n          this.credentials = 'same-origin';\n        }\n\n        // `any` cast here because @types/node v22 does not yet have `cache`\n        if ((init as any)?.cache !== undefined) {\n          this.cache = (init as any).cache;\n        } else if (typeof this.cache !== 'string') {\n          this.cache = 'default';\n        }\n\n        if (init?.redirect !== undefined) {\n          this.redirect = init.redirect;\n        } else if (typeof this.redirect !== 'string') {\n          this.redirect = 'follow';\n        }\n\n        if (init?.referrer !== undefined) {\n          this.referrer = init.referrer;\n        } else if (typeof this.referrer !== 'string') {\n          this.referrer = 'about:client';\n        }\n\n        if (init?.referrerPolicy !== undefined) {\n          this.referrerPolicy = init.referrerPolicy;\n        } else if (typeof this.referrerPolicy !== 'string') {\n          this.referrerPolicy = '';\n        }\n\n        if (init?.integrity !== undefined) {\n          this.integrity = init.integrity;\n        } else if (typeof this.integrity !== 'string') {\n          this.integrity = '';\n        }\n\n        if (init?.keepalive !== undefined) {\n          this.keepalive = init.keepalive;\n        } else if (typeof this.keepalive !== 'boolean') {\n          this.keepalive = false;\n        }\n\n        if (init?.signal !== undefined) {\n          // @ts-expect-error - AbortSignal stub\n          this.signal = init.signal;\n        } else if (!this.signal) {\n          // @ts-expect-error - AbortSignal stub\n          this.signal = { aborted: false };\n        }\n\n        if (!this.duplex) {\n          this.duplex = 'half';\n        }\n\n        if (!this.destination) {\n          this.destination = 'document';\n        }\n\n        const body = init?.body;\n\n        // Validate that GET/HEAD methods don't have a body\n        if (\n          body !== null &&\n          body !== undefined &&\n          (this.method === 'GET' || this.method === 'HEAD')\n        ) {\n          throw new TypeError(`Request with GET/HEAD method cannot have body.`);\n        }\n\n        // Store the original BodyInit for serialization\n        if (body !== null && body !== undefined) {\n          // Create a \"fake\" ReadableStream that stores the original body\n          // This avoids doing async work during workflow replay\n          this.body = Object.create(vmGlobalThis.ReadableStream.prototype, {\n            [BODY_INIT_SYMBOL]: {\n              value: body,\n              writable: false,\n            },\n          });\n        } else {\n          this.body = null;\n        }\n      }\n\n      clone(): Request {\n        ENOTSUP();\n      }\n\n      get bodyUsed() {\n        return false;\n      }\n\n      // TODO: implement these\n      blob!: () => Promise<Blob>;\n      formData!: () => Promise<FormData>;\n\n      arrayBuffer!: () => Promise<ArrayBuffer>;\n      json!: () => Promise<any>;\n      text!: () => Promise<string>;\n\n      async bytes() {\n        return new Uint8Array(await this.arrayBuffer());\n      }\n    }\n    vmGlobalThis.Request = Request;\n\n    Object.defineProperties(Request.prototype, {\n      arrayBuffer: {\n        value: useStep<[], ArrayBuffer>('__builtin_response_array_buffer'),\n        writable: true,\n        configurable: true,\n      },\n      json: {\n        value: useStep<[], any>('__builtin_response_json'),\n        writable: true,\n        configurable: true,\n      },\n      text: {\n        value: useStep<[], string>('__builtin_response_text'),\n        writable: true,\n        configurable: true,\n      },\n    });\n\n    class Response implements globalThis.Response {\n      type!: globalThis.Response['type'];\n      url!: string;\n      status!: number;\n      statusText!: string;\n      body!: ReadableStream<Uint8Array> | null;\n      headers!: Headers;\n      redirected!: boolean;\n\n      constructor(body?: any, init?: ResponseInit) {\n        this.status = init?.status ?? 200;\n        this.statusText = init?.statusText ?? '';\n        this.headers = new vmGlobalThis.Headers(init?.headers);\n        this.type = 'default';\n        this.url = '';\n        this.redirected = false;\n\n        // Validate that null-body status codes don't have a body\n        // Per HTTP spec: 204 (No Content), 205 (Reset Content), and 304 (Not Modified)\n        if (\n          body !== null &&\n          body !== undefined &&\n          (this.status === 204 || this.status === 205 || this.status === 304)\n        ) {\n          throw new TypeError(\n            `Response constructor: Invalid response status code ${this.status}`\n          );\n        }\n\n        // Store the original BodyInit for serialization\n        if (body !== null && body !== undefined) {\n          // Create a \"fake\" ReadableStream that stores the original body\n          // This avoids doing async work during workflow replay\n          this.body = Object.create(vmGlobalThis.ReadableStream.prototype, {\n            [BODY_INIT_SYMBOL]: {\n              value: body,\n              writable: false,\n            },\n          });\n        } else {\n          this.body = null;\n        }\n      }\n\n      // TODO: implement these\n      clone!: () => Response;\n      blob!: () => Promise<globalThis.Blob>;\n      formData!: () => Promise<globalThis.FormData>;\n\n      get ok() {\n        return this.status >= 200 && this.status < 300;\n      }\n\n      get bodyUsed() {\n        return false;\n      }\n\n      arrayBuffer!: () => Promise<ArrayBuffer>;\n      json!: () => Promise<any>;\n      text!: () => Promise<string>;\n\n      async bytes() {\n        return new Uint8Array(await this.arrayBuffer());\n      }\n\n      static json(data: any, init?: ResponseInit): Response {\n        const body = JSON.stringify(data);\n        const headers = new vmGlobalThis.Headers(init?.headers);\n        if (!headers.has('content-type')) {\n          headers.set('content-type', 'application/json');\n        }\n        return new Response(body, { ...init, headers });\n      }\n\n      static error(): Response {\n        ENOTSUP();\n      }\n\n      static redirect(url: string | URL, status: number = 302): Response {\n        // Validate status code - only specific redirect codes are allowed\n        if (![301, 302, 303, 307, 308].includes(status)) {\n          throw new RangeError(\n            `Invalid redirect status code: ${status}. Must be one of: 301, 302, 303, 307, 308`\n          );\n        }\n\n        // Create response with Location header\n        const headers = new vmGlobalThis.Headers();\n        headers.set('Location', String(url));\n\n        const response = Object.create(Response.prototype);\n        response.status = status;\n        response.statusText = '';\n        response.headers = headers;\n        response.body = null;\n        response.type = 'default';\n        response.url = '';\n        response.redirected = false;\n\n        return response;\n      }\n    }\n    vmGlobalThis.Response = Response;\n\n    Object.defineProperties(Response.prototype, {\n      arrayBuffer: {\n        value: useStep<[], ArrayBuffer>('__builtin_response_array_buffer'),\n        writable: true,\n        configurable: true,\n      },\n      json: {\n        value: useStep<[], any>('__builtin_response_json'),\n        writable: true,\n        configurable: true,\n      },\n      text: {\n        value: useStep<[], string>('__builtin_response_text'),\n        writable: true,\n        configurable: true,\n      },\n    });\n\n    class ReadableStream<T> implements globalThis.ReadableStream<T> {\n      constructor() {\n        ENOTSUP();\n      }\n\n      get locked() {\n        return false;\n      }\n\n      cancel(): any {\n        ENOTSUP();\n      }\n\n      getReader(): any {\n        ENOTSUP();\n      }\n\n      pipeThrough(): any {\n        ENOTSUP();\n      }\n\n      pipeTo(): any {\n        ENOTSUP();\n      }\n\n      tee(): any {\n        ENOTSUP();\n      }\n\n      values(): any {\n        ENOTSUP();\n      }\n\n      static from(): any {\n        ENOTSUP();\n      }\n\n      [Symbol.asyncIterator](): any {\n        ENOTSUP();\n      }\n    }\n    vmGlobalThis.ReadableStream = ReadableStream;\n\n    class WritableStream<T> implements globalThis.WritableStream<T> {\n      constructor() {\n        ENOTSUP();\n      }\n\n      get locked() {\n        return false;\n      }\n\n      abort(): any {\n        ENOTSUP();\n      }\n\n      close(): any {\n        ENOTSUP();\n      }\n\n      getWriter(): any {\n        ENOTSUP();\n      }\n    }\n    vmGlobalThis.WritableStream = WritableStream;\n\n    class TransformStream<I, O> implements globalThis.TransformStream<I, O> {\n      readable: globalThis.ReadableStream<O>;\n      writable: globalThis.WritableStream<I>;\n\n      constructor() {\n        ENOTSUP();\n      }\n    }\n    vmGlobalThis.TransformStream = TransformStream;\n\n    // Eventually we'll probably want to provide our own `console` object,\n    // but for now we'll just expose the global one.\n    vmGlobalThis.console = globalThis.console;\n\n    // HACK: propagate symbol needed for AI gateway usage\n    const SYMBOL_FOR_REQ_CONTEXT = Symbol.for('@vercel/request-context');\n    // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n    vmGlobalThis[SYMBOL_FOR_REQ_CONTEXT] = (globalThis as any)[\n      SYMBOL_FOR_REQ_CONTEXT\n    ];\n\n    // Get a reference to the user-defined workflow function.\n    // The filename parameter ensures stack traces show a meaningful name\n    // (e.g., \"example/workflows/99_e2e.ts\") instead of \"evalmachine.<anonymous>\".\n    const parsedName = parseWorkflowName(workflowRun.workflowName);\n    const filename = parsedName?.moduleSpecifier || workflowRun.workflowName;\n\n    const workflowFn = runInContext(\n      `${workflowCode}; globalThis.__private_workflows?.get(${JSON.stringify(workflowRun.workflowName)})`,\n      context,\n      { filename }\n    );\n\n    if (typeof workflowFn !== 'function') {\n      throw new WorkflowNotRegisteredError(workflowRun.workflowName);\n    }\n\n    // Chain workflow argument hydration onto the promiseQueue so that the\n    // unconsumed event check (which waits for the queue to drain) doesn't\n    // fire during the async gap between run_started consumption and the\n    // workflow function subscribing its first step callbacks.\n    let args: unknown[] = [];\n    workflowContext.promiseQueue = workflowContext.promiseQueue.then(\n      async () => {\n        args = await hydrateWorkflowArguments(\n          workflowRun.input,\n          workflowRun.runId,\n          encryptionKey,\n          vmGlobalThis\n        );\n      }\n    );\n    await workflowContext.promiseQueue;\n\n    span?.setAttributes({\n      ...Attribute.WorkflowArgumentsCount(args.length),\n    });\n\n    // Invoke user workflow\n    try {\n      const result = await Promise.race([\n        workflowFn(...args),\n        workflowDiscontinuation.promise,\n      ]);\n\n      const dehydrated = await dehydrateWorkflowReturnValue(\n        result,\n        workflowRun.runId,\n        encryptionKey,\n        vmGlobalThis\n      );\n\n      span?.setAttributes({\n        ...Attribute.WorkflowResultType(typeof result),\n      });\n\n      await drainPendingQueueItems(\n        workflowRun.runId,\n        workflowContext.invocationsQueue,\n        vmGlobalThis,\n        workflowRun,\n        'completed'\n      );\n\n      return dehydrated;\n    } catch (err) {\n      // Let WorkflowSuspension propagate — handled separately by the runtime\n      if (WorkflowSuspension.is(err)) {\n        throw err;\n      }\n\n      await drainPendingQueueItems(\n        workflowRun.runId,\n        workflowContext.invocationsQueue,\n        vmGlobalThis,\n        workflowRun,\n        'failed'\n      );\n\n      throw err;\n    }\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow.js","sourceRoot":"","sources":["../src/workflow.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Script } from 'node:vm';\nimport type { Span } from '@opentelemetry/api';\nimport {\n  ERROR_SLUGS,\n  ReplayDivergenceError,\n  WorkflowNotRegisteredError,\n  WorkflowRuntimeError,\n} from '@workflow/errors';\nimport {\n  createWorkflowBaseUrl,\n  type PromiseWithResolvers,\n  withResolvers,\n} from '@workflow/utils';\nimport { parseWorkflowName } from '@workflow/utils/parse-name';\nimport type { Event, WorkflowRun, WorldCapabilities } from '@workflow/world';\nimport { SPEC_VERSION_SUPPORTS_COMPRESSION } from '@workflow/world/spec-version';\nimport * as nanoid from 'nanoid';\nimport { monotonicFactory } from 'ulid';\nimport { EventConsumerResult, EventsConsumer } from './events-consumer.js';\nimport type { QueueItem } from './global.js';\nimport { ENOTSUP, WorkflowSuspension } from './global.js';\nimport { runtimeLogger } from './logger.js';\nimport type { WorkflowOrchestratorContext } from './private.js';\nimport { isDeliveryIdle } from './private.js';\nimport { describeDivergenceContext } from './replay-divergence.js';\nimport { ReplayPayloadCache } from './replay-payload-cache.js';\nimport { getPortLazy } from './runtime/get-port-lazy.js';\nimport { runIdCreatedAt } from './runtime/run-id-time.js';\nimport { handleSuspension } from './runtime/suspension-handler.js';\nimport { getWorld } from './runtime/world.js';\nimport type { PayloadKey } from './serialization/encryption.js';\nimport {\n  dehydrateWorkflowReturnValue,\n  hydrateWorkflowArguments,\n} from './serialization.js';\nimport { createUseStep } from './step.js';\nimport {\n  BODY_INIT_SYMBOL,\n  STABLE_ULID,\n  WORKFLOW_CREATE_HOOK,\n  WORKFLOW_GET_STREAM_ID,\n  WORKFLOW_SET_ATTRIBUTES,\n  WORKFLOW_SLEEP,\n  WORKFLOW_USE_STEP,\n} from './symbols.js';\nimport * as Attribute from './telemetry/semantic-conventions.js';\nimport {\n  applyWorkflowSuspensionToSpan,\n  createRefreshableTraceContext,\n  startTraceSpan,\n  trace,\n} from './telemetry.js';\nimport { getWorkflowRunStreamId } from './util.js';\nimport { createContext } from './vm/index.js';\nimport { getCachedWorkflowScript } from './vm/script-cache.js';\nimport {\n  createAbortSignalStatics,\n  createCreateAbortController,\n} from './workflow/abort-controller.js';\nimport { createSetAttributes } from './workflow/attribute-dispatcher.js';\nimport type { WorkflowMetadata } from './workflow/get-workflow-metadata.js';\nimport { WORKFLOW_CONTEXT_SYMBOL } from './workflow/get-workflow-metadata.js';\nimport { createCreateHook } from './workflow/hook.js';\nimport { createSleep } from './workflow/sleep.js';\n\n/**\n * Drain pending queue items at workflow completion (success or failure).\n *\n * Treats completion as a final suspension so unawaited hook, wait, and\n * attribute operations are recorded before the run becomes terminal. This\n * also lets a final `controller.abort()` reach in-flight steps.\n *\n * It records `*_created` and native attribute events, but never executes step\n * bodies: `step_started` is rejected after the run becomes terminal. A\n * fire-and-forget step therefore needs a later suspension to be scheduled.\n *\n * Drain failures do not change the workflow's terminal outcome.\n */\nasync function drainPendingQueueItems(\n  runId: string,\n  pendingQueue: Map<string, QueueItem>,\n  vmGlobalThis: typeof globalThis,\n  workflowRun: WorkflowRun,\n  outcome: 'completed' | 'failed',\n  /**\n   * In turbo mode, gates final `*_created` writes on backgrounded\n   * `run_started`. Undefined when `run_started` is awaited.\n   */\n  runReadyBarrier?: Promise<unknown>\n): Promise<void> {\n  if (pendingQueue.size === 0) return;\n  // Implicitly dispose any abort hooks (system hooks) that are still alive at\n  // workflow completion so they don't leak rows in the hooks table for the\n  // run's lifetime. Skip hooks that already have an abort in flight; those\n  // will emit hook_received via the abort processing path. User hooks\n  // (isSystem !== true) are intentionally left alone: their lifetime is\n  // managed by the user's code, not the runtime.\n  for (const item of pendingQueue.values()) {\n    if (\n      item.type === 'hook' &&\n      item.isSystem &&\n      !item.disposed &&\n      !item.abortRequested\n    ) {\n      item.disposed = true;\n    }\n  }\n  try {\n    const world = await getWorld();\n    const synthesized = new WorkflowSuspension(pendingQueue, vmGlobalThis);\n    await handleSuspension({\n      suspension: synthesized,\n      world,\n      run: workflowRun,\n      runReadyBarrier,\n    });\n  } catch (err) {\n    runtimeLogger.warn(\n      `Failed to drain pending queue items for ${outcome} workflow run`,\n      {\n        workflowRunId: runId,\n        message: err instanceof Error ? err.message : String(err),\n      }\n    );\n  }\n}\n\n/** Everything needed to cold-start a workflow VM over an event log. */\ninterface WorkflowSessionOptions {\n  readonly workflowCode: string;\n  readonly workflowRun: WorkflowRun;\n  readonly events: Event[];\n  readonly encryptionKey: PayloadKey | undefined;\n  readonly replayPayloadCache: ReplayPayloadCache;\n  readonly compiledWorkflowScripts?: CompiledWorkflowScripts;\n  readonly runReadyBarrier?: Promise<unknown>;\n  readonly worldCapabilities?: WorldCapabilities;\n}\n\n/** Context-independent V8 scripts that can be evaluated in any fresh VM. */\nexport interface CompiledWorkflowScripts {\n  readonly bundleScript: Script;\n  readonly workflowLookupScript: Script;\n}\n\n/**\n * Compile the workflow bundle before its run snapshot is available.\n *\n * Compilation depends only on the route's bundle string and the workflow name\n * persisted on the run, not the event log or VM context. The runtime starts\n * this promise while `run_started` loads the replay snapshot, then evaluates\n * the scripts only after it has created the fresh context.\n */\nexport function compileWorkflowBundle(\n  workflowCode: string,\n  workflowName: string\n): Promise<CompiledWorkflowScripts> {\n  const parsedName = parseWorkflowName(workflowName);\n  const filename = parsedName?.moduleSpecifier || workflowName;\n  const workflowLookupCode = `globalThis.__private_workflows?.get(${JSON.stringify(workflowName)})`;\n\n  return trace('workflow.bundle.compile', async (span) => {\n    const bundle = getCachedWorkflowScript(workflowCode, filename);\n    const lookup = getCachedWorkflowScript(workflowLookupCode, filename);\n    span?.setAttributes({\n      // This attribute intentionally describes the workflow bundle. The tiny\n      // lookup script may miss when another workflow from the same source file\n      // runs, but that does not mean V8 recompiled the application bundle.\n      ...Attribute.WorkflowBundleCompileCacheHit(bundle.cacheHit),\n    });\n    return {\n      bundleScript: bundle.script,\n      workflowLookupScript: lookup.script,\n    };\n  });\n}\n\n/**\n * A live workflow VM, parked at a suspension boundary. `resume` advances it\n * by appending events instead of replaying from scratch.\n */\nexport interface WorkflowSession {\n  readonly workflowRun: WorkflowRun;\n  readonly argumentCount: number;\n  resume(events: Event[]): Promise<WorkflowResumeResult>;\n}\n\n/** A finished execution attempt: the workflow's output or a live boundary. */\nexport type WorkflowResult =\n  | {\n      readonly type: 'completed';\n      readonly output: unknown;\n      /** `typeof` the raw return value, for telemetry. */\n      readonly resultType: string;\n    }\n  | {\n      readonly type: 'suspended';\n      readonly suspension: WorkflowSuspension;\n      readonly session: WorkflowSession;\n      /**\n       * Events the replay walked past unclaimed and is still holding, if any.\n       * Ordinary on a suspension, and only actionable across a run's\n       * suspensions, so it is reported for telemetry rather than acted on here.\n       */\n      readonly parked?: {\n        readonly count: number;\n        readonly eventId: string;\n        readonly eventType: string;\n      };\n    };\n\n/**\n * `resume` can additionally decline: `{ type: 'replay' }` means \"this\n * session is unusable, cold-replay instead\". A fresh replay never declines.\n */\nexport type WorkflowResumeResult = WorkflowResult | { readonly type: 'replay' };\n\n/** The session's private state machine. */\ntype WorkflowSessionState =\n  | {\n      readonly type: 'running';\n      readonly interruption: PromiseWithResolvers<never>;\n    }\n  | { readonly type: 'suspended'; readonly suspension: WorkflowSuspension }\n  | { readonly type: 'replay' }\n  | { readonly type: 'completed' };\n\n/** Cold-start: build a fresh VM session and replay it over `events`. */\nexport function replayWorkflow(\n  options: WorkflowSessionOptions\n): Promise<WorkflowResult> {\n  return traceExecution(\n    'replay',\n    options.workflowRun,\n    options.events,\n    async (span) => {\n      const { session, execution } = await createWorkflowSession(options);\n      span?.setAttributes({\n        ...Attribute.WorkflowArgumentsCount(session.argumentCount),\n      });\n      return recordResult(await execution, span);\n    }\n  );\n}\n\n/** Warm-start: advance a retained session by appending events. */\nexport function resumeWorkflow(\n  session: WorkflowSession,\n  events: Event[]\n): Promise<WorkflowResumeResult> {\n  return traceExecution(\n    'retained',\n    session.workflowRun,\n    events,\n    async (span) => {\n      span?.setAttributes({\n        ...Attribute.WorkflowArgumentsCount(session.argumentCount),\n      });\n      const result = await session.resume(events);\n      return result.type === 'replay' ? result : recordResult(result, span);\n    }\n  );\n}\n\nfunction traceExecution<T>(\n  mode: 'replay' | 'retained',\n  workflowRun: WorkflowRun,\n  events: Event[],\n  fn: (span: Span | undefined) => Promise<T>\n): Promise<T> {\n  return trace(`workflow.run ${workflowRun.workflowName}`, (span) => {\n    span?.setAttributes({\n      ...Attribute.WorkflowName(workflowRun.workflowName),\n      ...Attribute.WorkflowRunId(workflowRun.runId),\n      ...Attribute.WorkflowRunStatus(workflowRun.status),\n      ...Attribute.WorkflowEventsCount(events.length),\n      ...Attribute.WorkflowExecutionMode(mode),\n    });\n    return fn(span);\n  });\n}\n\nfunction recordResult(\n  result: WorkflowResult,\n  span: Span | undefined\n): WorkflowResult {\n  if (result.type === 'completed') {\n    span?.setAttributes({\n      ...Attribute.WorkflowResultType(result.resultType),\n    });\n  } else if (span) {\n    applyWorkflowSuspensionToSpan(result.suspension, span);\n    // Events this pass walked past unclaimed and is still holding. Ordinary on\n    // a suspension: an out-of-band delivery that landed ahead of the code that\n    // reads it waits for the pass that reaches that code, and failing here\n    // would fail exactly the runs that tolerance exists for. The case that is\n    // not ordinary (the same event still held pass after pass) is a shape\n    // across these spans, which is why the eventId is on each one and no pass\n    // tries to rule on it alone.\n    if (result.parked) {\n      span.setAttributes({\n        ...Attribute.WorkflowParkedEventsCount(result.parked.count),\n        ...Attribute.WorkflowParkedEventId(result.parked.eventId),\n        ...Attribute.WorkflowParkedEventType(result.parked.eventType),\n      });\n    }\n  }\n  return result;\n}\n\n/**\n * Single-shot replay: execute the workflow over `events` and either return\n * its output or throw its suspension. Kept for the extensive existing test\n * suites; production code goes through `replayWorkflow`/`resumeWorkflow`.\n */\nexport async function runWorkflow(\n  workflowCode: string,\n  workflowRun: WorkflowRun,\n  events: Event[],\n  encryptionKey: PayloadKey | undefined,\n  /**\n   * Optional per-run cache for replay payload preparation and immutable final\n   * values. Owned by the inline execution loop for this invocation.\n   */\n  replayPayloadCache: ReplayPayloadCache = new ReplayPayloadCache(\n    encryptionKey\n  ),\n  /**\n   * Turbo mode only: resolves once the backgrounded `run_started` has landed.\n   * Threaded into the end-of-run drain so fire-and-forget `*_created` writes\n   * committed at workflow completion order after the run's creation. Undefined\n   * outside turbo, where `run_started` is awaited up front.\n   */\n  runReadyBarrier?: Promise<unknown>,\n  /**\n   * Features supported by the World executing this workflow. Missing\n   * capabilities are treated as unsupported.\n   */\n  worldCapabilities?: WorldCapabilities\n): Promise<Uint8Array | unknown> {\n  const result = await replayWorkflow({\n    workflowCode,\n    workflowRun,\n    events,\n    encryptionKey,\n    replayPayloadCache,\n    runReadyBarrier,\n    worldCapabilities,\n  });\n  if (result.type === 'suspended') throw result.suspension;\n  return result.output;\n}\n\nasync function createWorkflowSession(options: WorkflowSessionOptions) {\n  const vmTrace = await startTraceSpan('workflow.vm.create_context');\n  return createWorkflowSessionInner(options, vmTrace.end).catch((error) => {\n    vmTrace.fail(error);\n    throw error;\n  });\n}\n\nasync function createWorkflowSessionInner(\n  {\n    workflowCode,\n    workflowRun,\n    events,\n    encryptionKey,\n    replayPayloadCache,\n    compiledWorkflowScripts,\n    runReadyBarrier,\n    worldCapabilities,\n  }: WorkflowSessionOptions,\n  endVmTrace: () => void\n): Promise<{\n  session: WorkflowSession;\n  execution: Promise<WorkflowResult>;\n}> {\n  const startedAt = workflowRun.startedAt;\n  if (!startedAt) {\n    throw new WorkflowRuntimeError(\n      `Workflow run \"${workflowRun.runId}\" has no \"startedAt\" timestamp (should not happen)`\n    );\n  }\n\n  // Seed and initial clock must be available before I/O and remain stable on\n  // replay. After the first event, EventsConsumer advances the VM clock from\n  // each event's `createdAt`.\n  const fixedTimestamp =\n    runIdCreatedAt(workflowRun.runId) ?? +workflowRun.createdAt;\n\n  // Truthiness, not presence: `vercel env pull` writes `VERCEL_URL=\"\"` into\n  // `.env.local`, and a framework that loads that file locally would otherwise\n  // put us on the Vercel branch with nothing to build a host from, making\n  // `https://` the base URL of every run.\n  const isVercel = Boolean(process.env.VERCEL_URL);\n  // Load getPort lazily to prevent Turbopack from tracing get-port's\n  // fs ops (readdir, readFile) into the flow route bundle. The resolved\n  // port is cached per process (see get-port-lazy.ts), so this is cheap\n  // on replays after the first.\n  const workflowBaseUrl = createWorkflowBaseUrl(\n    isVercel\n      ? `https://${process.env.VERCEL_URL}`\n      : `http://localhost:${(await getPortLazy()) ?? 3000}`\n  );\n  // Include both node:vm's context creation and the host-side sandbox wiring\n  // below. Most of the bootstrap lives in this function (EventsConsumer,\n  // workflow globals, Web API shims), so tracing createContext() alone would\n  // materially under-report VM startup.\n  const {\n    context,\n    globalThis: vmGlobalThis,\n    updateTimestamp,\n  } = createContext({\n    seed: `${workflowRun.runId}:${workflowRun.workflowName}:${workflowRun.deploymentId}`,\n    fixedTimestamp,\n  });\n\n  const initialInterruption = withResolvers<never>();\n  let state: WorkflowSessionState = {\n    type: 'running',\n    interruption: initialInterruption,\n  };\n\n  const onWorkflowError = (error: Error): void => {\n    switch (state.type) {\n      case 'running': {\n        const { interruption } = state;\n        state = WorkflowSuspension.is(error)\n          ? { type: 'suspended', suspension: error }\n          : { type: 'replay' };\n        // Step, hook, wait, and attribute consumers can schedule the same\n        // suspension. The first signal advances the generation so the rest\n        // no-op.\n        workflowContext.suspensionGeneration++;\n        interruption.reject(error);\n        return;\n      }\n      case 'suspended':\n        // Same-boundary duplicates were staled by the generation bump above,\n        // so anything landing here is out-of-band or a divergence. Fall back\n        // to replay rather than resuming a potentially inconsistent session.\n        state = { type: 'replay' };\n        return;\n      case 'replay':\n      case 'completed':\n        return;\n    }\n    state satisfies never;\n  };\n\n  const ulid = monotonicFactory(() => vmGlobalThis.Math.random());\n  // Correlation IDs must be replay-stable. `startedAt` differs between a turbo\n  // delivery and a later server-backed replay, so use fixedTimestamp.\n  // The draw counter is the progress metric for `quiesceEarlierCascades`\n  // (WORKFLOW_LOG_ORDER_DRAWS): a quiet turn is one that drew nothing. It\n  // counts EVERY draw from this sequence. This same function is installed as\n  // the `STABLE_ULID` global below, which serialization draws stream ids\n  // from during dehydration. This is deliberate because quiescence must also\n  // wait out serialization-driven draws, and counting extra draws only extends\n  // the wait (see the termination note on `quiesceEarlierCascades`).\n  let mintCount = 0;\n  const generateUlid = () => {\n    mintCount += 1;\n    return ulid(fixedTimestamp);\n  };\n  const generateNanoid = nanoid.customRandom(nanoid.urlAlphabet, 21, (size) =>\n    new Uint8Array(size).map(() => 256 * vmGlobalThis.Math.random())\n  );\n\n  // Create a mutable holder for the promise queue so the EventsConsumer\n  // can access the current queue state via a getter. The queue is mutated\n  // by step/hook/sleep callbacks as events are processed.\n  const promiseQueueHolder = { current: Promise.resolve() };\n\n  // Same reason as the queue holder: the consumer is built before the context\n  // whose delivery state it has to read. Idle until the context exists, which\n  // is before any delivery can be registered against it.\n  const deliveryIdleHolder = { current: (): boolean => true };\n\n  // The VM clock only ever moves forward. Consumption order is log order for\n  // everything whose order the replay decides, but an event the consumer\n  // parked is delivered after the walk has already passed events written after\n  // it, and letting its `createdAt` set the clock would make `Date.now()` go\n  // backwards inside a single replay.\n  let clock = fixedTimestamp;\n\n  const eventsConsumer = new EventsConsumer(events, {\n    onConsumedEvent: (event) => {\n      const at = +event.createdAt;\n      if (at > clock) {\n        clock = at;\n        updateTimestamp(at);\n      }\n    },\n    onUnconsumedEvent: (event) => {\n      // `workflowContext` is assigned below, before any event can be offered,\n      // so it is always populated by the time this fires. The appended detail\n      // names the pending invocation that holds this event's ordinal (the\n      // usual reason nobody can consume it) and where the walk stands.\n      onWorkflowError(\n        new ReplayDivergenceError(\n          `Replay could not consume event: eventType=${event.eventType}, correlationId=${event.correlationId}, eventId=${event.eventId}. ${describeDivergenceContext(event, workflowContext.invocationsQueue, eventsConsumer)}`,\n          { eventId: event.eventId }\n        )\n      );\n    },\n    // Both branches log at `debug`, so neither reaches the console unless\n    // `DEBUG` matches. A duplicate is a permanent feature of the log: every\n    // later replay re-reads it and lands here again, so anything the logger\n    // prints unconditionally would print once per replay for the life of the\n    // run. There is also nothing to act on. Ignoring the event is the correct\n    // outcome, not a degraded one, and no user change makes the straggler go\n    // away. What the levels are for is diagnosis after the fact, which is\n    // exactly what `DEBUG=workflow:runtime:debug` is for.\n    onDuplicateEvent: (event, firstEventType) => {\n      const details = {\n        workflowRunId: workflowRun.runId,\n        eventId: event.eventId,\n        eventType: event.eventType,\n        firstEventType,\n        correlationId: event.correlationId,\n      };\n      if (firstEventType !== event.eventType) {\n        // Two writers reached opposite conclusions about one entity: a\n        // `step_failed` behind a `step_completed`, or the reverse. Ignoring it\n        // is still correct and still deterministic (replay reads the first one\n        // at the same position every time), but unlike a re-commit of the same\n        // outcome there is no reading of this where both writers were right,\n        // so the discarded outcome gets its own message.\n        runtimeLogger.debug(\n          'Ignoring inert event that decides an already-decided outcome differently',\n          details\n        );\n        return;\n      }\n      // The first event of this class decided the outcome at a lower log\n      // position and replay reads that one. Recorded because a straggler is\n      // still evidence of two replays writing for the same entity, which is\n      // worth seeing when diagnosing a run.\n      runtimeLogger.debug(\n        'Ignoring inert event that repeats a class already in the event log',\n        details\n      );\n    },\n    getPromiseQueue: () => promiseQueueHolder.current,\n    isDeliveryIdle: () => deliveryIdleHolder.current(),\n  });\n\n  const workflowContext: WorkflowOrchestratorContext = {\n    runId: workflowRun.runId,\n    encryptionKey,\n    worldCapabilities,\n    globalThis: vmGlobalThis,\n    onWorkflowError,\n    eventsConsumer,\n    generateUlid,\n    generateNanoid,\n    get mintCount() {\n      return mintCount;\n    },\n    invocationsQueue: new Map(),\n    // Use getter/setter so the EventsConsumer's getPromiseQueue() always\n    // sees the latest queue state as it's mutated by step/hook/sleep callbacks.\n    get promiseQueue() {\n      return promiseQueueHolder.current;\n    },\n    set promiseQueue(value: Promise<void>) {\n      promiseQueueHolder.current = value;\n    },\n    pendingDeliveries: 0,\n    suspensionGeneration: 0,\n    pendingDeliveryBarriers: new Map(),\n    replayPayloadCache,\n  };\n\n  deliveryIdleHolder.current = () => isDeliveryIdle(workflowContext);\n\n  // Consume run lifecycle events - these are structural events that don't\n  // need special handling in the workflow, but must be consumed to advance\n  // past them in the event log\n  let consumedRunStarted = false;\n  workflowContext.eventsConsumer.subscribe((event) => {\n    if (!event) {\n      return EventConsumerResult.NotConsumed;\n    }\n\n    // Consume run_created - every run has exactly one\n    if (event.eventType === 'run_created') {\n      return EventConsumerResult.Consumed;\n    }\n\n    // Consume the first run_started. Two replays can each write one (the\n    // create is idempotent for a run already running, which makes the write\n    // safe, not single-shot); the first is the one the replay observes, and\n    // the consumer skips the rest rather than advancing the workflow clock\n    // twice.\n    if (event.eventType === 'run_started') {\n      if (consumedRunStarted) {\n        return EventConsumerResult.NotConsumed;\n      }\n      consumedRunStarted = true;\n      return EventConsumerResult.Consumed;\n    }\n\n    // Attribute writes performed from a step have no workflow-body call to\n    // consume them during replay; they are already reflected in the run\n    // snapshot and remain structural until a read API is introduced.\n    if (\n      event.eventType === 'attr_set' &&\n      event.eventData.writer.type === 'step'\n    ) {\n      return EventConsumerResult.Consumed;\n    }\n\n    return EventConsumerResult.NotConsumed;\n  });\n\n  const useStep = createUseStep(workflowContext);\n  const createHook = createCreateHook(workflowContext);\n  const sleep = createSleep(workflowContext);\n  const setAttributes = createSetAttributes(workflowContext);\n\n  // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n  vmGlobalThis[WORKFLOW_USE_STEP] = useStep;\n  // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n  vmGlobalThis[WORKFLOW_SET_ATTRIBUTES] = setAttributes;\n  // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n  vmGlobalThis[WORKFLOW_CREATE_HOOK] = createHook;\n  // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n  vmGlobalThis[WORKFLOW_SLEEP] = sleep;\n  // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n  vmGlobalThis[WORKFLOW_GET_STREAM_ID] = (namespace?: string) =>\n    getWorkflowRunStreamId(workflowRun.runId, namespace);\n\n  // For the workflow VM, we store the context in a symbol on the `globalThis` object\n  const ctx: WorkflowMetadata = {\n    workflowName: workflowRun.workflowName,\n    workflowRunId: workflowRun.runId,\n    workflowStartedAt: new vmGlobalThis.Date(+startedAt),\n    url: workflowBaseUrl,\n    features: { encryption: !!encryptionKey },\n  };\n\n  // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n  vmGlobalThis[WORKFLOW_CONTEXT_SYMBOL] = ctx;\n  // Serialization mints stream ids through this symbol, and calls it with no\n  // seed time. `monotonicFactory` returns `encodeTime(lastTime)` on its\n  // increment branch, so one such call latches the *host* wall clock into\n  // `lastTime`, and every id the run mints afterwards carries that timestamp\n  // instead of `fixedTimestamp`, a value that differs on every replay. Binding\n  // the seed time here keeps the whole run on one replay-stable clock.\n  // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n  vmGlobalThis[STABLE_ULID] = generateUlid;\n\n  // Workflow code must import the deterministic `fetch` step from `workflow`.\n  vmGlobalThis.fetch = () => {\n    throw new vmGlobalThis.Error(\n      `Global \"fetch\" is unavailable in workflow functions. Use the \"fetch\" step function from \"workflow\" to make HTTP requests.\\n\\nLearn more: https://workflow-sdk.dev/err/${ERROR_SLUGS.FETCH_IN_WORKFLOW_FUNCTION}`\n    );\n  };\n\n  // Override timeout/interval functions to throw helpful errors\n  // These are not supported in workflow functions because they rely on\n  // asynchronous scheduling which breaks deterministic replay\n  const timeoutErrorMessage =\n    'Timeout functions like \"setTimeout\" and \"setInterval\" are not supported in workflow functions. Use the \"sleep\" function from \"workflow\" for time-based delays.';\n\n  (vmGlobalThis as any).setTimeout = () => {\n    throw new WorkflowRuntimeError(timeoutErrorMessage, {\n      slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,\n    });\n  };\n  (vmGlobalThis as any).setInterval = () => {\n    throw new WorkflowRuntimeError(timeoutErrorMessage, {\n      slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,\n    });\n  };\n  (vmGlobalThis as any).clearTimeout = () => {\n    throw new WorkflowRuntimeError(timeoutErrorMessage, {\n      slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,\n    });\n  };\n  (vmGlobalThis as any).clearInterval = () => {\n    throw new WorkflowRuntimeError(timeoutErrorMessage, {\n      slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,\n    });\n  };\n  (vmGlobalThis as any).setImmediate = () => {\n    throw new WorkflowRuntimeError(timeoutErrorMessage, {\n      slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,\n    });\n  };\n  (vmGlobalThis as any).clearImmediate = () => {\n    throw new WorkflowRuntimeError(timeoutErrorMessage, {\n      slug: ERROR_SLUGS.TIMEOUT_FUNCTIONS_IN_WORKFLOW,\n    });\n  };\n\n  // `AbortController` and `AbortSignal` in the workflow VM are hook-backed\n  // for deterministic replay. The controller's abort() queues a hook resumption,\n  // and signal.aborted is updated when the hook event is processed during replay.\n  (vmGlobalThis as any).AbortController =\n    createCreateAbortController(workflowContext);\n  const abortSignalStatics = createAbortSignalStatics();\n  (vmGlobalThis as any).AbortSignal = {\n    abort: abortSignalStatics.abort,\n    any: abortSignalStatics.any,\n    timeout: abortSignalStatics.timeout,\n  };\n\n  // `Request` and `Response` are special built-in classes that invoke steps\n  // for the `json()`, `text()` and `arrayBuffer()` instance methods\n  class Request implements globalThis.Request {\n    cache!: globalThis.Request['cache'];\n    credentials!: globalThis.Request['credentials'];\n    destination!: globalThis.Request['destination'];\n    headers!: Headers;\n    integrity!: string;\n    method!: string;\n    mode!: globalThis.Request['mode'];\n    redirect!: globalThis.Request['redirect'];\n    referrer!: string;\n    referrerPolicy!: globalThis.Request['referrerPolicy'];\n    url!: string;\n    keepalive!: boolean;\n    signal!: AbortSignal;\n    duplex!: 'half';\n    body!: ReadableStream<any> | null;\n\n    constructor(input: any, init?: RequestInit) {\n      // Handle URL input\n      if (typeof input === 'string' || input instanceof vmGlobalThis.URL) {\n        const urlString = String(input);\n        // Validate URL format\n        try {\n          new vmGlobalThis.URL(urlString);\n          this.url = urlString;\n        } catch (cause) {\n          throw new TypeError(`Failed to parse URL from ${urlString}`, {\n            cause,\n          });\n        }\n      } else {\n        // Input is a Request object - clone its properties\n        this.url = input.url;\n        if (!init) {\n          this.method = input.method;\n          this.headers = new vmGlobalThis.Headers(input.headers);\n          this.body = input.body;\n          this.mode = input.mode;\n          this.credentials = input.credentials;\n          this.cache = input.cache;\n          this.redirect = input.redirect;\n          this.referrer = input.referrer;\n          this.referrerPolicy = input.referrerPolicy;\n          this.integrity = input.integrity;\n          this.keepalive = input.keepalive;\n          this.signal = input.signal;\n          this.duplex = input.duplex;\n          this.destination = input.destination;\n          return;\n        }\n        // If init is provided, merge: use source properties, then override with init\n        // Copy all properties from the source Request first\n        this.method = input.method;\n        this.headers = new vmGlobalThis.Headers(input.headers);\n        this.body = input.body;\n        this.mode = input.mode;\n        this.credentials = input.credentials;\n        this.cache = input.cache;\n        this.redirect = input.redirect;\n        this.referrer = input.referrer;\n        this.referrerPolicy = input.referrerPolicy;\n        this.integrity = input.integrity;\n        this.keepalive = input.keepalive;\n        this.signal = input.signal;\n        this.duplex = input.duplex;\n        this.destination = input.destination;\n      }\n\n      // Override with init options if provided\n      // Set method\n      if (init?.method) {\n        this.method = init.method.toUpperCase();\n      } else if (typeof this.method !== 'string') {\n        // Fallback to default for string input case\n        this.method = 'GET';\n      }\n\n      // Set headers\n      if (init?.headers) {\n        this.headers = new vmGlobalThis.Headers(init.headers);\n      } else if (\n        typeof input === 'string' ||\n        input instanceof vmGlobalThis.URL\n      ) {\n        // For string/URL input, create empty headers\n        this.headers = new vmGlobalThis.Headers();\n      }\n\n      // Set other properties with init values or defaults\n      if (init?.mode !== undefined) {\n        this.mode = init.mode;\n      } else if (typeof this.mode !== 'string') {\n        this.mode = 'cors';\n      }\n\n      if (init?.credentials !== undefined) {\n        this.credentials = init.credentials;\n      } else if (typeof this.credentials !== 'string') {\n        this.credentials = 'same-origin';\n      }\n\n      // `any` cast here because @types/node v22 does not yet have `cache`\n      if ((init as any)?.cache !== undefined) {\n        this.cache = (init as any).cache;\n      } else if (typeof this.cache !== 'string') {\n        this.cache = 'default';\n      }\n\n      if (init?.redirect !== undefined) {\n        this.redirect = init.redirect;\n      } else if (typeof this.redirect !== 'string') {\n        this.redirect = 'follow';\n      }\n\n      if (init?.referrer !== undefined) {\n        this.referrer = init.referrer;\n      } else if (typeof this.referrer !== 'string') {\n        this.referrer = 'about:client';\n      }\n\n      if (init?.referrerPolicy !== undefined) {\n        this.referrerPolicy = init.referrerPolicy;\n      } else if (typeof this.referrerPolicy !== 'string') {\n        this.referrerPolicy = '';\n      }\n\n      if (init?.integrity !== undefined) {\n        this.integrity = init.integrity;\n      } else if (typeof this.integrity !== 'string') {\n        this.integrity = '';\n      }\n\n      if (init?.keepalive !== undefined) {\n        this.keepalive = init.keepalive;\n      } else if (typeof this.keepalive !== 'boolean') {\n        this.keepalive = false;\n      }\n\n      if (init?.signal !== undefined) {\n        // @ts-expect-error - AbortSignal stub\n        this.signal = init.signal;\n      } else if (!this.signal) {\n        // @ts-expect-error - AbortSignal stub\n        this.signal = { aborted: false };\n      }\n\n      if (!this.duplex) {\n        this.duplex = 'half';\n      }\n\n      if (!this.destination) {\n        this.destination = 'document';\n      }\n\n      const body = init?.body;\n\n      // Validate that GET/HEAD methods don't have a body\n      if (\n        body !== null &&\n        body !== undefined &&\n        (this.method === 'GET' || this.method === 'HEAD')\n      ) {\n        throw new TypeError(`Request with GET/HEAD method cannot have body.`);\n      }\n\n      // Store the original BodyInit for serialization\n      if (body !== null && body !== undefined) {\n        // Create a \"fake\" ReadableStream that stores the original body\n        // This avoids doing async work during workflow replay\n        this.body = Object.create(vmGlobalThis.ReadableStream.prototype, {\n          [BODY_INIT_SYMBOL]: {\n            value: body,\n            writable: false,\n          },\n        });\n      } else {\n        this.body = null;\n      }\n    }\n\n    clone(): Request {\n      ENOTSUP();\n    }\n\n    get bodyUsed() {\n      return false;\n    }\n\n    // TODO: implement these\n    blob!: () => Promise<Blob>;\n    formData!: () => Promise<FormData>;\n\n    arrayBuffer!: () => Promise<ArrayBuffer>;\n    json!: () => Promise<any>;\n    text!: () => Promise<string>;\n\n    async bytes() {\n      return new Uint8Array(await this.arrayBuffer());\n    }\n  }\n  vmGlobalThis.Request = Request;\n\n  Object.defineProperties(Request.prototype, {\n    arrayBuffer: {\n      value: useStep<[], ArrayBuffer>('__builtin_response_array_buffer'),\n      writable: true,\n      configurable: true,\n    },\n    json: {\n      value: useStep<[], any>('__builtin_response_json'),\n      writable: true,\n      configurable: true,\n    },\n    text: {\n      value: useStep<[], string>('__builtin_response_text'),\n      writable: true,\n      configurable: true,\n    },\n  });\n\n  class Response implements globalThis.Response {\n    type!: globalThis.Response['type'];\n    url!: string;\n    status!: number;\n    statusText!: string;\n    body!: ReadableStream<Uint8Array> | null;\n    headers!: Headers;\n    redirected!: boolean;\n\n    constructor(body?: any, init?: ResponseInit) {\n      this.status = init?.status ?? 200;\n      this.statusText = init?.statusText ?? '';\n      this.headers = new vmGlobalThis.Headers(init?.headers);\n      this.type = 'default';\n      this.url = '';\n      this.redirected = false;\n\n      // Validate that null-body status codes don't have a body\n      // Per HTTP spec: 204 (No Content), 205 (Reset Content), and 304 (Not Modified)\n      if (\n        body !== null &&\n        body !== undefined &&\n        (this.status === 204 || this.status === 205 || this.status === 304)\n      ) {\n        throw new TypeError(\n          `Response constructor: Invalid response status code ${this.status}`\n        );\n      }\n\n      // Store the original BodyInit for serialization\n      if (body !== null && body !== undefined) {\n        // Create a \"fake\" ReadableStream that stores the original body\n        // This avoids doing async work during workflow replay\n        this.body = Object.create(vmGlobalThis.ReadableStream.prototype, {\n          [BODY_INIT_SYMBOL]: {\n            value: body,\n            writable: false,\n          },\n        });\n      } else {\n        this.body = null;\n      }\n    }\n\n    // TODO: implement these\n    clone!: () => Response;\n    blob!: () => Promise<globalThis.Blob>;\n    formData!: () => Promise<globalThis.FormData>;\n\n    get ok() {\n      return this.status >= 200 && this.status < 300;\n    }\n\n    get bodyUsed() {\n      return false;\n    }\n\n    arrayBuffer!: () => Promise<ArrayBuffer>;\n    json!: () => Promise<any>;\n    text!: () => Promise<string>;\n\n    async bytes() {\n      return new Uint8Array(await this.arrayBuffer());\n    }\n\n    static json(data: any, init?: ResponseInit): Response {\n      const body = JSON.stringify(data);\n      const headers = new vmGlobalThis.Headers(init?.headers);\n      if (!headers.has('content-type')) {\n        headers.set('content-type', 'application/json');\n      }\n      return new Response(body, { ...init, headers });\n    }\n\n    static error(): Response {\n      ENOTSUP();\n    }\n\n    static redirect(url: string | URL, status: number = 302): Response {\n      // Validate status code - only specific redirect codes are allowed\n      if (![301, 302, 303, 307, 308].includes(status)) {\n        throw new RangeError(\n          `Invalid redirect status code: ${status}. Must be one of: 301, 302, 303, 307, 308`\n        );\n      }\n\n      // Create response with Location header\n      const headers = new vmGlobalThis.Headers();\n      headers.set('Location', String(url));\n\n      const response = Object.create(Response.prototype);\n      response.status = status;\n      response.statusText = '';\n      response.headers = headers;\n      response.body = null;\n      response.type = 'default';\n      response.url = '';\n      response.redirected = false;\n\n      return response;\n    }\n  }\n  vmGlobalThis.Response = Response;\n\n  Object.defineProperties(Response.prototype, {\n    arrayBuffer: {\n      value: useStep<[], ArrayBuffer>('__builtin_response_array_buffer'),\n      writable: true,\n      configurable: true,\n    },\n    json: {\n      value: useStep<[], any>('__builtin_response_json'),\n      writable: true,\n      configurable: true,\n    },\n    text: {\n      value: useStep<[], string>('__builtin_response_text'),\n      writable: true,\n      configurable: true,\n    },\n  });\n\n  class ReadableStream<T> implements globalThis.ReadableStream<T> {\n    constructor() {\n      ENOTSUP();\n    }\n\n    get locked() {\n      return false;\n    }\n\n    cancel(): any {\n      ENOTSUP();\n    }\n\n    getReader(): any {\n      ENOTSUP();\n    }\n\n    pipeThrough(): any {\n      ENOTSUP();\n    }\n\n    pipeTo(): any {\n      ENOTSUP();\n    }\n\n    tee(): any {\n      ENOTSUP();\n    }\n\n    values(): any {\n      ENOTSUP();\n    }\n\n    static from(): any {\n      ENOTSUP();\n    }\n\n    [Symbol.asyncIterator](): any {\n      ENOTSUP();\n    }\n  }\n  vmGlobalThis.ReadableStream = ReadableStream;\n\n  class WritableStream<T> implements globalThis.WritableStream<T> {\n    constructor() {\n      ENOTSUP();\n    }\n\n    get locked() {\n      return false;\n    }\n\n    abort(): any {\n      ENOTSUP();\n    }\n\n    close(): any {\n      ENOTSUP();\n    }\n\n    getWriter(): any {\n      ENOTSUP();\n    }\n  }\n  vmGlobalThis.WritableStream = WritableStream;\n\n  class TransformStream<I, O> implements globalThis.TransformStream<I, O> {\n    readable: globalThis.ReadableStream<O>;\n    writable: globalThis.WritableStream<I>;\n\n    constructor() {\n      ENOTSUP();\n    }\n  }\n  vmGlobalThis.TransformStream = TransformStream;\n\n  vmGlobalThis.console = globalThis.console;\n\n  // Expose the request-context symbol required by AI Gateway.\n  const SYMBOL_FOR_REQ_CONTEXT = Symbol.for('@vercel/request-context');\n  // @ts-expect-error - `@types/node` says symbol is not valid, but it does work\n  vmGlobalThis[SYMBOL_FOR_REQ_CONTEXT] = (globalThis as any)[\n    SYMBOL_FOR_REQ_CONTEXT\n  ];\n  endVmTrace();\n\n  // Reuse compiled scripts by `(code, filename)`: compilation is deterministic\n  // and the filename preserves workflow source attribution in stack traces.\n  // The bundle registers workflows on `globalThis.__private_workflows`.\n  const { bundleScript, workflowLookupScript } =\n    compiledWorkflowScripts ??\n    (await compileWorkflowBundle(workflowCode, workflowRun.workflowName));\n  const workflowFn = await trace('workflow.bundle.evaluate', async () => {\n    bundleScript.runInContext(context);\n    return workflowLookupScript.runInContext(context);\n  });\n\n  if (typeof workflowFn !== 'function') {\n    throw new WorkflowNotRegisteredError(workflowRun.workflowName);\n  }\n\n  // Chain workflow argument hydration onto the promiseQueue so that the\n  // unconsumed event check (which waits for the queue to drain) doesn't\n  // fire during the async gap between run_started consumption and the\n  // workflow function subscribing its first step callbacks.\n  let args: unknown[] = [];\n  workflowContext.promiseQueue = workflowContext.promiseQueue.then(async () => {\n    // Include any residual payload preparation plus VM-local deserialization\n    // in the blocking boundary.\n    args = await trace('workflow.input.hydrate', async () => {\n      const prepared =\n        await replayPayloadCache.prepareWorkflowInput(workflowRun);\n      return hydrateWorkflowArguments(\n        workflowRun.input,\n        workflowRun.runId,\n        encryptionKey,\n        vmGlobalThis,\n        {},\n        prepared\n      );\n    });\n  });\n  await workflowContext.promiseQueue;\n\n  const failWorkflow = async (error: unknown): Promise<never> => {\n    // Control-flow signals are handled by the runtime and do not mean the\n    // workflow has terminally failed. `onWorkflowError` usually already moved\n    // the state machine, but a divergence can also arrive via a step\n    // promise's direct rejection (bypassing `onWorkflowError`); demote so\n    // every control-flow path converges on `replay` and a later resume falls\n    // back instead of throwing.\n    if (WorkflowSuspension.is(error) || ReplayDivergenceError.is(error)) {\n      if (state.type === 'running') state = { type: 'replay' };\n      throw error;\n    }\n    state = { type: 'completed' };\n\n    await drainPendingQueueItems(\n      workflowRun.runId,\n      workflowContext.invocationsQueue,\n      vmGlobalThis,\n      workflowRun,\n      'failed',\n      runReadyBarrier\n    );\n\n    throw error;\n  };\n\n  const waitForExecution = async (\n    workflowBody: Promise<unknown>,\n    interruption: PromiseWithResolvers<never>\n  ): Promise<WorkflowResult> => {\n    let result: unknown;\n    try {\n      result = await Promise.race([workflowBody, interruption.promise]);\n    } catch (error) {\n      if (state.type === 'suspended' && error === state.suspension) {\n        return {\n          type: 'suspended',\n          suspension: state.suspension,\n          session,\n          // A suspension is not a settling point: the consumer for something\n          // held may well be registered by the replay that follows this one.\n          // So it is carried out for the span instead of being judged here.\n          parked: eventsConsumer.parkedSummary,\n        };\n      }\n      return failWorkflow(error);\n    }\n\n    state = { type: 'completed' };\n    // The consumer walks past events whose type carries no ordering claim and\n    // holds them for a consumer it expects a later `subscribe()` to register.\n    // The workflow function returning is the point where that expectation is\n    // settled: nothing more will subscribe, so anything still held was never\n    // anyone's, and completing here would drop it silently.\n    const stranded = eventsConsumer.strandedEvent;\n    if (stranded) {\n      return failWorkflow(\n        new ReplayDivergenceError(\n          `Replay finished without consuming event: eventType=${stranded.eventType}, correlationId=${stranded.correlationId}, eventId=${stranded.eventId}. ${describeDivergenceContext(stranded, workflowContext.invocationsQueue, eventsConsumer)}`,\n          { eventId: stranded.eventId }\n        )\n      );\n    }\n    try {\n      const output = await dehydrateWorkflowReturnValue(\n        result,\n        workflowRun.runId,\n        encryptionKey,\n        vmGlobalThis,\n        false,\n        // Only compression-capable runs (spec >= 5) may write compressed\n        // payloads. The serializer uses zstd when supported and may use gzip.\n        (workflowRun.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION\n      );\n\n      await drainPendingQueueItems(\n        workflowRun.runId,\n        workflowContext.invocationsQueue,\n        vmGlobalThis,\n        workflowRun,\n        'completed',\n        runReadyBarrier\n      );\n\n      return { type: 'completed', output, resultType: typeof result };\n    } catch (error) {\n      return failWorkflow(error);\n    }\n  };\n\n  const workflowTraceContext = await createRefreshableTraceContext();\n  const replayTrace = await startTraceSpan('workflow.replay.execute');\n  const workflowBody = workflowTraceContext.run(async () =>\n    workflowFn(...args)\n  );\n\n  const session: WorkflowSession = {\n    workflowRun,\n    argumentCount: args.length,\n    async resume(nextEvents) {\n      switch (state.type) {\n        case 'suspended': {\n          // The full O(known events) prefix compare is required: the runtime\n          // usually grows one array in place, but its wait-completion and\n          // stale-reload paths REPLACE the array with a fresh full fetch, so\n          // a rewritten prefix is a real input, not paranoia. The compares\n          // are cheap string equality and dwarfed by the replay they avoid.\n          const knownEvents = eventsConsumer.events;\n          const isStrictExtension =\n            nextEvents.length > knownEvents.length &&\n            knownEvents.every(\n              (event, index) => event.eventId === nextEvents[index].eventId\n            );\n          if (!isStrictExtension) {\n            state = { type: 'replay' };\n            return { type: 'replay' };\n          }\n          const interruption = withResolvers<never>();\n          state = { type: 'running', interruption };\n          workflowContext.suspensionGeneration++;\n          workflowTraceContext.refresh();\n          eventsConsumer.append(nextEvents.slice(knownEvents.length));\n          return waitForExecution(workflowBody, interruption);\n        }\n        case 'replay':\n          return { type: 'replay' };\n        case 'completed':\n        case 'running':\n          throw new WorkflowRuntimeError(\n            `Cannot resume ${state.type} workflow \"${workflowRun.runId}\"`\n          );\n      }\n      state satisfies never;\n    },\n  };\n\n  // The replay span measures the user function without becoming its ambient\n  // context. The workflow promise stays pending across retained resumes, so an\n  // active replay span here would remain captured after that span has ended.\n  const execution = waitForExecution(workflowBody, initialInterruption);\n  void execution.then(replayTrace.end, replayTrace.fail);\n\n  return {\n    session,\n    execution,\n  };\n}\n"]}