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

package/dist/runtime/quickjs-runtime.js

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