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

package/dist/runtime/quickjs-entrypoint.js

@@ -0,0 +1,1863 @@
+/**
+ * QuickJS WebAssembly (WASM) VM integration with the Workflow DevKit.
+ *
+ * This module provides the entry point for running workflows in the
+ * QuickJS VM engine instead of the `node:vm` engine. Both engines
+ * implement the same event-replay execution model, where 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, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_COMPRESSION, } from '@workflow/world';
+import { classifyRunError, isRetryableWorldError } from '../classify-error.js';
+import { runtimeLogger } from '../logger.js';
+import { deriveRunPayloadKeys, encrypt as encryptSerializedData, } from '../serialization/encryption.js';
+import { dehydrateRunError, dehydrateStepArguments, dehydrateStepError, 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, isResilientStepDispatchEnabled, MAX_RESILIENT_STEP_INPUT_BYTES, } from './constants.js';
+import { getPortLazy } from './get-port-lazy.js';
+import { getWorkflowQueueName, queueMessage, runDispatchContext, stepDispatchIdempotencyKey, } from './helpers.js';
+import { QuickJSLogView } from './quickjs-log-view.js';
+import { BASELINE_BUNDLE_FILENAME, 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 { unserializableStepInputPlaceholder } from './unserializable-step.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, stepInput, wfdiag, } = params;
+    const traceCarrier = await nextTraceCarrier();
+    await queueMessage(world, getWorkflowQueueName(workflowRun.workflowName, namespace), {
+        runId,
+        stepId: step.correlationId,
+        stepName: step.stepId,
+        traceCarrier,
+        requestedAt: new Date(),
+        ...(stepInput !== undefined ? { stepInput: { input: stepInput } } : {}),
+        // Immutable run identity so the consumer can start the step without a
+        // blocking runs.get — see RunDispatchContextSchema.
+        runContext: runDispatchContext(workflowRun),
+    }, {
+        // The 'dispatch' key is step-identity-scoped (correlationId + hashed
+        // step name), shared with the node engine's dispatch of the same step
+        // so the two stay mutually exclusive, without a revoked resilient
+        // message absorbing a reassigned correlation id's legitimate dispatch.
+        // See stepDispatchIdempotencyKey.
+        idempotencyKey: purpose === 'dispatch'
+            ? stepDispatchIdempotencyKey(step.correlationId, step.stepId)
+            : `${step.correlationId}:${purpose}`,
+        ...(delaySeconds && delaySeconds > 0 ? { delaySeconds } : {}),
+    });
+    wfdiag('step_queued', {
+        stepId: step.stepId,
+        correlationId: step.correlationId,
+        purpose,
+        delaySeconds: delaySeconds ?? 0,
+        ...(stepInput !== undefined ? { resilient: true } : {}),
+    });
+}
+/**
+ * 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 (usually) not 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).
+ *
+ * The one exception is resilient step dispatch: for step cids named in
+ * `queueStepCids` (the caller's overflow steps) that pass the eligibility
+ * gates, the step_created write is parallelized with the step's queue
+ * publish: the message carries the serialized input (`stepInput`) so the
+ * consumer can idempotently re-ensure the event if the direct write failed
+ * transiently. Steps queued this way are reported in `queuedStepCids`; the
+ * caller queues the rest itself.
+ */
+async function dispatchPendingOps(params) {
+    const { world, runId, workflowRun, encryptionKey, pendingOperations, namespace, nextTraceCarrier, createEvent, } = params;
+    const skipStepCreation = params.skipStepCreation;
+    const queueStepCids = params.queueStepCids;
+    const wfdiag = params.wfdiag;
+    // Step cids published via resilient dispatch below (create + queue in
+    // parallel, message carrying `stepInput`). Reported to the caller so it
+    // skips them in its own queueing pass.
+    const queuedStepCids = new Set();
+    // Step cids finalized as step_created + step_failed because their input
+    // refused to serialize. See the `finalizeUnserializableSteps` param.
+    const failedSerializationStepCids = new Set();
+    // Resilient step dispatch eligibility, shared by every step op below (the
+    // per-step input-size check is applied inside the op): feature enabled and
+    // a binary-safe (CBOR) queue transport for the run.
+    //
+    // Unlike the node:vm suspension handler's gate (see
+    // SuspensionHandlerParams.stepDispatch), there is NO precondition-guard
+    // gate here: this engine's step_created writes are unguarded (no snapshot
+    // is attached), so a guard-enforcing World can never 412-reject them:
+    // the consumer's re-ensure therefore cannot materialize a step the guard
+    // rejected. If this engine ever adopts guarded suspension writes, the
+    // capability gate from the node:vm handler must be added here too.
+    const resilientDispatchEligible = queueStepCids !== undefined &&
+        queueStepCids.size > 0 &&
+        isResilientStepDispatchEnabled() &&
+        (workflowRun.specVersion ?? 0) >=
+            SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT;
+    // 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 hooksNeedingCreation = pendingOperations.filter((op) => op.type === 'hook' && !op.hasCreatedEvent).length;
+    const hookDeltaCursor = hooksNeedingCreation === 1 ? params.deltaCursor : undefined;
+    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, which 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 createEvent({
+                    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 } : {}),
+                    },
+                }, hookDeltaCursor !== undefined
+                    ? { sinceCursor: hookDeltaCursor }
+                    : undefined);
+                // 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, so 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 createEvent({
+                    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 createEvent({
+                eventType: 'hook_disposed',
+                specVersion: SPEC_VERSION_CURRENT,
+                correlationId: op.correlationId,
+                // The hook's token, which the node:vm engine has always sent. A world
+                // that keys a hook's token claim separately from the hook itself needs
+                // it to release both, and the only alternative is for it to look the
+                // token up first. Omitted rather than sent as undefined when the op
+                // carries none, so a world that reads it cannot tell the difference
+                // between this engine and a client too old to send one.
+                ...(op.token === undefined ? {} : { eventData: { token: op.token } }),
+            });
+        }
+        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 () => {
+                // The step's input refused to serialize while dumping the VM's
+                // pending ops (see PendingStep.serializationError). Finalize it
+                // as step_created (placeholder input, since the world requires the
+                // step entity before a terminal event) + step_failed carrying
+                // the SerializationError, so the live-VM feed rejects the
+                // step's promise and workflow code can catch it. Never queue an
+                // execution message for it. Mirrors the node:vm engine's
+                // finalizeUnserializableStep. In the terminal drain
+                // (finalizeUnserializableSteps unset), skip entirely: see the
+                // param docs.
+                if (step.serializationError) {
+                    if (!params.finalizeUnserializableSteps) {
+                        return;
+                    }
+                    runtimeLogger.warn('Step arguments failed to serialize; failing the step so ' +
+                        'the workflow can observe the error', {
+                        workflowRunId: runId,
+                        correlationId: step.correlationId,
+                        stepName: step.stepId,
+                        error: step.serializationError.message,
+                    });
+                    try {
+                        await createEvent({
+                            eventType: 'step_created',
+                            specVersion: SPEC_VERSION_CURRENT,
+                            correlationId: step.correlationId,
+                            eventData: {
+                                stepName: step.stepId,
+                                input: (await dehydrateStepArguments(unserializableStepInputPlaceholder(), runId, encryptionKey, globalThis, false, (workflowRun.specVersion ?? 0) >=
+                                    SPEC_VERSION_SUPPORTS_COMPRESSION)),
+                            },
+                        });
+                    }
+                    catch (err) {
+                        // Concurrent invocation hit the same deterministic failure
+                        // and created it first, or the run already finished.
+                        if (RunExpiredError.is(err))
+                            return;
+                        if (!EntityConflictError.is(err))
+                            throw err;
+                    }
+                    try {
+                        await createEvent({
+                            eventType: 'step_failed',
+                            specVersion: SPEC_VERSION_CURRENT,
+                            correlationId: step.correlationId,
+                            eventData: {
+                                stepName: step.stepId,
+                                error: await dehydrateStepError(step.serializationError, runId, encryptionKey, [], globalThis, (workflowRun.specVersion ?? 0) >=
+                                    SPEC_VERSION_SUPPORTS_COMPRESSION),
+                            },
+                        });
+                    }
+                    catch (err) {
+                        // Step already terminal or run already finished.
+                        if (!EntityConflictError.is(err) && !RunExpiredError.is(err)) {
+                            throw err;
+                        }
+                    }
+                    failedSerializationStepCids.add(step.correlationId);
+                    wfdiag('step_serialization_failed', {
+                        stepId: step.stepId,
+                        correlationId: step.correlationId,
+                    });
+                    return;
+                }
+                // 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.
+                const encryptedInput = await encryptSerializedData(step.input, encryptionKey);
+                // Resilient step dispatch: fire the step_created write and the
+                // step's queue publish in parallel: the message carries the
+                // same serialized input (`stepInput`) so the consumer can
+                // idempotently re-ensure the event if the direct write failed
+                // transiently. Mirrors the node:vm suspension handler and the
+                // resilient start / resilient hook resume patterns. Only for
+                // caller-designated overflow steps with inputs the queue
+                // message can safely carry (binary, under the VQS size cap).
+                if (resilientDispatchEligible &&
+                    queueStepCids?.has(step.correlationId) &&
+                    encryptedInput instanceof Uint8Array &&
+                    encryptedInput.byteLength <= MAX_RESILIENT_STEP_INPUT_BYTES) {
+                    const [createResult, queueResult] = await Promise.allSettled([
+                        createEvent({
+                            eventType: 'step_created',
+                            specVersion: SPEC_VERSION_CURRENT,
+                            correlationId: step.correlationId,
+                            eventData: {
+                                stepName: step.stepId,
+                                input: encryptedInput,
+                            },
+                        }),
+                        queueStepMessage({
+                            world,
+                            runId,
+                            workflowRun,
+                            step,
+                            namespace,
+                            nextTraceCarrier,
+                            purpose: 'dispatch',
+                            stepInput: encryptedInput,
+                            wfdiag,
+                        }),
+                    ]);
+                    // Queue failure is always fatal for this dispatch pass:
+                    // without the message the step would rely on the create
+                    // alone, and if the create ALSO failed there would be no
+                    // durable record at all. Propagating redelivers the
+                    // orchestrator message, which re-creates the (idempotent)
+                    // step_created and re-dispatches.
+                    if (queueResult.status === 'rejected') {
+                        throw queueResult.reason;
+                    }
+                    queuedStepCids.add(step.correlationId);
+                    if (createResult.status === 'rejected') {
+                        const err = createResult.reason;
+                        if (EntityConflictError.is(err)) {
+                            // Concurrent invocation wrote it first: the message is
+                            // already out; its duplicate publish dedupes on the
+                            // shared step-identity-scoped idempotency key.
+                            return;
+                        }
+                        if (isRetryableWorldError(err)) {
+                            // Resilient: the write failed transiently (429 / 5xx /
+                            // transport) but the step message (carrying the same
+                            // serialized input) was published, so the consumer
+                            // idempotently re-ensures the step_created before
+                            // executing.
+                            runtimeLogger.warn('Step creation event write failed, but the step was ' +
+                                'dispatched via the queue. The step_created event ' +
+                                'will be ensured by the queue consumer.', {
+                                workflowRunId: runId,
+                                correlationId: step.correlationId,
+                                stepName: step.stepId,
+                                error: err instanceof Error ? err.message : String(err),
+                            });
+                            wfdiag('step_resilient_dispatch_recovered', {
+                                stepId: step.stepId,
+                                correlationId: step.correlationId,
+                            });
+                            return;
+                        }
+                        throw err;
+                    }
+                    return;
+                }
+                try {
+                    await createEvent({
+                        eventType: 'step_created',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        correlationId: step.correlationId,
+                        eventData: {
+                            stepName: step.stepId,
+                            input: encryptedInput,
+                        },
+                    });
+                }
+                catch (err) {
+                    if (EntityConflictError.is(err))
+                        return;
+                    throw err;
+                }
+                // NOTE: step queueing is otherwise 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 createEvent({
+                        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), but 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 createEvent({
+                        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,
+        queuedStepCids,
+        failedSerializationStepCids,
+    };
+}
+/**
+ * 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.
+ *
+ * Log position on writes. This engine follows the same rule as the node:vm
+ * replay loop for which writes tell the World where the writer stood (see the
+ * "Who names a position" table above `slotSnapshotParams` in `helpers.ts`):
+ *
+ * - Writes made from this invocation's view of the log (`step_created`,
+ *   `wait_created`, `hook_created`, `hook_disposed`, `attr_set`, the abort
+ *   `hook_received`, `wait_completed`, and the `step_created` + `step_failed`
+ *   pair for an unserializable input) carry `eventCount`, and the page a
+ *   World hands back is queued for the live VM through {@link QuickJSLogView}.
+ * - A single inline step's terminal write asks for the inline delta
+ *   (`sinceCursor`) through `executeStep`, and so does a lone `hook_created`
+ *   (see `dispatchPendingOps.deltaCursor`); the delta is queued the same
+ *   way. The step executor's other writes carry nothing: it holds no log.
+ * - Run-terminal writes (`run_completed`, `run_failed`) and the terminal drain
+ *   of pending ops carry nothing: nothing reads the log afterwards.
+ *
+ * What differs from the node engine is what "merge into the log" means. The
+ * node engine merges a returned page into the array it replays from. This
+ * engine holds a live VM that consumes events exactly once, in position
+ * order, so a returned page is queued and delivered ahead of the next
+ * `events.list`, which then only runs when the queue cannot account for the
+ * next position. Both engines fall back to a list for anything a page did
+ * not carry.
+ */
+export async function runWorkflowWithQuickJS(params) {
+    const { workflowCode, workflowName, workflowRun, preloadedEvents, preloadedEventsComplete, preloadedCursor, runInput, parentSpan, maxEventsLimit, deliveryAttempt, ownerMessageId, requestId, namespace, waitContinuation, } = params;
+    /**
+     * Attempt number for the continuation this invocation is about to arm for
+     * `correlationId`. One higher than the incoming continuation's when this
+     * invocation IS that continuation and the wait is still pending — the only
+     * situation in which the previous key is spent. Every other caller, and
+     * every other wait, starts at 0 and keys exactly as it did before attempts
+     * existed.
+     */
+    const nextWaitContinuationAttempt = (correlationId) => waitContinuation?.correlationId === correlationId
+        ? waitContinuation.attempt + 1
+        : 0;
+    // 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;
+    // Where the log was read to: the cursor after the last page below, or the
+    // one the caller read the preload to. Seeds the incremental reads and the
+    // inline-delta requests that follow.
+    let loadedCursor = null;
+    const usePreloaded = (preloadedEventsComplete === true &&
+        Array.isArray(preloadedEvents) &&
+        preloadedEvents.length > 0) ||
+        isFirstInvocation(preloadedEvents);
+    if (usePreloaded && preloadedEvents) {
+        events = preloadedEvents;
+        loadedCursor = preloadedCursor ?? null;
+    }
+    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;
+        loadedCursor = cursor;
+    }
+    // This invocation's view of the log, and the queue of events a World has
+    // handed back on a write that the VM has not been given yet. Every write
+    // made from this view goes through `createEvent` below so it names the
+    // position it was decided against and its response is queued here.
+    const logView = new QuickJSLogView(events, loadedCursor);
+    const createEvent = async (data, eventParams) => {
+        const result = await world.events.create(runId, data, {
+            ...eventParams,
+            ...logView.snapshotParams(),
+        });
+        if (typeof eventParams?.sinceCursor === 'string' &&
+            result.events !== undefined) {
+            // The write asked for the inline delta and got one: everything after
+            // the cursor, this write included, read with refs resolved. Taken
+            // through the delta path so the cursor moves with it when that is
+            // safe; the created event's position is noted either way.
+            logView.absorb({ event: result.event });
+            const advanced = logView.absorbDelta(eventParams.sinceCursor, {
+                events: result.events,
+                cursor: result.cursor ?? null,
+                hasMore: result.hasMore ?? false,
+            });
+            wfdiag('inline_delta_absorbed', {
+                eventType: data.eventType,
+                events: result.events.length,
+                hasMore: result.hasMore ?? false,
+                cursorAdvanced: advanced,
+            });
+            return result;
+        }
+        // The created event is delivered off the response only when it carries
+        // no payload a VM reads; every other type waits for a page or a listing,
+        // which return it with its refs resolved. See QuickJSLogView.
+        const absorbed = logView.absorb(result, {
+            deliverEvent: data.eventType === 'wait_completed',
+        });
+        if (absorbed.truncated) {
+            runtimeLogger.debug('QuickJS runtime: dropped a truncated skipped-slot report', {
+                workflowRunId: runId,
+                eventType: data.eventType,
+                eventId: result.event?.eventId,
+                offered: result.events?.length ?? 0,
+            });
+        }
+        return result;
+    };
+    /**
+     * The create for writes that end the run (`run_completed`, `run_failed`,
+     * and the terminal drain of leftover ops): no position named and no page
+     * asked for, because nothing replays a finished run's log. The node
+     * engine's `deltaRequestCursor` makes the same exclusion for `sinceCursor`.
+     */
+    const terminalCreateEvent = (data, eventParams) => world.events.create(runId, data, eventParams);
+    // Event-limit guard: fail a runaway run once its log reaches the
+    // server-supplied ceiling, the 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 createEvent({
+                        eventType: 'wait_completed',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        correlationId: event.correlationId,
+                    });
+                    if (!logView.tracking && result.event) {
+                        // No positions to order by (see QuickJSLogView), so the event
+                        // joins the initial log directly, as it always has.
+                        events.push(result.event);
+                    }
+                }
+                catch (err) {
+                    if (EntityConflictError.is(err))
+                        continue;
+                    throw err;
+                }
+            }
+        }
+    }
+    // The VM has not started, so whatever those writes handed back (each
+    // wait_completed, plus anything another writer appended that they skipped
+    // over) joins the initial log instead of waiting for a feed.
+    events.push(...logView.takeContiguous());
+    // 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, since 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), reading
+     * from where the log was last read to. A World's cursor never passes a
+     * position whose writer is still in flight, so reading forward from it
+     * cannot skip an event; the id set is what makes a re-read of the same
+     * span (after a queued page or a delta moved the view ahead of the cursor)
+     * harmless.
+     */
+    const fetchUnseenEvents = async () => {
+        const unseen = [];
+        let cursor = logView.logCursor;
+        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;
+        }
+        logView.advanceCursor(cursor);
+        logView.markFed(unseen);
+        observeEventsForOwnership(unseen);
+        return unseen;
+    };
+    /**
+     * Events a World handed back on this invocation's writes that the VM can
+     * take now: the contiguous run above what it has (see
+     * `QuickJSLogView.takeContiguous`). Delivered ahead of `fetchUnseenEvents`
+     * so a write's response, not a listing, is what usually carries the log
+     * forward, which is the round-trip the page exists to save. Empty when
+     * nothing is queued or the next position is not in hand, and the caller
+     * lists.
+     */
+    const takeQueuedEvents = () => {
+        const queued = logView.takeContiguous();
+        for (const e of queued) {
+            if (e.eventId)
+                seenEventIds.add(e.eventId);
+        }
+        observeEventsForOwnership(queued);
+        return queued;
+    };
+    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));
+            // Steps whose input refused to serialize (see
+            // PendingStep.serializationError) never execute: they must not be
+            // inline-claimed (a lazy step_started would need the input that
+            // failed) nor queued. Dispatch below finalizes them as step_created
+            // + step_failed instead; only healthy steps compete for inline
+            // slots and overflow.
+            const healthySteps = freshSteps.filter((step) => !step.serializationError);
+            const inlineCandidates = maxInlineSteps <= 0 ? [] : healthySteps.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);
+                }
+            }
+            // Steps beyond the inline cap are handed to the queue in the same
+            // turn their step_created is written. Where eligible, the dispatch
+            // below parallelizes each overflow step's step_created write with
+            // its queue publish (resilient step dispatch: the message carries
+            // `stepInput` so the consumer can re-ensure the event); the rest
+            // are queued right after, in parallel. This must all happen BEFORE
+            // the event feed below: the feed always observes those
+            // 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
+            // step-identity-scoped idempotency key makes repeats harmless.
+            const overflowSteps = healthySteps.slice(inlineCandidates.length);
+            const dispatched = await dispatchPendingOps({
+                world,
+                runId,
+                workflowRun,
+                encryptionKey,
+                namespace,
+                nextTraceCarrier,
+                createEvent,
+                ...(logView.tracking && typeof logView.logCursor === 'string'
+                    ? { deltaCursor: logView.logCursor }
+                    : {}),
+                pendingOperations: opsToDispatch,
+                skipStepCreation: inlineClaimCids,
+                queueStepCids: new Set(overflowSteps.map((s) => s.correlationId)),
+                finalizeUnserializableSteps: true,
+                wfdiag,
+            });
+            if (dispatched.createdAttributeEvent ||
+                dispatched.createdGetConflictHook) {
+                pendingRequeueSignal = true;
+            }
+            // A finalized unserializable step has terminal events durably
+            // written but no execution message anywhere: if the feed below
+            // doesn't surface them (eventually-consistent listing) and the loop
+            // exits, nothing would ever re-invoke the run to observe the
+            // failure. Raise the requeue signal (same mechanism as inline
+            // terminals) and mark the steps handled so later turns don't
+            // re-finalize or backstop-queue them.
+            if (dispatched.failedSerializationStepCids.size > 0) {
+                pendingRequeueSignal = true;
+                for (const cid of dispatched.failedSerializationStepCids) {
+                    executedStepIds.add(cid);
+                }
+            }
+            for (const cid of dispatched.queuedStepCids) {
+                queuedStepIds.add(cid);
+            }
+            await Promise.all(overflowSteps
+                .filter((step) => !dispatched.queuedStepCids.has(step.correlationId))
+                .map((step) => {
+                queuedStepIds.add(step.correlationId);
+                return 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 createEvent({
+                            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. What the writes above handed back
+            // is delivered first, and a listing runs when the queue does not reach
+            // the next position. A report changes what is fed first, not whether
+            // this listing happens: after a queued page is fed, this branch
+            // `continue`s, and the next iteration finds the queue empty and lists
+            // from a cursor a report does not advance (re-reading the reported
+            // span, deduped on `seenEventIds`). Only the inline delta below, which
+            // does advance the cursor, saves a listing outright. Same shape as the
+            // node engine.
+            {
+                const queued = takeQueuedEvents();
+                const newEvents = queued.length > 0 ? queued : await fetchUnseenEvents();
+                if (newEvents.length > 0) {
+                    // The listing caught up with this invocation's writes, so 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,
+                        fedFrom: queued.length > 0 ? 'write-response' : 'list',
+                        outcome: result.completed
+                            ? 'completed'
+                            : result.failed
+                                ? 'failed'
+                                : 'suspended',
+                    });
+                    continue;
+                }
+            }
+            // 3. No cheap progress left, so 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
+            //     step-identity-scoped 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, the 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);
+                const attempt = nextWaitContinuationAttempt(soonestWait.correlationId);
+                await queueMessage(world, getWorkflowQueueName(workflowRun.workflowName, namespace), {
+                    runId,
+                    traceCarrier: await nextTraceCarrier(),
+                    requestedAt: new Date(),
+                    waitContinuation: {
+                        correlationId: soonestWait.correlationId,
+                        attempt,
+                    },
+                }, getWaitContinuationDispatch(soonestWait.seconds, soonestWait.correlationId, Date.now(), attempt));
+                wfdiag('wait_continuation_scheduled', {
+                    correlationId: soonestWait.correlationId,
+                    delaySeconds: soonestWait.seconds,
+                    attempt,
+                });
+            }
+            // 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.
+            // Inline delta: a single inline step's terminal write asks the World
+            // for everything after the cursor this view holds, so the step's own
+            // events (and anything interleaved) arrive on the write's response and
+            // the feed below needs no listing. Same gate as the node engine's
+            // `requestInlineDelta` (runtime.ts), translated to this loop's terms:
+            //
+            // - This step is the only step outstanding: no overflow sibling queued
+            //   this iteration, no unserializable sibling, no step from an earlier
+            //   invocation handed to the queue above. Several writers each diffing
+            //   against the same cursor would produce deltas of which only the
+            //   first could be taken.
+            // - No wait is pending. A `wait_completed` is a resolution the
+            //   workflow is waiting on rather than an event it can observe one
+            //   iteration late, so a delta that predates it would settle the
+            //   sleep from a view that does not hold its completion; the listing
+            //   after the step is what reads it in order.
+            // - The log has a cursor to name (tracking on, something read).
+            const hasPendingWait = pendingOperations.some((op) => op.type === 'wait' &&
+                !completedWaitIds2.has(op.correlationId));
+            const inlineDeltaSinceCursor = stepOps.length === 1 &&
+                freshSteps.length === 1 &&
+                inlineCandidates.length === 1 &&
+                !hasPendingWait &&
+                logView.tracking &&
+                typeof logView.logCursor === 'string'
+                ? logView.logCursor
+                : undefined;
+            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,
+                    requestId,
+                    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,
+                    ...(inlineDeltaSinceCursor !== undefined
+                        ? { inlineDeltaSinceCursor }
+                        : {}),
+                }))())));
+            }
+            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 === 'completed' &&
+                    outcome.inlineDelta !== undefined &&
+                    inlineDeltaSinceCursor !== undefined) {
+                    const advanced = logView.absorbDelta(inlineDeltaSinceCursor, outcome.inlineDelta);
+                    wfdiag('inline_delta_absorbed', {
+                        iteration,
+                        correlationId: step.correlationId,
+                        events: outcome.inlineDelta.events.length,
+                        hasMore: outcome.inlineDelta.hasMore,
+                        cursorAdvanced: advanced,
+                    });
+                }
+                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 dispatch key, 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 queued = takeQueuedEvents();
+            const newEvents = queued.length > 0 ? queued : 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,
+                    // Plain create: the run is ending, nothing replays its log, so a
+                    // page handed back here would be read by no one.
+                    createEvent: terminalCreateEvent,
+                    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 terminalCreateEvent({
+                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), so 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, so 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, so 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);
+            const attempt = nextWaitContinuationAttempt(soonestWait.correlationId);
+            await queueMessage(world, getWorkflowQueueName(workflowRun.workflowName, namespace), {
+                runId,
+                traceCarrier: await nextTraceCarrier(),
+                requestedAt: new Date(),
+                waitContinuation: {
+                    correlationId: soonestWait.correlationId,
+                    attempt,
+                },
+            }, getWaitContinuationDispatch(soonestWait.seconds, soonestWait.correlationId, Date.now(), attempt));
+            return;
+        }
+        wfdiag('exit_suspended', {
+            action: 'awaiting_external',
+            pendingOpsCount: pendingOperations.length,
+        });
+    }
+    else if (result.failed) {
+        // Workflow failed, so remap stack trace using inline source maps.
+        // Frames carry the run's workflowId as their filename on the fresh
+        // path, but the workflow-independent BASELINE_BUNDLE_FILENAME on the
+        // snapshot path (the name is baked into the shared baseline's
+        // compiled code at hydrate), so remap against both. remapErrorStack
+        // early-exits on a cheap includes() when a filename has no frames.
+        let errorStack = result.failed.stack;
+        if (errorStack) {
+            const parsedName = parseWorkflowName(workflowName);
+            const filename = parsedName?.moduleSpecifier || workflowName;
+            errorStack = remapErrorStack(errorStack, filename, workflowCode);
+            errorStack = remapErrorStack(errorStack, BASELINE_BUNDLE_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,
+                    createEvent: terminalCreateEvent,
+                    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.
+        //     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;
+                    // Both filename spaces. See the failed-branch comment above.
+                    hydrated.stack = remapErrorStack(remapErrorStack(hydrated.stack, filename, workflowCode), BASELINE_BUNDLE_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;
+                        // Both filename spaces. See the failed-branch comment above.
+                        node.stack = remapErrorStack(remapErrorStack(nodeStack, filename, workflowCode), BASELINE_BUNDLE_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 (applying
+                // 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 terminalCreateEvent({
+                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":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACtB,eAAe,EACf,0BAA0B,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAKL,qBAAqB,EAErB,oBAAoB,EACpB,0CAA0C,EAC1C,iCAAiC,GAElC,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EACL,oBAAoB,EACpB,OAAO,IAAI,qBAAqB,GAEjC,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,kBAAkB,EAClB,eAAe,EACf,YAAY,GACb,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,KAAK,SAAS,MAAM,sCAAsC,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EACL,8BAA8B,EAC9B,iBAAiB,EACjB,8BAA8B,EAC9B,8BAA8B,GAC/B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EACL,oBAAoB,EACpB,YAAY,EACZ,kBAAkB,EAClB,0BAA0B,GAC3B,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EACL,wBAAwB,EAOxB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAA4B,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,kCAAkC,EAAE,MAAM,0BAA0B,CAAC;AAC9E,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAQtC,wEAAwE;AACxE,SAAS,IAAI;IACX,OAAO,WAAW,CAAC,GAAG,EAAE,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,iBAAiB,CAC/B,eAA6C;IAE7C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACpE,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,eAAe,CAAC,KAAK,CAC1B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,aAAa,IAAI,CAAC,CAAC,SAAS,KAAK,aAAa,CACtE,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,KAAK,UAAU,gBAAgB,CAAC,MAmC/B;IACC,MAAM,EACJ,KAAK,EACL,KAAK,EACL,WAAW,EACX,IAAI,EACJ,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,OAAO,EACP,SAAS,EACT,MAAM,GACP,GAAG,MAAM,CAAC;IACX,MAAM,YAAY,GAAG,MAAM,gBAAgB,EAAE,CAAC;IAC9C,MAAM,YAAY,CAChB,KAAK,EACL,oBAAoB,CAAC,WAAW,CAAC,YAAY,EAAE,SAAS,CAAC,EACzD;QACE,KAAK;QACL,MAAM,EAAE,IAAI,CAAC,aAAa;QAC1B,QAAQ,EAAE,IAAI,CAAC,MAAM;QACrB,YAAY;QACZ,WAAW,EAAE,IAAI,IAAI,EAAE;QACvB,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACvE,sEAAsE;QACtE,oDAAoD;QACpD,UAAU,EAAE,kBAAkB,CAAC,WAAW,CAAC;KAC5C,EACD;QACE,qEAAqE;QACrE,sEAAsE;QACtE,kEAAkE;QAClE,uEAAuE;QACvE,kCAAkC;QAClC,cAAc,EACZ,OAAO,KAAK,UAAU;YACpB,CAAC,CAAC,0BAA0B,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC;YAC7D,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,IAAI,OAAO,EAAE;QACxC,GAAG,CAAC,YAAY,IAAI,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC9D,CACF,CAAC;IACF,MAAM,CAAC,aAAa,EAAE;QACpB,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,aAAa,EAAE,IAAI,CAAC,aAAa;QACjC,OAAO;QACP,YAAY,EAAE,YAAY,IAAI,CAAC;QAC/B,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACxD,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,KAAK,UAAU,kBAAkB,CAAC,MAgEjC;IAaC,MAAM,EACJ,KAAK,EACL,KAAK,EACL,WAAW,EACX,aAAa,EACb,iBAAiB,EACjB,SAAS,EACT,gBAAgB,EAChB,WAAW,GACZ,GAAG,MAAM,CAAC;IACX,MAAM,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC;IACjD,MAAM,aAAa,GAAG,MAAM,CAAC,aAAa,CAAC;IAC3C,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAC7B,sEAAsE;IACtE,wEAAwE;IACxE,uCAAuC;IACvC,MAAM,cAAc,GAAG,IAAI,GAAG,EAAU,CAAC;IACzC,wEAAwE;IACxE,qEAAqE;IACrE,MAAM,2BAA2B,GAAG,IAAI,GAAG,EAAU,CAAC;IACtD,0EAA0E;IAC1E,2EAA2E;IAC3E,oDAAoD;IACpD,EAAE;IACF,oDAAoD;IACpD,wEAAwE;IACxE,0EAA0E;IAC1E,sEAAsE;IACtE,yEAAyE;IACzE,sEAAsE;IACtE,mEAAmE;IACnE,MAAM,yBAAyB,GAC7B,aAAa,KAAK,SAAS;QAC3B,aAAa,CAAC,IAAI,GAAG,CAAC;QACtB,8BAA8B,EAAE;QAChC,CAAC,WAAW,CAAC,WAAW,IAAI,CAAC,CAAC;YAC5B,0CAA0C,CAAC;IAC/C,8DAA8D;IAC9D,wEAAwE;IACxE,0DAA0D;IAC1D,IAAI,sBAAsB,GAAG,KAAK,CAAC;IACnC,gEAAgE;IAChE,mEAAmE;IACnE,oEAAoE;IACpE,mCAAmC;IACnC,IAAI,qBAAqB,GAAG,KAAK,CAAC;IAClC,MAAM,WAAW,GAAoB,EAAE,CAAC;IACxC,MAAM,oBAAoB,GAAG,iBAAiB,CAAC,MAAM,CACnD,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,KAAK,MAAM,IAAI,CAAC,EAAE,CAAC,eAAe,CAClD,CAAC,MAAM,CAAC;IACT,MAAM,eAAe,GACnB,oBAAoB,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;IAE9D,MAAM,aAAa,GAAG,KAAK,EAAE,IAAiB,EAAiB,EAAE;QAC/D,aAAa,CAAC,KAAK,CAAC,qCAAqC,EAAE;YACzD,aAAa,EAAE,KAAK;YACpB,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,SAAS,EAAE,OAAO,IAAI,CAAC,KAAK;YAC5B,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC,CAAC;QAEH,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;YAC1B,uDAAuD;YACvD,4DAA4D;YAC5D,yDAAyD;YACzD,0DAA0D;YAC1D,iCAAiC;YACjC,EAAE;YACF,iEAAiE;YACjE,+DAA+D;YAC/D,gEAAgE;YAChE,8DAA8D;YAC9D,uCAAuC;YACvC,IAAI,CAAC;gBACH,MAAM,iBAAiB,GACrB,OAAO,IAAI,CAAC,QAAQ,KAAK,WAAW;oBAClC,CAAC,CAAC,SAAS;oBACX,CAAC,CAAC,MAAM,qBAAqB,CAAC,IAAI,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;gBAChE,MAAM,MAAM,GAAG,MAAM,WAAW,CAC9B;oBACE,SAAS,EAAE,cAAc;oBACzB,WAAW,EAAE,oBAAoB;oBACjC,aAAa,EAAE,IAAI,CAAC,aAAa;oBACjC,SAAS,EAAE;wBACT,KAAK,EAAE,IAAI,CAAC,KAAK;wBACjB,mBAAmB,EACjB,IAAI,CAAC,mBAAmB,KAAK,SAAS;4BACpC,CAAC,CAAC,SAAS;4BACX,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC;wBACxC,QAAQ,EAAE,iBAAiB;wBAC3B,4DAA4D;wBAC5D,2DAA2D;wBAC3D,2DAA2D;wBAC3D,SAAS,EAAE,IAAI,CAAC,SAAS;wBACzB,sDAAsD;wBACtD,mCAAmC;wBACnC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;qBACtC;iBACT,EACD,eAAe,KAAK,SAAS;oBAC3B,CAAC,CAAC,EAAE,WAAW,EAAE,eAAe,EAAE;oBAClC,CAAC,CAAC,SAAS,CACd,CAAC;gBAEF,yDAAyD;gBACzD,wDAAwD;gBACxD,kDAAkD;gBAClD,IAAI,MAAM,CAAC,KAAK,EAAE,SAAS,KAAK,eAAe,EAAE,CAAC;oBAChD,MAAM,YAAY,CAChB,KAAK,EACL,oBAAoB,CAAC,WAAW,CAAC,YAAY,EAAE,SAAS,CAAC,EACzD;wBACE,KAAK;wBACL,YAAY,EAAE,MAAM,gBAAgB,EAAE;wBACtC,WAAW,EAAE,IAAI,IAAI,EAAE;qBACxB,EACD,EAAE,cAAc,EAAE,iBAAiB,IAAI,CAAC,aAAa,EAAE,EAAE,CAC1D,CAAC;gBACJ,CAAC;YACH,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,8DAA8D;gBAC9D,yDAAyD;gBACzD,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC;oBAAE,MAAM,GAAG,CAAC;YAC9C,CAAC;YACD,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;gBAC/B,sBAAsB,GAAG,IAAI,CAAC;YAChC,CAAC;QACH,CAAC;QAED,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,2DAA2D;YAC3D,yDAAyD;YACzD,sDAAsD;YACtD,uDAAuD;YACvD,+BAA+B;YAC/B,MAAM,YAAY,GAChB,IAAI,CAAC,YAAY,YAAY,UAAU;gBACrC,CAAC,CAAE,CAAC,MAAM,qBAAqB,CAC3B,IAAI,CAAC,YAAY,EACjB,aAAa,CACd,CAAgB;gBACnB,CAAC,CAAC,SAAS,CAAC;YAChB,IAAI,CAAC;gBACH,MAAM,WAAW,CAAC;oBAChB,SAAS,EAAE,eAAe;oBAC1B,WAAW,EAAE,oBAAoB;oBACjC,aAAa,EAAE,IAAI,CAAC,aAAa;oBACjC,SAAS,EAAE;wBACT,KAAK,EAAE,IAAI,CAAC,KAAK;wBACjB,OAAO,EAAE,YAAY;qBACf;iBACT,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC;oBAAE,MAAM,GAAG,CAAC;YAC9C,CAAC;YACD,kDAAkD;YAClD,4CAA4C;YAC5C,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,YAAY,EAAE,CAAC;gBACnD,MAAM,UAAU,GAAG,QAAQ,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC;gBAC3E,IAAI,CAAC;oBACH,MAAM,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC;oBAC3D,MAAM,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;gBAC/C,CAAC;gBAAC,MAAM,CAAC;oBACP,mDAAmD;oBACnD,YAAY;oBACZ,aAAa,CAAC,KAAK,CACjB,sDAAsD,EACtD;wBACE,aAAa,EAAE,KAAK;wBACpB,aAAa,EAAE,IAAI,CAAC,aAAa;qBAClC,CACF,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,MAAM,CAAC,gBAAgB,EAAE;gBACvB,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,KAAK,EAAE,IAAI,CAAC,KAAK;aAClB,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC;IAEF,MAAM,oBAAoB,GAAG,KAAK,EAChC,EAAsB,EACP,EAAE;QACjB,IAAI,CAAC;YACH,MAAM,WAAW,CAAC;gBAChB,SAAS,EAAE,eAAe;gBAC1B,WAAW,EAAE,oBAAoB;gBACjC,aAAa,EAAE,EAAE,CAAC,aAAa;gBAC/B,sEAAsE;gBACtE,uEAAuE;gBACvE,qEAAqE;gBACrE,oEAAoE;gBACpE,oEAAoE;gBACpE,wDAAwD;gBACxD,GAAG,CAAC,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC;aACtE,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC;gBAAE,OAAO;YACxC,kEAAkE;YAClE,4DAA4D;YAC5D,6DAA6D;YAC7D,+DAA+D;YAC/D,IAAI,iBAAiB,CAAC,EAAE,CAAC,GAAG,CAAC;gBAAE,OAAO;YACtC,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC,CAAC;IAEF,qEAAqE;IACrE,iEAAiE;IACjE,kEAAkE;IAClE,iEAAiE;IACjE,qEAAqE;IACrE,qEAAqE;IACrE,qEAAqE;IACrE,qEAAqE;IACrE,mCAAmC;IACnC,MAAM,cAAc,GAAG,IAAI,GAAG,EAG3B,CAAC;IACJ,KAAK,MAAM,EAAE,IAAI,iBAAiB,EAAE,CAAC;QACnC,IAAI,GAAuB,CAAC;QAC5B,IACE,EAAE,CAAC,IAAI,KAAK,MAAM;YAClB,CAAC,CAAC,EAAE,CAAC,eAAe,IAAK,EAAkB,CAAC,cAAc,CAAC,EAC3D,CAAC;YACD,GAAG,GAAI,EAAkB,CAAC,KAAK,CAAC;QAClC,CAAC;aAAM,IAAI,EAAE,CAAC,IAAI,KAAK,cAAc,IAAI,CAAC,EAAE,CAAC,eAAe,EAAE,CAAC;YAC7D,+DAA+D;YAC/D,uDAAuD;YACvD,GAAG,GAAI,EAAyB,CAAC,KAAK,IAAI,SAAS,EAAE,CAAC,aAAa,EAAE,CAAC;QACxE,CAAC;QACD,IAAI,GAAG,KAAK,SAAS;YAAE,SAAS;QAChC,MAAM,KAAK,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACtC,IAAI,KAAK,EAAE,CAAC;YACV,KAAK,CAAC,IAAI,CAAC,EAAsC,CAAC,CAAC;QACrD,CAAC;aAAM,CAAC;YACN,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,EAAsC,CAAC,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IACD,KAAK,MAAM,KAAK,IAAI,cAAc,CAAC,MAAM,EAAE,EAAE,CAAC;QAC5C,WAAW,CAAC,IAAI,CACd,CAAC,KAAK,IAAI,EAAE;YACV,KAAK,MAAM,EAAE,IAAI,KAAK,EAAE,CAAC;gBACvB,IAAI,EAAE,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;oBACvB,MAAM,aAAa,CAAC,EAAE,CAAC,CAAC;gBAC1B,CAAC;qBAAM,CAAC;oBACN,MAAM,oBAAoB,CAAC,EAAE,CAAC,CAAC;gBACjC,CAAC;YACH,CAAC;QACH,CAAC,CAAC,EAAE,CACL,CAAC;IACJ,CAAC;IAED,KAAK,MAAM,EAAE,IAAI,iBAAiB,EAAE,CAAC;QACnC,IACE,EAAE,CAAC,IAAI,KAAK,MAAM;YAClB,CAAC,EAAE,CAAC,eAAe;YACnB,CAAC,gBAAgB,EAAE,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC,EACxC,CAAC;YACD,MAAM,IAAI,GAAG,EAAiB,CAAC;YAC/B,WAAW,CAAC,IAAI,CACd,CAAC,KAAK,IAAI,EAAE;gBACV,+DAA+D;gBAC/D,gEAAgE;gBAChE,mEAAmE;gBACnE,8DAA8D;gBAC9D,0DAA0D;gBAC1D,gEAAgE;gBAChE,yDAAyD;gBACzD,oDAAoD;gBACpD,8DAA8D;gBAC9D,cAAc;gBACd,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;oBAC5B,IAAI,CAAC,MAAM,CAAC,2BAA2B,EAAE,CAAC;wBACxC,OAAO;oBACT,CAAC;oBACD,aAAa,CAAC,IAAI,CAChB,0DAA0D;wBACxD,oCAAoC,EACtC;wBACE,aAAa,EAAE,KAAK;wBACpB,aAAa,EAAE,IAAI,CAAC,aAAa;wBACjC,QAAQ,EAAE,IAAI,CAAC,MAAM;wBACrB,KAAK,EAAE,IAAI,CAAC,kBAAkB,CAAC,OAAO;qBACvC,CACF,CAAC;oBACF,IAAI,CAAC;wBACH,MAAM,WAAW,CAAC;4BAChB,SAAS,EAAE,cAAc;4BACzB,WAAW,EAAE,oBAAoB;4BACjC,aAAa,EAAE,IAAI,CAAC,aAAa;4BACjC,SAAS,EAAE;gCACT,QAAQ,EAAE,IAAI,CAAC,MAAM;gCACrB,KAAK,EAAE,CAAC,MAAM,sBAAsB,CAClC,kCAAkC,EAAE,EACpC,KAAK,EACL,aAAa,EACb,UAAU,EACV,KAAK,EACL,CAAC,WAAW,CAAC,WAAW,IAAI,CAAC,CAAC;oCAC5B,iCAAiC,CACpC,CAAe;6BACjB;yBACF,CAAC,CAAC;oBACL,CAAC;oBAAC,OAAO,GAAG,EAAE,CAAC;wBACb,2DAA2D;wBAC3D,qDAAqD;wBACrD,IAAI,eAAe,CAAC,EAAE,CAAC,GAAG,CAAC;4BAAE,OAAO;wBACpC,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC;4BAAE,MAAM,GAAG,CAAC;oBAC9C,CAAC;oBACD,IAAI,CAAC;wBACH,MAAM,WAAW,CAAC;4BAChB,SAAS,EAAE,aAAa;4BACxB,WAAW,EAAE,oBAAoB;4BACjC,aAAa,EAAE,IAAI,CAAC,aAAa;4BACjC,SAAS,EAAE;gCACT,QAAQ,EAAE,IAAI,CAAC,MAAM;gCACrB,KAAK,EAAE,MAAM,kBAAkB,CAC7B,IAAI,CAAC,kBAAkB,EACvB,KAAK,EACL,aAAa,EACb,EAAE,EACF,UAAU,EACV,CAAC,WAAW,CAAC,WAAW,IAAI,CAAC,CAAC;oCAC5B,iCAAiC,CACpC;6BACF;yBACF,CAAC,CAAC;oBACL,CAAC;oBAAC,OAAO,GAAG,EAAE,CAAC;wBACb,iDAAiD;wBACjD,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;4BAC7D,MAAM,GAAG,CAAC;wBACZ,CAAC;oBACH,CAAC;oBACD,2BAA2B,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;oBACpD,MAAM,CAAC,2BAA2B,EAAE;wBAClC,MAAM,EAAE,IAAI,CAAC,MAAM;wBACnB,aAAa,EAAE,IAAI,CAAC,aAAa;qBAClC,CAAC,CAAC;oBACH,OAAO;gBACT,CAAC;gBAED,iDAAiD;gBACjD,4DAA4D;gBAC5D,0DAA0D;gBAC1D,uDAAuD;gBACvD,yDAAyD;gBACzD,kCAAkC;gBAClC,uDAAuD;gBACvD,MAAM,cAAc,GAAG,MAAM,qBAAqB,CAChD,IAAI,CAAC,KAAK,EACV,aAAa,CACd,CAAC;gBAEF,+DAA+D;gBAC/D,4DAA4D;gBAC5D,0DAA0D;gBAC1D,8DAA8D;gBAC9D,8DAA8D;gBAC9D,6DAA6D;gBAC7D,yDAAyD;gBACzD,6DAA6D;gBAC7D,IACE,yBAAyB;oBACzB,aAAa,EAAE,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC;oBACtC,cAAc,YAAY,UAAU;oBACpC,cAAc,CAAC,UAAU,IAAI,8BAA8B,EAC3D,CAAC;oBACD,MAAM,CAAC,YAAY,EAAE,WAAW,CAAC,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC;wBAC3D,WAAW,CAAC;4BACV,SAAS,EAAE,cAAc;4BACzB,WAAW,EAAE,oBAAoB;4BACjC,aAAa,EAAE,IAAI,CAAC,aAAa;4BACjC,SAAS,EAAE;gCACT,QAAQ,EAAE,IAAI,CAAC,MAAM;gCACrB,KAAK,EAAE,cAAc;6BACtB;yBACF,CAAC;wBACF,gBAAgB,CAAC;4BACf,KAAK;4BACL,KAAK;4BACL,WAAW;4BACX,IAAI;4BACJ,SAAS;4BACT,gBAAgB;4BAChB,OAAO,EAAE,UAAU;4BACnB,SAAS,EAAE,cAAc;4BACzB,MAAM;yBACP,CAAC;qBACH,CAAC,CAAC;oBACH,wDAAwD;oBACxD,wDAAwD;oBACxD,yDAAyD;oBACzD,oDAAoD;oBACpD,0DAA0D;oBAC1D,kCAAkC;oBAClC,IAAI,WAAW,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;wBACtC,MAAM,WAAW,CAAC,MAAM,CAAC;oBAC3B,CAAC;oBACD,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;oBACvC,IAAI,YAAY,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;wBACvC,MAAM,GAAG,GAAG,YAAY,CAAC,MAAM,CAAC;wBAChC,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;4BAChC,uDAAuD;4BACvD,oDAAoD;4BACpD,+CAA+C;4BAC/C,OAAO;wBACT,CAAC;wBACD,IAAI,qBAAqB,CAAC,GAAG,CAAC,EAAE,CAAC;4BAC/B,uDAAuD;4BACvD,qDAAqD;4BACrD,mDAAmD;4BACnD,kDAAkD;4BAClD,aAAa;4BACb,aAAa,CAAC,IAAI,CAChB,qDAAqD;gCACnD,mDAAmD;gCACnD,wCAAwC,EAC1C;gCACE,aAAa,EAAE,KAAK;gCACpB,aAAa,EAAE,IAAI,CAAC,aAAa;gCACjC,QAAQ,EAAE,IAAI,CAAC,MAAM;gCACrB,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;6BACxD,CACF,CAAC;4BACF,MAAM,CAAC,mCAAmC,EAAE;gCAC1C,MAAM,EAAE,IAAI,CAAC,MAAM;gCACnB,aAAa,EAAE,IAAI,CAAC,aAAa;6BAClC,CAAC,CAAC;4BACH,OAAO;wBACT,CAAC;wBACD,MAAM,GAAG,CAAC;oBACZ,CAAC;oBACD,OAAO;gBACT,CAAC;gBAED,IAAI,CAAC;oBACH,MAAM,WAAW,CAAC;wBAChB,SAAS,EAAE,cAAc;wBACzB,WAAW,EAAE,oBAAoB;wBACjC,aAAa,EAAE,IAAI,CAAC,aAAa;wBACjC,SAAS,EAAE;4BACT,QAAQ,EAAE,IAAI,CAAC,MAAM;4BACrB,KAAK,EAAE,cAAc;yBACtB;qBACF,CAAC,CAAC;gBACL,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC;wBAAE,OAAO;oBACxC,MAAM,GAAG,CAAC;gBACZ,CAAC;gBAED,8DAA8D;gBAC9D,2DAA2D;gBAC3D,oDAAoD;gBACpD,qBAAqB;YACvB,CAAC,CAAC,EAAE,CACL,CAAC;QACJ,CAAC;aAAM,IAAI,EAAE,CAAC,IAAI,KAAK,WAAW,IAAI,CAAC,EAAE,CAAC,eAAe,EAAE,CAAC;YAC1D,MAAM,IAAI,GAAG,EAAsB,CAAC;YACpC,WAAW,CAAC,IAAI,CACd,CAAC,KAAK,IAAI,EAAE;gBACV,IAAI,CAAC;oBACH,MAAM,WAAW,CAAC;wBAChB,SAAS,EAAE,UAAU;wBACrB,WAAW,EAAE,oBAAoB;wBACjC,aAAa,EAAE,IAAI,CAAC,aAAa;wBACjC,SAAS,EAAE;4BACT,OAAO,EAAE,IAAI,CAAC,OAAO;4BACrB,MAAM,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;4BAC5B,GAAG,CAAC,IAAI,CAAC,uBAAuB;gCAC9B,CAAC,CAAC,EAAE,uBAAuB,EAAE,IAAI,EAAE;gCACnC,CAAC,CAAC,EAAE,CAAC;yBACD;qBACT,CAAC,CAAC;oBACH,qBAAqB,GAAG,IAAI,CAAC;gBAC/B,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;wBAChC,wDAAwD;wBACxD,gDAAgD;wBAChD,qBAAqB,GAAG,IAAI,CAAC;wBAC7B,OAAO;oBACT,CAAC;oBACD,MAAM,GAAG,CAAC;gBACZ,CAAC;YACH,CAAC,CAAC,EAAE,CACL,CAAC;QACJ,CAAC;aAAM,IAAI,EAAE,CAAC,IAAI,KAAK,MAAM,IAAI,CAAC,EAAE,CAAC,eAAe,EAAE,CAAC;YACrD,MAAM,IAAI,GAAG,EAAiB,CAAC;YAC/B,WAAW,CAAC,IAAI,CACd,CAAC,KAAK,IAAI,EAAE;gBACV,IAAI,CAAC;oBACH,MAAM,WAAW,CAAC;wBAChB,SAAS,EAAE,cAAc;wBACzB,WAAW,EAAE,oBAAoB;wBACjC,aAAa,EAAE,IAAI,CAAC,aAAa;wBACjC,SAAS,EAAE;4BACT,QAAQ,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;yBAClC;qBACF,CAAC,CAAC;gBACL,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC;wBAAE,OAAO;oBACxC,MAAM,GAAG,CAAC;gBACZ,CAAC;YACH,CAAC,CAAC,EAAE,CACL,CAAC;QACJ,CAAC;IACH,CAAC;IAED,oCAAoC;IACpC,MAAM,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAE/B,OAAO;QACL,qBAAqB;QACrB,sBAAsB;QACtB,cAAc;QACd,2BAA2B;KAC5B,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAAC,MAuF5C;IACC,MAAM,EACJ,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,eAAe,EACf,uBAAuB,EACvB,eAAe,EACf,QAAQ,EACR,UAAU,EACV,cAAc,EACd,eAAe,EACf,cAAc,EACd,SAAS,EACT,SAAS,EACT,gBAAgB,GACjB,GAAG,MAAM,CAAC;IAEX;;;;;;;OAOG;IACH,MAAM,2BAA2B,GAAG,CAAC,aAAqB,EAAU,EAAE,CACpE,gBAAgB,EAAE,aAAa,KAAK,aAAa;QAC/C,CAAC,CAAC,gBAAgB,CAAC,OAAO,GAAG,CAAC;QAC9B,CAAC,CAAC,CAAC,CAAC;IACR,mEAAmE;IACnE,yDAAyD;IACzD,MAAM,gBAAgB,GACpB,MAAM,CAAC,gBAAgB,IAAI,CAAC,GAAG,EAAE,CAAC,qBAAqB,EAAE,CAAC,CAAC;IAC7D,MAAM,KAAK,GAAG,MAAM,QAAQ,EAAE,CAAC;IAC/B,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC;IAChC,MAAM,eAAe,GAAG,IAAI,EAAE,CAAC;IAE/B,sEAAsE;IACtE,2DAA2D;IAC3D,oEAAoE;IACpE,4DAA4D;IAC5D,qEAAqE;IACrE,8BAA8B;IAC9B,MAAM,iBAAiB,GAAG,oBAAoB,CAAC,YAAY,CAAC,CAAC;IAE7D,uEAAuE;IACvE,sEAAsE;IACtE,sBAAsB;IACtB,MAAM,YAAY,GAAG,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;IAEtE,uEAAuE;IACvE,MAAM,MAAM,GAAG,CAAC,UAAkB,EAAE,MAA+B,EAAE,EAAE;QACrE,aAAa,CAAC,KAAK,CAAC,iBAAiB,EAAE;YACrC,UAAU;YACV,KAAK;YACL,YAAY;YACZ,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,eAAe,CAAC;YAChD,GAAG,MAAM;SACV,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,UAAU,EAAE,aAAa,CAAC;QACxB,GAAG,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC;KACnC,CAAC,CAAC;IAEH,MAAM,CAAC,OAAO,EAAE;QACd,YAAY;QACZ,eAAe;QACf,kBAAkB,EAChB,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC;QAC9D,mBAAmB,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;QACjD,WAAW,EAAE,CAAC,CAAC,QAAQ;KACxB,CAAC,CAAC;IAEH,wEAAwE;IACxE,kDAAkD;IAClD,MAAM,UAAU,GAAG,YAAY,CAAC;IAEhC,+DAA+D;IAC/D,sEAAsE;IACtE,wEAAwE;IACxE,0EAA0E;IAC1E,uEAAuE;IACvE,gEAAgE;IAChE,0EAA0E;IAC1E,0EAA0E;IAC1E,uEAAuE;IACvE,uCAAuC;IACvC,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC,WAAW,CAAC,CAAC;IACjE,MAAM,aAAa,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAE9E,+DAA+D;IAC/D,sEAAsE;IACtE,mEAAmE;IACnE,yDAAyD;IACzD,IAAI,MAAe,CAAC;IACpB,IAAI,kBAAkB,GAAG,CAAC,CAAC;IAC3B,0EAA0E;IAC1E,0EAA0E;IAC1E,qCAAqC;IACrC,IAAI,YAAY,GAAkB,IAAI,CAAC;IACvC,MAAM,YAAY,GAChB,CAAC,uBAAuB,KAAK,IAAI;QAC/B,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC;QAC9B,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC;QAC7B,iBAAiB,CAAC,eAAe,CAAC,CAAC;IACrC,IAAI,YAAY,IAAI,eAAe,EAAE,CAAC;QACpC,MAAM,GAAG,eAAe,CAAC;QACzB,YAAY,GAAG,eAAe,IAAI,IAAI,CAAC;IACzC,CAAC;SAAM,CAAC;QACN,MAAM,SAAS,GAAY,EAAE,CAAC;QAC9B,IAAI,MAAM,GAAkB,IAAI,CAAC;QACjC,IAAI,OAAO,GAAG,IAAI,CAAC;QAEnB,OAAO,OAAO,EAAE,CAAC;YACf,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC;gBACvC,KAAK;gBACL,UAAU,EAAE;oBACV,SAAS,EAAE,KAAK;oBAChB,MAAM,EAAE,MAAM,IAAI,SAAS;oBAC3B,KAAK,EAAE,IAAI;iBACZ;aACF,CAAC,CAAC;YACH,kBAAkB,EAAE,CAAC;YACrB,SAAS,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;YACjC,oEAAoE;YACpE,iEAAiE;YACjE,yEAAyE;YACzE,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;gBACpB,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;YAC3B,CAAC;YACD,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,CAAC,MAAM,IAAI,IAAI,CAAC;QAChE,CAAC;QAED,MAAM,GAAG,SAAS,CAAC;QACnB,YAAY,GAAG,MAAM,CAAC;IACxB,CAAC;IAED,yEAAyE;IACzE,yEAAyE;IACzE,uEAAuE;IACvE,mEAAmE;IACnE,MAAM,OAAO,GAAG,IAAI,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACzD,MAAM,WAAW,GAAiB,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE;QAC5D,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE;YACpD,GAAG,WAAW;YACd,GAAG,OAAO,CAAC,cAAc,EAAE;SAC5B,CAAC,CAAC;QACH,IACE,OAAO,WAAW,EAAE,WAAW,KAAK,QAAQ;YAC5C,MAAM,CAAC,MAAM,KAAK,SAAS,EAC3B,CAAC;YACD,qEAAqE;YACrE,kEAAkE;YAClE,kEAAkE;YAClE,0DAA0D;YAC1D,OAAO,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;YACxC,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,WAAW,EAAE;gBAC5D,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,IAAI;gBAC7B,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,KAAK;aACjC,CAAC,CAAC;YACH,MAAM,CAAC,uBAAuB,EAAE;gBAC9B,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM;gBAC5B,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,KAAK;gBAChC,cAAc,EAAE,QAAQ;aACzB,CAAC,CAAC;YACH,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,uEAAuE;QACvE,yEAAyE;QACzE,8DAA8D;QAC9D,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE;YACtC,YAAY,EAAE,IAAI,CAAC,SAAS,KAAK,gBAAgB;SAClD,CAAC,CAAC;QACH,IAAI,QAAQ,CAAC,SAAS,EAAE,CAAC;YACvB,aAAa,CAAC,KAAK,CACjB,0DAA0D,EAC1D;gBACE,aAAa,EAAE,KAAK;gBACpB,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,OAAO,EAAE,MAAM,CAAC,KAAK,EAAE,OAAO;gBAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;aACpC,CACF,CAAC;QACJ,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;IACF;;;;;OAKG;IACH,MAAM,mBAAmB,GAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,CAC9D,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;IAEhD,iEAAiE;IACjE,qEAAqE;IACrE,wBAAwB;IACxB,IAAI,cAAc,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,IAAI,cAAc,EAAE,CAAC;QACpE,MAAM,IAAI,sBAAsB,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAClE,CAAC;IAED,UAAU,EAAE,aAAa,CAAC;QACxB,GAAG,SAAS,CAAC,sBAAsB,CAAC,YAAY,CAAC;QACjD,GAAG,SAAS,CAAC,yBAAyB,CAAC,MAAM,CAAC,MAAM,CAAC;QACrD,GAAG,SAAS,CAAC,yBAAyB,CAAC,kBAAkB,CAAC;KAC3D,CAAC,CAAC;IAEH,MAAM,CAAC,gBAAgB,EAAE;QACvB,UAAU,EAAE,MAAM,CAAC,MAAM;QACzB,kBAAkB;QAClB,YAAY;QACZ,UAAU,EAAE,MAAM,CAAC,MAAM,CAAyB,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE;YAC3D,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;YAC/C,OAAO,GAAG,CAAC;QACb,CAAC,EAAE,EAAE,CAAC;KACP,CAAC,CAAC;IAEH,0BAA0B;IAC1B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAC9B,MAAM;SACH,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,gBAAgB,CAAC;SAC/C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAC/B,CAAC;IACF,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IACE,KAAK,CAAC,SAAS,KAAK,cAAc;YAClC,KAAK,CAAC,aAAa;YACnB,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC,EAC1C,CAAC;YACD,MAAM,SAAS,GACb,WAAW,IAAI,KAAK;gBAClB,CAAC,CAAE,KAAK,CAAC,SAAqC;gBAC9C,CAAC,CAAC,SAAS,CAAC;YAChB,MAAM,QAAQ,GAAG,SAAS,EAAE,QAAQ,CAAC;YACrC,IAAI,QAAQ,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC,QAAkB,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC;gBAC9D,IAAI,CAAC;oBACH,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC;wBAC/B,SAAS,EAAE,gBAAgB;wBAC3B,WAAW,EAAE,oBAAoB;wBACjC,aAAa,EAAE,KAAK,CAAC,aAAa;qBACnC,CAAC,CAAC;oBACH,IAAI,CAAC,OAAO,CAAC,QAAQ,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;wBACtC,8DAA8D;wBAC9D,oDAAoD;wBACpD,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;oBAC5B,CAAC;gBACH,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC;wBAAE,SAAS;oBAC1C,MAAM,GAAG,CAAC;gBACZ,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IACD,qEAAqE;IACrE,0EAA0E;IAC1E,6DAA6D;IAC7D,MAAM,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAEzC,yEAAyE;IACzE,wEAAwE;IACxE,wDAAwD;IACxD,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC;IACtD,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,WAAW,EAAE,CAAC;IAExD,qCAAqC;IACrC,aAAa,CAAC,KAAK,CAAC,8BAA8B,EAAE;QAClD,aAAa,EAAE,KAAK;QACpB,UAAU;QACV,UAAU,EAAE,MAAM,CAAC,MAAM;KAC1B,CAAC,CAAC;IAEH,MAAM,OAAO,GAAG,MAAM,oBAAoB,CAAC;QACzC,8DAA8D;QAC9D,gEAAgE;QAChE,mEAAmE;QACnE,mDAAmD;QACnD,YAAY,EAAE,iBAAiB;QAC/B,UAAU;QACV,WAAW;QACX,MAAM;QACN,iBAAiB,EAAE,KAAK,CAAC,YAAY;QACrC,aAAa;QACb,IAAI;QACJ,QAAQ;KACT,CAAC,CAAC;IACH,IAAI,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAE5B,aAAa,CAAC,KAAK,CAAC,8BAA8B,EAAE;QAClD,aAAa,EAAE,KAAK;QACpB,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,SAAS;QAC7B,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,SAAS;QAC7B,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM;QACvB,eAAe,EAAE,MAAM,CAAC,SAAS,EAAE,iBAAiB,EAAE,MAAM;KAC7D,CAAC,CAAC;IAEH,MAAM,CAAC,aAAa,EAAE;QACpB,OAAO,EAAE,MAAM,CAAC,SAAS;YACvB,CAAC,CAAC,WAAW;YACb,CAAC,CAAC,MAAM,CAAC,SAAS;gBAChB,CAAC,CAAC,WAAW;gBACb,CAAC,CAAC,MAAM,CAAC,MAAM;oBACb,CAAC,CAAC,QAAQ;oBACV,CAAC,CAAC,SAAS;QACjB,eAAe,EAAE,MAAM,CAAC,SAAS,EAAE,iBAAiB,EAAE,MAAM,IAAI,CAAC;QACjE,gBAAgB,EAAE,MAAM,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACjE,IAAI,EAAE,CAAC,CAAC,IAAI;YACZ,aAAa,EAAE,CAAC,CAAC,aAAa;YAC9B,eAAe,EAAE,CAAC,CAAC,eAAe;YAClC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAG,CAAiB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACpE,CAAC,CAAC;QACH,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO;QACtC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI;KACjC,CAAC,CAAC;IAEH,qCAAqC;IACrC,EAAE;IACF,oEAAoE;IACpE,oEAAoE;IACpE,EAAE;IACF,sEAAsE;IACtE,gEAAgE;IAChE,6DAA6D;IAC7D,uEAAuE;IACvE,yEAAyE;IACzE,iEAAiE;IACjE,mEAAmE;IACnE,mEAAmE;IACnE,+DAA+D;IAC/D,qEAAqE;IACrE,2DAA2D;IAC3D,qDAAqD;IACrD,uEAAuE;IACvE,qEAAqE;IACrE,iEAAiE;IACjE,sEAAsE;IACtE,oEAAoE;IACpE,qEAAqE;IACrE,uEAAuE;IACvE,iBAAiB;IACjB,EAAE;IACF,mEAAmE;IACnE,qEAAqE;IACrE,QAAQ;IACR,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;IACvC,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,IAAI,CAAC,CAAC,OAAO;YAAE,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;IAC7C,CAAC;IACD,wDAAwD;IACxD,MAAM,eAAe,GAAG,IAAI,GAAG,EAAU,CAAC;IAC1C,gEAAgE;IAChE,MAAM,aAAa,GAAG,IAAI,GAAG,EAAU,CAAC;IACxC,mEAAmE;IACnE,iEAAiE;IACjE,yCAAyC;IACzC,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAU,CAAC;IAC3C,oEAAoE;IACpE,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAU,CAAC;IAC5C,oEAAoE;IACpE,iEAAiE;IACjE,sEAAsE;IACtE,gEAAgE;IAChE,qEAAqE;IACrE,kEAAkE;IAClE,MAAM,aAAa,GAAG,IAAI,GAAG,EAG1B,CAAC;IACJ,MAAM,yBAAyB,GAAG,CAAC,QAAiB,EAAQ,EAAE;QAC5D,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;YACzB,IAAI,CAAC,CAAC,aAAa,KAAK,SAAS;gBAAE,SAAS;YAC5C,IAAI,CAAC,CAAC,SAAS,KAAK,cAAc,EAAE,CAAC;gBACnC,MAAM,KAAK,GACT,WAAW,IAAI,CAAC;oBAChB,CAAC,CAAC,SAAS;oBACX,gBAAgB,IAAI,CAAC,CAAC,SAAS;oBAC/B,OAAO,CAAC,CAAC,SAAS,CAAC,cAAc,KAAK,QAAQ;oBAC5C,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,cAAc;oBAC5B,CAAC,CAAC,SAAS,CAAC;gBAChB,MAAM,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC;gBACjD,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,EAAE;oBACjC,KAAK;oBACL,WAAW,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS;oBAC7D,WAAW,EAAE,KAAK,EAAE,WAAW,IAAI,KAAK;iBACzC,CAAC,CAAC;YACL,CAAC;iBAAM,IAAI,CAAC,CAAC,SAAS,KAAK,eAAe,EAAE,CAAC;gBAC3C,MAAM,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC;gBACjD,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,EAAE;oBACjC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC;oBAChB,WAAW,EAAE,IAAI;iBAClB,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC,CAAC;IACF,yBAAyB,CAAC,MAAM,CAAC,CAAC;IAClC,MAAM,0BAA0B,GAAG,IAAI,GAAG,EAAU,CAAC;IACrD,MAAM,cAAc,GAAG,iBAAiB,EAAE,CAAC;IAC3C,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;IAClC,MAAM,iBAAiB,GAAG,WAAW,CAAC,SAAS;QAC7C,CAAC,CAAC,CAAC,WAAW,CAAC,SAAS;QACxB,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;IACf,MAAM,SAAS,GACZ,WAAW,CAAC,UAAiD,EAAE,CAC9D,qBAAqB,CACtB,IAAI,KAAK,CAAC;IACb,IAAI,mBAAmB,GAAG,CAAC,CAAC;IAC5B,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,uEAAuE;IACvE,qEAAqE;IACrE,0EAA0E;IAC1E,uEAAuE;IACvE,uEAAuE;IACvE,sEAAsE;IACtE,oCAAoC;IACpC,IAAI,oBAAoB,GAAG,KAAK,CAAC;IAEjC;;;;;;;OAOG;IACH,MAAM,iBAAiB,GAAG,KAAK,IAAsB,EAAE;QACrD,MAAM,MAAM,GAAY,EAAE,CAAC;QAC3B,IAAI,MAAM,GAAkB,OAAO,CAAC,SAAS,CAAC;QAC9C,IAAI,OAAO,GAAG,IAAI,CAAC;QACnB,OAAO,OAAO,EAAE,CAAC;YACf,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC;gBACvC,KAAK;gBACL,UAAU,EAAE;oBACV,SAAS,EAAE,KAAK;oBAChB,MAAM,EAAE,MAAM,IAAI,SAAS;oBAC3B,KAAK,EAAE,IAAI;iBACZ;aACF,CAAC,CAAC;YACH,KAAK,MAAM,CAAC,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC;gBAC9B,IAAI,CAAC,CAAC,OAAO,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC;oBAAE,SAAS;gBACvD,IAAI,CAAC,CAAC,OAAO;oBAAE,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBAC3C,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACjB,CAAC;YACD,IAAI,QAAQ,CAAC,MAAM;gBAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;YAC9C,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,CAAC,MAAM,IAAI,IAAI,CAAC;QAChE,CAAC;QACD,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACxB,yBAAyB,CAAC,MAAM,CAAC,CAAC;QAClC,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;IAEF;;;;;;;;OAQG;IACH,MAAM,gBAAgB,GAAG,GAAY,EAAE;QACrC,MAAM,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;QACxC,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;YACvB,IAAI,CAAC,CAAC,OAAO;gBAAE,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QAC7C,CAAC;QACD,yBAAyB,CAAC,MAAM,CAAC,CAAC;QAClC,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;IAEF,IAAI,CAAC;QACH,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,OAAO,MAAM,CAAC,SAAS,IAAI,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,CAAC;YAC7D,SAAS,EAAE,CAAC;YACZ,oEAAoE;YACpE,qEAAqE;YACrE,qEAAqE;YACrE,mEAAmE;YACnE,8DAA8D;YAC9D,SAAS;YACT,IAAI,cAAc,KAAK,SAAS,IAAI,YAAY,CAAC,IAAI,IAAI,cAAc,EAAE,CAAC;gBACxE,MAAM,IAAI,sBAAsB,CAAC,YAAY,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;YACtE,CAAC;YACD,MAAM,iBAAiB,GAAG,MAAM,CAAC,SAAS,CAAC,iBAAiB,CAAC;YAE7D,oEAAoE;YACpE,qEAAqE;YACrE,kEAAkE;YAClE,gEAAgE;YAChE,kEAAkE;YAClE,iEAAiE;YACjE,kEAAkE;YAClE,oEAAoE;YACpE,oCAAoC;YACpC,MAAM,UAAU,GAAG,iBAAiB,CAAC,MAAM,CACzC,CAAC,EAAE,EAAqB,EAAE,CACxB,EAAE,CAAC,IAAI,KAAK,MAAM;gBAClB,CAAC,EAAE,CAAC,eAAe;gBACnB,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC;gBACtC,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC,CACvC,CAAC;YACF,8CAA8C;YAC9C,kEAAkE;YAClE,gEAAgE;YAChE,oEAAoE;YACpE,+DAA+D;YAC/D,sBAAsB;YACtB,MAAM,YAAY,GAAG,UAAU,CAAC,MAAM,CACpC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,CACnC,CAAC;YACF,MAAM,gBAAgB,GACpB,cAAc,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;YACnE,MAAM,eAAe,GAAG,IAAI,GAAG,CAC7B,gBAAgB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CACnD,CAAC;YAEF,6DAA6D;YAC7D,MAAM,aAAa,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CACjD,EAAE,CAAC,IAAI,KAAK,MAAM;gBACjB,EAAkB,CAAC,cAAc;gBAClC,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC;gBACpC,CAAC,CAAE,EAAE,GAAG,EAAE,EAAE,cAAc,EAAE,KAAK,EAAuB;gBACxD,CAAC,CAAC,EAAE,CACP,CAAC;YACF,KAAK,MAAM,EAAE,IAAI,iBAAiB,EAAE,CAAC;gBACnC,IAAI,EAAE,CAAC,IAAI,KAAK,MAAM,IAAK,EAAkB,CAAC,cAAc,EAAE,CAAC;oBAC7D,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC;gBACzC,CAAC;YACH,CAAC;YACD,kEAAkE;YAClE,mEAAmE;YACnE,kEAAkE;YAClE,kEAAkE;YAClE,iEAAiE;YACjE,mEAAmE;YACnE,uDAAuD;YACvD,6DAA6D;YAC7D,+DAA+D;YAC/D,mEAAmE;YACnE,qEAAqE;YACrE,qEAAqE;YACrE,+DAA+D;YAC/D,MAAM,aAAa,GAAG,YAAY,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;YAClE,MAAM,UAAU,GAAG,MAAM,kBAAkB,CAAC;gBAC1C,KAAK;gBACL,KAAK;gBACL,WAAW;gBACX,aAAa;gBACb,SAAS;gBACT,gBAAgB;gBAChB,WAAW;gBACX,GAAG,CAAC,OAAO,CAAC,QAAQ,IAAI,OAAO,OAAO,CAAC,SAAS,KAAK,QAAQ;oBAC3D,CAAC,CAAC,EAAE,WAAW,EAAE,OAAO,CAAC,SAAS,EAAE;oBACpC,CAAC,CAAC,EAAE,CAAC;gBACP,iBAAiB,EAAE,aAAa;gBAChC,gBAAgB,EAAE,eAAe;gBACjC,aAAa,EAAE,IAAI,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC;gBACjE,2BAA2B,EAAE,IAAI;gBACjC,MAAM;aACP,CAAC,CAAC;YACH,IACE,UAAU,CAAC,qBAAqB;gBAChC,UAAU,CAAC,sBAAsB,EACjC,CAAC;gBACD,oBAAoB,GAAG,IAAI,CAAC;YAC9B,CAAC;YACD,8DAA8D;YAC9D,+DAA+D;YAC/D,oEAAoE;YACpE,6DAA6D;YAC7D,8DAA8D;YAC9D,6DAA6D;YAC7D,sCAAsC;YACtC,IAAI,UAAU,CAAC,2BAA2B,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;gBACpD,oBAAoB,GAAG,IAAI,CAAC;gBAC5B,KAAK,MAAM,GAAG,IAAI,UAAU,CAAC,2BAA2B,EAAE,CAAC;oBACzD,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAC3B,CAAC;YACH,CAAC;YAED,KAAK,MAAM,GAAG,IAAI,UAAU,CAAC,cAAc,EAAE,CAAC;gBAC5C,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACzB,CAAC;YACD,MAAM,OAAO,CAAC,GAAG,CACf,aAAa;iBACV,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;iBACpE,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;gBACZ,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;gBACtC,OAAO,gBAAgB,CAAC;oBACtB,KAAK;oBACL,KAAK;oBACL,WAAW;oBACX,IAAI;oBACJ,SAAS;oBACT,gBAAgB;oBAChB,OAAO,EAAE,UAAU;oBACnB,MAAM;iBACP,CAAC,CAAC;YACL,CAAC,CAAC,CACL,CAAC;YAEF,mEAAmE;YACnE,2DAA2D;YAC3D,MAAM,oBAAoB,GAAoB,EAAE,CAAC;YACjD,KAAK,MAAM,EAAE,IAAI,iBAAiB,EAAE,CAAC;gBACnC,IAAI,EAAE,CAAC,IAAI,KAAK,MAAM;oBAAE,SAAS;gBACjC,MAAM,IAAI,GAAG,EAAiB,CAAC;gBAC/B,IAAI,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC;oBAAE,SAAS;gBACxD,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC;oBAAE,SAAS;gBACjE,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;gBAC1C,oBAAoB,CAAC,IAAI,CACvB,CAAC,KAAK,IAAI,EAAE;oBACV,IAAI,CAAC;wBACH,MAAM,WAAW,CAAC;4BAChB,SAAS,EAAE,gBAAgB;4BAC3B,WAAW,EAAE,oBAAoB;4BACjC,aAAa,EAAE,IAAI,CAAC,aAAa;yBAClC,CAAC,CAAC;oBACL,CAAC;oBAAC,OAAO,GAAG,EAAE,CAAC;wBACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC;4BAAE,OAAO;wBACxC,MAAM,GAAG,CAAC;oBACZ,CAAC;gBACH,CAAC,CAAC,EAAE,CACL,CAAC;YACJ,CAAC;YACD,IAAI,oBAAoB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACpC,MAAM,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;YAC1C,CAAC;YAED,oEAAoE;YACpE,uEAAuE;YACvE,uEAAuE;YACvE,qEAAqE;YACrE,gEAAgE;YAChE,sEAAsE;YACtE,mEAAmE;YACnE,uEAAuE;YACvE,uEAAuE;YACvE,eAAe;YACf,CAAC;gBACC,MAAM,MAAM,GAAG,gBAAgB,EAAE,CAAC;gBAClC,MAAM,SAAS,GACb,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,iBAAiB,EAAE,CAAC;gBACzD,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACzB,8DAA8D;oBAC9D,6DAA6D;oBAC7D,6DAA6D;oBAC7D,oBAAoB,GAAG,KAAK,CAAC;oBAC7B,MAAM,GAAG,MAAM,OAAO,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;oBACrD,MAAM,CAAC,kBAAkB,EAAE;wBACzB,SAAS;wBACT,KAAK,EAAE,MAAM;wBACb,SAAS,EAAE,SAAS,CAAC,MAAM;wBAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,MAAM;wBACtD,OAAO,EAAE,MAAM,CAAC,SAAS;4BACvB,CAAC,CAAC,WAAW;4BACb,CAAC,CAAC,MAAM,CAAC,MAAM;gCACb,CAAC,CAAC,QAAQ;gCACV,CAAC,CAAC,WAAW;qBAClB,CAAC,CAAC;oBACH,SAAS;gBACX,CAAC;YACH,CAAC;YAED,sDAAsD;YACtD,MAAM,OAAO,GAAG,iBAAiB,CAAC,MAAM,CACtC,CAAC,EAAE,EAAqB,EAAE,CAAC,EAAE,CAAC,IAAI,KAAK,MAAM,CAC9C,CAAC;YACF,mEAAmE;YACnE,mEAAmE;YACnE,kEAAkE;YAClE,oEAAoE;YACpE,oEAAoE;YACpE,gEAAgE;YAChE,wDAAwD;YACxD,EAAE;YACF,oEAAoE;YACpE,gEAAgE;YAChE,6DAA6D;YAC7D,kEAAkE;YAClE,mEAAmE;YACnE,kEAAkE;YAClE,oBAAoB;YACpB,mEAAmE;YACnE,sDAAsD;YACtD,mEAAmE;YACnE,mEAAmE;YACnE,4DAA4D;YAC5D,+DAA+D;YAC/D,wBAAwB;YACxB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACzB,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;gBAC3B,IAAI,CAAC,IAAI,CAAC,eAAe;oBAAE,SAAS;gBACpC,IAAI,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC;oBAAE,SAAS;gBACtD,IAAI,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC;oBAAE,SAAS;gBACpD,MAAM,SAAS,GAAG,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;gBACxD,MAAM,eAAe,GACnB,SAAS,KAAK,SAAS;oBACvB,SAAS,CAAC,KAAK,KAAK,SAAS;oBAC7B,CAAC,SAAS,CAAC,WAAW,CAAC;gBACzB,IAAI,qBAAqB,GAAG,CAAC,CAAC;gBAC9B,IAAI,eAAe,IAAI,SAAS,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;oBAC3D,MAAM,YAAY,GAAG,8BAA8B,EAAE,CAAC;oBACtD,qBAAqB,GAAG,IAAI,CAAC,GAAG,CAC9B,YAAY,EACZ,IAAI,CAAC,GAAG,CACN,CAAC,EACD,IAAI,CAAC,IAAI,CACP,CAAC,SAAS,CAAC,WAAW,GAAG,YAAY,GAAG,IAAI,GAAG,KAAK,CAAC,GAAG,IAAI,CAC7D,CACF,CACF,CAAC;gBACJ,CAAC;gBACD,IACE,eAAe;oBACf,SAAS,CAAC,KAAK,KAAK,cAAc;oBAClC,qBAAqB,GAAG,CAAC,EACzB,CAAC;oBACD,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;oBACtC,MAAM,gBAAgB,CAAC;wBACrB,KAAK;wBACL,KAAK;wBACL,WAAW;wBACX,IAAI;wBACJ,YAAY,EAAE,qBAAqB;wBACnC,SAAS;wBACT,gBAAgB;wBAChB,OAAO,EAAE,YAAY,SAAS,CAAC,WAAW,EAAE;wBAC5C,MAAM;qBACP,CAAC,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACN,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;oBACtC,MAAM,gBAAgB,CAAC;wBACrB,KAAK;wBACL,KAAK;wBACL,WAAW;wBACX,IAAI;wBACJ,SAAS;wBACT,gBAAgB;wBAChB,OAAO,EAAE,UAAU;wBACnB,MAAM;qBACP,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;YAED,IAAI,gBAAgB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAClC,8DAA8D;gBAC9D,oDAAoD;gBACpD,MAAM;YACR,CAAC;YAED,+DAA+D;YAC/D,6DAA6D;YAC7D,mEAAmE;YACnE,qEAAqE;YACrE,+BAA+B;YAC/B,IAAI,WAAmE,CAAC;YACxE,KAAK,MAAM,EAAE,IAAI,iBAAiB,EAAE,CAAC;gBACnC,IAAI,EAAE,CAAC,IAAI,KAAK,MAAM;oBAAE,SAAS;gBACjC,MAAM,IAAI,GAAG,EAAiB,CAAC;gBAC/B,IAAI,0BAA0B,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC;oBAAE,SAAS;gBACjE,gEAAgE;gBAChE,+DAA+D;gBAC/D,gDAAgD;gBAChD,IAAI,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC;oBAAE,SAAS;gBACxD,MAAM,QAAQ,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBAChE,iEAAiE;gBACjE,oDAAoD;gBACpD,8DAA8D;gBAC9D,6DAA6D;gBAC7D,6DAA6D;gBAC7D,gEAAgE;gBAChE,4DAA4D;gBAC5D,2DAA2D;gBAC3D,gEAAgE;gBAChE,4DAA4D;gBAC5D,2DAA2D;gBAC3D,gEAAgE;gBAChE,iEAAiE;gBACjE,0DAA0D;gBAC1D,6DAA6D;gBAC7D,gEAAgE;gBAChE,4DAA4D;gBAC5D,4BAA4B;gBAC5B,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC;gBACxD,IAAI,CAAC,WAAW,IAAI,OAAO,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC;oBAClD,WAAW,GAAG,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,EAAE,CAAC;gBAC/D,CAAC;YACH,CAAC;YACD,IAAI,WAAW,EAAE,CAAC;gBAChB,0BAA0B,CAAC,GAAG,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;gBAC1D,MAAM,OAAO,GAAG,2BAA2B,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;gBACvE,MAAM,YAAY,CAChB,KAAK,EACL,oBAAoB,CAAC,WAAW,CAAC,YAAY,EAAE,SAAS,CAAC,EACzD;oBACE,KAAK;oBACL,YAAY,EAAE,MAAM,gBAAgB,EAAE;oBACtC,WAAW,EAAE,IAAI,IAAI,EAAE;oBACvB,gBAAgB,EAAE;wBAChB,aAAa,EAAE,WAAW,CAAC,aAAa;wBACxC,OAAO;qBACR;iBACF,EACD,2BAA2B,CACzB,WAAW,CAAC,OAAO,EACnB,WAAW,CAAC,aAAa,EACzB,IAAI,CAAC,GAAG,EAAE,EACV,OAAO,CACR,CACF,CAAC;gBACF,MAAM,CAAC,6BAA6B,EAAE;oBACpC,aAAa,EAAE,WAAW,CAAC,aAAa;oBACxC,YAAY,EAAE,WAAW,CAAC,OAAO;oBACjC,OAAO;iBACR,CAAC,CAAC;YACL,CAAC;YAED,6DAA6D;YAC7D,gEAAgE;YAChE,+DAA+D;YAC/D,mEAAmE;YACnE,+DAA+D;YAC/D,+DAA+D;YAC/D,4DAA4D;YAC5D,kEAAkE;YAClE,wDAAwD;YACxD,qEAAqE;YACrE,qEAAqE;YACrE,uEAAuE;YACvE,kEAAkE;YAClE,sEAAsE;YACtE,EAAE;YACF,uEAAuE;YACvE,uEAAuE;YACvE,uEAAuE;YACvE,mEAAmE;YACnE,0BAA0B;YAC1B,+DAA+D;YAC/D,mEAAmE;YACnE,iEAAiE;YACjE,qEAAqE;YACrE,8CAA8C;YAC9C,gEAAgE;YAChE,MAAM,cAAc,GAAG,iBAAiB,CAAC,IAAI,CAC3C,CAAC,EAAE,EAAE,EAAE,CACL,EAAE,CAAC,IAAI,KAAK,MAAM;gBAClB,CAAC,iBAAiB,CAAC,GAAG,CAAE,EAAkB,CAAC,aAAa,CAAC,CAC5D,CAAC;YACF,MAAM,sBAAsB,GAC1B,OAAO,CAAC,MAAM,KAAK,CAAC;gBACpB,UAAU,CAAC,MAAM,KAAK,CAAC;gBACvB,gBAAgB,CAAC,MAAM,KAAK,CAAC;gBAC7B,CAAC,cAAc;gBACf,OAAO,CAAC,QAAQ;gBAChB,OAAO,OAAO,CAAC,SAAS,KAAK,QAAQ;gBACnC,CAAC,CAAC,OAAO,CAAC,SAAS;gBACnB,CAAC,CAAC,SAAS,CAAC;YAChB,MAAM,CAAC,KAAK,EAAE,CAAC;YACf,IAAI,QAA+B,CAAC;YACpC,IAAI,CAAC;gBACH,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAC1B,gBAAgB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAC5B,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,GAAG,EAAE,CAClD,CAAC,KAAK,IAAI,EAAE,CACV,WAAW,CAAC;oBACV,KAAK;oBACL,aAAa,EAAE,KAAK;oBACpB,oBAAoB,EAAE,WAAW,CAAC,YAAY;oBAC9C,YAAY,EAAE,WAAW,CAAC,YAAY;oBACtC,iBAAiB;oBACjB,SAAS;oBACT,SAAS;oBACT,MAAM,EAAE,IAAI,CAAC,aAAa;oBAC1B,QAAQ,EAAE,IAAI,CAAC,MAAM;oBACrB,aAAa;oBACb,cAAc,EAAE,WAAW,CAAC,WAAW;oBACvC,wDAAwD;oBACxD,uDAAuD;oBACvD,4CAA4C;oBAC5C,gDAAgD;oBAChD,sDAAsD;oBACtD,wDAAwD;oBACxD,aAAa,EAAE,MAAM,qBAAqB,CACxC,IAAI,CAAC,KAAK,EACV,aAAa,CACd;oBACD,mDAAmD;oBACnD,uDAAuD;oBACvD,8CAA8C;oBAC9C,cAAc;oBACd,kDAAkD;oBAClD,WAAW;oBACX,oBAAoB,EAAE,CAAC;oBACvB,GAAG,CAAC,sBAAsB,KAAK,SAAS;wBACtC,CAAC,CAAC,EAAE,sBAAsB,EAAE;wBAC5B,CAAC,CAAC,EAAE,CAAC;iBACR,CAAC,CAAC,EAAE,CACR,CACF,CACF,CAAC;YACJ,CAAC;oBAAS,CAAC;gBACT,MAAM,CAAC,MAAM,EAAE,CAAC;YAClB,CAAC;YACD,mBAAmB,IAAI,gBAAgB,CAAC,MAAM,CAAC;YAE/C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACjD,MAAM,IAAI,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;gBACjC,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC5B,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;gBACxC,IACE,OAAO,CAAC,IAAI,KAAK,WAAW;oBAC5B,OAAO,CAAC,WAAW,KAAK,SAAS;oBACjC,sBAAsB,KAAK,SAAS,EACpC,CAAC;oBACD,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAClC,sBAAsB,EACtB,OAAO,CAAC,WAAW,CACpB,CAAC;oBACF,MAAM,CAAC,uBAAuB,EAAE;wBAC9B,SAAS;wBACT,aAAa,EAAE,IAAI,CAAC,aAAa;wBACjC,MAAM,EAAE,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM;wBACzC,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,OAAO;wBACpC,cAAc,EAAE,QAAQ;qBACzB,CAAC,CAAC;gBACL,CAAC;gBACD,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,IAAI,OAAO,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;oBAC7D,yDAAyD;oBACzD,kDAAkD;oBAClD,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;oBACtC,MAAM,gBAAgB,CAAC;wBACrB,KAAK;wBACL,KAAK;wBACL,WAAW;wBACX,IAAI;wBACJ,YAAY,EAAE,OAAO,CAAC,cAAc;wBACpC,SAAS;wBACT,gBAAgB;wBAChB,6DAA6D;wBAC7D,uDAAuD;wBACvD,wDAAwD;wBACxD,6DAA6D;wBAC7D,OAAO,EAAE,SAAS;wBAClB,MAAM;qBACP,CAAC,CAAC;gBACL,CAAC;qBAAM,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;oBACnC,OAAO,GAAG,IAAI,CAAC;gBACjB,CAAC;gBACD,mEAAmE;gBACnE,gEAAgE;gBAChE,iEAAiE;gBACjE,oCAAoC;YACtC,CAAC;YACD,MAAM,CAAC,uBAAuB,EAAE;gBAC9B,SAAS;gBACT,KAAK,EAAE,gBAAgB,CAAC,MAAM;gBAC9B,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;aACtC,CAAC,CAAC;YAEH,iEAAiE;YACjE,+DAA+D;YAC/D,oEAAoE;YACpE,mEAAmE;YACnE,oEAAoE;YACpE,gEAAgE;YAChE,mEAAmE;YACnE,oEAAoE;YACpE,+DAA+D;YAC/D,+DAA+D;YAC/D,mEAAmE;YACnE,iCAAiC;YACjC,MAAM,MAAM,GAAG,gBAAgB,EAAE,CAAC;YAClC,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,iBAAiB,EAAE,CAAC;YACzE,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC3B,oBAAoB,GAAG,IAAI,CAAC;gBAC5B,MAAM;YACR,CAAC;YACD,MAAM,GAAG,MAAM,OAAO,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;YAErD,MAAM,CAAC,kBAAkB,EAAE;gBACzB,SAAS;gBACT,KAAK,EAAE,OAAO;gBACd,SAAS,EAAE,SAAS,CAAC,MAAM;gBAC3B,OAAO,EAAE,MAAM,CAAC,SAAS;oBACvB,CAAC,CAAC,WAAW;oBACb,CAAC,CAAC,MAAM,CAAC,MAAM;wBACb,CAAC,CAAC,QAAQ;wBACV,CAAC,CAAC,WAAW;gBACjB,eAAe,EAAE,MAAM,CAAC,WAAW,EAAE;aACtC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;YAAS,CAAC;QACT,OAAO,CAAC,OAAO,EAAE,CAAC;IACpB,CAAC;IAED,UAAU,EAAE,aAAa,CAAC;QACxB,GAAG,SAAS,CAAC,kBAAkB,CAAC,mBAAmB,CAAC;KACrD,CAAC,CAAC;IAEH,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;QACrB,qBAAqB;QACrB,aAAa,CAAC,IAAI,CAAC,qCAAqC,EAAE;YACxD,aAAa,EAAE,KAAK;SACrB,CAAC,CAAC;QACH,UAAU,EAAE,aAAa,CAAC;YACxB,GAAG,SAAS,CAAC,cAAc,CAAC,WAAW,CAAC;SACzC,CAAC,CAAC;QAEH,qEAAqE;QACrE,mEAAmE;QACnE,sEAAsE;QACtE,kEAAkE;QAClE,mBAAmB;QACnB,IAAI,MAAM,CAAC,SAAS,CAAC,eAAe,EAAE,MAAM,EAAE,CAAC;YAC7C,IAAI,CAAC;gBACH,MAAM,kBAAkB,CAAC;oBACvB,KAAK;oBACL,KAAK;oBACL,WAAW;oBACX,aAAa;oBACb,SAAS;oBACT,gBAAgB;oBAChB,iEAAiE;oBACjE,iDAAiD;oBACjD,WAAW,EAAE,mBAAmB;oBAChC,iBAAiB,EAAE,MAAM,CAAC,SAAS,CAAC,eAAe;oBACnD,MAAM;iBACP,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,aAAa,CAAC,IAAI,CAAC,wCAAwC,EAAE;oBAC3D,aAAa,EAAE,KAAK;oBACpB,OAAO,EAAG,GAAa,EAAE,OAAO;iBACjC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,8BAA8B;QAC9B,yEAAyE;QACzE,qEAAqE;QACrE,2EAA2E;QAC3E,sEAAsE;QACtE,oDAAoD;QACpD,IAAI,CAAC;YACH,MAAM,mBAAmB,CAAC;gBACxB,SAAS,EAAE,eAAe;gBAC1B,WAAW,EAAE,oBAAoB;gBACjC,SAAS,EAAE;oBACT,MAAM,EAAE,MAAM,qBAAqB,CACjC,MAAM,CAAC,SAAS,CAAC,MAAM,EACvB,aAAa,CACd;iBACF;aACF,CAAC,CAAC;YACH,MAAM,CAAC,gBAAgB,EAAE,EAAE,MAAM,EAAE,uBAAuB,EAAE,CAAC,CAAC;QAChE,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,eAAe,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC3D,aAAa,CAAC,IAAI,CAChB,mDAAmD,EACnD,EAAE,aAAa,EAAE,KAAK,EAAE,CACzB,CAAC;gBACF,MAAM,CAAC,gBAAgB,EAAE,EAAE,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAAC;gBACzD,OAAO;YACT,CAAC;YACD,MAAM,CAAC,sBAAsB,EAAE;gBAC7B,SAAS,EAAG,GAAa,EAAE,IAAI;gBAC/B,YAAY,EAAG,GAAa,EAAE,OAAO;aACtC,CAAC,CAAC;YACH,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;SAAM,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;QAC5B,mEAAmE;QACnE,oEAAoE;QACpE,kEAAkE;QAClE,MAAM,EAAE,iBAAiB,EAAE,GAAG,MAAM,CAAC,SAAS,CAAC;QAE/C,aAAa,CAAC,IAAI,CAAC,qCAAqC,EAAE;YACxD,aAAa,EAAE,KAAK;YACpB,mBAAmB;YACnB,YAAY,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,MAAM;YACvE,YAAY,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,MAAM;YACvE,UAAU,EAAE,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBACxC,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,aAAa,EAAE,CAAC,CAAC,aAAa;gBAC9B,eAAe,EAAE,CAAC,CAAC,eAAe;gBAClC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAG,CAAiB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACpE,CAAC,CAAC;SACJ,CAAC,CAAC;QAEH,UAAU,EAAE,aAAa,CAAC;YACxB,GAAG,SAAS,CAAC,cAAc,CAAC,WAAW,CAAC;YACxC,GAAG,SAAS,CAAC,sBAAsB,CAAC,iBAAiB,CAAC,MAAM,CAAC;SAC9D,CAAC,CAAC;QAEH,IAAI,OAAO,EAAE,CAAC;YACZ,qEAAqE;YACrE,MAAM,CAAC,gBAAgB,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;YACjD,OAAO;QACT,CAAC;QAED,iEAAiE;QACjE,iEAAiE;QACjE,4DAA4D;QAC5D,oEAAoE;QACpE,8DAA8D;QAC9D,iEAAiE;QACjE,kEAAkE;QAClE,oEAAoE;QACpE,mEAAmE;QACnE,iEAAiE;QACjE,yDAAyD;QACzD,MAAM,kBAAkB,GAAG,KAAK,IAAmB,EAAE;YACnD,MAAM,YAAY,CAChB,KAAK,EACL,oBAAoB,CAAC,WAAW,CAAC,YAAY,EAAE,SAAS,CAAC,EACzD;gBACE,KAAK;gBACL,YAAY,EAAE,MAAM,gBAAgB,EAAE;gBACtC,WAAW,EAAE,IAAI,IAAI,EAAE;aACxB,CACF,CAAC;QACJ,CAAC,CAAC;QAEF,IAAI,MAAM,CAAC,WAAW,EAAE,EAAE,CAAC;YACzB,4DAA4D;YAC5D,+CAA+C;YAC/C,MAAM,CAAC,gBAAgB,EAAE,EAAE,MAAM,EAAE,0BAA0B,EAAE,CAAC,CAAC;YACjE,MAAM,kBAAkB,EAAE,CAAC;YAC3B,OAAO;QACT,CAAC;QAED,+DAA+D;QAC/D,gEAAgE;QAChE,qEAAqE;QACrE,4DAA4D;QAC5D,IAAI,WAAmE,CAAC;QACxE,IAAI,cAAc,GAAG,KAAK,CAAC;QAC3B,KAAK,MAAM,EAAE,IAAI,iBAAiB,EAAE,CAAC;YACnC,IAAI,EAAE,CAAC,IAAI,KAAK,MAAM;gBAAE,SAAS;YACjC,MAAM,IAAI,GAAG,EAAiB,CAAC;YAC/B,MAAM,QAAQ,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAChE,IAAI,QAAQ,IAAI,CAAC,EAAE,CAAC;gBAClB,cAAc,GAAG,IAAI,CAAC;YACxB,CAAC;iBAAM,IAAI,CAAC,0BAA0B,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;gBAC/D,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC;gBAC/D,IAAI,CAAC,WAAW,IAAI,cAAc,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC;oBACzD,WAAW,GAAG;wBACZ,OAAO,EAAE,cAAc;wBACvB,aAAa,EAAE,IAAI,CAAC,aAAa;qBAClC,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,cAAc,EAAE,CAAC;YACnB,MAAM,CAAC,gBAAgB,EAAE,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC,CAAC;YAC7D,MAAM,kBAAkB,EAAE,CAAC;YAC3B,OAAO;QACT,CAAC;QAED,IAAI,oBAAoB,EAAE,CAAC;YACzB,6DAA6D;YAC7D,6DAA6D;YAC7D,kEAAkE;YAClE,+DAA+D;YAC/D,4DAA4D;YAC5D,8DAA8D;YAC9D,gEAAgE;YAChE,mEAAmE;YACnE,iDAAiD;YACjD,MAAM,CAAC,gBAAgB,EAAE,EAAE,MAAM,EAAE,2BAA2B,EAAE,CAAC,CAAC;YAClE,MAAM,kBAAkB,EAAE,CAAC;YAC3B,OAAO;QACT,CAAC;QAED,IAAI,WAAW,EAAE,CAAC;YAChB,iEAAiE;YACjE,2DAA2D;YAC3D,8DAA8D;YAC9D,yDAAyD;YACzD,gCAAgC;YAChC,MAAM,CAAC,gBAAgB,EAAE;gBACvB,MAAM,EAAE,uBAAuB;gBAC/B,cAAc,EAAE,WAAW,CAAC,OAAO;gBACnC,iBAAiB,EAAE,WAAW,CAAC,aAAa;aAC7C,CAAC,CAAC;YACH,0BAA0B,CAAC,GAAG,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;YAC1D,MAAM,OAAO,GAAG,2BAA2B,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;YACvE,MAAM,YAAY,CAChB,KAAK,EACL,oBAAoB,CAAC,WAAW,CAAC,YAAY,EAAE,SAAS,CAAC,EACzD;gBACE,KAAK;gBACL,YAAY,EAAE,MAAM,gBAAgB,EAAE;gBACtC,WAAW,EAAE,IAAI,IAAI,EAAE;gBACvB,gBAAgB,EAAE;oBAChB,aAAa,EAAE,WAAW,CAAC,aAAa;oBACxC,OAAO;iBACR;aACF,EACD,2BAA2B,CACzB,WAAW,CAAC,OAAO,EACnB,WAAW,CAAC,aAAa,EACzB,IAAI,CAAC,GAAG,EAAE,EACV,OAAO,CACR,CACF,CAAC;YACF,OAAO;QACT,CAAC;QAED,MAAM,CAAC,gBAAgB,EAAE;YACvB,MAAM,EAAE,mBAAmB;YAC3B,eAAe,EAAE,iBAAiB,CAAC,MAAM;SAC1C,CAAC,CAAC;IACL,CAAC;SAAM,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;QACzB,kEAAkE;QAClE,mEAAmE;QACnE,qEAAqE;QACrE,8DAA8D;QAC9D,oEAAoE;QACpE,mEAAmE;QACnE,IAAI,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;QACrC,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,UAAU,GAAG,iBAAiB,CAAC,YAAY,CAAC,CAAC;YACnD,MAAM,QAAQ,GAAG,UAAU,EAAE,eAAe,IAAI,YAAY,CAAC;YAC7D,UAAU,GAAG,eAAe,CAAC,UAAU,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC;YACjE,UAAU,GAAG,eAAe,CAC1B,UAAU,EACV,wBAAwB,EACxB,YAAY,CACb,CAAC;QACJ,CAAC;QAED,qEAAqE;QACrE,qEAAqE;QACrE,sDAAsD;QACtD,EAAE;QACF,gEAAgE;QAChE,kEAAkE;QAClE,gEAAgE;QAChE,oEAAoE;QACpE,MAAM,aAAa,GACjB,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,4BAA4B;YACjD,CAAC,CAAC,IAAI,0BAA0B,CAAC,YAAY,CAAC;YAC9C,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,OAAO;gBAC9B,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;gBAClC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;oBAC9C,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI;iBACzB,CAAC,CAAC;QACX,MAAM,SAAS,GAAG,gBAAgB,CAAC,aAAa,CAAC,CAAC;QAElD,aAAa,CAAC,KAAK,CAAC,kCAAkC,EAAE;YACtD,aAAa,EAAE,KAAK;YACpB,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI;YAC7B,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO;YACnC,UAAU;YACV,SAAS;SACV,CAAC,CAAC;QACH,UAAU,EAAE,aAAa,CAAC;YACxB,GAAG,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC;SACtC,CAAC,CAAC;QAEH,iEAAiE;QACjE,gDAAgD;QAChD,IAAI,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,EAAE,CAAC;YAC1C,IAAI,CAAC;gBACH,MAAM,kBAAkB,CAAC;oBACvB,KAAK;oBACL,KAAK;oBACL,WAAW;oBACX,aAAa;oBACb,SAAS;oBACT,gBAAgB;oBAChB,WAAW,EAAE,mBAAmB;oBAChC,iBAAiB,EAAE,MAAM,CAAC,MAAM,CAAC,eAAe;oBAChD,MAAM;iBACP,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,aAAa,CAAC,IAAI,CAAC,wCAAwC,EAAE;oBAC3D,aAAa,EAAE,KAAK;oBACpB,OAAO,EAAG,GAAa,EAAE,OAAO;iBACjC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,2DAA2D;QAC3D,qEAAqE;QACrE,oEAAoE;QACpE,2BAA2B;QAC3B,iEAAiE;QACjE,gEAAgE;QAChE,iEAAiE;QACjE,+DAA+D;QAC/D,iEAAiE;QACjE,+CAA+C;QAC/C,6DAA6D;QAC7D,kEAAkE;QAClE,uDAAuD;QACvD,gEAAgE;QAChE,uDAAuD;QACvD,IAAI,eAA2B,CAAC;QAChC,IAAI,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAC7B,4DAA4D;YAC5D,gEAAgE;YAChE,4DAA4D;YAC5D,6DAA6D;YAC7D,8DAA8D;YAC9D,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,MAAM,eAAe,CACpC,MAAM,CAAC,MAAM,CAAC,UAAU,EACxB,KAAK,EACL,SAAS,CAAC,2BAA2B;iBACtC,CAAC;gBACF,IACE,QAAQ;oBACR,OAAO,QAAQ,KAAK,QAAQ;oBAC5B,OAAO,IAAK,QAAmB;oBAC/B,OAAQ,QAAgC,CAAC,KAAK,KAAK,QAAQ,EAC3D,CAAC;oBACD,MAAM,UAAU,GAAG,iBAAiB,CAAC,YAAY,CAAC,CAAC;oBACnD,MAAM,QAAQ,GAAG,UAAU,EAAE,eAAe,IAAI,YAAY,CAAC;oBAC7D,6DAA6D;oBAC5D,QAA+B,CAAC,KAAK,GAAG,eAAe,CACtD,eAAe,CACZ,QAA8B,CAAC,KAAK,EACrC,QAAQ,EACR,YAAY,CACb,EACD,wBAAwB,EACxB,YAAY,CACb,CAAC;gBACJ,CAAC;gBACD,oDAAoD;gBACpD,MAAM,IAAI,GAAG,IAAI,OAAO,EAAU,CAAC;gBACnC,IAAI,IAAI,GAAI,QAAgC,EAAE,KAAK,CAAC;gBACpD,OAAO,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAc,CAAC,EAAE,CAAC;oBACrE,IAAI,CAAC,GAAG,CAAC,IAAc,CAAC,CAAC;oBACzB,MAAM,SAAS,GAAI,IAA4B,CAAC,KAAK,CAAC;oBACtD,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;wBAClC,MAAM,UAAU,GAAG,iBAAiB,CAAC,YAAY,CAAC,CAAC;wBACnD,MAAM,QAAQ,GAAG,UAAU,EAAE,eAAe,IAAI,YAAY,CAAC;wBAC7D,6DAA6D;wBAC5D,IAA2B,CAAC,KAAK,GAAG,eAAe,CAClD,eAAe,CAAC,SAAS,EAAE,QAAQ,EAAE,YAAY,CAAC,EAClD,wBAAwB,EACxB,YAAY,CACb,CAAC;oBACJ,CAAC;oBACD,IAAI,GAAI,IAA4B,CAAC,KAAK,CAAC;gBAC7C,CAAC;gBACD,eAAe,GAAG,MAAM,iBAAiB,CACvC,QAAQ,EACR,KAAK,EACL,aAAa,CACd,CAAC;YACJ,CAAC;YAAC,OAAO,YAAY,EAAE,CAAC;gBACtB,2DAA2D;gBAC3D,0DAA0D;gBAC1D,0DAA0D;gBAC1D,0CAA0C;gBAC1C,aAAa,CAAC,IAAI,CAChB,iFAAiF,EACjF;oBACE,aAAa,EAAE,KAAK;oBACpB,OAAO,EAAG,YAAsB,EAAE,OAAO;iBAC1C,CACF,CAAC;gBACF,eAAe,GAAG,CAAC,MAAM,YAAY,CACnC,MAAM,CAAC,MAAM,CAAC,UAAU,EACxB,aAAa,CACd,CAAe,CAAC;YACnB,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,UAAU,EAAE,CAAC;gBACf,aAAa,CAAC,KAAK,GAAG,UAAU,CAAC;YACnC,CAAC;YACD,IAAI,CAAC;gBACH,eAAe,GAAG,MAAM,iBAAiB,CACvC,aAAa,EACb,KAAK,EACL,aAAa,CACd,CAAC;YACJ,CAAC;YAAC,OAAO,MAAM,EAAE,CAAC;gBAChB,6DAA6D;gBAC7D,6DAA6D;gBAC7D,aAAa,CAAC,IAAI,CAChB,4EAA4E,EAC5E,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,EAAG,MAAgB,EAAE,OAAO,EAAE,CAC9D,CAAC;gBACF,eAAe,GAAG,MAAM,iBAAiB,CACvC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;oBAC9C,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI;iBACzB,CAAC,EACF,KAAK,EACL,aAAa,CACd,CAAC;YACJ,CAAC;QACH,CAAC;QACD,IAAI,CAAC;YACH,MAAM,mBAAmB,CAAC;gBACxB,SAAS,EAAE,YAAY;gBACvB,WAAW,EAAE,oBAAoB;gBACjC,SAAS,EAAE;oBACT,KAAK,EAAE,eAAe;oBACtB,SAAS;iBACV;aACF,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,eAAe,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC3D,aAAa,CAAC,IAAI,CAAC,gDAAgD,EAAE;oBACnE,aAAa,EAAE,KAAK;iBACrB,CAAC,CAAC;gBACH,MAAM,CAAC,aAAa,EAAE,EAAE,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAAC;gBACtD,OAAO;YACT,CAAC;YACD,MAAM,CAAC,mBAAmB,EAAE;gBAC1B,SAAS,EAAG,GAAa,EAAE,IAAI;gBAC/B,YAAY,EAAG,GAAa,EAAE,OAAO;aACtC,CAAC,CAAC;YACH,MAAM,GAAG,CAAC;QACZ,CAAC;QACD,MAAM,CAAC,aAAa,EAAE,EAAE,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAC1D,CAAC;AACH,CAAC","sourcesContent":["/**\n * QuickJS WebAssembly (WASM) VM integration with the Workflow DevKit.\n *\n * This module provides the entry point for running workflows in the\n * QuickJS VM engine instead of the `node:vm` engine. Both engines\n * implement the same event-replay execution model, where 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 CreateEventParams,\n  type CreateEventRequest,\n  type Event,\n  type EventResult,\n  ROOT_RUN_ID_ATTRIBUTE,\n  type RunInput,\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT,\n  SPEC_VERSION_SUPPORTS_COMPRESSION,\n  type WorkflowRun,\n} from '@workflow/world';\nimport { classifyRunError, isRetryableWorldError } 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  dehydrateStepArguments,\n  dehydrateStepError,\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  isResilientStepDispatchEnabled,\n  MAX_RESILIENT_STEP_INPUT_BYTES,\n} from './constants.js';\nimport { getPortLazy } from './get-port-lazy.js';\nimport {\n  getWorkflowQueueName,\n  queueMessage,\n  runDispatchContext,\n  stepDispatchIdempotencyKey,\n} from './helpers.js';\nimport { QuickJSLogView } from './quickjs-log-view.js';\nimport {\n  BASELINE_BUNDLE_FILENAME,\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 { unserializableStepInputPlaceholder } from './unserializable-step.js';\nimport { getWaitContinuationDispatch } from './wait-continuation.js';\nimport { getWorld } from './world.js';\n\n/** An `events.create` bound to the run; see `dispatchPendingOps.createEvent`. */\ntype EventCreator = (\n  data: CreateEventRequest,\n  params?: CreateEventParams\n) => Promise<EventResult>;\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 uses the step-identity-scoped dispatch key\n   * (stepDispatchIdempotencyKey) 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  /**\n   * Resilient step dispatch: the serialized (possibly encrypted) step input\n   * to carry on the message as `stepInput`, so the consumer can idempotently\n   * re-ensure the `step_created` event if the producer's parallel direct\n   * write failed transiently. Only set on `dispatch` publishes that\n   * dispatchPendingOps parallelizes with the step_created write.\n   */\n  stepInput?: Uint8Array;\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    stepInput,\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      ...(stepInput !== undefined ? { stepInput: { input: stepInput } } : {}),\n      // Immutable run identity so the consumer can start the step without a\n      // blocking runs.get — see RunDispatchContextSchema.\n      runContext: runDispatchContext(workflowRun),\n    },\n    {\n      // The 'dispatch' key is step-identity-scoped (correlationId + hashed\n      // step name), shared with the node engine's dispatch of the same step\n      // so the two stay mutually exclusive, without a revoked resilient\n      // message absorbing a reassigned correlation id's legitimate dispatch.\n      // See stepDispatchIdempotencyKey.\n      idempotencyKey:\n        purpose === 'dispatch'\n          ? stepDispatchIdempotencyKey(step.correlationId, step.stepId)\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    ...(stepInput !== undefined ? { resilient: true } : {}),\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 (usually) not 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 *\n * The one exception is resilient step dispatch: for step cids named in\n * `queueStepCids` (the caller's overflow steps) that pass the eligibility\n * gates, the step_created write is parallelized with the step's queue\n * publish: the message carries the serialized input (`stepInput`) so the\n * consumer can idempotently re-ensure the event if the direct write failed\n * transiently. Steps queued this way are reported in `queuedStepCids`; the\n * caller queues the rest itself.\n */\nasync function dispatchPendingOps(params: {\n  world: Awaited<ReturnType<typeof getWorld>>;\n  runId: string;\n  /**\n   * The seam every event write in this pass goes through. The inline loop\n   * passes a create that names the log position this invocation holds\n   * (`eventCount`) and queues what the World hands back for the live VM; see\n   * {@link QuickJSLogView}. The terminal drain passes a plain create, since\n   * the run is ending and nothing reads its log afterwards.\n   */\n  createEvent: EventCreator;\n  /**\n   * The cursor this invocation's log was read to, when the caller wants a lone\n   * `hook_created` to ask for the inline delta against it (`sinceCursor`).\n   * The hook's awaiters are settled by the event that write commits and by\n   * nothing else (a `hook_created`, or the `hook_conflict` a claimed token\n   * commits instead), so the delta hands the VM that event, plus anything\n   * another writer landed meanwhile, without a listing. Same gate as the node\n   * engine's `hookDeltaCursor`: asked for only when exactly one hook needs\n   * creating, since two creates diffing against one cursor would produce two\n   * deltas of which only the first could be taken. Omitted by the terminal\n   * drain.\n   */\n  deltaCursor?: 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  /**\n   * Step cids the caller intends to hand to the queue this turn (overflow\n   * steps beyond the inline cap). Eligible ones are published here, in\n   * parallel with their step_created write (resilient step dispatch), and\n   * reported back in `queuedStepCids`.\n   */\n  queueStepCids?: 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  /**\n   * When true (the inline loop), a step carrying `serializationError` is\n   * finalized as step_created (placeholder input) + step_failed so the\n   * live-VM feed rejects the step's promise and workflow code can catch\n   * it, mirroring the node:vm engine's finalizeUnserializableStep. When\n   * false (the terminal drain), such steps are skipped entirely: the run\n   * is already completing/failing, no replay follows the drain to observe\n   * the failure, and a completed run carrying a failed step would read as\n   * a bug from the dashboard, matching the node:vm drain's behavior.\n   */\n  finalizeUnserializableSteps?: boolean;\n  wfdiag: (checkpoint: string, fields: Record<string, unknown>) => void;\n}): Promise<{\n  createdAttributeEvent: boolean;\n  createdGetConflictHook: boolean;\n  /** Step cids already published via resilient dispatch. See above. */\n  queuedStepCids: Set<string>;\n  /**\n   * Step cids finalized as failed because their input refused to\n   * serialize (see `finalizeUnserializableSteps`). No execution message\n   * exists for these; the caller must ensure the run observes the\n   * terminal event (the inline loop's feed, or the requeue signal).\n   */\n  failedSerializationStepCids: Set<string>;\n}> {\n  const {\n    world,\n    runId,\n    workflowRun,\n    encryptionKey,\n    pendingOperations,\n    namespace,\n    nextTraceCarrier,\n    createEvent,\n  } = params;\n  const skipStepCreation = params.skipStepCreation;\n  const queueStepCids = params.queueStepCids;\n  const wfdiag = params.wfdiag;\n  // Step cids published via resilient dispatch below (create + queue in\n  // parallel, message carrying `stepInput`). Reported to the caller so it\n  // skips them in its own queueing pass.\n  const queuedStepCids = new Set<string>();\n  // Step cids finalized as step_created + step_failed because their input\n  // refused to serialize. See the `finalizeUnserializableSteps` param.\n  const failedSerializationStepCids = new Set<string>();\n  // Resilient step dispatch eligibility, shared by every step op below (the\n  // per-step input-size check is applied inside the op): feature enabled and\n  // a binary-safe (CBOR) queue transport for the run.\n  //\n  // Unlike the node:vm suspension handler's gate (see\n  // SuspensionHandlerParams.stepDispatch), there is NO precondition-guard\n  // gate here: this engine's step_created writes are unguarded (no snapshot\n  // is attached), so a guard-enforcing World can never 412-reject them:\n  // the consumer's re-ensure therefore cannot materialize a step the guard\n  // rejected. If this engine ever adopts guarded suspension writes, the\n  // capability gate from the node:vm handler must be added here too.\n  const resilientDispatchEligible =\n    queueStepCids !== undefined &&\n    queueStepCids.size > 0 &&\n    isResilientStepDispatchEnabled() &&\n    (workflowRun.specVersion ?? 0) >=\n      SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT;\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  const hooksNeedingCreation = pendingOperations.filter(\n    (op) => op.type === 'hook' && !op.hasCreatedEvent\n  ).length;\n  const hookDeltaCursor =\n    hooksNeedingCreation === 1 ? params.deltaCursor : undefined;\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, which 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 createEvent(\n          {\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          hookDeltaCursor !== undefined\n            ? { sinceCursor: hookDeltaCursor }\n            : undefined\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, so 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 createEvent({\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 createEvent({\n        eventType: 'hook_disposed',\n        specVersion: SPEC_VERSION_CURRENT,\n        correlationId: op.correlationId,\n        // The hook's token, which the node:vm engine has always sent. A world\n        // that keys a hook's token claim separately from the hook itself needs\n        // it to release both, and the only alternative is for it to look the\n        // token up first. Omitted rather than sent as undefined when the op\n        // carries none, so a world that reads it cannot tell the difference\n        // between this engine and a client too old to send one.\n        ...(op.token === undefined ? {} : { eventData: { token: op.token } }),\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          // The step's input refused to serialize while dumping the VM's\n          // pending ops (see PendingStep.serializationError). Finalize it\n          // as step_created (placeholder input, since the world requires the\n          // step entity before a terminal event) + step_failed carrying\n          // the SerializationError, so the live-VM feed rejects the\n          // step's promise and workflow code can catch it. Never queue an\n          // execution message for it. Mirrors the node:vm engine's\n          // finalizeUnserializableStep. In the terminal drain\n          // (finalizeUnserializableSteps unset), skip entirely: see the\n          // param docs.\n          if (step.serializationError) {\n            if (!params.finalizeUnserializableSteps) {\n              return;\n            }\n            runtimeLogger.warn(\n              'Step arguments failed to serialize; failing the step so ' +\n                'the workflow can observe the error',\n              {\n                workflowRunId: runId,\n                correlationId: step.correlationId,\n                stepName: step.stepId,\n                error: step.serializationError.message,\n              }\n            );\n            try {\n              await createEvent({\n                eventType: 'step_created',\n                specVersion: SPEC_VERSION_CURRENT,\n                correlationId: step.correlationId,\n                eventData: {\n                  stepName: step.stepId,\n                  input: (await dehydrateStepArguments(\n                    unserializableStepInputPlaceholder(),\n                    runId,\n                    encryptionKey,\n                    globalThis,\n                    false,\n                    (workflowRun.specVersion ?? 0) >=\n                      SPEC_VERSION_SUPPORTS_COMPRESSION\n                  )) as Uint8Array,\n                },\n              });\n            } catch (err) {\n              // Concurrent invocation hit the same deterministic failure\n              // and created it first, or the run already finished.\n              if (RunExpiredError.is(err)) return;\n              if (!EntityConflictError.is(err)) throw err;\n            }\n            try {\n              await createEvent({\n                eventType: 'step_failed',\n                specVersion: SPEC_VERSION_CURRENT,\n                correlationId: step.correlationId,\n                eventData: {\n                  stepName: step.stepId,\n                  error: await dehydrateStepError(\n                    step.serializationError,\n                    runId,\n                    encryptionKey,\n                    [],\n                    globalThis,\n                    (workflowRun.specVersion ?? 0) >=\n                      SPEC_VERSION_SUPPORTS_COMPRESSION\n                  ),\n                },\n              });\n            } catch (err) {\n              // Step already terminal or run already finished.\n              if (!EntityConflictError.is(err) && !RunExpiredError.is(err)) {\n                throw err;\n              }\n            }\n            failedSerializationStepCids.add(step.correlationId);\n            wfdiag('step_serialization_failed', {\n              stepId: step.stepId,\n              correlationId: step.correlationId,\n            });\n            return;\n          }\n\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          const encryptedInput = await encryptSerializedData(\n            step.input,\n            encryptionKey\n          );\n\n          // Resilient step dispatch: fire the step_created write and the\n          // step's queue publish in parallel: the message carries the\n          // same serialized input (`stepInput`) so the consumer can\n          // idempotently re-ensure the event if the direct write failed\n          // transiently. Mirrors the node:vm suspension handler and the\n          // resilient start / resilient hook resume patterns. Only for\n          // caller-designated overflow steps with inputs the queue\n          // message can safely carry (binary, under the VQS size cap).\n          if (\n            resilientDispatchEligible &&\n            queueStepCids?.has(step.correlationId) &&\n            encryptedInput instanceof Uint8Array &&\n            encryptedInput.byteLength <= MAX_RESILIENT_STEP_INPUT_BYTES\n          ) {\n            const [createResult, queueResult] = await Promise.allSettled([\n              createEvent({\n                eventType: 'step_created',\n                specVersion: SPEC_VERSION_CURRENT,\n                correlationId: step.correlationId,\n                eventData: {\n                  stepName: step.stepId,\n                  input: encryptedInput,\n                },\n              }),\n              queueStepMessage({\n                world,\n                runId,\n                workflowRun,\n                step,\n                namespace,\n                nextTraceCarrier,\n                purpose: 'dispatch',\n                stepInput: encryptedInput,\n                wfdiag,\n              }),\n            ]);\n            // Queue failure is always fatal for this dispatch pass:\n            // without the message the step would rely on the create\n            // alone, and if the create ALSO failed there would be no\n            // durable record at all. Propagating redelivers the\n            // orchestrator message, which re-creates the (idempotent)\n            // step_created and re-dispatches.\n            if (queueResult.status === 'rejected') {\n              throw queueResult.reason;\n            }\n            queuedStepCids.add(step.correlationId);\n            if (createResult.status === 'rejected') {\n              const err = createResult.reason;\n              if (EntityConflictError.is(err)) {\n                // Concurrent invocation wrote it first: the message is\n                // already out; its duplicate publish dedupes on the\n                // shared step-identity-scoped idempotency key.\n                return;\n              }\n              if (isRetryableWorldError(err)) {\n                // Resilient: the write failed transiently (429 / 5xx /\n                // transport) but the step message (carrying the same\n                // serialized input) was published, so the consumer\n                // idempotently re-ensures the step_created before\n                // executing.\n                runtimeLogger.warn(\n                  'Step creation event write failed, but the step was ' +\n                    'dispatched via the queue. The step_created event ' +\n                    'will be ensured by the queue consumer.',\n                  {\n                    workflowRunId: runId,\n                    correlationId: step.correlationId,\n                    stepName: step.stepId,\n                    error: err instanceof Error ? err.message : String(err),\n                  }\n                );\n                wfdiag('step_resilient_dispatch_recovered', {\n                  stepId: step.stepId,\n                  correlationId: step.correlationId,\n                });\n                return;\n              }\n              throw err;\n            }\n            return;\n          }\n\n          try {\n            await createEvent({\n              eventType: 'step_created',\n              specVersion: SPEC_VERSION_CURRENT,\n              correlationId: step.correlationId,\n              eventData: {\n                stepName: step.stepId,\n                input: encryptedInput,\n              },\n            });\n          } catch (err) {\n            if (EntityConflictError.is(err)) return;\n            throw err;\n          }\n\n          // NOTE: step queueing is otherwise the caller's decision: the\n          // inline loop executes fresh steps in the live VM and only\n          // queues the overflow / retry / backstop cases (see\n          // 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 createEvent({\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), but 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 createEvent({\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 {\n    createdAttributeEvent,\n    createdGetConflictHook,\n    queuedStepCids,\n    failedSerializationStepCids,\n  };\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 * Log position on writes. This engine follows the same rule as the node:vm\n * replay loop for which writes tell the World where the writer stood (see the\n * \"Who names a position\" table above `slotSnapshotParams` in `helpers.ts`):\n *\n * - Writes made from this invocation's view of the log (`step_created`,\n *   `wait_created`, `hook_created`, `hook_disposed`, `attr_set`, the abort\n *   `hook_received`, `wait_completed`, and the `step_created` + `step_failed`\n *   pair for an unserializable input) carry `eventCount`, and the page a\n *   World hands back is queued for the live VM through {@link QuickJSLogView}.\n * - A single inline step's terminal write asks for the inline delta\n *   (`sinceCursor`) through `executeStep`, and so does a lone `hook_created`\n *   (see `dispatchPendingOps.deltaCursor`); the delta is queued the same\n *   way. The step executor's other writes carry nothing: it holds no log.\n * - Run-terminal writes (`run_completed`, `run_failed`) and the terminal drain\n *   of pending ops carry nothing: nothing reads the log afterwards.\n *\n * What differs from the node engine is what \"merge into the log\" means. The\n * node engine merges a returned page into the array it replays from. This\n * engine holds a live VM that consumes events exactly once, in position\n * order, so a returned page is queued and delivered ahead of the next\n * `events.list`, which then only runs when the queue cannot account for the\n * next position. Both engines fall back to a list for anything a page did\n * not carry.\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   * The `events.list` cursor positioned after the last of `preloadedEvents`,\n   * when the caller has one. Lets this invocation read incrementally from\n   * where the preload ended and ask for an inline delta against it. Without\n   * it the first read after the preload starts from the top of the log.\n   */\n  preloadedCursor?: string | null;\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  /** Request ID of the queue invocation, when the queue provides one. */\n  requestId?: 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  /**\n   * The wait this invocation is the delayed continuation for, if it is one\n   * (`WorkflowInvokePayload.waitContinuation`). Read only to decide the next\n   * continuation's idempotency key: a continuation that finds its own wait\n   * still pending has spent its key, so the re-arm has to advance the attempt\n   * or the world's dedupe window drops it and the wait loses its only timer.\n   */\n  waitContinuation?: { correlationId: string; attempt: number };\n}): Promise<{ timeoutSeconds?: number } | void> {\n  const {\n    workflowCode,\n    workflowName,\n    workflowRun,\n    preloadedEvents,\n    preloadedEventsComplete,\n    preloadedCursor,\n    runInput,\n    parentSpan,\n    maxEventsLimit,\n    deliveryAttempt,\n    ownerMessageId,\n    requestId,\n    namespace,\n    waitContinuation,\n  } = params;\n\n  /**\n   * Attempt number for the continuation this invocation is about to arm for\n   * `correlationId`. One higher than the incoming continuation's when this\n   * invocation IS that continuation and the wait is still pending — the only\n   * situation in which the previous key is spent. Every other caller, and\n   * every other wait, starts at 0 and keys exactly as it did before attempts\n   * existed.\n   */\n  const nextWaitContinuationAttempt = (correlationId: string): number =>\n    waitContinuation?.correlationId === correlationId\n      ? waitContinuation.attempt + 1\n      : 0;\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  // Where the log was read to: the cursor after the last page below, or the\n  // one the caller read the preload to. Seeds the incremental reads and the\n  // inline-delta requests that follow.\n  let loadedCursor: string | null = null;\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    loadedCursor = preloadedCursor ?? null;\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    loadedCursor = cursor;\n  }\n\n  // This invocation's view of the log, and the queue of events a World has\n  // handed back on a write that the VM has not been given yet. Every write\n  // made from this view goes through `createEvent` below so it names the\n  // position it was decided against and its response is queued here.\n  const logView = new QuickJSLogView(events, loadedCursor);\n  const createEvent: EventCreator = async (data, eventParams) => {\n    const result = await world.events.create(runId, data, {\n      ...eventParams,\n      ...logView.snapshotParams(),\n    });\n    if (\n      typeof eventParams?.sinceCursor === 'string' &&\n      result.events !== undefined\n    ) {\n      // The write asked for the inline delta and got one: everything after\n      // the cursor, this write included, read with refs resolved. Taken\n      // through the delta path so the cursor moves with it when that is\n      // safe; the created event's position is noted either way.\n      logView.absorb({ event: result.event });\n      const advanced = logView.absorbDelta(eventParams.sinceCursor, {\n        events: result.events,\n        cursor: result.cursor ?? null,\n        hasMore: result.hasMore ?? false,\n      });\n      wfdiag('inline_delta_absorbed', {\n        eventType: data.eventType,\n        events: result.events.length,\n        hasMore: result.hasMore ?? false,\n        cursorAdvanced: advanced,\n      });\n      return result;\n    }\n    // The created event is delivered off the response only when it carries\n    // no payload a VM reads; every other type waits for a page or a listing,\n    // which return it with its refs resolved. See QuickJSLogView.\n    const absorbed = logView.absorb(result, {\n      deliverEvent: data.eventType === 'wait_completed',\n    });\n    if (absorbed.truncated) {\n      runtimeLogger.debug(\n        'QuickJS runtime: dropped a truncated skipped-slot report',\n        {\n          workflowRunId: runId,\n          eventType: data.eventType,\n          eventId: result.event?.eventId,\n          offered: result.events?.length ?? 0,\n        }\n      );\n    }\n    return result;\n  };\n  /**\n   * The create for writes that end the run (`run_completed`, `run_failed`,\n   * and the terminal drain of leftover ops): no position named and no page\n   * asked for, because nothing replays a finished run's log. The node\n   * engine's `deltaRequestCursor` makes the same exclusion for `sinceCursor`.\n   */\n  const terminalCreateEvent: EventCreator = (data, eventParams) =>\n    world.events.create(runId, data, eventParams);\n\n  // Event-limit guard: fail a runaway run once its log reaches the\n  // server-supplied ceiling, the 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 createEvent({\n            eventType: 'wait_completed',\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: event.correlationId,\n          });\n          if (!logView.tracking && result.event) {\n            // No positions to order by (see QuickJSLogView), so the event\n            // joins the initial log directly, as it always has.\n            events.push(result.event);\n          }\n        } catch (err) {\n          if (EntityConflictError.is(err)) continue;\n          throw err;\n        }\n      }\n    }\n  }\n  // The VM has not started, so whatever those writes handed back (each\n  // wait_completed, plus anything another writer appended that they skipped\n  // over) joins the initial log instead of waiting for a feed.\n  events.push(...logView.takeContiguous());\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, since 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  /**\n   * Fetch all events not yet processed by the live VM (log order), reading\n   * from where the log was last read to. A World's cursor never passes a\n   * position whose writer is still in flight, so reading forward from it\n   * cannot skip an event; the id set is what makes a re-read of the same\n   * span (after a queued page or a delta moved the view ahead of the cursor)\n   * harmless.\n   */\n  const fetchUnseenEvents = async (): Promise<Event[]> => {\n    const unseen: Event[] = [];\n    let cursor: string | null = logView.logCursor;\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    logView.advanceCursor(cursor);\n    logView.markFed(unseen);\n    observeEventsForOwnership(unseen);\n    return unseen;\n  };\n\n  /**\n   * Events a World handed back on this invocation's writes that the VM can\n   * take now: the contiguous run above what it has (see\n   * `QuickJSLogView.takeContiguous`). Delivered ahead of `fetchUnseenEvents`\n   * so a write's response, not a listing, is what usually carries the log\n   * forward, which is the round-trip the page exists to save. Empty when\n   * nothing is queued or the next position is not in hand, and the caller\n   * lists.\n   */\n  const takeQueuedEvents = (): Event[] => {\n    const queued = logView.takeContiguous();\n    for (const e of queued) {\n      if (e.eventId) seenEventIds.add(e.eventId);\n    }\n    observeEventsForOwnership(queued);\n    return queued;\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      // Steps whose input refused to serialize (see\n      // PendingStep.serializationError) never execute: they must not be\n      // inline-claimed (a lazy step_started would need the input that\n      // failed) nor queued. Dispatch below finalizes them as step_created\n      // + step_failed instead; only healthy steps compete for inline\n      // slots and overflow.\n      const healthySteps = freshSteps.filter(\n        (step) => !step.serializationError\n      );\n      const inlineCandidates =\n        maxInlineSteps <= 0 ? [] : healthySteps.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      // Steps beyond the inline cap are handed to the queue in the same\n      // turn their step_created is written. Where eligible, the dispatch\n      // below parallelizes each overflow step's step_created write with\n      // its queue publish (resilient step dispatch: the message carries\n      // `stepInput` so the consumer can re-ensure the event); the rest\n      // are queued right after, in parallel. This must all happen BEFORE\n      // the event feed below: the feed always observes those\n      // step_created writes as unseen events and `continue`s, so a\n      // 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      // step-identity-scoped idempotency key makes repeats harmless.\n      const overflowSteps = healthySteps.slice(inlineCandidates.length);\n      const dispatched = await dispatchPendingOps({\n        world,\n        runId,\n        workflowRun,\n        encryptionKey,\n        namespace,\n        nextTraceCarrier,\n        createEvent,\n        ...(logView.tracking && typeof logView.logCursor === 'string'\n          ? { deltaCursor: logView.logCursor }\n          : {}),\n        pendingOperations: opsToDispatch,\n        skipStepCreation: inlineClaimCids,\n        queueStepCids: new Set(overflowSteps.map((s) => s.correlationId)),\n        finalizeUnserializableSteps: true,\n        wfdiag,\n      });\n      if (\n        dispatched.createdAttributeEvent ||\n        dispatched.createdGetConflictHook\n      ) {\n        pendingRequeueSignal = true;\n      }\n      // A finalized unserializable step has terminal events durably\n      // written but no execution message anywhere: if the feed below\n      // doesn't surface them (eventually-consistent listing) and the loop\n      // exits, nothing would ever re-invoke the run to observe the\n      // failure. Raise the requeue signal (same mechanism as inline\n      // terminals) and mark the steps handled so later turns don't\n      // re-finalize or backstop-queue them.\n      if (dispatched.failedSerializationStepCids.size > 0) {\n        pendingRequeueSignal = true;\n        for (const cid of dispatched.failedSerializationStepCids) {\n          executedStepIds.add(cid);\n        }\n      }\n\n      for (const cid of dispatched.queuedStepCids) {\n        queuedStepIds.add(cid);\n      }\n      await Promise.all(\n        overflowSteps\n          .filter((step) => !dispatched.queuedStepCids.has(step.correlationId))\n          .map((step) => {\n            queuedStepIds.add(step.correlationId);\n            return queueStepMessage({\n              world,\n              runId,\n              workflowRun,\n              step,\n              namespace,\n              nextTraceCarrier,\n              purpose: 'dispatch',\n              wfdiag,\n            });\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 createEvent({\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. What the writes above handed back\n      // is delivered first, and a listing runs when the queue does not reach\n      // the next position. A report changes what is fed first, not whether\n      // this listing happens: after a queued page is fed, this branch\n      // `continue`s, and the next iteration finds the queue empty and lists\n      // from a cursor a report does not advance (re-reading the reported\n      // span, deduped on `seenEventIds`). Only the inline delta below, which\n      // does advance the cursor, saves a listing outright. Same shape as the\n      // node engine.\n      {\n        const queued = takeQueuedEvents();\n        const newEvents =\n          queued.length > 0 ? queued : await fetchUnseenEvents();\n        if (newEvents.length > 0) {\n          // The listing caught up with this invocation's writes, so 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            fedFrom: queued.length > 0 ? 'write-response' : 'list',\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, so 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      //     step-identity-scoped 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, the 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        const attempt = nextWaitContinuationAttempt(soonestWait.correlationId);\n        await queueMessage(\n          world,\n          getWorkflowQueueName(workflowRun.workflowName, namespace),\n          {\n            runId,\n            traceCarrier: await nextTraceCarrier(),\n            requestedAt: new Date(),\n            waitContinuation: {\n              correlationId: soonestWait.correlationId,\n              attempt,\n            },\n          },\n          getWaitContinuationDispatch(\n            soonestWait.seconds,\n            soonestWait.correlationId,\n            Date.now(),\n            attempt\n          )\n        );\n        wfdiag('wait_continuation_scheduled', {\n          correlationId: soonestWait.correlationId,\n          delaySeconds: soonestWait.seconds,\n          attempt,\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      // Inline delta: a single inline step's terminal write asks the World\n      // for everything after the cursor this view holds, so the step's own\n      // events (and anything interleaved) arrive on the write's response and\n      // the feed below needs no listing. Same gate as the node engine's\n      // `requestInlineDelta` (runtime.ts), translated to this loop's terms:\n      //\n      // - This step is the only step outstanding: no overflow sibling queued\n      //   this iteration, no unserializable sibling, no step from an earlier\n      //   invocation handed to the queue above. Several writers each diffing\n      //   against the same cursor would produce deltas of which only the\n      //   first could be taken.\n      // - No wait is pending. A `wait_completed` is a resolution the\n      //   workflow is waiting on rather than an event it can observe one\n      //   iteration late, so a delta that predates it would settle the\n      //   sleep from a view that does not hold its completion; the listing\n      //   after the step is what reads it in order.\n      // - The log has a cursor to name (tracking on, something read).\n      const hasPendingWait = pendingOperations.some(\n        (op) =>\n          op.type === 'wait' &&\n          !completedWaitIds2.has((op as PendingWait).correlationId)\n      );\n      const inlineDeltaSinceCursor =\n        stepOps.length === 1 &&\n        freshSteps.length === 1 &&\n        inlineCandidates.length === 1 &&\n        !hasPendingWait &&\n        logView.tracking &&\n        typeof logView.logCursor === 'string'\n          ? logView.logCursor\n          : undefined;\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                  requestId,\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                  ...(inlineDeltaSinceCursor !== undefined\n                    ? { inlineDeltaSinceCursor }\n                    : {}),\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 (\n          outcome.type === 'completed' &&\n          outcome.inlineDelta !== undefined &&\n          inlineDeltaSinceCursor !== undefined\n        ) {\n          const advanced = logView.absorbDelta(\n            inlineDeltaSinceCursor,\n            outcome.inlineDelta\n          );\n          wfdiag('inline_delta_absorbed', {\n            iteration,\n            correlationId: step.correlationId,\n            events: outcome.inlineDelta.events.length,\n            hasMore: outcome.inlineDelta.hasMore,\n            cursorAdvanced: advanced,\n          });\n        }\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 dispatch key, 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 queued = takeQueuedEvents();\n      const newEvents = queued.length > 0 ? queued : 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          // Plain create: the run is ending, nothing replays its log, so a\n          // page handed back here would be read by no one.\n          createEvent: terminalCreateEvent,\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 terminalCreateEvent({\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), so 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, so 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, so 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      const attempt = nextWaitContinuationAttempt(soonestWait.correlationId);\n      await queueMessage(\n        world,\n        getWorkflowQueueName(workflowRun.workflowName, namespace),\n        {\n          runId,\n          traceCarrier: await nextTraceCarrier(),\n          requestedAt: new Date(),\n          waitContinuation: {\n            correlationId: soonestWait.correlationId,\n            attempt,\n          },\n        },\n        getWaitContinuationDispatch(\n          soonestWait.seconds,\n          soonestWait.correlationId,\n          Date.now(),\n          attempt\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, so remap stack trace using inline source maps.\n    // Frames carry the run's workflowId as their filename on the fresh\n    // path, but the workflow-independent BASELINE_BUNDLE_FILENAME on the\n    // snapshot path (the name is baked into the shared baseline's\n    // compiled code at hydrate), so remap against both. remapErrorStack\n    // early-exits on a cheap includes() when a filename has no frames.\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      errorStack = remapErrorStack(\n        errorStack,\n        BASELINE_BUNDLE_FILENAME,\n        workflowCode\n      );\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          createEvent: terminalCreateEvent,\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    //     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          // Both filename spaces. See the failed-branch comment above.\n          (hydrated as { stack?: string }).stack = remapErrorStack(\n            remapErrorStack(\n              (hydrated as { stack: string }).stack,\n              filename,\n              workflowCode\n            ),\n            BASELINE_BUNDLE_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            // Both filename spaces. See the failed-branch comment above.\n            (node as { stack?: string }).stack = remapErrorStack(\n              remapErrorStack(nodeStack, filename, workflowCode),\n              BASELINE_BUNDLE_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 (applying\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 terminalCreateEvent({\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"]}