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

package/dist/runtime/quickjs-entrypoint.js

@@ -0,0 +1,1429 @@
+/**
+ * QuickJS VM integration with the Workflow DevKit.
+ *
+ * This module provides the entry point for running workflows in the
+ * QuickJS WASM VM engine instead of the `node:vm` engine. Both engines
+ * implement the same event-replay execution model — every invocation:
+ *
+ * 1. Loads the full event log for the run
+ * 2. Runs the workflow function from the top in a fresh QuickJS VM,
+ *    replaying the event log to resolve awaited primitives
+ * 3. On suspension: creates events + queues steps for new pending ops
+ * 4. On completion: creates run_completed
+ * 5. On failure: creates run_failed
+ */
+import { EntityConflictError, HookNotFoundError, MaxEventsExceededError, RunExpiredError, WorkflowNotRegisteredError, } from '@workflow/errors';
+import { parseWorkflowName } from '@workflow/utils/parse-name';
+import { ROOT_RUN_ID_ATTRIBUTE, SPEC_VERSION_CURRENT, } from '@workflow/world';
+import { classifyRunError } from '../classify-error.js';
+import { runtimeLogger } from '../logger.js';
+import { deriveRunPayloadKeys, encrypt as encryptSerializedData, } from '../serialization/encryption.js';
+import { dehydrateRunError, hydrateRunError, maybeEncrypt, } from '../serialization.js';
+import { remapErrorStack, stripInlineSourceMap } from '../source-map.js';
+import * as Attribute from '../telemetry/semantic-conventions.js';
+import { serializeTraceCarrier } from '../telemetry.js';
+import { getInlineOwnershipLeaseSeconds, getMaxInlineSteps, } from './constants.js';
+import { getPortLazy } from './get-port-lazy.js';
+import { getWorkflowQueueName, queueMessage } from './helpers.js';
+import { startQuickJSWorkflow, } from './quickjs-runtime.js';
+import { ReplayBudget } from './replay-budget.js';
+import { executeStep } from './step-executor.js';
+import { runStepSingleFlight } from './step-single-flight.js';
+import { getWaitContinuationDispatch } from './wait-continuation.js';
+import { getWorld } from './world.js';
+/** Tiny ms timer using performance.now() — already monotonic on Node. */
+function tick() {
+    return performance.now();
+}
+/**
+ * Returns true when the supplied preloaded events indicate this is the
+ * first workflow handler invocation for the run — i.e. the log contains
+ * nothing beyond `run_created` / `run_started`. In that case the
+ * preloaded events ARE the complete event log and the `events.list`
+ * round-trips can be skipped entirely.
+ *
+ * Crucially, if the world backfilled a missing `run_created` via the
+ * resilient start path, `preloadedEvents` contains it even when a fresh
+ * `events.list` might not (eventual consistency), so preferring the
+ * preloaded events on first invocation is also the more correct choice.
+ *
+ * Returns false when `preloadedEvents` is missing/empty so the caller
+ * falls back to the normal fetch path.
+ *
+ * Exported for unit testing.
+ */
+export function isFirstInvocation(preloadedEvents) {
+    if (!Array.isArray(preloadedEvents) || preloadedEvents.length === 0) {
+        return false;
+    }
+    return preloadedEvents.every((e) => e.eventType === 'run_created' || e.eventType === 'run_started');
+}
+/**
+ * Queue a step for background execution via the unified workflow queue
+ * (V2 architecture). The combined handler in runtime.ts dispatches
+ * messages with `stepId` to executeStep, which works for both VM engines.
+ * `delaySeconds` supports retry/throttle backoff.
+ */
+async function queueStepMessage(params) {
+    const { world, runId, workflowRun, step, delaySeconds, namespace, nextTraceCarrier, purpose, wfdiag, } = params;
+    const traceCarrier = await nextTraceCarrier();
+    await queueMessage(world, getWorkflowQueueName(workflowRun.workflowName, namespace), {
+        runId,
+        stepId: step.correlationId,
+        stepName: step.stepId,
+        traceCarrier,
+        requestedAt: new Date(),
+    }, {
+        idempotencyKey: purpose === 'dispatch'
+            ? step.correlationId
+            : `${step.correlationId}:${purpose}`,
+        ...(delaySeconds && delaySeconds > 0 ? { delaySeconds } : {}),
+    });
+    wfdiag('step_queued', {
+        stepId: step.stepId,
+        correlationId: step.correlationId,
+        purpose,
+        delaySeconds: delaySeconds ?? 0,
+    });
+}
+/**
+ * Dispatch durable side effects for a set of pending VM operations:
+ * step_created (+ optional queueing), hook_created / hook_received (aborts),
+ * attr_set, hook_disposed, and wait_created events.
+ *
+ * Steps are created but never queued here — queueing (or inline
+ * execution) is the caller's decision. Used both for suspension
+ * processing (the inline loop) and for the terminal drain (flushing
+ * leftover side effects when the workflow completed or failed, mirroring
+ * the node:vm engine's drainPendingQueueItems).
+ */
+async function dispatchPendingOps(params) {
+    const { world, runId, workflowRun, encryptionKey, pendingOperations, namespace, nextTraceCarrier, } = params;
+    const skipStepCreation = params.skipStepCreation;
+    const wfdiag = params.wfdiag;
+    // Set when a hook with a parked getConflict() awaiter had its
+    // hook_created written this invocation. The workflow must be re-invoked
+    // so replay can confirm creation and resolve the awaiter.
+    let createdGetConflictHook = false;
+    // Set when a new attr_set event is written this invocation. The
+    // workflow must be re-invoked to consume it (resolving the pending
+    // setAttributes() promise), so the entrypoint requeues immediately —
+    // same pattern as an elapsed wait.
+    let createdAttributeEvent = false;
+    const opsPromises = [];
+    const processHookOp = async (hook) => {
+        runtimeLogger.debug('QuickJS runtime: processing hook op', {
+            workflowRunId: runId,
+            correlationId: hook.correlationId,
+            token: hook.token,
+            tokenType: typeof hook.token,
+            isWebhook: hook.isWebhook,
+            isSystem: hook.isSystem,
+            hasCreatedEvent: hook.hasCreatedEvent,
+            abortRequested: hook.abortRequested,
+        });
+        if (!hook.hasCreatedEvent) {
+            // `hook.metadata` is the format-prefixed devalue bytes
+            // produced by `globalThis[Symbol.for('workflow-serialize')]
+            // (options.metadata)` inside the VM. Encrypt on the host
+            // side before writing — matches the node:vm engine's
+            // `dehydrateStepArguments` flow.
+            //
+            // No pre-check via hooks.list: with deterministic correlationIds
+            // (same VM seed across replays) and per-(runId, correlationId)
+            // uniqueness in worlds, the storage layer rejects duplicates as
+            // EntityConflictError, which we swallow below. This drops one
+            // network round-trip per pending hook.
+            try {
+                const encryptedMetadata = typeof hook.metadata === 'undefined'
+                    ? undefined
+                    : await encryptSerializedData(hook.metadata, encryptionKey);
+                const result = await world.events.create(runId, {
+                    eventType: 'hook_created',
+                    specVersion: SPEC_VERSION_CURRENT,
+                    correlationId: hook.correlationId,
+                    eventData: {
+                        token: hook.token,
+                        tokenRetentionUntil: hook.tokenRetentionUntil === undefined
+                            ? undefined
+                            : new Date(hook.tokenRetentionUntil),
+                        metadata: encryptedMetadata,
+                        // Always include isWebhook explicitly. Worlds default it to
+                        // `true` when absent, which would break the public webhook
+                        // endpoint's 404 guard for hooks created via createHook().
+                        isWebhook: hook.isWebhook,
+                        // System hooks (AbortController) are exempt from user
+                        // token namespace conflict checks.
+                        ...(hook.isSystem ? { isSystem: true } : {}),
+                    },
+                });
+                // If storage detected a real token conflict with another
+                // workflow's hook, re-queue so the workflow handler can
+                // process the conflict event and fail gracefully.
+                if (result.event?.eventType === 'hook_conflict') {
+                    await queueMessage(world, getWorkflowQueueName(workflowRun.workflowName, namespace), {
+                        runId,
+                        traceCarrier: await nextTraceCarrier(),
+                        requestedAt: new Date(),
+                    }, { idempotencyKey: `hook_conflict_${hook.correlationId}` });
+                }
+            }
+            catch (err) {
+                // Already created by a concurrent invocation — fall through
+                // to abort processing below (if any) instead of bailing.
+                if (!EntityConflictError.is(err))
+                    throw err;
+            }
+            if (hook.hasGetConflictAwaiter) {
+                createdGetConflictHook = true;
+            }
+        }
+        if (hook.abortRequested) {
+            // Record the abort durably: a hook_received event carrying
+            // the VM-serialized `{ aborted: true, reason }` payload,
+            // plus a best-effort stream packet for real-time step
+            // propagation. Mirrors the node:vm engine's suspension
+            // handler (hooksNeedingAbort).
+            const abortPayload = hook.abortPayload instanceof Uint8Array
+                ? (await encryptSerializedData(hook.abortPayload, encryptionKey))
+                : undefined;
+            try {
+                await world.events.create(runId, {
+                    eventType: 'hook_received',
+                    specVersion: SPEC_VERSION_CURRENT,
+                    correlationId: hook.correlationId,
+                    eventData: {
+                        token: hook.token,
+                        payload: abortPayload,
+                    },
+                });
+            }
+            catch (err) {
+                if (!EntityConflictError.is(err))
+                    throw err;
+            }
+            // streamName is derived from the abort hook token
+            // (`abrt_{id}` → `strm_{id}_system_abort`).
+            if (hook.token.startsWith('abrt_') && abortPayload) {
+                const streamName = `strm_${hook.token.slice('abrt_'.length)}_system_abort`;
+                try {
+                    await world.streams.write(runId, streamName, abortPayload);
+                    await world.streams.close(runId, streamName);
+                }
+                catch {
+                    // Best-effort — the hook event provides the durable
+                    // fallback.
+                    runtimeLogger.debug('QuickJS runtime: failed to write abort stream packet', {
+                        workflowRunId: runId,
+                        correlationId: hook.correlationId,
+                    });
+                }
+            }
+            wfdiag('abort_recorded', {
+                correlationId: hook.correlationId,
+                token: hook.token,
+            });
+        }
+    };
+    const processHookDisposeOp = async (op) => {
+        try {
+            await world.events.create(runId, {
+                eventType: 'hook_disposed',
+                specVersion: SPEC_VERSION_CURRENT,
+                correlationId: op.correlationId,
+            });
+        }
+        catch (err) {
+            if (EntityConflictError.is(err))
+                return;
+            // Disposing a hook whose entity no longer (or never) exists is an
+            // idempotent no-op: the entity may have been torn down by a
+            // concurrent run cancellation, or the hook may have lost its
+            // token claim to a conflict. There is nothing left to release.
+            if (HookNotFoundError.is(err))
+                return;
+            throw err;
+        }
+    };
+    // Hook operations are grouped by token and processed SEQUENTIALLY in
+    // code order within each group, mirroring the node:vm suspension
+    // handler (hookItemsByToken): a dispose() of an earlier hook must
+    // release the token before a later same-token hook's creation is
+    // validated by the world — parallel dispatch would otherwise record a
+    // spurious hook_conflict against the run's own disposed hook (e.g. a
+    // dispose→recreate loop reusing one token). Different tokens have no
+    // claim interaction, so token groups run in parallel with each other
+    // and with the non-hook ops below.
+    const hookOpsByToken = new Map();
+    for (const op of pendingOperations) {
+        let key;
+        if (op.type === 'hook' &&
+            (!op.hasCreatedEvent || op.abortRequested)) {
+            key = op.token;
+        }
+        else if (op.type === 'hook_dispose' && !op.hasCreatedEvent) {
+            // Per-op fallback group when the token is unknown — no ordering
+            // guarantees, matching the previous parallel behavior.
+            key = op.token ?? `__cid:${op.correlationId}`;
+        }
+        if (key === undefined)
+            continue;
+        const group = hookOpsByToken.get(key);
+        if (group) {
+            group.push(op);
+        }
+        else {
+            hookOpsByToken.set(key, [op]);
+        }
+    }
+    for (const group of hookOpsByToken.values()) {
+        opsPromises.push((async () => {
+            for (const op of group) {
+                if (op.type === 'hook') {
+                    await processHookOp(op);
+                }
+                else {
+                    await processHookDisposeOp(op);
+                }
+            }
+        })());
+    }
+    for (const op of pendingOperations) {
+        if (op.type === 'step' &&
+            !op.hasCreatedEvent &&
+            !skipStepCreation?.has(op.correlationId)) {
+            const step = op;
+            opsPromises.push((async () => {
+                // Create step_created event. `step.input` is the
+                // format-prefixed devalue bytes ("devl" + devalue) produced
+                // by `globalThis[Symbol.for('workflow-serialize')]({args,
+                // closureVars, thisVal})` inside the VM. The VM has no
+                // access to the CryptoKey, so encryption is applied here
+                // on the host side — matching what
+                // `dehydrateStepArguments` does in the node:vm engine.
+                try {
+                    await world.events.create(runId, {
+                        eventType: 'step_created',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        correlationId: step.correlationId,
+                        eventData: {
+                            stepName: step.stepId,
+                            input: await encryptSerializedData(step.input, encryptionKey),
+                        },
+                    });
+                }
+                catch (err) {
+                    if (EntityConflictError.is(err))
+                        return;
+                    throw err;
+                }
+                // NOTE: step queueing is the caller's decision — the inline
+                // loop executes fresh steps in the live VM and only queues the
+                // overflow / retry / backstop cases (see queueStepMessage).
+            })());
+        }
+        else if (op.type === 'attribute' && !op.hasCreatedEvent) {
+            const attr = op;
+            opsPromises.push((async () => {
+                try {
+                    await world.events.create(runId, {
+                        eventType: 'attr_set',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        correlationId: attr.correlationId,
+                        eventData: {
+                            changes: attr.changes,
+                            writer: { type: 'workflow' },
+                            ...(attr.allowReservedAttributes
+                                ? { allowReservedAttributes: true }
+                                : {}),
+                        },
+                    });
+                    createdAttributeEvent = true;
+                }
+                catch (err) {
+                    if (EntityConflictError.is(err)) {
+                        // Event already exists (concurrent invocation) — the
+                        // replay still needs to consume it, so requeue.
+                        createdAttributeEvent = true;
+                        return;
+                    }
+                    throw err;
+                }
+            })());
+        }
+        else if (op.type === 'wait' && !op.hasCreatedEvent) {
+            const wait = op;
+            opsPromises.push((async () => {
+                try {
+                    await world.events.create(runId, {
+                        eventType: 'wait_created',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        correlationId: wait.correlationId,
+                        eventData: {
+                            resumeAt: new Date(wait.resumeAt),
+                        },
+                    });
+                }
+                catch (err) {
+                    if (EntityConflictError.is(err))
+                        return;
+                    throw err;
+                }
+            })());
+        }
+    }
+    // Per-op dispatch runs in parallel.
+    await Promise.all(opsPromises);
+    return { createdAttributeEvent, createdGetConflictHook };
+}
+/**
+ * Run a workflow using the QuickJS WASM VM engine.
+ *
+ * This replaces the `node:vm` replay path (runWorkflow + EventsConsumer)
+ * with a QuickJS VM invocation that performs the same full event replay.
+ *
+ * KNOWN GAP — precondition guard: unlike the node:vm path, no event write
+ * in this file participates in the optimistic-concurrency precondition
+ * guard (`withPreconditionRetry` + `stateUpdatedAtForCreate`), which
+ * protects a writer holding a stale event-log snapshot from clobbering a
+ * concurrent one. The engine currently relies on per-(runId,
+ * correlationId) event uniqueness (EntityConflictError dedup) alone. This
+ * is a deliberate simplification while the engine is experimental — wiring
+ * the guard is tracked follow-up work; anyone adding new write paths here
+ * should not assume parity with the node engine on this axis.
+ */
+export async function runWorkflowWithQuickJS(params) {
+    const { workflowCode, workflowName, workflowRun, preloadedEvents, preloadedEventsComplete, runInput, parentSpan, maxEventsLimit, deliveryAttempt, ownerMessageId, namespace, } = params;
+    // Standalone-caller fallback (tests): without a runtime.ts carrier
+    // accessor, fall back to the current invocation context.
+    const nextTraceCarrier = params.nextTraceCarrier ?? (() => serializeTraceCarrier());
+    const world = await getWorld();
+    const runId = workflowRun.runId;
+    const invocationStart = tick();
+    // Strip the inline source map comment before evaluating the bundle in
+    // the QuickJS VM. The map is purely host-side metadata for
+    // `remapErrorStack` (called below on workflow failures, against the
+    // ORIGINAL `workflowCode`). QuickJS retains source text for
+    // stack-trace line lookups, so the few-MB base64 comment would bloat
+    // the VM heap for no benefit.
+    const workflowCodeForVM = stripInlineSourceMap(workflowCode);
+    // Per-invocation diagnostic id so debug logs can be correlated even if
+    // the same runId is processed by overlapping invocations on different
+    // function instances.
+    const invocationId = `inv_${Math.random().toString(36).slice(2, 10)}`;
+    // Structured per-checkpoint diagnostic helper, grep-friendly by runId.
+    const wfdiag = (checkpoint, fields) => {
+        runtimeLogger.debug('QUICKJS_VM_DIAG', {
+            checkpoint,
+            runId,
+            invocationId,
+            tElapsedMs: Math.round(tick() - invocationStart),
+            ...fields,
+        });
+    };
+    parentSpan?.setAttributes({
+        ...Attribute.WorkflowVm('quickjs'),
+    });
+    wfdiag('enter', {
+        workflowName,
+        deliveryAttempt,
+        hasPreloadedEvents: Array.isArray(preloadedEvents) && preloadedEvents.length > 0,
+        preloadedEventCount: preloadedEvents?.length ?? 0,
+        hasRunInput: !!runInput,
+    });
+    // The workflowName from the queue topic is already the full workflow ID
+    // (e.g. "workflow//./workflows/1_simple//simple")
+    const workflowId = workflowName;
+    // Resolve the encryption key up front — needed to decrypt event
+    // payloads inside the VM and to encrypt event payloads written below.
+    // Resolve the FULL capability (symmetric AES key + X25519 keypair), not
+    // just `importKey(rawKey)`: a run reading its own event log can encounter
+    // sealed (`encp`) hook payloads that a cross-deployment `resumeHook()`
+    // wrote to it (sealing is presence-gated on the run's published
+    // encryptionPublicKey, which the shared start() path stamps regardless of
+    // engine). A bare symmetric key cannot open those and would wedge the run
+    // right after hook_received — the node:vm engine resolves the same full
+    // capability via memoizeEncryptionKey.
+    const rawKey = await world.getEncryptionKeyForRun?.(workflowRun);
+    const encryptionKey = rawKey ? await deriveRunPayloadKeys(rawKey) : undefined;
+    // Load the FULL event log for the run. On first invocation the
+    // preloaded events from the run_started response are the complete log
+    // and save the events.list round-trips; a caller-attested complete
+    // preload (lazy hook fast path) is trusted the same way.
+    let events;
+    let eventsFetchedPages = 0;
+    const usePreloaded = (preloadedEventsComplete === true &&
+        Array.isArray(preloadedEvents) &&
+        preloadedEvents.length > 0) ||
+        isFirstInvocation(preloadedEvents);
+    if (usePreloaded && preloadedEvents) {
+        events = preloadedEvents;
+    }
+    else {
+        const allEvents = [];
+        let cursor = null;
+        let hasMore = true;
+        while (hasMore) {
+            const response = await world.events.list({
+                runId,
+                pagination: {
+                    sortOrder: 'asc',
+                    cursor: cursor ?? undefined,
+                    limit: 1000,
+                },
+            });
+            eventsFetchedPages++;
+            allEvents.push(...response.data);
+            // Update the cursor to the last successfully fetched page's cursor.
+            // Only update when we got results — the final empty-page response
+            // returns cursor=null which we must NOT use (it would reset the cursor).
+            if (response.cursor) {
+                cursor = response.cursor;
+            }
+            hasMore = response.data.length > 0 && response.cursor != null;
+        }
+        events = allEvents;
+    }
+    // Event-limit guard: fail a runaway run once its log reaches the
+    // server-supplied ceiling — same enforcement point as the node:vm
+    // engine's replay loop.
+    if (maxEventsLimit !== undefined && events.length >= maxEventsLimit) {
+        throw new MaxEventsExceededError(events.length, maxEventsLimit);
+    }
+    parentSpan?.setAttributes({
+        ...Attribute.QuickJSEventsPreloaded(usePreloaded),
+        ...Attribute.QuickJSEventsFetchedCount(events.length),
+        ...Attribute.QuickJSEventsFetchedPages(eventsFetchedPages),
+    });
+    wfdiag('events_fetched', {
+        eventCount: events.length,
+        eventsFetchedPages,
+        usePreloaded,
+        eventTypes: events.reduce((acc, e) => {
+            acc[e.eventType] = (acc[e.eventType] ?? 0) + 1;
+            return acc;
+        }, {}),
+    });
+    // Check for elapsed waits
+    const now = Date.now();
+    const completedWaitIds = new Set(events
+        .filter((e) => e.eventType === 'wait_completed')
+        .map((e) => e.correlationId));
+    for (const event of events) {
+        if (event.eventType === 'wait_created' &&
+            event.correlationId &&
+            !completedWaitIds.has(event.correlationId)) {
+            const eventData = 'eventData' in event
+                ? event.eventData
+                : undefined;
+            const resumeAt = eventData?.resumeAt;
+            if (resumeAt && now >= new Date(resumeAt).getTime()) {
+                try {
+                    const result = await world.events.create(runId, {
+                        eventType: 'wait_completed',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        correlationId: event.correlationId,
+                    });
+                    if (result.event)
+                        events.push(result.event);
+                }
+                catch (err) {
+                    if (EntityConflictError.is(err))
+                        continue;
+                    throw err;
+                }
+            }
+        }
+    }
+    // Resolve the workflow server port so `getWorkflowMetadata().url` inside
+    // the VM matches what the step-side handler reports. Skipped on Vercel —
+    // the VM reads VERCEL_URL directly in that environment.
+    const isVercel = process.env.VERCEL_URL !== undefined;
+    const port = isVercel ? undefined : await getPortLazy();
+    // Run the workflow in the QuickJS VM
+    runtimeLogger.debug('QuickJS runtime: invoking VM', {
+        workflowRunId: runId,
+        workflowId,
+        eventCount: events.length,
+    });
+    const session = await startQuickJSWorkflow({
+        // Pass the STRIPPED bundle to the VM so the inline source map
+        // doesn't end up in the QuickJS heap. The original (unstripped)
+        // `workflowCode` is still kept in this host-side scope and is used
+        // by `remapErrorStack` on workflow failures below.
+        workflowCode: workflowCodeForVM,
+        workflowId,
+        workflowRun,
+        events,
+        worldCapabilities: world.capabilities,
+        encryptionKey,
+        port,
+        runInput,
+    });
+    let result = session.result;
+    runtimeLogger.debug('QuickJS runtime: VM returned', {
+        workflowRunId: runId,
+        completed: !!result.completed,
+        suspended: !!result.suspended,
+        failed: !!result.failed,
+        pendingOpsCount: result.suspended?.pendingOperations?.length,
+    });
+    wfdiag('vm_returned', {
+        outcome: result.completed
+            ? 'completed'
+            : result.suspended
+                ? 'suspended'
+                : result.failed
+                    ? 'failed'
+                    : 'unknown',
+        pendingOpsCount: result.suspended?.pendingOperations?.length ?? 0,
+        pendingOpSummary: result.suspended?.pendingOperations?.map((p) => ({
+            type: p.type,
+            correlationId: p.correlationId,
+            hasCreatedEvent: p.hasCreatedEvent,
+            ...(p.type === 'step' ? { stepId: p.stepId } : {}),
+        })),
+        failureMessage: result.failed?.message,
+        failureName: result.failed?.name,
+    });
+    // ---- Inline continuation loop ----
+    //
+    // While the workflow is suspended, this loop keeps the VM alive and
+    // makes as much forward progress as possible within one invocation:
+    //
+    //   1. Dispatch durable side effects for the suspension's pending ops
+    //      (step_created / hook_created / attr_set / wait_created /
+    //      hook_received for aborts) and complete elapsed waits.
+    //   2. Feed all newly recorded events (attr_set, hook_created, elapsed
+    //      wait_completed, terminals written by concurrent invocations, ...)
+    //      into the LIVE VM via session.continueWithEvents — resuming
+    //      execution exactly where it left off, no fresh-VM re-replay.
+    //      Cheap progress is fed BEFORE running step bodies so promise
+    //      chains that are not gated on steps (hook.getConflict(),
+    //      setAttributes(), racing sleeps) advance first and can surface
+    //      additional pending steps for the same inline batch.
+    //   3. Once no cheap progress remains, execute up to
+    //      getMaxInlineSteps() steps created by THIS invocation inline (no
+    //      queue round-trip), in parallel, with the replay budget paused
+    //      during step bodies — mirroring the node:vm engine's inline
+    //      replay loop. Overflow and retry/throttled steps are queued for
+    //      background execution. A delayed wait-continuation message is
+    //      enqueued for the soonest pending wait first, so racing timers
+    //      fire on time (in a separate invocation) while step bodies block
+    //      this one.
+    //
+    // The loop exits when the workflow settles, no forward progress is
+    // possible in-process, the replay budget is exhausted, or the run is
+    // gone.
+    const seenEventIds = new Set();
+    for (const e of events) {
+        if (e.eventId)
+            seenEventIds.add(e.eventId);
+    }
+    // Step cids already executed inline by this invocation.
+    const executedStepIds = new Set();
+    // Steps for which THIS invocation already sent a queue message.
+    const queuedStepIds = new Set();
+    // Aborts THIS invocation already recorded (hook_received written) —
+    // guards against re-recording when the VM-side flag has not been
+    // cleared yet within the same iteration.
+    const recordedAbortIds = new Set();
+    // Waits for which THIS invocation already completed/scheduled work.
+    const completedWaitIds2 = new Set();
+    // Inline-ownership state per step correlationId, derived from every
+    // event this invocation observes (initial log + every feed) — the
+    // quickjs analog of the replay-derived ownership on the node engine's
+    // StepInvocationQueueItem (see step-ownership.ts). Latest-wins:
+    // events arrive in log order, so a later step_started overwrites the
+    // stamp; a step_retrying lapses ownership permanently for the id.
+    const stepOwnership = new Map();
+    const observeEventsForOwnership = (observed) => {
+        for (const e of observed) {
+            if (e.correlationId === undefined)
+                continue;
+            if (e.eventType === 'step_started') {
+                const owner = 'eventData' in e &&
+                    e.eventData &&
+                    'ownerMessageId' in e.eventData &&
+                    typeof e.eventData.ownerMessageId === 'string'
+                    ? e.eventData.ownerMessageId
+                    : undefined;
+                const prior = stepOwnership.get(e.correlationId);
+                stepOwnership.set(e.correlationId, {
+                    owner,
+                    startedAtMs: e.createdAt ? +new Date(e.createdAt) : undefined,
+                    sawRetrying: prior?.sawRetrying ?? false,
+                });
+            }
+            else if (e.eventType === 'step_retrying') {
+                const prior = stepOwnership.get(e.correlationId);
+                stepOwnership.set(e.correlationId, {
+                    ...(prior ?? {}),
+                    sawRetrying: true,
+                });
+            }
+        }
+    };
+    observeEventsForOwnership(events);
+    const scheduledWaitContinuations = new Set();
+    const maxInlineSteps = getMaxInlineSteps();
+    const budget = new ReplayBudget();
+    const workflowStartedAt = workflowRun.startedAt
+        ? +workflowRun.startedAt
+        : Date.now();
+    const rootRunId = workflowRun.attributes?.[ROOT_RUN_ID_ATTRIBUTE] ?? runId;
+    let inlineStepsExecuted = 0;
+    let runGone = false;
+    // Set when this invocation wrote an event the workflow must consume to
+    // make progress (attr_set, getConflict-awaited hook_created) and the
+    // loop has not yet read it back — eventually-consistent listings can
+    // return 0 new events right after a write. If it is still set when the
+    // loop exits suspended, the entrypoint requeues immediately instead of
+    // exiting awaiting_external with the unblocking event already written
+    // and nothing scheduled to read it.
+    let pendingRequeueSignal = false;
+    /** Fetch all events not yet processed by the live VM (log order). */
+    const fetchUnseenEvents = async () => {
+        const unseen = [];
+        let cursor = null;
+        let hasMore = true;
+        while (hasMore) {
+            const response = await world.events.list({
+                runId,
+                pagination: {
+                    sortOrder: 'asc',
+                    cursor: cursor ?? undefined,
+                    limit: 1000,
+                },
+            });
+            for (const e of response.data) {
+                if (e.eventId && seenEventIds.has(e.eventId))
+                    continue;
+                if (e.eventId)
+                    seenEventIds.add(e.eventId);
+                unseen.push(e);
+            }
+            if (response.cursor)
+                cursor = response.cursor;
+            hasMore = response.data.length > 0 && response.cursor != null;
+        }
+        observeEventsForOwnership(unseen);
+        return unseen;
+    };
+    try {
+        let iteration = 0;
+        while (result.suspended && !runGone && !budget.isExhausted()) {
+            iteration++;
+            // Re-check the event ceiling every turn: the loop appends events on
+            // each continueWithEvents, so a single invocation can otherwise grow
+            // the log arbitrarily far past the operator's limit (the node engine
+            // re-checks per replay for the same reason). `seenEventIds` counts
+            // every event this invocation has observed — initial log + all
+            // feeds.
+            if (maxEventsLimit !== undefined && seenEventIds.size >= maxEventsLimit) {
+                throw new MaxEventsExceededError(seenEventIds.size, maxEventsLimit);
+            }
+            const pendingOperations = result.suspended.pendingOperations;
+            // Select this turn's inline candidates BEFORE dispatch: fresh steps
+            // (no step_created yet) that this invocation hasn't already handled.
+            // Their step_created is deliberately NOT written by dispatch — the
+            // inline claim below is a lazy step_started carrying the input,
+            // which the world applies as an atomic create-claim. A concurrent
+            // invocation racing on the same fresh step loses that claim with
+            // EntityConflictError and skips, so step bodies cannot double-run
+            // (previously both invocations bare-started the step after one lost
+            // the swallowed step_created race).
+            const freshSteps = pendingOperations.filter((op) => op.type === 'step' &&
+                !op.hasCreatedEvent &&
+                !executedStepIds.has(op.correlationId) &&
+                !queuedStepIds.has(op.correlationId));
+            const inlineCandidates = maxInlineSteps <= 0 ? [] : freshSteps.slice(0, maxInlineSteps);
+            const inlineClaimCids = new Set(inlineCandidates.map((step) => step.correlationId));
+            // 1. Durable side effects for this suspension's pending ops.
+            const opsToDispatch = pendingOperations.map((op) => op.type === 'hook' &&
+                op.abortRequested &&
+                recordedAbortIds.has(op.correlationId)
+                ? { ...op, abortRequested: false }
+                : op);
+            for (const op of pendingOperations) {
+                if (op.type === 'hook' && op.abortRequested) {
+                    recordedAbortIds.add(op.correlationId);
+                }
+            }
+            const dispatched = await dispatchPendingOps({
+                world,
+                runId,
+                workflowRun,
+                encryptionKey,
+                namespace,
+                nextTraceCarrier,
+                pendingOperations: opsToDispatch,
+                skipStepCreation: inlineClaimCids,
+                wfdiag,
+            });
+            if (dispatched.createdAttributeEvent ||
+                dispatched.createdGetConflictHook) {
+                pendingRequeueSignal = true;
+            }
+            // Hand steps beyond the inline cap to the queue NOW — in the same
+            // turn their step_created was written by the dispatch above. This
+            // must happen BEFORE the event feed below: the feed always observes
+            // those very step_created writes as unseen events and `continue`s,
+            // so a handoff placed after it is unreachable on the only iteration
+            // that still classifies these steps as fresh — next turn they carry
+            // hasCreatedEvent and would never be queued at all (the wedge behind
+            // promiseRaceStressTestWorkflow hanging in the quickjs CI legs). The
+            // bare-correlationId idempotency key makes repeats harmless.
+            const overflowSteps = freshSteps.slice(inlineCandidates.length);
+            for (const step of overflowSteps) {
+                queuedStepIds.add(step.correlationId);
+                await queueStepMessage({
+                    world,
+                    runId,
+                    workflowRun,
+                    step,
+                    namespace,
+                    nextTraceCarrier,
+                    purpose: 'dispatch',
+                    wfdiag,
+                });
+            }
+            // Complete elapsed waits so their wait_completed events are picked
+            // up by the feed below (instead of a queue re-invocation).
+            const waitCompletePromises = [];
+            for (const op of pendingOperations) {
+                if (op.type !== 'wait')
+                    continue;
+                const wait = op;
+                if (completedWaitIds2.has(wait.correlationId))
+                    continue;
+                if (new Date(wait.resumeAt).getTime() - Date.now() > 0)
+                    continue;
+                completedWaitIds2.add(wait.correlationId);
+                waitCompletePromises.push((async () => {
+                    try {
+                        await world.events.create(runId, {
+                            eventType: 'wait_completed',
+                            specVersion: SPEC_VERSION_CURRENT,
+                            correlationId: wait.correlationId,
+                        });
+                    }
+                    catch (err) {
+                        if (EntityConflictError.is(err))
+                            return;
+                        throw err;
+                    }
+                })());
+            }
+            if (waitCompletePromises.length > 0) {
+                await Promise.all(waitCompletePromises);
+            }
+            // 2. Cheap progress first: feed newly recorded events into the live
+            // VM before blocking on step bodies.
+            {
+                const newEvents = await fetchUnseenEvents();
+                if (newEvents.length > 0) {
+                    // The listing caught up with this invocation's writes — any
+                    // attr_set / getConflict hook_created has been (or is being)
+                    // consumed by the live VM, so no external requeue is needed.
+                    pendingRequeueSignal = false;
+                    result = await session.continueWithEvents(newEvents);
+                    wfdiag('inline_iteration', {
+                        iteration,
+                        phase: 'feed',
+                        fedEvents: newEvents.length,
+                        outcome: result.completed
+                            ? 'completed'
+                            : result.failed
+                                ? 'failed'
+                                : 'suspended',
+                    });
+                    continue;
+                }
+            }
+            // 3. No cheap progress left — execute steps inline.
+            const stepOps = pendingOperations.filter((op) => op.type === 'step');
+            // Steps created by an EARLIER invocation (or an earlier turn) that
+            // are still pending, with no work owned by THIS invocation. Mirror
+            // the node engine's ownership decision table (step-ownership.ts) —
+            // NOT a deliveryAttempt gate: worlds advance the attempt counter on
+            // routine redeliveries (world-local counts every handled response),
+            // so attempt > 1 is the common case and would fire backstops at
+            // steps actively executing inline in a live invocation.
+            //
+            //   - Ownership lease ACTIVE, held by ANOTHER message → the step is
+            //     (presumably) executing inline in a live invocation. Arm a
+            //     DELAYED backstop for the lease remainder, keyed to the
+            //     ownership epoch (a refreshed lease re-arms a fresh backstop
+            //     instead of deduping against the in-flight one). If the owner
+            //     completes normally, the backstop delivery resolves the step
+            //     as 'skipped'.
+            //   - Ownership lease ACTIVE, held by THIS message → this delivery
+            //     is the owner's redelivery; the claimant crashed
+            //     mid-execution. Dispatch immediately for background recovery.
+            //   - No stamp / lease EXPIRED / step_retrying observed → the step
+            //     is queue-owned or orphaned. Dispatch immediately; the
+            //     bare-correlationId idempotency key dedupes against the
+            //     original handoff.
+            const nowMs = Date.now();
+            for (const step of stepOps) {
+                if (!step.hasCreatedEvent)
+                    continue;
+                if (executedStepIds.has(step.correlationId))
+                    continue;
+                if (queuedStepIds.has(step.correlationId))
+                    continue;
+                const ownership = stepOwnership.get(step.correlationId);
+                const ownershipActive = ownership !== undefined &&
+                    ownership.owner !== undefined &&
+                    !ownership.sawRetrying;
+                let leaseRemainingSeconds = 0;
+                if (ownershipActive && ownership.startedAtMs !== undefined) {
+                    const leaseSeconds = getInlineOwnershipLeaseSeconds();
+                    leaseRemainingSeconds = Math.min(leaseSeconds, Math.max(0, Math.ceil((ownership.startedAtMs + leaseSeconds * 1000 - nowMs) / 1000)));
+                }
+                if (ownershipActive &&
+                    ownership.owner !== ownerMessageId &&
+                    leaseRemainingSeconds > 0) {
+                    queuedStepIds.add(step.correlationId);
+                    await queueStepMessage({
+                        world,
+                        runId,
+                        workflowRun,
+                        step,
+                        delaySeconds: leaseRemainingSeconds,
+                        namespace,
+                        nextTraceCarrier,
+                        purpose: `backstop:${ownership.startedAtMs}`,
+                        wfdiag,
+                    });
+                }
+                else {
+                    queuedStepIds.add(step.correlationId);
+                    await queueStepMessage({
+                        world,
+                        runId,
+                        workflowRun,
+                        step,
+                        namespace,
+                        nextTraceCarrier,
+                        purpose: 'dispatch',
+                        wfdiag,
+                    });
+                }
+            }
+            if (inlineCandidates.length === 0) {
+                // No in-process progress possible — the run awaits an external
+                // stimulus (hook payload, queued step, wait timer).
+                break;
+            }
+            // Racing timers must fire on time while step bodies block this
+            // invocation: enqueue a delayed continuation for the soonest
+            // pending wait (a separate invocation writes its wait_completed at
+            // the right log position — same mechanism as the node:vm engine's
+            // wait-continuation dispatch).
+            let soonestWait;
+            for (const op of pendingOperations) {
+                if (op.type !== 'wait')
+                    continue;
+                const wait = op;
+                if (scheduledWaitContinuations.has(wait.correlationId))
+                    continue;
+                // Waits whose wait_completed THIS invocation already wrote (the
+                // elapsed-wait pass above) are done — the event just hasn't fed
+                // back into the VM yet. No continuation needed.
+                if (completedWaitIds2.has(wait.correlationId))
+                    continue;
+                const resumeMs = new Date(wait.resumeAt).getTime() - Date.now();
+                // An already-elapsed wait MUST still get a continuation (clamped
+                // to the 1s minimum, exactly like the node engine's
+                // `Math.max(1000, resumeAtMs - now)`), not be skipped: a wait
+                // whose deadline falls between this iteration's elapsed-wait
+                // pass (which saw it as still pending and wrote nothing) and
+                // this sweep would otherwise get NEITHER a wait_completed NOR a
+                // continuation — and the inline batch below then blocks this
+                // invocation for the full step duration with no wake armed
+                // anywhere. For `Promise.race(step, sleep)` that silently hands
+                // the race to the step: the sleep's wait_completed is never
+                // written and the run completes with the wrong winner. The
+                // window between the two checks spans this iteration's dispatch
+                // + feed round-trips, so on network-backed worlds (world-vercel)
+                // a short sleep lands in it routinely — observed as a ~50%
+                // sleepWinsRaceWorkflow failure rate in the Vercel e2e legs,
+                // while world-local's sub-ms round-trips masked it locally. The
+                // continuation invocation's pre-VM elapsed check writes the
+                // wait_completed ~1s later.
+                const seconds = Math.max(1, Math.ceil(resumeMs / 1000));
+                if (!soonestWait || seconds < soonestWait.seconds) {
+                    soonestWait = { correlationId: wait.correlationId, seconds };
+                }
+            }
+            if (soonestWait) {
+                scheduledWaitContinuations.add(soonestWait.correlationId);
+                await queueMessage(world, getWorkflowQueueName(workflowRun.workflowName, namespace), {
+                    runId,
+                    traceCarrier: await nextTraceCarrier(),
+                    requestedAt: new Date(),
+                }, getWaitContinuationDispatch(soonestWait.seconds, soonestWait.correlationId));
+                wfdiag('wait_continuation_scheduled', {
+                    correlationId: soonestWait.correlationId,
+                    delaySeconds: soonestWait.seconds,
+                });
+            }
+            // Execute the inline batch in parallel. The replay budget is
+            // paused while step bodies run — step duration is bounded by the
+            // platform function duration, not the replay timeout. NOTE (by
+            // design): with the budget parked per batch, the only bound on how
+            // many inline steps one invocation can chain is the platform's
+            // function timeout — the SDK deliberately imposes no cap of its
+            // own, matching the node:vm engine, where a long sequential
+            // workflow likewise runs step-by-step until the platform reclaims
+            // the invocation and a redelivery resumes from the log.
+            budget.pause();
+            let outcomes;
+            try {
+                outcomes = await Promise.all(inlineCandidates.map((step) => runStepSingleFlight(runId, step.correlationId, () => (async () => executeStep({
+                    world,
+                    workflowRunId: runId,
+                    workflowDeploymentId: workflowRun.deploymentId,
+                    workflowName: workflowRun.workflowName,
+                    workflowStartedAt,
+                    rootRunId,
+                    stepId: step.correlationId,
+                    stepName: step.stepId,
+                    encryptionKey,
+                    runSpecVersion: workflowRun.specVersion,
+                    // Lazy inline claim: step_created is deferred (dispatch
+                    // skipped it) and this step_started carries the input,
+                    // so the world creates the step atomically —
+                    // exactly-one-owner. A concurrent claimant gets
+                    // EntityConflictError → { type: 'skipped' } and never
+                    // runs the body. Mirrors the node engine's inline path.
+                    lazyStepInput: await encryptSerializedData(step.input, encryptionKey),
+                    // Ownership stamp: wake replays see the body as in
+                    // flight in this invocation and arm a delayed backstop
+                    // instead of immediately requeueing the step.
+                    ownerMessageId,
+                    // A lazy step is brand-new by construction — first
+                    // attempt.
+                    authoritativeAttempt: 1,
+                }))())));
+            }
+            finally {
+                budget.resume();
+            }
+            inlineStepsExecuted += inlineCandidates.length;
+            for (let i = 0; i < inlineCandidates.length; i++) {
+                const step = inlineCandidates[i];
+                const outcome = outcomes[i];
+                executedStepIds.add(step.correlationId);
+                if (outcome.type === 'retry' || outcome.type === 'throttled') {
+                    // Hand the step to the queue with the requested backoff —
+                    // background delivery drives the retry from here.
+                    queuedStepIds.add(step.correlationId);
+                    await queueStepMessage({
+                        world,
+                        runId,
+                        workflowRun,
+                        step,
+                        delaySeconds: outcome.timeoutSeconds,
+                        namespace,
+                        nextTraceCarrier,
+                        // Suffixed key: this step was inline-claimed, so no dispatch
+                        // publish exists under the bare correlationId — but suffixing
+                        // keeps the retry enqueueable even if a world retired a
+                        // historical key for this step (see the purpose docs above).
+                        purpose: 'retry:1',
+                        wfdiag,
+                    });
+                }
+                else if (outcome.type === 'gone') {
+                    runGone = true;
+                }
+                // 'skipped': a concurrent invocation won the lazy create-claim and
+                // owns the body. Marked executed above so this invocation never
+                // re-claims it; the winner's terminal events arrive via the feed
+                // (or drive a separate invocation).
+            }
+            wfdiag('inline_steps_executed', {
+                iteration,
+                count: inlineCandidates.length,
+                outcomes: outcomes.map((o) => o.type),
+            });
+            // Feed the inline batch's terminal events into the live VM. When
+            // the eventually-consistent listing has not surfaced them yet,
+            // exiting must NOT ack silently: the terminals this invocation just
+            // caused are durably written with no queue message left to consume
+            // them (inline steps have none), so an awaiting_external exit would
+            // park the run 'running' with all its steps complete. Raise the
+            // requeue signal so the suspended exit schedules a fresh immediate
+            // invocation whose fresh read picks the terminals up. Outcomes that
+            // wrote no terminal ('skipped' — a concurrent claimant owns the
+            // body; 'gone', retry/throttled — a queue message exists) don't
+            // need it, but signaling on them too only costs a no-op invocation
+            // in an already-rare lag window.
+            const newEvents = await fetchUnseenEvents();
+            if (newEvents.length === 0) {
+                pendingRequeueSignal = true;
+                break;
+            }
+            result = await session.continueWithEvents(newEvents);
+            wfdiag('inline_iteration', {
+                iteration,
+                phase: 'steps',
+                fedEvents: newEvents.length,
+                outcome: result.completed
+                    ? 'completed'
+                    : result.failed
+                        ? 'failed'
+                        : 'suspended',
+                budgetExhausted: budget.isExhausted(),
+            });
+        }
+    }
+    finally {
+        session.dispose();
+    }
+    parentSpan?.setAttributes({
+        ...Attribute.QuickJSInlineSteps(inlineStepsExecuted),
+    });
+    if (result.completed) {
+        // Workflow completed
+        runtimeLogger.info('QuickJS runtime: workflow completed', {
+            workflowRunId: runId,
+        });
+        parentSpan?.setAttributes({
+            ...Attribute.QuickJSOutcome('completed'),
+        });
+        // Flush leftover pending side effects (abort recordings, system-hook
+        // disposals, fire-and-forget attribute/hook events) BEFORE writing
+        // run_completed — mirrors the node:vm engine's drainPendingQueueItems.
+        // Drain failures are swallowed: the workflow's own outcome is the
+        // source of truth.
+        if (result.completed.drainOperations?.length) {
+            try {
+                await dispatchPendingOps({
+                    world,
+                    runId,
+                    workflowRun,
+                    encryptionKey,
+                    namespace,
+                    nextTraceCarrier,
+                    pendingOperations: result.completed.drainOperations,
+                    wfdiag,
+                });
+            }
+            catch (err) {
+                runtimeLogger.warn('QuickJS runtime: terminal drain failed', {
+                    workflowRunId: runId,
+                    message: err?.message,
+                });
+            }
+        }
+        // Create run_completed event.
+        // The VM serializes the workflow result as format-prefixed devalue bytes
+        // ("devl" + devalue) with no encryption (the VM has no access to the
+        // CryptoKey). Host-side encryption is applied here so that `run_completed`
+        // events have the same `encr`-prefixed payload shape that the node:vm
+        // engine's `dehydrateWorkflowReturnValue` produces.
+        try {
+            await world.events.create(runId, {
+                eventType: 'run_completed',
+                specVersion: SPEC_VERSION_CURRENT,
+                eventData: {
+                    output: await encryptSerializedData(result.completed.result, encryptionKey),
+                },
+            });
+            wfdiag('exit_completed', { result: 'run_completed_written' });
+        }
+        catch (err) {
+            if (EntityConflictError.is(err) || RunExpiredError.is(err)) {
+                runtimeLogger.warn('Workflow already finished, skipping run_completed', { workflowRunId: runId });
+                wfdiag('exit_completed', { result: 'already_finished' });
+                return;
+            }
+            wfdiag('exit_completed_error', {
+                errorName: err?.name,
+                errorMessage: err?.message,
+            });
+            throw err;
+        }
+    }
+    else if (result.suspended) {
+        // Workflow still suspended after the inline loop. All durable side
+        // effects for the final suspension state were already dispatched by
+        // the loop; what remains is deciding how the run gets re-invoked.
+        const { pendingOperations } = result.suspended;
+        runtimeLogger.info('QuickJS runtime: workflow suspended', {
+            workflowRunId: runId,
+            inlineStepsExecuted,
+            pendingSteps: pendingOperations.filter((p) => p.type === 'step').length,
+            pendingWaits: pendingOperations.filter((p) => p.type === 'wait').length,
+            pendingOps: pendingOperations.map((p) => ({
+                type: p.type,
+                correlationId: p.correlationId,
+                hasCreatedEvent: p.hasCreatedEvent,
+                ...(p.type === 'step' ? { stepId: p.stepId } : {}),
+            })),
+        });
+        parentSpan?.setAttributes({
+            ...Attribute.QuickJSOutcome('suspended'),
+            ...Attribute.QuickJSPendingOpsCount(pendingOperations.length),
+        });
+        if (runGone) {
+            // The run no longer exists (expired / deleted) — nothing to drive.
+            wfdiag('exit_suspended', { action: 'run_gone' });
+            return;
+        }
+        // Exit requeues are FRESH messages, never a `{ timeoutSeconds }`
+        // visibility-redelivery of the current message. Redelivering the
+        // CURRENT message is a trap: a hook-resume delivery carries
+        // `hookInput`, and its redelivery re-runs the lazy-resume re-ensure
+        // in the handler prologue — if the workflow disposed that hook
+        // during this invocation (dispose → sleep), a world that rejects
+        // the re-ensure would ack the message as "nothing left to resume"
+        // and the continuation it carried is silently lost. A fresh message
+        // carries only `runId`, so its delivery always reaches replay (and
+        // under turbo a reschedule would re-engage turbo against a stale
+        // preloaded log — see the reinvoke() docs in runtime.ts).
+        const requeueImmediately = async () => {
+            await queueMessage(world, getWorkflowQueueName(workflowRun.workflowName, namespace), {
+                runId,
+                traceCarrier: await nextTraceCarrier(),
+                requestedAt: new Date(),
+            });
+        };
+        if (budget.isExhausted()) {
+            // The loop stopped on the replay budget with progress still
+            // possible — continue in a fresh invocation.
+            wfdiag('exit_suspended', { action: 'budget_exhausted_requeue' });
+            await requeueImmediately();
+            return;
+        }
+        // Exit wait sweep. A wait that elapsed in the window since the
+        // loop's last check requeues immediately (its wait_completed is
+        // written by the next invocation's elapsed-wait pass); pending waits
+        // whose continuation the loop already enqueued are skipped.
+        let soonestWait;
+        let hasElapsedWait = false;
+        for (const op of pendingOperations) {
+            if (op.type !== 'wait')
+                continue;
+            const wait = op;
+            const resumeMs = new Date(wait.resumeAt).getTime() - Date.now();
+            if (resumeMs <= 0) {
+                hasElapsedWait = true;
+            }
+            else if (!scheduledWaitContinuations.has(wait.correlationId)) {
+                const timeoutSeconds = Math.max(1, Math.ceil(resumeMs / 1000));
+                if (!soonestWait || timeoutSeconds < soonestWait.seconds) {
+                    soonestWait = {
+                        seconds: timeoutSeconds,
+                        correlationId: wait.correlationId,
+                    };
+                }
+            }
+        }
+        if (hasElapsedWait) {
+            wfdiag('exit_suspended', { action: 'wait_elapsed_requeue' });
+            await requeueImmediately();
+            return;
+        }
+        if (pendingRequeueSignal) {
+            // This invocation wrote events the workflow needs to consume
+            // (attr_set / getConflict-awaited hook_created / inline step
+            // terminals) but the eventually-consistent listing never returned
+            // them before the loop exited. Without a requeue the run would
+            // park awaiting_external with its unblocking events already
+            // durably written and no future invocation coming — requeue
+            // immediately so a fresh read picks them up. In the common case
+            // the loop's own feed observes the writes and clears this flag, so
+            // this only fires when the read actually lagged.
+            wfdiag('exit_suspended', { action: 'unread_self_write_requeue' });
+            await requeueImmediately();
+            return;
+        }
+        if (soonestWait) {
+            // Delayed continuation for the soonest pending wait the loop has
+            // not already scheduled. The dispatch helper handles delay
+            // clamping (long waits chain across hops) and idempotency-key
+            // dedup of re-observations of the same pending wait — see
+            // runtime/wait-continuation.ts.
+            wfdiag('exit_suspended', {
+                action: 'schedule_wait_timeout',
+                timeoutSeconds: soonestWait.seconds,
+                waitCorrelationId: soonestWait.correlationId,
+            });
+            scheduledWaitContinuations.add(soonestWait.correlationId);
+            await queueMessage(world, getWorkflowQueueName(workflowRun.workflowName, namespace), {
+                runId,
+                traceCarrier: await nextTraceCarrier(),
+                requestedAt: new Date(),
+            }, getWaitContinuationDispatch(soonestWait.seconds, soonestWait.correlationId));
+            return;
+        }
+        wfdiag('exit_suspended', {
+            action: 'awaiting_external',
+            pendingOpsCount: pendingOperations.length,
+        });
+    }
+    else if (result.failed) {
+        // Workflow failed — remap stack trace using inline source maps
+        let errorStack = result.failed.stack;
+        if (errorStack) {
+            const parsedName = parseWorkflowName(workflowName);
+            const filename = parsedName?.moduleSpecifier || workflowName;
+            errorStack = remapErrorStack(errorStack, filename, workflowCode);
+        }
+        // Classify the error so consumers (`run.returnValue`, observability)
+        // get `USER_ERROR` / `RUNTIME_ERROR` on `error.cause.code`, matching
+        // what the node:vm engine already does in runtime.ts.
+        //
+        // The VM serializes errors as `{ name, message, stack }`, so we
+        // reconstruct a host-side Error of the correct class based on the
+        // VM-side `name` — specific WorkflowRuntimeError subclasses need
+        // to be preserved so classifyRunError() tags them as RUNTIME_ERROR.
+        const reconstructed = result.failed.name === 'WorkflowNotRegisteredError'
+            ? new WorkflowNotRegisteredError(workflowName)
+            : result.failed.name === 'Error'
+                ? new Error(result.failed.message)
+                : Object.assign(new Error(result.failed.message), {
+                    name: result.failed.name,
+                });
+        const errorCode = classifyRunError(reconstructed);
+        runtimeLogger.error('QuickJS runtime: workflow failed', {
+            workflowRunId: runId,
+            errorName: result.failed.name,
+            errorMessage: result.failed.message,
+            errorStack,
+            errorCode,
+        });
+        parentSpan?.setAttributes({
+            ...Attribute.QuickJSOutcome('failed'),
+        });
+        // Flush leftover pending side effects before writing run_failed —
+        // same drain semantics as the completed branch.
+        if (result.failed.drainOperations?.length) {
+            try {
+                await dispatchPendingOps({
+                    world,
+                    runId,
+                    workflowRun,
+                    encryptionKey,
+                    namespace,
+                    nextTraceCarrier,
+                    pendingOperations: result.failed.drainOperations,
+                    wfdiag,
+                });
+            }
+            catch (err) {
+                runtimeLogger.warn('QuickJS runtime: terminal drain failed', {
+                    workflowRunId: runId,
+                    message: err?.message,
+                });
+            }
+        }
+        // Create run_failed event. Serialize the error through the
+        // first-class dehydration pipeline so consumers (CLI, observability,
+        // run.returnValue) get the same hydrated value shape as the node:vm
+        // engine emits. Two paths:
+        //   * Modern (valueBytes present): the VM-side rejection handler
+        //     serialized the original thrown value (Error subclass with
+        //     cause chain, plain object, primitive, etc.) using the VM's
+        //     workflow-serialize. Pass those bytes through directly so
+        //     type identity, cause chains, and non-Error throws survive.
+        //     We just need to apply encryption if configured (the VM's
+        //     serializer doesn't have access to the encryption key).
+        //   * Legacy fallback: reconstruct an Error from the host-visible
+        //     {name, message, stack} fields and run it through
+        //     `dehydrateRunError`. Used when valueBytes is absent (e.g.
+        //     extractError pseudo-failures from VM bootstrap).
+        let dehydratedError;
+        if (result.failed.valueBytes) {
+            // Hydrate the VM-side bytes, remap the error stack with the
+            // host-side source map (the VM can't do this — it lacks both the
+            // source map and `remapErrorStack`), and re-dehydrate. This
+            // preserves the original value's type identity / cause chain
+            // while fixing up frames to point at the user's source files.
+            try {
+                const hydrated = await hydrateRunError(result.failed.valueBytes, runId, undefined // VM bytes are unencrypted
+                );
+                if (hydrated &&
+                    typeof hydrated === 'object' &&
+                    'stack' in hydrated &&
+                    typeof hydrated.stack === 'string') {
+                    const parsedName = parseWorkflowName(workflowName);
+                    const filename = parsedName?.moduleSpecifier || workflowName;
+                    hydrated.stack = remapErrorStack(hydrated.stack, filename, workflowCode);
+                }
+                // Walk the cause chain and remap nested stacks too.
+                const seen = new WeakSet();
+                let node = hydrated?.cause;
+                while (node && typeof node === 'object' && !seen.has(node)) {
+                    seen.add(node);
+                    const nodeStack = node.stack;
+                    if (typeof nodeStack === 'string') {
+                        const parsedName = parseWorkflowName(workflowName);
+                        const filename = parsedName?.moduleSpecifier || workflowName;
+                        node.stack = remapErrorStack(nodeStack, filename, workflowCode);
+                    }
+                    node = node.cause;
+                }
+                dehydratedError = await dehydrateRunError(hydrated, runId, encryptionKey);
+            }
+            catch (rehydrateErr) {
+                // If hydration / re-dehydration fails for any reason, fall
+                // back to passing through the original VM bytes (just apply
+                // encryption if configured). Better to lose source-mapped
+                // frames than to lose the error entirely.
+                runtimeLogger.warn('QuickJS runtime: failed to remap workflow error stack, passing VM bytes through', {
+                    workflowRunId: runId,
+                    message: rehydrateErr?.message,
+                });
+                dehydratedError = (await maybeEncrypt(result.failed.valueBytes, encryptionKey));
+            }
+        }
+        else {
+            if (errorStack) {
+                reconstructed.stack = errorStack;
+            }
+            try {
+                dehydratedError = await dehydrateRunError(reconstructed, runId, encryptionKey);
+            }
+            catch (serErr) {
+                // Fall back to a minimal payload so the run still terminates
+                // even when the error itself contains unserializable values.
+                runtimeLogger.warn('QuickJS runtime: failed to dehydrate run error, falling back to bare Error', { workflowRunId: runId, message: serErr?.message });
+                dehydratedError = await dehydrateRunError(Object.assign(new Error(result.failed.message), {
+                    name: result.failed.name,
+                }), runId, encryptionKey);
+            }
+        }
+        try {
+            await world.events.create(runId, {
+                eventType: 'run_failed',
+                specVersion: SPEC_VERSION_CURRENT,
+                eventData: {
+                    error: dehydratedError,
+                    errorCode,
+                },
+            });
+        }
+        catch (err) {
+            if (EntityConflictError.is(err) || RunExpiredError.is(err)) {
+                runtimeLogger.warn('Workflow already finished, skipping run_failed', {
+                    workflowRunId: runId,
+                });
+                wfdiag('exit_failed', { result: 'already_finished' });
+                return;
+            }
+            wfdiag('exit_failed_error', {
+                errorName: err?.name,
+                errorMessage: err?.message,
+            });
+            throw err;
+        }
+        wfdiag('exit_failed', { result: 'run_failed_written' });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quickjs-entrypoint.js","sourceRoot":"","sources":["../../src/runtime/quickjs-entrypoint.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * QuickJS VM integration with the Workflow DevKit.\n *\n * This module provides the entry point for running workflows in the\n * QuickJS WASM VM engine instead of the `node:vm` engine. Both engines\n * implement the same event-replay execution model — every invocation:\n *\n * 1. Loads the full event log for the run\n * 2. Runs the workflow function from the top in a fresh QuickJS VM,\n *    replaying the event log to resolve awaited primitives\n * 3. On suspension: creates events + queues steps for new pending ops\n * 4. On completion: creates run_completed\n * 5. On failure: creates run_failed\n */\n\nimport type { Span } from '@opentelemetry/api';\nimport {\n  EntityConflictError,\n  HookNotFoundError,\n  MaxEventsExceededError,\n  RunExpiredError,\n  WorkflowNotRegisteredError,\n} from '@workflow/errors';\nimport { parseWorkflowName } from '@workflow/utils/parse-name';\nimport {\n  type Event,\n  ROOT_RUN_ID_ATTRIBUTE,\n  type RunInput,\n  SPEC_VERSION_CURRENT,\n  type WorkflowRun,\n} from '@workflow/world';\nimport { classifyRunError } from '../classify-error.js';\nimport { runtimeLogger } from '../logger.js';\nimport {\n  deriveRunPayloadKeys,\n  encrypt as encryptSerializedData,\n  type RunPayloadKeys,\n} from '../serialization/encryption.js';\nimport {\n  dehydrateRunError,\n  hydrateRunError,\n  maybeEncrypt,\n} from '../serialization.js';\nimport { remapErrorStack, stripInlineSourceMap } from '../source-map.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { serializeTraceCarrier } from '../telemetry.js';\nimport {\n  getInlineOwnershipLeaseSeconds,\n  getMaxInlineSteps,\n} from './constants.js';\nimport { getPortLazy } from './get-port-lazy.js';\nimport { getWorkflowQueueName, queueMessage } from './helpers.js';\nimport {\n  type PendingAttribute,\n  type PendingHook,\n  type PendingHookDispose,\n  type PendingOperation,\n  type PendingStep,\n  type PendingWait,\n  startQuickJSWorkflow,\n} from './quickjs-runtime.js';\nimport { ReplayBudget } from './replay-budget.js';\nimport { executeStep, type StepExecutionResult } from './step-executor.js';\nimport { runStepSingleFlight } from './step-single-flight.js';\nimport { getWaitContinuationDispatch } from './wait-continuation.js';\nimport { getWorld } from './world.js';\n\n/** Tiny ms timer using performance.now() — already monotonic on Node. */\nfunction tick(): number {\n  return performance.now();\n}\n\n/**\n * Returns true when the supplied preloaded events indicate this is the\n * first workflow handler invocation for the run — i.e. the log contains\n * nothing beyond `run_created` / `run_started`. In that case the\n * preloaded events ARE the complete event log and the `events.list`\n * round-trips can be skipped entirely.\n *\n * Crucially, if the world backfilled a missing `run_created` via the\n * resilient start path, `preloadedEvents` contains it even when a fresh\n * `events.list` might not (eventual consistency), so preferring the\n * preloaded events on first invocation is also the more correct choice.\n *\n * Returns false when `preloadedEvents` is missing/empty so the caller\n * falls back to the normal fetch path.\n *\n * Exported for unit testing.\n */\nexport function isFirstInvocation(\n  preloadedEvents: readonly Event[] | undefined\n): boolean {\n  if (!Array.isArray(preloadedEvents) || preloadedEvents.length === 0) {\n    return false;\n  }\n  return preloadedEvents.every(\n    (e) => e.eventType === 'run_created' || e.eventType === 'run_started'\n  );\n}\n\n/**\n * Queue a step for background execution via the unified workflow queue\n * (V2 architecture). The combined handler in runtime.ts dispatches\n * messages with `stepId` to executeStep, which works for both VM engines.\n * `delaySeconds` supports retry/throttle backoff.\n */\nasync function queueStepMessage(params: {\n  world: Awaited<ReturnType<typeof getWorld>>;\n  runId: string;\n  workflowRun: WorkflowRun;\n  step: PendingStep;\n  delaySeconds?: number;\n  /** Queue namespace for the publish (see runtime.ts). */\n  namespace: string | undefined;\n  /** Run-origin trace carrier accessor (see runWorkflowWithQuickJS). */\n  nextTraceCarrier: () => Promise<Record<string, string>>;\n  /**\n   * Publish purpose, used to bucket the idempotency key. Worlds retire\n   * used keys (VQS retention TTL, world-postgres completed-keys cache),\n   * so a key shared across purposes silently swallows the second\n   * publish — see wait-continuation.ts for the same hazard on wait\n   * keys. `dispatch` is the plain background handoff (overflow / crash\n   * recovery) and keeps the bare correlationId so it stays mutually\n   * exclusive with the node engine's dispatch of the same step;\n   * `backstop:<epoch>` covers delayed crash backstops, scoped to the\n   * ownership epoch so a refreshed lease re-arms a NEW backstop instead\n   * of being absorbed by the in-flight one; `retry:<n>` covers delayed\n   * retry/throttle re-enqueues, scoped to the attempt so each backoff\n   * hop is enqueueable.\n   */\n  purpose: 'dispatch' | `backstop:${string}` | `retry:${number}`;\n  wfdiag: (checkpoint: string, fields: Record<string, unknown>) => void;\n}): Promise<void> {\n  const {\n    world,\n    runId,\n    workflowRun,\n    step,\n    delaySeconds,\n    namespace,\n    nextTraceCarrier,\n    purpose,\n    wfdiag,\n  } = params;\n  const traceCarrier = await nextTraceCarrier();\n  await queueMessage(\n    world,\n    getWorkflowQueueName(workflowRun.workflowName, namespace),\n    {\n      runId,\n      stepId: step.correlationId,\n      stepName: step.stepId,\n      traceCarrier,\n      requestedAt: new Date(),\n    },\n    {\n      idempotencyKey:\n        purpose === 'dispatch'\n          ? step.correlationId\n          : `${step.correlationId}:${purpose}`,\n      ...(delaySeconds && delaySeconds > 0 ? { delaySeconds } : {}),\n    }\n  );\n  wfdiag('step_queued', {\n    stepId: step.stepId,\n    correlationId: step.correlationId,\n    purpose,\n    delaySeconds: delaySeconds ?? 0,\n  });\n}\n\n/**\n * Dispatch durable side effects for a set of pending VM operations:\n * step_created (+ optional queueing), hook_created / hook_received (aborts),\n * attr_set, hook_disposed, and wait_created events.\n *\n * Steps are created but never queued here — queueing (or inline\n * execution) is the caller's decision. Used both for suspension\n * processing (the inline loop) and for the terminal drain (flushing\n * leftover side effects when the workflow completed or failed, mirroring\n * the node:vm engine's drainPendingQueueItems).\n */\nasync function dispatchPendingOps(params: {\n  world: Awaited<ReturnType<typeof getWorld>>;\n  runId: string;\n  workflowRun: WorkflowRun;\n  encryptionKey: RunPayloadKeys | undefined;\n  pendingOperations: PendingOperation[];\n  /**\n   * Step cids whose `step_created` must NOT be written here: the inline\n   * loop claims these atomically via a lazy `step_started` (carrying the\n   * input), so a concurrent claimant loses with EntityConflictError\n   * instead of both invocations bare-starting the same step.\n   */\n  skipStepCreation?: Set<string>;\n  /** Queue namespace for all message publishes (see runtime.ts). */\n  namespace: string | undefined;\n  /**\n   * Run-origin trace carrier accessor from runtime.ts. In the default\n   * `linked` trace mode this returns the carrier of the run's ORIGIN\n   * context (workflow.start), so every invocation links back to the\n   * start in a star — capturing the current context here instead would\n   * chain invocations to each other and fragment the run view on async\n   * queues.\n   */\n  nextTraceCarrier: () => Promise<Record<string, string>>;\n  wfdiag: (checkpoint: string, fields: Record<string, unknown>) => void;\n}): Promise<{\n  createdAttributeEvent: boolean;\n  createdGetConflictHook: boolean;\n}> {\n  const {\n    world,\n    runId,\n    workflowRun,\n    encryptionKey,\n    pendingOperations,\n    namespace,\n    nextTraceCarrier,\n  } = params;\n  const skipStepCreation = params.skipStepCreation;\n  const wfdiag = params.wfdiag;\n  // Set when a hook with a parked getConflict() awaiter had its\n  // hook_created written this invocation. The workflow must be re-invoked\n  // so replay can confirm creation and resolve the awaiter.\n  let createdGetConflictHook = false;\n  // Set when a new attr_set event is written this invocation. The\n  // workflow must be re-invoked to consume it (resolving the pending\n  // setAttributes() promise), so the entrypoint requeues immediately —\n  // same pattern as an elapsed wait.\n  let createdAttributeEvent = false;\n  const opsPromises: Promise<void>[] = [];\n\n  const processHookOp = async (hook: PendingHook): Promise<void> => {\n    runtimeLogger.debug('QuickJS runtime: processing hook op', {\n      workflowRunId: runId,\n      correlationId: hook.correlationId,\n      token: hook.token,\n      tokenType: typeof hook.token,\n      isWebhook: hook.isWebhook,\n      isSystem: hook.isSystem,\n      hasCreatedEvent: hook.hasCreatedEvent,\n      abortRequested: hook.abortRequested,\n    });\n\n    if (!hook.hasCreatedEvent) {\n      // `hook.metadata` is the format-prefixed devalue bytes\n      // produced by `globalThis[Symbol.for('workflow-serialize')]\n      // (options.metadata)` inside the VM. Encrypt on the host\n      // side before writing — matches the node:vm engine's\n      // `dehydrateStepArguments` flow.\n      //\n      // No pre-check via hooks.list: with deterministic correlationIds\n      // (same VM seed across replays) and per-(runId, correlationId)\n      // uniqueness in worlds, the storage layer rejects duplicates as\n      // EntityConflictError, which we swallow below. This drops one\n      // network round-trip per pending hook.\n      try {\n        const encryptedMetadata =\n          typeof hook.metadata === 'undefined'\n            ? undefined\n            : await encryptSerializedData(hook.metadata, encryptionKey);\n        const result = await world.events.create(runId, {\n          eventType: 'hook_created',\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: hook.correlationId,\n          eventData: {\n            token: hook.token,\n            tokenRetentionUntil:\n              hook.tokenRetentionUntil === undefined\n                ? undefined\n                : new Date(hook.tokenRetentionUntil),\n            metadata: encryptedMetadata,\n            // Always include isWebhook explicitly. Worlds default it to\n            // `true` when absent, which would break the public webhook\n            // endpoint's 404 guard for hooks created via createHook().\n            isWebhook: hook.isWebhook,\n            // System hooks (AbortController) are exempt from user\n            // token namespace conflict checks.\n            ...(hook.isSystem ? { isSystem: true } : {}),\n          } as any,\n        });\n\n        // If storage detected a real token conflict with another\n        // workflow's hook, re-queue so the workflow handler can\n        // process the conflict event and fail gracefully.\n        if (result.event?.eventType === 'hook_conflict') {\n          await queueMessage(\n            world,\n            getWorkflowQueueName(workflowRun.workflowName, namespace),\n            {\n              runId,\n              traceCarrier: await nextTraceCarrier(),\n              requestedAt: new Date(),\n            },\n            { idempotencyKey: `hook_conflict_${hook.correlationId}` }\n          );\n        }\n      } catch (err) {\n        // Already created by a concurrent invocation — fall through\n        // to abort processing below (if any) instead of bailing.\n        if (!EntityConflictError.is(err)) throw err;\n      }\n      if (hook.hasGetConflictAwaiter) {\n        createdGetConflictHook = true;\n      }\n    }\n\n    if (hook.abortRequested) {\n      // Record the abort durably: a hook_received event carrying\n      // the VM-serialized `{ aborted: true, reason }` payload,\n      // plus a best-effort stream packet for real-time step\n      // propagation. Mirrors the node:vm engine's suspension\n      // handler (hooksNeedingAbort).\n      const abortPayload =\n        hook.abortPayload instanceof Uint8Array\n          ? ((await encryptSerializedData(\n              hook.abortPayload,\n              encryptionKey\n            )) as Uint8Array)\n          : undefined;\n      try {\n        await world.events.create(runId, {\n          eventType: 'hook_received',\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: hook.correlationId,\n          eventData: {\n            token: hook.token,\n            payload: abortPayload,\n          } as any,\n        });\n      } catch (err) {\n        if (!EntityConflictError.is(err)) throw err;\n      }\n      // streamName is derived from the abort hook token\n      // (`abrt_{id}` → `strm_{id}_system_abort`).\n      if (hook.token.startsWith('abrt_') && abortPayload) {\n        const streamName = `strm_${hook.token.slice('abrt_'.length)}_system_abort`;\n        try {\n          await world.streams.write(runId, streamName, abortPayload);\n          await world.streams.close(runId, streamName);\n        } catch {\n          // Best-effort — the hook event provides the durable\n          // fallback.\n          runtimeLogger.debug(\n            'QuickJS runtime: failed to write abort stream packet',\n            {\n              workflowRunId: runId,\n              correlationId: hook.correlationId,\n            }\n          );\n        }\n      }\n      wfdiag('abort_recorded', {\n        correlationId: hook.correlationId,\n        token: hook.token,\n      });\n    }\n  };\n\n  const processHookDisposeOp = async (\n    op: PendingHookDispose\n  ): Promise<void> => {\n    try {\n      await world.events.create(runId, {\n        eventType: 'hook_disposed',\n        specVersion: SPEC_VERSION_CURRENT,\n        correlationId: op.correlationId,\n      });\n    } catch (err) {\n      if (EntityConflictError.is(err)) return;\n      // Disposing a hook whose entity no longer (or never) exists is an\n      // idempotent no-op: the entity may have been torn down by a\n      // concurrent run cancellation, or the hook may have lost its\n      // token claim to a conflict. There is nothing left to release.\n      if (HookNotFoundError.is(err)) return;\n      throw err;\n    }\n  };\n\n  // Hook operations are grouped by token and processed SEQUENTIALLY in\n  // code order within each group, mirroring the node:vm suspension\n  // handler (hookItemsByToken): a dispose() of an earlier hook must\n  // release the token before a later same-token hook's creation is\n  // validated by the world — parallel dispatch would otherwise record a\n  // spurious hook_conflict against the run's own disposed hook (e.g. a\n  // dispose→recreate loop reusing one token). Different tokens have no\n  // claim interaction, so token groups run in parallel with each other\n  // and with the non-hook ops below.\n  const hookOpsByToken = new Map<\n    string,\n    (PendingHook | PendingHookDispose)[]\n  >();\n  for (const op of pendingOperations) {\n    let key: string | undefined;\n    if (\n      op.type === 'hook' &&\n      (!op.hasCreatedEvent || (op as PendingHook).abortRequested)\n    ) {\n      key = (op as PendingHook).token;\n    } else if (op.type === 'hook_dispose' && !op.hasCreatedEvent) {\n      // Per-op fallback group when the token is unknown — no ordering\n      // guarantees, matching the previous parallel behavior.\n      key = (op as PendingHookDispose).token ?? `__cid:${op.correlationId}`;\n    }\n    if (key === undefined) continue;\n    const group = hookOpsByToken.get(key);\n    if (group) {\n      group.push(op as PendingHook | PendingHookDispose);\n    } else {\n      hookOpsByToken.set(key, [op as PendingHook | PendingHookDispose]);\n    }\n  }\n  for (const group of hookOpsByToken.values()) {\n    opsPromises.push(\n      (async () => {\n        for (const op of group) {\n          if (op.type === 'hook') {\n            await processHookOp(op);\n          } else {\n            await processHookDisposeOp(op);\n          }\n        }\n      })()\n    );\n  }\n\n  for (const op of pendingOperations) {\n    if (\n      op.type === 'step' &&\n      !op.hasCreatedEvent &&\n      !skipStepCreation?.has(op.correlationId)\n    ) {\n      const step = op as PendingStep;\n      opsPromises.push(\n        (async () => {\n          // Create step_created event. `step.input` is the\n          // format-prefixed devalue bytes (\"devl\" + devalue) produced\n          // by `globalThis[Symbol.for('workflow-serialize')]({args,\n          // closureVars, thisVal})` inside the VM. The VM has no\n          // access to the CryptoKey, so encryption is applied here\n          // on the host side — matching what\n          // `dehydrateStepArguments` does in the node:vm engine.\n          try {\n            await world.events.create(runId, {\n              eventType: 'step_created',\n              specVersion: SPEC_VERSION_CURRENT,\n              correlationId: step.correlationId,\n              eventData: {\n                stepName: step.stepId,\n                input: await encryptSerializedData(step.input, encryptionKey),\n              },\n            });\n          } catch (err) {\n            if (EntityConflictError.is(err)) return;\n            throw err;\n          }\n\n          // NOTE: step queueing is the caller's decision — the inline\n          // loop executes fresh steps in the live VM and only queues the\n          // overflow / retry / backstop cases (see queueStepMessage).\n        })()\n      );\n    } else if (op.type === 'attribute' && !op.hasCreatedEvent) {\n      const attr = op as PendingAttribute;\n      opsPromises.push(\n        (async () => {\n          try {\n            await world.events.create(runId, {\n              eventType: 'attr_set',\n              specVersion: SPEC_VERSION_CURRENT,\n              correlationId: attr.correlationId,\n              eventData: {\n                changes: attr.changes,\n                writer: { type: 'workflow' },\n                ...(attr.allowReservedAttributes\n                  ? { allowReservedAttributes: true }\n                  : {}),\n              } as any,\n            });\n            createdAttributeEvent = true;\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              // Event already exists (concurrent invocation) — the\n              // replay still needs to consume it, so requeue.\n              createdAttributeEvent = true;\n              return;\n            }\n            throw err;\n          }\n        })()\n      );\n    } else if (op.type === 'wait' && !op.hasCreatedEvent) {\n      const wait = op as PendingWait;\n      opsPromises.push(\n        (async () => {\n          try {\n            await world.events.create(runId, {\n              eventType: 'wait_created',\n              specVersion: SPEC_VERSION_CURRENT,\n              correlationId: wait.correlationId,\n              eventData: {\n                resumeAt: new Date(wait.resumeAt),\n              },\n            });\n          } catch (err) {\n            if (EntityConflictError.is(err)) return;\n            throw err;\n          }\n        })()\n      );\n    }\n  }\n\n  // Per-op dispatch runs in parallel.\n  await Promise.all(opsPromises);\n\n  return { createdAttributeEvent, createdGetConflictHook };\n}\n\n/**\n * Run a workflow using the QuickJS WASM VM engine.\n *\n * This replaces the `node:vm` replay path (runWorkflow + EventsConsumer)\n * with a QuickJS VM invocation that performs the same full event replay.\n *\n * KNOWN GAP — precondition guard: unlike the node:vm path, no event write\n * in this file participates in the optimistic-concurrency precondition\n * guard (`withPreconditionRetry` + `stateUpdatedAtForCreate`), which\n * protects a writer holding a stale event-log snapshot from clobbering a\n * concurrent one. The engine currently relies on per-(runId,\n * correlationId) event uniqueness (EntityConflictError dedup) alone. This\n * is a deliberate simplification while the engine is experimental — wiring\n * the guard is tracked follow-up work; anyone adding new write paths here\n * should not assume parity with the node engine on this axis.\n */\nexport async function runWorkflowWithQuickJS(params: {\n  workflowCode: string;\n  workflowName: string;\n  workflowRun: WorkflowRun;\n  /**\n   * Events returned inline by `events.create('run_started', ...)` or by\n   * the lazy hook fast path's `hook_received` preload. When they indicate\n   * a first invocation — or when `preloadedEventsComplete` attests they\n   * are the complete log — they are used as the event log instead of\n   * fetching via `events.list`, matching the node:vm engine's fast path.\n   */\n  preloadedEvents?: Event[];\n  /**\n   * True when the caller has validated that `preloadedEvents` is the run's\n   * COMPLETE event log (e.g. the lazy hook fast path's hasMore-false\n   * replay preload). The first-invocation heuristic below only recognizes\n   * run_created/run_started-only preloads, so without this attestation a\n   * hook-resume preload would be discarded and refetched.\n   */\n  preloadedEventsComplete?: boolean;\n  /**\n   * Run input carried through the queue message on first delivery. Used\n   * as a last-resort fallback for `run_created.eventData.input` when\n   * the event log is incomplete.\n   */\n  runInput?: RunInput;\n  /**\n   * The parent OTel span (the outer `WORKFLOW {workflowName}` span from\n   * `runtime.ts`). When supplied, VM lifecycle attributes are attached\n   * to it for end-to-end visibility.\n   */\n  parentSpan?: Span;\n  /**\n   * Server-supplied per-run event ceiling from the run_started response\n   * (undefined ⇒ no enforcement). Mirrors the node:vm engine's guard:\n   * a runaway run is failed once its log reaches the ceiling. The throw\n   * propagates to the replay loop's catch in runtime.ts (the QuickJS\n   * dispatch runs inside that loop's try), which classifies it and\n   * records run_failed with MAX_EVENTS_EXCEEDED.\n   */\n  maxEventsLimit?: number;\n  /**\n   * Queue delivery attempt of the message driving this invocation (from\n   * the queue handler's metadata; 1 = first delivery). Surfaced in\n   * diagnostics; crash recovery itself is driven by the ownership-lease\n   * decision table in the loop, not by the attempt count.\n   */\n  deliveryAttempt?: number;\n  /**\n   * Queue message ID of the delivery driving this invocation, stamped as\n   * `ownerMessageId` on inline lazy step claims so wake replays defer to\n   * the in-flight body instead of requeueing the step.\n   */\n  ownerMessageId?: string;\n  /**\n   * Queue namespace resolved at route registration (runtime.ts). Must be\n   * threaded into every message publish: the builders bake the namespace\n   * into generated routes, so consumers listen on `__<ns>_wkf_workflow_*`\n   * — a publish without it lands on `__wkf_workflow_*` and is never\n   * picked up.\n   */\n  namespace?: string;\n  /**\n   * Run-origin trace carrier accessor from runtime.ts\n   * (getNextTraceCarrier). In the default `linked` trace mode every\n   * invocation must link back to the run's origin (workflow.start) in a\n   * star; capturing the current invocation context instead would chain\n   * invocations to each other and fragment the run view on async queues.\n   */\n  nextTraceCarrier?: () => Promise<Record<string, string>>;\n}): Promise<{ timeoutSeconds?: number } | void> {\n  const {\n    workflowCode,\n    workflowName,\n    workflowRun,\n    preloadedEvents,\n    preloadedEventsComplete,\n    runInput,\n    parentSpan,\n    maxEventsLimit,\n    deliveryAttempt,\n    ownerMessageId,\n    namespace,\n  } = params;\n  // Standalone-caller fallback (tests): without a runtime.ts carrier\n  // accessor, fall back to the current invocation context.\n  const nextTraceCarrier =\n    params.nextTraceCarrier ?? (() => serializeTraceCarrier());\n  const world = await getWorld();\n  const runId = workflowRun.runId;\n  const invocationStart = tick();\n\n  // Strip the inline source map comment before evaluating the bundle in\n  // the QuickJS VM. The map is purely host-side metadata for\n  // `remapErrorStack` (called below on workflow failures, against the\n  // ORIGINAL `workflowCode`). QuickJS retains source text for\n  // stack-trace line lookups, so the few-MB base64 comment would bloat\n  // the VM heap for no benefit.\n  const workflowCodeForVM = stripInlineSourceMap(workflowCode);\n\n  // Per-invocation diagnostic id so debug logs can be correlated even if\n  // the same runId is processed by overlapping invocations on different\n  // function instances.\n  const invocationId = `inv_${Math.random().toString(36).slice(2, 10)}`;\n\n  // Structured per-checkpoint diagnostic helper, grep-friendly by runId.\n  const wfdiag = (checkpoint: string, fields: Record<string, unknown>) => {\n    runtimeLogger.debug('QUICKJS_VM_DIAG', {\n      checkpoint,\n      runId,\n      invocationId,\n      tElapsedMs: Math.round(tick() - invocationStart),\n      ...fields,\n    });\n  };\n\n  parentSpan?.setAttributes({\n    ...Attribute.WorkflowVm('quickjs'),\n  });\n\n  wfdiag('enter', {\n    workflowName,\n    deliveryAttempt,\n    hasPreloadedEvents:\n      Array.isArray(preloadedEvents) && preloadedEvents.length > 0,\n    preloadedEventCount: preloadedEvents?.length ?? 0,\n    hasRunInput: !!runInput,\n  });\n\n  // The workflowName from the queue topic is already the full workflow ID\n  // (e.g. \"workflow//./workflows/1_simple//simple\")\n  const workflowId = workflowName;\n\n  // Resolve the encryption key up front — needed to decrypt event\n  // payloads inside the VM and to encrypt event payloads written below.\n  // Resolve the FULL capability (symmetric AES key + X25519 keypair), not\n  // just `importKey(rawKey)`: a run reading its own event log can encounter\n  // sealed (`encp`) hook payloads that a cross-deployment `resumeHook()`\n  // wrote to it (sealing is presence-gated on the run's published\n  // encryptionPublicKey, which the shared start() path stamps regardless of\n  // engine). A bare symmetric key cannot open those and would wedge the run\n  // right after hook_received — the node:vm engine resolves the same full\n  // capability via memoizeEncryptionKey.\n  const rawKey = await world.getEncryptionKeyForRun?.(workflowRun);\n  const encryptionKey = rawKey ? await deriveRunPayloadKeys(rawKey) : undefined;\n\n  // Load the FULL event log for the run. On first invocation the\n  // preloaded events from the run_started response are the complete log\n  // and save the events.list round-trips; a caller-attested complete\n  // preload (lazy hook fast path) is trusted the same way.\n  let events: Event[];\n  let eventsFetchedPages = 0;\n  const usePreloaded =\n    (preloadedEventsComplete === true &&\n      Array.isArray(preloadedEvents) &&\n      preloadedEvents.length > 0) ||\n    isFirstInvocation(preloadedEvents);\n  if (usePreloaded && preloadedEvents) {\n    events = preloadedEvents;\n  } else {\n    const allEvents: Event[] = [];\n    let cursor: string | null = null;\n    let hasMore = true;\n\n    while (hasMore) {\n      const response = await world.events.list({\n        runId,\n        pagination: {\n          sortOrder: 'asc',\n          cursor: cursor ?? undefined,\n          limit: 1000,\n        },\n      });\n      eventsFetchedPages++;\n      allEvents.push(...response.data);\n      // Update the cursor to the last successfully fetched page's cursor.\n      // Only update when we got results — the final empty-page response\n      // returns cursor=null which we must NOT use (it would reset the cursor).\n      if (response.cursor) {\n        cursor = response.cursor;\n      }\n      hasMore = response.data.length > 0 && response.cursor != null;\n    }\n\n    events = allEvents;\n  }\n\n  // Event-limit guard: fail a runaway run once its log reaches the\n  // server-supplied ceiling — same enforcement point as the node:vm\n  // engine's replay loop.\n  if (maxEventsLimit !== undefined && events.length >= maxEventsLimit) {\n    throw new MaxEventsExceededError(events.length, maxEventsLimit);\n  }\n\n  parentSpan?.setAttributes({\n    ...Attribute.QuickJSEventsPreloaded(usePreloaded),\n    ...Attribute.QuickJSEventsFetchedCount(events.length),\n    ...Attribute.QuickJSEventsFetchedPages(eventsFetchedPages),\n  });\n\n  wfdiag('events_fetched', {\n    eventCount: events.length,\n    eventsFetchedPages,\n    usePreloaded,\n    eventTypes: events.reduce<Record<string, number>>((acc, e) => {\n      acc[e.eventType] = (acc[e.eventType] ?? 0) + 1;\n      return acc;\n    }, {}),\n  });\n\n  // Check for elapsed waits\n  const now = Date.now();\n  const completedWaitIds = new Set(\n    events\n      .filter((e) => e.eventType === 'wait_completed')\n      .map((e) => e.correlationId)\n  );\n  for (const event of events) {\n    if (\n      event.eventType === 'wait_created' &&\n      event.correlationId &&\n      !completedWaitIds.has(event.correlationId)\n    ) {\n      const eventData =\n        'eventData' in event\n          ? (event.eventData as Record<string, unknown>)\n          : undefined;\n      const resumeAt = eventData?.resumeAt;\n      if (resumeAt && now >= new Date(resumeAt as string).getTime()) {\n        try {\n          const result = await world.events.create(runId, {\n            eventType: 'wait_completed',\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: event.correlationId,\n          });\n          if (result.event) events.push(result.event);\n        } catch (err) {\n          if (EntityConflictError.is(err)) continue;\n          throw err;\n        }\n      }\n    }\n  }\n\n  // Resolve the workflow server port so `getWorkflowMetadata().url` inside\n  // the VM matches what the step-side handler reports. Skipped on Vercel —\n  // the VM reads VERCEL_URL directly in that environment.\n  const isVercel = process.env.VERCEL_URL !== undefined;\n  const port = isVercel ? undefined : await getPortLazy();\n\n  // Run the workflow in the QuickJS VM\n  runtimeLogger.debug('QuickJS runtime: invoking VM', {\n    workflowRunId: runId,\n    workflowId,\n    eventCount: events.length,\n  });\n\n  const session = await startQuickJSWorkflow({\n    // Pass the STRIPPED bundle to the VM so the inline source map\n    // doesn't end up in the QuickJS heap. The original (unstripped)\n    // `workflowCode` is still kept in this host-side scope and is used\n    // by `remapErrorStack` on workflow failures below.\n    workflowCode: workflowCodeForVM,\n    workflowId,\n    workflowRun,\n    events,\n    worldCapabilities: world.capabilities,\n    encryptionKey,\n    port,\n    runInput,\n  });\n  let result = session.result;\n\n  runtimeLogger.debug('QuickJS runtime: VM returned', {\n    workflowRunId: runId,\n    completed: !!result.completed,\n    suspended: !!result.suspended,\n    failed: !!result.failed,\n    pendingOpsCount: result.suspended?.pendingOperations?.length,\n  });\n\n  wfdiag('vm_returned', {\n    outcome: result.completed\n      ? 'completed'\n      : result.suspended\n        ? 'suspended'\n        : result.failed\n          ? 'failed'\n          : 'unknown',\n    pendingOpsCount: result.suspended?.pendingOperations?.length ?? 0,\n    pendingOpSummary: result.suspended?.pendingOperations?.map((p) => ({\n      type: p.type,\n      correlationId: p.correlationId,\n      hasCreatedEvent: p.hasCreatedEvent,\n      ...(p.type === 'step' ? { stepId: (p as PendingStep).stepId } : {}),\n    })),\n    failureMessage: result.failed?.message,\n    failureName: result.failed?.name,\n  });\n\n  // ---- Inline continuation loop ----\n  //\n  // While the workflow is suspended, this loop keeps the VM alive and\n  // makes as much forward progress as possible within one invocation:\n  //\n  //   1. Dispatch durable side effects for the suspension's pending ops\n  //      (step_created / hook_created / attr_set / wait_created /\n  //      hook_received for aborts) and complete elapsed waits.\n  //   2. Feed all newly recorded events (attr_set, hook_created, elapsed\n  //      wait_completed, terminals written by concurrent invocations, ...)\n  //      into the LIVE VM via session.continueWithEvents — resuming\n  //      execution exactly where it left off, no fresh-VM re-replay.\n  //      Cheap progress is fed BEFORE running step bodies so promise\n  //      chains that are not gated on steps (hook.getConflict(),\n  //      setAttributes(), racing sleeps) advance first and can surface\n  //      additional pending steps for the same inline batch.\n  //   3. Once no cheap progress remains, execute up to\n  //      getMaxInlineSteps() steps created by THIS invocation inline (no\n  //      queue round-trip), in parallel, with the replay budget paused\n  //      during step bodies — mirroring the node:vm engine's inline\n  //      replay loop. Overflow and retry/throttled steps are queued for\n  //      background execution. A delayed wait-continuation message is\n  //      enqueued for the soonest pending wait first, so racing timers\n  //      fire on time (in a separate invocation) while step bodies block\n  //      this one.\n  //\n  // The loop exits when the workflow settles, no forward progress is\n  // possible in-process, the replay budget is exhausted, or the run is\n  // gone.\n  const seenEventIds = new Set<string>();\n  for (const e of events) {\n    if (e.eventId) seenEventIds.add(e.eventId);\n  }\n  // Step cids already executed inline by this invocation.\n  const executedStepIds = new Set<string>();\n  // Steps for which THIS invocation already sent a queue message.\n  const queuedStepIds = new Set<string>();\n  // Aborts THIS invocation already recorded (hook_received written) —\n  // guards against re-recording when the VM-side flag has not been\n  // cleared yet within the same iteration.\n  const recordedAbortIds = new Set<string>();\n  // Waits for which THIS invocation already completed/scheduled work.\n  const completedWaitIds2 = new Set<string>();\n  // Inline-ownership state per step correlationId, derived from every\n  // event this invocation observes (initial log + every feed) — the\n  // quickjs analog of the replay-derived ownership on the node engine's\n  // StepInvocationQueueItem (see step-ownership.ts). Latest-wins:\n  // events arrive in log order, so a later step_started overwrites the\n  // stamp; a step_retrying lapses ownership permanently for the id.\n  const stepOwnership = new Map<\n    string,\n    { owner?: string; startedAtMs?: number; sawRetrying: boolean }\n  >();\n  const observeEventsForOwnership = (observed: Event[]): void => {\n    for (const e of observed) {\n      if (e.correlationId === undefined) continue;\n      if (e.eventType === 'step_started') {\n        const owner =\n          'eventData' in e &&\n          e.eventData &&\n          'ownerMessageId' in e.eventData &&\n          typeof e.eventData.ownerMessageId === 'string'\n            ? e.eventData.ownerMessageId\n            : undefined;\n        const prior = stepOwnership.get(e.correlationId);\n        stepOwnership.set(e.correlationId, {\n          owner,\n          startedAtMs: e.createdAt ? +new Date(e.createdAt) : undefined,\n          sawRetrying: prior?.sawRetrying ?? false,\n        });\n      } else if (e.eventType === 'step_retrying') {\n        const prior = stepOwnership.get(e.correlationId);\n        stepOwnership.set(e.correlationId, {\n          ...(prior ?? {}),\n          sawRetrying: true,\n        });\n      }\n    }\n  };\n  observeEventsForOwnership(events);\n  const scheduledWaitContinuations = new Set<string>();\n  const maxInlineSteps = getMaxInlineSteps();\n  const budget = new ReplayBudget();\n  const workflowStartedAt = workflowRun.startedAt\n    ? +workflowRun.startedAt\n    : Date.now();\n  const rootRunId =\n    (workflowRun.attributes as Record<string, string> | undefined)?.[\n      ROOT_RUN_ID_ATTRIBUTE\n    ] ?? runId;\n  let inlineStepsExecuted = 0;\n  let runGone = false;\n  // Set when this invocation wrote an event the workflow must consume to\n  // make progress (attr_set, getConflict-awaited hook_created) and the\n  // loop has not yet read it back — eventually-consistent listings can\n  // return 0 new events right after a write. If it is still set when the\n  // loop exits suspended, the entrypoint requeues immediately instead of\n  // exiting awaiting_external with the unblocking event already written\n  // and nothing scheduled to read it.\n  let pendingRequeueSignal = false;\n\n  /** Fetch all events not yet processed by the live VM (log order). */\n  const fetchUnseenEvents = async (): Promise<Event[]> => {\n    const unseen: Event[] = [];\n    let cursor: string | null = null;\n    let hasMore = true;\n    while (hasMore) {\n      const response = await world.events.list({\n        runId,\n        pagination: {\n          sortOrder: 'asc',\n          cursor: cursor ?? undefined,\n          limit: 1000,\n        },\n      });\n      for (const e of response.data) {\n        if (e.eventId && seenEventIds.has(e.eventId)) continue;\n        if (e.eventId) seenEventIds.add(e.eventId);\n        unseen.push(e);\n      }\n      if (response.cursor) cursor = response.cursor;\n      hasMore = response.data.length > 0 && response.cursor != null;\n    }\n    observeEventsForOwnership(unseen);\n    return unseen;\n  };\n\n  try {\n    let iteration = 0;\n    while (result.suspended && !runGone && !budget.isExhausted()) {\n      iteration++;\n      // Re-check the event ceiling every turn: the loop appends events on\n      // each continueWithEvents, so a single invocation can otherwise grow\n      // the log arbitrarily far past the operator's limit (the node engine\n      // re-checks per replay for the same reason). `seenEventIds` counts\n      // every event this invocation has observed — initial log + all\n      // feeds.\n      if (maxEventsLimit !== undefined && seenEventIds.size >= maxEventsLimit) {\n        throw new MaxEventsExceededError(seenEventIds.size, maxEventsLimit);\n      }\n      const pendingOperations = result.suspended.pendingOperations;\n\n      // Select this turn's inline candidates BEFORE dispatch: fresh steps\n      // (no step_created yet) that this invocation hasn't already handled.\n      // Their step_created is deliberately NOT written by dispatch — the\n      // inline claim below is a lazy step_started carrying the input,\n      // which the world applies as an atomic create-claim. A concurrent\n      // invocation racing on the same fresh step loses that claim with\n      // EntityConflictError and skips, so step bodies cannot double-run\n      // (previously both invocations bare-started the step after one lost\n      // the swallowed step_created race).\n      const freshSteps = pendingOperations.filter(\n        (op): op is PendingStep =>\n          op.type === 'step' &&\n          !op.hasCreatedEvent &&\n          !executedStepIds.has(op.correlationId) &&\n          !queuedStepIds.has(op.correlationId)\n      );\n      const inlineCandidates =\n        maxInlineSteps <= 0 ? [] : freshSteps.slice(0, maxInlineSteps);\n      const inlineClaimCids = new Set(\n        inlineCandidates.map((step) => step.correlationId)\n      );\n\n      // 1. Durable side effects for this suspension's pending ops.\n      const opsToDispatch = pendingOperations.map((op) =>\n        op.type === 'hook' &&\n        (op as PendingHook).abortRequested &&\n        recordedAbortIds.has(op.correlationId)\n          ? ({ ...op, abortRequested: false } as PendingOperation)\n          : op\n      );\n      for (const op of pendingOperations) {\n        if (op.type === 'hook' && (op as PendingHook).abortRequested) {\n          recordedAbortIds.add(op.correlationId);\n        }\n      }\n      const dispatched = await dispatchPendingOps({\n        world,\n        runId,\n        workflowRun,\n        encryptionKey,\n        namespace,\n        nextTraceCarrier,\n        pendingOperations: opsToDispatch,\n        skipStepCreation: inlineClaimCids,\n        wfdiag,\n      });\n      if (\n        dispatched.createdAttributeEvent ||\n        dispatched.createdGetConflictHook\n      ) {\n        pendingRequeueSignal = true;\n      }\n\n      // Hand steps beyond the inline cap to the queue NOW — in the same\n      // turn their step_created was written by the dispatch above. This\n      // must happen BEFORE the event feed below: the feed always observes\n      // those very step_created writes as unseen events and `continue`s,\n      // so a handoff placed after it is unreachable on the only iteration\n      // that still classifies these steps as fresh — next turn they carry\n      // hasCreatedEvent and would never be queued at all (the wedge behind\n      // promiseRaceStressTestWorkflow hanging in the quickjs CI legs). The\n      // bare-correlationId idempotency key makes repeats harmless.\n      const overflowSteps = freshSteps.slice(inlineCandidates.length);\n      for (const step of overflowSteps) {\n        queuedStepIds.add(step.correlationId);\n        await queueStepMessage({\n          world,\n          runId,\n          workflowRun,\n          step,\n          namespace,\n          nextTraceCarrier,\n          purpose: 'dispatch',\n          wfdiag,\n        });\n      }\n\n      // Complete elapsed waits so their wait_completed events are picked\n      // up by the feed below (instead of a queue re-invocation).\n      const waitCompletePromises: Promise<void>[] = [];\n      for (const op of pendingOperations) {\n        if (op.type !== 'wait') continue;\n        const wait = op as PendingWait;\n        if (completedWaitIds2.has(wait.correlationId)) continue;\n        if (new Date(wait.resumeAt).getTime() - Date.now() > 0) continue;\n        completedWaitIds2.add(wait.correlationId);\n        waitCompletePromises.push(\n          (async () => {\n            try {\n              await world.events.create(runId, {\n                eventType: 'wait_completed',\n                specVersion: SPEC_VERSION_CURRENT,\n                correlationId: wait.correlationId,\n              });\n            } catch (err) {\n              if (EntityConflictError.is(err)) return;\n              throw err;\n            }\n          })()\n        );\n      }\n      if (waitCompletePromises.length > 0) {\n        await Promise.all(waitCompletePromises);\n      }\n\n      // 2. Cheap progress first: feed newly recorded events into the live\n      // VM before blocking on step bodies.\n      {\n        const newEvents = await fetchUnseenEvents();\n        if (newEvents.length > 0) {\n          // The listing caught up with this invocation's writes — any\n          // attr_set / getConflict hook_created has been (or is being)\n          // consumed by the live VM, so no external requeue is needed.\n          pendingRequeueSignal = false;\n          result = await session.continueWithEvents(newEvents);\n          wfdiag('inline_iteration', {\n            iteration,\n            phase: 'feed',\n            fedEvents: newEvents.length,\n            outcome: result.completed\n              ? 'completed'\n              : result.failed\n                ? 'failed'\n                : 'suspended',\n          });\n          continue;\n        }\n      }\n\n      // 3. No cheap progress left — execute steps inline.\n      const stepOps = pendingOperations.filter(\n        (op): op is PendingStep => op.type === 'step'\n      );\n      // Steps created by an EARLIER invocation (or an earlier turn) that\n      // are still pending, with no work owned by THIS invocation. Mirror\n      // the node engine's ownership decision table (step-ownership.ts) —\n      // NOT a deliveryAttempt gate: worlds advance the attempt counter on\n      // routine redeliveries (world-local counts every handled response),\n      // so attempt > 1 is the common case and would fire backstops at\n      // steps actively executing inline in a live invocation.\n      //\n      //   - Ownership lease ACTIVE, held by ANOTHER message → the step is\n      //     (presumably) executing inline in a live invocation. Arm a\n      //     DELAYED backstop for the lease remainder, keyed to the\n      //     ownership epoch (a refreshed lease re-arms a fresh backstop\n      //     instead of deduping against the in-flight one). If the owner\n      //     completes normally, the backstop delivery resolves the step\n      //     as 'skipped'.\n      //   - Ownership lease ACTIVE, held by THIS message → this delivery\n      //     is the owner's redelivery; the claimant crashed\n      //     mid-execution. Dispatch immediately for background recovery.\n      //   - No stamp / lease EXPIRED / step_retrying observed → the step\n      //     is queue-owned or orphaned. Dispatch immediately; the\n      //     bare-correlationId idempotency key dedupes against the\n      //     original handoff.\n      const nowMs = Date.now();\n      for (const step of stepOps) {\n        if (!step.hasCreatedEvent) continue;\n        if (executedStepIds.has(step.correlationId)) continue;\n        if (queuedStepIds.has(step.correlationId)) continue;\n        const ownership = stepOwnership.get(step.correlationId);\n        const ownershipActive =\n          ownership !== undefined &&\n          ownership.owner !== undefined &&\n          !ownership.sawRetrying;\n        let leaseRemainingSeconds = 0;\n        if (ownershipActive && ownership.startedAtMs !== undefined) {\n          const leaseSeconds = getInlineOwnershipLeaseSeconds();\n          leaseRemainingSeconds = Math.min(\n            leaseSeconds,\n            Math.max(\n              0,\n              Math.ceil(\n                (ownership.startedAtMs + leaseSeconds * 1000 - nowMs) / 1000\n              )\n            )\n          );\n        }\n        if (\n          ownershipActive &&\n          ownership.owner !== ownerMessageId &&\n          leaseRemainingSeconds > 0\n        ) {\n          queuedStepIds.add(step.correlationId);\n          await queueStepMessage({\n            world,\n            runId,\n            workflowRun,\n            step,\n            delaySeconds: leaseRemainingSeconds,\n            namespace,\n            nextTraceCarrier,\n            purpose: `backstop:${ownership.startedAtMs}`,\n            wfdiag,\n          });\n        } else {\n          queuedStepIds.add(step.correlationId);\n          await queueStepMessage({\n            world,\n            runId,\n            workflowRun,\n            step,\n            namespace,\n            nextTraceCarrier,\n            purpose: 'dispatch',\n            wfdiag,\n          });\n        }\n      }\n\n      if (inlineCandidates.length === 0) {\n        // No in-process progress possible — the run awaits an external\n        // stimulus (hook payload, queued step, wait timer).\n        break;\n      }\n\n      // Racing timers must fire on time while step bodies block this\n      // invocation: enqueue a delayed continuation for the soonest\n      // pending wait (a separate invocation writes its wait_completed at\n      // the right log position — same mechanism as the node:vm engine's\n      // wait-continuation dispatch).\n      let soonestWait: { correlationId: string; seconds: number } | undefined;\n      for (const op of pendingOperations) {\n        if (op.type !== 'wait') continue;\n        const wait = op as PendingWait;\n        if (scheduledWaitContinuations.has(wait.correlationId)) continue;\n        // Waits whose wait_completed THIS invocation already wrote (the\n        // elapsed-wait pass above) are done — the event just hasn't fed\n        // back into the VM yet. No continuation needed.\n        if (completedWaitIds2.has(wait.correlationId)) continue;\n        const resumeMs = new Date(wait.resumeAt).getTime() - Date.now();\n        // An already-elapsed wait MUST still get a continuation (clamped\n        // to the 1s minimum, exactly like the node engine's\n        // `Math.max(1000, resumeAtMs - now)`), not be skipped: a wait\n        // whose deadline falls between this iteration's elapsed-wait\n        // pass (which saw it as still pending and wrote nothing) and\n        // this sweep would otherwise get NEITHER a wait_completed NOR a\n        // continuation — and the inline batch below then blocks this\n        // invocation for the full step duration with no wake armed\n        // anywhere. For `Promise.race(step, sleep)` that silently hands\n        // the race to the step: the sleep's wait_completed is never\n        // written and the run completes with the wrong winner. The\n        // window between the two checks spans this iteration's dispatch\n        // + feed round-trips, so on network-backed worlds (world-vercel)\n        // a short sleep lands in it routinely — observed as a ~50%\n        // sleepWinsRaceWorkflow failure rate in the Vercel e2e legs,\n        // while world-local's sub-ms round-trips masked it locally. The\n        // continuation invocation's pre-VM elapsed check writes the\n        // wait_completed ~1s later.\n        const seconds = Math.max(1, Math.ceil(resumeMs / 1000));\n        if (!soonestWait || seconds < soonestWait.seconds) {\n          soonestWait = { correlationId: wait.correlationId, seconds };\n        }\n      }\n      if (soonestWait) {\n        scheduledWaitContinuations.add(soonestWait.correlationId);\n        await queueMessage(\n          world,\n          getWorkflowQueueName(workflowRun.workflowName, namespace),\n          {\n            runId,\n            traceCarrier: await nextTraceCarrier(),\n            requestedAt: new Date(),\n          },\n          getWaitContinuationDispatch(\n            soonestWait.seconds,\n            soonestWait.correlationId\n          )\n        );\n        wfdiag('wait_continuation_scheduled', {\n          correlationId: soonestWait.correlationId,\n          delaySeconds: soonestWait.seconds,\n        });\n      }\n\n      // Execute the inline batch in parallel. The replay budget is\n      // paused while step bodies run — step duration is bounded by the\n      // platform function duration, not the replay timeout. NOTE (by\n      // design): with the budget parked per batch, the only bound on how\n      // many inline steps one invocation can chain is the platform's\n      // function timeout — the SDK deliberately imposes no cap of its\n      // own, matching the node:vm engine, where a long sequential\n      // workflow likewise runs step-by-step until the platform reclaims\n      // the invocation and a redelivery resumes from the log.\n      budget.pause();\n      let outcomes: StepExecutionResult[];\n      try {\n        outcomes = await Promise.all(\n          inlineCandidates.map((step) =>\n            runStepSingleFlight(runId, step.correlationId, () =>\n              (async () =>\n                executeStep({\n                  world,\n                  workflowRunId: runId,\n                  workflowDeploymentId: workflowRun.deploymentId,\n                  workflowName: workflowRun.workflowName,\n                  workflowStartedAt,\n                  rootRunId,\n                  stepId: step.correlationId,\n                  stepName: step.stepId,\n                  encryptionKey,\n                  runSpecVersion: workflowRun.specVersion,\n                  // Lazy inline claim: step_created is deferred (dispatch\n                  // skipped it) and this step_started carries the input,\n                  // so the world creates the step atomically —\n                  // exactly-one-owner. A concurrent claimant gets\n                  // EntityConflictError → { type: 'skipped' } and never\n                  // runs the body. Mirrors the node engine's inline path.\n                  lazyStepInput: await encryptSerializedData(\n                    step.input,\n                    encryptionKey\n                  ),\n                  // Ownership stamp: wake replays see the body as in\n                  // flight in this invocation and arm a delayed backstop\n                  // instead of immediately requeueing the step.\n                  ownerMessageId,\n                  // A lazy step is brand-new by construction — first\n                  // attempt.\n                  authoritativeAttempt: 1,\n                }))()\n            )\n          )\n        );\n      } finally {\n        budget.resume();\n      }\n      inlineStepsExecuted += inlineCandidates.length;\n\n      for (let i = 0; i < inlineCandidates.length; i++) {\n        const step = inlineCandidates[i];\n        const outcome = outcomes[i];\n        executedStepIds.add(step.correlationId);\n        if (outcome.type === 'retry' || outcome.type === 'throttled') {\n          // Hand the step to the queue with the requested backoff —\n          // background delivery drives the retry from here.\n          queuedStepIds.add(step.correlationId);\n          await queueStepMessage({\n            world,\n            runId,\n            workflowRun,\n            step,\n            delaySeconds: outcome.timeoutSeconds,\n            namespace,\n            nextTraceCarrier,\n            // Suffixed key: this step was inline-claimed, so no dispatch\n            // publish exists under the bare correlationId — but suffixing\n            // keeps the retry enqueueable even if a world retired a\n            // historical key for this step (see the purpose docs above).\n            purpose: 'retry:1',\n            wfdiag,\n          });\n        } else if (outcome.type === 'gone') {\n          runGone = true;\n        }\n        // 'skipped': a concurrent invocation won the lazy create-claim and\n        // owns the body. Marked executed above so this invocation never\n        // re-claims it; the winner's terminal events arrive via the feed\n        // (or drive a separate invocation).\n      }\n      wfdiag('inline_steps_executed', {\n        iteration,\n        count: inlineCandidates.length,\n        outcomes: outcomes.map((o) => o.type),\n      });\n\n      // Feed the inline batch's terminal events into the live VM. When\n      // the eventually-consistent listing has not surfaced them yet,\n      // exiting must NOT ack silently: the terminals this invocation just\n      // caused are durably written with no queue message left to consume\n      // them (inline steps have none), so an awaiting_external exit would\n      // park the run 'running' with all its steps complete. Raise the\n      // requeue signal so the suspended exit schedules a fresh immediate\n      // invocation whose fresh read picks the terminals up. Outcomes that\n      // wrote no terminal ('skipped' — a concurrent claimant owns the\n      // body; 'gone', retry/throttled — a queue message exists) don't\n      // need it, but signaling on them too only costs a no-op invocation\n      // in an already-rare lag window.\n      const newEvents = await fetchUnseenEvents();\n      if (newEvents.length === 0) {\n        pendingRequeueSignal = true;\n        break;\n      }\n      result = await session.continueWithEvents(newEvents);\n\n      wfdiag('inline_iteration', {\n        iteration,\n        phase: 'steps',\n        fedEvents: newEvents.length,\n        outcome: result.completed\n          ? 'completed'\n          : result.failed\n            ? 'failed'\n            : 'suspended',\n        budgetExhausted: budget.isExhausted(),\n      });\n    }\n  } finally {\n    session.dispose();\n  }\n\n  parentSpan?.setAttributes({\n    ...Attribute.QuickJSInlineSteps(inlineStepsExecuted),\n  });\n\n  if (result.completed) {\n    // Workflow completed\n    runtimeLogger.info('QuickJS runtime: workflow completed', {\n      workflowRunId: runId,\n    });\n    parentSpan?.setAttributes({\n      ...Attribute.QuickJSOutcome('completed'),\n    });\n\n    // Flush leftover pending side effects (abort recordings, system-hook\n    // disposals, fire-and-forget attribute/hook events) BEFORE writing\n    // run_completed — mirrors the node:vm engine's drainPendingQueueItems.\n    // Drain failures are swallowed: the workflow's own outcome is the\n    // source of truth.\n    if (result.completed.drainOperations?.length) {\n      try {\n        await dispatchPendingOps({\n          world,\n          runId,\n          workflowRun,\n          encryptionKey,\n          namespace,\n          nextTraceCarrier,\n          pendingOperations: result.completed.drainOperations,\n          wfdiag,\n        });\n      } catch (err) {\n        runtimeLogger.warn('QuickJS runtime: terminal drain failed', {\n          workflowRunId: runId,\n          message: (err as Error)?.message,\n        });\n      }\n    }\n\n    // Create run_completed event.\n    // The VM serializes the workflow result as format-prefixed devalue bytes\n    // (\"devl\" + devalue) with no encryption (the VM has no access to the\n    // CryptoKey). Host-side encryption is applied here so that `run_completed`\n    // events have the same `encr`-prefixed payload shape that the node:vm\n    // engine's `dehydrateWorkflowReturnValue` produces.\n    try {\n      await world.events.create(runId, {\n        eventType: 'run_completed',\n        specVersion: SPEC_VERSION_CURRENT,\n        eventData: {\n          output: await encryptSerializedData(\n            result.completed.result,\n            encryptionKey\n          ),\n        },\n      });\n      wfdiag('exit_completed', { result: 'run_completed_written' });\n    } catch (err) {\n      if (EntityConflictError.is(err) || RunExpiredError.is(err)) {\n        runtimeLogger.warn(\n          'Workflow already finished, skipping run_completed',\n          { workflowRunId: runId }\n        );\n        wfdiag('exit_completed', { result: 'already_finished' });\n        return;\n      }\n      wfdiag('exit_completed_error', {\n        errorName: (err as Error)?.name,\n        errorMessage: (err as Error)?.message,\n      });\n      throw err;\n    }\n  } else if (result.suspended) {\n    // Workflow still suspended after the inline loop. All durable side\n    // effects for the final suspension state were already dispatched by\n    // the loop; what remains is deciding how the run gets re-invoked.\n    const { pendingOperations } = result.suspended;\n\n    runtimeLogger.info('QuickJS runtime: workflow suspended', {\n      workflowRunId: runId,\n      inlineStepsExecuted,\n      pendingSteps: pendingOperations.filter((p) => p.type === 'step').length,\n      pendingWaits: pendingOperations.filter((p) => p.type === 'wait').length,\n      pendingOps: pendingOperations.map((p) => ({\n        type: p.type,\n        correlationId: p.correlationId,\n        hasCreatedEvent: p.hasCreatedEvent,\n        ...(p.type === 'step' ? { stepId: (p as PendingStep).stepId } : {}),\n      })),\n    });\n\n    parentSpan?.setAttributes({\n      ...Attribute.QuickJSOutcome('suspended'),\n      ...Attribute.QuickJSPendingOpsCount(pendingOperations.length),\n    });\n\n    if (runGone) {\n      // The run no longer exists (expired / deleted) — nothing to drive.\n      wfdiag('exit_suspended', { action: 'run_gone' });\n      return;\n    }\n\n    // Exit requeues are FRESH messages, never a `{ timeoutSeconds }`\n    // visibility-redelivery of the current message. Redelivering the\n    // CURRENT message is a trap: a hook-resume delivery carries\n    // `hookInput`, and its redelivery re-runs the lazy-resume re-ensure\n    // in the handler prologue — if the workflow disposed that hook\n    // during this invocation (dispose → sleep), a world that rejects\n    // the re-ensure would ack the message as \"nothing left to resume\"\n    // and the continuation it carried is silently lost. A fresh message\n    // carries only `runId`, so its delivery always reaches replay (and\n    // under turbo a reschedule would re-engage turbo against a stale\n    // preloaded log — see the reinvoke() docs in runtime.ts).\n    const requeueImmediately = async (): Promise<void> => {\n      await queueMessage(\n        world,\n        getWorkflowQueueName(workflowRun.workflowName, namespace),\n        {\n          runId,\n          traceCarrier: await nextTraceCarrier(),\n          requestedAt: new Date(),\n        }\n      );\n    };\n\n    if (budget.isExhausted()) {\n      // The loop stopped on the replay budget with progress still\n      // possible — continue in a fresh invocation.\n      wfdiag('exit_suspended', { action: 'budget_exhausted_requeue' });\n      await requeueImmediately();\n      return;\n    }\n\n    // Exit wait sweep. A wait that elapsed in the window since the\n    // loop's last check requeues immediately (its wait_completed is\n    // written by the next invocation's elapsed-wait pass); pending waits\n    // whose continuation the loop already enqueued are skipped.\n    let soonestWait: { seconds: number; correlationId: string } | undefined;\n    let hasElapsedWait = false;\n    for (const op of pendingOperations) {\n      if (op.type !== 'wait') continue;\n      const wait = op as PendingWait;\n      const resumeMs = new Date(wait.resumeAt).getTime() - Date.now();\n      if (resumeMs <= 0) {\n        hasElapsedWait = true;\n      } else if (!scheduledWaitContinuations.has(wait.correlationId)) {\n        const timeoutSeconds = Math.max(1, Math.ceil(resumeMs / 1000));\n        if (!soonestWait || timeoutSeconds < soonestWait.seconds) {\n          soonestWait = {\n            seconds: timeoutSeconds,\n            correlationId: wait.correlationId,\n          };\n        }\n      }\n    }\n\n    if (hasElapsedWait) {\n      wfdiag('exit_suspended', { action: 'wait_elapsed_requeue' });\n      await requeueImmediately();\n      return;\n    }\n\n    if (pendingRequeueSignal) {\n      // This invocation wrote events the workflow needs to consume\n      // (attr_set / getConflict-awaited hook_created / inline step\n      // terminals) but the eventually-consistent listing never returned\n      // them before the loop exited. Without a requeue the run would\n      // park awaiting_external with its unblocking events already\n      // durably written and no future invocation coming — requeue\n      // immediately so a fresh read picks them up. In the common case\n      // the loop's own feed observes the writes and clears this flag, so\n      // this only fires when the read actually lagged.\n      wfdiag('exit_suspended', { action: 'unread_self_write_requeue' });\n      await requeueImmediately();\n      return;\n    }\n\n    if (soonestWait) {\n      // Delayed continuation for the soonest pending wait the loop has\n      // not already scheduled. The dispatch helper handles delay\n      // clamping (long waits chain across hops) and idempotency-key\n      // dedup of re-observations of the same pending wait — see\n      // runtime/wait-continuation.ts.\n      wfdiag('exit_suspended', {\n        action: 'schedule_wait_timeout',\n        timeoutSeconds: soonestWait.seconds,\n        waitCorrelationId: soonestWait.correlationId,\n      });\n      scheduledWaitContinuations.add(soonestWait.correlationId);\n      await queueMessage(\n        world,\n        getWorkflowQueueName(workflowRun.workflowName, namespace),\n        {\n          runId,\n          traceCarrier: await nextTraceCarrier(),\n          requestedAt: new Date(),\n        },\n        getWaitContinuationDispatch(\n          soonestWait.seconds,\n          soonestWait.correlationId\n        )\n      );\n      return;\n    }\n\n    wfdiag('exit_suspended', {\n      action: 'awaiting_external',\n      pendingOpsCount: pendingOperations.length,\n    });\n  } else if (result.failed) {\n    // Workflow failed — remap stack trace using inline source maps\n    let errorStack = result.failed.stack;\n    if (errorStack) {\n      const parsedName = parseWorkflowName(workflowName);\n      const filename = parsedName?.moduleSpecifier || workflowName;\n      errorStack = remapErrorStack(errorStack, filename, workflowCode);\n    }\n\n    // Classify the error so consumers (`run.returnValue`, observability)\n    // get `USER_ERROR` / `RUNTIME_ERROR` on `error.cause.code`, matching\n    // what the node:vm engine already does in runtime.ts.\n    //\n    // The VM serializes errors as `{ name, message, stack }`, so we\n    // reconstruct a host-side Error of the correct class based on the\n    // VM-side `name` — specific WorkflowRuntimeError subclasses need\n    // to be preserved so classifyRunError() tags them as RUNTIME_ERROR.\n    const reconstructed: Error =\n      result.failed.name === 'WorkflowNotRegisteredError'\n        ? new WorkflowNotRegisteredError(workflowName)\n        : result.failed.name === 'Error'\n          ? new Error(result.failed.message)\n          : Object.assign(new Error(result.failed.message), {\n              name: result.failed.name,\n            });\n    const errorCode = classifyRunError(reconstructed);\n\n    runtimeLogger.error('QuickJS runtime: workflow failed', {\n      workflowRunId: runId,\n      errorName: result.failed.name,\n      errorMessage: result.failed.message,\n      errorStack,\n      errorCode,\n    });\n    parentSpan?.setAttributes({\n      ...Attribute.QuickJSOutcome('failed'),\n    });\n\n    // Flush leftover pending side effects before writing run_failed —\n    // same drain semantics as the completed branch.\n    if (result.failed.drainOperations?.length) {\n      try {\n        await dispatchPendingOps({\n          world,\n          runId,\n          workflowRun,\n          encryptionKey,\n          namespace,\n          nextTraceCarrier,\n          pendingOperations: result.failed.drainOperations,\n          wfdiag,\n        });\n      } catch (err) {\n        runtimeLogger.warn('QuickJS runtime: terminal drain failed', {\n          workflowRunId: runId,\n          message: (err as Error)?.message,\n        });\n      }\n    }\n\n    // Create run_failed event. Serialize the error through the\n    // first-class dehydration pipeline so consumers (CLI, observability,\n    // run.returnValue) get the same hydrated value shape as the node:vm\n    // engine emits. Two paths:\n    //   * Modern (valueBytes present): the VM-side rejection handler\n    //     serialized the original thrown value (Error subclass with\n    //     cause chain, plain object, primitive, etc.) using the VM's\n    //     workflow-serialize. Pass those bytes through directly so\n    //     type identity, cause chains, and non-Error throws survive.\n    //     We just need to apply encryption if configured (the VM's\n    //     serializer doesn't have access to the encryption key).\n    //   * Legacy fallback: reconstruct an Error from the host-visible\n    //     {name, message, stack} fields and run it through\n    //     `dehydrateRunError`. Used when valueBytes is absent (e.g.\n    //     extractError pseudo-failures from VM bootstrap).\n    let dehydratedError: Uint8Array;\n    if (result.failed.valueBytes) {\n      // Hydrate the VM-side bytes, remap the error stack with the\n      // host-side source map (the VM can't do this — it lacks both the\n      // source map and `remapErrorStack`), and re-dehydrate. This\n      // preserves the original value's type identity / cause chain\n      // while fixing up frames to point at the user's source files.\n      try {\n        const hydrated = await hydrateRunError(\n          result.failed.valueBytes,\n          runId,\n          undefined // VM bytes are unencrypted\n        );\n        if (\n          hydrated &&\n          typeof hydrated === 'object' &&\n          'stack' in (hydrated as object) &&\n          typeof (hydrated as { stack?: unknown }).stack === 'string'\n        ) {\n          const parsedName = parseWorkflowName(workflowName);\n          const filename = parsedName?.moduleSpecifier || workflowName;\n          (hydrated as { stack?: string }).stack = remapErrorStack(\n            (hydrated as { stack: string }).stack,\n            filename,\n            workflowCode\n          );\n        }\n        // Walk the cause chain and remap nested stacks too.\n        const seen = new WeakSet<object>();\n        let node = (hydrated as { cause?: unknown })?.cause;\n        while (node && typeof node === 'object' && !seen.has(node as object)) {\n          seen.add(node as object);\n          const nodeStack = (node as { stack?: unknown }).stack;\n          if (typeof nodeStack === 'string') {\n            const parsedName = parseWorkflowName(workflowName);\n            const filename = parsedName?.moduleSpecifier || workflowName;\n            (node as { stack?: string }).stack = remapErrorStack(\n              nodeStack,\n              filename,\n              workflowCode\n            );\n          }\n          node = (node as { cause?: unknown }).cause;\n        }\n        dehydratedError = await dehydrateRunError(\n          hydrated,\n          runId,\n          encryptionKey\n        );\n      } catch (rehydrateErr) {\n        // If hydration / re-dehydration fails for any reason, fall\n        // back to passing through the original VM bytes (just apply\n        // encryption if configured). Better to lose source-mapped\n        // frames than to lose the error entirely.\n        runtimeLogger.warn(\n          'QuickJS runtime: failed to remap workflow error stack, passing VM bytes through',\n          {\n            workflowRunId: runId,\n            message: (rehydrateErr as Error)?.message,\n          }\n        );\n        dehydratedError = (await maybeEncrypt(\n          result.failed.valueBytes,\n          encryptionKey\n        )) as Uint8Array;\n      }\n    } else {\n      if (errorStack) {\n        reconstructed.stack = errorStack;\n      }\n      try {\n        dehydratedError = await dehydrateRunError(\n          reconstructed,\n          runId,\n          encryptionKey\n        );\n      } catch (serErr) {\n        // Fall back to a minimal payload so the run still terminates\n        // even when the error itself contains unserializable values.\n        runtimeLogger.warn(\n          'QuickJS runtime: failed to dehydrate run error, falling back to bare Error',\n          { workflowRunId: runId, message: (serErr as Error)?.message }\n        );\n        dehydratedError = await dehydrateRunError(\n          Object.assign(new Error(result.failed.message), {\n            name: result.failed.name,\n          }),\n          runId,\n          encryptionKey\n        );\n      }\n    }\n    try {\n      await world.events.create(runId, {\n        eventType: 'run_failed',\n        specVersion: SPEC_VERSION_CURRENT,\n        eventData: {\n          error: dehydratedError,\n          errorCode,\n        },\n      });\n    } catch (err) {\n      if (EntityConflictError.is(err) || RunExpiredError.is(err)) {\n        runtimeLogger.warn('Workflow already finished, skipping run_failed', {\n          workflowRunId: runId,\n        });\n        wfdiag('exit_failed', { result: 'already_finished' });\n        return;\n      }\n      wfdiag('exit_failed_error', {\n        errorName: (err as Error)?.name,\n        errorMessage: (err as Error)?.message,\n      });\n      throw err;\n    }\n    wfdiag('exit_failed', { result: 'run_failed_written' });\n  }\n}\n"]}