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

package/dist/runtime/quickjs-runtime.js

@@ -15,7 +15,9 @@
  *
  * The VM bootstrap is deliberately split into two phases:
  *   1. Static initialization (`initWorkflowVM`) — run-independent setup:
- *      VM creation, the serde bundle, and the workflow primitives.
+ *      VM creation and the workflow primitives. (Serialization lives on
+ *      the host — see quickjs-serde.ts — so no serde code is evaluated
+ *      in the VM.)
  *   2. Per-run initialization (inline in `runQuickJSWorkflow`) — seeded
  *      PRNG/ULID host functions, workflow bundle evaluation, run metadata,
  *      workflow input, and start.
@@ -81,13 +83,14 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 import * as nanoid from 'nanoid';
 import { JSException, QuickJS, } from 'quickjs-wasi';
 import seedrandom from 'seedrandom';
+import { monotonicFactory } from 'ulid';
 import { runtimeLogger } from '../logger.js';
 import { decompress } from '../serialization/compression.js';
 import { decrypt } from '../serialization/encryption.js';
-import { getReplayTimeoutMs } from './constants.js';
+import { getReplayTimeoutMs, isQuickJSBaselineSnapshotEnabled, } from './constants.js';
 import { quickjsExtensions, quickjsWasm } from './quickjs-assets.generated.js';
+import { adoptSerdeRoot, captureSerdeRoot, createQuickJSSerde, exportSerdeRoot, } from './quickjs-serde.js';
 import { runIdCreatedAt } from './run-id-time.js';
-import { VM_SERDE_BUNDLE } from './vm-serde-bundle.generated.js';
 // ---- Host -> VM payload preparation ----
 /**
  * Prepare persisted payload bytes for consumption inside the VM: decrypt
@@ -148,17 +151,17 @@ globalThis.__terminalBuffer = {};
 
 // Registers a resolver for an awaited primitive, first draining any
 // buffered terminal recorded for the correlationId. Entries are prepared
-// host-side (bytes already decrypted; see processEvents).
+// host-side: bytes are decrypted AND deserialized into VM values by the
+// host serde before buffering (the VM has no in-guest deserializer on
+// the host-serde engine), so draining only forwards the stored value.
 globalThis.__registerResolver = function(correlationId, resolve, reject) {
   var buffered = globalThis.__terminalBuffer[correlationId];
   if (buffered) {
     delete globalThis.__terminalBuffer[correlationId];
-    if (buffered.kind === "resolve_bytes") {
-      resolve(globalThis[Symbol.for("workflow-deserialize")](buffered.bytes));
-    } else if (buffered.kind === "resolve_value") {
+    if (buffered.kind === "resolve_value") {
       resolve(buffered.value);
-    } else if (buffered.kind === "reject_bytes") {
-      reject(globalThis[Symbol.for("workflow-deserialize")](buffered.bytes));
+    } else if (buffered.kind === "reject_value") {
+      reject(buffered.value);
     } else if (buffered.kind === "reject_error") {
       var e = new Error(buffered.message);
       e.name = "FatalError";
@@ -314,13 +317,14 @@ globalThis[Symbol.for("WORKFLOW_USE_STEP")] = function(stepId, closureVarsFn) {
     var correlationId = "step_" + globalThis.__generateUlid();
     // Capture 'this' for method invocations (e.g., MyClass.method())
     var thisVal = (this !== undefined && this !== null && this !== globalThis) ? this : undefined;
-    // Serialize step input using the host-provided devalue serializer.
-    // This produces a format-prefixed Uint8Array ("devl" + devalue.stringify).
-    var input = globalThis[Symbol.for("workflow-serialize")]({
+    // The RAW input value. Serialization happens on the host, which reads
+    // this through a handle when it collects the pending op — no
+    // serializer code runs inside the VM.
+    var input = {
       args: args,
       closureVars: closureVarsFn ? closureVarsFn() : undefined,
       thisVal: thisVal,
-    });
+    };
     globalThis.__pending.push({
       type: "step",
       correlationId: correlationId,
@@ -537,16 +541,15 @@ globalThis[Symbol.for("WORKFLOW_CREATE_HOOK")] = function(options) {
     }
   }
 
-  // Register in pending operations.
-  // Serialize metadata inside the VM so Response/Request objects are
-  // properly handled by the devalue reducers before crossing the boundary.
+  // Register in pending operations. Metadata stays a RAW value; the host
+  // serializes it through a handle when it collects the pending op.
   var pendingOp = {
     type: "hook",
     correlationId: correlationId,
     token: token,
     tokenRetentionUntil: tokenRetentionUntil,
     isWebhook: !!options.isWebhook,
-    metadata: options.metadata ? globalThis[Symbol.for("workflow-serialize")](options.metadata) : undefined,
+    metadata: options.metadata,
     hasCreatedEvent: false,
   };
   globalThis.__pending.push(pendingOp);
@@ -747,8 +750,8 @@ WorkflowAbortSignal.prototype.throwIfAborted = function() {
       : __makeAbortError();
   }
 };
-// Expose for the serde bundle's revivers (evaluated before this bootstrap;
-// they look the class up lazily at revive time).
+// Expose for the host serde's revivers (they look the class up lazily,
+// through a handle, at revive time).
 globalThis.__WorkflowAbortSignal = WorkflowAbortSignal;
 
 // Registry of live abort signals keyed by their hook correlationId. The
@@ -779,17 +782,17 @@ globalThis.AbortController.prototype.abort = function(reason) {
   if (this.signal.aborted) return; // already aborted (e.g. from replay)
   this.signal._setAborted(reason);
   // Mark the pending hook op so the host records the abort. The payload
-  // is serialized in the VM so the reason crosses the boundary with
+  // stays a RAW value; the host serializes it through a handle with full
   // type fidelity (Errors, DOMException, custom values).
   var token = this[__ABORT_HOOK_TOKEN];
   for (var i = 0; i < globalThis.__pending.length; i++) {
     var item = globalThis.__pending[i];
     if (item.type === "hook" && item.token === token) {
       item.abortRequested = true;
-      item.abortPayload = globalThis[Symbol.for("workflow-serialize")]({
+      item.abortPayload = {
         aborted: true,
         reason: reason,
-      });
+      };
       break;
     }
   }
@@ -860,9 +863,10 @@ globalThis[Symbol.for("WORKFLOW_GET_STREAM_ID")] = function(namespace) {
  * Phase 1 — static (run-independent) VM initialization.
  *
  * Creates a QuickJS VM and loads everything that does not depend on a
- * specific workflow run: the serde bundle (devalue-based serialization
- * used at the host/VM boundary) and the workflow-primitive bootstrap
- * (useStep / sleep / createHook / Response-Request polyfills).
+ * specific workflow run: the workflow-primitive bootstrap (useStep /
+ * sleep / createHook / Response-Request polyfills). Serialization is
+ * host-side (quickjs-serde.ts) and captures its intrinsics from the VM
+ * right after this returns.
  *
  * `getNowMs` backs the VM's WASI clock (`Date.now()` / `new Date()`
  * inside the VM). The callback itself is static — the per-run state it
@@ -913,33 +917,218 @@ function getCompiledAssets() {
     }
     return compiledAssetsPromise;
 }
-async function initWorkflowVM(getNowMs, interruptBudget) {
-    // Deterministic replay clock: Date.now() / new Date() inside the VM
-    // read the host-controlled clock instead of wall time. Replay
-    // re-executes the workflow from the top on every invocation, so the
-    // clock must be derived from the event log (not real time) for the
-    // workflow to observe stable timestamps across invocations.
-    const wasi = (memory) => ({
+/**
+ * WASI clock override reading the given accessor — shared between fresh
+ * boots (initWorkflowVM) and baseline-snapshot restores, so the two
+ * paths cannot drift on rounding/encoding.
+ *
+ * Deterministic replay clock: Date.now() / new Date() inside the VM
+ * read the host-controlled clock instead of wall time. Replay
+ * re-executes the workflow from the top on every invocation, so the
+ * clock must be derived from the event log (not real time) for the
+ * workflow to observe stable timestamps across invocations.
+ */
+function makeDeterministicClockWasi(getNowMs) {
+    return (memory) => ({
         clock_time_get(_clockId, _precision, resultPtr) {
             const timeNs = BigInt(Math.round(getNowMs())) * 1000000n;
             new DataView(memory.buffer).setBigUint64(resultPtr, timeNs, true);
             return 0;
         },
     });
+}
+async function initWorkflowVM(getNowMs, interruptBudget) {
     const assets = await getCompiledAssets();
     const vm = await QuickJS.create({
         wasm: assets.wasm,
         memoryLimit: 256 * 1024 * 1024,
         interruptHandler: createInterruptHandler(interruptBudget),
         extensions: assets.extensions,
-        wasi,
+        wasi: makeDeterministicClockWasi(getNowMs),
     });
-    // Evaluate the VM serde bundle
-    vm.evalCode(VM_SERDE_BUNDLE, 'vm-serde.js').dispose();
     // Bootstrap workflow primitives
     vm.evalCode(VM_BOOTSTRAP, 'bootstrap.js').dispose();
     return vm;
 }
+// ---- Baseline snapshot (startup optimization) --------------------------
+//
+// Evaluating the workflow bundle dominates VM startup (~74ms of a ~77ms
+// boot for a 1.3MB bundle), and full event replay pays it on EVERY
+// invocation. The bundle is identical across all runs of a deployment, so
+// the engine hydrates one VM per function instance (bootstrap + bundle
+// eval), snapshots its memory, and starts every invocation by restoring
+// the snapshot (~3ms) instead of re-evaluating.
+//
+// Determinism: replay requires module-scope user code to observe the
+// run-seeded PRNG and the run's deterministic clock. A restored heap
+// carries whatever module scope computed at HYDRATE time, so the
+// optimization is only sound when module scope consumed neither
+// randomness nor time. Both are detected during hydrate — the placeholder
+// host fns count draws, the hydrate clock counts reads — and a bundle
+// that used either is marked ineligible: every invocation falls back to
+// fresh evaluation, preserving exact node:vm-parity semantics. When the
+// gate passes, restore is byte-equivalent to fresh eval (verified by the
+// parity tests): the per-run host fns are re-registered by name on the
+// restored VM (quickjs-wasi restore semantics) before the workflow body
+// runs, so the seeded draw sequence — and every correlationId — is
+// identical.
+//
+// The cache is per function instance and keyed on the bundle string
+// (reference-stable: the generated flow route holds it in a module-level
+// const). Capped at a few entries so tests with many distinct bundles
+// don't accumulate 16MB snapshots.
+/**
+ * Eval filename used when hydrating the baseline VM. The baseline is
+ * shared by EVERY workflow in the bundle, so the filename baked into
+ * its compiled code (and therefore into snapshot-path stack frames)
+ * must be workflow-independent — hydrating under the first caller's
+ * workflowId would break `remapErrorStack`'s filename matching for
+ * every other workflow in the bundle. Remap call sites match this
+ * constant IN ADDITION to the run's module specifier (which covers
+ * fresh-path frames).
+ */
+export const BASELINE_BUNDLE_FILENAME = 'workflow-bundle.js';
+const baselineCache = new Map();
+const BASELINE_CACHE_MAX_ENTRIES = 4;
+/** Test-only: reset the baseline cache between test cases. */
+export function __clearBaselineSnapshotCacheForTests() {
+    baselineCache.clear();
+}
+/** Test-only: observe how a bundle was classified. */
+export async function __peekBaselineEntryForTests(workflowCode) {
+    return baselineCache.get(workflowCode);
+}
+/**
+ * Hydrate a VM with the workflow bundle and snapshot it, gating on
+ * module-scope nondeterminism (see the section comment above). Returns an
+ * `ineligible` entry instead of throwing on eval failure — the fresh path
+ * re-evaluates and produces the real, source-mapped error.
+ */
+async function prepareBaselineSnapshot(workflowCode, workflowId) {
+    const hydrateStart = Date.now();
+    let clockReads = 0;
+    const budget = { start: Date.now() };
+    const assets = await getCompiledAssets();
+    const vm = await QuickJS.create({
+        wasm: assets.wasm,
+        memoryLimit: 256 * 1024 * 1024,
+        interruptHandler: createInterruptHandler(budget),
+        extensions: assets.extensions,
+        wasi: ((memory) => ({
+            clock_time_get(_clockId, _precision, resultPtr) {
+                clockReads++;
+                const timeNs = BigInt(hydrateStart) * 1000000n;
+                new DataView(memory.buffer).setBigUint64(resultPtr, timeNs, true);
+                return 0;
+            },
+        })),
+    });
+    try {
+        vm.evalCode(VM_BOOTSTRAP, 'bootstrap.js').dispose();
+        // Placeholder host fns under the SAME NAMES the per-run phase uses.
+        // They exist so module-scope code can execute at hydrate time, and to
+        // detect that it did: any draw means the heap would bake
+        // hydrate-seeded values that per-run fresh eval would compute
+        // differently. runWorkflowInVM re-registers all three names with the
+        // run-seeded closures after restore.
+        let draws = 0;
+        {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const randomFn = __addDisposableResource(env_1, vm.newFunction('random', () => {
+                    draws++;
+                    return vm.newNumber(Math.random());
+                }), false);
+                const math = __addDisposableResource(env_1, vm.global.getProp('Math'), false);
+                math.setProp('random', randomFn);
+                const nanoidFn = __addDisposableResource(env_1, vm.newFunction('__generateNanoid', () => {
+                    draws++;
+                    return vm.newString('baseline-placeholder');
+                }), false);
+                vm.setProp(vm.global, '__generateNanoid', nanoidFn);
+                const ulidFn = __addDisposableResource(env_1, vm.newFunction('__generateUlid', () => {
+                    draws++;
+                    return vm.newString('00000000000000000000000000');
+                }), false);
+                vm.setProp(vm.global, '__generateUlid', ulidFn);
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        }
+        // Serde capture root — created BEFORE the bundle evaluates, exactly
+        // like the fresh path's capture. Its box pointer rides the
+        // BaselineEntry and each restored VM re-adopts it, so serde
+        // initialization never executes guest code after user code has run.
+        // This is what makes module-scope intrinsic patching (polyfills,
+        // stateful wrappers around Object.getOwnPropertyDescriptor, …)
+        // HARMLESS on the snapshot path rather than merely detectable: the
+        // serde uses the pristine pre-eval captures on both paths, and no
+        // post-eval probe exists whose side effects could bake into the
+        // snapshot. The handle is deliberately NOT disposed before the
+        // snapshot — the box must stay live in the memory image (the
+        // baseline VM's dispose below tears down the whole instance without
+        // freeing individual boxes).
+        const serdeRoot = captureSerdeRoot(vm);
+        clockReads = 0; // only count reads made by the bundle itself
+        try {
+            // Workflow-independent filename — see BASELINE_BUNDLE_FILENAME.
+            vm.evalCode(workflowCode, BASELINE_BUNDLE_FILENAME).dispose();
+        }
+        catch {
+            // Let the fresh path re-evaluate and surface the real error with
+            // proper filename / source-map handling.
+            return {
+                state: 'ineligible',
+                reason: 'module scope threw during hydrate',
+            };
+        }
+        if (draws > 0 || clockReads > 0) {
+            runtimeLogger.info('QuickJS baseline snapshot disabled for this bundle: module scope consumed nondeterministic inputs; every invocation will evaluate the bundle fresh', { workflowId, draws, clockReads });
+            return {
+                state: 'ineligible',
+                reason: `module scope consumed ${draws} PRNG draw(s) and ${clockReads} clock read(s)`,
+            };
+        }
+        const snapshot = vm.snapshot();
+        runtimeLogger.debug('QuickJS baseline snapshot prepared', {
+            workflowId,
+            hydrateMs: Date.now() - hydrateStart,
+        });
+        return {
+            state: 'ready',
+            snapshot,
+            serdeRootPtr: exportSerdeRoot(vm, serdeRoot),
+        };
+    }
+    finally {
+        vm.dispose();
+    }
+}
+/**
+ * Cached baseline entry for a bundle, preparing it on first access.
+ * Concurrent first invocations share one hydrate via the cached promise;
+ * a hydrate that REJECTS (infrastructure failure, not bundle eval — that
+ * returns `ineligible`) is evicted so a later invocation can retry.
+ */
+function getBaselineEntry(workflowCode, workflowId) {
+    let entry = baselineCache.get(workflowCode);
+    if (!entry) {
+        if (baselineCache.size >= BASELINE_CACHE_MAX_ENTRIES) {
+            const oldest = baselineCache.keys().next().value;
+            if (oldest !== undefined)
+                baselineCache.delete(oldest);
+        }
+        entry = prepareBaselineSnapshot(workflowCode, workflowId);
+        baselineCache.set(workflowCode, entry);
+        entry.catch(() => baselineCache.delete(workflowCode));
+    }
+    return entry;
+}
 /**
  * Run a workflow invocation to its first settled state and dispose the
  * VM. Convenience wrapper over {@link startQuickJSWorkflow} for callers
@@ -991,8 +1180,60 @@ export async function startQuickJSWorkflow(options) {
             vmNowMs = Math.max(vmNowMs, ms);
     };
     // ---- Phase 1: static initialization ----
+    //
+    // Baseline-snapshot fast path (default ON; see the section comment at
+    // prepareBaselineSnapshot): restore a bundle-hydrated VM instead of
+    // booting fresh and re-evaluating the bundle. `ineligible` bundles
+    // (module-scope nondeterminism, eval failure) take the fresh path with
+    // identical semantics.
     const interruptBudget = { start: Date.now() };
-    const vm = await initWorkflowVM(() => vmNowMs, interruptBudget);
+    let baselineSnapshot;
+    let baselineSerdeRootPtr;
+    if (isQuickJSBaselineSnapshotEnabled()) {
+        try {
+            const entry = await getBaselineEntry(workflowCode, workflowId);
+            if (entry.state === 'ready') {
+                baselineSnapshot = entry.snapshot;
+                baselineSerdeRootPtr = entry.serdeRootPtr;
+            }
+        }
+        catch (err) {
+            // A rejection here is an infrastructure failure during hydrate
+            // (e.g. vm.snapshot() under memory pressure, QuickJS.create or
+            // getCompiledAssets() failing) — NOT bundle eval, which returns
+            // an ineligible entry. getBaselineEntry has already evicted the
+            // cached promise so a later invocation can retry. This invocation
+            // must fall back to fresh evaluation (which would have succeeded)
+            // rather than fail the whole run for a snapshot-only failure mode.
+            runtimeLogger.warn('QuickJS baseline snapshot hydrate failed; falling back to fresh evaluation for this invocation', { workflowId, error: err });
+        }
+    }
+    let vm;
+    if (baselineSnapshot) {
+        const assets = await getCompiledAssets();
+        vm = await QuickJS.restore(baselineSnapshot, {
+            wasm: assets.wasm,
+            memoryLimit: 256 * 1024 * 1024,
+            interruptHandler: createInterruptHandler(interruptBudget),
+            extensions: assets.extensions,
+            wasi: makeDeterministicClockWasi(() => vmNowMs),
+        });
+    }
+    else {
+        vm = await initWorkflowVM(() => vmNowMs, interruptBudget);
+    }
+    // Host-side serde: captures the VM's intrinsics (bootstrap included)
+    // before any user code runs. All serialization now happens on the host
+    // through handles — no serializer code is evaluated inside the VM.
+    // Fresh path: capture now (no user code has run — the bundle evaluates
+    // later in the per-run phase). Snapshot path: re-adopt the capture root
+    // the baseline hydrate created BEFORE the bundle evaluated — the box
+    // lives in the restored memory image at the recorded offset. Both give
+    // the serde pristine capture-before-user-code intrinsics; neither
+    // executes guest code here.
+    const serde = baselineSnapshot && baselineSerdeRootPtr !== undefined
+        ? createQuickJSSerde(vm, adoptSerdeRoot(vm, baselineSerdeRootPtr))
+        : createQuickJSSerde(vm);
     // Any throw between here and the terminal paths (which dispose the VM
     // inside checkWorkflowState / extractError before RETURNING) would leak
     // a live QuickJS instance and its WASM linear memory for the lifetime
@@ -1015,66 +1256,91 @@ export async function startQuickJSWorkflow(options) {
         vm.evalCode(`globalThis.__worldCapabilities = ${JSON.stringify(options.worldCapabilities)};`).dispose();
         // Seeded Math.random
         {
-            const env_1 = { stack: [], error: void 0, hasError: false };
+            const env_2 = { stack: [], error: void 0, hasError: false };
             try {
-                const randomFn = __addDisposableResource(env_1, vm.newFunction('random', () => vm.newNumber(rng())), false);
-                const math = __addDisposableResource(env_1, vm.global.getProp('Math'), false);
+                const randomFn = __addDisposableResource(env_2, vm.newFunction('random', () => vm.newNumber(rng())), false);
+                const math = __addDisposableResource(env_2, vm.global.getProp('Math'), false);
                 math.setProp('random', randomFn);
             }
-            catch (e_1) {
-                env_1.error = e_1;
-                env_1.hasError = true;
+            catch (e_2) {
+                env_2.error = e_2;
+                env_2.hasError = true;
             }
             finally {
-                __disposeResources(env_1);
+                __disposeResources(env_2);
             }
         }
         // Seeded nanoid generator
         {
-            const env_2 = { stack: [], error: void 0, hasError: false };
+            const env_3 = { stack: [], error: void 0, hasError: false };
             try {
-                const nanoidFn = __addDisposableResource(env_2, vm.newFunction('__generateNanoid', () => vm.newString(generateNanoid())), false);
+                const nanoidFn = __addDisposableResource(env_3, vm.newFunction('__generateNanoid', () => vm.newString(generateNanoid())), false);
                 vm.setProp(vm.global, '__generateNanoid', nanoidFn);
             }
-            catch (e_2) {
-                env_2.error = e_2;
-                env_2.hasError = true;
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
             }
             finally {
-                __disposeResources(env_2);
+                __disposeResources(env_3);
             }
         }
-        // Inject a deterministic timestamp for the VM's ULID factory. ULIDs
-        // produced inside the VM use this as their time prefix instead of
-        // Date.now(), so two concurrent workflow invocations of the same run
-        // produce IDENTICAL correlationIds (the random portion also matches
-        // because the PRNG is seeded the same way) and the world's
+        // Host-side deterministic ULID generator for correlationIds. Uses the
+        // same `ulid` package and monotonic factory as before, drawing from
+        // the SAME seeded PRNG instance as the VM's Math.random — so the
+        // interleaved draw sequence (and therefore every correlationId) is
+        // byte-identical to what the previous in-VM ULID factory produced for
+        // the same run. The time prefix is derived from the runId's embedded
+        // ULID (stable across invocations by construction — unlike
+        // `startedAt`, which differs between turbo's synthesized run object
+        // and the durably stored run), so two concurrent invocations of the
+        // same run produce IDENTICAL correlationIds and the world's
         // EntityConflictError on `events.create` dedups one of each pair.
-        // Derived from the runId's embedded ULID (stable across invocations by
-        // construction — unlike `startedAt`, which differs between turbo's
-        // synthesized run object and the durably stored run).
-        vm.evalCode(`globalThis.__ulidTimestamp = ${runIdCreatedAt(workflowRun.runId) ?? (+workflowRun.createdAt || startedAt)};`).dispose();
-        // `process.env` — parity with the node:vm engine, which exposes a frozen
-        // copy of the host env (vm/index.ts). Injected per run so the snapshot of
-        // the env is taken at invocation time, same as node.
         {
-            const envHandle = vm.newString(JSON.stringify(process.env));
-            vm.setProp(vm.global, '__wdk_env', envHandle);
-            envHandle.dispose();
-            vm.evalCode('globalThis.process = { env: Object.freeze(JSON.parse(globalThis.__wdk_env)) };' +
-                'delete globalThis.__wdk_env;').dispose();
+            const env_4 = { stack: [], error: void 0, hasError: false };
+            try {
+                const ulidFactory = monotonicFactory(() => rng());
+                const ulidTimestamp = runIdCreatedAt(workflowRun.runId) ??
+                    (+workflowRun.createdAt || startedAt);
+                const ulidFn = __addDisposableResource(env_4, vm.newFunction('__generateUlid', () => vm.newString(ulidFactory(ulidTimestamp))), false);
+                vm.setProp(vm.global, '__generateUlid', ulidFn);
+            }
+            catch (e_4) {
+                env_4.error = e_4;
+                env_4.hasError = true;
+            }
+            finally {
+                __disposeResources(env_4);
+            }
         }
+        // `process.env` — parity with the node:vm engine, which exposes a frozen
+        // copy of the host env (vm/index.ts). Injected per run so the snapshot of
+        // the env is taken at invocation time, same as node. Handle-based (no
+        // guest source evaluated): on the baseline-snapshot path this runs
+        // after user code, and a guest-source injection would execute through
+        // potentially patched globals (JSON.parse, Object.freeze) — visible
+        // to module-scope wrappers only on the restore path, diverging
+        // replays.
+        serde.installProcessEnv(process.env);
         // Execute the workflow bundle — use the workflowId as the eval filename
         // so QuickJS stack traces reference the workflow name, enabling source map
         // remapping by remapErrorStack (which matches frames by filename).
         // Evaluated in the per-run phase (after Math.random seeding) so that
         // module-scope user code draws from the seeded PRNG, matching the
-        // node:vm engine's replay determinism.
-        try {
-            vm.evalCode(workflowCode, workflowId || 'workflow.js').dispose();
-        }
-        catch (err) {
-            return makeSettledSession(extractError(vm, err, 'Workflow evaluation failed'));
+        // node:vm engine's replay determinism. Skipped on the
+        // baseline-snapshot path: the restored heap already carries the
+        // evaluated bundle, and the baseline gate guarantees module scope
+        // consumed no PRNG draws or clock reads — so skipping the eval is
+        // observationally identical to re-running it (the run-seeded host
+        // fns registered above rebind the SAME names the restored heap's
+        // function objects dispatch through).
+        if (!baselineSnapshot) {
+            try {
+                vm.evalCode(workflowCode, workflowId || 'workflow.js').dispose();
+            }
+            catch (err) {
+                return makeSettledSession(extractError(vm, err, 'Workflow evaluation failed'));
+            }
         }
         // Extract workflow arguments. Prefer the run_created event; fall back
         // to the queue message's runInput if the event log is incomplete
@@ -1094,7 +1360,9 @@ export async function startQuickJSWorkflow(options) {
                 byteLength: decryptedInput.byteLength,
                 source: runCreatedInput ? 'run_created' : 'queueMessage.runInput',
             });
-            const inputHandle = vm.newUint8Array(decryptedInput);
+            // Build the argument value directly in the VM via the host-side
+            // serde (guest code never sees the wire bytes).
+            const inputHandle = serde.deserialize(decryptedInput);
             vm.setProp(vm.global, '__wdk_input', inputHandle);
             inputHandle.dispose();
         }
@@ -1148,24 +1416,30 @@ export async function startQuickJSWorkflow(options) {
         __wfnErr.name = "WorkflowNotRegisteredError";
         throw __wfnErr;
       }
-      var __args = globalThis.__wdk_input
-        ? globalThis[Symbol.for("workflow-deserialize")](globalThis.__wdk_input)
+      var __args = globalThis.__wdk_input !== undefined
+        ? globalThis.__wdk_input
         : [];
       delete globalThis.__wdk_input;
       if (!Array.isArray(__args)) __args = [__args];
       __wfn.apply(null, __args).then(
-        function(result) { globalThis.__workflowResult = globalThis[Symbol.for("workflow-serialize")](result); },
+        function(result) {
+          // Store the RAW result; the host serializes it through a handle.
+          // A separate done flag distinguishes "completed with undefined"
+          // from "not completed".
+          globalThis.__workflowDone = true;
+          globalThis.__workflowResult = result;
+        },
         function(error) {
           // Preserve display info on the host-side failed object
-          // (matches the legacy host-visible shape) AND serialize the
-          // entire thrown value so the host can dehydrate the original
+          // (matches the legacy host-visible shape) AND keep the RAW
+          // thrown value so the host can serialize the original
           // type-identity, cause chain, or non-Error throws verbatim
           // through the standard error pipeline.
           globalThis.__workflowError = {
             message: error && error.message != null ? String(error.message) : String(error),
             stack: error && error.stack ? error.stack : "",
             name: error && error.name ? error.name : (error instanceof Error ? "Error" : typeof error),
-            valueBytes: globalThis[Symbol.for("workflow-serialize")](error),
+            value: error,
           };
         }
       );
@@ -1182,7 +1456,7 @@ export async function startQuickJSWorkflow(options) {
             let maxIterations = 100;
             let madeProgress;
             do {
-                madeProgress = await processEvents(vm, events, advanceClock, options.encryptionKey);
+                madeProgress = await processEvents(vm, serde, events, advanceClock, options.encryptionKey);
                 let batch;
                 do {
                     batch = vm.executePendingJobs();
@@ -1202,7 +1476,7 @@ export async function startQuickJSWorkflow(options) {
             }
         }
         // ---- Check result ----
-        return makeLiveSession(vm, interruptBudget, advanceClock, options.encryptionKey);
+        return makeLiveSession(vm, serde, interruptBudget, advanceClock, options.encryptionKey);
     }
 }
 /** Session wrapper for a result whose VM is already settled/disposed. */
