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

package/dist/runtime/quickjs-runtime.js

@@ -0,0 +1,2427 @@
+/**
+ * QuickJS WebAssembly (WASM) workflow VM.
+ *
+ * An alternative engine for the event-replay execution model: the workflow
+ * code runs inside a QuickJS WASM VM (via quickjs-wasi) instead of a
+ * `node:vm` context. Every invocation creates a fresh VM, re-executes the
+ * workflow function from the top, and replays the recorded event log to
+ * resolve awaited primitives: the same replay semantics as the `node:vm`
+ * engine.
+ *
+ * The workflow primitives (useStep, sleep, createHook) are implemented as
+ * JavaScript code running inside the QuickJS VM. The host communicates with
+ * the VM by evaluating small JS snippets to read pending operations and
+ * resolve/reject promises.
+ *
+ * The VM bootstrap is deliberately split into two phases:
+ *   1. Static initialization (`initWorkflowVM`): run-independent setup:
+ *      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.
+ * Keeping the phases separate is groundwork for VM-memory snapshotting:
+ * a follow-up can persist/restore the VM at the phase boundary (e.g. a
+ * build-time initial snapshot) without restructuring this module. Note
+ * that bundle evaluation currently sits in the per-run phase so that
+ * module-scope user code observes the seeded `Math.random`, matching the
+ * `node:vm` engine's replay determinism.
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { SerializationError } from '@workflow/errors';
+import { globalSingleton } from '@workflow/utils';
+import { isSealedNoopEvent, } from '@workflow/world';
+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 { formatSerializationError } from '../serialization/errors.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';
+// ---- Host -> VM payload preparation ----
+/**
+ * Prepare persisted payload bytes for consumption inside the VM: decrypt
+ * (when an encryption key is configured) and decompress (specVersion >= 5
+ * payloads may be gzip/zstd-compressed). The VM only understands plain
+ * format-prefixed 'devl' bytes: it has neither the key material nor zlib.
+ * The key is the run's full DecryptionKey capability (symmetric AES key +
+ * X25519 keypair) so sealed `encp` hook payloads from cross-deployment
+ * resumeHook() calls open here too, not just symmetric `encr` ones.
+ * Both stages are format-prefix dispatched, so plaintext/uncompressed
+ * data passes through unchanged. Mirrors `prepareReplayPayload` in
+ * serialization.ts (the node:vm engine's equivalent host-side stage).
+ */
+async function prepareBytesForVM(data, key) {
+    return (await decompress(await decrypt(data, key)));
+}
+// ---- VM Bootstrap Code ----
+/**
+ * JavaScript code that runs inside the QuickJS VM to set up the workflow
+ * primitives. This sets up:
+ * - globalThis.__private_workflows (Map) - workflow registry
+ * - globalThis.__resolvers (Object) - pending promise resolve/reject functions
+ * - globalThis.__pending (Array) - metadata about pending operations
+ * - globalThis[Symbol.for("WORKFLOW_USE_STEP")] - step proxy factory
+ * - globalThis[Symbol.for("WORKFLOW_SLEEP")] - sleep function
+ */
+const VM_BOOTSTRAP = `
+// Symbol.dispose / Symbol.asyncDispose polyfills for QuickJS
+if (typeof Symbol.dispose === "undefined") {
+  Symbol.dispose = Symbol.for("Symbol.dispose");
+}
+if (typeof Symbol.asyncDispose === "undefined") {
+  Symbol.asyncDispose = Symbol.for("Symbol.asyncDispose");
+}
+
+globalThis.__private_workflows = new Map();
+globalThis.__resolvers = {};
+globalThis.__pending = [];
+globalThis.__workflowResult = undefined;
+globalThis.__workflowError = undefined;
+// Buffer for hook_received payloads that arrive before the hook is awaited.
+// Keyed by correlationId → array of payloads (preserves delivery order).
+// This mirrors the event-replay runtime's payloadsQueue in hook.ts.
+globalThis.__hookPayloadBuffer = {};
+
+// Buffer for step/wait/attr terminal outcomes that arrive before this VM
+// has constructed the corresponding awaiting promise. In fresh-VM replay
+// the multi-pass event scan makes this unreachable (awaits are
+// reconstructed before their terminals are re-scanned), but the live
+// continuation path (continueWithEvents) scans each delta exactly once —
+// a concurrent invocation's terminal arriving before this VM reaches the
+// await would otherwise be dropped on the floor and the await would
+// never settle (the feed's seen-set means it is never re-delivered).
+// Mirrors __hookPayloadBuffer, which exists for exactly this reason on
+// the hook path. Keyed by correlationId → single terminal (steps, waits
+// and attrs settle exactly once).
+globalThis.__terminalBuffer = {};
+
+// Registers a resolver for an awaited primitive, first draining any
+// buffered terminal recorded for the correlationId. Entries are prepared
+// 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_value") {
+      resolve(buffered.value);
+    } else if (buffered.kind === "reject_value") {
+      reject(buffered.value);
+    } else if (buffered.kind === "reject_error") {
+      var e = new Error(buffered.message);
+      e.name = "FatalError";
+      e.fatal = true;
+      if (buffered.stack) e.stack = buffered.stack;
+      reject(e);
+    } else {
+      resolve(undefined);
+    }
+    return;
+  }
+  globalThis.__resolvers[correlationId] = { resolve: resolve, reject: reject };
+};
+
+// Stubs for Web APIs that the workflow bundle may reference but are not
+// available in QuickJS. Native C extensions (encoding, headers, url,
+// structured-clone) provide the real implementations; these are minimal
+// stubs for APIs that don't have native extensions yet. (btoa/atob and
+// the Uint8Array base64/hex methods are built into quickjs-wasi >= 3.)
+
+if (typeof ReadableStream === "undefined") {
+  // Minimal ReadableStream that stores body data for Response.json()/text()
+  globalThis.ReadableStream = function() {};
+  globalThis.ReadableStream.prototype.__bodyData = null;
+}
+
+if (typeof WritableStream === "undefined") {
+  globalThis.WritableStream = function() {};
+}
+
+if (typeof TransformStream === "undefined") {
+  globalThis.TransformStream = function() {};
+}
+
+if (typeof console === "undefined") {
+  globalThis.console = { log: function(){}, error: function(){}, warn: function(){}, info: function(){} };
+}
+// Stub exports/module for CJS bundle format
+globalThis.exports = {};
+globalThis.module = { exports: globalThis.exports };
+// NOTE: TextEncoder/TextDecoder are provided by the native encoding extension.
+
+// ---- Deterministic \`crypto\` (parity with the node:vm engine) ----
+// getRandomValues / randomUUID draw from Math.random, which the host
+// replaces with the run's seeded PRNG before any user code runs — so the
+// values replay deterministically and match the node engine, whose
+// implementations draw from the same seeded sequence (see vm/index.ts).
+// Every crypto.subtle method throws with the same guidance as the node
+// engine's non-replayable methods; unlike node, \`digest\` is also
+// unavailable here (no native hash in the VM yet).
+(function() {
+  function getRandomValues(array) {
+    for (var i = 0; i < array.length; i++) {
+      array[i] = Math.floor(Math.random() * 256);
+    }
+    return array;
+  }
+  // Mirrors vm/uuid.ts createRandomUUID: identical draw pattern from the
+  // seeded PRNG, so both engines produce the same UUID at the same point
+  // in a replay.
+  function randomUUID() {
+    var chars = "0123456789abcdef";
+    var uuid = "";
+    for (var i = 0; i < 36; i++) {
+      if (i === 8 || i === 13 || i === 18 || i === 23) {
+        uuid += "-";
+      } else if (i === 14) {
+        uuid += "4";
+      } else if (i === 19) {
+        uuid += chars[Math.floor(Math.random() * 4) + 8];
+      } else {
+        uuid += chars[Math.floor(Math.random() * 16)];
+      }
+    }
+    return uuid;
+  }
+  function subtleThrow(name) {
+    return function() {
+      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.");
+      err.name = "WorkflowRuntimeError";
+      throw err;
+    };
+  }
+  var subtle = {};
+  ["encrypt","decrypt","sign","verify","digest","generateKey","deriveKey","deriveBits","importKey","exportKey","wrapKey","unwrapKey"].forEach(function(m) {
+    subtle[m] = subtleThrow(m);
+  });
+  globalThis.crypto = {
+    getRandomValues: getRandomValues,
+    randomUUID: randomUUID,
+    subtle: subtle,
+  };
+})();
+
+// ---- Loud Intl / locale guards ----
+// QuickJS has no ICU: \`Intl\` is absent and toLocaleString-family methods
+// silently ignore their locale argument. Silent divergence from the node
+// engine would write different values into a durable event log with no
+// error anywhere — so make the gap loud instead: Intl constructors throw,
+// and toLocale* methods throw ONLY when called with an explicit locale
+// (the no-argument forms keep QuickJS's default behavior).
+(function() {
+  function intlThrow(name) {
+    return function() {
+      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.");
+      err.name = "WorkflowRuntimeError";
+      throw err;
+    };
+  }
+  if (typeof Intl === "undefined") {
+    var intl = {};
+    ["Collator","DateTimeFormat","DisplayNames","DurationFormat","ListFormat","Locale","NumberFormat","PluralRules","RelativeTimeFormat","Segmenter"].forEach(function(n) {
+      intl[n] = intlThrow(n);
+    });
+    intl.getCanonicalLocales = intlThrow("getCanonicalLocales");
+    globalThis.Intl = intl;
+  }
+  function guardLocale(proto, method) {
+    var original = proto[method];
+    if (typeof original !== "function") return;
+    proto[method] = function(locales) {
+      if (locales !== undefined) {
+        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.");
+        err.name = "WorkflowRuntimeError";
+        throw err;
+      }
+      return original.call(this);
+    };
+  }
+  guardLocale(Number.prototype, "toLocaleString");
+  guardLocale(Date.prototype, "toLocaleString");
+  guardLocale(Date.prototype, "toLocaleDateString");
+  guardLocale(Date.prototype, "toLocaleTimeString");
+  guardLocale(String.prototype, "toLocaleLowerCase");
+  guardLocale(String.prototype, "toLocaleUpperCase");
+  // localeCompare's locales argument is the SECOND parameter.
+  (function() {
+    var original = String.prototype.localeCompare;
+    String.prototype.localeCompare = function(that, locales) {
+      if (locales !== undefined) {
+        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.");
+        err.name = "WorkflowRuntimeError";
+        throw err;
+      }
+      return original.call(this, that);
+    };
+  })();
+})();
+
+globalThis[Symbol.for("WORKFLOW_USE_STEP")] = function(stepId, closureVarsFn) {
+  var fn = function() {
+    var args = Array.prototype.slice.call(arguments);
+    var correlationId = "step_" + globalThis.__generateUlid();
+    // Capture 'this' for method invocations (e.g., MyClass.method())
+    var thisVal = (this !== undefined && this !== null && this !== globalThis) ? this : undefined;
+    // 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,
+      stepId: stepId,
+      input: input,
+      hasCreatedEvent: false,
+    });
+    return new Promise(function(resolve, reject) {
+      globalThis.__registerResolver(correlationId, resolve, reject);
+    });
+  };
+  // Set stepId on the proxy so the StepFunction reducer can detect and
+  // serialize step function references (e.g. when passed as arguments).
+  fn.stepId = stepId;
+  if (closureVarsFn) fn.__closureVarsFn = closureVarsFn;
+  // Override .bind so a bound step proxy (e.g. the SWC plugin's
+  // useStep(...).bind(this) for lexical-this arrow steps) keeps its
+  // stepId and records the bound receiver / prefilled args — the native
+  // bind drops own properties, which would make the StepFunction
+  // reducer fail to recognize the proxy when it crosses a serialization
+  // boundary. Mirrors the node:vm engine's override in step.ts.
+  fn.bind = function(thisArg) {
+    var partialArgs = Array.prototype.slice.call(arguments, 1);
+    var bound = Function.prototype.bind.apply(this, [thisArg].concat(partialArgs));
+    bound.stepId = stepId;
+    if (closureVarsFn) bound.__closureVarsFn = closureVarsFn;
+    bound.__boundThis = thisArg;
+    if (partialArgs.length > 0) bound.__boundArgs = partialArgs;
+    return bound;
+  };
+  return fn;
+};
+
+// Parses an "ms" library style duration string into milliseconds.
+// Supports the same units as the replay runtime (which uses the "ms"
+// package): ms / s / m / h / d / w / y, with verbose aliases
+// (seconds, minutes, ...).
+globalThis.__parseDurationMs = function(str) {
+  str = String(str);
+  if (str.length > 100) return undefined;
+  var match = str.match(
+    /^(-?(?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i
+  );
+  if (!match) return undefined;
+  var n = parseFloat(match[1]);
+  var type = (match[2] || "ms").toLowerCase();
+  var s = 1000, m = 60 * s, h = 60 * m, d = 24 * h, w = 7 * d, y = 365.25 * d;
+  switch (type) {
+    case "years": case "year": case "yrs": case "yr": case "y": return n * y;
+    case "weeks": case "week": case "w": return n * w;
+    case "days": case "day": case "d": return n * d;
+    case "hours": case "hour": case "hrs": case "hr": case "h": return n * h;
+    case "minutes": case "minute": case "mins": case "min": case "m": return n * m;
+    case "seconds": case "second": case "secs": case "sec": case "s": return n * s;
+    case "milliseconds": case "millisecond": case "msecs": case "msec": case "ms": return n;
+    default: return undefined;
+  }
+};
+
+globalThis[Symbol.for("WORKFLOW_SLEEP")] = function(param) {
+  var correlationId = "wait_" + globalThis.__generateUlid();
+  var resumeAt;
+  if (typeof param === "number") {
+    resumeAt = new Date(Date.now() + param).toISOString();
+  } else if (typeof param === "string") {
+    var ms = globalThis.__parseDurationMs(param);
+    if (typeof ms === "number" && isFinite(ms)) {
+      resumeAt = new Date(Date.now() + ms).toISOString();
+    } else {
+      // Not a duration string — try as an absolute date string.
+      var date = new Date(param);
+      if (isNaN(date.getTime())) {
+        throw new Error("Invalid sleep parameter: " + param);
+      }
+      resumeAt = date.toISOString();
+    }
+  } else if (param instanceof Date) {
+    if (isNaN(param.getTime())) {
+      throw new Error("Invalid sleep parameter: " + param);
+    }
+    resumeAt = param.toISOString();
+  } else {
+    throw new Error("Invalid sleep parameter: " + param);
+  }
+  globalThis.__pending.push({
+    type: "wait",
+    correlationId: correlationId,
+    resumeAt: resumeAt,
+    hasCreatedEvent: false,
+  });
+  return new Promise(function(resolve, reject) {
+    globalThis.__registerResolver(correlationId, resolve, reject);
+  });
+};
+
+// Response/Request polyfills — .json()/.text()/.arrayBuffer() are useStep
+// proxies that execute on the host side. The proxies are assigned directly
+// to the prototypes so that 'this' (the Response/Request instance) is
+// serialized as thisVal by WORKFLOW_USE_STEP, matching the event-replay
+// runtime's approach (commit dcb0761).
+if (typeof Response === "undefined") {
+  var __BODY_INIT = Symbol.for("BODY_INIT");
+
+  globalThis.Response = function(body, init) {
+    init = init || {};
+    this.status = init.status || 200;
+    this.statusText = init.statusText || "";
+    this.headers = new globalThis.Headers(init.headers || []);
+    this.type = "default";
+    this.url = "";
+    this.redirected = false;
+    if (body !== null && body !== undefined) {
+      this.body = Object.create(globalThis.ReadableStream.prototype);
+      this.body[__BODY_INIT] = body;
+    } else {
+      this.body = null;
+    }
+  };
+  Object.defineProperty(globalThis.Response.prototype, "ok", {
+    get: function() { return this.status >= 200 && this.status < 300; }
+  });
+  Object.defineProperty(globalThis.Response.prototype, "bodyUsed", {
+    get: function() { return false; }
+  });
+  // Assign useStep proxies directly — 'this' binding provides the
+  // Response instance, which gets serialized as thisVal by the proxy.
+  Object.defineProperties(globalThis.Response.prototype, {
+    arrayBuffer: { value: globalThis[Symbol.for("WORKFLOW_USE_STEP")]("__builtin_response_array_buffer"), writable: true, configurable: true },
+    json: { value: globalThis[Symbol.for("WORKFLOW_USE_STEP")]("__builtin_response_json"), writable: true, configurable: true },
+    text: { value: globalThis[Symbol.for("WORKFLOW_USE_STEP")]("__builtin_response_text"), writable: true, configurable: true },
+  });
+  globalThis.Response.prototype.bytes = function() {
+    return this.arrayBuffer().then(function(buf) { return new Uint8Array(buf); });
+  };
+  globalThis.Response.prototype.clone = function() {
+    var r = Object.create(globalThis.Response.prototype);
+    r.status = this.status; r.statusText = this.statusText;
+    r.headers = this.headers; r.type = this.type;
+    r.url = this.url; r.redirected = this.redirected; r.body = this.body;
+    return r;
+  };
+  globalThis.Response.json = function(data, init) {
+    var body = JSON.stringify(data);
+    var headers = new globalThis.Headers(init ? init.headers : []);
+    if (!headers.has("content-type")) { headers.set("content-type", "application/json"); }
+    return new globalThis.Response(body, { status: (init && init.status) || 200, statusText: (init && init.statusText) || "", headers: headers });
+  };
+}
+if (typeof Request === "undefined") {
+  globalThis.Request = function(input, init) {
+    init = init || {};
+    if (typeof input === "string") { this.url = input; }
+    else if (input && typeof input === "object") {
+      this.url = input.url || ""; this.method = input.method;
+      this.headers = input.headers; this.body = input.body;
+    }
+    if (init.method) this.method = init.method.toUpperCase();
+    if (!this.method) this.method = "GET";
+    if (init.headers) this.headers = new globalThis.Headers(init.headers);
+    if (!this.headers) this.headers = new globalThis.Headers();
+    if (init.body !== undefined) this.body = init.body;
+    if (!this.body) this.body = null;
+    this.duplex = init.duplex || "half";
+  };
+  Object.defineProperty(globalThis.Request.prototype, "bodyUsed", {
+    get: function() { return false; }
+  });
+  Object.defineProperties(globalThis.Request.prototype, {
+    arrayBuffer: { value: globalThis[Symbol.for("WORKFLOW_USE_STEP")]("__builtin_response_array_buffer"), writable: true, configurable: true },
+    json: { value: globalThis[Symbol.for("WORKFLOW_USE_STEP")]("__builtin_response_json"), writable: true, configurable: true },
+    text: { value: globalThis[Symbol.for("WORKFLOW_USE_STEP")]("__builtin_response_text"), writable: true, configurable: true },
+  });
+}
+
+// createHook — returns a Hook object that is both a Thenable and AsyncIterable.
+// Each await/yield creates a new promise keyed by the same correlationId.
+// The promise is resolved when a hook_received event arrives.
+globalThis[Symbol.for("WORKFLOW_CREATE_HOOK")] = function(options) {
+  options = options || {};
+  if (options.isWebhook === true && options.experimental_minRetention !== undefined) {
+    throw new Error('Webhook hooks do not support \`experimental_minRetention\`. Use a non-webhook \`createHook()\` with \`resumeHook()\`.');
+  }
+  if (options.experimental_minRetention !== undefined && globalThis.__worldCapabilities?.hookRetention?.active !== true) {
+    var unsupportedRetentionError = new Error('The configured World does not support \`experimental_minRetention\` for Hooks.');
+    unsupportedRetentionError.name = "FatalError";
+    unsupportedRetentionError.fatal = true;
+    throw unsupportedRetentionError;
+  }
+  var token = options.token || globalThis.__generateNanoid();
+  var correlationId = "hook_" + globalThis.__generateUlid();
+  var isDisposed = false;
+  var hasCreatedEvent = false;
+  var tokenRetentionUntil;
+  if (options.experimental_minRetention !== undefined) {
+    var minRetention = options.experimental_minRetention;
+    if (typeof minRetention === "number") {
+      if (minRetention < 0 || !isFinite(minRetention)) {
+        throw new Error("Invalid duration: " + minRetention + ". Expected a non-negative finite number of milliseconds.");
+      }
+      tokenRetentionUntil = Date.now() + minRetention;
+    } else if (typeof minRetention === "string") {
+      var retentionMs = globalThis.__parseDurationMs(minRetention);
+      if (typeof retentionMs !== "number" || retentionMs < 0 || !isFinite(retentionMs)) {
+        throw new Error('Invalid duration: "' + minRetention + '". Expected a valid duration string like "1s", "1m", "1h", etc.');
+      }
+      tokenRetentionUntil = Date.now() + retentionMs;
+    } else if (minRetention instanceof Date || (minRetention && typeof minRetention.getTime === "function")) {
+      // Accept Date-like objects (anything with getTime), matching
+      // parseDurationToDate: values that crossed the serde boundary may
+      // not be realm-native Date instances.
+      tokenRetentionUntil = minRetention.getTime();
+    } else {
+      throw new Error("Invalid duration parameter. Expected a duration string, number (milliseconds), or Date object.");
+    }
+  }
+
+  // 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,
+    hasCreatedEvent: false,
+  };
+  globalThis.__pending.push(pendingOp);
+
+  // Per-hook lifecycle state backing hook.getConflict(): resolves null
+  // once creation is confirmed (hook_created), or resolves with the
+  // conflicting Run handle / rejects with HookConflictError on
+  // hook_conflict. State transitions are driven by the host during event
+  // processing (see processEvents).
+  globalThis.__hooks = globalThis.__hooks || {};
+  globalThis.__hooks[correlationId] = {
+    token: token,
+    created: false,
+    conflict: null,
+    getConflictResolvers: [],
+  };
+
+  // Each await creates a new promise for the next payload.
+  // The correlationId stays the same — the resolver is replaced each time.
+  function createHookPromise() {
+    // Check the payload buffer first — if a hook_received event arrived
+    // before this hook was awaited, the payload was buffered in the VM
+    // heap. Drain it immediately (matching event-replay payloadsQueue).
+    var buf = globalThis.__hookPayloadBuffer[correlationId];
+    if (buf && buf.length > 0) {
+      return Promise.resolve(buf.shift());
+    }
+    return new Promise(function(resolve, reject) {
+      globalThis.__resolvers[correlationId] = { resolve: resolve, reject: reject };
+    });
+  }
+
+  function disposeHook() {
+    if (isDisposed) return;
+    isDisposed = true;
+    // A conflicted hook was never created (the world rejected its claim
+    // — the token belongs to another run), so there is no entity to
+    // dispose. Mirrors the node:vm engine, where hook_conflict removes
+    // the invocation-queue item before dispose can mark it. Emitting a
+    // hook_disposed here would be rejected by the world's
+    // hook-existence validation.
+    var state = globalThis.__hooks[correlationId];
+    if (!state || !state.conflict) {
+      // Signal to the entrypoint to create a hook_disposed event. The
+      // token is carried so the entrypoint can order same-token hook
+      // operations sequentially (a dispose must release the token before
+      // a later same-token hook's creation is validated).
+      globalThis.__pending.push({
+        type: "hook_dispose",
+        correlationId: correlationId,
+        token: token,
+        hasCreatedEvent: false,
+      });
+    }
+    // If there's a pending resolver, resolve it with undefined to break the iterator
+    if (globalThis.__resolvers[correlationId]) {
+      globalThis.__resolvers[correlationId].resolve(undefined);
+      delete globalThis.__resolvers[correlationId];
+    }
+  }
+
+  function getConflict() {
+    var state = globalThis.__hooks[correlationId];
+    if (state.conflict) {
+      return state.conflict.run
+        ? Promise.resolve(state.conflict.run)
+        : Promise.reject(state.conflict.error);
+    }
+    if (state.created) {
+      return Promise.resolve(null);
+    }
+    // Creation not yet confirmed by the event log — park the awaiter and
+    // flag the pending op so the entrypoint re-invokes the workflow right
+    // after writing hook_created (nothing external resumes a getConflict
+    // awaiter; confirmation only comes from replaying the new event).
+    pendingOp.hasGetConflictAwaiter = true;
+    return new Promise(function(resolve, reject) {
+      state.getConflictResolvers.push({ resolve: resolve, reject: reject });
+    });
+  }
+
+  var hook = {
+    token: token,
+    then: function(onFulfilled, onRejected) {
+      return createHookPromise().then(onFulfilled, onRejected);
+    },
+    getConflict: getConflict,
+    dispose: disposeHook,
+  };
+
+  // Symbol.dispose for explicit resource management
+  hook[Symbol.dispose] = disposeHook;
+
+  // AsyncIterable — yields payloads until disposed
+  hook[Symbol.asyncIterator] = function() {
+    return {
+      next: function() {
+        if (isDisposed) {
+          return Promise.resolve({ done: true, value: undefined });
+        }
+        return createHookPromise().then(function(value) {
+          // If disposed while waiting, signal done
+          if (isDisposed) return { done: true, value: undefined };
+          return { done: false, value: value };
+        });
+      },
+      return: function() {
+        disposeHook();
+        return Promise.resolve({ done: true, value: undefined });
+      },
+    };
+  };
+
+  return hook;
+};
+
+// setAttributes — attaches plaintext metadata to the current run.
+// Validation happens in library code (normalizeAttributeChanges) before
+// this dispatcher is invoked, so "changes" is already normalized. The
+// returned promise resolves when the matching attr_set event is
+// observed during event processing — mirroring the node:vm engine's
+// createSetAttributes (attribute-dispatcher.ts).
+globalThis[Symbol.for("WORKFLOW_SET_ATTRIBUTES")] = function(changes, options) {
+  var correlationId = "attr_" + globalThis.__generateUlid();
+  globalThis.__pending.push({
+    type: "attribute",
+    correlationId: correlationId,
+    changes: changes,
+    allowReservedAttributes: !!(options && options.allowReservedAttributes),
+    hasCreatedEvent: false,
+  });
+  return new Promise(function(resolve, reject) {
+    globalThis.__registerResolver(correlationId, resolve, reject);
+  });
+};
+
+// ---- AbortController / AbortSignal (hook-backed) ----
+// Port of workflow/abort-controller.ts to the VM pending-op model:
+// the controller registers a system hook; abort() flips the signal
+// synchronously and marks the pending op so the host records the abort
+// (hook_received event + stream packet). On replay, the recorded
+// hook_received event calls _setAborted during event processing and the
+// workflow's own abort() call becomes a no-op.
+var __ABORT_STREAM_NAME = Symbol.for("WORKFLOW_ABORT_STREAM_NAME");
+var __ABORT_HOOK_TOKEN = Symbol.for("WORKFLOW_ABORT_HOOK_TOKEN");
+
+function __makeAbortError() {
+  if (typeof DOMException !== "undefined") {
+    return new DOMException("The operation was aborted.", "AbortError");
+  }
+  var e = new Error("The operation was aborted.");
+  e.name = "AbortError";
+  return e;
+}
+
+function WorkflowAbortSignal(streamName, hookToken) {
+  this.aborted = false;
+  this.reason = undefined;
+  this[__ABORT_STREAM_NAME] = streamName;
+  this[__ABORT_HOOK_TOKEN] = hookToken;
+  this.__listeners = [];
+  this.__onabort = null;
+}
+Object.defineProperty(WorkflowAbortSignal.prototype, "onabort", {
+  get: function() { return this.__onabort; },
+  set: function(handler) {
+    this.__onabort = handler;
+    if (handler && this.aborted) handler.call(this);
+  },
+});
+WorkflowAbortSignal.prototype._setAborted = function(reason) {
+  if (this.aborted) return;
+  this.aborted = true;
+  this.reason = reason;
+  if (this.__onabort) this.__onabort.call(this);
+  var listeners = this.__listeners;
+  this.__listeners = [];
+  for (var i = 0; i < listeners.length; i++) listeners[i]();
+};
+WorkflowAbortSignal.prototype.addEventListener = function(type, listener) {
+  if (type !== "abort") return;
+  if (this.aborted) {
+    // Fire synchronously (not on a microtask) for deterministic replay —
+    // matches the node:vm engine's WorkflowAbortSignal.
+    listener();
+    return;
+  }
+  this.__listeners.push(listener);
+};
+WorkflowAbortSignal.prototype.removeEventListener = function(type, listener) {
+  if (type !== "abort") return;
+  this.__listeners = this.__listeners.filter(function(l) { return l !== listener; });
+};
+WorkflowAbortSignal.prototype.throwIfAborted = function() {
+  if (this.aborted) {
+    throw this.reason !== undefined && this.reason !== null
+      ? this.reason
+      : __makeAbortError();
+  }
+};
+// 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
+// host delivers hook_received events for these ids as _setAborted calls.
+globalThis.__abortSignals = {};
+
+globalThis.AbortController = function WorkflowAbortController() {
+  var id = globalThis.__generateUlid();
+  var streamName = "strm_" + id + "_system_abort";
+  var hookToken = "abrt_" + id;
+  this[__ABORT_STREAM_NAME] = streamName;
+  this[__ABORT_HOOK_TOKEN] = hookToken;
+  this.signal = new WorkflowAbortSignal(streamName, hookToken);
+  var correlationId = "hook_" + globalThis.__generateUlid();
+  // Register an internal system hook. isSystem prevents token namespace
+  // conflicts with user hooks.
+  globalThis.__pending.push({
+    type: "hook",
+    correlationId: correlationId,
+    token: hookToken,
+    isWebhook: false,
+    isSystem: true,
+    hasCreatedEvent: false,
+  });
+  globalThis.__abortSignals[correlationId] = this.signal;
+};
+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
+  // 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 = {
+        aborted: true,
+        reason: reason,
+      };
+      break;
+    }
+  }
+};
+
+globalThis.AbortSignal = {
+  abort: function(reason) {
+    var s = new WorkflowAbortSignal("", "");
+    s._setAborted(reason !== undefined ? reason : __makeAbortError());
+    return s;
+  },
+  any: function(signals) {
+    var composite = new WorkflowAbortSignal("", "");
+    var arr = Array.from(signals);
+    for (var i = 0; i < arr.length; i++) {
+      if (arr[i].aborted) {
+        composite._setAborted(arr[i].reason);
+        return composite;
+      }
+    }
+    var listeners = [];
+    var cleanup = function() {
+      for (var j = 0; j < listeners.length; j++) {
+        if (listeners[j].signal.removeEventListener) {
+          listeners[j].signal.removeEventListener("abort", listeners[j].listener);
+        }
+      }
+      listeners.length = 0;
+    };
+    arr.forEach(function(signal) {
+      if (!signal.addEventListener) return;
+      var listener = function() {
+        if (!composite.aborted) {
+          composite._setAborted(signal.reason);
+          cleanup();
+        }
+      };
+      listeners.push({ signal: signal, listener: listener });
+      signal.addEventListener("abort", listener);
+    });
+    return composite;
+  },
+  timeout: function() {
+    throw new Error(
+      "AbortSignal.timeout() is not supported in workflow functions. " +
+        "Use sleep() with an AbortController instead. " +
+        "See: /docs/errors/abort-signal-timeout-in-workflow"
+    );
+  },
+};
+
+// WORKFLOW_GET_STREAM_ID — generates a stream ID for a workflow run.
+// Replicates getWorkflowRunStreamId() from util.ts inside the QuickJS VM.
+// Uses the built-in btoa() for base64url encoding.
+globalThis[Symbol.for("WORKFLOW_GET_STREAM_ID")] = function(namespace) {
+  var runId = globalThis[Symbol.for("WORKFLOW_CONTEXT")]
+    ? globalThis[Symbol.for("WORKFLOW_CONTEXT")].workflowRunId
+    : "";
+  var streamId = runId.replace("wrun_", "strm_") + "_user";
+  if (!namespace) return streamId;
+  // base64url: btoa then replace + with -, / with _, strip =
+  var b64 = btoa(namespace).replace(/\\+/g, "-").replace(/\\//g, "_").replace(/=+$/, "");
+  return streamId + "_" + b64;
+};
+`;
+// ---- Runtime ----
+/**
+ * Phase 1: static (run-independent) VM initialization.
+ *
+ * Creates a QuickJS VM and loads everything that does not depend on a
+ * 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
+ * reads lives on the host and is advanced as events are consumed,
+ * matching the node:vm engine's deterministic replay clock.
+ *
+ * This phase is the future boundary for VM-memory snapshotting: a
+ * build-time snapshot can capture the VM right after this function and
+ * new runs can restore from it instead of paying VM creation + eval cost
+ * (`QuickJS.restore` accepts the same wasi override).
+ */
+/**
+ * Loosely-typed accessor for the `WebAssembly` global. The package
+ * tsconfig's `lib: ["es2022"]` does not include the DOM lib where the
+ * `WebAssembly` namespace types live; the runtime global is available on
+ * every WASM-capable platform this engine targets.
+ */
+const WebAssemblyGlobal = globalThis.WebAssembly;
+/**
+ * Process-wide cache of the compiled `WebAssembly.Module`s for the main
+ * QuickJS runtime and its native extensions. `WebAssembly.compile` of the
+ * ~600 KB runtime binary is the most expensive part of VM creation and is
+ * pure (no per-VM state: instantiation binds the per-VM memory), so it
+ * only needs to happen once per process. The promise is cached (not the
+ * result) so concurrent first invocations share a single compilation.
+ */
+// On `globalThis` (see `globalSingleton`): the comment above says once per
+// process, and module scope would make it once per bundler layer, recompiling
+// the ~600 KB runtime binary for each.
+const quickjsAssets = globalSingleton('@workflow/core//quickjsCompiledAssets', 1, () => ({
+    promise: undefined,
+}));
+function getCompiledAssets() {
+    if (!quickjsAssets.promise) {
+        quickjsAssets.promise = (async () => {
+            const [wasm, ...extensionModules] = await Promise.all([
+                WebAssemblyGlobal.compile(quickjsWasm),
+                ...quickjsExtensions.map((ext) => WebAssemblyGlobal.compile(ext.wasm)),
+            ]);
+            return {
+                wasm,
+                extensions: quickjsExtensions.map((ext, i) => ({
+                    ...ext,
+                    wasm: extensionModules[i],
+                })),
+            };
+        })();
+        // On failure, clear the cache so a later invocation can retry rather
+        // than being stuck with a rejected promise forever.
+        quickjsAssets.promise.catch(() => {
+            quickjsAssets.promise = undefined;
+        });
+    }
+    return quickjsAssets.promise;
+}
+/**
+ * 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: makeDeterministicClockWasi(getNowMs),
+    });
+    // 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';
+// On `globalThis` (see `globalSingleton`): a snapshot is expensive to build and
+// is keyed by bundle, so per-copy caches would build the same baseline once per
+// bundler layer while each enforcing its own bound.
+const baselines = globalSingleton('@workflow/core//quickjsBaselines', 1, () => ({
+    byKey: new Map(),
+}));
+const BASELINE_CACHE_MAX_ENTRIES = 4;
+/** Test-only: reset the baseline cache between test cases. */
+export function __clearBaselineSnapshotCacheForTests() {
+    baselines.byKey.clear();
+}
+/** Test-only: observe how a bundle was classified. */
+export async function __peekBaselineEntryForTests(workflowCode) {
+    return baselines.byKey.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, which
+ * returns `ineligible`) is evicted so a later invocation can retry.
+ */
+function getBaselineEntry(workflowCode, workflowId) {
+    let entry = baselines.byKey.get(workflowCode);
+    if (!entry) {
+        if (baselines.byKey.size >= BASELINE_CACHE_MAX_ENTRIES) {
+            const oldest = baselines.byKey.keys().next().value;
+            if (oldest !== undefined)
+                baselines.byKey.delete(oldest);
+        }
+        entry = prepareBaselineSnapshot(workflowCode, workflowId);
+        baselines.byKey.set(workflowCode, entry);
+        entry.catch(() => baselines.byKey.delete(workflowCode));
+    }
+    return entry;
+}
+/**
+ * Run a workflow invocation to its first settled state and dispose the
+ * VM. Convenience wrapper over {@link startQuickJSWorkflow} for callers
+ * (and tests) that don't use live-VM continuation.
+ */
+export async function runQuickJSWorkflow(options) {
+    const session = await startQuickJSWorkflow(options);
+    session.dispose();
+    return session.result;
+}
+export async function startQuickJSWorkflow(options) {
+    const { workflowCode, workflowId, workflowRun, events } = options;
+    const startedAt = workflowRun.startedAt ? +workflowRun.startedAt : Date.now();
+    // Deterministic PRNG seed, identical for EVERY invocation of the same
+    // run. Full event replay requires this: each invocation re-executes the
+    // workflow from the top and must regenerate the exact same correlationId
+    // sequence so that pending operations re-created by replay match the
+    // events recorded by earlier invocations. Sequential operations within
+    // one execution still get distinct ids because the PRNG advances as the
+    // workflow draws from it. Identical seeding across CONCURRENT invocations
+    // of the same run is also load-bearing: both produce the same ids, and
+    // the world's per-(runId, correlationId) uniqueness turns the duplicate
+    // `events.create` into an EntityConflictError that the entrypoint
+    // swallows.
+    //
+    // The seed inputs MUST be stable across invocations. Notably
+    // `startedAt` is NOT: under turbo the first invocation runs against a
+    // synthesized run object whose timestamps differ from the durably
+    // stored ones that later invocations load. Matches the node:vm
+    // engine's seed (workflow.ts).
+    const seed = [
+        workflowRun.runId,
+        workflowRun.workflowName,
+        workflowRun.deploymentId,
+    ].join(':');
+    const rng = seedrandom(seed);
+    // Seeded nanoid generator: uses the same nanoid package and seeded PRNG
+    // as the node:vm engine for consistent token generation.
+    const generateNanoid = nanoid.customRandom(nanoid.urlAlphabet, 21, (size) => new Uint8Array(size).map(() => 256 * rng()));
+    // Deterministic replay clock, mirroring the node:vm engine (see
+    // workflow.ts): the initial value is the run's creation time recovered
+    // from the ULID embedded in `runId` (falling back to `createdAt`), and
+    // it advances to each processed event's `createdAt` as the event log is
+    // replayed. Monotonic (Math.max) so the outer processEvents re-scan
+    // loop can't move the clock backwards mid-execution.
+    let vmNowMs = runIdCreatedAt(workflowRun.runId) ?? (+workflowRun.createdAt || startedAt);
+    const advanceClock = (ms) => {
+        if (Number.isFinite(ms))
+            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() };
+    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, as the bundle evaluates
+    // later in the per-run phase). Snapshot path: re-adopt the capture root
+    // the baseline hydrate created BEFORE the bundle evaluated, since 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
+    // of the compute instance, which is reused. Dispose on the way out of
+    // an exceptional exit and rethrow.
+    try {
+        return await runWorkflowInVM();
+    }
+    catch (err) {
+        try {
+            vm.dispose();
+        }
+        catch {
+            // Already disposed by a terminal path, so ignore.
+        }
+        throw err;
+    }
+    // ---- Phase 2: per-run initialization ----
+    async function runWorkflowInVM() {
+        vm.evalCode(`globalThis.__worldCapabilities = ${JSON.stringify(options.worldCapabilities)};`).dispose();
+        // Seeded Math.random
+        {
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                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_2) {
+                env_2.error = e_2;
+                env_2.hasError = true;
+            }
+            finally {
+                __disposeResources(env_2);
+            }
+        }
+        // Seeded nanoid generator
+        {
+            const env_3 = { stack: [], error: void 0, hasError: false };
+            try {
+                const nanoidFn = __addDisposableResource(env_3, vm.newFunction('__generateNanoid', () => vm.newString(generateNanoid())), false);
+                vm.setProp(vm.global, '__generateNanoid', nanoidFn);
+            }
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
+            }
+            finally {
+                __disposeResources(env_3);
+            }
+        }
+        // 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.
+        {
+            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. 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
+        // (eventually-consistent read after start()). Failing to find input
+        // for a first invocation is fatal: running the workflow function
+        // with no args would silently turn typed arguments into `undefined`
+        // and, for recursive workflows, produce exponential fan-out.
+        const runCreatedEvent = events.find((e) => e.eventType === 'run_created');
+        const runCreatedInput = runCreatedEvent && 'eventData' in runCreatedEvent
+            ? runCreatedEvent.eventData?.input
+            : undefined;
+        const runInput = runCreatedInput ?? options.runInput?.input;
+        if (runInput instanceof Uint8Array) {
+            const decryptedInput = await prepareBytesForVM(runInput, options.encryptionKey);
+            runtimeLogger.debug('QuickJS runtime: run input format', {
+                prefix: new TextDecoder().decode(decryptedInput.subarray(0, 4)),
+                byteLength: decryptedInput.byteLength,
+                source: runCreatedInput ? 'run_created' : 'queueMessage.runInput',
+            });
+            // 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();
+        }
+        else if (runInput === undefined && events.length > 0) {
+            // The event log is non-empty (we got run_started or similar) but
+            // no run_created event was found and no queue-provided runInput is
+            // available. This is the race condition observed during the fib
+            // incident: silently dropping arguments would turn `n` into
+            // `undefined` and, for recursive workflows, cause exponential
+            // fan-out. Fail loud: the throw escapes the entrypoint into the
+            // replay loop's catch in runtime.ts (the QuickJS dispatch runs
+            // inside that loop's try), which records run_failed. A visible
+            // terminal failure is
+            // preferred over silently executing with undefined arguments. The
+            // queue-provided runInput fallback above makes this path rare.
+            // Empty `events` is allowed because tests that bootstrap a workflow
+            // with no arguments rely on the old permissive behavior.
+            throw new Error(`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()).`);
+        }
+        // Set workflow context metadata (for getWorkflowMetadata()).
+        // Must match the shape that the node:vm engine produces (see
+        // packages/core/src/workflow.ts: runWorkflow → ctx) so user code
+        // that compares `getWorkflowMetadata()` values between a step
+        // (server-side) and the workflow (VM-side) sees identical objects.
+        {
+            const metadata = {
+                workflowName: workflowRun.workflowName,
+                workflowRunId: workflowRun.runId,
+                workflowStartedAt: workflowRun.startedAt
+                    ? new Date(+workflowRun.startedAt)
+                    : new Date(),
+                url: process.env.VERCEL_URL
+                    ? `https://${process.env.VERCEL_URL}`
+                    : `http://localhost:${options.port ?? 3000}`,
+                features: { encryption: !!options.encryptionKey },
+            };
+            vm.evalCode(`globalThis[Symbol.for("WORKFLOW_CONTEXT")] = ${JSON.stringify(metadata)};` +
+                `globalThis[Symbol.for("WORKFLOW_CONTEXT")].workflowStartedAt = new Date(${JSON.stringify(metadata.workflowStartedAt.toISOString())});`).dispose();
+        }
+        // Start the workflow function. If the workflow isn't registered,
+        // throw an error tagged with `name = "WorkflowNotRegisteredError"`
+        // so the host-side entrypoint can reconstruct a real
+        // WorkflowNotRegisteredError (a WorkflowRuntimeError subclass that
+        // classifies as RUNTIME_ERROR) rather than a generic user error.
+        // See quickjs-entrypoint.ts's run_failed branch.
+        try {
+            vm.evalCode(`
+      var __wfn = globalThis.__private_workflows.get(${JSON.stringify(workflowId)});
+      if (!__wfn) {
+        var __wfnErr = new Error("Workflow \\"" + ${JSON.stringify(workflowId)} + "\\" is not registered in the current deployment.");
+        __wfnErr.name = "WorkflowNotRegisteredError";
+        throw __wfnErr;
+      }
+      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) {
+          // 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 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),
+            value: error,
+          };
+        }
+      );
+    `).dispose();
+        }
+        catch (err) {
+            return makeSettledSession(extractError(vm, err, 'Failed to start workflow'));
+        }
+        // Process events and drain jobs in a loop. Events may resolve promises
+        // that unblock workflow code, which then creates NEW resolvers for
+        // subsequent events. Re-processing events matches these new resolvers
+        // against events that were already delivered.
+        {
+            let maxIterations = 100;
+            let madeProgress;
+            do {
+                madeProgress = await processEvents(vm, serde, events, advanceClock, options.encryptionKey);
+                let batch;
+                do {
+                    batch = vm.executePendingJobs();
+                    if (batch > 0)
+                        madeProgress = true;
+                } while (batch > 0);
+            } while (madeProgress && --maxIterations > 0);
+            if (madeProgress && maxIterations === 0) {
+                // The drain loop hit its bound while still making progress:
+                // proceeding as if it converged would present as a mysterious
+                // suspension or replay divergence. Make the giving-up visible so
+                // a wedge is attributable to this bound rather than a mystery.
+                runtimeLogger.warn('QuickJS runtime: event drain loop hit its iteration bound before reaching a fixed point', {
+                    workflowRunId: workflowRun.runId,
+                    eventCount: events.length,
+                });
+            }
+        }
+        // ---- Check result ----
+        return makeLiveSession(vm, serde, interruptBudget, advanceClock, options.encryptionKey);
+    }
+}
+/** Session wrapper for a result whose VM is already settled/disposed. */
+function makeSettledSession(result) {
+    return {
+        result,
+        continueWithEvents: () => {
+            throw new Error('QuickJS workflow session is settled — continueWithEvents is only valid while suspended');
+        },
+        dispose: () => { },
+    };
+}
+/**
+ * Evaluate the VM's state and wrap it in a live session. While suspended,
+ * the VM stays alive so `continueWithEvents` can resume it in place;
+ * terminal states dispose the VM immediately (inside checkWorkflowState).
+ */
+function makeLiveSession(vm, serde, interruptBudget, advanceClock, encryptionKey) {
+    const result = checkWorkflowState(vm, serde, { keepAliveOnSuspend: true });
+    let alive = !!result.suspended;
+    const session = {
+        result,
+        async continueWithEvents(newEvents) {
+            if (!alive) {
+                throw new Error('QuickJS workflow session is not alive — continueWithEvents is only valid while suspended');
+            }
+            // Fresh execution burst: the interrupt budget bounds VM compute,
+            // not wall time spent waiting on inline steps between bursts.
+            interruptBudget.start = Date.now();
+            let maxIterations = 100;
+            let madeProgress;
+            do {
+                madeProgress = await processEvents(vm, serde, newEvents, advanceClock, encryptionKey);
+                let batch;
+                do {
+                    batch = vm.executePendingJobs();
+                    if (batch > 0)
+                        madeProgress = true;
+                } while (batch > 0);
+            } while (madeProgress && --maxIterations > 0);
+            const next = checkWorkflowState(vm, serde, {
+                keepAliveOnSuspend: true,
+            });
+            if (!next.suspended)
+                alive = false;
+            session.result = next;
+            return next;
+        },
+        dispose() {
+            if (alive) {
+                alive = false;
+                try {
+                    vm.dispose();
+                }
+                catch {
+                    // Already disposed, so ignore.
+                }
+            }
+        },
+    };
+    return session;
+}
+// ---- Event Processing ----
+async function processEvents(vm, serde, events, advanceClock, encryptionKey) {
+    let resolved = false;
+    for (const event of events) {
+        // A sealed-log noop occupies a slot whose writer died; the run never
+        // observed it. Step over it BEFORE the clock line below, not at the
+        // switch: its `createdAt` is the sealer's wall clock and can postdate
+        // every real event around it, so advancing to it would leak the sealer's
+        // schedule into replay. Because the clock is monotonic, every later
+        // Date.now() in the run with it. That would make a log whose hole was
+        // sealed replay differently from the same log whose hole its own writer
+        // filled, and differently from this log on the node:vm engine, which
+        // skips noops in `EventsConsumer` before `onConsumedEvent` feeds the
+        // clock. Same rule, both engines, one predicate.
+        if (isSealedNoopEvent(event))
+            continue;
+        // Advance the VM's deterministic clock to this event's creation time
+        // BEFORE resolving anything, so workflow code unblocked by this event
+        // observes Date.now() at (or after, since the clock is monotonic) the time
+        // the event was recorded. Mirrors the node:vm engine's
+        // `onConsumedEvent → updateTimestamp(+event.createdAt)`.
+        advanceClock(+event.createdAt);
+        const cid = event.correlationId;
+        if (!cid)
+            continue;
+        // JSON.stringify handles quotes, backslashes and control characters;
+        // correlation ids are host-generated ULIDs today, but the eval-string
+        // safety shouldn't depend on that invariant being asserted nowhere.
+        const cidJs = JSON.stringify(cid);
+        const eventData = 'eventData' in event
+            ? event.eventData
+            : undefined;
+        // Log the event and whether the resolver exists
+        switch (event.eventType) {
+            case 'step_completed': {
+                const hasResolver = vm.dump(vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`));
+                const rawOutput = eventData?.result ?? eventData?.output;
+                if (hasResolver) {
+                    if (rawOutput instanceof Uint8Array) {
+                        // Decrypt if encrypted: the VM only understands 'devl' format
+                        runtimeLogger.debug('QuickJS runtime: step result raw', {
+                            correlationId: cid,
+                            rawPrefix: new TextDecoder().decode(rawOutput.subarray(0, 4)),
+                            rawByteLength: rawOutput.byteLength,
+                            isBuffer: Buffer.isBuffer(rawOutput),
+                        });
+                        const decryptedOutput = await prepareBytesForVM(rawOutput, encryptionKey);
+                        runtimeLogger.debug('QuickJS runtime: step result decrypted', {
+                            correlationId: cid,
+                            prefix: new TextDecoder().decode(decryptedOutput.subarray(0, 4)),
+                            byteLength: decryptedOutput.byteLength,
+                        });
+                        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();
+                    }
+                    else {
+                        runtimeLogger.debug('QuickJS runtime: step result non-binary', {
+                            correlationId: cid,
+                            type: typeof rawOutput,
+                            isNull: rawOutput === null,
+                            isUndefined: rawOutput === undefined,
+                            constructor: rawOutput?.constructor?.name,
+                        });
+                        const serialized = rawOutput !== undefined ? JSON.stringify(rawOutput) : 'undefined';
+                        vm.evalCode(`globalThis.__resolvers[${cidJs}].resolve(${serialized});` +
+                            `delete globalThis.__resolvers[${cidJs}];`).dispose();
+                    }
+                    // Drain ALL microtasks after resolve
+                    {
+                        resolved = true;
+                        let b;
+                        do {
+                            b = vm.executePendingJobs();
+                        } while (b > 0);
+                    }
+                }
+                else {
+                    // No resolver yet, so buffer the prepared outcome so the promise
+                    // settles the moment the VM constructs it (see __terminalBuffer
+                    // in the bootstrap). Without this, the live-continuation path
+                    // (which scans each delta exactly once) drops the terminal and
+                    // the await never settles.
+                    if (rawOutput instanceof Uint8Array) {
+                        const decryptedOutput = await prepareBytesForVM(rawOutput, encryptionKey);
+                        // 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 {
+                        const serialized = rawOutput !== undefined ? JSON.stringify(rawOutput) : 'undefined';
+                        vm.evalCode(`globalThis.__terminalBuffer[${cidJs}] = { kind: "resolve_value", value: ${serialized} };`).dispose();
+                    }
+                }
+                markCreated(vm, cidJs);
+                break;
+            }
+            case 'step_failed': {
+                const hasResolver = vm.dump(vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`));
+                if (hasResolver) {
+                    const errorData = eventData?.error;
+                    if (errorData instanceof Uint8Array) {
+                        // Modern path (post-#1851): the step handler dehydrated the
+                        // thrown value through the first-class error pipeline. Decrypt
+                        // (if encrypted) and pass the bytes to the VM-side deserializer
+                        // so the workflow catch sees a properly typed Error subclass
+                        // (TypeError, FatalError with original cause chain, etc.) with
+                        // the original message and stack preserved.
+                        const decrypted = await prepareBytesForVM(errorData, encryptionKey);
+                        const errorHandle = serde.deserialize(decrypted);
+                        vm.setProp(vm.global, '__tmp_error', errorHandle);
+                        errorHandle.dispose();
+                        vm.evalCode(`(function(){` +
+                            `globalThis.__resolvers[${cidJs}].reject(globalThis.__tmp_error);` +
+                            `delete globalThis.__resolvers[${cidJs}];` +
+                            `delete globalThis.__tmp_error;` +
+                            `})()`).dispose();
+                    }
+                    else {
+                        // Legacy path: pre-pipeline events stored error as
+                        // `{ message, stack, code }`. Reconstruct a FatalError so
+                        // workflow catch can detect it via FatalError.is(), matching
+                        // the original V1 step handler behavior.
+                        const isErrorObject = typeof errorData === 'object' && errorData !== null;
+                        const msg = isErrorObject
+                            ? (errorData.message ??
+                                'Step failed')
+                            : typeof errorData === 'string'
+                                ? errorData
+                                : 'Step failed';
+                        const errorStack = (isErrorObject
+                            ? errorData.stack
+                            : undefined) ?? eventData?.stack;
+                        const stackAssignment = errorStack
+                            ? `e.stack=${JSON.stringify(errorStack)};`
+                            : '';
+                        vm.evalCode(`(function(){var e=new Error(${JSON.stringify(msg)});e.name="FatalError";e.fatal=true;${stackAssignment}` +
+                            `globalThis.__resolvers[${cidJs}].reject(e);` +
+                            `delete globalThis.__resolvers[${cidJs}];})()`).dispose();
+                    }
+                    {
+                        resolved = true;
+                        let b;
+                        do {
+                            b = vm.executePendingJobs();
+                        } while (b > 0);
+                    }
+                }
+                else {
+                    // No resolver yet, so buffer the prepared rejection (see the
+                    // step_completed branch above for the rationale).
+                    const errorData = eventData?.error;
+                    if (errorData instanceof Uint8Array) {
+                        const decrypted = await prepareBytesForVM(errorData, encryptionKey);
+                        // 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 {
+                        const isErrorObject = typeof errorData === 'object' && errorData !== null;
+                        const msg = isErrorObject
+                            ? (errorData.message ??
+                                'Step failed')
+                            : typeof errorData === 'string'
+                                ? errorData
+                                : 'Step failed';
+                        const errorStack = (isErrorObject
+                            ? errorData.stack
+                            : undefined) ?? eventData?.stack;
+                        vm.evalCode(`globalThis.__terminalBuffer[${cidJs}] = { kind: "reject_error", message: ${JSON.stringify(msg)}, stack: ${errorStack ? JSON.stringify(errorStack) : 'undefined'} };`).dispose();
+                    }
+                }
+                markCreated(vm, cidJs);
+                break;
+            }
+            case 'wait_completed': {
+                const hasResolver = vm.dump(vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`));
+                if (hasResolver) {
+                    vm.evalCode(`globalThis.__resolvers[${cidJs}].resolve();` +
+                        `delete globalThis.__resolvers[${cidJs}];`).dispose();
+                    {
+                        resolved = true;
+                        let b;
+                        do {
+                            b = vm.executePendingJobs();
+                        } while (b > 0);
+                    }
+                }
+                else {
+                    // No resolver yet, so buffer (see step_completed above).
+                    vm.evalCode(`globalThis.__terminalBuffer[${cidJs}] = { kind: "resolve_undefined" };`).dispose();
+                }
+                markCreated(vm, cidJs);
+                break;
+            }
+            case 'attr_set': {
+                // Only workflow-written attribute events resolve a pending
+                // setAttributes() promise; step/system writers share no
+                // correlationIds with VM resolvers, so the guard is defensive.
+                const writer = eventData?.writer
+                    ?.type;
+                if (writer !== 'workflow')
+                    break;
+                const hasResolver = vm.dump(vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`));
+                if (!hasResolver) {
+                    // No resolver yet, so buffer (see step_completed above).
+                    vm.evalCode(`globalThis.__terminalBuffer[${cidJs}] = { kind: "resolve_undefined" };`).dispose();
+                }
+                if (hasResolver) {
+                    vm.evalCode(`globalThis.__resolvers[${cidJs}].resolve();` +
+                        `delete globalThis.__resolvers[${cidJs}];`).dispose();
+                    {
+                        resolved = true;
+                        let b;
+                        do {
+                            b = vm.executePendingJobs();
+                        } while (b > 0);
+                    }
+                }
+                markCreated(vm, cidJs);
+                break;
+            }
+            case 'hook_received': {
+                // Check if this event was already processed (delivered or
+                // buffered) within this invocation. Prevents double-delivery when
+                // the outer loop re-scans events.
+                const alreadyProcessed = event.eventId
+                    ? vm.dump(vm.evalCode(`!!(globalThis.__hookPayloadBuffer.__processedEventIds && globalThis.__hookPayloadBuffer.__processedEventIds[${JSON.stringify(event.eventId)}])`))
+                    : false;
+                if (alreadyProcessed) {
+                    runtimeLogger.debug('QuickJS runtime: hook_received already processed', {
+                        correlationId: cid,
+                        eventId: event.eventId,
+                    });
+                    markCreated(vm, cidJs);
+                    break;
+                }
+                // Resilient-resume dedup (parity with the node engine's
+                // EventsConsumer in workflow/hook.ts): two hook_received rows for
+                // ONE resume attempt share a client-minted `resumeId` (a duplicate
+                // can be committed when the materialization fallback races a
+                // delayed direct write, since hook_received has no storage uniqueness
+                // constraint). Deliver only the first-in-log occurrence. The seen
+                // set lives in the VM heap so it is deterministic per replay and
+                // survives event re-scans within the invocation. Events without a
+                // resumeId (older SDKs) are never deduped.
+                {
+                    // Top-level event.resumeId is the canonical location (the backend
+                    // hoists it to a first-class column); the nested
+                    // eventData.resumeId form is a deprecated legacy fallback.
+                    // Mirrors the node engine's dedup in workflow/hook.ts.
+                    const resumeId = event.resumeId ??
+                        eventData?.resumeId;
+                    if (typeof resumeId === 'string') {
+                        const resumeIdJs = JSON.stringify(resumeId);
+                        const duplicate = vm.dump(vm.evalCode(`(globalThis.__hookSeenResumeIds = globalThis.__hookSeenResumeIds || {})[${resumeIdJs}] === true`));
+                        if (duplicate) {
+                            runtimeLogger.debug('QuickJS runtime: duplicate hook_received for the same resume attempt, dropping', { correlationId: cid, eventId: event.eventId, resumeId });
+                            if (event.eventId) {
+                                vm.evalCode(`(globalThis.__hookPayloadBuffer.__processedEventIds = globalThis.__hookPayloadBuffer.__processedEventIds || {})[${JSON.stringify(event.eventId)}] = true;`).dispose();
+                            }
+                            markCreated(vm, cidJs);
+                            break;
+                        }
+                        vm.evalCode(`globalThis.__hookSeenResumeIds[${resumeIdJs}] = true;`).dispose();
+                    }
+                }
+                // Abort delivery: hook_received for an AbortController's system
+                // hook flips the registered signal instead of resolving a promise.
+                // The payload is the dehydrated `{ aborted: true, reason }` object.
+                const isAbortHook = vm.dump(vm.evalCode(`!!(globalThis.__abortSignals && globalThis.__abortSignals[${cidJs}])`));
+                if (isAbortHook) {
+                    const rawAbortPayload = eventData?.payload;
+                    if (rawAbortPayload instanceof Uint8Array) {
+                        const decrypted = await prepareBytesForVM(rawAbortPayload, encryptionKey);
+                        const payloadHandle = serde.deserialize(decrypted);
+                        vm.setProp(vm.global, '__tmp_abort', payloadHandle);
+                        payloadHandle.dispose();
+                        vm.evalCode(`(function(){` +
+                            `var p=globalThis.__tmp_abort;` +
+                            `delete globalThis.__tmp_abort;` +
+                            `globalThis.__abortSignals[${cidJs}]._setAborted(p&&typeof p==="object"?p.reason:undefined);` +
+                            `})()`).dispose();
+                    }
+                    else {
+                        vm.evalCode(`globalThis.__abortSignals[${cidJs}]._setAborted(undefined);`).dispose();
+                    }
+                    // The abort is durably recorded, so clear the pending op's
+                    // abortRequested marker so the host doesn't re-record it (the
+                    // workflow's own abort() call can set the flag before this
+                    // event is processed when it happens later in replay order,
+                    // and hook_received events are not unique per correlationId).
+                    vm.evalCode(`(function(){` +
+                        `var p=globalThis.__pending.find(function(q){return q.correlationId===${JSON.stringify(cid)}&&q.type==="hook";});` +
+                        `if(p)p.abortRequested=false;` +
+                        `})()`).dispose();
+                    if (event.eventId) {
+                        vm.evalCode(`(globalThis.__hookPayloadBuffer.__processedEventIds = globalThis.__hookPayloadBuffer.__processedEventIds || {})[${JSON.stringify(event.eventId)}] = true;`).dispose();
+                    }
+                    {
+                        resolved = true;
+                        let b;
+                        do {
+                            b = vm.executePendingJobs();
+                        } while (b > 0);
+                    }
+                    markCreated(vm, cidJs);
+                    break;
+                }
+                const hasResolver = vm.dump(vm.evalCode(`!!globalThis.__resolvers[${cidJs}]`));
+                const rawPayload = eventData?.payload ?? eventData?.result;
+                runtimeLogger.debug('QuickJS runtime: processing hook_received', {
+                    correlationId: cid,
+                    eventId: event.eventId,
+                    hasResolver,
+                    payloadType: typeof rawPayload,
+                    payloadIsUint8Array: rawPayload instanceof Uint8Array,
+                    payloadKeys: rawPayload && typeof rawPayload === 'object'
+                        ? Object.keys(rawPayload)
+                        : undefined,
+                });
+                if (hasResolver) {
+                    if (rawPayload instanceof Uint8Array) {
+                        // Decrypt if encrypted: the VM only understands 'devl' format
+                        const decryptedPayload = await prepareBytesForVM(rawPayload, encryptionKey);
+                        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();
+                    }
+                    else {
+                        const serialized = rawPayload !== undefined
+                            ? JSON.stringify(rawPayload)
+                            : 'undefined';
+                        vm.evalCode(`globalThis.__resolvers[${cidJs}].resolve(${serialized});` +
+                            `delete globalThis.__resolvers[${cidJs}];`).dispose();
+                    }
+                    // Mark this event as processed in the VM heap to prevent
+                    // double-delivery when the outer loop re-scans events.
+                    if (event.eventId) {
+                        vm.evalCode(`(globalThis.__hookPayloadBuffer.__processedEventIds = globalThis.__hookPayloadBuffer.__processedEventIds || {})[${JSON.stringify(event.eventId)}] = true;`).dispose();
+                    }
+                    {
+                        resolved = true;
+                        let b;
+                        do {
+                            b = vm.executePendingJobs();
+                        } while (b > 0);
+                    }
+                }
+                else {
+                    // No resolver yet, so buffer the payload in the VM heap. When
+                    // createHookPromise() is called later, it will drain this buffer
+                    // first (matching the node:vm engine's payloadsQueue behavior).
+                    const eventIdJs = event.eventId
+                        ? JSON.stringify(event.eventId)
+                        : 'null';
+                    const bufferAndTrack = `(globalThis.__hookPayloadBuffer[${cidJs}] = globalThis.__hookPayloadBuffer[${cidJs}] || [])` +
+                        `.push(%PAYLOAD%);` +
+                        (event.eventId
+                            ? `(globalThis.__hookPayloadBuffer.__processedEventIds = globalThis.__hookPayloadBuffer.__processedEventIds || {})[${eventIdJs}] = true;`
+                            : '');
+                    if (rawPayload instanceof Uint8Array) {
+                        // Decrypt if encrypted: the VM only understands 'devl' format
+                        const decryptedPayload = await prepareBytesForVM(rawPayload, encryptionKey);
+                        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.__tmp_result') + 'delete globalThis.__tmp_result;').dispose();
+                    }
+                    else {
+                        const serialized = rawPayload !== undefined
+                            ? JSON.stringify(rawPayload)
+                            : 'undefined';
+                        // Function replacement: a JSON-serialized payload can contain
+                        // `$&`, `$'`, `$\``, ... which String.replace would otherwise
+                        // expand, silently corrupting the injected code.
+                        vm.evalCode(bufferAndTrack.replace('%PAYLOAD%', () => serialized)).dispose();
+                    }
+                }
+                markCreated(vm, cidJs);
+                break;
+            }
+            case 'hook_conflict': {
+                // Another workflow owns this hook token. Payload awaiters reject
+                // with HookConflictError; getConflict() awaiters resolve with a
+                // Run handle for the conflicting run (revived through the VM's
+                // class registry so its methods are durable step proxies) or
+                // reject with the error when no handle can be constructed,
+                // mirroring the node:vm engine's hook.ts hook_conflict handling.
+                const conflictToken = eventData?.token ?? 'unknown';
+                const conflictingRunId = eventData?.conflictingRunId;
+                const didSettle = vm.dump(vm.evalCode(`(function(){
+              var cid = ${JSON.stringify(cid)};
+              var token = ${JSON.stringify(conflictToken)};
+              var conflictingRunId = ${JSON.stringify(conflictingRunId ?? null)};
+              var ErrCls = globalThis[Symbol.for('@workflow/errors//HookConflictError')];
+              var err;
+              if (typeof ErrCls === 'function') {
+                err = new ErrCls(token, conflictingRunId || undefined);
+              } else {
+                err = new Error('Hook token "' + token + '" is already in use by another workflow');
+                err.name = 'HookConflictError';
+                err.token = token;
+                if (conflictingRunId) err.conflictingRunId = conflictingRunId;
+              }
+              var run = null;
+              if (conflictingRunId) {
+                var reg = globalThis[Symbol.for('workflow-class-registry')];
+                var RunCls = reg && reg.get('class//workflow//Run');
+                var des = RunCls && RunCls[Symbol.for('workflow-deserialize')];
+                if (typeof des === 'function') {
+                  run = des.call(RunCls, { runId: conflictingRunId });
+                }
+              }
+              var settled = false;
+              var state = globalThis.__hooks && globalThis.__hooks[cid];
+              if (state && !state.conflict) {
+                state.conflict = { error: err, run: run };
+                var gc = state.getConflictResolvers;
+                state.getConflictResolvers = [];
+                for (var i = 0; i < gc.length; i++) {
+                  if (run) { gc[i].resolve(run); } else { gc[i].reject(err); }
+                  settled = true;
+                }
+              }
+              if (globalThis.__resolvers[cid]) {
+                globalThis.__resolvers[cid].reject(err);
+                delete globalThis.__resolvers[cid];
+                settled = true;
+              }
+              return settled;
+            })()`));
+                if (didSettle) {
+                    resolved = true;
+                    let b;
+                    do {
+                        b = vm.executePendingJobs();
+                    } while (b > 0);
+                }
+                markCreated(vm, cidJs);
+                break;
+            }
+            case 'step_created':
+            case 'step_started':
+            case 'step_retrying':
+            case 'wait_created': {
+                markCreated(vm, cidJs);
+                break;
+            }
+            case 'hook_created': {
+                // Confirm creation for getConflict() awaiters: resolve them with
+                // null (no conflict) once the event log proves the hook exists.
+                const settledGetConflict = vm.dump(vm.evalCode(`(function(){
+              var state = globalThis.__hooks && globalThis.__hooks[${JSON.stringify(cid)}];
+              if (!state) return false;
+              state.created = true;
+              var gc = state.getConflictResolvers;
+              state.getConflictResolvers = [];
+              for (var i = 0; i < gc.length; i++) gc[i].resolve(null);
+              return gc.length > 0;
+            })()`));
+                if (settledGetConflict) {
+                    resolved = true;
+                    let b;
+                    do {
+                        b = vm.executePendingJobs();
+                    } while (b > 0);
+                }
+                markCreated(vm, cidJs);
+                break;
+            }
+            case 'hook_disposed': {
+                // Disambiguate from the `hook` pending op with the same
+                // correlationId: we want to mark the `hook_dispose` entry.
+                markCreated(vm, cidJs, 'hook_dispose');
+                break;
+            }
+        }
+    }
+    return resolved;
+}
+function markCreated(vm, cidJs, opType) {
+    // `cidJs` is the JSON.stringify-quoted correlation id (see processEvents).
+    // `hook` and `hook_dispose` pending ops share the same correlationId,
+    // so when processing `hook_disposed` events we must disambiguate by
+    // type: otherwise `.find()` returns the original `hook` op and the
+    // `hook_dispose` op is never marked, causing the entrypoint to keep
+    // retrying a hook_disposed for an already-deleted entity.
+    const predicate = opType
+        ? `function(p){return p.correlationId===${cidJs}&&p.type===${JSON.stringify(opType)};}`
+        : `function(p){return p.correlationId===${cidJs};}`;
+    vm.evalCode(`var __p=globalThis.__pending.find(${predicate});` +
+        `if(__p)__p.hasCreatedEvent=true;`).dispose();
+}
+// ---- State Checking ----
+/**
+ * Collect leftover pending operations that need durable side effects when
+ * the workflow reaches a terminal state. Mirrors the node:vm engine's
+ * drainPendingQueueItems (workflow.ts): still-alive system hooks
+ * (AbortController) without an abort in flight are implicitly disposed so
+ * they don't leak hook rows; ops without created events (fire-and-forget
+ * attributes/hooks/steps/waits) and pending abort recordings are surfaced
+ * for the entrypoint to flush.
+ */
+/**
+ * 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.
+ */
+// per-copy-ok: keyed on the VM instance, and a VM is created and driven by one
+// copy. Another copy holds no reference to the key, so a shared map could never
+// be read from it.
+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 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);
+                        try {
+                            bytes = serde.serialize(valueHandle);
+                        }
+                        catch (err) {
+                            // A step input that refuses to serialize is a deterministic user
+                            // error: failing the whole collection here would fail the run
+                            // from the outside, where no workflow code can observe it (and
+                            // with a bare DevalueError instead of the framed message the
+                            // node:vm engine produces). Reframe it exactly like
+                            // `dehydrateStepArguments` does and surface it on the op: the
+                            // entrypoint finalizes the step as step_created + step_failed so
+                            // the failure rejects into the workflow, catchable. Other raw
+                            // fields (hook metadata, abort payloads) keep the throwing
+                            // behavior, matching the node:vm engine's scope.
+                            if (op.type === 'step' && field === 'input') {
+                                const { message, hint } = formatSerializationError('step arguments', err);
+                                op.serializationError = new SerializationError(message, { hint, cause: err });
+                                continue;
+                            }
+                            throw err;
+                        }
+                        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, since 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) {
+        p.disposed = true;
+        // Only dispose hooks that were durably created; a hook that never
+        // reached storage has nothing to clean up.
+        if (p.hasCreatedEvent) {
+          toDispose.push({
+            type: "hook_dispose",
+            correlationId: p.correlationId,
+            // Carried, not dropped: the entrypoint sends it on hook_disposed,
+            // and the node:vm engine does the same for this case — its
+            // completion drain marks the system hook disposed and reuses the
+            // queue item, token and all. Synthesizing a fresh object here is
+            // what makes it easy to lose.
+            token: p.token,
+            hasCreatedEvent: false,
+          });
+        }
+      }
+    });
+    toDispose.forEach(function(d){ globalThis.__pending.push(d); });
+    return globalThis.__pending.filter(function(p){
+      if (p.abortRequested) return true;
+      if (p.hasCreatedEvent) return false;
+      // Skip system hooks that were disposed before ever being created.
+      if (p.type === "hook" && p.disposed) return false;
+      return true;
+    });
+  })()`, ensurePendingByteCache(vm));
+}
+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_7 = { stack: [], error: void 0, hasError: false };
+        try {
+            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_8) {
+            env_7.error = e_8;
+            env_7.hasError = true;
+        }
+        finally {
+            __disposeResources(env_7);
+        }
+    }
+    // Check failed
+    {
+        const env_9 = { stack: [], error: void 0, hasError: false };
+        try {
+            const h = __addDisposableResource(env_9, vm.evalCode('globalThis.__workflowError'), false);
+            if (!h.isUndefined) {
+                // 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, so 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,
+                    };
+                runtimeLogger.error('QuickJS runtime: workflow failed in VM', {
+                    errorMessage: failed.message,
+                    errorName: failed.name,
+                    errorStack: failed.stack,
+                });
+                const drainOperations = collectDrainOperations(vm, serde);
+                vm.dispose();
+                return {
+                    failed: {
+                        ...failed,
+                        ...(drainOperations.length > 0 ? { drainOperations } : {}),
+                    },
+                };
+            }
+        }
+        catch (e_10) {
+            env_9.error = e_10;
+            env_9.hasError = true;
+        }
+        finally {
+            __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_11 = { stack: [], error: void 0, hasError: false };
+        try {
+            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)) {
+                // 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_11) {
+            env_11.error = e_11;
+            env_11.hasError = true;
+        }
+        finally {
+            __disposeResources(env_11);
+        }
+    }
+    vm.dispose();
+    return { failed: { message: 'Workflow ended in unknown state' } };
+}
+// ---- Helpers ----
+function extractError(vm, err, fallbackMessage) {
+    let message = fallbackMessage;
+    let stack;
+    let name;
+    if (err instanceof JSException) {
+        const error = vm.dump(err.handle);
+        err.handle.dispose();
+        message = error?.message ?? err.message ?? fallbackMessage;
+        stack = error?.stack ?? err.stack;
+        name = error?.name ?? err.name;
+    }
+    else if (err instanceof Error) {
+        message = err.message ?? fallbackMessage;
+        stack = err.stack;
+        name = err.name;
+    }
+    vm.dispose();
+    return {
+        failed: { message, stack, name },
+    };
+}
+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 WebAssembly (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 { SerializationError } from '@workflow/errors';\nimport { globalSingleton } from '@workflow/utils';\nimport {\n  type Event,\n  isSealedNoopEvent,\n  type RunInput,\n  type WorkflowRun,\n  type 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 { formatSerializationError } from '../serialization/errors.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  /**\n   * Format-prefixed devalue-serialized step input (args + closureVars).\n   * Absent when {@link serializationError} is set: the input is precisely\n   * what refused to serialize.\n   */\n  input?: Uint8Array;\n  /** Whether a step_created event already exists for this step */\n  hasCreatedEvent: boolean;\n  /**\n   * Set when host-side serialization of the step's raw input failed while\n   * dumping the VM's pending ops (see `dumpPendingOps`). The failure is\n   * deterministic (replaying re-derives the same unserializable value), so\n   * instead of failing the whole collection the op is surfaced with the\n   * reframed error and no `input`; the entrypoint finalizes the step as\n   * `step_created` (placeholder input) + `step_failed`, mirroring the\n   * node:vm engine's `finalizeUnserializableStep`, so a try/catch around\n   * the step call observes the SerializationError.\n   */\n  serializationError?: SerializationError;\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, where\n   * VERCEL_URL takes precedence.\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 */\n// On `globalThis` (see `globalSingleton`): the comment above says once per\n// process, and module scope would make it once per bundler layer, recompiling\n// the ~600 KB runtime binary for each.\nconst quickjsAssets = globalSingleton(\n  '@workflow/core//quickjsCompiledAssets',\n  1,\n  () => ({\n    promise: undefined as\n      | Promise<{\n          wasm: object;\n          extensions: CompiledExtension[];\n        }>\n      | undefined,\n  })\n);\n\nfunction getCompiledAssets() {\n  if (!quickjsAssets.promise) {\n    quickjsAssets.promise = (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    quickjsAssets.promise.catch(() => {\n      quickjsAssets.promise = undefined;\n    });\n  }\n  return quickjsAssets.promise;\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\n// On `globalThis` (see `globalSingleton`): a snapshot is expensive to build and\n// is keyed by bundle, so per-copy caches would build the same baseline once per\n// bundler layer while each enforcing its own bound.\nconst baselines = globalSingleton(\n  '@workflow/core//quickjsBaselines',\n  1,\n  () => ({\n    byKey: new Map<string, Promise<BaselineEntry>>(),\n  })\n);\nconst BASELINE_CACHE_MAX_ENTRIES = 4;\n\n/** Test-only: reset the baseline cache between test cases. */\nexport function __clearBaselineSnapshotCacheForTests(): void {\n  baselines.byKey.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 baselines.byKey.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, which\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 = baselines.byKey.get(workflowCode);\n  if (!entry) {\n    if (baselines.byKey.size >= BASELINE_CACHE_MAX_ENTRIES) {\n      const oldest = baselines.byKey.keys().next().value;\n      if (oldest !== undefined) baselines.byKey.delete(oldest);\n    }\n    entry = prepareBaselineSnapshot(workflowCode, workflowId);\n    baselines.byKey.set(workflowCode, entry);\n    entry.catch(() => baselines.byKey.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, as 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, since 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, so 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, so 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    // A sealed-log noop occupies a slot whose writer died; the run never\n    // observed it. Step over it BEFORE the clock line below, not at the\n    // switch: its `createdAt` is the sealer's wall clock and can postdate\n    // every real event around it, so advancing to it would leak the sealer's\n    // schedule into replay. Because the clock is monotonic, every later\n    // Date.now() in the run with it. That would make a log whose hole was\n    // sealed replay differently from the same log whose hole its own writer\n    // filled, and differently from this log on the node:vm engine, which\n    // skips noops in `EventsConsumer` before `onConsumedEvent` feeds the\n    // clock. Same rule, both engines, one predicate.\n    if (isSealedNoopEvent(event)) continue;\n\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, since 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, so 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, so 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, so 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, so 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, since 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, so 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, so 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 */\n// per-copy-ok: keyed on the VM instance, and a VM is created and driven by one\n// copy. Another copy holds no reference to the key, so a shared map could never\n// be read from it.\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        try {\n          bytes = serde.serialize(valueHandle);\n        } catch (err) {\n          // A step input that refuses to serialize is a deterministic user\n          // error: failing the whole collection here would fail the run\n          // from the outside, where no workflow code can observe it (and\n          // with a bare DevalueError instead of the framed message the\n          // node:vm engine produces). Reframe it exactly like\n          // `dehydrateStepArguments` does and surface it on the op: the\n          // entrypoint finalizes the step as step_created + step_failed so\n          // the failure rejects into the workflow, catchable. Other raw\n          // fields (hook metadata, abort payloads) keep the throwing\n          // behavior, matching the node:vm engine's scope.\n          if (op.type === 'step' && field === 'input') {\n            const { message, hint } = formatSerializationError(\n              'step arguments',\n              err\n            );\n            (op as PendingStep).serializationError = new SerializationError(\n              message,\n              { hint, cause: err }\n            );\n            continue;\n          }\n          throw err;\n        }\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, since 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            // Carried, not dropped: the entrypoint sends it on hook_disposed,\n            // and the node:vm engine does the same for this case — its\n            // completion drain marks the system hook disposed and reuses the\n            // queue item, token and all. Synthesizing a fresh object here is\n            // what makes it easy to lose.\n            token: p.token,\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, so 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"]}