@@ -1220,8 +1494,8 @@ function makeSettledSession(result) {
  * the VM stays alive so `continueWithEvents` can resume it in place;
  * terminal states dispose the VM immediately (inside checkWorkflowState).
  */
-function makeLiveSession(vm, interruptBudget, advanceClock, encryptionKey) {
-    const result = checkWorkflowState(vm, { keepAliveOnSuspend: true });
+function makeLiveSession(vm, serde, interruptBudget, advanceClock, encryptionKey) {
+    const result = checkWorkflowState(vm, serde, { keepAliveOnSuspend: true });
     let alive = !!result.suspended;
     const session = {
         result,
@@ -1235,7 +1509,7 @@ function makeLiveSession(vm, interruptBudget, advanceClock, encryptionKey) {
             let maxIterations = 100;
             let madeProgress;
             do {
-                madeProgress = await processEvents(vm, newEvents, advanceClock, encryptionKey);
+                madeProgress = await processEvents(vm, serde, newEvents, advanceClock, encryptionKey);
                 let batch;
                 do {
                     batch = vm.executePendingJobs();
@@ -1243,7 +1517,9 @@ function makeLiveSession(vm, interruptBudget, advanceClock, encryptionKey) {
                         madeProgress = true;
                 } while (batch > 0);
             } while (madeProgress && --maxIterations > 0);
-            const next = checkWorkflowState(vm, { keepAliveOnSuspend: true });
+            const next = checkWorkflowState(vm, serde, {
+                keepAliveOnSuspend: true,
+            });
             if (!next.suspended)
                 alive = false;
             session.result = next;
@@ -1264,7 +1540,7 @@ function makeLiveSession(vm, interruptBudget, advanceClock, encryptionKey) {
     return session;
 }
 // ---- Event Processing ----
-async function processEvents(vm, events, advanceClock, encryptionKey) {
+async function processEvents(vm, serde, events, advanceClock, encryptionKey) {
     let resolved = false;
     for (const event of events) {
         // Advance the VM's deterministic clock to this event's creation time
@@ -1303,10 +1579,10 @@ async function processEvents(vm, events, advanceClock, encryptionKey) {
                             prefix: new TextDecoder().decode(decryptedOutput.subarray(0, 4)),
                             byteLength: decryptedOutput.byteLength,
                         });
-                        const bytesHandle = vm.newUint8Array(decryptedOutput);
-                        vm.setProp(vm.global, '__tmp_result', bytesHandle);
-                        bytesHandle.dispose();
-                        vm.evalCode(`globalThis.__resolvers[${cidJs}].resolve(globalThis[Symbol.for("workflow-deserialize")](globalThis.__tmp_result));` +
+                        const valueHandle = serde.deserialize(decryptedOutput);
+                        vm.setProp(vm.global, '__tmp_result', valueHandle);
+                        valueHandle.dispose();
+                        vm.evalCode(`globalThis.__resolvers[${cidJs}].resolve(globalThis.__tmp_result);` +
                             `delete globalThis.__resolvers[${cidJs}];` +
                             `delete globalThis.__tmp_result;`).dispose();
                     }
@@ -1339,10 +1615,12 @@ async function processEvents(vm, events, advanceClock, encryptionKey) {
                     // the await never settles.
                     if (rawOutput instanceof Uint8Array) {
                         const decryptedOutput = await prepareBytesForVM(rawOutput, encryptionKey);
-                        const bytesHandle = vm.newUint8Array(decryptedOutput);
-                        vm.setProp(vm.global, '__tmp_buf', bytesHandle);
-                        bytesHandle.dispose();
-                        vm.evalCode(`globalThis.__terminalBuffer[${cidJs}] = { kind: "resolve_bytes", bytes: globalThis.__tmp_buf };` +
+                        // Host serde: deserialize into a VM value NOW (same path as
+                        // the resolver branch above) and buffer the value itself.
+                        const valueHandle = serde.deserialize(decryptedOutput);
+                        vm.setProp(vm.global, '__tmp_buf', valueHandle);
+                        valueHandle.dispose();
+                        vm.evalCode(`globalThis.__terminalBuffer[${cidJs}] = { kind: "resolve_value", value: globalThis.__tmp_buf };` +
                             `delete globalThis.__tmp_buf;`).dispose();
                     }
                     else {
@@ -1365,12 +1643,11 @@ async function processEvents(vm, events, advanceClock, encryptionKey) {
                         // (TypeError, FatalError with original cause chain, etc.) with
                         // the original message and stack preserved.
                         const decrypted = await prepareBytesForVM(errorData, encryptionKey);
-                        const bytesHandle = vm.newUint8Array(decrypted);
-                        vm.setProp(vm.global, '__tmp_error', bytesHandle);
-                        bytesHandle.dispose();
+                        const errorHandle = serde.deserialize(decrypted);
+                        vm.setProp(vm.global, '__tmp_error', errorHandle);
+                        errorHandle.dispose();
                         vm.evalCode(`(function(){` +
-                            `var e=globalThis[Symbol.for("workflow-deserialize")](globalThis.__tmp_error);` +
-                            `globalThis.__resolvers[${cidJs}].reject(e);` +
+                            `globalThis.__resolvers[${cidJs}].reject(globalThis.__tmp_error);` +
                             `delete globalThis.__resolvers[${cidJs}];` +
                             `delete globalThis.__tmp_error;` +
                             `})()`).dispose();
@@ -1411,10 +1688,12 @@ async function processEvents(vm, events, advanceClock, encryptionKey) {
                     const errorData = eventData?.error;
                     if (errorData instanceof Uint8Array) {
                         const decrypted = await prepareBytesForVM(errorData, encryptionKey);
-                        const bytesHandle = vm.newUint8Array(decrypted);
-                        vm.setProp(vm.global, '__tmp_buf', bytesHandle);
-                        bytesHandle.dispose();
-                        vm.evalCode(`globalThis.__terminalBuffer[${cidJs}] = { kind: "reject_bytes", bytes: globalThis.__tmp_buf };` +
+                        // Host serde: deserialize into the VM error value NOW (same
+                        // path as the resolver branch above) and buffer it.
+                        const errorHandle = serde.deserialize(decrypted);
+                        vm.setProp(vm.global, '__tmp_buf', errorHandle);
+                        errorHandle.dispose();
+                        vm.evalCode(`globalThis.__terminalBuffer[${cidJs}] = { kind: "reject_value", value: globalThis.__tmp_buf };` +
                             `delete globalThis.__tmp_buf;`).dispose();
                     }
                     else {
@@ -1534,11 +1813,11 @@ async function processEvents(vm, events, advanceClock, encryptionKey) {
                     const rawAbortPayload = eventData?.payload;
                     if (rawAbortPayload instanceof Uint8Array) {
                         const decrypted = await prepareBytesForVM(rawAbortPayload, encryptionKey);
-                        const bytesHandle = vm.newUint8Array(decrypted);
-                        vm.setProp(vm.global, '__tmp_abort', bytesHandle);
-                        bytesHandle.dispose();
+                        const payloadHandle = serde.deserialize(decrypted);
+                        vm.setProp(vm.global, '__tmp_abort', payloadHandle);
+                        payloadHandle.dispose();
                         vm.evalCode(`(function(){` +
-                            `var p=globalThis[Symbol.for("workflow-deserialize")](globalThis.__tmp_abort);` +
+                            `var p=globalThis.__tmp_abort;` +
                             `delete globalThis.__tmp_abort;` +
                             `globalThis.__abortSignals[${cidJs}]._setAborted(p&&typeof p==="object"?p.reason:undefined);` +
                             `})()`).dispose();
@@ -1584,10 +1863,10 @@ async function processEvents(vm, events, advanceClock, encryptionKey) {
                     if (rawPayload instanceof Uint8Array) {
                         // Decrypt if encrypted — the VM only understands 'devl' format
                         const decryptedPayload = await prepareBytesForVM(rawPayload, encryptionKey);
-                        const bytesHandle = vm.newUint8Array(decryptedPayload);
-                        vm.setProp(vm.global, '__tmp_result', bytesHandle);
-                        bytesHandle.dispose();
-                        vm.evalCode(`globalThis.__resolvers[${cidJs}].resolve(globalThis[Symbol.for("workflow-deserialize")](globalThis.__tmp_result));` +
+                        const payloadHandle = serde.deserialize(decryptedPayload);
+                        vm.setProp(vm.global, '__tmp_result', payloadHandle);
+                        payloadHandle.dispose();
+                        vm.evalCode(`globalThis.__resolvers[${cidJs}].resolve(globalThis.__tmp_result);` +
                             `delete globalThis.__resolvers[${cidJs}];` +
                             `delete globalThis.__tmp_result;`).dispose();
                     }
@@ -1626,13 +1905,13 @@ async function processEvents(vm, events, advanceClock, encryptionKey) {
                     if (rawPayload instanceof Uint8Array) {
                         // Decrypt if encrypted — the VM only understands 'devl' format
                         const decryptedPayload = await prepareBytesForVM(rawPayload, encryptionKey);
-                        const bytesHandle = vm.newUint8Array(decryptedPayload);
-                        vm.setProp(vm.global, '__tmp_result', bytesHandle);
-                        bytesHandle.dispose();
+                        const payloadHandle = serde.deserialize(decryptedPayload);
+                        vm.setProp(vm.global, '__tmp_result', payloadHandle);
+                        payloadHandle.dispose();
                         // NOTE: replacement is a function so `$`-sequences in the
                         // substituted JS never get interpreted as String.replace
                         // special replacement patterns.
-                        vm.evalCode(bufferAndTrack.replace('%PAYLOAD%', () => 'globalThis[Symbol.for("workflow-deserialize")](globalThis.__tmp_result)') + 'delete globalThis.__tmp_result;').dispose();
+                        vm.evalCode(bufferAndTrack.replace('%PAYLOAD%', () => 'globalThis.__tmp_result') + 'delete globalThis.__tmp_result;').dispose();
                     }
                     else {
                         const serialized = rawPayload !== undefined
@@ -1769,10 +2048,124 @@ function markCreated(vm, cidJs, opType) {
  * attributes/hooks/steps/waits) and pending abort recordings are surfaced
  * for the entrypoint to flush.
  */
-function collectDrainOperations(vm) {
-    const env_3 = { stack: [], error: void 0, hasError: false };
+/**
+ * Per-VM cache of serialized pending-op field bytes, keyed
+ * `correlationId:field`. A step's raw input is immutable once pushed, so
+ * its bytes are computed once even though the op is re-collected on every
+ * suspension it stays pending through.
+ */
+const pendingByteCache = new WeakMap();
+function ensurePendingByteCache(vm) {
+    let cache = pendingByteCache.get(vm);
+    if (!cache) {
+        cache = new Map();
+        pendingByteCache.set(vm, cache);
+    }
+    return cache;
+}
+/**
+ * The pending-op fields that hold RAW guest values (the bootstrap no longer
+ * serializes them in the VM). Collection projects them out of the dumped
+ * plain metadata and serializes each through a handle with the host serde.
+ */
+const RAW_PENDING_FIELDS = ['input', 'metadata', 'abortPayload'];
+/**
+ * Dump a filtered view of `globalThis.__pending` to host PendingOperation
+ * objects, serializing the raw-value fields host-side. `filterExpr` is a
+ * guest expression that evaluates to the array of ops to collect.
+ */
+function dumpPendingOps(vm, serde, filterExpr, byteCache) {
+    const env_5 = { stack: [], error: void 0, hasError: false };
     try {
-        const h = __addDisposableResource(env_3, vm.evalCode(`(function(){
+        const projected = __addDisposableResource(env_5, vm.evalCode(`(function(){
+    var ops = ${filterExpr};
+    globalThis.__rawFields = [];
+    // Settled ops — created, resolver-less, no abort in flight — are
+    // never collected again by either the suspension or the drain
+    // filter, so their cached bytes are dead weight; surface their cids
+    // so the host can evict them (see the byte-cache eviction below).
+    var settled = [];
+    globalThis.__pending.forEach(function(p){
+      if (p.hasCreatedEvent && !globalThis.__resolvers[p.correlationId] && !p.abortRequested) {
+        settled.push(p.correlationId);
+      }
+    });
+    return { settled: settled, ops: ops.map(function(p){
+      var q = {};
+      for (var k in p) {
+        if (k === 'input' || k === 'metadata' || k === 'abortPayload') continue;
+        q[k] = p[k];
+      }
+      var raw = {};
+      ['input', 'metadata', 'abortPayload'].forEach(function(f){
+        if (p[f] !== undefined) {
+          raw[f] = globalThis.__rawFields.length;
+          globalThis.__rawFields.push(p[f]);
+        }
+      });
+      q.__rawIndices = raw;
+      return q;
+    }) };
+  })()`), false);
+        const dumped = vm.dump(projected);
+        const plainOps = dumped.ops;
+        // Byte-cache eviction: entries for settled ops can never be read again
+        // (neither collection filter matches a settled op), so dropping them
+        // bounds the cache by the LIVE pending set instead of growing
+        // monotonically for the VM's lifetime — which matters for the inline
+        // loop's long-lived sessions and snapshot-restored VMs.
+        if (byteCache && dumped.settled.length > 0) {
+            for (const cid of dumped.settled) {
+                for (const field of RAW_PENDING_FIELDS) {
+                    byteCache.delete(`${cid}:${field}`);
+                }
+            }
+        }
+        const rawFields = __addDisposableResource(env_5, vm.evalCode('globalThis.__rawFields'), false);
+        for (const op of plainOps) {
+            const rawIndices = op.__rawIndices ?? {};
+            delete op.__rawIndices;
+            for (const field of RAW_PENDING_FIELDS) {
+                const index = rawIndices[field];
+                if (index === undefined)
+                    continue;
+                const cacheKey = `${op.correlationId}:${field}`;
+                let bytes = byteCache?.get(cacheKey);
+                if (!bytes) {
+                    const env_6 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        const valueHandle = __addDisposableResource(env_6, rawFields.getProp(String(index)), false);
+                        bytes = serde.serialize(valueHandle);
+                        byteCache?.set(cacheKey, bytes);
+                    }
+                    catch (e_5) {
+                        env_6.error = e_5;
+                        env_6.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_6);
+                    }
+                }
+                op[field] = bytes;
+            }
+        }
+        vm.evalCode('delete globalThis.__rawFields').dispose();
+        return plainOps;
+    }
+    catch (e_6) {
+        env_5.error = e_6;
+        env_5.hasError = true;
+    }
+    finally {
+        __disposeResources(env_5);
+    }
+}
+function collectDrainOperations(vm, serde) {
+    // Share the per-VM byte cache with the suspension path: an op that was
+    // serialized during a suspension pass must reuse those exact bytes at
+    // terminal drain — re-serializing can invoke getters again and produce
+    // a DIFFERENT byte sequence for what the event log treats as one value.
+    return dumpPendingOps(vm, serde, `(function(){
     var toDispose = [];
     globalThis.__pending.forEach(function(p){
       if (p.type === "hook" && p.isSystem && !p.abortRequested && !p.disposed) {
@@ -1796,64 +2189,111 @@ function collectDrainOperations(vm) {
       if (p.type === "hook" && p.disposed) return false;
       return true;
     });
-  })()`), false);
-        return vm.dump(h);
-    }
-    catch (e_3) {
-        env_3.error = e_3;
-        env_3.hasError = true;
-    }
-    finally {
-        __disposeResources(env_3);
-    }
+  })()`, ensurePendingByteCache(vm));
 }
-function checkWorkflowState(vm, opts = {}) {
-    // Check completed — __workflowResult is a format-prefixed Uint8Array
+function checkWorkflowState(vm, serde, opts = {}) {
+    // Check completed — __workflowResult holds the RAW return value (with a
+    // separate done flag so `undefined` results are distinguishable); the
+    // host serializes it through a handle.
     {
-        const env_4 = { stack: [], error: void 0, hasError: false };
+        const env_7 = { stack: [], error: void 0, hasError: false };
         try {
-            const h = __addDisposableResource(env_4, vm.evalCode('globalThis.__workflowResult'), false);
-            if (!h.isUndefined) {
-                const resultBytes = h.toUint8Array();
-                const drainOperations = collectDrainOperations(vm);
-                vm.dispose();
-                return {
-                    completed: {
-                        result: resultBytes,
-                        ...(drainOperations.length > 0 ? { drainOperations } : {}),
-                    },
-                };
+            const done = __addDisposableResource(env_7, vm.evalCode('globalThis.__workflowDone === true'), false);
+            if (done.toBoolean()) {
+                const env_8 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const h = __addDisposableResource(env_8, vm.evalCode('globalThis.__workflowResult'), false);
+                    const resultBytes = serde.serialize(h);
+                    const drainOperations = collectDrainOperations(vm, serde);
+                    vm.dispose();
+                    return {
+                        completed: {
+                            result: resultBytes,
+                            ...(drainOperations.length > 0 ? { drainOperations } : {}),
+                        },
+                    };
+                }
+                catch (e_7) {
+                    env_8.error = e_7;
+                    env_8.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_8);
+                }
             }
         }
-        catch (e_4) {
-            env_4.error = e_4;
-            env_4.hasError = true;
+        catch (e_8) {
+            env_7.error = e_8;
+            env_7.hasError = true;
         }
         finally {
-            __disposeResources(env_4);
+            __disposeResources(env_7);
         }
     }
     // Check failed
     {
-        const env_5 = { stack: [], error: void 0, hasError: false };
+        const env_9 = { stack: [], error: void 0, hasError: false };
         try {
-            const h = __addDisposableResource(env_5, vm.evalCode('globalThis.__workflowError'), false);
+            const h = __addDisposableResource(env_9, vm.evalCode('globalThis.__workflowError'), false);
             if (!h.isUndefined) {
-                const errorObj = vm.dump(h);
+                // The display fields are plain strings; the thrown value itself is
+                // RAW and serialized host-side through a handle.
+                const errorObj = h.isString
+                    ? h.toString()
+                    : (() => {
+                        const env_12 = { stack: [], error: void 0, hasError: false };
+                        try {
+                            const plain = __addDisposableResource(env_12, vm.evalCode('(function(e){return {message: e.message, stack: e.stack, name: e.name};})(globalThis.__workflowError)'), false);
+                            return vm.dump(plain);
+                        }
+                        catch (e_12) {
+                            env_12.error = e_12;
+                            env_12.hasError = true;
+                        }
+                        finally {
+                            __disposeResources(env_12);
+                        }
+                    })();
+                let valueBytes;
+                if (!h.isString) {
+                    const env_10 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        const rawValue = __addDisposableResource(env_10, h.getProp('value'), false);
+                        try {
+                            valueBytes = serde.serialize(rawValue);
+                        }
+                        catch (serializeErr) {
+                            // A thrown value the codec cannot serialize must not mask the
+                            // workflow failure itself — fall back to the display fields.
+                            runtimeLogger.warn('QuickJS runtime: failed to serialize thrown workflow error', {
+                                message: serializeErr instanceof Error
+                                    ? serializeErr.message
+                                    : String(serializeErr),
+                            });
+                        }
+                    }
+                    catch (e_9) {
+                        env_10.error = e_9;
+                        env_10.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_10);
+                    }
+                }
                 const failed = typeof errorObj === 'string'
                     ? { message: errorObj }
                     : {
                         message: errorObj.message,
                         stack: errorObj.stack || undefined,
                         name: errorObj.name || undefined,
-                        valueBytes: errorObj.valueBytes,
+                        valueBytes,
                     };
                 runtimeLogger.error('QuickJS runtime: workflow failed in VM', {
                     errorMessage: failed.message,
                     errorName: failed.name,
                     errorStack: failed.stack,
                 });
-                const drainOperations = collectDrainOperations(vm);
+                const drainOperations = collectDrainOperations(vm, serde);
                 vm.dispose();
                 return {
                     failed: {
@@ -1863,53 +2303,41 @@ function checkWorkflowState(vm, opts = {}) {
                 };
             }
         }
-        catch (e_5) {
-            env_5.error = e_5;
-            env_5.hasError = true;
+        catch (e_10) {
+            env_9.error = e_10;
+            env_9.hasError = true;
         }
         finally {
-            __disposeResources(env_5);
+            __disposeResources(env_9);
         }
     }
     // Check suspended — the workflow is suspended if there are active resolvers
     // OR pending operations that haven't been created yet (e.g. hooks created
     // upfront but not yet awaited)
     {
-        const env_6 = { stack: [], error: void 0, hasError: false };
+        const env_11 = { stack: [], error: void 0, hasError: false };
         try {
-            const h = __addDisposableResource(env_6, vm.evalCode('Object.keys(globalThis.__resolvers).length > 0 || globalThis.__pending.some(function(p){return!p.hasCreatedEvent;})'), false);
+            const h = __addDisposableResource(env_11, vm.evalCode('Object.keys(globalThis.__resolvers).length > 0 || globalThis.__pending.some(function(p){return!p.hasCreatedEvent;})'), false);
             if (vm.dump(h)) {
-                const env_7 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const pendingH = __addDisposableResource(env_7, vm.evalCode(
-                    // Ops with an active resolver or without a created event are
-                    // pending; abort-requested hooks are also surfaced (even when
-                    // already created and unawaited) so the host records the abort.
-                    `globalThis.__pending.filter(function(p){return!!globalThis.__resolvers[p.correlationId] || !p.hasCreatedEvent || p.abortRequested;})`), false);
-                    const pendingOps = vm.dump(pendingH);
-                    if (!opts.keepAliveOnSuspend)
-                        vm.dispose();
-                    return {
-                        suspended: {
-                            pendingOperations: pendingOps,
-                        },
-                    };
-                }
-                catch (e_6) {
-                    env_7.error = e_6;
-                    env_7.hasError = true;
-                }
-                finally {
-                    __disposeResources(env_7);
-                }
+                // Ops with an active resolver or without a created event are
+                // pending; abort-requested hooks are also surfaced (even when
+                // already created and unawaited) so the host records the abort.
+                const pendingOps = dumpPendingOps(vm, serde, `globalThis.__pending.filter(function(p){return!!globalThis.__resolvers[p.correlationId] || !p.hasCreatedEvent || p.abortRequested;})`, ensurePendingByteCache(vm));
+                if (!opts.keepAliveOnSuspend)
+                    vm.dispose();
+                return {
+                    suspended: {
+                        pendingOperations: pendingOps,
+                    },
+                };
             }
         }
-        catch (e_7) {
-            env_6.error = e_7;
-            env_6.hasError = true;
+        catch (e_11) {
+            env_11.error = e_11;
+            env_11.hasError = true;
         }
         finally {
-            __disposeResources(env_6);
+            __disposeResources(env_11);
         }
     }
     vm.dispose();
@@ -1941,4 +2369,4 @@ function createInterruptHandler(budget) {
     const timeout = getReplayTimeoutMs();
     return () => Date.now() - budget.start > timeout;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quickjs-runtime.js","sourceRoot":"","sources":["../../src/runtime/quickjs-runtime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * QuickJS WASM workflow VM.\n *\n * An alternative engine for the event-replay execution model: the workflow\n * code runs inside a QuickJS WASM VM (via quickjs-wasi) instead of a\n * `node:vm` context. Every invocation creates a fresh VM, re-executes the\n * workflow function from the top, and replays the recorded event log to\n * resolve awaited primitives — the same replay semantics as the `node:vm`\n * engine.\n *\n * The workflow primitives (useStep, sleep, createHook) are implemented as\n * JavaScript code running inside the QuickJS VM. The host communicates with\n * the VM by evaluating small JS snippets to read pending operations and\n * resolve/reject promises.\n *\n * The VM bootstrap is deliberately split into two phases:\n *   1. Static initialization (`initWorkflowVM`) — run-independent setup:\n *      VM creation, the serde bundle, and the workflow primitives.\n *   2. Per-run initialization (inline in `runQuickJSWorkflow`) — seeded\n *      PRNG/ULID host functions, workflow bundle evaluation, run metadata,\n *      workflow input, and start.\n * Keeping the phases separate is groundwork for VM-memory snapshotting:\n * a follow-up can persist/restore the VM at the phase boundary (e.g. a\n * build-time initial snapshot) without restructuring this module. Note\n * that bundle evaluation currently sits in the per-run phase so that\n * module-scope user code observes the seeded `Math.random`, matching the\n * `node:vm` engine's replay determinism.\n */\n\nimport type {\n  Event,\n  RunInput,\n  WorkflowRun,\n  WorldCapabilities,\n} from '@workflow/world';\nimport * as nanoid from 'nanoid';\nimport {\n  type ExtensionDescriptor,\n  JSException,\n  QuickJS,\n  type WasiOptions,\n} from 'quickjs-wasi';\nimport seedrandom from 'seedrandom';\nimport { runtimeLogger } from '../logger.js';\nimport { decompress } from '../serialization/compression.js';\nimport type { DecryptionKey } from '../serialization/encryption.js';\nimport { decrypt } from '../serialization/encryption.js';\nimport { getReplayTimeoutMs } from './constants.js';\nimport { quickjsExtensions, quickjsWasm } from './quickjs-assets.generated.js';\nimport { runIdCreatedAt } from './run-id-time.js';\nimport { VM_SERDE_BUNDLE } from './vm-serde-bundle.generated.js';\n\n// ---- Host -> VM payload preparation ----\n\n/**\n * Prepare persisted payload bytes for consumption inside the VM: decrypt\n * (when an encryption key is configured) and decompress (specVersion >= 5\n * payloads may be gzip/zstd-compressed). The VM only understands plain\n * format-prefixed 'devl' bytes — it has neither the key material nor zlib.\n * The key is the run's full DecryptionKey capability (symmetric AES key +\n * X25519 keypair) so sealed `encp` hook payloads from cross-deployment\n * resumeHook() calls open here too, not just symmetric `encr` ones.\n * Both stages are format-prefix dispatched, so plaintext/uncompressed\n * data passes through unchanged. Mirrors `prepareReplayPayload` in\n * serialization.ts (the node:vm engine's equivalent host-side stage).\n */\nasync function prepareBytesForVM(\n  data: Uint8Array,\n  key?: DecryptionKey\n): Promise<Uint8Array> {\n  return (await decompress(await decrypt(data, key))) as Uint8Array;\n}\n\n// ---- Types ----\n\nexport interface PendingStep {\n  type: 'step';\n  correlationId: string;\n  stepId: string;\n  /** Format-prefixed devalue-serialized step input (args + closureVars) */\n  input: Uint8Array;\n  /** Whether a step_created event already exists for this step */\n  hasCreatedEvent: boolean;\n}\n\nexport interface PendingWait {\n  type: 'wait';\n  correlationId: string;\n  /** ISO string of when to resume */\n  resumeAt: string;\n  /** Whether a wait_created event already exists for this wait */\n  hasCreatedEvent: boolean;\n}\n\nexport interface PendingHook {\n  type: 'hook';\n  correlationId: string;\n  token: string;\n  /** Earliest token reuse time, as milliseconds since the Unix epoch. */\n  tokenRetentionUntil?: number;\n  isWebhook: boolean;\n  metadata?: unknown;\n  hasCreatedEvent: boolean;\n  /**\n   * True for internal system hooks (e.g. AbortController's hook), which\n   * are exempt from user-hook token namespace conflict checks.\n   */\n  isSystem?: boolean;\n  /**\n   * Set when the workflow called AbortController.abort() during this\n   * invocation. The host must record the abort: create a hook_received\n   * event carrying `abortPayload` and write/close the abort stream.\n   */\n  abortRequested?: boolean;\n  /** VM-serialized `{ aborted: true, reason }` payload for the abort. */\n  abortPayload?: Uint8Array;\n  /** Set by the completion drain when a system hook is implicitly disposed. */\n  disposed?: boolean;\n  /**\n   * True when the workflow is awaiting hook.getConflict() for this hook.\n   * The entrypoint re-invokes the workflow right after writing\n   * hook_created so replay can confirm creation and resolve the awaiter.\n   */\n  hasGetConflictAwaiter?: boolean;\n}\n\nexport interface PendingAttribute {\n  type: 'attribute';\n  correlationId: string;\n  /** Normalized attribute changes (plain JSON-able objects) */\n  changes: unknown[];\n  allowReservedAttributes?: boolean;\n  /** Whether an attr_set event already exists for this write */\n  hasCreatedEvent: boolean;\n}\n\nexport interface PendingHookDispose {\n  type: 'hook_dispose';\n  correlationId: string;\n  /**\n   * Token of the hook being disposed. Used by the entrypoint to order\n   * same-token hook operations sequentially in code order.\n   */\n  token?: string;\n  hasCreatedEvent: boolean;\n}\n\nexport type PendingOperation =\n  | PendingStep\n  | PendingWait\n  | PendingHook\n  | PendingAttribute\n  | PendingHookDispose;\n\nexport interface QuickJSRuntimeResult {\n  /** The workflow completed — result is format-prefixed devalue bytes */\n  completed?: {\n    result: Uint8Array;\n    /**\n     * Leftover pending operations that still need durable side effects at\n     * completion: abort recordings, system-hook disposals, fire-and-forget\n     * attribute/hook/step events. Mirrors the node:vm engine's\n     * drainPendingQueueItems. The entrypoint dispatches these WITHOUT\n     * queueing steps or requeuing the run.\n     */\n    drainOperations?: PendingOperation[];\n  };\n  /** The workflow suspended with pending operations */\n  suspended?: {\n    pendingOperations: PendingOperation[];\n  };\n  /** The workflow failed */\n  failed?: {\n    message: string;\n    stack?: string;\n    name?: string;\n    /** See completed.drainOperations — same semantics on failure. */\n    drainOperations?: PendingOperation[];\n    /**\n     * Format-prefixed devalue bytes of the original thrown value\n     * (Error subclass with cause chain, plain object, primitive, etc.).\n     * Set when the VM-side rejection handler successfully serializes\n     * the thrown value. The host uses these bytes to reconstruct the\n     * original value through the standard error hydration pipeline,\n     * preserving type identity (TypeError, FatalError) and non-Error\n     * throws verbatim. Falls back to the message/stack/name fields\n     * when this is undefined (e.g. extractError pseudo-failures).\n     */\n    valueBytes?: Uint8Array;\n  };\n}\n\nexport interface QuickJSRuntimeOptions {\n  /** The compiled workflow bundle code (workflow mode output from SWC) */\n  workflowCode: string;\n  /** The workflow ID (e.g. \"workflow//./workflows/1_simple//simple\") */\n  workflowId: string;\n  /** The workflow run entity */\n  workflowRun: WorkflowRun;\n  /** Features supported by the World executing this workflow. */\n  worldCapabilities?: WorldCapabilities;\n  /**\n   * The full event log for the run. Every invocation replays the complete\n   * log from the start (same replay semantics as the `node:vm` engine).\n   */\n  events: Event[];\n  /** Encryption key for decrypting event payloads (undefined if unencrypted) */\n  encryptionKey?: DecryptionKey;\n  /**\n   * The local port the workflow server is listening on, used to populate\n   * `workflowMetadata.url`. Resolved at call time on the host side so the\n   * VM doesn't have to probe the filesystem. Ignored on Vercel — VERCEL_URL\n   * takes precedence there.\n   */\n  port?: number;\n  /**\n   * Fallback workflow input from the queue message's resilient-start\n   * payload. Used when the fetched event log lacks a `run_created` event\n   * (eventually-consistent read after the parent's start() wrote it).\n   */\n  runInput?: RunInput;\n}\n\n// ---- VM Bootstrap Code ----\n\n/**\n * JavaScript code that runs inside the QuickJS VM to set up the workflow\n * primitives. This sets up:\n * - globalThis.__private_workflows (Map) - workflow registry\n * - globalThis.__resolvers (Object) - pending promise resolve/reject functions\n * - globalThis.__pending (Array) - metadata about pending operations\n * - globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")] - step proxy factory\n * - globalThis[Symbol.for(\"WORKFLOW_SLEEP\")] - sleep function\n */\nconst VM_BOOTSTRAP = `\n// Symbol.dispose / Symbol.asyncDispose polyfills for QuickJS\nif (typeof Symbol.dispose === \"undefined\") {\n  Symbol.dispose = Symbol.for(\"Symbol.dispose\");\n}\nif (typeof Symbol.asyncDispose === \"undefined\") {\n  Symbol.asyncDispose = Symbol.for(\"Symbol.asyncDispose\");\n}\n\nglobalThis.__private_workflows = new Map();\nglobalThis.__resolvers = {};\nglobalThis.__pending = [];\nglobalThis.__workflowResult = undefined;\nglobalThis.__workflowError = undefined;\n// Buffer for hook_received payloads that arrive before the hook is awaited.\n// Keyed by correlationId → array of payloads (preserves delivery order).\n// This mirrors the event-replay runtime's payloadsQueue in hook.ts.\nglobalThis.__hookPayloadBuffer = {};\n\n// Buffer for step/wait/attr terminal outcomes that arrive before this VM\n// has constructed the corresponding awaiting promise. In fresh-VM replay\n// the multi-pass event scan makes this unreachable (awaits are\n// reconstructed before their terminals are re-scanned), but the live\n// continuation path (continueWithEvents) scans each delta exactly once —\n// a concurrent invocation's terminal arriving before this VM reaches the\n// await would otherwise be dropped on the floor and the await would\n// never settle (the feed's seen-set means it is never re-delivered).\n// Mirrors __hookPayloadBuffer, which exists for exactly this reason on\n// the hook path. Keyed by correlationId → single terminal (steps, waits\n// and attrs settle exactly once).\nglobalThis.__terminalBuffer = {};\n\n// Registers a resolver for an awaited primitive, first draining any\n// buffered terminal recorded for the correlationId. Entries are prepared\n// host-side (bytes already decrypted; see processEvents).\nglobalThis.__registerResolver = function(correlationId, resolve, reject) {\n  var buffered = globalThis.__terminalBuffer[correlationId];\n  if (buffered) {\n    delete globalThis.__terminalBuffer[correlationId];\n    if (buffered.kind === \"resolve_bytes\") {\n      resolve(globalThis[Symbol.for(\"workflow-deserialize\")](buffered.bytes));\n    } else if (buffered.kind === \"resolve_value\") {\n      resolve(buffered.value);\n    } else if (buffered.kind === \"reject_bytes\") {\n      reject(globalThis[Symbol.for(\"workflow-deserialize\")](buffered.bytes));\n    } else if (buffered.kind === \"reject_error\") {\n      var e = new Error(buffered.message);\n      e.name = \"FatalError\";\n      e.fatal = true;\n      if (buffered.stack) e.stack = buffered.stack;\n      reject(e);\n    } else {\n      resolve(undefined);\n    }\n    return;\n  }\n  globalThis.__resolvers[correlationId] = { resolve: resolve, reject: reject };\n};\n\n// Stubs for Web APIs that the workflow bundle may reference but are not\n// available in QuickJS. Native C extensions (encoding, headers, url,\n// structured-clone) provide the real implementations; these are minimal\n// stubs for APIs that don't have native extensions yet. (btoa/atob and\n// the Uint8Array base64/hex methods are built into quickjs-wasi >= 3.)\n\nif (typeof ReadableStream === \"undefined\") {\n  // Minimal ReadableStream that stores body data for Response.json()/text()\n  globalThis.ReadableStream = function() {};\n  globalThis.ReadableStream.prototype.__bodyData = null;\n}\n\nif (typeof WritableStream === \"undefined\") {\n  globalThis.WritableStream = function() {};\n}\n\nif (typeof TransformStream === \"undefined\") {\n  globalThis.TransformStream = function() {};\n}\n\nif (typeof console === \"undefined\") {\n  globalThis.console = { log: function(){}, error: function(){}, warn: function(){}, info: function(){} };\n}\n// Stub exports/module for CJS bundle format\nglobalThis.exports = {};\nglobalThis.module = { exports: globalThis.exports };\n// NOTE: TextEncoder/TextDecoder are provided by the native encoding extension.\n\n// ---- Deterministic \\`crypto\\` (parity with the node:vm engine) ----\n// getRandomValues / randomUUID draw from Math.random, which the host\n// replaces with the run's seeded PRNG before any user code runs — so the\n// values replay deterministically and match the node engine, whose\n// implementations draw from the same seeded sequence (see vm/index.ts).\n// Every crypto.subtle method throws with the same guidance as the node\n// engine's non-replayable methods; unlike node, \\`digest\\` is also\n// unavailable here (no native hash in the VM yet).\n(function() {\n  function getRandomValues(array) {\n    for (var i = 0; i < array.length; i++) {\n      array[i] = Math.floor(Math.random() * 256);\n    }\n    return array;\n  }\n  // Mirrors vm/uuid.ts createRandomUUID: identical draw pattern from the\n  // seeded PRNG, so both engines produce the same UUID at the same point\n  // in a replay.\n  function randomUUID() {\n    var chars = \"0123456789abcdef\";\n    var uuid = \"\";\n    for (var i = 0; i < 36; i++) {\n      if (i === 8 || i === 13 || i === 18 || i === 23) {\n        uuid += \"-\";\n      } else if (i === 14) {\n        uuid += \"4\";\n      } else if (i === 19) {\n        uuid += chars[Math.floor(Math.random() * 4) + 8];\n      } else {\n        uuid += chars[Math.floor(Math.random() * 16)];\n      }\n    }\n    return uuid;\n  }\n  function subtleThrow(name) {\n    return function() {\n      var err = new Error(\"\\`crypto.subtle.\" + name + \"()\\` is not available inside a workflow function. Move it to a step function where full Node.js crypto is available.\");\n      err.name = \"WorkflowRuntimeError\";\n      throw err;\n    };\n  }\n  var subtle = {};\n  [\"encrypt\",\"decrypt\",\"sign\",\"verify\",\"digest\",\"generateKey\",\"deriveKey\",\"deriveBits\",\"importKey\",\"exportKey\",\"wrapKey\",\"unwrapKey\"].forEach(function(m) {\n    subtle[m] = subtleThrow(m);\n  });\n  globalThis.crypto = {\n    getRandomValues: getRandomValues,\n    randomUUID: randomUUID,\n    subtle: subtle,\n  };\n})();\n\n// ---- Loud Intl / locale guards ----\n// QuickJS has no ICU: \\`Intl\\` is absent and toLocaleString-family methods\n// silently ignore their locale argument. Silent divergence from the node\n// engine would write different values into a durable event log with no\n// error anywhere — so make the gap loud instead: Intl constructors throw,\n// and toLocale* methods throw ONLY when called with an explicit locale\n// (the no-argument forms keep QuickJS's default behavior).\n(function() {\n  function intlThrow(name) {\n    return function() {\n      var err = new Error(\"\\`Intl.\" + name + \"\\` is not available in the QuickJS workflow engine (no ICU). Perform locale-sensitive formatting in a step function, or use WORKFLOW_VM=node.\");\n      err.name = \"WorkflowRuntimeError\";\n      throw err;\n    };\n  }\n  if (typeof Intl === \"undefined\") {\n    var intl = {};\n    [\"Collator\",\"DateTimeFormat\",\"DisplayNames\",\"DurationFormat\",\"ListFormat\",\"Locale\",\"NumberFormat\",\"PluralRules\",\"RelativeTimeFormat\",\"Segmenter\"].forEach(function(n) {\n      intl[n] = intlThrow(n);\n    });\n    intl.getCanonicalLocales = intlThrow(\"getCanonicalLocales\");\n    globalThis.Intl = intl;\n  }\n  function guardLocale(proto, method) {\n    var original = proto[method];\n    if (typeof original !== \"function\") return;\n    proto[method] = function(locales) {\n      if (locales !== undefined) {\n        var err = new Error(\"\\`\" + method + \"(locales, ...)\\` with an explicit locale is not supported in the QuickJS workflow engine (no ICU) — it would silently ignore the locale. Format in a step function, or call without arguments for the engine default.\");\n        err.name = \"WorkflowRuntimeError\";\n        throw err;\n      }\n      return original.call(this);\n    };\n  }\n  guardLocale(Number.prototype, \"toLocaleString\");\n  guardLocale(Date.prototype, \"toLocaleString\");\n  guardLocale(Date.prototype, \"toLocaleDateString\");\n  guardLocale(Date.prototype, \"toLocaleTimeString\");\n  guardLocale(String.prototype, \"toLocaleLowerCase\");\n  guardLocale(String.prototype, \"toLocaleUpperCase\");\n  // localeCompare's locales argument is the SECOND parameter.\n  (function() {\n    var original = String.prototype.localeCompare;\n    String.prototype.localeCompare = function(that, locales) {\n      if (locales !== undefined) {\n        var err = new Error(\"\\`localeCompare(that, locales, ...)\\` with an explicit locale is not supported in the QuickJS workflow engine (no ICU). Compare in a step function, or call without a locale.\");\n        err.name = \"WorkflowRuntimeError\";\n        throw err;\n      }\n      return original.call(this, that);\n    };\n  })();\n})();\n\nglobalThis[Symbol.for(\"WORKFLOW_USE_STEP\")] = function(stepId, closureVarsFn) {\n  var fn = function() {\n    var args = Array.prototype.slice.call(arguments);\n    var correlationId = \"step_\" + globalThis.__generateUlid();\n    // Capture 'this' for method invocations (e.g., MyClass.method())\n    var thisVal = (this !== undefined && this !== null && this !== globalThis) ? this : undefined;\n    // Serialize step input using the host-provided devalue serializer.\n    // This produces a format-prefixed Uint8Array (\"devl\" + devalue.stringify).\n    var input = globalThis[Symbol.for(\"workflow-serialize\")]({\n      args: args,\n      closureVars: closureVarsFn ? closureVarsFn() : undefined,\n      thisVal: thisVal,\n    });\n    globalThis.__pending.push({\n      type: \"step\",\n      correlationId: correlationId,\n      stepId: stepId,\n      input: input,\n      hasCreatedEvent: false,\n    });\n    return new Promise(function(resolve, reject) {\n      globalThis.__registerResolver(correlationId, resolve, reject);\n    });\n  };\n  // Set stepId on the proxy so the StepFunction reducer can detect and\n  // serialize step function references (e.g. when passed as arguments).\n  fn.stepId = stepId;\n  if (closureVarsFn) fn.__closureVarsFn = closureVarsFn;\n  // Override .bind so a bound step proxy (e.g. the SWC plugin's\n  // useStep(...).bind(this) for lexical-this arrow steps) keeps its\n  // stepId and records the bound receiver / prefilled args — the native\n  // bind drops own properties, which would make the StepFunction\n  // reducer fail to recognize the proxy when it crosses a serialization\n  // boundary. Mirrors the node:vm engine's override in step.ts.\n  fn.bind = function(thisArg) {\n    var partialArgs = Array.prototype.slice.call(arguments, 1);\n    var bound = Function.prototype.bind.apply(this, [thisArg].concat(partialArgs));\n    bound.stepId = stepId;\n    if (closureVarsFn) bound.__closureVarsFn = closureVarsFn;\n    bound.__boundThis = thisArg;\n    if (partialArgs.length > 0) bound.__boundArgs = partialArgs;\n    return bound;\n  };\n  return fn;\n};\n\n// Parses an \"ms\" library style duration string into milliseconds.\n// Supports the same units as the replay runtime (which uses the \"ms\"\n// package): ms / s / m / h / d / w / y, with verbose aliases\n// (seconds, minutes, ...).\nglobalThis.__parseDurationMs = function(str) {\n  str = String(str);\n  if (str.length > 100) return undefined;\n  var match = str.match(\n    /^(-?(?:\\\\d+)?\\\\.?\\\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i\n  );\n  if (!match) return undefined;\n  var n = parseFloat(match[1]);\n  var type = (match[2] || \"ms\").toLowerCase();\n  var s = 1000, m = 60 * s, h = 60 * m, d = 24 * h, w = 7 * d, y = 365.25 * d;\n  switch (type) {\n    case \"years\": case \"year\": case \"yrs\": case \"yr\": case \"y\": return n * y;\n    case \"weeks\": case \"week\": case \"w\": return n * w;\n    case \"days\": case \"day\": case \"d\": return n * d;\n    case \"hours\": case \"hour\": case \"hrs\": case \"hr\": case \"h\": return n * h;\n    case \"minutes\": case \"minute\": case \"mins\": case \"min\": case \"m\": return n * m;\n    case \"seconds\": case \"second\": case \"secs\": case \"sec\": case \"s\": return n * s;\n    case \"milliseconds\": case \"millisecond\": case \"msecs\": case \"msec\": case \"ms\": return n;\n    default: return undefined;\n  }\n};\n\nglobalThis[Symbol.for(\"WORKFLOW_SLEEP\")] = function(param) {\n  var correlationId = \"wait_\" + globalThis.__generateUlid();\n  var resumeAt;\n  if (typeof param === \"number\") {\n    resumeAt = new Date(Date.now() + param).toISOString();\n  } else if (typeof param === \"string\") {\n    var ms = globalThis.__parseDurationMs(param);\n    if (typeof ms === \"number\" && isFinite(ms)) {\n      resumeAt = new Date(Date.now() + ms).toISOString();\n    } else {\n      // Not a duration string — try as an absolute date string.\n      var date = new Date(param);\n      if (isNaN(date.getTime())) {\n        throw new Error(\"Invalid sleep parameter: \" + param);\n      }\n      resumeAt = date.toISOString();\n    }\n  } else if (param instanceof Date) {\n    if (isNaN(param.getTime())) {\n      throw new Error(\"Invalid sleep parameter: \" + param);\n    }\n    resumeAt = param.toISOString();\n  } else {\n    throw new Error(\"Invalid sleep parameter: \" + param);\n  }\n  globalThis.__pending.push({\n    type: \"wait\",\n    correlationId: correlationId,\n    resumeAt: resumeAt,\n    hasCreatedEvent: false,\n  });\n  return new Promise(function(resolve, reject) {\n    globalThis.__registerResolver(correlationId, resolve, reject);\n  });\n};\n\n// Response/Request polyfills — .json()/.text()/.arrayBuffer() are useStep\n// proxies that execute on the host side. The proxies are assigned directly\n// to the prototypes so that 'this' (the Response/Request instance) is\n// serialized as thisVal by WORKFLOW_USE_STEP, matching the event-replay\n// runtime's approach (commit dcb0761).\nif (typeof Response === \"undefined\") {\n  var __BODY_INIT = Symbol.for(\"BODY_INIT\");\n\n  globalThis.Response = function(body, init) {\n    init = init || {};\n    this.status = init.status || 200;\n    this.statusText = init.statusText || \"\";\n    this.headers = new globalThis.Headers(init.headers || []);\n    this.type = \"default\";\n    this.url = \"\";\n    this.redirected = false;\n    if (body !== null && body !== undefined) {\n      this.body = Object.create(globalThis.ReadableStream.prototype);\n      this.body[__BODY_INIT] = body;\n    } else {\n      this.body = null;\n    }\n  };\n  Object.defineProperty(globalThis.Response.prototype, \"ok\", {\n    get: function() { return this.status >= 200 && this.status < 300; }\n  });\n  Object.defineProperty(globalThis.Response.prototype, \"bodyUsed\", {\n    get: function() { return false; }\n  });\n  // Assign useStep proxies directly — 'this' binding provides the\n  // Response instance, which gets serialized as thisVal by the proxy.\n  Object.defineProperties(globalThis.Response.prototype, {\n    arrayBuffer: { value: globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"__builtin_response_array_buffer\"), writable: true, configurable: true },\n    json: { value: globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"__builtin_response_json\"), writable: true, configurable: true },\n    text: { value: globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"__builtin_response_text\"), writable: true, configurable: true },\n  });\n  globalThis.Response.prototype.bytes = function() {\n    return this.arrayBuffer().then(function(buf) { return new Uint8Array(buf); });\n  };\n  globalThis.Response.prototype.clone = function() {\n    var r = Object.create(globalThis.Response.prototype);\n    r.status = this.status; r.statusText = this.statusText;\n    r.headers = this.headers; r.type = this.type;\n    r.url = this.url; r.redirected = this.redirected; r.body = this.body;\n    return r;\n  };\n  globalThis.Response.json = function(data, init) {\n    var body = JSON.stringify(data);\n    var headers = new globalThis.Headers(init ? init.headers : []);\n    if (!headers.has(\"content-type\")) { headers.set(\"content-type\", \"application/json\"); }\n    return new globalThis.Response(body, { status: (init && init.status) || 200, statusText: (init && init.statusText) || \"\", headers: headers });\n  };\n}\nif (typeof Request === \"undefined\") {\n  globalThis.Request = function(input, init) {\n    init = init || {};\n    if (typeof input === \"string\") { this.url = input; }\n    else if (input && typeof input === \"object\") {\n      this.url = input.url || \"\"; this.method = input.method;\n      this.headers = input.headers; this.body = input.body;\n    }\n    if (init.method) this.method = init.method.toUpperCase();\n    if (!this.method) this.method = \"GET\";\n    if (init.headers) this.headers = new globalThis.Headers(init.headers);\n    if (!this.headers) this.headers = new globalThis.Headers();\n    if (init.body !== undefined) this.body = init.body;\n    if (!this.body) this.body = null;\n    this.duplex = init.duplex || \"half\";\n  };\n  Object.defineProperty(globalThis.Request.prototype, \"bodyUsed\", {\n    get: function() { return false; }\n  });\n  Object.defineProperties(globalThis.Request.prototype, {\n    arrayBuffer: { value: globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"__builtin_response_array_buffer\"), writable: true, configurable: true },\n    json: { value: globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"__builtin_response_json\"), writable: true, configurable: true },\n    text: { value: globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"__builtin_response_text\"), writable: true, configurable: true },\n  });\n}\n\n// createHook — returns a Hook object that is both a Thenable and AsyncIterable.\n// Each await/yield creates a new promise keyed by the same correlationId.\n// The promise is resolved when a hook_received event arrives.\nglobalThis[Symbol.for(\"WORKFLOW_CREATE_HOOK\")] = function(options) {\n  options = options || {};\n  if (options.isWebhook === true && options.experimental_minRetention !== undefined) {\n    throw new Error('Webhook hooks do not support \\`experimental_minRetention\\`. Use a non-webhook \\`createHook()\\` with \\`resumeHook()\\`.');\n  }\n  if (options.experimental_minRetention !== undefined && globalThis.__worldCapabilities?.hookRetention?.active !== true) {\n    var unsupportedRetentionError = new Error('The configured World does not support \\`experimental_minRetention\\` for Hooks.');\n    unsupportedRetentionError.name = \"FatalError\";\n    unsupportedRetentionError.fatal = true;\n    throw unsupportedRetentionError;\n  }\n  var token = options.token || globalThis.__generateNanoid();\n  var correlationId = \"hook_\" + globalThis.__generateUlid();\n  var isDisposed = false;\n  var hasCreatedEvent = false;\n  var tokenRetentionUntil;\n  if (options.experimental_minRetention !== undefined) {\n    var minRetention = options.experimental_minRetention;\n    if (typeof minRetention === \"number\") {\n      if (minRetention < 0 || !isFinite(minRetention)) {\n        throw new Error(\"Invalid duration: \" + minRetention + \". Expected a non-negative finite number of milliseconds.\");\n      }\n      tokenRetentionUntil = Date.now() + minRetention;\n    } else if (typeof minRetention === \"string\") {\n      var retentionMs = globalThis.__parseDurationMs(minRetention);\n      if (typeof retentionMs !== \"number\" || retentionMs < 0 || !isFinite(retentionMs)) {\n        throw new Error('Invalid duration: \"' + minRetention + '\". Expected a valid duration string like \"1s\", \"1m\", \"1h\", etc.');\n      }\n      tokenRetentionUntil = Date.now() + retentionMs;\n    } else if (minRetention instanceof Date || (minRetention && typeof minRetention.getTime === \"function\")) {\n      // Accept Date-like objects (anything with getTime), matching\n      // parseDurationToDate: values that crossed the serde boundary may\n      // not be realm-native Date instances.\n      tokenRetentionUntil = minRetention.getTime();\n    } else {\n      throw new Error(\"Invalid duration parameter. Expected a duration string, number (milliseconds), or Date object.\");\n    }\n  }\n\n  // Register in pending operations.\n  // Serialize metadata inside the VM so Response/Request objects are\n  // properly handled by the devalue reducers before crossing the boundary.\n  var pendingOp = {\n    type: \"hook\",\n    correlationId: correlationId,\n    token: token,\n    tokenRetentionUntil: tokenRetentionUntil,\n    isWebhook: !!options.isWebhook,\n    metadata: options.metadata ? globalThis[Symbol.for(\"workflow-serialize\")](options.metadata) : undefined,\n    hasCreatedEvent: false,\n  };\n  globalThis.__pending.push(pendingOp);\n\n  // Per-hook lifecycle state backing hook.getConflict(): resolves null\n  // once creation is confirmed (hook_created), or resolves with the\n  // conflicting Run handle / rejects with HookConflictError on\n  // hook_conflict. State transitions are driven by the host during event\n  // processing (see processEvents).\n  globalThis.__hooks = globalThis.__hooks || {};\n  globalThis.__hooks[correlationId] = {\n    token: token,\n    created: false,\n    conflict: null,\n    getConflictResolvers: [],\n  };\n\n  // Each await creates a new promise for the next payload.\n  // The correlationId stays the same — the resolver is replaced each time.\n  function createHookPromise() {\n    // Check the payload buffer first — if a hook_received event arrived\n    // before this hook was awaited, the payload was buffered in the VM\n    // heap. Drain it immediately (matching event-replay payloadsQueue).\n    var buf = globalThis.__hookPayloadBuffer[correlationId];\n    if (buf && buf.length > 0) {\n      return Promise.resolve(buf.shift());\n    }\n    return new Promise(function(resolve, reject) {\n      globalThis.__resolvers[correlationId] = { resolve: resolve, reject: reject };\n    });\n  }\n\n  function disposeHook() {\n    if (isDisposed) return;\n    isDisposed = true;\n    // A conflicted hook was never created (the world rejected its claim\n    // — the token belongs to another run), so there is no entity to\n    // dispose. Mirrors the node:vm engine, where hook_conflict removes\n    // the invocation-queue item before dispose can mark it. Emitting a\n    // hook_disposed here would be rejected by the world's\n    // hook-existence validation.\n    var state = globalThis.__hooks[correlationId];\n    if (!state || !state.conflict) {\n      // Signal to the entrypoint to create a hook_disposed event. The\n      // token is carried so the entrypoint can order same-token hook\n      // operations sequentially (a dispose must release the token before\n      // a later same-token hook's creation is validated).\n      globalThis.__pending.push({\n        type: \"hook_dispose\",\n        correlationId: correlationId,\n        token: token,\n        hasCreatedEvent: false,\n      });\n    }\n    // If there's a pending resolver, resolve it with undefined to break the iterator\n    if (globalThis.__resolvers[correlationId]) {\n      globalThis.__resolvers[correlationId].resolve(undefined);\n      delete globalThis.__resolvers[correlationId];\n    }\n  }\n\n  function getConflict() {\n    var state = globalThis.__hooks[correlationId];\n    if (state.conflict) {\n      return state.conflict.run\n        ? Promise.resolve(state.conflict.run)\n        : Promise.reject(state.conflict.error);\n    }\n    if (state.created) {\n      return Promise.resolve(null);\n    }\n    // Creation not yet confirmed by the event log — park the awaiter and\n    // flag the pending op so the entrypoint re-invokes the workflow right\n    // after writing hook_created (nothing external resumes a getConflict\n    // awaiter; confirmation only comes from replaying the new event).\n    pendingOp.hasGetConflictAwaiter = true;\n    return new Promise(function(resolve, reject) {\n      state.getConflictResolvers.push({ resolve: resolve, reject: reject });\n    });\n  }\n\n  var hook = {\n    token: token,\n    then: function(onFulfilled, onRejected) {\n      return createHookPromise().then(onFulfilled, onRejected);\n    },\n    getConflict: getConflict,\n    dispose: disposeHook,\n  };\n\n  // Symbol.dispose for explicit resource management\n  hook[Symbol.dispose] = disposeHook;\n\n  // AsyncIterable — yields payloads until disposed\n  hook[Symbol.asyncIterator] = function() {\n    return {\n      next: function() {\n        if (isDisposed) {\n          return Promise.resolve({ done: true, value: undefined });\n        }\n        return createHookPromise().then(function(value) {\n          // If disposed while waiting, signal done\n          if (isDisposed) return { done: true, value: undefined };\n          return { done: false, value: value };\n        });\n      },\n      return: function() {\n        disposeHook();\n        return Promise.resolve({ done: true, value: undefined });\n      },\n    };\n  };\n\n  return hook;\n};\n\n// setAttributes — attaches plaintext metadata to the current run.\n// Validation happens in library code (normalizeAttributeChanges) before\n// this dispatcher is invoked, so \"changes\" is already normalized. The\n// returned promise resolves when the matching attr_set event is\n// observed during event processing — mirroring the node:vm engine's\n// createSetAttributes (attribute-dispatcher.ts).\nglobalThis[Symbol.for(\"WORKFLOW_SET_ATTRIBUTES\")] = function(changes, options) {\n  var correlationId = \"attr_\" + globalThis.__generateUlid();\n  globalThis.__pending.push({\n    type: \"attribute\",\n    correlationId: correlationId,\n    changes: changes,\n    allowReservedAttributes: !!(options && options.allowReservedAttributes),\n    hasCreatedEvent: false,\n  });\n  return new Promise(function(resolve, reject) {\n    globalThis.__registerResolver(correlationId, resolve, reject);\n  });\n};\n\n// ---- AbortController / AbortSignal (hook-backed) ----\n// Port of workflow/abort-controller.ts to the VM pending-op model:\n// the controller registers a system hook; abort() flips the signal\n// synchronously and marks the pending op so the host records the abort\n// (hook_received event + stream packet). On replay, the recorded\n// hook_received event calls _setAborted during event processing and the\n// workflow's own abort() call becomes a no-op.\nvar __ABORT_STREAM_NAME = Symbol.for(\"WORKFLOW_ABORT_STREAM_NAME\");\nvar __ABORT_HOOK_TOKEN = Symbol.for(\"WORKFLOW_ABORT_HOOK_TOKEN\");\n\nfunction __makeAbortError() {\n  if (typeof DOMException !== \"undefined\") {\n    return new DOMException(\"The operation was aborted.\", \"AbortError\");\n  }\n  var e = new Error(\"The operation was aborted.\");\n  e.name = \"AbortError\";\n  return e;\n}\n\nfunction WorkflowAbortSignal(streamName, hookToken) {\n  this.aborted = false;\n  this.reason = undefined;\n  this[__ABORT_STREAM_NAME] = streamName;\n  this[__ABORT_HOOK_TOKEN] = hookToken;\n  this.__listeners = [];\n  this.__onabort = null;\n}\nObject.defineProperty(WorkflowAbortSignal.prototype, \"onabort\", {\n  get: function() { return this.__onabort; },\n  set: function(handler) {\n    this.__onabort = handler;\n    if (handler && this.aborted) handler.call(this);\n  },\n});\nWorkflowAbortSignal.prototype._setAborted = function(reason) {\n  if (this.aborted) return;\n  this.aborted = true;\n  this.reason = reason;\n  if (this.__onabort) this.__onabort.call(this);\n  var listeners = this.__listeners;\n  this.__listeners = [];\n  for (var i = 0; i < listeners.length; i++) listeners[i]();\n};\nWorkflowAbortSignal.prototype.addEventListener = function(type, listener) {\n  if (type !== \"abort\") return;\n  if (this.aborted) {\n    // Fire synchronously (not on a microtask) for deterministic replay —\n    // matches the node:vm engine's WorkflowAbortSignal.\n    listener();\n    return;\n  }\n  this.__listeners.push(listener);\n};\nWorkflowAbortSignal.prototype.removeEventListener = function(type, listener) {\n  if (type !== \"abort\") return;\n  this.__listeners = this.__listeners.filter(function(l) { return l !== listener; });\n};\nWorkflowAbortSignal.prototype.throwIfAborted = function() {\n  if (this.aborted) {\n    throw this.reason !== undefined && this.reason !== null\n      ? this.reason\n      : __makeAbortError();\n  }\n};\n// Expose for the serde bundle's revivers (evaluated before this bootstrap;\n// they look the class up lazily at revive time).\nglobalThis.__WorkflowAbortSignal = WorkflowAbortSignal;\n\n// Registry of live abort signals keyed by their hook correlationId. The\n// host delivers hook_received events for these ids as _setAborted calls.\nglobalThis.__abortSignals = {};\n\nglobalThis.AbortController = function WorkflowAbortController() {\n  var id = globalThis.__generateUlid();\n  var streamName = \"strm_\" + id + \"_system_abort\";\n  var hookToken = \"abrt_\" + id;\n  this[__ABORT_STREAM_NAME] = streamName;\n  this[__ABORT_HOOK_TOKEN] = hookToken;\n  this.signal = new WorkflowAbortSignal(streamName, hookToken);\n  var correlationId = \"hook_\" + globalThis.__generateUlid();\n  // Register an internal system hook. isSystem prevents token namespace\n  // conflicts with user hooks.\n  globalThis.__pending.push({\n    type: \"hook\",\n    correlationId: correlationId,\n    token: hookToken,\n    isWebhook: false,\n    isSystem: true,\n    hasCreatedEvent: false,\n  });\n  globalThis.__abortSignals[correlationId] = this.signal;\n};\nglobalThis.AbortController.prototype.abort = function(reason) {\n  if (this.signal.aborted) return; // already aborted (e.g. from replay)\n  this.signal._setAborted(reason);\n  // Mark the pending hook op so the host records the abort. The payload\n  // is serialized in the VM so the reason crosses the boundary with\n  // type fidelity (Errors, DOMException, custom values).\n  var token = this[__ABORT_HOOK_TOKEN];\n  for (var i = 0; i < globalThis.__pending.length; i++) {\n    var item = globalThis.__pending[i];\n    if (item.type === \"hook\" && item.token === token) {\n      item.abortRequested = true;\n      item.abortPayload = globalThis[Symbol.for(\"workflow-serialize\")]({\n        aborted: true,\n        reason: reason,\n      });\n      break;\n    }\n  }\n};\n\nglobalThis.AbortSignal = {\n  abort: function(reason) {\n    var s = new WorkflowAbortSignal(\"\", \"\");\n    s._setAborted(reason !== undefined ? reason : __makeAbortError());\n    return s;\n  },\n  any: function(signals) {\n    var composite = new WorkflowAbortSignal(\"\", \"\");\n    var arr = Array.from(signals);\n    for (var i = 0; i < arr.length; i++) {\n      if (arr[i].aborted) {\n        composite._setAborted(arr[i].reason);\n        return composite;\n      }\n    }\n    var listeners = [];\n    var cleanup = function() {\n      for (var j = 0; j < listeners.length; j++) {\n        if (listeners[j].signal.removeEventListener) {\n          listeners[j].signal.removeEventListener(\"abort\", listeners[j].listener);\n        }\n      }\n      listeners.length = 0;\n    };\n    arr.forEach(function(signal) {\n      if (!signal.addEventListener) return;\n      var listener = function() {\n        if (!composite.aborted) {\n          composite._setAborted(signal.reason);\n          cleanup();\n        }\n      };\n      listeners.push({ signal: signal, listener: listener });\n      signal.addEventListener(\"abort\", listener);\n    });\n    return composite;\n  },\n  timeout: function() {\n    throw new Error(\n      \"AbortSignal.timeout() is not supported in workflow functions. \" +\n        \"Use sleep() with an AbortController instead. \" +\n        \"See: /docs/errors/abort-signal-timeout-in-workflow\"\n    );\n  },\n};\n\n// WORKFLOW_GET_STREAM_ID — generates a stream ID for a workflow run.\n// Replicates getWorkflowRunStreamId() from util.ts inside the QuickJS VM.\n// Uses the built-in btoa() for base64url encoding.\nglobalThis[Symbol.for(\"WORKFLOW_GET_STREAM_ID\")] = function(namespace) {\n  var runId = globalThis[Symbol.for(\"WORKFLOW_CONTEXT\")]\n    ? globalThis[Symbol.for(\"WORKFLOW_CONTEXT\")].workflowRunId\n    : \"\";\n  var streamId = runId.replace(\"wrun_\", \"strm_\") + \"_user\";\n  if (!namespace) return streamId;\n  // base64url: btoa then replace + with -, / with _, strip =\n  var b64 = btoa(namespace).replace(/\\\\+/g, \"-\").replace(/\\\\//g, \"_\").replace(/=+$/, \"\");\n  return streamId + \"_\" + b64;\n};\n`;\n\n// ---- Runtime ----\n\n/**\n * Phase 1 — static (run-independent) VM initialization.\n *\n * Creates a QuickJS VM and loads everything that does not depend on a\n * specific workflow run: the serde bundle (devalue-based serialization\n * used at the host/VM boundary) and the workflow-primitive bootstrap\n * (useStep / sleep / createHook / Response-Request polyfills).\n *\n * `getNowMs` backs the VM's WASI clock (`Date.now()` / `new Date()`\n * inside the VM). The callback itself is static — the per-run state it\n * reads lives on the host and is advanced as events are consumed,\n * matching the node:vm engine's deterministic replay clock.\n *\n * This phase is the future boundary for VM-memory snapshotting: a\n * build-time snapshot can capture the VM right after this function and\n * new runs can restore from it instead of paying VM creation + eval cost\n * (`QuickJS.restore` accepts the same wasi override).\n */\n/**\n * Loosely-typed accessor for the `WebAssembly` global. The package\n * tsconfig's `lib: [\"es2022\"]` does not include the DOM lib where the\n * `WebAssembly` namespace types live; the runtime global is available on\n * every WASM-capable platform this engine targets.\n */\nconst WebAssemblyGlobal = (globalThis as any).WebAssembly as {\n  compile(bytes: Uint8Array): Promise<object>;\n};\n\ntype CompiledExtension = Omit<ExtensionDescriptor, 'wasm'> & {\n  wasm: ExtensionDescriptor['wasm'];\n};\n\n/**\n * Process-wide cache of the compiled `WebAssembly.Module`s for the main\n * QuickJS runtime and its native extensions. `WebAssembly.compile` of the\n * ~600 KB runtime binary is the most expensive part of VM creation and is\n * pure (no per-VM state — instantiation binds the per-VM memory), so it\n * only needs to happen once per process. The promise is cached (not the\n * result) so concurrent first invocations share a single compilation.\n */\nlet compiledAssetsPromise:\n  | Promise<{\n      wasm: object;\n      extensions: CompiledExtension[];\n    }>\n  | undefined;\n\nfunction getCompiledAssets() {\n  if (!compiledAssetsPromise) {\n    compiledAssetsPromise = (async () => {\n      const [wasm, ...extensionModules] = await Promise.all([\n        WebAssemblyGlobal.compile(quickjsWasm),\n        ...quickjsExtensions.map((ext) =>\n          WebAssemblyGlobal.compile(ext.wasm as Uint8Array)\n        ),\n      ]);\n      return {\n        wasm,\n        extensions: quickjsExtensions.map((ext, i) => ({\n          ...ext,\n          wasm: extensionModules[i] as ExtensionDescriptor['wasm'],\n        })),\n      };\n    })();\n    // On failure, clear the cache so a later invocation can retry rather\n    // than being stuck with a rejected promise forever.\n    compiledAssetsPromise.catch(() => {\n      compiledAssetsPromise = undefined;\n    });\n  }\n  return compiledAssetsPromise;\n}\n\nasync function initWorkflowVM(\n  getNowMs: () => number,\n  interruptBudget: InterruptBudget\n): Promise<QuickJS> {\n  // Deterministic replay clock: Date.now() / new Date() inside the VM\n  // read the host-controlled clock instead of wall time. Replay\n  // re-executes the workflow from the top on every invocation, so the\n  // clock must be derived from the event log (not real time) for the\n  // workflow to observe stable timestamps across invocations.\n  const wasi: WasiOptions = (memory) => ({\n    clock_time_get(_clockId: number, _precision: bigint, resultPtr: number) {\n      const timeNs = BigInt(Math.round(getNowMs())) * 1_000_000n;\n      new DataView(memory.buffer).setBigUint64(resultPtr, timeNs, true);\n      return 0;\n    },\n  });\n\n  const assets = await getCompiledAssets();\n  const vm = await QuickJS.create({\n    wasm: assets.wasm as never,\n    memoryLimit: 256 * 1024 * 1024,\n    interruptHandler: createInterruptHandler(interruptBudget),\n    extensions: assets.extensions,\n    wasi,\n  });\n\n  // Evaluate the VM serde bundle\n  vm.evalCode(VM_SERDE_BUNDLE, 'vm-serde.js').dispose();\n\n  // Bootstrap workflow primitives\n  vm.evalCode(VM_BOOTSTRAP, 'bootstrap.js').dispose();\n\n  return vm;\n}\n\n/**\n * A live QuickJS workflow invocation. When the initial `result` is\n * `suspended`, the VM is kept alive so the caller can feed newly recorded\n * events (e.g. terminal events of inline-executed steps) into the SAME VM\n * via `continueWithEvents` — resuming execution exactly where it left off\n * without a fresh-VM re-replay. Terminal results dispose the VM\n * automatically; `dispose()` must be called when abandoning a suspended\n * session (idempotent).\n */\nexport interface QuickJSWorkflowSession {\n  result: QuickJSRuntimeResult;\n  /**\n   * Process newly recorded events in the live VM and re-evaluate the\n   * workflow state. Only valid while the last result was `suspended`.\n   * Resets the VM's interrupt budget for the new execution burst.\n   */\n  continueWithEvents(newEvents: Event[]): Promise<QuickJSRuntimeResult>;\n  /** Dispose the VM if it is still alive. Safe to call multiple times. */\n  dispose(): void;\n}\n\n/**\n * Run a workflow invocation to its first settled state and dispose the\n * VM. Convenience wrapper over {@link startQuickJSWorkflow} for callers\n * (and tests) that don't use live-VM continuation.\n */\nexport async function runQuickJSWorkflow(\n  options: QuickJSRuntimeOptions\n): Promise<QuickJSRuntimeResult> {\n  const session = await startQuickJSWorkflow(options);\n  session.dispose();\n  return session.result;\n}\n\nexport async function startQuickJSWorkflow(\n  options: QuickJSRuntimeOptions\n): Promise<QuickJSWorkflowSession> {\n  const { workflowCode, workflowId, workflowRun, events } = options;\n\n  const startedAt = workflowRun.startedAt ? +workflowRun.startedAt : Date.now();\n\n  // Deterministic PRNG seed — identical for EVERY invocation of the same\n  // run. Full event replay requires this: each invocation re-executes the\n  // workflow from the top and must regenerate the exact same correlationId\n  // sequence so that pending operations re-created by replay match the\n  // events recorded by earlier invocations. Sequential operations within\n  // one execution still get distinct ids because the PRNG advances as the\n  // workflow draws from it. Identical seeding across CONCURRENT invocations\n  // of the same run is also load-bearing: both produce the same ids, and\n  // the world's per-(runId, correlationId) uniqueness turns the duplicate\n  // `events.create` into an EntityConflictError that the entrypoint\n  // swallows.\n  //\n  // The seed inputs MUST be stable across invocations. Notably\n  // `startedAt` is NOT: under turbo the first invocation runs against a\n  // synthesized run object whose timestamps differ from the durably\n  // stored ones that later invocations load. Matches the node:vm\n  // engine's seed (workflow.ts).\n  const seed = [\n    workflowRun.runId,\n    workflowRun.workflowName,\n    workflowRun.deploymentId,\n  ].join(':');\n  const rng = seedrandom(seed);\n\n  // Seeded nanoid generator — uses the same nanoid package and seeded PRNG\n  // as the node:vm engine for consistent token generation.\n  const generateNanoid = nanoid.customRandom(nanoid.urlAlphabet, 21, (size) =>\n    new Uint8Array(size).map(() => 256 * rng())\n  );\n\n  // Deterministic replay clock, mirroring the node:vm engine (see\n  // workflow.ts): the initial value is the run's creation time recovered\n  // from the ULID embedded in `runId` (falling back to `createdAt`), and\n  // it advances to each processed event's `createdAt` as the event log is\n  // replayed. Monotonic (Math.max) so the outer processEvents re-scan\n  // loop can't move the clock backwards mid-execution.\n  let vmNowMs =\n    runIdCreatedAt(workflowRun.runId) ?? (+workflowRun.createdAt || startedAt);\n  const advanceClock = (ms: number) => {\n    if (Number.isFinite(ms)) vmNowMs = Math.max(vmNowMs, ms);\n  };\n\n  // ---- Phase 1: static initialization ----\n  const interruptBudget: InterruptBudget = { start: Date.now() };\n  const vm = await initWorkflowVM(() => vmNowMs, interruptBudget);\n\n  // Any throw between here and the terminal paths (which dispose the VM\n  // inside checkWorkflowState / extractError before RETURNING) would leak\n  // a live QuickJS instance and its WASM linear memory for the lifetime\n  // of the compute instance — which is reused. Dispose on the way out of\n  // an exceptional exit and rethrow.\n  try {\n    return await runWorkflowInVM();\n  } catch (err) {\n    try {\n      vm.dispose();\n    } catch {\n      // Already disposed by a terminal path — ignore.\n    }\n    throw err;\n  }\n\n  // ---- Phase 2: per-run initialization ----\n  async function runWorkflowInVM(): Promise<QuickJSWorkflowSession> {\n    vm.evalCode(\n      `globalThis.__worldCapabilities = ${JSON.stringify(options.worldCapabilities)};`\n    ).dispose();\n\n    // Seeded Math.random\n    {\n      using randomFn = vm.newFunction('random', () => vm.newNumber(rng()));\n      using math = vm.global.getProp('Math');\n      math.setProp('random', randomFn);\n    }\n\n    // Seeded nanoid generator\n    {\n      using nanoidFn = vm.newFunction('__generateNanoid', () =>\n        vm.newString(generateNanoid())\n      );\n      vm.setProp(vm.global, '__generateNanoid', nanoidFn);\n    }\n\n    // Inject a deterministic timestamp for the VM's ULID factory. ULIDs\n    // produced inside the VM use this as their time prefix instead of\n    // Date.now(), so two concurrent workflow invocations of the same run\n    // produce IDENTICAL correlationIds (the random portion also matches\n    // because the PRNG is seeded the same way) and the world's\n    // EntityConflictError on `events.create` dedups one of each pair.\n    // Derived from the runId's embedded ULID (stable across invocations by\n    // construction — unlike `startedAt`, which differs between turbo's\n    // synthesized run object and the durably stored run).\n    vm.evalCode(\n      `globalThis.__ulidTimestamp = ${runIdCreatedAt(workflowRun.runId) ?? (+workflowRun.createdAt || startedAt)};`\n    ).dispose();\n\n    // `process.env` — parity with the node:vm engine, which exposes a frozen\n    // copy of the host env (vm/index.ts). Injected per run so the snapshot of\n    // the env is taken at invocation time, same as node.\n    {\n      const envHandle = vm.newString(JSON.stringify(process.env));\n      vm.setProp(vm.global, '__wdk_env', envHandle);\n      envHandle.dispose();\n      vm.evalCode(\n        'globalThis.process = { env: Object.freeze(JSON.parse(globalThis.__wdk_env)) };' +\n          'delete globalThis.__wdk_env;'\n      ).dispose();\n    }\n\n    // Execute the workflow bundle — use the workflowId as the eval filename\n    // so QuickJS stack traces reference the workflow name, enabling source map\n    // remapping by remapErrorStack (which matches frames by filename).\n    // Evaluated in the per-run phase (after Math.random seeding) so that\n    // module-scope user code draws from the seeded PRNG, matching the\n    // node:vm engine's replay determinism.\n    try {\n      vm.evalCode(workflowCode, workflowId || 'workflow.js').dispose();\n    } catch (err) {\n      return makeSettledSession(\n        extractError(vm, err, 'Workflow evaluation failed')\n      );\n    }\n\n    // Extract workflow arguments. Prefer the run_created event; fall back\n    // to the queue message's runInput if the event log is incomplete\n    // (eventually-consistent read after start()). Failing to find input\n    // for a first invocation is fatal — running the workflow function\n    // with no args would silently turn typed arguments into `undefined`\n    // and, for recursive workflows, produce exponential fan-out.\n    const runCreatedEvent = events.find((e) => e.eventType === 'run_created');\n    const runCreatedInput =\n      runCreatedEvent && 'eventData' in runCreatedEvent\n        ? (runCreatedEvent.eventData as Record<string, unknown>)?.input\n        : undefined;\n    const runInput: unknown =\n      runCreatedInput ?? (options.runInput?.input as unknown);\n\n    if (runInput instanceof Uint8Array) {\n      const decryptedInput = await prepareBytesForVM(\n        runInput,\n        options.encryptionKey\n      );\n      runtimeLogger.debug('QuickJS runtime: run input format', {\n        prefix: new TextDecoder().decode(decryptedInput.subarray(0, 4)),\n        byteLength: decryptedInput.byteLength,\n        source: runCreatedInput ? 'run_created' : 'queueMessage.runInput',\n      });\n      const inputHandle = vm.newUint8Array(decryptedInput);\n      vm.setProp(vm.global, '__wdk_input', inputHandle);\n      inputHandle.dispose();\n    } else if (runInput === undefined && events.length > 0) {\n      // The event log is non-empty (we got run_started or similar) but\n      // no run_created event was found and no queue-provided runInput is\n      // available. This is the race condition observed during the fib\n      // incident — silently dropping arguments would turn `n` into\n      // `undefined` and, for recursive workflows, cause exponential\n      // fan-out. Fail loud: the throw escapes the entrypoint into the\n      // replay loop's catch in runtime.ts (the QuickJS dispatch runs\n      // inside that loop's try), which records run_failed. A visible\n      // terminal failure is\n      // preferred over silently executing with undefined arguments — the\n      // queue-provided runInput fallback above makes this path rare.\n      // Empty `events` is allowed because tests that bootstrap a workflow\n      // with no arguments rely on the old permissive behavior.\n      throw new Error(\n        `Cannot start workflow run \"${workflowRun.runId}\": no run_created event found and no runInput in the queue payload, but other events are present (likely a read-after-write race during start()).`\n      );\n    }\n\n    // Set workflow context metadata (for getWorkflowMetadata()).\n    // Must match the shape that the node:vm engine produces (see\n    // packages/core/src/workflow.ts: runWorkflow → ctx) so user code\n    // that compares `getWorkflowMetadata()` values between a step\n    // (server-side) and the workflow (VM-side) sees identical objects.\n    {\n      const metadata = {\n        workflowName: workflowRun.workflowName,\n        workflowRunId: workflowRun.runId,\n        workflowStartedAt: workflowRun.startedAt\n          ? new Date(+workflowRun.startedAt)\n          : new Date(),\n        url: process.env.VERCEL_URL\n          ? `https://${process.env.VERCEL_URL}`\n          : `http://localhost:${options.port ?? 3000}`,\n        features: { encryption: !!options.encryptionKey },\n      };\n      vm.evalCode(\n        `globalThis[Symbol.for(\"WORKFLOW_CONTEXT\")] = ${JSON.stringify(metadata)};` +\n          `globalThis[Symbol.for(\"WORKFLOW_CONTEXT\")].workflowStartedAt = new Date(${JSON.stringify(metadata.workflowStartedAt.toISOString())});`\n      ).dispose();\n    }\n\n    // Start the workflow function. If the workflow isn't registered,\n    // throw an error tagged with `name = \"WorkflowNotRegisteredError\"`\n    // so the host-side entrypoint can reconstruct a real\n    // WorkflowNotRegisteredError (a WorkflowRuntimeError subclass that\n    // classifies as RUNTIME_ERROR) rather than a generic user error.\n    // See quickjs-entrypoint.ts's run_failed branch.\n    try {\n      vm.evalCode(`\n      var __wfn = globalThis.__private_workflows.get(${JSON.stringify(workflowId)});\n      if (!__wfn) {\n        var __wfnErr = new Error(\"Workflow \\\\\"\" + ${JSON.stringify(workflowId)} + \"\\\\\" is not registered in the current deployment.\");\n        __wfnErr.name = \"WorkflowNotRegisteredError\";\n        throw __wfnErr;\n      }\n      var __args = globalThis.__wdk_input\n        ? globalThis[Symbol.for(\"workflow-deserialize\")](globalThis.__wdk_input)\n        : [];\n      delete globalThis.__wdk_input;\n      if (!Array.isArray(__args)) __args = [__args];\n      __wfn.apply(null, __args).then(\n        function(result) { globalThis.__workflowResult = globalThis[Symbol.for(\"workflow-serialize\")](result); },\n        function(error) {\n          // Preserve display info on the host-side failed object\n          // (matches the legacy host-visible shape) AND serialize the\n          // entire thrown value so the host can dehydrate the original\n          // type-identity, cause chain, or non-Error throws verbatim\n          // through the standard error pipeline.\n          globalThis.__workflowError = {\n            message: error && error.message != null ? String(error.message) : String(error),\n            stack: error && error.stack ? error.stack : \"\",\n            name: error && error.name ? error.name : (error instanceof Error ? \"Error\" : typeof error),\n            valueBytes: globalThis[Symbol.for(\"workflow-serialize\")](error),\n          };\n        }\n      );\n    `).dispose();\n    } catch (err) {\n      return makeSettledSession(\n        extractError(vm, err, 'Failed to start workflow')\n      );\n    }\n\n    // Process events and drain jobs in a loop. Events may resolve promises\n    // that unblock workflow code, which then creates NEW resolvers for\n    // subsequent events. Re-processing events matches these new resolvers\n    // against events that were already delivered.\n    {\n      let maxIterations = 100;\n      let madeProgress: boolean;\n      do {\n        madeProgress = await processEvents(\n          vm,\n          events,\n          advanceClock,\n          options.encryptionKey\n        );\n        let batch: number;\n        do {\n          batch = vm.executePendingJobs();\n          if (batch > 0) madeProgress = true;\n        } while (batch > 0);\n      } while (madeProgress && --maxIterations > 0);\n      if (madeProgress && maxIterations === 0) {\n        // The drain loop hit its bound while still making progress —\n        // proceeding as if it converged would present as a mysterious\n        // suspension or replay divergence. Make the giving-up visible so\n        // a wedge is attributable to this bound rather than a mystery.\n        runtimeLogger.warn(\n          'QuickJS runtime: event drain loop hit its iteration bound before reaching a fixed point',\n          {\n            workflowRunId: workflowRun.runId,\n            eventCount: events.length,\n          }\n        );\n      }\n    }\n\n    // ---- Check result ----\n    return makeLiveSession(\n      vm,\n      interruptBudget,\n      advanceClock,\n      options.encryptionKey\n    );\n  }\n}\n\n/** Session wrapper for a result whose VM is already settled/disposed. */\nfunction makeSettledSession(\n  result: QuickJSRuntimeResult\n): QuickJSWorkflowSession {\n  return {\n    result,\n    continueWithEvents: () => {\n      throw new Error(\n        'QuickJS workflow session is settled — continueWithEvents is only valid while suspended'\n      );\n    },\n    dispose: () => {},\n  };\n}\n\n/**\n * Evaluate the VM's state and wrap it in a live session. While suspended,\n * the VM stays alive so `continueWithEvents` can resume it in place;\n * terminal states dispose the VM immediately (inside checkWorkflowState).\n */\nfunction makeLiveSession(\n  vm: QuickJS,\n  interruptBudget: InterruptBudget,\n  advanceClock: (ms: number) => void,\n  encryptionKey?: DecryptionKey\n): QuickJSWorkflowSession {\n  const result = checkWorkflowState(vm, { keepAliveOnSuspend: true });\n  let alive = !!result.suspended;\n\n  const session: QuickJSWorkflowSession = {\n    result,\n    async continueWithEvents(\n      newEvents: Event[]\n    ): Promise<QuickJSRuntimeResult> {\n      if (!alive) {\n        throw new Error(\n          'QuickJS workflow session is not alive — continueWithEvents is only valid while suspended'\n        );\n      }\n      // Fresh execution burst — the interrupt budget bounds VM compute,\n      // not wall time spent waiting on inline steps between bursts.\n      interruptBudget.start = Date.now();\n\n      let maxIterations = 100;\n      let madeProgress: boolean;\n      do {\n        madeProgress = await processEvents(\n          vm,\n          newEvents,\n          advanceClock,\n          encryptionKey\n        );\n        let batch: number;\n        do {\n          batch = vm.executePendingJobs();\n          if (batch > 0) madeProgress = true;\n        } while (batch > 0);\n      } while (madeProgress && --maxIterations > 0);\n\n      const next = checkWorkflowState(vm, { keepAliveOnSuspend: true });\n      if (!next.suspended) alive = false;\n      session.result = next;\n      return next;\n    },\n    dispose(): void {\n      if (alive) {\n        alive = false;\n        try {\n          vm.dispose();\n        } catch {\n          // Already disposed — ignore.\n        }\n      }\n    },\n  };\n  return session;\n}\n\n// ---- Event Processing ----\n\nasync function processEvents(\n  vm: QuickJS,\n  events: Event[],\n  advanceClock: (ms: number) => void,\n  encryptionKey?: DecryptionKey\n): Promise<boolean> {\n  let resolved = false;\n  for (const event of events) {\n    // Advance the VM's deterministic clock to this event's creation time\n    // BEFORE resolving anything, so workflow code unblocked by this event\n    // observes Date.now() at (or after — the clock is monotonic) the time\n    // the event was recorded. Mirrors the node:vm engine's\n    // `onConsumedEvent → updateTimestamp(+event.createdAt)`.\n    advanceClock(+event.createdAt);\n\n    const cid = event.correlationId;\n    if (!cid) continue;\n\n    // JSON.stringify handles quotes, backslashes and control characters;\n    // correlation ids are host-generated ULIDs today, but the eval-string\n    // safety shouldn't depend on that invariant being asserted nowhere.\n    const cidJs = JSON.stringify(cid);\n    const eventData =\n      'eventData' in event\n        ? (event.eventData as Record<string, unknown>)\n        : undefined;\n\n    // Log the event and whether the resolver exists\n    switch (event.eventType) {\n      case 'step_completed': {\n        const hasResolver = vm.dump(\n          vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`)\n        );\n        const rawOutput = eventData?.result ?? eventData?.output;\n        if (hasResolver) {\n          if (rawOutput instanceof Uint8Array) {\n            // Decrypt if encrypted — the VM only understands 'devl' format\n            runtimeLogger.debug('QuickJS runtime: step result raw', {\n              correlationId: cid,\n              rawPrefix: new TextDecoder().decode(rawOutput.subarray(0, 4)),\n              rawByteLength: rawOutput.byteLength,\n              isBuffer: Buffer.isBuffer(rawOutput),\n            });\n            const decryptedOutput = await prepareBytesForVM(\n              rawOutput,\n              encryptionKey\n            );\n            runtimeLogger.debug('QuickJS runtime: step result decrypted', {\n              correlationId: cid,\n              prefix: new TextDecoder().decode(decryptedOutput.subarray(0, 4)),\n              byteLength: decryptedOutput.byteLength,\n            });\n            const bytesHandle = vm.newUint8Array(decryptedOutput);\n            vm.setProp(vm.global, '__tmp_result', bytesHandle);\n            bytesHandle.dispose();\n            vm.evalCode(\n              `globalThis.__resolvers[${cidJs}].resolve(globalThis[Symbol.for(\"workflow-deserialize\")](globalThis.__tmp_result));` +\n                `delete globalThis.__resolvers[${cidJs}];` +\n                `delete globalThis.__tmp_result;`\n            ).dispose();\n          } else {\n            runtimeLogger.debug('QuickJS runtime: step result non-binary', {\n              correlationId: cid,\n              type: typeof rawOutput,\n              isNull: rawOutput === null,\n              isUndefined: rawOutput === undefined,\n              constructor: rawOutput?.constructor?.name,\n            });\n            const serialized =\n              rawOutput !== undefined ? JSON.stringify(rawOutput) : 'undefined';\n            vm.evalCode(\n              `globalThis.__resolvers[${cidJs}].resolve(${serialized});` +\n                `delete globalThis.__resolvers[${cidJs}];`\n            ).dispose();\n          }\n          // Drain ALL microtasks after resolve\n          {\n            resolved = true;\n            let b: number;\n            do {\n              b = vm.executePendingJobs();\n            } while (b > 0);\n          }\n        } else {\n          // No resolver yet — buffer the prepared outcome so the promise\n          // settles the moment the VM constructs it (see __terminalBuffer\n          // in the bootstrap). Without this, the live-continuation path\n          // (which scans each delta exactly once) drops the terminal and\n          // the await never settles.\n          if (rawOutput instanceof Uint8Array) {\n            const decryptedOutput = await prepareBytesForVM(\n              rawOutput,\n              encryptionKey\n            );\n            const bytesHandle = vm.newUint8Array(decryptedOutput);\n            vm.setProp(vm.global, '__tmp_buf', bytesHandle);\n            bytesHandle.dispose();\n            vm.evalCode(\n              `globalThis.__terminalBuffer[${cidJs}] = { kind: \"resolve_bytes\", bytes: globalThis.__tmp_buf };` +\n                `delete globalThis.__tmp_buf;`\n            ).dispose();\n          } else {\n            const serialized =\n              rawOutput !== undefined ? JSON.stringify(rawOutput) : 'undefined';\n            vm.evalCode(\n              `globalThis.__terminalBuffer[${cidJs}] = { kind: \"resolve_value\", value: ${serialized} };`\n            ).dispose();\n          }\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'step_failed': {\n        const hasResolver = vm.dump(\n          vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`)\n        );\n        if (hasResolver) {\n          const errorData = eventData?.error;\n          if (errorData instanceof Uint8Array) {\n            // Modern path (post-#1851): the step handler dehydrated the\n            // thrown value through the first-class error pipeline. Decrypt\n            // (if encrypted) and pass the bytes to the VM-side deserializer\n            // so the workflow catch sees a properly typed Error subclass\n            // (TypeError, FatalError with original cause chain, etc.) with\n            // the original message and stack preserved.\n            const decrypted = await prepareBytesForVM(errorData, encryptionKey);\n            const bytesHandle = vm.newUint8Array(decrypted);\n            vm.setProp(vm.global, '__tmp_error', bytesHandle);\n            bytesHandle.dispose();\n            vm.evalCode(\n              `(function(){` +\n                `var e=globalThis[Symbol.for(\"workflow-deserialize\")](globalThis.__tmp_error);` +\n                `globalThis.__resolvers[${cidJs}].reject(e);` +\n                `delete globalThis.__resolvers[${cidJs}];` +\n                `delete globalThis.__tmp_error;` +\n                `})()`\n            ).dispose();\n          } else {\n            // Legacy path: pre-pipeline events stored error as\n            // `{ message, stack, code }`. Reconstruct a FatalError so\n            // workflow catch can detect it via FatalError.is(), matching\n            // the original V1 step handler behavior.\n            const isErrorObject =\n              typeof errorData === 'object' && errorData !== null;\n            const msg = isErrorObject\n              ? (((errorData as Record<string, unknown>).message as string) ??\n                'Step failed')\n              : typeof errorData === 'string'\n                ? errorData\n                : 'Step failed';\n            const errorStack =\n              (isErrorObject\n                ? (errorData as Record<string, unknown>).stack\n                : undefined) ?? (eventData?.stack as string | undefined);\n            const stackAssignment = errorStack\n              ? `e.stack=${JSON.stringify(errorStack)};`\n              : '';\n            vm.evalCode(\n              `(function(){var e=new Error(${JSON.stringify(msg)});e.name=\"FatalError\";e.fatal=true;${stackAssignment}` +\n                `globalThis.__resolvers[${cidJs}].reject(e);` +\n                `delete globalThis.__resolvers[${cidJs}];})()`\n            ).dispose();\n          }\n          {\n            resolved = true;\n            let b: number;\n            do {\n              b = vm.executePendingJobs();\n            } while (b > 0);\n          }\n        } else {\n          // No resolver yet — buffer the prepared rejection (see the\n          // step_completed branch above for the rationale).\n          const errorData = eventData?.error;\n          if (errorData instanceof Uint8Array) {\n            const decrypted = await prepareBytesForVM(errorData, encryptionKey);\n            const bytesHandle = vm.newUint8Array(decrypted);\n            vm.setProp(vm.global, '__tmp_buf', bytesHandle);\n            bytesHandle.dispose();\n            vm.evalCode(\n              `globalThis.__terminalBuffer[${cidJs}] = { kind: \"reject_bytes\", bytes: globalThis.__tmp_buf };` +\n                `delete globalThis.__tmp_buf;`\n            ).dispose();\n          } else {\n            const isErrorObject =\n              typeof errorData === 'object' && errorData !== null;\n            const msg = isErrorObject\n              ? (((errorData as Record<string, unknown>).message as string) ??\n                'Step failed')\n              : typeof errorData === 'string'\n                ? errorData\n                : 'Step failed';\n            const errorStack =\n              (isErrorObject\n                ? (errorData as Record<string, unknown>).stack\n                : undefined) ?? (eventData?.stack as string | undefined);\n            vm.evalCode(\n              `globalThis.__terminalBuffer[${cidJs}] = { kind: \"reject_error\", message: ${JSON.stringify(msg)}, stack: ${errorStack ? JSON.stringify(errorStack) : 'undefined'} };`\n            ).dispose();\n          }\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'wait_completed': {\n        const hasResolver = vm.dump(\n          vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`)\n        );\n        if (hasResolver) {\n          vm.evalCode(\n            `globalThis.__resolvers[${cidJs}].resolve();` +\n              `delete globalThis.__resolvers[${cidJs}];`\n          ).dispose();\n          {\n            resolved = true;\n            let b: number;\n            do {\n              b = vm.executePendingJobs();\n            } while (b > 0);\n          }\n        } else {\n          // No resolver yet — buffer (see step_completed above).\n          vm.evalCode(\n            `globalThis.__terminalBuffer[${cidJs}] = { kind: \"resolve_undefined\" };`\n          ).dispose();\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'attr_set': {\n        // Only workflow-written attribute events resolve a pending\n        // setAttributes() promise; step/system writers share no\n        // correlationIds with VM resolvers, so the guard is defensive.\n        const writer = (eventData?.writer as { type?: string } | undefined)\n          ?.type;\n        if (writer !== 'workflow') break;\n        const hasResolver = vm.dump(\n          vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`)\n        );\n        if (!hasResolver) {\n          // No resolver yet — buffer (see step_completed above).\n          vm.evalCode(\n            `globalThis.__terminalBuffer[${cidJs}] = { kind: \"resolve_undefined\" };`\n          ).dispose();\n        }\n        if (hasResolver) {\n          vm.evalCode(\n            `globalThis.__resolvers[${cidJs}].resolve();` +\n              `delete globalThis.__resolvers[${cidJs}];`\n          ).dispose();\n          {\n            resolved = true;\n            let b: number;\n            do {\n              b = vm.executePendingJobs();\n            } while (b > 0);\n          }\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'hook_received': {\n        // Check if this event was already processed (delivered or\n        // buffered) within this invocation. Prevents double-delivery when\n        // the outer loop re-scans events.\n        const alreadyProcessed = event.eventId\n          ? vm.dump(\n              vm.evalCode(\n                `!!(globalThis.__hookPayloadBuffer.__processedEventIds && globalThis.__hookPayloadBuffer.__processedEventIds[${JSON.stringify(event.eventId)}])`\n              )\n            )\n          : false;\n        if (alreadyProcessed) {\n          runtimeLogger.debug(\n            'QuickJS runtime: hook_received already processed',\n            {\n              correlationId: cid,\n              eventId: event.eventId,\n            }\n          );\n          markCreated(vm, cidJs);\n          break;\n        }\n\n        // Resilient-resume dedup (parity with the node engine's\n        // EventsConsumer in workflow/hook.ts): two hook_received rows for\n        // ONE resume attempt share a client-minted `resumeId` (a duplicate\n        // can be committed when the materialization fallback races a\n        // delayed direct write — hook_received has no storage uniqueness\n        // constraint). Deliver only the first-in-log occurrence. The seen\n        // set lives in the VM heap so it is deterministic per replay and\n        // survives event re-scans within the invocation. Events without a\n        // resumeId (older SDKs) are never deduped.\n        {\n          // Top-level event.resumeId is the canonical location (the backend\n          // hoists it to a first-class column); the nested\n          // eventData.resumeId form is a deprecated legacy fallback —\n          // mirrors the node engine's dedup in workflow/hook.ts.\n          const resumeId =\n            (event as { resumeId?: unknown }).resumeId ??\n            (eventData as { resumeId?: unknown } | undefined)?.resumeId;\n          if (typeof resumeId === 'string') {\n            const resumeIdJs = JSON.stringify(resumeId);\n            const duplicate = vm.dump(\n              vm.evalCode(\n                `(globalThis.__hookSeenResumeIds = globalThis.__hookSeenResumeIds || {})[${resumeIdJs}] === true`\n              )\n            );\n            if (duplicate) {\n              runtimeLogger.debug(\n                'QuickJS runtime: duplicate hook_received for the same resume attempt, dropping',\n                { correlationId: cid, eventId: event.eventId, resumeId }\n              );\n              if (event.eventId) {\n                vm.evalCode(\n                  `(globalThis.__hookPayloadBuffer.__processedEventIds = globalThis.__hookPayloadBuffer.__processedEventIds || {})[${JSON.stringify(event.eventId)}] = true;`\n                ).dispose();\n              }\n              markCreated(vm, cidJs);\n              break;\n            }\n            vm.evalCode(\n              `globalThis.__hookSeenResumeIds[${resumeIdJs}] = true;`\n            ).dispose();\n          }\n        }\n\n        // Abort delivery: hook_received for an AbortController's system\n        // hook flips the registered signal instead of resolving a promise.\n        // The payload is the dehydrated `{ aborted: true, reason }` object.\n        const isAbortHook = vm.dump(\n          vm.evalCode(\n            `!!(globalThis.__abortSignals && globalThis.__abortSignals[${cidJs}])`\n          )\n        );\n        if (isAbortHook) {\n          const rawAbortPayload = eventData?.payload;\n          if (rawAbortPayload instanceof Uint8Array) {\n            const decrypted = await prepareBytesForVM(\n              rawAbortPayload,\n              encryptionKey\n            );\n            const bytesHandle = vm.newUint8Array(decrypted);\n            vm.setProp(vm.global, '__tmp_abort', bytesHandle);\n            bytesHandle.dispose();\n            vm.evalCode(\n              `(function(){` +\n                `var p=globalThis[Symbol.for(\"workflow-deserialize\")](globalThis.__tmp_abort);` +\n                `delete globalThis.__tmp_abort;` +\n                `globalThis.__abortSignals[${cidJs}]._setAborted(p&&typeof p===\"object\"?p.reason:undefined);` +\n                `})()`\n            ).dispose();\n          } else {\n            vm.evalCode(\n              `globalThis.__abortSignals[${cidJs}]._setAborted(undefined);`\n            ).dispose();\n          }\n          // The abort is durably recorded — clear the pending op's\n          // abortRequested marker so the host doesn't re-record it (the\n          // workflow's own abort() call can set the flag before this\n          // event is processed when it happens later in replay order,\n          // and hook_received events are not unique per correlationId).\n          vm.evalCode(\n            `(function(){` +\n              `var p=globalThis.__pending.find(function(q){return q.correlationId===${JSON.stringify(cid)}&&q.type===\"hook\";});` +\n              `if(p)p.abortRequested=false;` +\n              `})()`\n          ).dispose();\n          if (event.eventId) {\n            vm.evalCode(\n              `(globalThis.__hookPayloadBuffer.__processedEventIds = globalThis.__hookPayloadBuffer.__processedEventIds || {})[${JSON.stringify(event.eventId)}] = true;`\n            ).dispose();\n          }\n          {\n            resolved = true;\n            let b: number;\n            do {\n              b = vm.executePendingJobs();\n            } while (b > 0);\n          }\n          markCreated(vm, cidJs);\n          break;\n        }\n\n        const hasResolver = vm.dump(\n          vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`)\n        );\n        const rawPayload = eventData?.payload ?? eventData?.result;\n        runtimeLogger.debug('QuickJS runtime: processing hook_received', {\n          correlationId: cid,\n          eventId: event.eventId,\n          hasResolver,\n          payloadType: typeof rawPayload,\n          payloadIsUint8Array: rawPayload instanceof Uint8Array,\n          payloadKeys:\n            rawPayload && typeof rawPayload === 'object'\n              ? Object.keys(rawPayload)\n              : undefined,\n        });\n        if (hasResolver) {\n          if (rawPayload instanceof Uint8Array) {\n            // Decrypt if encrypted — the VM only understands 'devl' format\n            const decryptedPayload = await prepareBytesForVM(\n              rawPayload,\n              encryptionKey\n            );\n            const bytesHandle = vm.newUint8Array(decryptedPayload);\n            vm.setProp(vm.global, '__tmp_result', bytesHandle);\n            bytesHandle.dispose();\n            vm.evalCode(\n              `globalThis.__resolvers[${cidJs}].resolve(globalThis[Symbol.for(\"workflow-deserialize\")](globalThis.__tmp_result));` +\n                `delete globalThis.__resolvers[${cidJs}];` +\n                `delete globalThis.__tmp_result;`\n            ).dispose();\n          } else {\n            const serialized =\n              rawPayload !== undefined\n                ? JSON.stringify(rawPayload)\n                : 'undefined';\n            vm.evalCode(\n              `globalThis.__resolvers[${cidJs}].resolve(${serialized});` +\n                `delete globalThis.__resolvers[${cidJs}];`\n            ).dispose();\n          }\n          // Mark this event as processed in the VM heap to prevent\n          // double-delivery when the outer loop re-scans events.\n          if (event.eventId) {\n            vm.evalCode(\n              `(globalThis.__hookPayloadBuffer.__processedEventIds = globalThis.__hookPayloadBuffer.__processedEventIds || {})[${JSON.stringify(event.eventId)}] = true;`\n            ).dispose();\n          }\n          {\n            resolved = true;\n            let b: number;\n            do {\n              b = vm.executePendingJobs();\n            } while (b > 0);\n          }\n        } else {\n          // No resolver yet — buffer the payload in the VM heap. When\n          // createHookPromise() is called later, it will drain this buffer\n          // first (matching the node:vm engine's payloadsQueue behavior).\n          const eventIdJs = event.eventId\n            ? JSON.stringify(event.eventId)\n            : 'null';\n          const bufferAndTrack =\n            `(globalThis.__hookPayloadBuffer[${cidJs}] = globalThis.__hookPayloadBuffer[${cidJs}] || [])` +\n            `.push(%PAYLOAD%);` +\n            (event.eventId\n              ? `(globalThis.__hookPayloadBuffer.__processedEventIds = globalThis.__hookPayloadBuffer.__processedEventIds || {})[${eventIdJs}] = true;`\n              : '');\n          if (rawPayload instanceof Uint8Array) {\n            // Decrypt if encrypted — the VM only understands 'devl' format\n            const decryptedPayload = await prepareBytesForVM(\n              rawPayload,\n              encryptionKey\n            );\n            const bytesHandle = vm.newUint8Array(decryptedPayload);\n            vm.setProp(vm.global, '__tmp_result', bytesHandle);\n            bytesHandle.dispose();\n            // NOTE: replacement is a function so `$`-sequences in the\n            // substituted JS never get interpreted as String.replace\n            // special replacement patterns.\n            vm.evalCode(\n              bufferAndTrack.replace(\n                '%PAYLOAD%',\n                () =>\n                  'globalThis[Symbol.for(\"workflow-deserialize\")](globalThis.__tmp_result)'\n              ) + 'delete globalThis.__tmp_result;'\n            ).dispose();\n          } else {\n            const serialized =\n              rawPayload !== undefined\n                ? JSON.stringify(rawPayload)\n                : 'undefined';\n            // Function replacement: a JSON-serialized payload can contain\n            // `$&`, `$'`, `$\\``, ... which String.replace would otherwise\n            // expand, silently corrupting the injected code.\n            vm.evalCode(\n              bufferAndTrack.replace('%PAYLOAD%', () => serialized)\n            ).dispose();\n          }\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'hook_conflict': {\n        // Another workflow owns this hook token. Payload awaiters reject\n        // with HookConflictError; getConflict() awaiters resolve with a\n        // Run handle for the conflicting run (revived through the VM's\n        // class registry so its methods are durable step proxies) or\n        // reject with the error when no handle can be constructed —\n        // mirroring the node:vm engine's hook.ts hook_conflict handling.\n        const conflictToken = (eventData?.token as string) ?? 'unknown';\n        const conflictingRunId = eventData?.conflictingRunId as\n          | string\n          | undefined;\n        const didSettle = vm.dump(\n          vm.evalCode(\n            `(function(){\n              var cid = ${JSON.stringify(cid)};\n              var token = ${JSON.stringify(conflictToken)};\n              var conflictingRunId = ${JSON.stringify(conflictingRunId ?? null)};\n              var ErrCls = globalThis[Symbol.for('@workflow/errors//HookConflictError')];\n              var err;\n              if (typeof ErrCls === 'function') {\n                err = new ErrCls(token, conflictingRunId || undefined);\n              } else {\n                err = new Error('Hook token \"' + token + '\" is already in use by another workflow');\n                err.name = 'HookConflictError';\n                err.token = token;\n                if (conflictingRunId) err.conflictingRunId = conflictingRunId;\n              }\n              var run = null;\n              if (conflictingRunId) {\n                var reg = globalThis[Symbol.for('workflow-class-registry')];\n                var RunCls = reg && reg.get('class//workflow//Run');\n                var des = RunCls && RunCls[Symbol.for('workflow-deserialize')];\n                if (typeof des === 'function') {\n                  run = des.call(RunCls, { runId: conflictingRunId });\n                }\n              }\n              var settled = false;\n              var state = globalThis.__hooks && globalThis.__hooks[cid];\n              if (state && !state.conflict) {\n                state.conflict = { error: err, run: run };\n                var gc = state.getConflictResolvers;\n                state.getConflictResolvers = [];\n                for (var i = 0; i < gc.length; i++) {\n                  if (run) { gc[i].resolve(run); } else { gc[i].reject(err); }\n                  settled = true;\n                }\n              }\n              if (globalThis.__resolvers[cid]) {\n                globalThis.__resolvers[cid].reject(err);\n                delete globalThis.__resolvers[cid];\n                settled = true;\n              }\n              return settled;\n            })()`\n          )\n        );\n        if (didSettle) {\n          resolved = true;\n          let b: number;\n          do {\n            b = vm.executePendingJobs();\n          } while (b > 0);\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'step_created':\n      case 'step_started':\n      case 'step_retrying':\n      case 'wait_created': {\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'hook_created': {\n        // Confirm creation for getConflict() awaiters: resolve them with\n        // null (no conflict) once the event log proves the hook exists.\n        const settledGetConflict = vm.dump(\n          vm.evalCode(\n            `(function(){\n              var state = globalThis.__hooks && globalThis.__hooks[${JSON.stringify(cid)}];\n              if (!state) return false;\n              state.created = true;\n              var gc = state.getConflictResolvers;\n              state.getConflictResolvers = [];\n              for (var i = 0; i < gc.length; i++) gc[i].resolve(null);\n              return gc.length > 0;\n            })()`\n          )\n        );\n        if (settledGetConflict) {\n          resolved = true;\n          let b: number;\n          do {\n            b = vm.executePendingJobs();\n          } while (b > 0);\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'hook_disposed': {\n        // Disambiguate from the `hook` pending op with the same\n        // correlationId — we want to mark the `hook_dispose` entry.\n        markCreated(vm, cidJs, 'hook_dispose');\n        break;\n      }\n    }\n  }\n  return resolved;\n}\n\nfunction markCreated(vm: QuickJS, cidJs: string, opType?: string): void {\n  // `cidJs` is the JSON.stringify-quoted correlation id (see processEvents).\n  // `hook` and `hook_dispose` pending ops share the same correlationId,\n  // so when processing `hook_disposed` events we must disambiguate by\n  // type — otherwise `.find()` returns the original `hook` op and the\n  // `hook_dispose` op is never marked, causing the entrypoint to keep\n  // retrying a hook_disposed for an already-deleted entity.\n  const predicate = opType\n    ? `function(p){return p.correlationId===${cidJs}&&p.type===${JSON.stringify(opType)};}`\n    : `function(p){return p.correlationId===${cidJs};}`;\n  vm.evalCode(\n    `var __p=globalThis.__pending.find(${predicate});` +\n      `if(__p)__p.hasCreatedEvent=true;`\n  ).dispose();\n}\n\n// ---- State Checking ----\n\n/**\n * Collect leftover pending operations that need durable side effects when\n * the workflow reaches a terminal state. Mirrors the node:vm engine's\n * drainPendingQueueItems (workflow.ts): still-alive system hooks\n * (AbortController) without an abort in flight are implicitly disposed so\n * they don't leak hook rows; ops without created events (fire-and-forget\n * attributes/hooks/steps/waits) and pending abort recordings are surfaced\n * for the entrypoint to flush.\n */\nfunction collectDrainOperations(vm: QuickJS): PendingOperation[] {\n  using h = vm.evalCode(`(function(){\n    var toDispose = [];\n    globalThis.__pending.forEach(function(p){\n      if (p.type === \"hook\" && p.isSystem && !p.abortRequested && !p.disposed) {\n        p.disposed = true;\n        // Only dispose hooks that were durably created; a hook that never\n        // reached storage has nothing to clean up.\n        if (p.hasCreatedEvent) {\n          toDispose.push({\n            type: \"hook_dispose\",\n            correlationId: p.correlationId,\n            hasCreatedEvent: false,\n          });\n        }\n      }\n    });\n    toDispose.forEach(function(d){ globalThis.__pending.push(d); });\n    return globalThis.__pending.filter(function(p){\n      if (p.abortRequested) return true;\n      if (p.hasCreatedEvent) return false;\n      // Skip system hooks that were disposed before ever being created.\n      if (p.type === \"hook\" && p.disposed) return false;\n      return true;\n    });\n  })()`);\n  return vm.dump(h) as PendingOperation[];\n}\n\nfunction checkWorkflowState(\n  vm: QuickJS,\n  opts: { keepAliveOnSuspend?: boolean } = {}\n): QuickJSRuntimeResult {\n  // Check completed — __workflowResult is a format-prefixed Uint8Array\n  {\n    using h = vm.evalCode('globalThis.__workflowResult');\n    if (!h.isUndefined) {\n      const resultBytes = h.toUint8Array();\n      const drainOperations = collectDrainOperations(vm);\n      vm.dispose();\n      return {\n        completed: {\n          result: resultBytes,\n          ...(drainOperations.length > 0 ? { drainOperations } : {}),\n        },\n      };\n    }\n  }\n\n  // Check failed\n  {\n    using h = vm.evalCode('globalThis.__workflowError');\n    if (!h.isUndefined) {\n      const errorObj = vm.dump(h) as\n        | {\n            message: string;\n            stack?: string;\n            name?: string;\n            valueBytes?: Uint8Array;\n          }\n        | string;\n      const failed =\n        typeof errorObj === 'string'\n          ? { message: errorObj }\n          : {\n              message: errorObj.message,\n              stack: errorObj.stack || undefined,\n              name: errorObj.name || undefined,\n              valueBytes: errorObj.valueBytes,\n            };\n      runtimeLogger.error('QuickJS runtime: workflow failed in VM', {\n        errorMessage: failed.message,\n        errorName: failed.name,\n        errorStack: failed.stack,\n      });\n      const drainOperations = collectDrainOperations(vm);\n      vm.dispose();\n      return {\n        failed: {\n          ...failed,\n          ...(drainOperations.length > 0 ? { drainOperations } : {}),\n        },\n      };\n    }\n  }\n\n  // Check suspended — the workflow is suspended if there are active resolvers\n  // OR pending operations that haven't been created yet (e.g. hooks created\n  // upfront but not yet awaited)\n  {\n    using h = vm.evalCode(\n      'Object.keys(globalThis.__resolvers).length > 0 || globalThis.__pending.some(function(p){return!p.hasCreatedEvent;})'\n    );\n    if (vm.dump(h)) {\n      using pendingH = vm.evalCode(\n        // Ops with an active resolver or without a created event are\n        // pending; abort-requested hooks are also surfaced (even when\n        // already created and unawaited) so the host records the abort.\n        `globalThis.__pending.filter(function(p){return!!globalThis.__resolvers[p.correlationId] || !p.hasCreatedEvent || p.abortRequested;})`\n      );\n      const pendingOps = vm.dump(pendingH) as PendingOperation[];\n      if (!opts.keepAliveOnSuspend) vm.dispose();\n\n      return {\n        suspended: {\n          pendingOperations: pendingOps,\n        },\n      };\n    }\n  }\n\n  vm.dispose();\n  return { failed: { message: 'Workflow ended in unknown state' } };\n}\n\n// ---- Helpers ----\n\nfunction extractError(\n  vm: QuickJS,\n  err: unknown,\n  fallbackMessage: string\n): QuickJSRuntimeResult {\n  let message = fallbackMessage;\n  let stack: string | undefined;\n  let name: string | undefined;\n\n  if (err instanceof JSException) {\n    const error = vm.dump(err.handle) as Record<string, unknown> | null;\n    err.handle.dispose();\n    message = (error?.message as string) ?? err.message ?? fallbackMessage;\n    stack = (error?.stack as string) ?? err.stack;\n    name = (error?.name as string) ?? err.name;\n  } else if (err instanceof Error) {\n    message = err.message ?? fallbackMessage;\n    stack = err.stack;\n    name = err.name;\n  }\n\n  vm.dispose();\n  return {\n    failed: { message, stack, name },\n  };\n}\n\n/**\n * Mutable interrupt budget for a VM. QuickJS polls the interrupt handler\n * during JS execution; when it returns true, execution aborts. The budget\n * bounds a single host->VM execution burst (bundle eval + event\n * processing), not total VM lifetime — the inline-step loop keeps a VM\n * alive across step executions that can legitimately take minutes, so the\n * host resets the budget before each re-entry (see resetBudget calls).\n *\n * The per-burst ceiling is the same configurable budget as the node\n * engine's ReplayBudget (REPLAY_TIMEOUT_MS, default 240s): a workflow\n * whose replay the node engine handles fine must not be interrupted here\n * by a lower hardcoded ceiling. The interrupt error escapes\n * runQuickJSWorkflow and reaches the replay loop's catch in runtime.ts,\n * which records run_failed.\n */\ninterface InterruptBudget {\n  start: number;\n}\n\nfunction createInterruptHandler(budget: InterruptBudget): () => boolean {\n  const timeout = getReplayTimeoutMs();\n  return () => Date.now() - budget.start > timeout;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quickjs-runtime.js","sourceRoot":"","sources":["../../src/runtime/quickjs-runtime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * QuickJS WASM workflow VM.\n *\n * An alternative engine for the event-replay execution model: the workflow\n * code runs inside a QuickJS WASM VM (via quickjs-wasi) instead of a\n * `node:vm` context. Every invocation creates a fresh VM, re-executes the\n * workflow function from the top, and replays the recorded event log to\n * resolve awaited primitives — the same replay semantics as the `node:vm`\n * engine.\n *\n * The workflow primitives (useStep, sleep, createHook) are implemented as\n * JavaScript code running inside the QuickJS VM. The host communicates with\n * the VM by evaluating small JS snippets to read pending operations and\n * resolve/reject promises.\n *\n * The VM bootstrap is deliberately split into two phases:\n *   1. Static initialization (`initWorkflowVM`) — run-independent setup:\n *      VM creation and the workflow primitives. (Serialization lives on\n *      the host — see quickjs-serde.ts — so no serde code is evaluated\n *      in the VM.)\n *   2. Per-run initialization (inline in `runQuickJSWorkflow`) — seeded\n *      PRNG/ULID host functions, workflow bundle evaluation, run metadata,\n *      workflow input, and start.\n * Keeping the phases separate is groundwork for VM-memory snapshotting:\n * a follow-up can persist/restore the VM at the phase boundary (e.g. a\n * build-time initial snapshot) without restructuring this module. Note\n * that bundle evaluation currently sits in the per-run phase so that\n * module-scope user code observes the seeded `Math.random`, matching the\n * `node:vm` engine's replay determinism.\n */\n\nimport type {\n  Event,\n  RunInput,\n  WorkflowRun,\n  WorldCapabilities,\n} from '@workflow/world';\nimport * as nanoid from 'nanoid';\nimport {\n  type ExtensionDescriptor,\n  JSException,\n  QuickJS,\n  type Snapshot,\n  type WasiOptions,\n} from 'quickjs-wasi';\nimport seedrandom from 'seedrandom';\nimport { monotonicFactory } from 'ulid';\nimport { runtimeLogger } from '../logger.js';\nimport { decompress } from '../serialization/compression.js';\nimport type { DecryptionKey } from '../serialization/encryption.js';\nimport { decrypt } from '../serialization/encryption.js';\nimport {\n  getReplayTimeoutMs,\n  isQuickJSBaselineSnapshotEnabled,\n} from './constants.js';\nimport { quickjsExtensions, quickjsWasm } from './quickjs-assets.generated.js';\nimport {\n  adoptSerdeRoot,\n  captureSerdeRoot,\n  createQuickJSSerde,\n  exportSerdeRoot,\n  type QuickJSSerde,\n} from './quickjs-serde.js';\nimport { runIdCreatedAt } from './run-id-time.js';\n\n// ---- Host -> VM payload preparation ----\n\n/**\n * Prepare persisted payload bytes for consumption inside the VM: decrypt\n * (when an encryption key is configured) and decompress (specVersion >= 5\n * payloads may be gzip/zstd-compressed). The VM only understands plain\n * format-prefixed 'devl' bytes — it has neither the key material nor zlib.\n * The key is the run's full DecryptionKey capability (symmetric AES key +\n * X25519 keypair) so sealed `encp` hook payloads from cross-deployment\n * resumeHook() calls open here too, not just symmetric `encr` ones.\n * Both stages are format-prefix dispatched, so plaintext/uncompressed\n * data passes through unchanged. Mirrors `prepareReplayPayload` in\n * serialization.ts (the node:vm engine's equivalent host-side stage).\n */\nasync function prepareBytesForVM(\n  data: Uint8Array,\n  key?: DecryptionKey\n): Promise<Uint8Array> {\n  return (await decompress(await decrypt(data, key))) as Uint8Array;\n}\n\n// ---- Types ----\n\nexport interface PendingStep {\n  type: 'step';\n  correlationId: string;\n  stepId: string;\n  /** Format-prefixed devalue-serialized step input (args + closureVars) */\n  input: Uint8Array;\n  /** Whether a step_created event already exists for this step */\n  hasCreatedEvent: boolean;\n}\n\nexport interface PendingWait {\n  type: 'wait';\n  correlationId: string;\n  /** ISO string of when to resume */\n  resumeAt: string;\n  /** Whether a wait_created event already exists for this wait */\n  hasCreatedEvent: boolean;\n}\n\nexport interface PendingHook {\n  type: 'hook';\n  correlationId: string;\n  token: string;\n  /** Earliest token reuse time, as milliseconds since the Unix epoch. */\n  tokenRetentionUntil?: number;\n  isWebhook: boolean;\n  metadata?: unknown;\n  hasCreatedEvent: boolean;\n  /**\n   * True for internal system hooks (e.g. AbortController's hook), which\n   * are exempt from user-hook token namespace conflict checks.\n   */\n  isSystem?: boolean;\n  /**\n   * Set when the workflow called AbortController.abort() during this\n   * invocation. The host must record the abort: create a hook_received\n   * event carrying `abortPayload` and write/close the abort stream.\n   */\n  abortRequested?: boolean;\n  /** VM-serialized `{ aborted: true, reason }` payload for the abort. */\n  abortPayload?: Uint8Array;\n  /** Set by the completion drain when a system hook is implicitly disposed. */\n  disposed?: boolean;\n  /**\n   * True when the workflow is awaiting hook.getConflict() for this hook.\n   * The entrypoint re-invokes the workflow right after writing\n   * hook_created so replay can confirm creation and resolve the awaiter.\n   */\n  hasGetConflictAwaiter?: boolean;\n}\n\nexport interface PendingAttribute {\n  type: 'attribute';\n  correlationId: string;\n  /** Normalized attribute changes (plain JSON-able objects) */\n  changes: unknown[];\n  allowReservedAttributes?: boolean;\n  /** Whether an attr_set event already exists for this write */\n  hasCreatedEvent: boolean;\n}\n\nexport interface PendingHookDispose {\n  type: 'hook_dispose';\n  correlationId: string;\n  /**\n   * Token of the hook being disposed. Used by the entrypoint to order\n   * same-token hook operations sequentially in code order.\n   */\n  token?: string;\n  hasCreatedEvent: boolean;\n}\n\nexport type PendingOperation =\n  | PendingStep\n  | PendingWait\n  | PendingHook\n  | PendingAttribute\n  | PendingHookDispose;\n\nexport interface QuickJSRuntimeResult {\n  /** The workflow completed — result is format-prefixed devalue bytes */\n  completed?: {\n    result: Uint8Array;\n    /**\n     * Leftover pending operations that still need durable side effects at\n     * completion: abort recordings, system-hook disposals, fire-and-forget\n     * attribute/hook/step events. Mirrors the node:vm engine's\n     * drainPendingQueueItems. The entrypoint dispatches these WITHOUT\n     * queueing steps or requeuing the run.\n     */\n    drainOperations?: PendingOperation[];\n  };\n  /** The workflow suspended with pending operations */\n  suspended?: {\n    pendingOperations: PendingOperation[];\n  };\n  /** The workflow failed */\n  failed?: {\n    message: string;\n    stack?: string;\n    name?: string;\n    /** See completed.drainOperations — same semantics on failure. */\n    drainOperations?: PendingOperation[];\n    /**\n     * Format-prefixed devalue bytes of the original thrown value\n     * (Error subclass with cause chain, plain object, primitive, etc.).\n     * Set when the VM-side rejection handler successfully serializes\n     * the thrown value. The host uses these bytes to reconstruct the\n     * original value through the standard error hydration pipeline,\n     * preserving type identity (TypeError, FatalError) and non-Error\n     * throws verbatim. Falls back to the message/stack/name fields\n     * when this is undefined (e.g. extractError pseudo-failures).\n     */\n    valueBytes?: Uint8Array;\n  };\n}\n\nexport interface QuickJSRuntimeOptions {\n  /** The compiled workflow bundle code (workflow mode output from SWC) */\n  workflowCode: string;\n  /** The workflow ID (e.g. \"workflow//./workflows/1_simple//simple\") */\n  workflowId: string;\n  /** The workflow run entity */\n  workflowRun: WorkflowRun;\n  /** Features supported by the World executing this workflow. */\n  worldCapabilities?: WorldCapabilities;\n  /**\n   * The full event log for the run. Every invocation replays the complete\n   * log from the start (same replay semantics as the `node:vm` engine).\n   */\n  events: Event[];\n  /** Encryption key for decrypting event payloads (undefined if unencrypted) */\n  encryptionKey?: DecryptionKey;\n  /**\n   * The local port the workflow server is listening on, used to populate\n   * `workflowMetadata.url`. Resolved at call time on the host side so the\n   * VM doesn't have to probe the filesystem. Ignored on Vercel — VERCEL_URL\n   * takes precedence there.\n   */\n  port?: number;\n  /**\n   * Fallback workflow input from the queue message's resilient-start\n   * payload. Used when the fetched event log lacks a `run_created` event\n   * (eventually-consistent read after the parent's start() wrote it).\n   */\n  runInput?: RunInput;\n}\n\n// ---- VM Bootstrap Code ----\n\n/**\n * JavaScript code that runs inside the QuickJS VM to set up the workflow\n * primitives. This sets up:\n * - globalThis.__private_workflows (Map) - workflow registry\n * - globalThis.__resolvers (Object) - pending promise resolve/reject functions\n * - globalThis.__pending (Array) - metadata about pending operations\n * - globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")] - step proxy factory\n * - globalThis[Symbol.for(\"WORKFLOW_SLEEP\")] - sleep function\n */\nconst VM_BOOTSTRAP = `\n// Symbol.dispose / Symbol.asyncDispose polyfills for QuickJS\nif (typeof Symbol.dispose === \"undefined\") {\n  Symbol.dispose = Symbol.for(\"Symbol.dispose\");\n}\nif (typeof Symbol.asyncDispose === \"undefined\") {\n  Symbol.asyncDispose = Symbol.for(\"Symbol.asyncDispose\");\n}\n\nglobalThis.__private_workflows = new Map();\nglobalThis.__resolvers = {};\nglobalThis.__pending = [];\nglobalThis.__workflowResult = undefined;\nglobalThis.__workflowError = undefined;\n// Buffer for hook_received payloads that arrive before the hook is awaited.\n// Keyed by correlationId → array of payloads (preserves delivery order).\n// This mirrors the event-replay runtime's payloadsQueue in hook.ts.\nglobalThis.__hookPayloadBuffer = {};\n\n// Buffer for step/wait/attr terminal outcomes that arrive before this VM\n// has constructed the corresponding awaiting promise. In fresh-VM replay\n// the multi-pass event scan makes this unreachable (awaits are\n// reconstructed before their terminals are re-scanned), but the live\n// continuation path (continueWithEvents) scans each delta exactly once —\n// a concurrent invocation's terminal arriving before this VM reaches the\n// await would otherwise be dropped on the floor and the await would\n// never settle (the feed's seen-set means it is never re-delivered).\n// Mirrors __hookPayloadBuffer, which exists for exactly this reason on\n// the hook path. Keyed by correlationId → single terminal (steps, waits\n// and attrs settle exactly once).\nglobalThis.__terminalBuffer = {};\n\n// Registers a resolver for an awaited primitive, first draining any\n// buffered terminal recorded for the correlationId. Entries are prepared\n// host-side: bytes are decrypted AND deserialized into VM values by the\n// host serde before buffering (the VM has no in-guest deserializer on\n// the host-serde engine), so draining only forwards the stored value.\nglobalThis.__registerResolver = function(correlationId, resolve, reject) {\n  var buffered = globalThis.__terminalBuffer[correlationId];\n  if (buffered) {\n    delete globalThis.__terminalBuffer[correlationId];\n    if (buffered.kind === \"resolve_value\") {\n      resolve(buffered.value);\n    } else if (buffered.kind === \"reject_value\") {\n      reject(buffered.value);\n    } else if (buffered.kind === \"reject_error\") {\n      var e = new Error(buffered.message);\n      e.name = \"FatalError\";\n      e.fatal = true;\n      if (buffered.stack) e.stack = buffered.stack;\n      reject(e);\n    } else {\n      resolve(undefined);\n    }\n    return;\n  }\n  globalThis.__resolvers[correlationId] = { resolve: resolve, reject: reject };\n};\n\n// Stubs for Web APIs that the workflow bundle may reference but are not\n// available in QuickJS. Native C extensions (encoding, headers, url,\n// structured-clone) provide the real implementations; these are minimal\n// stubs for APIs that don't have native extensions yet. (btoa/atob and\n// the Uint8Array base64/hex methods are built into quickjs-wasi >= 3.)\n\nif (typeof ReadableStream === \"undefined\") {\n  // Minimal ReadableStream that stores body data for Response.json()/text()\n  globalThis.ReadableStream = function() {};\n  globalThis.ReadableStream.prototype.__bodyData = null;\n}\n\nif (typeof WritableStream === \"undefined\") {\n  globalThis.WritableStream = function() {};\n}\n\nif (typeof TransformStream === \"undefined\") {\n  globalThis.TransformStream = function() {};\n}\n\nif (typeof console === \"undefined\") {\n  globalThis.console = { log: function(){}, error: function(){}, warn: function(){}, info: function(){} };\n}\n// Stub exports/module for CJS bundle format\nglobalThis.exports = {};\nglobalThis.module = { exports: globalThis.exports };\n// NOTE: TextEncoder/TextDecoder are provided by the native encoding extension.\n\n// ---- Deterministic \\`crypto\\` (parity with the node:vm engine) ----\n// getRandomValues / randomUUID draw from Math.random, which the host\n// replaces with the run's seeded PRNG before any user code runs — so the\n// values replay deterministically and match the node engine, whose\n// implementations draw from the same seeded sequence (see vm/index.ts).\n// Every crypto.subtle method throws with the same guidance as the node\n// engine's non-replayable methods; unlike node, \\`digest\\` is also\n// unavailable here (no native hash in the VM yet).\n(function() {\n  function getRandomValues(array) {\n    for (var i = 0; i < array.length; i++) {\n      array[i] = Math.floor(Math.random() * 256);\n    }\n    return array;\n  }\n  // Mirrors vm/uuid.ts createRandomUUID: identical draw pattern from the\n  // seeded PRNG, so both engines produce the same UUID at the same point\n  // in a replay.\n  function randomUUID() {\n    var chars = \"0123456789abcdef\";\n    var uuid = \"\";\n    for (var i = 0; i < 36; i++) {\n      if (i === 8 || i === 13 || i === 18 || i === 23) {\n        uuid += \"-\";\n      } else if (i === 14) {\n        uuid += \"4\";\n      } else if (i === 19) {\n        uuid += chars[Math.floor(Math.random() * 4) + 8];\n      } else {\n        uuid += chars[Math.floor(Math.random() * 16)];\n      }\n    }\n    return uuid;\n  }\n  function subtleThrow(name) {\n    return function() {\n      var err = new Error(\"\\`crypto.subtle.\" + name + \"()\\` is not available inside a workflow function. Move it to a step function where full Node.js crypto is available.\");\n      err.name = \"WorkflowRuntimeError\";\n      throw err;\n    };\n  }\n  var subtle = {};\n  [\"encrypt\",\"decrypt\",\"sign\",\"verify\",\"digest\",\"generateKey\",\"deriveKey\",\"deriveBits\",\"importKey\",\"exportKey\",\"wrapKey\",\"unwrapKey\"].forEach(function(m) {\n    subtle[m] = subtleThrow(m);\n  });\n  globalThis.crypto = {\n    getRandomValues: getRandomValues,\n    randomUUID: randomUUID,\n    subtle: subtle,\n  };\n})();\n\n// ---- Loud Intl / locale guards ----\n// QuickJS has no ICU: \\`Intl\\` is absent and toLocaleString-family methods\n// silently ignore their locale argument. Silent divergence from the node\n// engine would write different values into a durable event log with no\n// error anywhere — so make the gap loud instead: Intl constructors throw,\n// and toLocale* methods throw ONLY when called with an explicit locale\n// (the no-argument forms keep QuickJS's default behavior).\n(function() {\n  function intlThrow(name) {\n    return function() {\n      var err = new Error(\"\\`Intl.\" + name + \"\\` is not available in the QuickJS workflow engine (no ICU). Perform locale-sensitive formatting in a step function, or use WORKFLOW_VM=node.\");\n      err.name = \"WorkflowRuntimeError\";\n      throw err;\n    };\n  }\n  if (typeof Intl === \"undefined\") {\n    var intl = {};\n    [\"Collator\",\"DateTimeFormat\",\"DisplayNames\",\"DurationFormat\",\"ListFormat\",\"Locale\",\"NumberFormat\",\"PluralRules\",\"RelativeTimeFormat\",\"Segmenter\"].forEach(function(n) {\n      intl[n] = intlThrow(n);\n    });\n    intl.getCanonicalLocales = intlThrow(\"getCanonicalLocales\");\n    globalThis.Intl = intl;\n  }\n  function guardLocale(proto, method) {\n    var original = proto[method];\n    if (typeof original !== \"function\") return;\n    proto[method] = function(locales) {\n      if (locales !== undefined) {\n        var err = new Error(\"\\`\" + method + \"(locales, ...)\\` with an explicit locale is not supported in the QuickJS workflow engine (no ICU) — it would silently ignore the locale. Format in a step function, or call without arguments for the engine default.\");\n        err.name = \"WorkflowRuntimeError\";\n        throw err;\n      }\n      return original.call(this);\n    };\n  }\n  guardLocale(Number.prototype, \"toLocaleString\");\n  guardLocale(Date.prototype, \"toLocaleString\");\n  guardLocale(Date.prototype, \"toLocaleDateString\");\n  guardLocale(Date.prototype, \"toLocaleTimeString\");\n  guardLocale(String.prototype, \"toLocaleLowerCase\");\n  guardLocale(String.prototype, \"toLocaleUpperCase\");\n  // localeCompare's locales argument is the SECOND parameter.\n  (function() {\n    var original = String.prototype.localeCompare;\n    String.prototype.localeCompare = function(that, locales) {\n      if (locales !== undefined) {\n        var err = new Error(\"\\`localeCompare(that, locales, ...)\\` with an explicit locale is not supported in the QuickJS workflow engine (no ICU). Compare in a step function, or call without a locale.\");\n        err.name = \"WorkflowRuntimeError\";\n        throw err;\n      }\n      return original.call(this, that);\n    };\n  })();\n})();\n\nglobalThis[Symbol.for(\"WORKFLOW_USE_STEP\")] = function(stepId, closureVarsFn) {\n  var fn = function() {\n    var args = Array.prototype.slice.call(arguments);\n    var correlationId = \"step_\" + globalThis.__generateUlid();\n    // Capture 'this' for method invocations (e.g., MyClass.method())\n    var thisVal = (this !== undefined && this !== null && this !== globalThis) ? this : undefined;\n    // The RAW input value. Serialization happens on the host, which reads\n    // this through a handle when it collects the pending op — no\n    // serializer code runs inside the VM.\n    var input = {\n      args: args,\n      closureVars: closureVarsFn ? closureVarsFn() : undefined,\n      thisVal: thisVal,\n    };\n    globalThis.__pending.push({\n      type: \"step\",\n      correlationId: correlationId,\n      stepId: stepId,\n      input: input,\n      hasCreatedEvent: false,\n    });\n    return new Promise(function(resolve, reject) {\n      globalThis.__registerResolver(correlationId, resolve, reject);\n    });\n  };\n  // Set stepId on the proxy so the StepFunction reducer can detect and\n  // serialize step function references (e.g. when passed as arguments).\n  fn.stepId = stepId;\n  if (closureVarsFn) fn.__closureVarsFn = closureVarsFn;\n  // Override .bind so a bound step proxy (e.g. the SWC plugin's\n  // useStep(...).bind(this) for lexical-this arrow steps) keeps its\n  // stepId and records the bound receiver / prefilled args — the native\n  // bind drops own properties, which would make the StepFunction\n  // reducer fail to recognize the proxy when it crosses a serialization\n  // boundary. Mirrors the node:vm engine's override in step.ts.\n  fn.bind = function(thisArg) {\n    var partialArgs = Array.prototype.slice.call(arguments, 1);\n    var bound = Function.prototype.bind.apply(this, [thisArg].concat(partialArgs));\n    bound.stepId = stepId;\n    if (closureVarsFn) bound.__closureVarsFn = closureVarsFn;\n    bound.__boundThis = thisArg;\n    if (partialArgs.length > 0) bound.__boundArgs = partialArgs;\n    return bound;\n  };\n  return fn;\n};\n\n// Parses an \"ms\" library style duration string into milliseconds.\n// Supports the same units as the replay runtime (which uses the \"ms\"\n// package): ms / s / m / h / d / w / y, with verbose aliases\n// (seconds, minutes, ...).\nglobalThis.__parseDurationMs = function(str) {\n  str = String(str);\n  if (str.length > 100) return undefined;\n  var match = str.match(\n    /^(-?(?:\\\\d+)?\\\\.?\\\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i\n  );\n  if (!match) return undefined;\n  var n = parseFloat(match[1]);\n  var type = (match[2] || \"ms\").toLowerCase();\n  var s = 1000, m = 60 * s, h = 60 * m, d = 24 * h, w = 7 * d, y = 365.25 * d;\n  switch (type) {\n    case \"years\": case \"year\": case \"yrs\": case \"yr\": case \"y\": return n * y;\n    case \"weeks\": case \"week\": case \"w\": return n * w;\n    case \"days\": case \"day\": case \"d\": return n * d;\n    case \"hours\": case \"hour\": case \"hrs\": case \"hr\": case \"h\": return n * h;\n    case \"minutes\": case \"minute\": case \"mins\": case \"min\": case \"m\": return n * m;\n    case \"seconds\": case \"second\": case \"secs\": case \"sec\": case \"s\": return n * s;\n    case \"milliseconds\": case \"millisecond\": case \"msecs\": case \"msec\": case \"ms\": return n;\n    default: return undefined;\n  }\n};\n\nglobalThis[Symbol.for(\"WORKFLOW_SLEEP\")] = function(param) {\n  var correlationId = \"wait_\" + globalThis.__generateUlid();\n  var resumeAt;\n  if (typeof param === \"number\") {\n    resumeAt = new Date(Date.now() + param).toISOString();\n  } else if (typeof param === \"string\") {\n    var ms = globalThis.__parseDurationMs(param);\n    if (typeof ms === \"number\" && isFinite(ms)) {\n      resumeAt = new Date(Date.now() + ms).toISOString();\n    } else {\n      // Not a duration string — try as an absolute date string.\n      var date = new Date(param);\n      if (isNaN(date.getTime())) {\n        throw new Error(\"Invalid sleep parameter: \" + param);\n      }\n      resumeAt = date.toISOString();\n    }\n  } else if (param instanceof Date) {\n    if (isNaN(param.getTime())) {\n      throw new Error(\"Invalid sleep parameter: \" + param);\n    }\n    resumeAt = param.toISOString();\n  } else {\n    throw new Error(\"Invalid sleep parameter: \" + param);\n  }\n  globalThis.__pending.push({\n    type: \"wait\",\n    correlationId: correlationId,\n    resumeAt: resumeAt,\n    hasCreatedEvent: false,\n  });\n  return new Promise(function(resolve, reject) {\n    globalThis.__registerResolver(correlationId, resolve, reject);\n  });\n};\n\n// Response/Request polyfills — .json()/.text()/.arrayBuffer() are useStep\n// proxies that execute on the host side. The proxies are assigned directly\n// to the prototypes so that 'this' (the Response/Request instance) is\n// serialized as thisVal by WORKFLOW_USE_STEP, matching the event-replay\n// runtime's approach (commit dcb0761).\nif (typeof Response === \"undefined\") {\n  var __BODY_INIT = Symbol.for(\"BODY_INIT\");\n\n  globalThis.Response = function(body, init) {\n    init = init || {};\n    this.status = init.status || 200;\n    this.statusText = init.statusText || \"\";\n    this.headers = new globalThis.Headers(init.headers || []);\n    this.type = \"default\";\n    this.url = \"\";\n    this.redirected = false;\n    if (body !== null && body !== undefined) {\n      this.body = Object.create(globalThis.ReadableStream.prototype);\n      this.body[__BODY_INIT] = body;\n    } else {\n      this.body = null;\n    }\n  };\n  Object.defineProperty(globalThis.Response.prototype, \"ok\", {\n    get: function() { return this.status >= 200 && this.status < 300; }\n  });\n  Object.defineProperty(globalThis.Response.prototype, \"bodyUsed\", {\n    get: function() { return false; }\n  });\n  // Assign useStep proxies directly — 'this' binding provides the\n  // Response instance, which gets serialized as thisVal by the proxy.\n  Object.defineProperties(globalThis.Response.prototype, {\n    arrayBuffer: { value: globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"__builtin_response_array_buffer\"), writable: true, configurable: true },\n    json: { value: globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"__builtin_response_json\"), writable: true, configurable: true },\n    text: { value: globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"__builtin_response_text\"), writable: true, configurable: true },\n  });\n  globalThis.Response.prototype.bytes = function() {\n    return this.arrayBuffer().then(function(buf) { return new Uint8Array(buf); });\n  };\n  globalThis.Response.prototype.clone = function() {\n    var r = Object.create(globalThis.Response.prototype);\n    r.status = this.status; r.statusText = this.statusText;\n    r.headers = this.headers; r.type = this.type;\n    r.url = this.url; r.redirected = this.redirected; r.body = this.body;\n    return r;\n  };\n  globalThis.Response.json = function(data, init) {\n    var body = JSON.stringify(data);\n    var headers = new globalThis.Headers(init ? init.headers : []);\n    if (!headers.has(\"content-type\")) { headers.set(\"content-type\", \"application/json\"); }\n    return new globalThis.Response(body, { status: (init && init.status) || 200, statusText: (init && init.statusText) || \"\", headers: headers });\n  };\n}\nif (typeof Request === \"undefined\") {\n  globalThis.Request = function(input, init) {\n    init = init || {};\n    if (typeof input === \"string\") { this.url = input; }\n    else if (input && typeof input === \"object\") {\n      this.url = input.url || \"\"; this.method = input.method;\n      this.headers = input.headers; this.body = input.body;\n    }\n    if (init.method) this.method = init.method.toUpperCase();\n    if (!this.method) this.method = \"GET\";\n    if (init.headers) this.headers = new globalThis.Headers(init.headers);\n    if (!this.headers) this.headers = new globalThis.Headers();\n    if (init.body !== undefined) this.body = init.body;\n    if (!this.body) this.body = null;\n    this.duplex = init.duplex || \"half\";\n  };\n  Object.defineProperty(globalThis.Request.prototype, \"bodyUsed\", {\n    get: function() { return false; }\n  });\n  Object.defineProperties(globalThis.Request.prototype, {\n    arrayBuffer: { value: globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"__builtin_response_array_buffer\"), writable: true, configurable: true },\n    json: { value: globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"__builtin_response_json\"), writable: true, configurable: true },\n    text: { value: globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"__builtin_response_text\"), writable: true, configurable: true },\n  });\n}\n\n// createHook — returns a Hook object that is both a Thenable and AsyncIterable.\n// Each await/yield creates a new promise keyed by the same correlationId.\n// The promise is resolved when a hook_received event arrives.\nglobalThis[Symbol.for(\"WORKFLOW_CREATE_HOOK\")] = function(options) {\n  options = options || {};\n  if (options.isWebhook === true && options.experimental_minRetention !== undefined) {\n    throw new Error('Webhook hooks do not support \\`experimental_minRetention\\`. Use a non-webhook \\`createHook()\\` with \\`resumeHook()\\`.');\n  }\n  if (options.experimental_minRetention !== undefined && globalThis.__worldCapabilities?.hookRetention?.active !== true) {\n    var unsupportedRetentionError = new Error('The configured World does not support \\`experimental_minRetention\\` for Hooks.');\n    unsupportedRetentionError.name = \"FatalError\";\n    unsupportedRetentionError.fatal = true;\n    throw unsupportedRetentionError;\n  }\n  var token = options.token || globalThis.__generateNanoid();\n  var correlationId = \"hook_\" + globalThis.__generateUlid();\n  var isDisposed = false;\n  var hasCreatedEvent = false;\n  var tokenRetentionUntil;\n  if (options.experimental_minRetention !== undefined) {\n    var minRetention = options.experimental_minRetention;\n    if (typeof minRetention === \"number\") {\n      if (minRetention < 0 || !isFinite(minRetention)) {\n        throw new Error(\"Invalid duration: \" + minRetention + \". Expected a non-negative finite number of milliseconds.\");\n      }\n      tokenRetentionUntil = Date.now() + minRetention;\n    } else if (typeof minRetention === \"string\") {\n      var retentionMs = globalThis.__parseDurationMs(minRetention);\n      if (typeof retentionMs !== \"number\" || retentionMs < 0 || !isFinite(retentionMs)) {\n        throw new Error('Invalid duration: \"' + minRetention + '\". Expected a valid duration string like \"1s\", \"1m\", \"1h\", etc.');\n      }\n      tokenRetentionUntil = Date.now() + retentionMs;\n    } else if (minRetention instanceof Date || (minRetention && typeof minRetention.getTime === \"function\")) {\n      // Accept Date-like objects (anything with getTime), matching\n      // parseDurationToDate: values that crossed the serde boundary may\n      // not be realm-native Date instances.\n      tokenRetentionUntil = minRetention.getTime();\n    } else {\n      throw new Error(\"Invalid duration parameter. Expected a duration string, number (milliseconds), or Date object.\");\n    }\n  }\n\n  // Register in pending operations. Metadata stays a RAW value; the host\n  // serializes it through a handle when it collects the pending op.\n  var pendingOp = {\n    type: \"hook\",\n    correlationId: correlationId,\n    token: token,\n    tokenRetentionUntil: tokenRetentionUntil,\n    isWebhook: !!options.isWebhook,\n    metadata: options.metadata,\n    hasCreatedEvent: false,\n  };\n  globalThis.__pending.push(pendingOp);\n\n  // Per-hook lifecycle state backing hook.getConflict(): resolves null\n  // once creation is confirmed (hook_created), or resolves with the\n  // conflicting Run handle / rejects with HookConflictError on\n  // hook_conflict. State transitions are driven by the host during event\n  // processing (see processEvents).\n  globalThis.__hooks = globalThis.__hooks || {};\n  globalThis.__hooks[correlationId] = {\n    token: token,\n    created: false,\n    conflict: null,\n    getConflictResolvers: [],\n  };\n\n  // Each await creates a new promise for the next payload.\n  // The correlationId stays the same — the resolver is replaced each time.\n  function createHookPromise() {\n    // Check the payload buffer first — if a hook_received event arrived\n    // before this hook was awaited, the payload was buffered in the VM\n    // heap. Drain it immediately (matching event-replay payloadsQueue).\n    var buf = globalThis.__hookPayloadBuffer[correlationId];\n    if (buf && buf.length > 0) {\n      return Promise.resolve(buf.shift());\n    }\n    return new Promise(function(resolve, reject) {\n      globalThis.__resolvers[correlationId] = { resolve: resolve, reject: reject };\n    });\n  }\n\n  function disposeHook() {\n    if (isDisposed) return;\n    isDisposed = true;\n    // A conflicted hook was never created (the world rejected its claim\n    // — the token belongs to another run), so there is no entity to\n    // dispose. Mirrors the node:vm engine, where hook_conflict removes\n    // the invocation-queue item before dispose can mark it. Emitting a\n    // hook_disposed here would be rejected by the world's\n    // hook-existence validation.\n    var state = globalThis.__hooks[correlationId];\n    if (!state || !state.conflict) {\n      // Signal to the entrypoint to create a hook_disposed event. The\n      // token is carried so the entrypoint can order same-token hook\n      // operations sequentially (a dispose must release the token before\n      // a later same-token hook's creation is validated).\n      globalThis.__pending.push({\n        type: \"hook_dispose\",\n        correlationId: correlationId,\n        token: token,\n        hasCreatedEvent: false,\n      });\n    }\n    // If there's a pending resolver, resolve it with undefined to break the iterator\n    if (globalThis.__resolvers[correlationId]) {\n      globalThis.__resolvers[correlationId].resolve(undefined);\n      delete globalThis.__resolvers[correlationId];\n    }\n  }\n\n  function getConflict() {\n    var state = globalThis.__hooks[correlationId];\n    if (state.conflict) {\n      return state.conflict.run\n        ? Promise.resolve(state.conflict.run)\n        : Promise.reject(state.conflict.error);\n    }\n    if (state.created) {\n      return Promise.resolve(null);\n    }\n    // Creation not yet confirmed by the event log — park the awaiter and\n    // flag the pending op so the entrypoint re-invokes the workflow right\n    // after writing hook_created (nothing external resumes a getConflict\n    // awaiter; confirmation only comes from replaying the new event).\n    pendingOp.hasGetConflictAwaiter = true;\n    return new Promise(function(resolve, reject) {\n      state.getConflictResolvers.push({ resolve: resolve, reject: reject });\n    });\n  }\n\n  var hook = {\n    token: token,\n    then: function(onFulfilled, onRejected) {\n      return createHookPromise().then(onFulfilled, onRejected);\n    },\n    getConflict: getConflict,\n    dispose: disposeHook,\n  };\n\n  // Symbol.dispose for explicit resource management\n  hook[Symbol.dispose] = disposeHook;\n\n  // AsyncIterable — yields payloads until disposed\n  hook[Symbol.asyncIterator] = function() {\n    return {\n      next: function() {\n        if (isDisposed) {\n          return Promise.resolve({ done: true, value: undefined });\n        }\n        return createHookPromise().then(function(value) {\n          // If disposed while waiting, signal done\n          if (isDisposed) return { done: true, value: undefined };\n          return { done: false, value: value };\n        });\n      },\n      return: function() {\n        disposeHook();\n        return Promise.resolve({ done: true, value: undefined });\n      },\n    };\n  };\n\n  return hook;\n};\n\n// setAttributes — attaches plaintext metadata to the current run.\n// Validation happens in library code (normalizeAttributeChanges) before\n// this dispatcher is invoked, so \"changes\" is already normalized. The\n// returned promise resolves when the matching attr_set event is\n// observed during event processing — mirroring the node:vm engine's\n// createSetAttributes (attribute-dispatcher.ts).\nglobalThis[Symbol.for(\"WORKFLOW_SET_ATTRIBUTES\")] = function(changes, options) {\n  var correlationId = \"attr_\" + globalThis.__generateUlid();\n  globalThis.__pending.push({\n    type: \"attribute\",\n    correlationId: correlationId,\n    changes: changes,\n    allowReservedAttributes: !!(options && options.allowReservedAttributes),\n    hasCreatedEvent: false,\n  });\n  return new Promise(function(resolve, reject) {\n    globalThis.__registerResolver(correlationId, resolve, reject);\n  });\n};\n\n// ---- AbortController / AbortSignal (hook-backed) ----\n// Port of workflow/abort-controller.ts to the VM pending-op model:\n// the controller registers a system hook; abort() flips the signal\n// synchronously and marks the pending op so the host records the abort\n// (hook_received event + stream packet). On replay, the recorded\n// hook_received event calls _setAborted during event processing and the\n// workflow's own abort() call becomes a no-op.\nvar __ABORT_STREAM_NAME = Symbol.for(\"WORKFLOW_ABORT_STREAM_NAME\");\nvar __ABORT_HOOK_TOKEN = Symbol.for(\"WORKFLOW_ABORT_HOOK_TOKEN\");\n\nfunction __makeAbortError() {\n  if (typeof DOMException !== \"undefined\") {\n    return new DOMException(\"The operation was aborted.\", \"AbortError\");\n  }\n  var e = new Error(\"The operation was aborted.\");\n  e.name = \"AbortError\";\n  return e;\n}\n\nfunction WorkflowAbortSignal(streamName, hookToken) {\n  this.aborted = false;\n  this.reason = undefined;\n  this[__ABORT_STREAM_NAME] = streamName;\n  this[__ABORT_HOOK_TOKEN] = hookToken;\n  this.__listeners = [];\n  this.__onabort = null;\n}\nObject.defineProperty(WorkflowAbortSignal.prototype, \"onabort\", {\n  get: function() { return this.__onabort; },\n  set: function(handler) {\n    this.__onabort = handler;\n    if (handler && this.aborted) handler.call(this);\n  },\n});\nWorkflowAbortSignal.prototype._setAborted = function(reason) {\n  if (this.aborted) return;\n  this.aborted = true;\n  this.reason = reason;\n  if (this.__onabort) this.__onabort.call(this);\n  var listeners = this.__listeners;\n  this.__listeners = [];\n  for (var i = 0; i < listeners.length; i++) listeners[i]();\n};\nWorkflowAbortSignal.prototype.addEventListener = function(type, listener) {\n  if (type !== \"abort\") return;\n  if (this.aborted) {\n    // Fire synchronously (not on a microtask) for deterministic replay —\n    // matches the node:vm engine's WorkflowAbortSignal.\n    listener();\n    return;\n  }\n  this.__listeners.push(listener);\n};\nWorkflowAbortSignal.prototype.removeEventListener = function(type, listener) {\n  if (type !== \"abort\") return;\n  this.__listeners = this.__listeners.filter(function(l) { return l !== listener; });\n};\nWorkflowAbortSignal.prototype.throwIfAborted = function() {\n  if (this.aborted) {\n    throw this.reason !== undefined && this.reason !== null\n      ? this.reason\n      : __makeAbortError();\n  }\n};\n// Expose for the host serde's revivers (they look the class up lazily,\n// through a handle, at revive time).\nglobalThis.__WorkflowAbortSignal = WorkflowAbortSignal;\n\n// Registry of live abort signals keyed by their hook correlationId. The\n// host delivers hook_received events for these ids as _setAborted calls.\nglobalThis.__abortSignals = {};\n\nglobalThis.AbortController = function WorkflowAbortController() {\n  var id = globalThis.__generateUlid();\n  var streamName = \"strm_\" + id + \"_system_abort\";\n  var hookToken = \"abrt_\" + id;\n  this[__ABORT_STREAM_NAME] = streamName;\n  this[__ABORT_HOOK_TOKEN] = hookToken;\n  this.signal = new WorkflowAbortSignal(streamName, hookToken);\n  var correlationId = \"hook_\" + globalThis.__generateUlid();\n  // Register an internal system hook. isSystem prevents token namespace\n  // conflicts with user hooks.\n  globalThis.__pending.push({\n    type: \"hook\",\n    correlationId: correlationId,\n    token: hookToken,\n    isWebhook: false,\n    isSystem: true,\n    hasCreatedEvent: false,\n  });\n  globalThis.__abortSignals[correlationId] = this.signal;\n};\nglobalThis.AbortController.prototype.abort = function(reason) {\n  if (this.signal.aborted) return; // already aborted (e.g. from replay)\n  this.signal._setAborted(reason);\n  // Mark the pending hook op so the host records the abort. The payload\n  // stays a RAW value; the host serializes it through a handle with full\n  // type fidelity (Errors, DOMException, custom values).\n  var token = this[__ABORT_HOOK_TOKEN];\n  for (var i = 0; i < globalThis.__pending.length; i++) {\n    var item = globalThis.__pending[i];\n    if (item.type === \"hook\" && item.token === token) {\n      item.abortRequested = true;\n      item.abortPayload = {\n        aborted: true,\n        reason: reason,\n      };\n      break;\n    }\n  }\n};\n\nglobalThis.AbortSignal = {\n  abort: function(reason) {\n    var s = new WorkflowAbortSignal(\"\", \"\");\n    s._setAborted(reason !== undefined ? reason : __makeAbortError());\n    return s;\n  },\n  any: function(signals) {\n    var composite = new WorkflowAbortSignal(\"\", \"\");\n    var arr = Array.from(signals);\n    for (var i = 0; i < arr.length; i++) {\n      if (arr[i].aborted) {\n        composite._setAborted(arr[i].reason);\n        return composite;\n      }\n    }\n    var listeners = [];\n    var cleanup = function() {\n      for (var j = 0; j < listeners.length; j++) {\n        if (listeners[j].signal.removeEventListener) {\n          listeners[j].signal.removeEventListener(\"abort\", listeners[j].listener);\n        }\n      }\n      listeners.length = 0;\n    };\n    arr.forEach(function(signal) {\n      if (!signal.addEventListener) return;\n      var listener = function() {\n        if (!composite.aborted) {\n          composite._setAborted(signal.reason);\n          cleanup();\n        }\n      };\n      listeners.push({ signal: signal, listener: listener });\n      signal.addEventListener(\"abort\", listener);\n    });\n    return composite;\n  },\n  timeout: function() {\n    throw new Error(\n      \"AbortSignal.timeout() is not supported in workflow functions. \" +\n        \"Use sleep() with an AbortController instead. \" +\n        \"See: /docs/errors/abort-signal-timeout-in-workflow\"\n    );\n  },\n};\n\n// WORKFLOW_GET_STREAM_ID — generates a stream ID for a workflow run.\n// Replicates getWorkflowRunStreamId() from util.ts inside the QuickJS VM.\n// Uses the built-in btoa() for base64url encoding.\nglobalThis[Symbol.for(\"WORKFLOW_GET_STREAM_ID\")] = function(namespace) {\n  var runId = globalThis[Symbol.for(\"WORKFLOW_CONTEXT\")]\n    ? globalThis[Symbol.for(\"WORKFLOW_CONTEXT\")].workflowRunId\n    : \"\";\n  var streamId = runId.replace(\"wrun_\", \"strm_\") + \"_user\";\n  if (!namespace) return streamId;\n  // base64url: btoa then replace + with -, / with _, strip =\n  var b64 = btoa(namespace).replace(/\\\\+/g, \"-\").replace(/\\\\//g, \"_\").replace(/=+$/, \"\");\n  return streamId + \"_\" + b64;\n};\n`;\n\n// ---- Runtime ----\n\n/**\n * Phase 1 — static (run-independent) VM initialization.\n *\n * Creates a QuickJS VM and loads everything that does not depend on a\n * specific workflow run: the workflow-primitive bootstrap (useStep /\n * sleep / createHook / Response-Request polyfills). Serialization is\n * host-side (quickjs-serde.ts) and captures its intrinsics from the VM\n * right after this returns.\n *\n * `getNowMs` backs the VM's WASI clock (`Date.now()` / `new Date()`\n * inside the VM). The callback itself is static — the per-run state it\n * reads lives on the host and is advanced as events are consumed,\n * matching the node:vm engine's deterministic replay clock.\n *\n * This phase is the future boundary for VM-memory snapshotting: a\n * build-time snapshot can capture the VM right after this function and\n * new runs can restore from it instead of paying VM creation + eval cost\n * (`QuickJS.restore` accepts the same wasi override).\n */\n/**\n * Loosely-typed accessor for the `WebAssembly` global. The package\n * tsconfig's `lib: [\"es2022\"]` does not include the DOM lib where the\n * `WebAssembly` namespace types live; the runtime global is available on\n * every WASM-capable platform this engine targets.\n */\nconst WebAssemblyGlobal = (globalThis as any).WebAssembly as {\n  compile(bytes: Uint8Array): Promise<object>;\n};\n\ntype CompiledExtension = Omit<ExtensionDescriptor, 'wasm'> & {\n  wasm: ExtensionDescriptor['wasm'];\n};\n\n/**\n * Process-wide cache of the compiled `WebAssembly.Module`s for the main\n * QuickJS runtime and its native extensions. `WebAssembly.compile` of the\n * ~600 KB runtime binary is the most expensive part of VM creation and is\n * pure (no per-VM state — instantiation binds the per-VM memory), so it\n * only needs to happen once per process. The promise is cached (not the\n * result) so concurrent first invocations share a single compilation.\n */\nlet compiledAssetsPromise:\n  | Promise<{\n      wasm: object;\n      extensions: CompiledExtension[];\n    }>\n  | undefined;\n\nfunction getCompiledAssets() {\n  if (!compiledAssetsPromise) {\n    compiledAssetsPromise = (async () => {\n      const [wasm, ...extensionModules] = await Promise.all([\n        WebAssemblyGlobal.compile(quickjsWasm),\n        ...quickjsExtensions.map((ext) =>\n          WebAssemblyGlobal.compile(ext.wasm as Uint8Array)\n        ),\n      ]);\n      return {\n        wasm,\n        extensions: quickjsExtensions.map((ext, i) => ({\n          ...ext,\n          wasm: extensionModules[i] as ExtensionDescriptor['wasm'],\n        })),\n      };\n    })();\n    // On failure, clear the cache so a later invocation can retry rather\n    // than being stuck with a rejected promise forever.\n    compiledAssetsPromise.catch(() => {\n      compiledAssetsPromise = undefined;\n    });\n  }\n  return compiledAssetsPromise;\n}\n\n/**\n * WASI clock override reading the given accessor — shared between fresh\n * boots (initWorkflowVM) and baseline-snapshot restores, so the two\n * paths cannot drift on rounding/encoding.\n *\n * Deterministic replay clock: Date.now() / new Date() inside the VM\n * read the host-controlled clock instead of wall time. Replay\n * re-executes the workflow from the top on every invocation, so the\n * clock must be derived from the event log (not real time) for the\n * workflow to observe stable timestamps across invocations.\n */\nfunction makeDeterministicClockWasi(getNowMs: () => number): WasiOptions {\n  return (memory) => ({\n    clock_time_get(_clockId: number, _precision: bigint, resultPtr: number) {\n      const timeNs = BigInt(Math.round(getNowMs())) * 1_000_000n;\n      new DataView(memory.buffer).setBigUint64(resultPtr, timeNs, true);\n      return 0;\n    },\n  });\n}\n\nasync function initWorkflowVM(\n  getNowMs: () => number,\n  interruptBudget: InterruptBudget\n): Promise<QuickJS> {\n  const assets = await getCompiledAssets();\n  const vm = await QuickJS.create({\n    wasm: assets.wasm as never,\n    memoryLimit: 256 * 1024 * 1024,\n    interruptHandler: createInterruptHandler(interruptBudget),\n    extensions: assets.extensions,\n    wasi: makeDeterministicClockWasi(getNowMs),\n  });\n\n  // Bootstrap workflow primitives\n  vm.evalCode(VM_BOOTSTRAP, 'bootstrap.js').dispose();\n\n  return vm;\n}\n\n// ---- Baseline snapshot (startup optimization) --------------------------\n//\n// Evaluating the workflow bundle dominates VM startup (~74ms of a ~77ms\n// boot for a 1.3MB bundle), and full event replay pays it on EVERY\n// invocation. The bundle is identical across all runs of a deployment, so\n// the engine hydrates one VM per function instance (bootstrap + bundle\n// eval), snapshots its memory, and starts every invocation by restoring\n// the snapshot (~3ms) instead of re-evaluating.\n//\n// Determinism: replay requires module-scope user code to observe the\n// run-seeded PRNG and the run's deterministic clock. A restored heap\n// carries whatever module scope computed at HYDRATE time, so the\n// optimization is only sound when module scope consumed neither\n// randomness nor time. Both are detected during hydrate — the placeholder\n// host fns count draws, the hydrate clock counts reads — and a bundle\n// that used either is marked ineligible: every invocation falls back to\n// fresh evaluation, preserving exact node:vm-parity semantics. When the\n// gate passes, restore is byte-equivalent to fresh eval (verified by the\n// parity tests): the per-run host fns are re-registered by name on the\n// restored VM (quickjs-wasi restore semantics) before the workflow body\n// runs, so the seeded draw sequence — and every correlationId — is\n// identical.\n//\n// The cache is per function instance and keyed on the bundle string\n// (reference-stable: the generated flow route holds it in a module-level\n// const). Capped at a few entries so tests with many distinct bundles\n// don't accumulate 16MB snapshots.\n\n/**\n * Eval filename used when hydrating the baseline VM. The baseline is\n * shared by EVERY workflow in the bundle, so the filename baked into\n * its compiled code (and therefore into snapshot-path stack frames)\n * must be workflow-independent — hydrating under the first caller's\n * workflowId would break `remapErrorStack`'s filename matching for\n * every other workflow in the bundle. Remap call sites match this\n * constant IN ADDITION to the run's module specifier (which covers\n * fresh-path frames).\n */\nexport const BASELINE_BUNDLE_FILENAME = 'workflow-bundle.js';\n\ntype BaselineEntry =\n  | {\n      state: 'ready';\n      snapshot: Snapshot;\n      /**\n       * Raw box pointer of the serde capture root created BEFORE the\n       * bundle evaluated (see captureSerdeRoot). The box lives in the\n       * snapshot's memory image at this offset; every restored VM\n       * re-adopts it so serde initialization executes no guest code\n       * after user code has run — capture-before-user-code semantics,\n       * identical to the fresh path.\n       */\n      serdeRootPtr: number;\n    }\n  | { state: 'ineligible'; reason: string };\n\nconst baselineCache = new Map<string, Promise<BaselineEntry>>();\nconst BASELINE_CACHE_MAX_ENTRIES = 4;\n\n/** Test-only: reset the baseline cache between test cases. */\nexport function __clearBaselineSnapshotCacheForTests(): void {\n  baselineCache.clear();\n}\n\n/** Test-only: observe how a bundle was classified. */\nexport async function __peekBaselineEntryForTests(\n  workflowCode: string\n): Promise<BaselineEntry | undefined> {\n  return baselineCache.get(workflowCode);\n}\n\n/**\n * Hydrate a VM with the workflow bundle and snapshot it, gating on\n * module-scope nondeterminism (see the section comment above). Returns an\n * `ineligible` entry instead of throwing on eval failure — the fresh path\n * re-evaluates and produces the real, source-mapped error.\n */\nasync function prepareBaselineSnapshot(\n  workflowCode: string,\n  workflowId: string\n): Promise<BaselineEntry> {\n  const hydrateStart = Date.now();\n  let clockReads = 0;\n  const budget: InterruptBudget = { start: Date.now() };\n  const assets = await getCompiledAssets();\n  const vm = await QuickJS.create({\n    wasm: assets.wasm as never,\n    memoryLimit: 256 * 1024 * 1024,\n    interruptHandler: createInterruptHandler(budget),\n    extensions: assets.extensions,\n    wasi: ((memory) => ({\n      clock_time_get(_clockId: number, _precision: bigint, resultPtr: number) {\n        clockReads++;\n        const timeNs = BigInt(hydrateStart) * 1_000_000n;\n        new DataView(memory.buffer).setBigUint64(resultPtr, timeNs, true);\n        return 0;\n      },\n    })) satisfies WasiOptions,\n  });\n  try {\n    vm.evalCode(VM_BOOTSTRAP, 'bootstrap.js').dispose();\n\n    // Placeholder host fns under the SAME NAMES the per-run phase uses.\n    // They exist so module-scope code can execute at hydrate time, and to\n    // detect that it did: any draw means the heap would bake\n    // hydrate-seeded values that per-run fresh eval would compute\n    // differently. runWorkflowInVM re-registers all three names with the\n    // run-seeded closures after restore.\n    let draws = 0;\n    {\n      using randomFn = vm.newFunction('random', () => {\n        draws++;\n        return vm.newNumber(Math.random());\n      });\n      using math = vm.global.getProp('Math');\n      math.setProp('random', randomFn);\n      using nanoidFn = vm.newFunction('__generateNanoid', () => {\n        draws++;\n        return vm.newString('baseline-placeholder');\n      });\n      vm.setProp(vm.global, '__generateNanoid', nanoidFn);\n      using ulidFn = vm.newFunction('__generateUlid', () => {\n        draws++;\n        return vm.newString('00000000000000000000000000');\n      });\n      vm.setProp(vm.global, '__generateUlid', ulidFn);\n    }\n\n    // Serde capture root — created BEFORE the bundle evaluates, exactly\n    // like the fresh path's capture. Its box pointer rides the\n    // BaselineEntry and each restored VM re-adopts it, so serde\n    // initialization never executes guest code after user code has run.\n    // This is what makes module-scope intrinsic patching (polyfills,\n    // stateful wrappers around Object.getOwnPropertyDescriptor, …)\n    // HARMLESS on the snapshot path rather than merely detectable: the\n    // serde uses the pristine pre-eval captures on both paths, and no\n    // post-eval probe exists whose side effects could bake into the\n    // snapshot. The handle is deliberately NOT disposed before the\n    // snapshot — the box must stay live in the memory image (the\n    // baseline VM's dispose below tears down the whole instance without\n    // freeing individual boxes).\n    const serdeRoot = captureSerdeRoot(vm);\n\n    clockReads = 0; // only count reads made by the bundle itself\n    try {\n      // Workflow-independent filename — see BASELINE_BUNDLE_FILENAME.\n      vm.evalCode(workflowCode, BASELINE_BUNDLE_FILENAME).dispose();\n    } catch {\n      // Let the fresh path re-evaluate and surface the real error with\n      // proper filename / source-map handling.\n      return {\n        state: 'ineligible',\n        reason: 'module scope threw during hydrate',\n      };\n    }\n\n    if (draws > 0 || clockReads > 0) {\n      runtimeLogger.info(\n        'QuickJS baseline snapshot disabled for this bundle: module scope consumed nondeterministic inputs; every invocation will evaluate the bundle fresh',\n        { workflowId, draws, clockReads }\n      );\n      return {\n        state: 'ineligible',\n        reason: `module scope consumed ${draws} PRNG draw(s) and ${clockReads} clock read(s)`,\n      };\n    }\n\n    const snapshot = vm.snapshot();\n    runtimeLogger.debug('QuickJS baseline snapshot prepared', {\n      workflowId,\n      hydrateMs: Date.now() - hydrateStart,\n    });\n    return {\n      state: 'ready',\n      snapshot,\n      serdeRootPtr: exportSerdeRoot(vm, serdeRoot),\n    };\n  } finally {\n    vm.dispose();\n  }\n}\n\n/**\n * Cached baseline entry for a bundle, preparing it on first access.\n * Concurrent first invocations share one hydrate via the cached promise;\n * a hydrate that REJECTS (infrastructure failure, not bundle eval — that\n * returns `ineligible`) is evicted so a later invocation can retry.\n */\nfunction getBaselineEntry(\n  workflowCode: string,\n  workflowId: string\n): Promise<BaselineEntry> {\n  let entry = baselineCache.get(workflowCode);\n  if (!entry) {\n    if (baselineCache.size >= BASELINE_CACHE_MAX_ENTRIES) {\n      const oldest = baselineCache.keys().next().value;\n      if (oldest !== undefined) baselineCache.delete(oldest);\n    }\n    entry = prepareBaselineSnapshot(workflowCode, workflowId);\n    baselineCache.set(workflowCode, entry);\n    entry.catch(() => baselineCache.delete(workflowCode));\n  }\n  return entry;\n}\n\n/**\n * A live QuickJS workflow invocation. When the initial `result` is\n * `suspended`, the VM is kept alive so the caller can feed newly recorded\n * events (e.g. terminal events of inline-executed steps) into the SAME VM\n * via `continueWithEvents` — resuming execution exactly where it left off\n * without a fresh-VM re-replay. Terminal results dispose the VM\n * automatically; `dispose()` must be called when abandoning a suspended\n * session (idempotent).\n */\nexport interface QuickJSWorkflowSession {\n  result: QuickJSRuntimeResult;\n  /**\n   * Process newly recorded events in the live VM and re-evaluate the\n   * workflow state. Only valid while the last result was `suspended`.\n   * Resets the VM's interrupt budget for the new execution burst.\n   */\n  continueWithEvents(newEvents: Event[]): Promise<QuickJSRuntimeResult>;\n  /** Dispose the VM if it is still alive. Safe to call multiple times. */\n  dispose(): void;\n}\n\n/**\n * Run a workflow invocation to its first settled state and dispose the\n * VM. Convenience wrapper over {@link startQuickJSWorkflow} for callers\n * (and tests) that don't use live-VM continuation.\n */\nexport async function runQuickJSWorkflow(\n  options: QuickJSRuntimeOptions\n): Promise<QuickJSRuntimeResult> {\n  const session = await startQuickJSWorkflow(options);\n  session.dispose();\n  return session.result;\n}\n\nexport async function startQuickJSWorkflow(\n  options: QuickJSRuntimeOptions\n): Promise<QuickJSWorkflowSession> {\n  const { workflowCode, workflowId, workflowRun, events } = options;\n\n  const startedAt = workflowRun.startedAt ? +workflowRun.startedAt : Date.now();\n\n  // Deterministic PRNG seed — identical for EVERY invocation of the same\n  // run. Full event replay requires this: each invocation re-executes the\n  // workflow from the top and must regenerate the exact same correlationId\n  // sequence so that pending operations re-created by replay match the\n  // events recorded by earlier invocations. Sequential operations within\n  // one execution still get distinct ids because the PRNG advances as the\n  // workflow draws from it. Identical seeding across CONCURRENT invocations\n  // of the same run is also load-bearing: both produce the same ids, and\n  // the world's per-(runId, correlationId) uniqueness turns the duplicate\n  // `events.create` into an EntityConflictError that the entrypoint\n  // swallows.\n  //\n  // The seed inputs MUST be stable across invocations. Notably\n  // `startedAt` is NOT: under turbo the first invocation runs against a\n  // synthesized run object whose timestamps differ from the durably\n  // stored ones that later invocations load. Matches the node:vm\n  // engine's seed (workflow.ts).\n  const seed = [\n    workflowRun.runId,\n    workflowRun.workflowName,\n    workflowRun.deploymentId,\n  ].join(':');\n  const rng = seedrandom(seed);\n\n  // Seeded nanoid generator — uses the same nanoid package and seeded PRNG\n  // as the node:vm engine for consistent token generation.\n  const generateNanoid = nanoid.customRandom(nanoid.urlAlphabet, 21, (size) =>\n    new Uint8Array(size).map(() => 256 * rng())\n  );\n\n  // Deterministic replay clock, mirroring the node:vm engine (see\n  // workflow.ts): the initial value is the run's creation time recovered\n  // from the ULID embedded in `runId` (falling back to `createdAt`), and\n  // it advances to each processed event's `createdAt` as the event log is\n  // replayed. Monotonic (Math.max) so the outer processEvents re-scan\n  // loop can't move the clock backwards mid-execution.\n  let vmNowMs =\n    runIdCreatedAt(workflowRun.runId) ?? (+workflowRun.createdAt || startedAt);\n  const advanceClock = (ms: number) => {\n    if (Number.isFinite(ms)) vmNowMs = Math.max(vmNowMs, ms);\n  };\n\n  // ---- Phase 1: static initialization ----\n  //\n  // Baseline-snapshot fast path (default ON; see the section comment at\n  // prepareBaselineSnapshot): restore a bundle-hydrated VM instead of\n  // booting fresh and re-evaluating the bundle. `ineligible` bundles\n  // (module-scope nondeterminism, eval failure) take the fresh path with\n  // identical semantics.\n  const interruptBudget: InterruptBudget = { start: Date.now() };\n  let baselineSnapshot: Snapshot | undefined;\n  let baselineSerdeRootPtr: number | undefined;\n  if (isQuickJSBaselineSnapshotEnabled()) {\n    try {\n      const entry = await getBaselineEntry(workflowCode, workflowId);\n      if (entry.state === 'ready') {\n        baselineSnapshot = entry.snapshot;\n        baselineSerdeRootPtr = entry.serdeRootPtr;\n      }\n    } catch (err) {\n      // A rejection here is an infrastructure failure during hydrate\n      // (e.g. vm.snapshot() under memory pressure, QuickJS.create or\n      // getCompiledAssets() failing) — NOT bundle eval, which returns\n      // an ineligible entry. getBaselineEntry has already evicted the\n      // cached promise so a later invocation can retry. This invocation\n      // must fall back to fresh evaluation (which would have succeeded)\n      // rather than fail the whole run for a snapshot-only failure mode.\n      runtimeLogger.warn(\n        'QuickJS baseline snapshot hydrate failed; falling back to fresh evaluation for this invocation',\n        { workflowId, error: err }\n      );\n    }\n  }\n  let vm: QuickJS;\n  if (baselineSnapshot) {\n    const assets = await getCompiledAssets();\n    vm = await QuickJS.restore(baselineSnapshot, {\n      wasm: assets.wasm as never,\n      memoryLimit: 256 * 1024 * 1024,\n      interruptHandler: createInterruptHandler(interruptBudget),\n      extensions: assets.extensions,\n      wasi: makeDeterministicClockWasi(() => vmNowMs),\n    });\n  } else {\n    vm = await initWorkflowVM(() => vmNowMs, interruptBudget);\n  }\n\n  // Host-side serde: captures the VM's intrinsics (bootstrap included)\n  // before any user code runs. All serialization now happens on the host\n  // through handles — no serializer code is evaluated inside the VM.\n  // Fresh path: capture now (no user code has run — the bundle evaluates\n  // later in the per-run phase). Snapshot path: re-adopt the capture root\n  // the baseline hydrate created BEFORE the bundle evaluated — the box\n  // lives in the restored memory image at the recorded offset. Both give\n  // the serde pristine capture-before-user-code intrinsics; neither\n  // executes guest code here.\n  const serde =\n    baselineSnapshot && baselineSerdeRootPtr !== undefined\n      ? createQuickJSSerde(vm, adoptSerdeRoot(vm, baselineSerdeRootPtr))\n      : createQuickJSSerde(vm);\n\n  // Any throw between here and the terminal paths (which dispose the VM\n  // inside checkWorkflowState / extractError before RETURNING) would leak\n  // a live QuickJS instance and its WASM linear memory for the lifetime\n  // of the compute instance — which is reused. Dispose on the way out of\n  // an exceptional exit and rethrow.\n  try {\n    return await runWorkflowInVM();\n  } catch (err) {\n    try {\n      vm.dispose();\n    } catch {\n      // Already disposed by a terminal path — ignore.\n    }\n    throw err;\n  }\n\n  // ---- Phase 2: per-run initialization ----\n  async function runWorkflowInVM(): Promise<QuickJSWorkflowSession> {\n    vm.evalCode(\n      `globalThis.__worldCapabilities = ${JSON.stringify(options.worldCapabilities)};`\n    ).dispose();\n\n    // Seeded Math.random\n    {\n      using randomFn = vm.newFunction('random', () => vm.newNumber(rng()));\n      using math = vm.global.getProp('Math');\n      math.setProp('random', randomFn);\n    }\n\n    // Seeded nanoid generator\n    {\n      using nanoidFn = vm.newFunction('__generateNanoid', () =>\n        vm.newString(generateNanoid())\n      );\n      vm.setProp(vm.global, '__generateNanoid', nanoidFn);\n    }\n\n    // Host-side deterministic ULID generator for correlationIds. Uses the\n    // same `ulid` package and monotonic factory as before, drawing from\n    // the SAME seeded PRNG instance as the VM's Math.random — so the\n    // interleaved draw sequence (and therefore every correlationId) is\n    // byte-identical to what the previous in-VM ULID factory produced for\n    // the same run. The time prefix is derived from the runId's embedded\n    // ULID (stable across invocations by construction — unlike\n    // `startedAt`, which differs between turbo's synthesized run object\n    // and the durably stored run), so two concurrent invocations of the\n    // same run produce IDENTICAL correlationIds and the world's\n    // EntityConflictError on `events.create` dedups one of each pair.\n    {\n      const ulidFactory = monotonicFactory(() => rng());\n      const ulidTimestamp =\n        runIdCreatedAt(workflowRun.runId) ??\n        (+workflowRun.createdAt || startedAt);\n      using ulidFn = vm.newFunction('__generateUlid', () =>\n        vm.newString(ulidFactory(ulidTimestamp))\n      );\n      vm.setProp(vm.global, '__generateUlid', ulidFn);\n    }\n\n    // `process.env` — parity with the node:vm engine, which exposes a frozen\n    // copy of the host env (vm/index.ts). Injected per run so the snapshot of\n    // the env is taken at invocation time, same as node. Handle-based (no\n    // guest source evaluated): on the baseline-snapshot path this runs\n    // after user code, and a guest-source injection would execute through\n    // potentially patched globals (JSON.parse, Object.freeze) — visible\n    // to module-scope wrappers only on the restore path, diverging\n    // replays.\n    serde.installProcessEnv(process.env);\n\n    // Execute the workflow bundle — use the workflowId as the eval filename\n    // so QuickJS stack traces reference the workflow name, enabling source map\n    // remapping by remapErrorStack (which matches frames by filename).\n    // Evaluated in the per-run phase (after Math.random seeding) so that\n    // module-scope user code draws from the seeded PRNG, matching the\n    // node:vm engine's replay determinism. Skipped on the\n    // baseline-snapshot path: the restored heap already carries the\n    // evaluated bundle, and the baseline gate guarantees module scope\n    // consumed no PRNG draws or clock reads — so skipping the eval is\n    // observationally identical to re-running it (the run-seeded host\n    // fns registered above rebind the SAME names the restored heap's\n    // function objects dispatch through).\n    if (!baselineSnapshot) {\n      try {\n        vm.evalCode(workflowCode, workflowId || 'workflow.js').dispose();\n      } catch (err) {\n        return makeSettledSession(\n          extractError(vm, err, 'Workflow evaluation failed')\n        );\n      }\n    }\n\n    // Extract workflow arguments. Prefer the run_created event; fall back\n    // to the queue message's runInput if the event log is incomplete\n    // (eventually-consistent read after start()). Failing to find input\n    // for a first invocation is fatal — running the workflow function\n    // with no args would silently turn typed arguments into `undefined`\n    // and, for recursive workflows, produce exponential fan-out.\n    const runCreatedEvent = events.find((e) => e.eventType === 'run_created');\n    const runCreatedInput =\n      runCreatedEvent && 'eventData' in runCreatedEvent\n        ? (runCreatedEvent.eventData as Record<string, unknown>)?.input\n        : undefined;\n    const runInput: unknown =\n      runCreatedInput ?? (options.runInput?.input as unknown);\n\n    if (runInput instanceof Uint8Array) {\n      const decryptedInput = await prepareBytesForVM(\n        runInput,\n        options.encryptionKey\n      );\n      runtimeLogger.debug('QuickJS runtime: run input format', {\n        prefix: new TextDecoder().decode(decryptedInput.subarray(0, 4)),\n        byteLength: decryptedInput.byteLength,\n        source: runCreatedInput ? 'run_created' : 'queueMessage.runInput',\n      });\n      // Build the argument value directly in the VM via the host-side\n      // serde (guest code never sees the wire bytes).\n      const inputHandle = serde.deserialize(decryptedInput);\n      vm.setProp(vm.global, '__wdk_input', inputHandle);\n      inputHandle.dispose();\n    } else if (runInput === undefined && events.length > 0) {\n      // The event log is non-empty (we got run_started or similar) but\n      // no run_created event was found and no queue-provided runInput is\n      // available. This is the race condition observed during the fib\n      // incident — silently dropping arguments would turn `n` into\n      // `undefined` and, for recursive workflows, cause exponential\n      // fan-out. Fail loud: the throw escapes the entrypoint into the\n      // replay loop's catch in runtime.ts (the QuickJS dispatch runs\n      // inside that loop's try), which records run_failed. A visible\n      // terminal failure is\n      // preferred over silently executing with undefined arguments — the\n      // queue-provided runInput fallback above makes this path rare.\n      // Empty `events` is allowed because tests that bootstrap a workflow\n      // with no arguments rely on the old permissive behavior.\n      throw new Error(\n        `Cannot start workflow run \"${workflowRun.runId}\": no run_created event found and no runInput in the queue payload, but other events are present (likely a read-after-write race during start()).`\n      );\n    }\n\n    // Set workflow context metadata (for getWorkflowMetadata()).\n    // Must match the shape that the node:vm engine produces (see\n    // packages/core/src/workflow.ts: runWorkflow → ctx) so user code\n    // that compares `getWorkflowMetadata()` values between a step\n    // (server-side) and the workflow (VM-side) sees identical objects.\n    {\n      const metadata = {\n        workflowName: workflowRun.workflowName,\n        workflowRunId: workflowRun.runId,\n        workflowStartedAt: workflowRun.startedAt\n          ? new Date(+workflowRun.startedAt)\n          : new Date(),\n        url: process.env.VERCEL_URL\n          ? `https://${process.env.VERCEL_URL}`\n          : `http://localhost:${options.port ?? 3000}`,\n        features: { encryption: !!options.encryptionKey },\n      };\n      vm.evalCode(\n        `globalThis[Symbol.for(\"WORKFLOW_CONTEXT\")] = ${JSON.stringify(metadata)};` +\n          `globalThis[Symbol.for(\"WORKFLOW_CONTEXT\")].workflowStartedAt = new Date(${JSON.stringify(metadata.workflowStartedAt.toISOString())});`\n      ).dispose();\n    }\n\n    // Start the workflow function. If the workflow isn't registered,\n    // throw an error tagged with `name = \"WorkflowNotRegisteredError\"`\n    // so the host-side entrypoint can reconstruct a real\n    // WorkflowNotRegisteredError (a WorkflowRuntimeError subclass that\n    // classifies as RUNTIME_ERROR) rather than a generic user error.\n    // See quickjs-entrypoint.ts's run_failed branch.\n    try {\n      vm.evalCode(`\n      var __wfn = globalThis.__private_workflows.get(${JSON.stringify(workflowId)});\n      if (!__wfn) {\n        var __wfnErr = new Error(\"Workflow \\\\\"\" + ${JSON.stringify(workflowId)} + \"\\\\\" is not registered in the current deployment.\");\n        __wfnErr.name = \"WorkflowNotRegisteredError\";\n        throw __wfnErr;\n      }\n      var __args = globalThis.__wdk_input !== undefined\n        ? globalThis.__wdk_input\n        : [];\n      delete globalThis.__wdk_input;\n      if (!Array.isArray(__args)) __args = [__args];\n      __wfn.apply(null, __args).then(\n        function(result) {\n          // Store the RAW result; the host serializes it through a handle.\n          // A separate done flag distinguishes \"completed with undefined\"\n          // from \"not completed\".\n          globalThis.__workflowDone = true;\n          globalThis.__workflowResult = result;\n        },\n        function(error) {\n          // Preserve display info on the host-side failed object\n          // (matches the legacy host-visible shape) AND keep the RAW\n          // thrown value so the host can serialize the original\n          // type-identity, cause chain, or non-Error throws verbatim\n          // through the standard error pipeline.\n          globalThis.__workflowError = {\n            message: error && error.message != null ? String(error.message) : String(error),\n            stack: error && error.stack ? error.stack : \"\",\n            name: error && error.name ? error.name : (error instanceof Error ? \"Error\" : typeof error),\n            value: error,\n          };\n        }\n      );\n    `).dispose();\n    } catch (err) {\n      return makeSettledSession(\n        extractError(vm, err, 'Failed to start workflow')\n      );\n    }\n\n    // Process events and drain jobs in a loop. Events may resolve promises\n    // that unblock workflow code, which then creates NEW resolvers for\n    // subsequent events. Re-processing events matches these new resolvers\n    // against events that were already delivered.\n    {\n      let maxIterations = 100;\n      let madeProgress: boolean;\n      do {\n        madeProgress = await processEvents(\n          vm,\n          serde,\n          events,\n          advanceClock,\n          options.encryptionKey\n        );\n        let batch: number;\n        do {\n          batch = vm.executePendingJobs();\n          if (batch > 0) madeProgress = true;\n        } while (batch > 0);\n      } while (madeProgress && --maxIterations > 0);\n      if (madeProgress && maxIterations === 0) {\n        // The drain loop hit its bound while still making progress —\n        // proceeding as if it converged would present as a mysterious\n        // suspension or replay divergence. Make the giving-up visible so\n        // a wedge is attributable to this bound rather than a mystery.\n        runtimeLogger.warn(\n          'QuickJS runtime: event drain loop hit its iteration bound before reaching a fixed point',\n          {\n            workflowRunId: workflowRun.runId,\n            eventCount: events.length,\n          }\n        );\n      }\n    }\n\n    // ---- Check result ----\n    return makeLiveSession(\n      vm,\n      serde,\n      interruptBudget,\n      advanceClock,\n      options.encryptionKey\n    );\n  }\n}\n\n/** Session wrapper for a result whose VM is already settled/disposed. */\nfunction makeSettledSession(\n  result: QuickJSRuntimeResult\n): QuickJSWorkflowSession {\n  return {\n    result,\n    continueWithEvents: () => {\n      throw new Error(\n        'QuickJS workflow session is settled — continueWithEvents is only valid while suspended'\n      );\n    },\n    dispose: () => {},\n  };\n}\n\n/**\n * Evaluate the VM's state and wrap it in a live session. While suspended,\n * the VM stays alive so `continueWithEvents` can resume it in place;\n * terminal states dispose the VM immediately (inside checkWorkflowState).\n */\nfunction makeLiveSession(\n  vm: QuickJS,\n  serde: QuickJSSerde,\n  interruptBudget: InterruptBudget,\n  advanceClock: (ms: number) => void,\n  encryptionKey?: DecryptionKey\n): QuickJSWorkflowSession {\n  const result = checkWorkflowState(vm, serde, { keepAliveOnSuspend: true });\n  let alive = !!result.suspended;\n\n  const session: QuickJSWorkflowSession = {\n    result,\n    async continueWithEvents(\n      newEvents: Event[]\n    ): Promise<QuickJSRuntimeResult> {\n      if (!alive) {\n        throw new Error(\n          'QuickJS workflow session is not alive — continueWithEvents is only valid while suspended'\n        );\n      }\n      // Fresh execution burst — the interrupt budget bounds VM compute,\n      // not wall time spent waiting on inline steps between bursts.\n      interruptBudget.start = Date.now();\n\n      let maxIterations = 100;\n      let madeProgress: boolean;\n      do {\n        madeProgress = await processEvents(\n          vm,\n          serde,\n          newEvents,\n          advanceClock,\n          encryptionKey\n        );\n        let batch: number;\n        do {\n          batch = vm.executePendingJobs();\n          if (batch > 0) madeProgress = true;\n        } while (batch > 0);\n      } while (madeProgress && --maxIterations > 0);\n\n      const next = checkWorkflowState(vm, serde, {\n        keepAliveOnSuspend: true,\n      });\n      if (!next.suspended) alive = false;\n      session.result = next;\n      return next;\n    },\n    dispose(): void {\n      if (alive) {\n        alive = false;\n        try {\n          vm.dispose();\n        } catch {\n          // Already disposed — ignore.\n        }\n      }\n    },\n  };\n  return session;\n}\n\n// ---- Event Processing ----\n\nasync function processEvents(\n  vm: QuickJS,\n  serde: QuickJSSerde,\n  events: Event[],\n  advanceClock: (ms: number) => void,\n  encryptionKey?: DecryptionKey\n): Promise<boolean> {\n  let resolved = false;\n  for (const event of events) {\n    // Advance the VM's deterministic clock to this event's creation time\n    // BEFORE resolving anything, so workflow code unblocked by this event\n    // observes Date.now() at (or after — the clock is monotonic) the time\n    // the event was recorded. Mirrors the node:vm engine's\n    // `onConsumedEvent → updateTimestamp(+event.createdAt)`.\n    advanceClock(+event.createdAt);\n\n    const cid = event.correlationId;\n    if (!cid) continue;\n\n    // JSON.stringify handles quotes, backslashes and control characters;\n    // correlation ids are host-generated ULIDs today, but the eval-string\n    // safety shouldn't depend on that invariant being asserted nowhere.\n    const cidJs = JSON.stringify(cid);\n    const eventData =\n      'eventData' in event\n        ? (event.eventData as Record<string, unknown>)\n        : undefined;\n\n    // Log the event and whether the resolver exists\n    switch (event.eventType) {\n      case 'step_completed': {\n        const hasResolver = vm.dump(\n          vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`)\n        );\n        const rawOutput = eventData?.result ?? eventData?.output;\n        if (hasResolver) {\n          if (rawOutput instanceof Uint8Array) {\n            // Decrypt if encrypted — the VM only understands 'devl' format\n            runtimeLogger.debug('QuickJS runtime: step result raw', {\n              correlationId: cid,\n              rawPrefix: new TextDecoder().decode(rawOutput.subarray(0, 4)),\n              rawByteLength: rawOutput.byteLength,\n              isBuffer: Buffer.isBuffer(rawOutput),\n            });\n            const decryptedOutput = await prepareBytesForVM(\n              rawOutput,\n              encryptionKey\n            );\n            runtimeLogger.debug('QuickJS runtime: step result decrypted', {\n              correlationId: cid,\n              prefix: new TextDecoder().decode(decryptedOutput.subarray(0, 4)),\n              byteLength: decryptedOutput.byteLength,\n            });\n            const valueHandle = serde.deserialize(decryptedOutput);\n            vm.setProp(vm.global, '__tmp_result', valueHandle);\n            valueHandle.dispose();\n            vm.evalCode(\n              `globalThis.__resolvers[${cidJs}].resolve(globalThis.__tmp_result);` +\n                `delete globalThis.__resolvers[${cidJs}];` +\n                `delete globalThis.__tmp_result;`\n            ).dispose();\n          } else {\n            runtimeLogger.debug('QuickJS runtime: step result non-binary', {\n              correlationId: cid,\n              type: typeof rawOutput,\n              isNull: rawOutput === null,\n              isUndefined: rawOutput === undefined,\n              constructor: rawOutput?.constructor?.name,\n            });\n            const serialized =\n              rawOutput !== undefined ? JSON.stringify(rawOutput) : 'undefined';\n            vm.evalCode(\n              `globalThis.__resolvers[${cidJs}].resolve(${serialized});` +\n                `delete globalThis.__resolvers[${cidJs}];`\n            ).dispose();\n          }\n          // Drain ALL microtasks after resolve\n          {\n            resolved = true;\n            let b: number;\n            do {\n              b = vm.executePendingJobs();\n            } while (b > 0);\n          }\n        } else {\n          // No resolver yet — buffer the prepared outcome so the promise\n          // settles the moment the VM constructs it (see __terminalBuffer\n          // in the bootstrap). Without this, the live-continuation path\n          // (which scans each delta exactly once) drops the terminal and\n          // the await never settles.\n          if (rawOutput instanceof Uint8Array) {\n            const decryptedOutput = await prepareBytesForVM(\n              rawOutput,\n              encryptionKey\n            );\n            // Host serde: deserialize into a VM value NOW (same path as\n            // the resolver branch above) and buffer the value itself.\n            const valueHandle = serde.deserialize(decryptedOutput);\n            vm.setProp(vm.global, '__tmp_buf', valueHandle);\n            valueHandle.dispose();\n            vm.evalCode(\n              `globalThis.__terminalBuffer[${cidJs}] = { kind: \"resolve_value\", value: globalThis.__tmp_buf };` +\n                `delete globalThis.__tmp_buf;`\n            ).dispose();\n          } else {\n            const serialized =\n              rawOutput !== undefined ? JSON.stringify(rawOutput) : 'undefined';\n            vm.evalCode(\n              `globalThis.__terminalBuffer[${cidJs}] = { kind: \"resolve_value\", value: ${serialized} };`\n            ).dispose();\n          }\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'step_failed': {\n        const hasResolver = vm.dump(\n          vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`)\n        );\n        if (hasResolver) {\n          const errorData = eventData?.error;\n          if (errorData instanceof Uint8Array) {\n            // Modern path (post-#1851): the step handler dehydrated the\n            // thrown value through the first-class error pipeline. Decrypt\n            // (if encrypted) and pass the bytes to the VM-side deserializer\n            // so the workflow catch sees a properly typed Error subclass\n            // (TypeError, FatalError with original cause chain, etc.) with\n            // the original message and stack preserved.\n            const decrypted = await prepareBytesForVM(errorData, encryptionKey);\n            const errorHandle = serde.deserialize(decrypted);\n            vm.setProp(vm.global, '__tmp_error', errorHandle);\n            errorHandle.dispose();\n            vm.evalCode(\n              `(function(){` +\n                `globalThis.__resolvers[${cidJs}].reject(globalThis.__tmp_error);` +\n                `delete globalThis.__resolvers[${cidJs}];` +\n                `delete globalThis.__tmp_error;` +\n                `})()`\n            ).dispose();\n          } else {\n            // Legacy path: pre-pipeline events stored error as\n            // `{ message, stack, code }`. Reconstruct a FatalError so\n            // workflow catch can detect it via FatalError.is(), matching\n            // the original V1 step handler behavior.\n            const isErrorObject =\n              typeof errorData === 'object' && errorData !== null;\n            const msg = isErrorObject\n              ? (((errorData as Record<string, unknown>).message as string) ??\n                'Step failed')\n              : typeof errorData === 'string'\n                ? errorData\n                : 'Step failed';\n            const errorStack =\n              (isErrorObject\n                ? (errorData as Record<string, unknown>).stack\n                : undefined) ?? (eventData?.stack as string | undefined);\n            const stackAssignment = errorStack\n              ? `e.stack=${JSON.stringify(errorStack)};`\n              : '';\n            vm.evalCode(\n              `(function(){var e=new Error(${JSON.stringify(msg)});e.name=\"FatalError\";e.fatal=true;${stackAssignment}` +\n                `globalThis.__resolvers[${cidJs}].reject(e);` +\n                `delete globalThis.__resolvers[${cidJs}];})()`\n            ).dispose();\n          }\n          {\n            resolved = true;\n            let b: number;\n            do {\n              b = vm.executePendingJobs();\n            } while (b > 0);\n          }\n        } else {\n          // No resolver yet — buffer the prepared rejection (see the\n          // step_completed branch above for the rationale).\n          const errorData = eventData?.error;\n          if (errorData instanceof Uint8Array) {\n            const decrypted = await prepareBytesForVM(errorData, encryptionKey);\n            // Host serde: deserialize into the VM error value NOW (same\n            // path as the resolver branch above) and buffer it.\n            const errorHandle = serde.deserialize(decrypted);\n            vm.setProp(vm.global, '__tmp_buf', errorHandle);\n            errorHandle.dispose();\n            vm.evalCode(\n              `globalThis.__terminalBuffer[${cidJs}] = { kind: \"reject_value\", value: globalThis.__tmp_buf };` +\n                `delete globalThis.__tmp_buf;`\n            ).dispose();\n          } else {\n            const isErrorObject =\n              typeof errorData === 'object' && errorData !== null;\n            const msg = isErrorObject\n              ? (((errorData as Record<string, unknown>).message as string) ??\n                'Step failed')\n              : typeof errorData === 'string'\n                ? errorData\n                : 'Step failed';\n            const errorStack =\n              (isErrorObject\n                ? (errorData as Record<string, unknown>).stack\n                : undefined) ?? (eventData?.stack as string | undefined);\n            vm.evalCode(\n              `globalThis.__terminalBuffer[${cidJs}] = { kind: \"reject_error\", message: ${JSON.stringify(msg)}, stack: ${errorStack ? JSON.stringify(errorStack) : 'undefined'} };`\n            ).dispose();\n          }\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'wait_completed': {\n        const hasResolver = vm.dump(\n          vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`)\n        );\n        if (hasResolver) {\n          vm.evalCode(\n            `globalThis.__resolvers[${cidJs}].resolve();` +\n              `delete globalThis.__resolvers[${cidJs}];`\n          ).dispose();\n          {\n            resolved = true;\n            let b: number;\n            do {\n              b = vm.executePendingJobs();\n            } while (b > 0);\n          }\n        } else {\n          // No resolver yet — buffer (see step_completed above).\n          vm.evalCode(\n            `globalThis.__terminalBuffer[${cidJs}] = { kind: \"resolve_undefined\" };`\n          ).dispose();\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'attr_set': {\n        // Only workflow-written attribute events resolve a pending\n        // setAttributes() promise; step/system writers share no\n        // correlationIds with VM resolvers, so the guard is defensive.\n        const writer = (eventData?.writer as { type?: string } | undefined)\n          ?.type;\n        if (writer !== 'workflow') break;\n        const hasResolver = vm.dump(\n          vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`)\n        );\n        if (!hasResolver) {\n          // No resolver yet — buffer (see step_completed above).\n          vm.evalCode(\n            `globalThis.__terminalBuffer[${cidJs}] = { kind: \"resolve_undefined\" };`\n          ).dispose();\n        }\n        if (hasResolver) {\n          vm.evalCode(\n            `globalThis.__resolvers[${cidJs}].resolve();` +\n              `delete globalThis.__resolvers[${cidJs}];`\n          ).dispose();\n          {\n            resolved = true;\n            let b: number;\n            do {\n              b = vm.executePendingJobs();\n            } while (b > 0);\n          }\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'hook_received': {\n        // Check if this event was already processed (delivered or\n        // buffered) within this invocation. Prevents double-delivery when\n        // the outer loop re-scans events.\n        const alreadyProcessed = event.eventId\n          ? vm.dump(\n              vm.evalCode(\n                `!!(globalThis.__hookPayloadBuffer.__processedEventIds && globalThis.__hookPayloadBuffer.__processedEventIds[${JSON.stringify(event.eventId)}])`\n              )\n            )\n          : false;\n        if (alreadyProcessed) {\n          runtimeLogger.debug(\n            'QuickJS runtime: hook_received already processed',\n            {\n              correlationId: cid,\n              eventId: event.eventId,\n            }\n          );\n          markCreated(vm, cidJs);\n          break;\n        }\n\n        // Resilient-resume dedup (parity with the node engine's\n        // EventsConsumer in workflow/hook.ts): two hook_received rows for\n        // ONE resume attempt share a client-minted `resumeId` (a duplicate\n        // can be committed when the materialization fallback races a\n        // delayed direct write — hook_received has no storage uniqueness\n        // constraint). Deliver only the first-in-log occurrence. The seen\n        // set lives in the VM heap so it is deterministic per replay and\n        // survives event re-scans within the invocation. Events without a\n        // resumeId (older SDKs) are never deduped.\n        {\n          // Top-level event.resumeId is the canonical location (the backend\n          // hoists it to a first-class column); the nested\n          // eventData.resumeId form is a deprecated legacy fallback —\n          // mirrors the node engine's dedup in workflow/hook.ts.\n          const resumeId =\n            (event as { resumeId?: unknown }).resumeId ??\n            (eventData as { resumeId?: unknown } | undefined)?.resumeId;\n          if (typeof resumeId === 'string') {\n            const resumeIdJs = JSON.stringify(resumeId);\n            const duplicate = vm.dump(\n              vm.evalCode(\n                `(globalThis.__hookSeenResumeIds = globalThis.__hookSeenResumeIds || {})[${resumeIdJs}] === true`\n              )\n            );\n            if (duplicate) {\n              runtimeLogger.debug(\n                'QuickJS runtime: duplicate hook_received for the same resume attempt, dropping',\n                { correlationId: cid, eventId: event.eventId, resumeId }\n              );\n              if (event.eventId) {\n                vm.evalCode(\n                  `(globalThis.__hookPayloadBuffer.__processedEventIds = globalThis.__hookPayloadBuffer.__processedEventIds || {})[${JSON.stringify(event.eventId)}] = true;`\n                ).dispose();\n              }\n              markCreated(vm, cidJs);\n              break;\n            }\n            vm.evalCode(\n              `globalThis.__hookSeenResumeIds[${resumeIdJs}] = true;`\n            ).dispose();\n          }\n        }\n\n        // Abort delivery: hook_received for an AbortController's system\n        // hook flips the registered signal instead of resolving a promise.\n        // The payload is the dehydrated `{ aborted: true, reason }` object.\n        const isAbortHook = vm.dump(\n          vm.evalCode(\n            `!!(globalThis.__abortSignals && globalThis.__abortSignals[${cidJs}])`\n          )\n        );\n        if (isAbortHook) {\n          const rawAbortPayload = eventData?.payload;\n          if (rawAbortPayload instanceof Uint8Array) {\n            const decrypted = await prepareBytesForVM(\n              rawAbortPayload,\n              encryptionKey\n            );\n            const payloadHandle = serde.deserialize(decrypted);\n            vm.setProp(vm.global, '__tmp_abort', payloadHandle);\n            payloadHandle.dispose();\n            vm.evalCode(\n              `(function(){` +\n                `var p=globalThis.__tmp_abort;` +\n                `delete globalThis.__tmp_abort;` +\n                `globalThis.__abortSignals[${cidJs}]._setAborted(p&&typeof p===\"object\"?p.reason:undefined);` +\n                `})()`\n            ).dispose();\n          } else {\n            vm.evalCode(\n              `globalThis.__abortSignals[${cidJs}]._setAborted(undefined);`\n            ).dispose();\n          }\n          // The abort is durably recorded — clear the pending op's\n          // abortRequested marker so the host doesn't re-record it (the\n          // workflow's own abort() call can set the flag before this\n          // event is processed when it happens later in replay order,\n          // and hook_received events are not unique per correlationId).\n          vm.evalCode(\n            `(function(){` +\n              `var p=globalThis.__pending.find(function(q){return q.correlationId===${JSON.stringify(cid)}&&q.type===\"hook\";});` +\n              `if(p)p.abortRequested=false;` +\n              `})()`\n          ).dispose();\n          if (event.eventId) {\n            vm.evalCode(\n              `(globalThis.__hookPayloadBuffer.__processedEventIds = globalThis.__hookPayloadBuffer.__processedEventIds || {})[${JSON.stringify(event.eventId)}] = true;`\n            ).dispose();\n          }\n          {\n            resolved = true;\n            let b: number;\n            do {\n              b = vm.executePendingJobs();\n            } while (b > 0);\n          }\n          markCreated(vm, cidJs);\n          break;\n        }\n\n        const hasResolver = vm.dump(\n          vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`)\n        );\n        const rawPayload = eventData?.payload ?? eventData?.result;\n        runtimeLogger.debug('QuickJS runtime: processing hook_received', {\n          correlationId: cid,\n          eventId: event.eventId,\n          hasResolver,\n          payloadType: typeof rawPayload,\n          payloadIsUint8Array: rawPayload instanceof Uint8Array,\n          payloadKeys:\n            rawPayload && typeof rawPayload === 'object'\n              ? Object.keys(rawPayload)\n              : undefined,\n        });\n        if (hasResolver) {\n          if (rawPayload instanceof Uint8Array) {\n            // Decrypt if encrypted — the VM only understands 'devl' format\n            const decryptedPayload = await prepareBytesForVM(\n              rawPayload,\n              encryptionKey\n            );\n            const payloadHandle = serde.deserialize(decryptedPayload);\n            vm.setProp(vm.global, '__tmp_result', payloadHandle);\n            payloadHandle.dispose();\n            vm.evalCode(\n              `globalThis.__resolvers[${cidJs}].resolve(globalThis.__tmp_result);` +\n                `delete globalThis.__resolvers[${cidJs}];` +\n                `delete globalThis.__tmp_result;`\n            ).dispose();\n          } else {\n            const serialized =\n              rawPayload !== undefined\n                ? JSON.stringify(rawPayload)\n                : 'undefined';\n            vm.evalCode(\n              `globalThis.__resolvers[${cidJs}].resolve(${serialized});` +\n                `delete globalThis.__resolvers[${cidJs}];`\n            ).dispose();\n          }\n          // Mark this event as processed in the VM heap to prevent\n          // double-delivery when the outer loop re-scans events.\n          if (event.eventId) {\n            vm.evalCode(\n              `(globalThis.__hookPayloadBuffer.__processedEventIds = globalThis.__hookPayloadBuffer.__processedEventIds || {})[${JSON.stringify(event.eventId)}] = true;`\n            ).dispose();\n          }\n          {\n            resolved = true;\n            let b: number;\n            do {\n              b = vm.executePendingJobs();\n            } while (b > 0);\n          }\n        } else {\n          // No resolver yet — buffer the payload in the VM heap. When\n          // createHookPromise() is called later, it will drain this buffer\n          // first (matching the node:vm engine's payloadsQueue behavior).\n          const eventIdJs = event.eventId\n            ? JSON.stringify(event.eventId)\n            : 'null';\n          const bufferAndTrack =\n            `(globalThis.__hookPayloadBuffer[${cidJs}] = globalThis.__hookPayloadBuffer[${cidJs}] || [])` +\n            `.push(%PAYLOAD%);` +\n            (event.eventId\n              ? `(globalThis.__hookPayloadBuffer.__processedEventIds = globalThis.__hookPayloadBuffer.__processedEventIds || {})[${eventIdJs}] = true;`\n              : '');\n          if (rawPayload instanceof Uint8Array) {\n            // Decrypt if encrypted — the VM only understands 'devl' format\n            const decryptedPayload = await prepareBytesForVM(\n              rawPayload,\n              encryptionKey\n            );\n            const payloadHandle = serde.deserialize(decryptedPayload);\n            vm.setProp(vm.global, '__tmp_result', payloadHandle);\n            payloadHandle.dispose();\n            // NOTE: replacement is a function so `$`-sequences in the\n            // substituted JS never get interpreted as String.replace\n            // special replacement patterns.\n            vm.evalCode(\n              bufferAndTrack.replace(\n                '%PAYLOAD%',\n                () => 'globalThis.__tmp_result'\n              ) + 'delete globalThis.__tmp_result;'\n            ).dispose();\n          } else {\n            const serialized =\n              rawPayload !== undefined\n                ? JSON.stringify(rawPayload)\n                : 'undefined';\n            // Function replacement: a JSON-serialized payload can contain\n            // `$&`, `$'`, `$\\``, ... which String.replace would otherwise\n            // expand, silently corrupting the injected code.\n            vm.evalCode(\n              bufferAndTrack.replace('%PAYLOAD%', () => serialized)\n            ).dispose();\n          }\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'hook_conflict': {\n        // Another workflow owns this hook token. Payload awaiters reject\n        // with HookConflictError; getConflict() awaiters resolve with a\n        // Run handle for the conflicting run (revived through the VM's\n        // class registry so its methods are durable step proxies) or\n        // reject with the error when no handle can be constructed —\n        // mirroring the node:vm engine's hook.ts hook_conflict handling.\n        const conflictToken = (eventData?.token as string) ?? 'unknown';\n        const conflictingRunId = eventData?.conflictingRunId as\n          | string\n          | undefined;\n        const didSettle = vm.dump(\n          vm.evalCode(\n            `(function(){\n              var cid = ${JSON.stringify(cid)};\n              var token = ${JSON.stringify(conflictToken)};\n              var conflictingRunId = ${JSON.stringify(conflictingRunId ?? null)};\n              var ErrCls = globalThis[Symbol.for('@workflow/errors//HookConflictError')];\n              var err;\n              if (typeof ErrCls === 'function') {\n                err = new ErrCls(token, conflictingRunId || undefined);\n              } else {\n                err = new Error('Hook token \"' + token + '\" is already in use by another workflow');\n                err.name = 'HookConflictError';\n                err.token = token;\n                if (conflictingRunId) err.conflictingRunId = conflictingRunId;\n              }\n              var run = null;\n              if (conflictingRunId) {\n                var reg = globalThis[Symbol.for('workflow-class-registry')];\n                var RunCls = reg && reg.get('class//workflow//Run');\n                var des = RunCls && RunCls[Symbol.for('workflow-deserialize')];\n                if (typeof des === 'function') {\n                  run = des.call(RunCls, { runId: conflictingRunId });\n                }\n              }\n              var settled = false;\n              var state = globalThis.__hooks && globalThis.__hooks[cid];\n              if (state && !state.conflict) {\n                state.conflict = { error: err, run: run };\n                var gc = state.getConflictResolvers;\n                state.getConflictResolvers = [];\n                for (var i = 0; i < gc.length; i++) {\n                  if (run) { gc[i].resolve(run); } else { gc[i].reject(err); }\n                  settled = true;\n                }\n              }\n              if (globalThis.__resolvers[cid]) {\n                globalThis.__resolvers[cid].reject(err);\n                delete globalThis.__resolvers[cid];\n                settled = true;\n              }\n              return settled;\n            })()`\n          )\n        );\n        if (didSettle) {\n          resolved = true;\n          let b: number;\n          do {\n            b = vm.executePendingJobs();\n          } while (b > 0);\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'step_created':\n      case 'step_started':\n      case 'step_retrying':\n      case 'wait_created': {\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'hook_created': {\n        // Confirm creation for getConflict() awaiters: resolve them with\n        // null (no conflict) once the event log proves the hook exists.\n        const settledGetConflict = vm.dump(\n          vm.evalCode(\n            `(function(){\n              var state = globalThis.__hooks && globalThis.__hooks[${JSON.stringify(cid)}];\n              if (!state) return false;\n              state.created = true;\n              var gc = state.getConflictResolvers;\n              state.getConflictResolvers = [];\n              for (var i = 0; i < gc.length; i++) gc[i].resolve(null);\n              return gc.length > 0;\n            })()`\n          )\n        );\n        if (settledGetConflict) {\n          resolved = true;\n          let b: number;\n          do {\n            b = vm.executePendingJobs();\n          } while (b > 0);\n        }\n        markCreated(vm, cidJs);\n        break;\n      }\n      case 'hook_disposed': {\n        // Disambiguate from the `hook` pending op with the same\n        // correlationId — we want to mark the `hook_dispose` entry.\n        markCreated(vm, cidJs, 'hook_dispose');\n        break;\n      }\n    }\n  }\n  return resolved;\n}\n\nfunction markCreated(vm: QuickJS, cidJs: string, opType?: string): void {\n  // `cidJs` is the JSON.stringify-quoted correlation id (see processEvents).\n  // `hook` and `hook_dispose` pending ops share the same correlationId,\n  // so when processing `hook_disposed` events we must disambiguate by\n  // type — otherwise `.find()` returns the original `hook` op and the\n  // `hook_dispose` op is never marked, causing the entrypoint to keep\n  // retrying a hook_disposed for an already-deleted entity.\n  const predicate = opType\n    ? `function(p){return p.correlationId===${cidJs}&&p.type===${JSON.stringify(opType)};}`\n    : `function(p){return p.correlationId===${cidJs};}`;\n  vm.evalCode(\n    `var __p=globalThis.__pending.find(${predicate});` +\n      `if(__p)__p.hasCreatedEvent=true;`\n  ).dispose();\n}\n\n// ---- State Checking ----\n\n/**\n * Collect leftover pending operations that need durable side effects when\n * the workflow reaches a terminal state. Mirrors the node:vm engine's\n * drainPendingQueueItems (workflow.ts): still-alive system hooks\n * (AbortController) without an abort in flight are implicitly disposed so\n * they don't leak hook rows; ops without created events (fire-and-forget\n * attributes/hooks/steps/waits) and pending abort recordings are surfaced\n * for the entrypoint to flush.\n */\n/**\n * Per-VM cache of serialized pending-op field bytes, keyed\n * `correlationId:field`. A step's raw input is immutable once pushed, so\n * its bytes are computed once even though the op is re-collected on every\n * suspension it stays pending through.\n */\nconst pendingByteCache = new WeakMap<QuickJS, Map<string, Uint8Array>>();\n\nfunction ensurePendingByteCache(vm: QuickJS): Map<string, Uint8Array> {\n  let cache = pendingByteCache.get(vm);\n  if (!cache) {\n    cache = new Map();\n    pendingByteCache.set(vm, cache);\n  }\n  return cache;\n}\n\n/**\n * The pending-op fields that hold RAW guest values (the bootstrap no longer\n * serializes them in the VM). Collection projects them out of the dumped\n * plain metadata and serializes each through a handle with the host serde.\n */\nconst RAW_PENDING_FIELDS = ['input', 'metadata', 'abortPayload'] as const;\n\n/**\n * Dump a filtered view of `globalThis.__pending` to host PendingOperation\n * objects, serializing the raw-value fields host-side. `filterExpr` is a\n * guest expression that evaluates to the array of ops to collect.\n */\nfunction dumpPendingOps(\n  vm: QuickJS,\n  serde: QuickJSSerde,\n  filterExpr: string,\n  byteCache?: Map<string, Uint8Array>\n): PendingOperation[] {\n  using projected = vm.evalCode(`(function(){\n    var ops = ${filterExpr};\n    globalThis.__rawFields = [];\n    // Settled ops — created, resolver-less, no abort in flight — are\n    // never collected again by either the suspension or the drain\n    // filter, so their cached bytes are dead weight; surface their cids\n    // so the host can evict them (see the byte-cache eviction below).\n    var settled = [];\n    globalThis.__pending.forEach(function(p){\n      if (p.hasCreatedEvent && !globalThis.__resolvers[p.correlationId] && !p.abortRequested) {\n        settled.push(p.correlationId);\n      }\n    });\n    return { settled: settled, ops: ops.map(function(p){\n      var q = {};\n      for (var k in p) {\n        if (k === 'input' || k === 'metadata' || k === 'abortPayload') continue;\n        q[k] = p[k];\n      }\n      var raw = {};\n      ['input', 'metadata', 'abortPayload'].forEach(function(f){\n        if (p[f] !== undefined) {\n          raw[f] = globalThis.__rawFields.length;\n          globalThis.__rawFields.push(p[f]);\n        }\n      });\n      q.__rawIndices = raw;\n      return q;\n    }) };\n  })()`);\n  const dumped = vm.dump(projected) as {\n    settled: string[];\n    ops: (PendingOperation & {\n      __rawIndices?: Record<string, number>;\n    })[];\n  };\n  const plainOps = dumped.ops;\n  // Byte-cache eviction: entries for settled ops can never be read again\n  // (neither collection filter matches a settled op), so dropping them\n  // bounds the cache by the LIVE pending set instead of growing\n  // monotonically for the VM's lifetime — which matters for the inline\n  // loop's long-lived sessions and snapshot-restored VMs.\n  if (byteCache && dumped.settled.length > 0) {\n    for (const cid of dumped.settled) {\n      for (const field of RAW_PENDING_FIELDS) {\n        byteCache.delete(`${cid}:${field}`);\n      }\n    }\n  }\n  using rawFields = vm.evalCode('globalThis.__rawFields');\n  for (const op of plainOps) {\n    const rawIndices = op.__rawIndices ?? {};\n    delete op.__rawIndices;\n    for (const field of RAW_PENDING_FIELDS) {\n      const index = rawIndices[field];\n      if (index === undefined) continue;\n      const cacheKey = `${op.correlationId}:${field}`;\n      let bytes = byteCache?.get(cacheKey);\n      if (!bytes) {\n        using valueHandle = rawFields.getProp(String(index));\n        bytes = serde.serialize(valueHandle);\n        byteCache?.set(cacheKey, bytes);\n      }\n      (op as unknown as Record<string, unknown>)[field] = bytes;\n    }\n  }\n  vm.evalCode('delete globalThis.__rawFields').dispose();\n  return plainOps;\n}\n\nfunction collectDrainOperations(\n  vm: QuickJS,\n  serde: QuickJSSerde\n): PendingOperation[] {\n  // Share the per-VM byte cache with the suspension path: an op that was\n  // serialized during a suspension pass must reuse those exact bytes at\n  // terminal drain — re-serializing can invoke getters again and produce\n  // a DIFFERENT byte sequence for what the event log treats as one value.\n  return dumpPendingOps(\n    vm,\n    serde,\n    `(function(){\n    var toDispose = [];\n    globalThis.__pending.forEach(function(p){\n      if (p.type === \"hook\" && p.isSystem && !p.abortRequested && !p.disposed) {\n        p.disposed = true;\n        // Only dispose hooks that were durably created; a hook that never\n        // reached storage has nothing to clean up.\n        if (p.hasCreatedEvent) {\n          toDispose.push({\n            type: \"hook_dispose\",\n            correlationId: p.correlationId,\n            hasCreatedEvent: false,\n          });\n        }\n      }\n    });\n    toDispose.forEach(function(d){ globalThis.__pending.push(d); });\n    return globalThis.__pending.filter(function(p){\n      if (p.abortRequested) return true;\n      if (p.hasCreatedEvent) return false;\n      // Skip system hooks that were disposed before ever being created.\n      if (p.type === \"hook\" && p.disposed) return false;\n      return true;\n    });\n  })()`,\n    ensurePendingByteCache(vm)\n  );\n}\n\nfunction checkWorkflowState(\n  vm: QuickJS,\n  serde: QuickJSSerde,\n  opts: { keepAliveOnSuspend?: boolean } = {}\n): QuickJSRuntimeResult {\n  // Check completed — __workflowResult holds the RAW return value (with a\n  // separate done flag so `undefined` results are distinguishable); the\n  // host serializes it through a handle.\n  {\n    using done = vm.evalCode('globalThis.__workflowDone === true');\n    if (done.toBoolean()) {\n      using h = vm.evalCode('globalThis.__workflowResult');\n      const resultBytes = serde.serialize(h);\n      const drainOperations = collectDrainOperations(vm, serde);\n      vm.dispose();\n      return {\n        completed: {\n          result: resultBytes,\n          ...(drainOperations.length > 0 ? { drainOperations } : {}),\n        },\n      };\n    }\n  }\n\n  // Check failed\n  {\n    using h = vm.evalCode('globalThis.__workflowError');\n    if (!h.isUndefined) {\n      // The display fields are plain strings; the thrown value itself is\n      // RAW and serialized host-side through a handle.\n      const errorObj = h.isString\n        ? (h.toString() as string)\n        : (() => {\n            using plain = vm.evalCode(\n              '(function(e){return {message: e.message, stack: e.stack, name: e.name};})(globalThis.__workflowError)'\n            );\n            return vm.dump(plain) as {\n              message: string;\n              stack?: string;\n              name?: string;\n            };\n          })();\n      let valueBytes: Uint8Array | undefined;\n      if (!h.isString) {\n        using rawValue = h.getProp('value');\n        try {\n          valueBytes = serde.serialize(rawValue);\n        } catch (serializeErr) {\n          // A thrown value the codec cannot serialize must not mask the\n          // workflow failure itself — fall back to the display fields.\n          runtimeLogger.warn(\n            'QuickJS runtime: failed to serialize thrown workflow error',\n            {\n              message:\n                serializeErr instanceof Error\n                  ? serializeErr.message\n                  : String(serializeErr),\n            }\n          );\n        }\n      }\n      const failed =\n        typeof errorObj === 'string'\n          ? { message: errorObj }\n          : {\n              message: errorObj.message,\n              stack: errorObj.stack || undefined,\n              name: errorObj.name || undefined,\n              valueBytes,\n            };\n      runtimeLogger.error('QuickJS runtime: workflow failed in VM', {\n        errorMessage: failed.message,\n        errorName: failed.name,\n        errorStack: failed.stack,\n      });\n      const drainOperations = collectDrainOperations(vm, serde);\n      vm.dispose();\n      return {\n        failed: {\n          ...failed,\n          ...(drainOperations.length > 0 ? { drainOperations } : {}),\n        },\n      };\n    }\n  }\n\n  // Check suspended — the workflow is suspended if there are active resolvers\n  // OR pending operations that haven't been created yet (e.g. hooks created\n  // upfront but not yet awaited)\n  {\n    using h = vm.evalCode(\n      'Object.keys(globalThis.__resolvers).length > 0 || globalThis.__pending.some(function(p){return!p.hasCreatedEvent;})'\n    );\n    if (vm.dump(h)) {\n      // Ops with an active resolver or without a created event are\n      // pending; abort-requested hooks are also surfaced (even when\n      // already created and unawaited) so the host records the abort.\n      const pendingOps = dumpPendingOps(\n        vm,\n        serde,\n        `globalThis.__pending.filter(function(p){return!!globalThis.__resolvers[p.correlationId] || !p.hasCreatedEvent || p.abortRequested;})`,\n        ensurePendingByteCache(vm)\n      );\n      if (!opts.keepAliveOnSuspend) vm.dispose();\n\n      return {\n        suspended: {\n          pendingOperations: pendingOps,\n        },\n      };\n    }\n  }\n\n  vm.dispose();\n  return { failed: { message: 'Workflow ended in unknown state' } };\n}\n\n// ---- Helpers ----\n\nfunction extractError(\n  vm: QuickJS,\n  err: unknown,\n  fallbackMessage: string\n): QuickJSRuntimeResult {\n  let message = fallbackMessage;\n  let stack: string | undefined;\n  let name: string | undefined;\n\n  if (err instanceof JSException) {\n    const error = vm.dump(err.handle) as Record<string, unknown> | null;\n    err.handle.dispose();\n    message = (error?.message as string) ?? err.message ?? fallbackMessage;\n    stack = (error?.stack as string) ?? err.stack;\n    name = (error?.name as string) ?? err.name;\n  } else if (err instanceof Error) {\n    message = err.message ?? fallbackMessage;\n    stack = err.stack;\n    name = err.name;\n  }\n\n  vm.dispose();\n  return {\n    failed: { message, stack, name },\n  };\n}\n\n/**\n * Mutable interrupt budget for a VM. QuickJS polls the interrupt handler\n * during JS execution; when it returns true, execution aborts. The budget\n * bounds a single host->VM execution burst (bundle eval + event\n * processing), not total VM lifetime — the inline-step loop keeps a VM\n * alive across step executions that can legitimately take minutes, so the\n * host resets the budget before each re-entry (see resetBudget calls).\n *\n * The per-burst ceiling is the same configurable budget as the node\n * engine's ReplayBudget (REPLAY_TIMEOUT_MS, default 240s): a workflow\n * whose replay the node engine handles fine must not be interrupted here\n * by a lower hardcoded ceiling. The interrupt error escapes\n * runQuickJSWorkflow and reaches the replay loop's catch in runtime.ts,\n * which records run_failed.\n */\ninterface InterruptBudget {\n  start: number;\n}\n\nfunction createInterruptHandler(budget: InterruptBudget): () => boolean {\n  const timeout = getReplayTimeoutMs();\n  return () => Date.now() - budget.start > timeout;\n}\n"]}